mirror of
https://github.com/zhigang1992/RestKit.git
synced 2026-04-01 22:42:51 +08:00
499 lines
16 KiB
Objective-C
499 lines
16 KiB
Objective-C
//
|
|
// RKObjectManager.m
|
|
// RestKit
|
|
//
|
|
// Created by Jeremy Ellison on 8/14/09.
|
|
// Copyright (c) 2009-2012 RestKit. All rights reserved.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
//
|
|
|
|
#import "RKObjectManager.h"
|
|
#import "RKObjectSerializer.h"
|
|
#import "RKManagedObjectStore.h"
|
|
#import "RKManagedObjectLoader.h"
|
|
#import "Support.h"
|
|
|
|
NSString * const RKObjectManagerDidBecomeOfflineNotification = @"RKDidEnterOfflineModeNotification";
|
|
NSString * const RKObjectManagerDidBecomeOnlineNotification = @"RKDidEnterOnlineModeNotification";
|
|
|
|
//////////////////////////////////
|
|
// Shared Instances
|
|
|
|
static RKObjectManager *sharedManager = nil;
|
|
static NSOperationQueue *defaultMappingQueue = nil;
|
|
|
|
///////////////////////////////////
|
|
|
|
@interface RKObjectManager ()
|
|
@property (nonatomic, assign, readwrite) RKObjectManagerNetworkStatus networkStatus;
|
|
@end
|
|
|
|
@implementation RKObjectManager
|
|
|
|
@synthesize client = _client;
|
|
@synthesize managedObjectStore = _managedObjectStore;
|
|
@synthesize mappingProvider = _mappingProvider;
|
|
@synthesize serializationMIMEType = _serializationMIMEType;
|
|
@synthesize networkStatus = _networkStatus;
|
|
@synthesize mappingQueue = _mappingQueue;
|
|
|
|
+ (NSOperationQueue *)defaultMappingQueue
|
|
{
|
|
if (! defaultMappingQueue) {
|
|
defaultMappingQueue = [NSOperationQueue new];
|
|
defaultMappingQueue.name = @"org.restkit.ObjectMapping";
|
|
defaultMappingQueue.maxConcurrentOperationCount = 1;
|
|
}
|
|
|
|
return defaultMappingQueue;
|
|
}
|
|
|
|
+ (void)setDefaultMappingQueue:(NSOperationQueue *)newDefaultMappingQueue
|
|
{
|
|
if (defaultMappingQueue) {
|
|
[defaultMappingQueue release];
|
|
defaultMappingQueue = nil;
|
|
}
|
|
|
|
if (newDefaultMappingQueue) {
|
|
[newDefaultMappingQueue retain];
|
|
defaultMappingQueue = newDefaultMappingQueue;
|
|
}
|
|
}
|
|
|
|
- (id)init
|
|
{
|
|
self = [super init];
|
|
if (self) {
|
|
_mappingProvider = [RKObjectMappingProvider new];
|
|
_networkStatus = RKObjectManagerNetworkStatusUnknown;
|
|
|
|
self.serializationMIMEType = RKMIMETypeFormURLEncoded;
|
|
self.mappingQueue = [RKObjectManager defaultMappingQueue];
|
|
|
|
[self addObserver:self
|
|
forKeyPath:@"client.reachabilityObserver"
|
|
options:NSKeyValueObservingOptionOld | NSKeyValueObservingOptionNew | NSKeyValueObservingOptionInitial
|
|
context:nil];
|
|
|
|
// Set shared manager if nil
|
|
if (nil == sharedManager) {
|
|
[RKObjectManager setSharedManager:self];
|
|
}
|
|
}
|
|
|
|
return self;
|
|
}
|
|
|
|
- (id)initWithBaseURL:(RKURL *)baseURL
|
|
{
|
|
self = [self init];
|
|
if (self) {
|
|
self.client = [RKClient clientWithBaseURL:baseURL];
|
|
self.acceptMIMEType = RKMIMETypeJSON;
|
|
}
|
|
|
|
return self;
|
|
}
|
|
|
|
+ (RKObjectManager *)sharedManager
|
|
{
|
|
return sharedManager;
|
|
}
|
|
|
|
+ (void)setSharedManager:(RKObjectManager *)manager
|
|
{
|
|
[manager retain];
|
|
[sharedManager release];
|
|
sharedManager = manager;
|
|
}
|
|
|
|
+ (RKObjectManager *)managerWithBaseURLString:(NSString *)baseURLString
|
|
{
|
|
return [self managerWithBaseURL:[RKURL URLWithString:baseURLString]];
|
|
}
|
|
|
|
+ (RKObjectManager *)managerWithBaseURL:(NSURL *)baseURL
|
|
{
|
|
RKObjectManager *manager = [[[self alloc] initWithBaseURL:[RKURL URLWithBaseURL:baseURL]] autorelease];
|
|
return manager;
|
|
}
|
|
|
|
- (void)dealloc
|
|
{
|
|
[self removeObserver:self forKeyPath:@"client.reachabilityObserver"];
|
|
[[NSNotificationCenter defaultCenter] removeObserver:self];
|
|
|
|
[_client release];
|
|
[_managedObjectStore release];
|
|
[_serializationMIMEType release];
|
|
[_mappingProvider release];
|
|
|
|
[super dealloc];
|
|
}
|
|
|
|
- (BOOL)isOnline
|
|
{
|
|
return (_networkStatus == RKObjectManagerNetworkStatusOnline);
|
|
}
|
|
|
|
- (BOOL)isOffline
|
|
{
|
|
return (_networkStatus == RKObjectManagerNetworkStatusOffline);
|
|
}
|
|
|
|
- (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary *)change context:(void *)context
|
|
{
|
|
if ([keyPath isEqualToString:@"client.reachabilityObserver"]) {
|
|
[self reachabilityObserverDidChange:change];
|
|
}
|
|
}
|
|
|
|
- (void)reachabilityObserverDidChange:(NSDictionary *)change
|
|
{
|
|
RKReachabilityObserver *oldReachabilityObserver = [change objectForKey:NSKeyValueChangeOldKey];
|
|
RKReachabilityObserver *newReachabilityObserver = [change objectForKey:NSKeyValueChangeNewKey];
|
|
|
|
if (! [oldReachabilityObserver isEqual:[NSNull null]]) {
|
|
RKLogDebug(@"Reachability observer changed for RKClient %@ of RKObjectManager %@, stopping observing reachability changes", self.client, self);
|
|
[[NSNotificationCenter defaultCenter] removeObserver:self name:RKReachabilityDidChangeNotification object:oldReachabilityObserver];
|
|
}
|
|
|
|
if (! [newReachabilityObserver isEqual:[NSNull null]]) {
|
|
[[NSNotificationCenter defaultCenter] addObserver:self
|
|
selector:@selector(reachabilityChanged:)
|
|
name:RKReachabilityDidChangeNotification
|
|
object:newReachabilityObserver];
|
|
|
|
RKLogDebug(@"Reachability observer changed for client %@ of object manager %@, starting observing reachability changes", self.client, self);
|
|
}
|
|
|
|
// Initialize current Network Status
|
|
if ([self.client.reachabilityObserver isReachabilityDetermined]) {
|
|
BOOL isNetworkReachable = [self.client.reachabilityObserver isNetworkReachable];
|
|
self.networkStatus = isNetworkReachable ? RKObjectManagerNetworkStatusOnline : RKObjectManagerNetworkStatusOffline;
|
|
} else {
|
|
self.networkStatus = RKObjectManagerNetworkStatusUnknown;
|
|
}
|
|
}
|
|
|
|
- (void)reachabilityChanged:(NSNotification *)notification
|
|
{
|
|
BOOL isHostReachable = [self.client.reachabilityObserver isNetworkReachable];
|
|
|
|
_networkStatus = isHostReachable ? RKObjectManagerNetworkStatusOnline : RKObjectManagerNetworkStatusOffline;
|
|
|
|
if (isHostReachable) {
|
|
[[NSNotificationCenter defaultCenter] postNotificationName:RKObjectManagerDidBecomeOnlineNotification object:self];
|
|
} else {
|
|
[[NSNotificationCenter defaultCenter] postNotificationName:RKObjectManagerDidBecomeOfflineNotification object:self];
|
|
}
|
|
}
|
|
|
|
- (void)setAcceptMIMEType:(NSString *)MIMEType
|
|
{
|
|
[self.client setValue:MIMEType forHTTPHeaderField:@"Accept"];
|
|
}
|
|
|
|
- (NSString *)acceptMIMEType
|
|
{
|
|
return [self.client.HTTPHeaders valueForKey:@"Accept"];
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////
|
|
#pragma mark - Object Collection Loaders
|
|
|
|
- (Class)objectLoaderClass
|
|
{
|
|
Class managedObjectLoaderClass = NSClassFromString(@"RKManagedObjectLoader");
|
|
if (self.managedObjectStore && managedObjectLoaderClass) {
|
|
return managedObjectLoaderClass;
|
|
}
|
|
|
|
return [RKObjectLoader class];
|
|
}
|
|
|
|
- (id)loaderWithResourcePath:(NSString *)resourcePath
|
|
{
|
|
RKURL *URL = [self.baseURL URLByAppendingResourcePath:resourcePath];
|
|
return [self loaderWithURL:URL];
|
|
}
|
|
|
|
- (id)loaderWithURL:(RKURL *)URL
|
|
{
|
|
RKObjectLoader *loader = [[self objectLoaderClass] loaderWithURL:URL mappingProvider:self.mappingProvider];
|
|
loader.configurationDelegate = self;
|
|
if ([loader isKindOfClass:[RKManagedObjectLoader class]]) {
|
|
RKManagedObjectLoader *managedObjectLoader = (RKManagedObjectLoader *)loader;
|
|
managedObjectLoader.managedObjectContext = self.managedObjectStore.primaryManagedObjectContext;
|
|
managedObjectLoader.mainQueueManagedObjectContext = self.managedObjectStore.mainQueueManagedObjectContext;
|
|
managedObjectLoader.managedObjectCache = self.managedObjectStore.managedObjectCache;
|
|
}
|
|
[self configureObjectLoader:loader];
|
|
|
|
return loader;
|
|
}
|
|
|
|
- (NSURL *)baseURL
|
|
{
|
|
return self.client.baseURL;
|
|
}
|
|
|
|
- (RKObjectPaginator *)paginatorWithResourcePathPattern:(NSString *)resourcePathPattern
|
|
{
|
|
RKURL *patternURL = [[self baseURL] URLByAppendingResourcePath:resourcePathPattern];
|
|
RKObjectPaginator *paginator = [RKObjectPaginator paginatorWithPatternURL:patternURL
|
|
mappingProvider:self.mappingProvider];
|
|
paginator.configurationDelegate = self;
|
|
return paginator;
|
|
}
|
|
|
|
- (id)loaderForObject:(id<NSObject>)object method:(RKRequestMethod)method
|
|
{
|
|
RKURL *URL = [self.router URLForObject:object method:method];
|
|
RKObjectLoader *loader = [self loaderWithURL:URL];
|
|
loader.method = method;
|
|
loader.sourceObject = object;
|
|
loader.serializationMIMEType = self.serializationMIMEType;
|
|
loader.serializationMapping = [self.mappingProvider serializationMappingForClass:[object class]];
|
|
|
|
RKMapping *objectMapping = URL.resourcePath ? [self.mappingProvider objectMappingForResourcePath:URL.resourcePath] : nil;
|
|
if (objectMapping == nil || ([objectMapping isKindOfClass:[RKObjectMapping class]] && [object isMemberOfClass:[(RKObjectMapping *)objectMapping objectClass]])) {
|
|
loader.targetObject = object;
|
|
} else {
|
|
loader.targetObject = nil;
|
|
}
|
|
|
|
return loader;
|
|
}
|
|
|
|
- (void)loadObjectsAtResourcePath:(NSString *)resourcePath delegate:(id<RKObjectLoaderDelegate>)delegate
|
|
{
|
|
RKObjectLoader *loader = [self loaderWithResourcePath:resourcePath];
|
|
loader.delegate = delegate;
|
|
loader.method = RKRequestMethodGET;
|
|
|
|
[loader send];
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////
|
|
#pragma mark - Object Instance Loaders
|
|
|
|
- (void)getObject:(id<NSObject>)object delegate:(id<RKObjectLoaderDelegate>)delegate
|
|
{
|
|
RKObjectLoader *loader = [self loaderForObject:object method:RKRequestMethodGET];
|
|
loader.delegate = delegate;
|
|
[loader send];
|
|
}
|
|
|
|
- (void)postObject:(id<NSObject>)object delegate:(id<RKObjectLoaderDelegate>)delegate
|
|
{
|
|
RKObjectLoader *loader = [self loaderForObject:object method:RKRequestMethodPOST];
|
|
loader.delegate = delegate;
|
|
[loader send];
|
|
}
|
|
|
|
- (void)putObject:(id<NSObject>)object delegate:(id<RKObjectLoaderDelegate>)delegate
|
|
{
|
|
RKObjectLoader *loader = [self loaderForObject:object method:RKRequestMethodPUT];
|
|
loader.delegate = delegate;
|
|
[loader send];
|
|
}
|
|
|
|
- (void)deleteObject:(id<NSObject>)object delegate:(id<RKObjectLoaderDelegate>)delegate
|
|
{
|
|
RKObjectLoader *loader = [self loaderForObject:object method:RKRequestMethodDELETE];
|
|
loader.delegate = delegate;
|
|
[loader send];
|
|
}
|
|
|
|
#if NS_BLOCKS_AVAILABLE
|
|
|
|
#pragma mark - Block Configured Object Loaders
|
|
|
|
- (void)loadObjectsAtResourcePath:(NSString *)resourcePath usingBlock:(void(^)(RKObjectLoader *))block
|
|
{
|
|
RKObjectLoader *loader = [self loaderWithResourcePath:resourcePath];
|
|
loader.method = RKRequestMethodGET;
|
|
|
|
// Yield to the block for setup
|
|
block(loader);
|
|
|
|
[loader send];
|
|
}
|
|
|
|
- (void)sendObject:(id<NSObject>)object toResourcePath:(NSString *)resourcePath usingBlock:(void(^)(RKObjectLoader *))block
|
|
{
|
|
RKObjectLoader *loader = [self loaderForObject:object method:RKRequestMethodInvalid];
|
|
loader.URL = [self.baseURL URLByAppendingResourcePath:resourcePath];
|
|
// Yield to the block for setup
|
|
block(loader);
|
|
|
|
[loader send];
|
|
}
|
|
|
|
- (void)sendObject:(id<NSObject>)object method:(RKRequestMethod)method usingBlock:(void(^)(RKObjectLoader *))block
|
|
{
|
|
RKObjectLoader *loader = [self loaderForObject:object method:method];
|
|
// Yield to the block for setup
|
|
block(loader);
|
|
|
|
[loader send];
|
|
}
|
|
|
|
- (void)getObject:(id<NSObject>)object usingBlock:(void(^)(RKObjectLoader *))block
|
|
{
|
|
[self sendObject:object method:RKRequestMethodGET usingBlock:block];
|
|
}
|
|
|
|
- (void)postObject:(id<NSObject>)object usingBlock:(void(^)(RKObjectLoader *))block
|
|
{
|
|
[self sendObject:object method:RKRequestMethodPOST usingBlock:block];
|
|
}
|
|
|
|
- (void)putObject:(id<NSObject>)object usingBlock:(void(^)(RKObjectLoader *))block
|
|
{
|
|
[self sendObject:object method:RKRequestMethodPUT usingBlock:block];
|
|
}
|
|
|
|
- (void)deleteObject:(id<NSObject>)object usingBlock:(void(^)(RKObjectLoader *))block
|
|
{
|
|
[self sendObject:object method:RKRequestMethodDELETE usingBlock:block];
|
|
}
|
|
|
|
- (void)loadRelationship:(NSString *)relationshipName ofObject:(id)object usingBlock:(void(^)(RKObjectLoader *))block
|
|
{
|
|
// TODO: Try to pull the path/url off of the object (relationshipResourcePath | relationshipURL)
|
|
RKURL *URL = [self.router URLForRelationship:relationshipName ofObject:object method:RKRequestMethodGET];
|
|
[self loadObjectsAtResourcePath:URL.resourcePath usingBlock:block];
|
|
}
|
|
|
|
#endif // NS_BLOCKS_AVAILABLE
|
|
|
|
#pragma mark - Object Instance Loaders for Non-nested JSON
|
|
|
|
- (void)getObject:(id<NSObject>)object mapResponseWith:(RKObjectMapping *)objectMapping delegate:(id<RKObjectLoaderDelegate>)delegate
|
|
{
|
|
[self sendObject:object method:RKRequestMethodGET usingBlock:^(RKObjectLoader *loader) {
|
|
loader.delegate = delegate;
|
|
loader.objectMapping = objectMapping;
|
|
}];
|
|
}
|
|
|
|
- (void)postObject:(id<NSObject>)object mapResponseWith:(RKObjectMapping *)objectMapping delegate:(id<RKObjectLoaderDelegate>)delegate
|
|
{
|
|
[self sendObject:object method:RKRequestMethodPOST usingBlock:^(RKObjectLoader *loader) {
|
|
loader.delegate = delegate;
|
|
loader.objectMapping = objectMapping;
|
|
}];
|
|
}
|
|
|
|
- (void)putObject:(id<NSObject>)object mapResponseWith:(RKObjectMapping *)objectMapping delegate:(id<RKObjectLoaderDelegate>)delegate
|
|
{
|
|
[self sendObject:object method:RKRequestMethodPUT usingBlock:^(RKObjectLoader *loader) {
|
|
loader.delegate = delegate;
|
|
loader.objectMapping = objectMapping;
|
|
}];
|
|
}
|
|
|
|
- (void)deleteObject:(id<NSObject>)object mapResponseWith:(RKObjectMapping *)objectMapping delegate:(id<RKObjectLoaderDelegate>)delegate
|
|
{
|
|
[self sendObject:object method:RKRequestMethodDELETE usingBlock:^(RKObjectLoader *loader) {
|
|
loader.delegate = delegate;
|
|
loader.objectMapping = objectMapping;
|
|
}];
|
|
}
|
|
|
|
- (RKRequestCache *)requestCache
|
|
{
|
|
return self.client.requestCache;
|
|
}
|
|
|
|
- (RKRequestQueue *)requestQueue
|
|
{
|
|
return self.client.requestQueue;
|
|
}
|
|
|
|
- (RKRouter *)router
|
|
{
|
|
return self.client.router;
|
|
}
|
|
|
|
- (void)setRouter:(RKRouter *)router
|
|
{
|
|
self.client.router = router;
|
|
}
|
|
|
|
#pragma mark - RKConfigrationDelegate
|
|
|
|
- (void)configureRequest:(RKRequest *)request
|
|
{
|
|
[self.client configureRequest:request];
|
|
}
|
|
|
|
- (void)configureObjectLoader:(RKObjectLoader *)objectLoader
|
|
{
|
|
objectLoader.serializationMIMEType = self.serializationMIMEType;
|
|
[self configureRequest:objectLoader];
|
|
}
|
|
|
|
#pragma mark - Deprecations
|
|
|
|
+ (RKObjectManager *)objectManagerWithBaseURLString:(NSString *)baseURLString
|
|
{
|
|
return [self managerWithBaseURLString:baseURLString];
|
|
}
|
|
|
|
+ (RKObjectManager *)objectManagerWithBaseURL:(NSURL *)baseURL
|
|
{
|
|
return [self managerWithBaseURL:baseURL];
|
|
}
|
|
|
|
- (RKObjectLoader *)objectLoaderWithResourcePath:(NSString *)resourcePath delegate:(id<RKObjectLoaderDelegate>)delegate
|
|
{
|
|
RKObjectLoader *loader = [self loaderWithResourcePath:resourcePath];
|
|
loader.delegate = delegate;
|
|
|
|
return loader;
|
|
}
|
|
|
|
- (RKObjectLoader *)objectLoaderForObject:(id<NSObject>)object method:(RKRequestMethod)method delegate:(id<RKObjectLoaderDelegate>)delegate
|
|
{
|
|
RKObjectLoader *loader = [self loaderForObject:object method:method];
|
|
loader.delegate = delegate;
|
|
return loader;
|
|
}
|
|
|
|
- (void)loadObjectsAtResourcePath:(NSString *)resourcePath objectMapping:(RKObjectMapping *)objectMapping delegate:(id<RKObjectLoaderDelegate>)delegate
|
|
{
|
|
RKObjectLoader *loader = [self loaderWithResourcePath:resourcePath];
|
|
loader.delegate = delegate;
|
|
loader.method = RKRequestMethodGET;
|
|
loader.objectMapping = objectMapping;
|
|
|
|
[loader send];
|
|
}
|
|
|
|
- (RKManagedObjectStore *)objectStore
|
|
{
|
|
return self.managedObjectStore;
|
|
}
|
|
|
|
- (void)setObjectStore:(RKManagedObjectStore *)objectStore
|
|
{
|
|
self.managedObjectStore = objectStore;
|
|
}
|
|
|
|
@end
|