BlackBerry Dynamics

1. Start Xcode.

2. Open the Xcode project for the app.

3. Create new GDiOSDelegate class files. The GDiOSDelegate class name used in this process will be GDAppGDiOSDelegate.h and AppGDiOSDelegate.m

• Go to New > File > iOS > Cocoa Touch Class and add AppGDiOSDelegate. Put the subclass as NSObject.

4. Open AppGDiOSDelegate.h and do the following:

• Add #import <GD/GDiOS.h>
• Add the GDiOSDelegate protocol.
• Declare the GDiOSDelegate class as having a static function sharedInstance that returns an instance of itself.
• Add the property BOOL hasAuthorized as a flag to keep the status of the BlackBerry Dynamics authorization.
• Add the property AppDelegate *appDelegate for a reference to an instance of the app delegate.
• Add the property RootViewController *rootViewController to get a reference to the app’s main interface. 

After these changes, the AppGDiOSDelegate.h file should look like this:

#import <Foundation/Foundation.h>
#import <GD/GDiOS.h>
#import "RootViewController.h"
#import "AppDelegate.h"

@interface AppGDiOSDelegate : NSObject <GDiOSDelegate>

@property (weak, nonatomic) RootViewController *rootViewController;

@property (weak, nonatomic) AppDelegate *appDelegate;

@property (assign, nonatomic, readonly) BOOL hasAuthorized;

+(AppGDiOSDelegate *)sharedInstance;

@end

5. Open AppGDiOSDelegate.m and do the following:

• Add import statements for Foundation.h, GDiOS.h, AppGDiOSDelegate.h,  and RootViewController.h.
• Override the read-only property hasAuthorized to be writeable internally.
• Add static initializer code, including an init function that is declared as private and a sharedInstance implementation that guarantees that only one instance is ever created.
• Add custom setters for the view controller and app delegate properties that call the new function, as well as setting the property values.
• Add a new private method didAuthorize that checks whether the end user has been authorized, checks that properties for the view controller and app delegate have been set, and then calls the app delegate didAuthorize function if all those conditions are met.
• Add a dummy for the required GDiOSDelegate functions

After these changes, the AppGDiOSDelegate.m file should look like this:

#import <Foundation/Foundation.h>
#import <GD/GDiOS.h>
#import "AppGDiOSDelegate.h"
#import "RootViewController.h"
#import "AppDelegate.h"

@interface AppGDiOSDelegate()

@property(assign, nonatomic) BOOL hasAuthorized;

-(instancetype)init;
-(void)didAuthorize;

@end

@implementation AppGDiOSDelegate

+(instancetype)sharedInstance
{
static AppGDiOSDelegate *appGDiOSDelegate = nil;
static dispatch_once_t onceToken = 0;
dispatch_once(&onceToken, ^{
                appGDiOSDelegate = [[AppGDiOSDelegate alloc] init]; });
return appGDiOSDelegate;
}

-(instancetype)init
{
self = [super init];
return self;
}

-(void)setRootViewController:(RootViewController *)rootViewController
{
        _rootViewController = rootViewController;
        [self didAuthorize];
}

-(void)setAppDelegate:(AppDelegate *)appDelegate
{
        _appDelegate = appDelegate;
        [self didAuthorize];
}

-(void)didAuthorize
{
    if (self.hasAuthorized && self.rootViewController && self.appDelegate) {
        [self.appDelegate didAuthorize];
    }
}

-(void)handleEvent:(GDAppEvent *)anEvent { }

@end

Follow the steps below to integrate your existing Swift app with the BlackBerry Dynamics SDK:

1. Start Xcode.

2. Open the Xcode project for your app.

3. In AppDelegate.swift, import the GD library.

import GD.Runtime


4. Copy the variables below and add them to your App Delegate class in AppDelegate.swift.

class AppDelegate : UIResponder , UIApplicationDelegate,  GDiOSDelegate {
    var window: UIWindow?
    var good: GDiOS?
    var started: Bool = false

5. Modify the didFinishLaunchingWithOptions method to implement GDiOSDelegate.

func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplicationLaunchOptionsKey: Any]?) -> Bool 
{
  // Call BlackBerry Dynamics to authorise the app
   self.good = GDiOS.sharedInstance()
         
   self.good!.delegate = self
   self.started = false
       
  // Show the Good Authentication UI.
   self.good!.authorize()
         
  return true
}

1. Open the app’s info.plist file. 

Note the UIMainStoryboardFile key value, then delete the key. This value will be programmatically added after a successful BlackBerry Dynamics authorization. 

2. Open AppGDiOSDelegate.m. To handle the BlackBerry Dynamics authorization events, add the following functions:

• handleEvent
• onNotAuthorized
• onAuthorized

In the onAuthorized function, note the code under the case GDErrorNone: . When there is no error during the authorization process, you will need to add the code to load the main storyboard, which you deleted from the property file. Add code to instantiate and launch the initial view controller. Add a call to the new didAuthorize function that was just added. See the following code:

-(void)handleEvent:(GDAppEvent *)anEvent {

    /* Called from _good when events occur, such as system startup. */
    switch (anEvent.type)
    {
        case GDAppEventAuthorized:
        {
            [self onAuthorized:anEvent];
            break;
        }
        case GDAppEventNotAuthorized:
        {
            [self onNotAuthorized:anEvent];
            break;
        }
        case GDAppEventRemoteSettingsUpdate:
        {
            //A change to application-related configuration or policy settings.
            break;
        }
        case GDAppEventServicesUpdate:
        {
            //A change to services-related configuration.
            break;
        }
        case GDAppEventPolicyUpdate:
        {
            //A change to one or more application-specific policy settings has been received.
            break;
        }
        case GDAppEventEntitlementsUpdate:
        {
            //A change to the entitlements data has been received.
            break;
        }

    }
}

- (void)onNotAuthorized:(GDAppEvent *)anEvent {

    /* Handle the Good Libraries not authorized event. */
    switch (anEvent.code)
    {
        case GDErrorActivationFailed:
        case GDErrorProvisioningFailed:
        case GDErrorPushConnectionTimeout:
        case GDErrorSecurityError:
        case GDErrorAppDenied:
        case GDErrorAppVersionNotEntitled:
        case GDErrorBlocked:
        case GDErrorWiped:
        case GDErrorRemoteLockout:
        case GDErrorPasswordChangeRequired:
        {
            // an condition has occured denying authorization, an application
                        // may wish to log these events
            NSLog(@"onNotAuthorized %@", anEvent.message);
            break;
        }
        case GDErrorIdleLockout:
        {
            // idle lockout is benign & informational
            break;
        }
        default:
            NSAssert(false, @"Unhandled not authorized event");
            break;
    }

}
- (void)onAuthorized:(GDAppEvent *)anEvent {
    /* Handle the Good Libraries authorized event. */
    switch (anEvent.code)
    {
        case GDErrorNone:
        {
            if (!self.hasAuthorized)
            {
                // launch application UI here
                self.hasAuthorized = YES;

                UIStoryboard *uiStoryboard =
                [UIStoryboard storyboardWithName:@"Main" bundle:nil];
                                UIViewController *uiViewController =
                [uiStoryboard instantiateInitialViewController];

                self.appDelegate.window.rootViewController = uiViewController;

                [self didAuthorize];

            }
            break;
        }
        default:
            NSAssert(false, @"authorized startup with an error");
            break;
    }
}

3. Open AppDelegate.m, the original app delegate class. Add:

#import "AppGDiOSDelegate.h"
#import "RootViewController.h".

4. In didFinishLaunchingWithOptions, add the following calls:

[AppGDiOSDelegate sharedInstance].appDelegate = self;

[[GDiOS sharedInstance] authorize:[AppGDiOSDelegate sharedInstance]];

5. Save the app.

1. Open the app’s info.plist file. 

Note the UIMainStoryboardFile key value and delete the key. You can also do this on the General tab. This value will be programmatically added after a successful BlackBerry Dynamics authorization. 

2. Open AppDelegate.swift. Add the following functions to handle authorization events:

func handle(_ anEvent: GDAppEvent) 
{     
    switch anEvent.type 
    {
            case .authorized:
                onAuthorized(anEvent: anEvent)
                break  
            case .notAuthorized:
                self.onNotAuthorized(anEvent: anEvent)
                break
            case .remoteSettingsUpdate:
               //A change to application-related configuration or policy settings.
                break
                
            case .servicesUpdate:
                //A change to services-related configuration.
                break
             case .policyUpdate:
                if started {
                    NotificationCenter.default.post(name: NSNotification.Name(rawValue: "AppPolicyUpdated"), object: nil)
                }
                break
            default:
                print("handleEvent \(anEvent.message)")
     }
}
    
func onNotAuthorized(anEvent:GDAppEvent ) 
{
    /* Handle the Good Libraries not authorized event. */
    switch anEvent.code 
    {
        case .errorActivationFailed: break
        case .errorProvisioningFailed: break
        case .errorPushConnectionTimeout: break
        case .errorSecurityError: break
        case .errorAppDenied: break
        case .errorAppVersionNotEntitled: break
        case .errorBlocked: break
        case .errorWiped: break
        case .errorRemoteLockout: break
        case .errorPasswordChangeRequired:
        // an condition has occured denying authorization, an application may wish to log these events
            print("onNotAuthorized \(anEvent.message)")
        case .errorIdleLockout:
            // idle lockout is benign & informational
            break        default: assert(false, "Unhandled not authorized event");
     }
}
    
func onAuthorized(anEvent:GDAppEvent ) 
{
    /* Handle the Good Libraries authorized event. */
    switch anEvent.code 
    {
        case .errorNone:
            if !self.started 
     {
                //Show the User UI
                self.started = true
            }
        default:
            assert(false, "Authorized startup with an error")
            break
    }
}

1. Change the app user interface to be monitored and secured by the BlackBerry Dynamics Runtime. Open RootViewController.m and add the following import statement:

#import "AppGDiOSDelegate.h".

2. In the viewDidLoad function, add an assignment of the new property in the static class to a reference of this instance of the view controller. In this example, it’s rootViewController.

[AppGDiOSDelegate sharedInstance].rootViewController = self;

3. Search the rootViewController assignment and replace with sharedInstance.

4. In AppDelegate.h, add didAuthorize to the interface of AppDelegate:

-(void)didAuthorize;

5. In AppDelegate.m, add didAuthorize to the implementation of AppDelegate.m and move any original app launch code to the new function:

-(void)didAuthorize
{
//move your launch code to here...
    RootViewController *rootViewController = [AppGDiOSDelegate sharedInstance].rootViewController;
}

5. Save and compile the app.

1. Move the original launch code to the new onAuthorized:

func onAuthorized(anEvent:GDAppEvent ) 
{
    /* Handle the Good Libraries authorized event. */
    switch anEvent.code 
    {
        case .errorNone:
            if !self.started 
            {
                //Show the User UI
                self.started = true
               self.window?.rootViewController = UIStoryboard(name: "Main", bundle: nil).instantiateInitialViewController()
            }
        default:
            assert(false, "Authorized startup with an error")
            break
    }
}

2. Save and compile the app.

To run and test your BlackBerry Dynamics app, you will need to set up a BlackBerry UEM or Good Control server. If you don’t have a BlackBerry Dynamics environment set up, Enterprise Simulation Mode can be used to test your app without a connection to UEM or Good Control.

In Enterprise Simulation Mode, there is no user authentication at the enterprise level, so there will be no communication through the enterprise firewall. If your app requires a connection behind the firewall, using the Enterprise Simulation Mode to test your app is not recommended. You will need to set up UEM or Good Control to test the app on a device.

Important: Enterprise Simulation Mode is not intended for a production environment.

To enable Enterprise Simulation Mode for your BlackBerry Dynamics app, add the following to the app's Info.plist file:

Key: GDLibraryMode
Type: String (default)
Value: GDEnterpriseSimulation

You are now ready to build and run your BlackBerry Dynamics app on the iOS Simulator.

When your app is running for the first time on the iOS simulator, you’ll be prompted to activate the app. In Enterprise Simulation Mode, you can enter any email address and any 15-character access key to complete the activation process. After the app is activated, you’ll be prompted to create a password to access the app.

The “Password Requirements” link at the bottom of the screen provides guidance on the required password complexity. Password complexity is controlled via policies managed by the IT admin through the UEM or Good Control management console.