Rails and iOS with RestKit

Rails + iOS with RestKit
@andrewculver

Topics
• Rails API Versioning
• RestKit Installation
• Mapping Configuration
• Pulling and Pushing Data
• Offline Mode and Other Syncing
• Authentication

Goals
• Understand some basics.
• Keep it as simple as possible.

Our Example App
“ClipQueue”

“ClipQueue”
• Helps with workflow automation.
• Detects content in the clipboard.
• Prompts to save it as a “Clip”, categorize it.
• Server processes it.
• Dispatches webhooks, sends emails, etc.

Rails JSON API
• Keep your API separate from your core app.
• Doing this efficiently requires thin controllers.
• Creating resources to represent actions that would
otherwise be custom controller actions helps, too.

class Clip < ActiveRecord::Base
attr_accessible :content, :created_at
end
Clip Model

Clipqueue::Application.routes.draw do
namespace :api do
namespace :v1 do
resources :clips
end
end
end
Setting up a Router

class Api::V1::ClipsController < ApplicationController
load_and_authorize_resource :clip
respond_to :json
...
end
API Controller

respond_to :json
...
def index
respond_with @clips
end
...
end
API Controller Actions

respond_to :json
...
def show
respond_with @clip
end
...
end

respond_to :json
...
def create
@clip.save
redirect_to [:api, :v1, @clip]
end
...
end

class Ability
include CanCan::Ability
// Guest users can do anything.
def initialize(user)
user ||= User.new
can :manage, :all
end
end
Single User System

Installation
• Use CocoaPods.
• This tutorial includes great installation steps for
new projects.
• https://github.com/RestKit/RKGist/blob/master/
TUTORIAL.md

Rails JSON API Versioning
• If your API changes, older apps will crash.
• Your ranking in the App Store will crash, too.
• Does anyone have a Gem they use for this?
• Maintaining old versions of your API is easy:
• Make a separate copy for each new version.

$ cp -R v1/ v2/
Setting up a Router

Clipqueue::Application.routes.draw do
namespace :api do
namespace :v1 do
resources :clips
end
namespace :v2 do
resources :clips
resources :categories
end
end
end
Setting up a Router

RESTKit ‘GET’ Lifecycle
• Issues HTTP GET request for URL.
• Receives XML/JSON response.
• Converts to NSDictionary + NSArray structure.
• Matches response URL to defined entity mapping.
• Maps response data to entity.

RKEntityMapping *clipMapping = [RKEntityMapping
mappingForEntityForName: @"Clip"
inManagedObjectStore: managedObjectStore];
[clipMapping addAttributeMappingsFromDictionary:@{
@"id": @"clipId",
@"content": @"content",
@"created_at": @"createdAt"}];
A Mapping

RKResponseDescriptor *clipsResponseDescriptor =
[RKResponseDescriptor
responseDescriptorWithMapping: clipMapping
pathPattern: @"/api/v1/clips"
keyPath: nil
statusCodes: RKStatusCodeIndexSetForClass(RKStatusCodeClassSuccessful)];
[objectManager addResponseDescriptor:clipsResponseDescriptor];
‘Index’ Response Descriptor

RKResponseDescriptor *clipResponseDescriptor =
[RKResponseDescriptor
responseDescriptorWithMapping: clipMapping
pathPattern: @"/api/v1/clips/:id"
keyPath: nil
statusCodes: RKStatusCodeIndexSetForClass(RKStatusCodeClassSuccessful)];
[objectManager addResponseDescriptor:clipResponseDescriptor];
‘Show’ Response Descriptor

- (void)loadClips
{
[[RKObjectManager sharedManager]
getObjectsAtPath:@"/api/v1/clips"
parameters:nil
success:nil
failure:nil];
}
Fetching Objects
(UITableViewController)

- (void)loadClips
{
[[RKObjectManager sharedManager]
getObjectsAtPath:@"/api/v1/clips"
parameters:nil
success:
^(RKObjectRequestOperation *operation, RKMappingResult *mappingResult) {}
failure:
^(RKObjectRequestOperation *operation, NSError *error) {}
];
}
Fetching Objects

The View
• How does this information get to the user?
• A NSFetchedResultsController is handling the heavy
lifting.

// In your UITableViewController.
UIRefreshControl *refreshControl = [UIRefreshControl new];
[refreshControl
addTarget:self
action:@selector(loadClips)
forControlEvents:UIControlEventValueChanged];
self.refreshControl = refreshControl;
Adding Pull to Refresh

RESTKit ‘POST’ Lifecycle
• Issues HTTP POST request to URL.
• Rails creates the object and redirects to it.
• From here it’s the same as before:
• Receives XML/JSON response.
• Converts to NSDictionary + NSArray structure.
• Matches redirected URL to defined entity mapping.
• Maps response data to entity.

Clip *clip = (Clip *)[NSEntityDescription
insertNewObjectForEntityForName:@"Clip"
inManagedObjectContext:self.managedObjectContext];
clip.content = [[UIPasteboard generalPasteboard] string];
Creating a New Clip

[[RKObjectManager sharedManager] postObject:clip
path:@"/api/v1/clips"
parameters:nil
success:nil
failure:nil];
Posting a New Clip

path:@"/api/v1/clips"
parameters:nil
success:
^(RKObjectRequestOperation *operation, RKMappingResult *mappingResult) {}
failure:
^(RKObjectRequestOperation *operation, NSError *error) {}
];
Posting a New Clip

RKRequestDescriptor *newClipRequestDescriptor =
[RKRequestDescriptor
requestDescriptorWithMapping:[clipMapping inverseMapping]
objectClass:[Clip class]
rootKeyPath:@"clip"];
[objectManager addRequestDescriptor:newClipRequestDescriptor];
A Request Descriptor

Mass-Assignment
• Rails’ new mass-assignment defaults are good, but
they cause issues for us here.
• RESTKit sends the ‘id’ and ‘created_at’ attributes
across in the request.
• This triggers an exception in development by default,
because of this:
config.active_record.mass_assignment_sanitizer = :strict

Offline Mode
• The server is the authority, but is not always
available.
• We want to be able to work and save data locally even
in the absence of an Internet connection.
• We don’t want to lose our work.
• When a connection is available, we’d like our local
work to be pushed up to the server.

A VerySimple Example
• In this app, “Clips” are read-only.
• Don’t have to worry about resolving conflicting
changes from two sources.
• How simple a solution can you get away with?

A VerySimple Solution
• Try saving to the server.
• If that doesn’t work, just save it locally.
• It won’t have a “Clip ID”, but that doesn’t matter
for CoreData, even with relationships.
• When a connection becomes available, push it up.

• Try saving to the server.
• If that doesn’t work, just save it locally.
• It won’t have a “Clip ID”, but that doesn’t matter
for CoreData, even with relationships.
• When a connection becomes available:
• Push it up to the server.
• Claim our shiny new “Clip ID”.

• The only question is, how will the new ID get mapped
to the locally stored object?
• It can’t be matched by primary key ID, because it
didn’t have one locally.
• We’ll use a globally unique ID.

NSString *dataBaseString = [RKApplicationDataDirectory()
stringByAppendingPathComponent:@"ClipQueue.sqlite"];
NSPersistentStore __unused *persistentStore =
[managedObjectStore
addSQLitePersistentStoreAtPath:dataBaseString
fromSeedDatabaseAtPath:nil
withConfiguration:nil
options:nil
error:nil];
Adding Local Storage

RKEntityMapping *clipMapping = [RKEntityMapping
mappingForEntityForName: @"Clip"
inManagedObjectStore: managedObjectStore];
[clipMapping addAttributeMappingsFromDictionary:@{
@"id": @"clipId",
@"content": @"content",
@"uuid": @"uuid",
@"created_at": @"createdAt",
@"deleted_at": @"deletedAt"}];
clipMapping.identificationAttributes = @[ @"uuid" ];
An Improved Mapping

clip.uuid = [self getUUID];
path:@"/api/v1/clips" parameters:nil
success: ^(RKObjectRequestOperation *operation, RKMappingResult *mappingResult) {}
failure: ^(RKObjectRequestOperation *operation, NSError *error) {
NSError *localError = nil;
if (![self.managedObjectContext save:&localError]) {
// Show UIAlertView to user.
[self showErrorAlert:[localError localizedDescription]];
}
}];
Queuing Up Locally

NSFetchRequest *request = [[NSFetchRequest alloc] init];
NSEntityDescription *entity = [NSEntityDescription entityForName:@"Clip"
inManagedObjectContext:self.managedObjectContext];
[request setEntity:entity];
NSPredicate *predicate = [NSPredicate predicateWithFormat:@"clipId == 0"];
[request setPredicate:predicate];
...
for (Clip *clip in mutableFetchResults) {
[[RKObjectManager sharedManager] postObject:clip path:@"/api/v1/clips"
parameters:nil success:nil failure: nil];
}
Syncing Up

...
before_validation do
self.uuid = UUIDTools::UUID.random_create.to_s if uuid.nil?
end
end
Updating API Logic

Sync Friendly Deletes
• An object exists locally, but not on the server.
• Was it created locally or deleted remotely?
• An object exists remotely, but not locally.
• Was it created remotely or deleted locally?
• Let’s look at a really easy way to deal with this.

...
scope :not_deleted, where('deleted_at IS NULL')
def destroy
self.update_column(:deleted_at, Time.zone.now)
end
end
Soft Delete

- (NSFetchedResultsController *)fetchedResultsController
{
...
// Filter out deleted results.
NSPredicate *predicate =
[NSPredicate predicateWithFormat:@"deletedAt == nil"];
[fetchRequest setPredicate:predicate];
...
}
Filtering Deleted Items

Added Bonus
• NSFetchedResultsController makes this an other UI
updates really pleasant to the user by default, even
when they’re triggered by results from the server.

Authentication Goals
• Require username and password.
• Scope all data by user.

Authentication
• Prompt for credentials.
• Store them in iOS Keychain.
• Delay loading until credentials are provided.
• Configure the credentials for RestKit.
• Implement data scoping on the server based on the
session.

Devise.setup do |config|
...
config.http_authenticatable = true
...
end
HTTP Authentication

- (void)viewWillAppear:(BOOL)animated
{
[super viewWillAppear:animated];
if ([self shouldDisplayLoginModal]) {
[self performSegueWithIdentifier:@"ShowLogin" sender:self];
}
}
Show Sign-In Modal

- (void)viewDidAppear:(BOOL)animated
{
[super viewDidAppear:animated];
if (![self shouldDisplayLoginModal]) {
[self loadObjectsFromDataStore];
}
}
Delay Loading

RKObjectManager* objectManager = [RKObjectManager sharedManager];
objectManager.client.username = emailAddressField.text;
objectManager.client.password = passwordField.text;
Configure Credentials

Add User-Clips Relationship
• Add “user_id” attribute to Clip.
• Add “has_one :user” relationship to Clip.
• Add “has_many :clips” relationship to User.

class Ability
include CanCan::Ability
def initialize(user)
user ||= User.new
if user.persisted?
can :manage, :clip, {user_id: user.id}
end
end
end
HTTP Authentication

before_filter :authenticate_user!
load_and_authorize_resource :clip, through: current_user
...
end
Scoping Controller Results

What We’ve Covered
• Rails API Versioning
• RestKit Installation
• Mapping Configuration
• Pulling and Pushing Data
• Offline Mode and Other Syncing
• Authentication

Additional Resources
Blake Watters’ RESTKit 0.20.0 “Gist” Tutorial
https://github.com/RestKit/RKGist/blob/master/TUTORIAL.md
(A work in progress.)

Thanks! Questions?
@andrewculver

Rails and iOS with RestKit

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Similar to Rails and iOS with RestKit

Similar to Rails and iOS with RestKit (20)

Recently uploaded

Recently uploaded (20)

Rails and iOS with RestKit