Wait for asynchronous request result

I would like somehow to asynchronously validate the pin in ABPadLockScreen since pins are not saved on the device. I’m using Alamofire for http requests along with PromiseKit to have promises.

I have tried to use AwaitKit but the problem is that i get into a deadlock.

  • Best approach to update managed objects from async web services responses?
  • API JSON & UIPageViewController optional Nil
  • Alamofire returns wrong encoding
  • Return value after Alamofire dowloaded data
  • How to pass dictionary as a parameter in the method in Swift?
  • How to get response headers when using Alamofire in Swift?
  • I have also tried to use semaphore as well, but the result is the same. Since i can’t change the ABPadLock method to accommodate something like a completion handler i need some solution, it doesn’t matter if it blocks the main thread, just that it works.

    Alamofire request method:

    public func loginAsync(pinCode: String?, apiPath: String?) -> Promise<LoginResult>{
        return Promise { fullfil, reject in
            let params = [
                "Pin": pinCode!
            ]
    
            Alamofire.request(.POST, "\(baseUrl!)/\(apiPath!)", parameters: params).responseObject{(response: Response<LoginResult, NSError>) in
                let serverResponse = response.response
    
                if serverResponse!.statusCode != 200 {
                    reject(NSError(domain: "http", code: serverResponse!.statusCode, userInfo: nil))
                }
    
                if let loginResult = response.result.value {
                    fullfil(loginResult)
                }
            }
        }
    }
    

    ABPadLockScreen pin validation method:

    public func padLockScreenViewController(padLockScreenViewController: ABPadLockScreenViewController!, validatePin pin: String!) -> Bool {
        let pinCode = pin!
        let defaults = NSUserDefaults.standardUserDefaults()
        let serverUrl = defaults.stringForKey(Util.serverUrlKey)
        let service = AirpharmService(baseUrl: serverUrl)
    
        service.loginAsync(pinCode, apiPath: "sw/airpharm/login").then { loginResult -> Void in
            if loginResult.code == HTTPStatusCode.OK {
                AirpharmService.id = loginResult.result!.id
            }
        }
    
        return false // how do i get the result of above async method here?
    }
    

    With semaphore:

    public func padLockScreenViewController(padLockScreenViewController: ABPadLockScreenViewController!, validatePin pin: String!) -> Bool {
    
        var loginResult: LoginResult?
    
        let defaults = NSUserDefaults.standardUserDefaults()
    
        let baseUrl = defaults.stringForKey(Util.serverUrlKey)
    
        let service = AirpharmService(baseUrl: baseUrl)
    
        let semaphore: dispatch_semaphore_t = dispatch_semaphore_create(0)
    
        service.loginAsync(pin, apiPath: "sw/airpharm/login").then { loginResultRaw -> Void in
            loginResult = loginResultRaw
            dispatch_semaphore_signal(semaphore)//after a suggestion from Josip B.
        }
    
        dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER)
    
        return loginResult != nil // rudimentary check for now
    }
    

    EDIT:

    After a suggestion from Josip B. i added semaphore signal in then, but it still doesn’t work

    AirpharmService is a class that contains a static property called id, and the Alamofire request method.

    ABPadLockScreen pin validation is done on main thread in a ViewController

    SOLVED EDIT:

    Thanks to everyone for being so patient with me and my, not so good, knowledge of swift and iOS. There are a lot of good answers here and in the end i just went with, in my opinion, simplest solution. I listened to Losiowaty-s suggestion; implemented a spinner and manually dismissed the lock screen when i get the response from the server. I’ve used a SwiftSpinner. The final solution looked like this:

    public func padLockScreenViewController(padLockScreenViewController: ABPadLockScreenViewController!, validatePin pin: String!) -> Bool {
        let defaults = NSUserDefaults.standardUserDefaults()
        let baseUrl = defaults.stringForKey(Util.serverUrlKey)
    
        let service = AirpharmService(baseUrl: baseUrl)
        SwiftSpinner.show("Logging in. Please wait...")
        service.loginAsync(pin, apiPath: "sw/airpharm/login").then { loginResult -> Void in
            if loginResult.code == HTTPStatusCode.OK {
                SwiftSpinner.hide()
                AirpharmService.id = loginResult.result!.id
                self.unlockWasSuccessfulForPadLockScreenViewController(padLockScreenViewController)
            } else if loginResult.code == HTTPStatusCode.Unauthorized {
                let toast = JLToast.makeText("Invalid pin, please try again", duration: 5)
                toast.show()
                SwiftSpinner.hide()
            } else {
                let toast = JLToast.makeText("\(loginResult.code) sent from server. Please try again.", duration: 5)
                toast.show()
                SwiftSpinner.hide()
            }
        }.error { error in
            let toast = JLToast.makeText("\((error as NSError).code) sent from server. Please try again.", duration: 5)
            toast.show()
            SwiftSpinner.hide()
        }
    
        return false
    }
    

    6 Solutions Collect From Internet About “Wait for asynchronous request result”

    It’s great that a lot of people tried to help you make your asynchronous call synchronous. Personally I agree with @OOPer and his comment that you should redesign your code, especially after looking through ABPadLockScreen code. It seems they don’t support asynchronous pin verification, which is a shame. Also it seems from their github repo that the original author has abandoned the project, for the time being at least.

    I’d attempt to solve your issue like this :

    public func padLockScreenViewController(padLockScreenViewController: ABPadLockScreenViewController!, validatePin pin: String!) -> Bool {
        let pinCode = pin!
        let defaults = NSUserDefaults.standardUserDefaults()
        let serverUrl = defaults.stringForKey(Util.serverUrlKey)
        let service = AirpharmService(baseUrl: serverUrl)
    
        service.loginAsync(pinCode, apiPath: "sw/airpharm/login").then { loginResult -> Void in
            if loginResult.code == HTTPStatusCode.OK {
                AirpharmService.id = loginResult.result!.id
                self.handleLoginOk()
            } else {
                self.handleLoginFailed()
            }
        }
    
        // disable interaction on padlock screen 
        // indicate to user that an async operation is going on, show a spinner
    
        return false // always return false here
    }
    
    func handleLoginOk() {
        // dismiss the ABPadlockScreenViewController manually
    }
    
    func handleLoginFailed() {
        // dismiss the spinner indicating the async operation
        // restore user interaction to padlock screen
    }
    

    With this approach your users will know that something is going on (the spinner, you can use for example SVProgressHUD as a drop-in solution) and that the app didn’t hang. It is quite important, ux-wise, as users with poor connection could get frustrated thinking the app hanged and close it.
    There is a potential problem though – if the padlock screen shows some kind of “wrong pin” message when you return false from the delegate method, it could be visible to the user creating some confusion. Now this can be tackled by making/positioning the spinner so that it obscures the message, though this is a very crude and unelegant solution. On the other hand, maybe it can be customised enough so that no message gets shown, and you’d display your own alert after server side verification.

    Let me know what you think about this!

    … it doesn’t matter if it blocks the main thread… but the problem is that i get into a deadlock.

    One problem could be it is blocking the main thread with dispatch_semaphore_wait, so the Alamofire response never get a chance to run on the main thread and you’re deadlocking.

    The solution to this could be create another queue on which the Alamofire completion handler is dispatched.

    For example:

    If you making a request like this:

    Alamofire.request(.GET, "https://jsonplaceholder.typicode.com/posts").validate().responseData() { response in
        print(response.result.value)
    }
    

    You can modify this call to dispatch completion handler in your defined queue like this:

    let queue = dispatch_queue_create("myQueue", DISPATCH_QUEUE_CONCURRENT)
    
    let request = Alamofire.request(.GET, "https://jsonplaceholder.typicode.com/posts", parameters: .None).validate()
    request.response(queue: queue, responseSerializer: Request.JSONResponseSerializer(options: .AllowFragments)) { response in
        print(response.result.value)
    }
    

    A simplified version for test.

    //MARK: Lock Screen Delegate
    func padLockScreenViewController(padLockScreenViewController: ABPadLockScreenViewController!, validatePin pin: String!) -> Bool {
        print("Validating Pin \(pin)")
    
        let queue = dispatch_queue_create("myQueue", DISPATCH_QUEUE_CONCURRENT)
        let semaphore = dispatch_semaphore_create(0)
    
        let request = Alamofire.request(.GET, "https://jsonplaceholder.typicode.com/posts", parameters: .None).validate()
        request.response(queue: queue, responseSerializer: Request.JSONResponseSerializer(options: .AllowFragments)) { response in
            print(response.result.value)
            //isPinValid = ???
            dispatch_semaphore_signal(semaphore);
        }
    
        dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER)
    
        return thePin == pin
        //return isPinValid
    }
    

    Try this:

    add dispatch_group:

    static let serviceGroup = dispatch_group_create();
    

    Then after calling the function, wait for this group:

    public func padLockScreenViewController(padLockScreenViewController: ABPadLockScreenViewController!, validatePin pin: String!) -> Bool {
    
        var loginResult: LoginResult?
    
        let defaults = NSUserDefaults.standardUserDefaults()
    
        let baseUrl = defaults.stringForKey(Util.serverUrlKey)
    
        let service = AirpharmService(baseUrl: baseUrl)
    
        let semaphore: dispatch_semaphore_t = dispatch_semaphore_create(0)
    
        service.loginAsync(pin, apiPath: "sw/airpharm/login").then { loginResultRaw -> Void in
            loginResult = loginResultRaw
        }
    
        dispatch_group_wait(yourClass.serviceGroup, DISPATCH_TIME_FOREVER);
    
        return loginResult != nil // rudimentary check for now
    }
    

    And release the group after the function returns an answer:

    public func loginAsync(pinCode: String?, apiPath: String?) -> Promise<LoginResult>{
        return Promise { fullfil, reject in
            let params = [
                "Pin": pinCode!
            ]
    
            Alamofire.request(.POST, "\(baseUrl!)/\(apiPath!)", parameters: params).responseObject{(response: Response<LoginResult, NSError>) in
                let serverResponse = response.response
    
                if serverResponse!.statusCode != 200 {
                    reject(NSError(domain: "http", code: serverResponse!.statusCode, userInfo: nil))
                }
    
                if let loginResult = response.result.value {
                    fullfil(loginResult)
                }
                dispatch_group_leave(yourClass.serviceGroup)
            }
        }
    }
    

    Based on the comments we exchanged, it sounds like the endless wait when you tried using a semaphore is because the semaphore signal is never being sent. Let’s try to simplify this down to the minimum code needed to test:

    public func padLockScreenViewController(padLockScreenViewController: ABPadLockScreenViewController!, validatePin pin: String!) -> Bool {
    
        var success = false
        let defaults = NSUserDefaults.standardUserDefaults()
        let baseUrl = defaults.stringForKey(Util.serverUrlKey)
        let semaphore: dispatch_semaphore_t = dispatch_semaphore_create(0)
    
        let params = ["Pin": pin]
    
        Alamofire.request(.POST, "\(baseUrl!)/sw/airpharm/login", parameters: params).responseObject {
            (response: Response<LoginResult, NSError>) in
    
            if let loginResult = response.result.value where loginResult.code == HTTPStatusCode.OK {
                AirpharmService.id = loginResult.result!.id
                success = true
            }
    
            dispatch_semaphore_signal(semaphore)
        }
    
        dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER)
        return success
    }
    

    This should either:

    1. crash because you are force unwrapping several variables (e.g.baseUrl!, loginResult.result!.id, etc. and one of them is nil

    2. return true if you got a valid LoginResult

    3. return false if you didn’t get a valid LoginResult

    But theoretically, it shouldn’t deadlock.

    I’ve tried to make the ABPadLockScreen support asynchronous pin verification.

    I’ve modified ABPadLockScreenViewController. Added a new ABPadLockScreenViewControllerDelegate protocol method shouldValidatePinManuallyForPadLockScreenViewController:.

    /**
      Call when pin validation is needed manually
      Call processUnlock method to validate manually if return true from this method
      */
     - (BOOL)shouldValidatePinManuallyForPadLockScreenViewController:(ABPadLockScreenViewController *)padLockScreenViewController;
    

    Added a new instance method processUnlock

    - (void)processUnlock {
        if ([self isPinValid:self.currentPin]) {
            [self unlockScreen];
        } else {
            [self processFailure];
        }
    }
    

    Modified the processPin method

    - (void)processPin {
    
        if ([self.lockScreenDelegate respondsToSelector:@selector(shouldValidatePinManuallyForPadLockScreenViewController:)]) {
            if ([self.lockScreenDelegate shouldValidatePinManuallyForPadLockScreenViewController:self]) {
                return;
            }
        }
    
        [self processUnlock];
    }
    

    Now in your viewController implement shouldValidatePinManuallyForPadLockScreenViewController

    func shouldValidatePinManuallyForPadLockScreenViewController(padLockScreenViewController: ABPadLockScreenViewController!) -> Bool {
    
        print("Requesting server...")
        Alamofire.request(.GET, "https://jsonplaceholder.typicode.com/posts").validate().responseJSON() { response in
            //isPinValid = ???
            print("Request complete")
            padLockScreenViewController.processUnlock()
        }
    
        return true
    }
    

    Made a demo project at https://github.com/rishi420/ABPadLockScreen

    See the swift demo example.

    I think semaphore can help. Here is a usage example:

    - (NSArray *)tasksForKeyPath:(NSString *)keyPath {
        __block NSArray *tasks = nil;
        dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
        [self.session getTasksWithCompletionHandler:^(NSArray *dataTasks, NSArray *uploadTasks, NSArray *downloadTasks) {
            if ([keyPath isEqualToString:NSStringFromSelector(@selector(dataTasks))]) {
                tasks = dataTasks;
            } else if ([keyPath isEqualToString:NSStringFromSelector(@selector(uploadTasks))]) {
                tasks = uploadTasks;
            } else if ([keyPath isEqualToString:NSStringFromSelector(@selector(downloadTasks))]) {
                tasks = downloadTasks;
            } else if ([keyPath isEqualToString:NSStringFromSelector(@selector(tasks))]) {
                tasks = [@[dataTasks, uploadTasks, downloadTasks] valueForKeyPath:@"@unionOfArrays.self"];
            }
    
            dispatch_semaphore_signal(semaphore);
        }];
    
        dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
    
        return tasks;
    }
    

    This is a function comes from AFNetworking. The method getTasksWithCompletionHandler is a method of NSURLSession which will

    Asynchronously calls a completion callback with all data, upload, and download tasks in a session.

    Semaphore_wait will ensure that tasks has be assigned with proper value. This way you can get the asynchronously request result.