0

I'm trying to think up a scenario when I'd have three different forms of NSData (or whatever) to be sent to three different services like Evernote, Google drive, Dropbox. Granted, each of those has there own SDKs to be bundled into the iOS app, and thats okay.

Now, I want to create a single Class that serialises the both sending and receiving data to and from the above services.

My mind is taking me to a singleton, a shared class with NSOperationQueue at its foundation.

I'd periodically add {send:"this data" to:dropbox} into an NSOperationBlock and add it to the singleton.

At any given time say the following operations could be within the singleton's NSOperationQueue.

  • {send:"this data" to:dropbox}
  • {send:"this number" to:evernote}
  • {send:"this dude" to:googledrive}

The singleton would need to handle internet reachability, app sessions etc. This class would be connected to Dropbox, Evernote and GDrive and their respective SDK bundles. So, in reality the only thing this class would do is, hand over the data to the respective SDKs to handle it on their own (which is like saying, handle it and let me know if it was a success or failed.)

I'd really like suggestions/critique on the approach i'm taking. I have little experience with NSOperationQueue, I don't know if I'm making the right choices here. Some clues to a good API pattern would really be helpful.

UPDATE

It was suggested I create a wrapper for each service. But If can stress that theres little to do in a Dropbox Wrapper classes, Since in iOS everything is handled in their own SDK. For example, Evernote extends only a simple [ENSession .. uploadNote..]. All I wanted to do, is serialise my uploads into a single global queue and then dispatch the single methods to either Dropbox or Evernote or wherever. If suppose there is a service that requires some form of data handling, I'd then use a wrapper and dispatch its own thread. I'll add this into the question too. Its the serialising & queueing I want.Sounds reasonable?

4
  • The singleton would need to handle internet reachability, app sessions etc. This class would be connected to Dropbox, Evernote and GDrive and their respective This clearly breaks the Single Responsability principle, and may be the beginning of an over-complicated, unmanageable class with kilometric methods.
    – SJuan76
    Jul 14, 2014 at 17:26
  • Hmm, Thanks for commenting. I should probably kick out reachability and app open/close responses. But regarding the Dbx, Evernote thing, your saying I shouldn't be using the singleton send data to their respective SDKs? That was the whole point of making one?
    – user134611
    Jul 14, 2014 at 17:41
  • At the very least, you code a middle layer that hides each service complexity. You create a "Dropbox Wrapper" which hides all the technical details of Dropbox, a "GDrive Wrapper", etc., all of which implement the same contract (in Java it would be "interface", I do not know the term in objective-c).
    – SJuan76
    Jul 14, 2014 at 17:45
  • I take your point. But If can stress that theres little to do in a Dropbox Wrapper classes, Since in iOS everything is handled in their own SDK. For example, Evernote extends only a simple [ENSession .. uploadNote..]. All I wanted to do, is serialise my uploads into a single global queue and then dispatch the single methods to either Dropbox or Evernote or wherever. If suppose there is a service that requires some form of data handling, I'd then use a wrapper and dispatch its own thread. I'll add this into the question too. Its the serialising & queueing I want.Sounds reasonable?
    – user134611
    Jul 14, 2014 at 18:37

1 Answer 1

1

Break the services into their own respective classes. Even if a class only has one function in it, it will add much better readability, and thus scalability and be readily editable in the future. Stick to the Unix philosophy that each class should do only one thing, and do that one thing well. So I would have one class handle internet reachability using the notification center and three classes for each service. For example, here is a singleton class I once used with Google Drive.

#import <Foundation/Foundation.h>

#import "GTLDrive.h"
#import "GTMOAuth2Authentication.h"
#import "VSGConstants.h"

@interface VSGGoogleServiceDrive : GTLServiceDrive

/**
 Static method for having a shared Google service across the app
 */
+ (VSGGoogleServiceDrive *)sharedService;

@end

#import "VSGGoogleServiceDrive.h"

@implementation VSGGoogleServiceDrive

+ (VSGGoogleServiceDrive *)sharedService {

    static VSGGoogleServiceDrive *sharedServiceDrive = nil;
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        sharedServiceDrive = [[VSGGoogleServiceDrive alloc] init];
    });
    return sharedServiceDrive;
}


- (id)init {

    self = [super init];
    if (!self){
        return nil;
    }
    GTMOAuth2Authentication *auth = [[GTMOAuth2Authentication alloc] init];
    auth.accessToken = GOOGLE_ACCESS_TOKEN;
    auth.refreshToken = GOOGLE_REFRESH_TOKEN;
    auth.tokenURL = [NSURL URLWithString:GOOGLE_TOKEN_URL];
    auth.clientID = GOOGLE_CLIENT_ID;
    auth.clientSecret = GOOGLE_CLIENT_SECRET;
    self.authorizer = auth;
    return self;
}

@end

Extremely simple, but the individual service is nicely decoupled, making it more plug-n-play. This was from an old app so with my xp now, I would go ahead and also implement my service functions here such as uploading NSData to drive or deleting folders/files, etc.

I was also using the Google Calendar service, but kept that in it's own singleton as well.

Here's also my Reachability class using Tony Million's Reachability.

#import "Reachability.h"
#import "VSGConstants.h"

/**
 This class is used to monitor network connection. Dependent on the Reachability class. Provides an
 alert view to the user detailing the network connection upon network changes (disconnect/connect).
 */
@interface VSGNetworkMonitor : NSObject

/**
 Network used to check whether there is a valid connection to the server
 */
@property Reachability *network;

- (void)startMonitoringNetwork;

@end

    #import "VSGNetworkMonitor.h"

@interface VSGNetworkMonitor()

- (void)checkNetworkStatus:(NSNotification *)notice;

@end


@implementation VSGNetworkMonitor

static NSString *CONNECTION_LOST_TITLE = @"Connection Lost";
static NSString *CONNECTION_LOST_MESSAGE = @"Unable to connect to the server. Please check your connection";

static NSString *NO_CONNECTION_TITLE = @"Network Issue";
static NSString *NO_CONNECTION_MESSAGE = @"No valid internet connection detected";

static NSString *CONNECTION_FOUND_TITLE = @"Connection Found";
static NSString *CONNECTION_FOUND_MESSAGE = @"Connection to the server restored";

- (id)init {

    self = [super init];

    if(!self) {

        return nil;
    }

    self.network = [Reachability reachabilityWithHostname:SERVER_IP];

    if([self.network currentReachabilityStatus] == NotReachable) {

        UIAlertView *alert = [[UIAlertView alloc] initWithTitle:NO_CONNECTION_TITLE
                                                        message:NO_CONNECTION_MESSAGE
                                                       delegate:self
                                              cancelButtonTitle:OK_BUTTON
                                              otherButtonTitles:nil];
        [alert show];
    }

    return self;
}


- (void)startMonitoringNetwork {

    [self.network startNotifier];
    [[NSNotificationCenter defaultCenter] addObserver:self
                                             selector:@selector(checkNetworkStatus:)
                                                 name:kReachabilityChangedNotification
                                               object:nil];
}


- (void)checkNetworkStatus:(NSNotification *)notice {

    NetworkStatus internetStatus = [self.network currentReachabilityStatus];
    switch (internetStatus) {

        case NotReachable: {

            UIAlertView *alert = [[UIAlertView alloc] initWithTitle:CONNECTION_LOST_TITLE
                                                            message:CONNECTION_LOST_MESSAGE
                                                           delegate:nil
                                                  cancelButtonTitle:OK_BUTTON
                                                  otherButtonTitles:nil];
            [alert show];
            break;
        }

        case ReachableViaWiFi:
        case ReachableViaWWAN: {

            UIAlertView *alert = [[UIAlertView alloc] initWithTitle:CONNECTION_FOUND_TITLE
                                                            message:CONNECTION_FOUND_MESSAGE
                                                           delegate:nil
                                                  cancelButtonTitle:OK_BUTTON
                                                  otherButtonTitles:nil];
            [alert show];
            break;
        }
    }
}


@end

Don't avoid breaking things apart. Instead, to the contrary, break things apart as much as you can. This also helps with Information Hiding as well.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Not the answer you're looking for? Browse other questions tagged or ask your own question.