Integrating the Tapkey Mobile SDK for iOS¶

source 'https://github.com/tapkey/TapkeyCocoaPods'
source 'https://cdn.cocoapods.org/'

use_frameworks!

target 'App' do
    pod 'TapkeyMobileLib', '2.21.2.2'
end

import TapkeyMobileLib
import UIKit

@UIApplicationMain
class AppDelegate: UIResponder, UIApplicationDelegate {

    private var TKMServiceFactory: TKMServiceFactory!

    func application(_ application: UIApplication,
                     willFinishLaunchingWithOptions launchOptions:
                     [UIApplication.LaunchOptionsKey : Any]? = nil) -> Bool {

        // Build service factory
        self.TKMServiceFactory = TKMServiceFactoryBuilder()
            .build()
    }
}

// Background App Refresh
func application(
        _ application: UIApplication,
        performFetchWithCompletionHandler completionHandler: @escaping (UIBackgroundFetchResult) -> Void) {

    // Configure the Tapkey SDK to poll for notifications.
    // Run the code via runAsyncInBackground to prevent the app from sleeping while fetching is in progress.
    runAsyncInBackground(application, promise:
        TKMServiceFactory.notificationManager
                .pollForNotificationsAsync(cancellationToken: TKMCancellationTokens.None)
                .finallyOnUi {
                    completionHandler(UIBackgroundFetchResult.newData)
                }
    )
}

TKMServiceFactory.userManager.logInAsync(accessToken: "eyJhbGciOiJSUz...O-YbBq8F7086rQi-kEbERp4dA3r0WonpHnmYcXEnA", cancellationToken: ct)
    .continueOnUi(userId -> {
        // User logged in, use user's ID here.
    })

val userId = userManager.users[0]
// Fetch information about the user using the ID

// In the `willFinishLaunchingWithOptions` callback in the app delegate:

// Build service factory
self.tapkeyServiceFactory = TKMServiceFactoryBuilder()
    .setTokenRefreshHandler(SampleTokenRefreshHandler())
    .build()

// Sample token refresh handler implementation

import RxSwift
import TapkeyMobileLib

class SampleTokenRefreshHandler: TKMTokenRefreshHandler {

    func refreshAuthenticationAsync(userId: String, cancellationToken: TKMCancellationToken) -> TKMPromise<String> {
        let promiseSource = TKMPromiseSource<String>()

        let accessToken = getNewTapkeyAccessTokenFromCustomApplicationLogic()

        // OK:
        promiseSource.setResult(value)

        // Or, in case no access token could be obtained:
        promiseSource.setError(TKMError(errorDescriptor: TKMErrorDescriptor(
                code: TKMAuthenticationHandlerErrorCodes.TokenRefreshFailed,
                message: "No new token can be obtained.",
                details: nil)))

        return promiseSource.promise
    }

    func onRefreshFailed(userId: String) {
        /*
         * Will be called if re-authentication failed and a manual call to
         * userManager.updateAccessToken() is required.
         */
    }
}

TKMBleLockScanner bleLockScanner = tapkeyServiceFactory.bleLockScanner

// Returns an observer registration to stop scanning once finished.
bleScanObserverRegistration = bleLockScanner.startForegroundScan()

// Listen for Tapkey locks coming into or leaving range.
nearbyLocksObserverRegistration = bleLockScanner.observable
    .addObserver(locks -> {
        // Handle nearby locks here, e.g. present them to the user.
    })

// Alternatively, the locks property can be used to get a list of nearby locks in this moment.
nearbyLocks = bleLockScanner.locks

// Check if a specific lock is nearby.
bleLockScanner.isLockNearby(physicalLockId: physicalLockId)

// Stop scanning for nearby locks.
if self.nearbyLocksObserverRegistration != nil {
    self.nearbyLocksObserverRegistration!.close()
    self.nearbyLocksObserverRegistration = nil
}

let ct = TKMCancellationTokens.fromTimeout(timeoutMs: 15000)

// Use the BLE lock communicator to send a command to the lock
return bleLockCommunicator.executeCommandAsync(
                bluetoothAddress: bluetoothAddress,
                physicalLockId: physicalLockId,
                commandFunc: { tlcpConnection -> TKMPromise<TKMCommandResult> in

                    let triggerLockCommand = TKMDefaultTriggerLockCommandBuilder()
                            .build()

                    // Pass the TLCP connection to the command execution facade
                    return self.commandExecutionFacade!.executeStandardCommandAsync(
                        tlcpConnection,
                        command: triggerLockCommand,
                        cancellationToken: ct)
                },
                cancellationToken: ct)

    // Process the command's result
    .continueOnUi({ commandResult in
        let code: TKMCommandResult.TKMCommandResultCode = commandResult?.code ??
                TKMCommandResult.TKMCommandResultCode.technicalError

        switch code {
        case TKMCommandResult.TKMCommandResultCode.ok:
            return true
        default:
            return false
        }
    })
    .catchOnUi({ (e: TKMAsyncError) -> Bool in

        let syncError = e.syncSrcError

        // A TKMRuntimeError.bleInconsistencyError indicates that the bluetooth chip of the lock
        // did not response as expected and should not happen. But the iPhone is known to cache some
        // bluetooth connection specific cofigurations which might cause issues when the bluetooth
        // configuration of the lock was changed during an firmware upgrade.
        // In such very rare and unexpected cases a restart of the iphone should resolve the issue.
        if case TKMRuntimeError.bleInconsistencyError(_) = syncError {
            NSLog("Trigger lock failed because of a bleInconsistencyError")
            // Inform the user that an unexpected happend and a restart of the iphone might help.
            return false
        } 

        NSLog("Trigger lock failed")
        return false
    })

class CustomLogger: TKMLogger {
    func println(priority: Int32, tag: String, msg: String, error: Error?) {
        // Custom logging implementation
    }
}

TKMLogs.VERBOSE
TKMLogs.DEBUG
TKMLogs.INFO
TKMLogs.WARN
TKMLogs.ERROR

func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {

    TKMLogs.setLogger(CustomLogger())

        self.tapkeyServiceFactory = TKMServiceFactoryBuilder()
            ...
            .build()

        ...
  }