Brtdku

I have a 3rd-party SDK where architecture is like this:

• I call a method of the service (lets call it TheirService)


• Once that method completes, a delegate of that service (lets call it TheirServiceDelegate will receive a notification onSuccess if call succeeds or onFailure if it fails.

The problem with that is that methods of TheirService are dependant on each other, so I end up having a "chain reaction", where each next method of TheirService is called from previous callback.

Note that TheirService is single threaded, and is really picky about previous method to be complete before I can start the next one.

Currently my interactions with the service look like this:

protocol MyClientListener { 

    notifyOnFailure()

    notifyOnResult(result: SomeObject)

}



class MyClient: TheirServiceDelegate {



    static let instance = MyClient()



    let myService = TheirService()

    var myResult: SomeObject?

    var resultListener: MyClientListener



    private init() { }



    func start(resultListener: MyClientListener) {

        self.resultListener = resultListener

        myService.initialize()

    }



    // TheirServiceDelegate method

    func onInitializeSuccess() {

        myService.bootstrap()

    }



    // TheirServiceDelegate method

    func onBootstrapSuccess() {

        myService.login(user, password)

    }



    // TheirServiceDelegate method

    func onLoginSuccess() {

        myService.doSomethingUsefulStep1()

    }



    // TheirServiceDelegate method

    func onDoSomethingUsefulStep1Success() {

        myService.doSomethingUsefulStep2()

    }



    // TheirServiceDelegate method

    func onDoSomethingUsefulStep2Success(result: SomeObject) {

        // ah, look, now I have some object I actually wanted!

        resultListener.notifyOnResult(result)

    }

}

I also have to deal with failure case for each of them. And I cannot skip or change the order of steps, which creates some sort of awkward state machine.

Instead i would like to interact with service via logical functions, that complete certain stages of the process from end to end, waiting for results between the steps:

 class MyClient {



    static let instance = MyClient()



    let myService = MyService()



    private init() { }



    func connect() throws {

        myService.initialize()

        // wait for success or failure, throw on failure

        myService.bootstrap()

        // wait for success or failure, throw on failure

        myService.login(user, password)

        // wait for success or failure, throw on failure

    }



    func doSomethingUseful() -> SomeObject {

        myService.doSomethingUsefulStep1()

        // wait for success or failure, throw on failure

        myService.doSomethingUsefulStep2()

        // wait for success or failure, throw on failure

        // on success, it will get an object it could return

    }

Called like this:

try MyClient.instance.connect()

let x = try MyClient.instance.doSomethingUseful()

So is there any way to turn "wait for success or failure" comment into actual code that waits for that single-threaded service to call back? And where a delegate would fit in that case?