An iOS7 and iOS8 simple alert

http://coding.tabasoft.it/ios/an-ios7-and-ios8-simple-alert/

In iOS8 the code to show a simple alert to the user is completely changed. UIAlertView is now deprecated:

The new class is UIAlertController and it is not complex to use (more in a minute). But we also want to support our iOS7 users, so wouldn’t it be nice to have a single class handling the different code? This is what we are going to create in this post.

The old way

To show a simple alert with an “OK” button in iOS7 we use this code:

Swift

1

2

3

let alert:UIAlertView = UIAlertView(title: "Alert", message: "I'm an iOS7 alert", delegate: self, cancelButtonTitle: "OK")

alert.delegate = self

alert.show()

Then we conform our class to the UIAlertViewDelegate protocol and add the method:

Swift

1

2

3

funcalertView(alertView:UIAlertView,clickedButtonAtIndexbuttonIndex:Int){

    println("ok button clicked")

}

This method is called when the button “ok” is pressed. Very simple code and the result is:

This code works right in iOS7 and iOS8 (but it is deprecated in iOS8).

The new way

The new way to do this is in iOS8 is to allocate an UIAlertController, add to it an action relative to the button “OK” and then present the controller using presentViewController.

Swift

1

2

3

4

5

6

let alert:UIAlertController = UIAlertController(title: "Alert", message: "I'm an iOS8 alert", preferredStyle:.Alert)

alert.addAction(UIAlertAction(title: "OK", style: .Default, handler: { (action: UIAlertAction!) in

    

    println("ok button clicked")

}))

self.presentViewController(alert, animated:true, completion:nil);

The result is identical to the previous:

Two notes about the iOS8 code:

• If you run it in iOS7 you cause a crash, so this can be used only if your running device has a system >= iOS8
• A curiosity: in iOS7 you could show an alert from inside viewDidLoad. Now, if you try this, you get a message in the console “Warning: Attempt to present <UIAlertController: 0x7fb219733510> on <ViewController: 0x7fb2196625d0> whose view is not in the window hierarchy!” and nothing happens. It seems that the alert is now a controller and the controller hierarchy is not yet ready. I think this is not a problem and you should not show an alert from viewDidLoad anyway. I showed the alert from the viewDidAppear method.

A single multi-system Alert object

Now we want to create our class that hides the different implementation from our app.

Let’s call it SevenEightAlert. We will invoke it with the common code:

Swift

1

2

3

4

5

6

7

8

overridefuncviewDidAppear(animated:Bool){

    super.viewDidAppear(animated)

    SevenEightAlert().show("Alert",message:"I'm an iOS7 and iOS8 alert",viewController:self,okAction:{

        

        ()->()in

        println("alert dismissed")

    })

}

The implementation

In our class we ask for the current version of the system using UIDevice.currentDevice().systemVersion and execute different code depending on it:

Swift

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

public class SevenEightAlert : NSObject, UIAlertViewDelegate {

 

    var okAction : (()->())?

    

    public func alertView(alertView: UIAlertView, clickedButtonAtIndex buttonIndex: Int) {

        

        if let _okaction = self.okAction {

            _okaction()

        }

    }

    

    public func show(title : String, message : String, viewController : UIViewController, okAction : (()->())? = nil) {

        

        let version:NSString = UIDevice.currentDevice().systemVersion as NSString;

 

        if  version.doubleValue >= 8 {

            let alert:UIAlertController = UIAlertController(title: title, message: message, preferredStyle:.Alert)

            alert.addAction(UIAlertAction(title: "OK", style: .Default, handler: { (action: UIAlertAction!) in

                

                if let _okAction = okAction {

                    

                    _okAction()

                }

            }))

            viewController.presentViewController(alert, animated:true, completion:nil);

            

        } else {

            let alert:UIAlertView = UIAlertView(title: title, message: message, delegate: nil, cancelButtonTitle: "OK")

            self.okAction = okAction

            alert.delegate = self

            alert.show()

        }

    }

}

Note that for iOS7 we save the closure passed as the third parameter in a property in order to use it later, in the alertView method of the UIAlertViewDelegate.

This code works perfectly on iOS8: we see the alert, press OK and see the log in the console (“alert dismissed”) and the alert disappear graciously.

But when we run it on iOS7 the app just … crashes (with a bad SIGABRT signal). Why?

Alert is Asynchronous

In viewDidAppear we create an instance of SevenEightAlert (calling SevenEightAlert()), then we call show on it and exit from the function. At the time the closure is called (when we press back, some seconds after) that instance does not exist anymore. But that instance was also the delegate of our UIAlertView (remember “delegate = self”) so the app crashes trying to call a delegate object that does not exist anymore.

Not a simple problem, we should try to extend the life of that instance more after the method viewDidAppearreturns. How we can do this?

Welcome the associated object

In iOS we can associate an object to another object.

This is a feature of the Objective-C 2.0 runtime, useful when we want to add a property to another object (of which we don’t have the code), something we cannot do with a category (or swift extension).

To read more about associated object start from this apple document.

If we use associated objects we also extend the length of the life of the object we attach to the length of the life of the object attached (as if it would be a property).

To use associated object we must extend NSObject (because it uses theObjective-C 2.0 runtime).

In the SevenEightAlert.show method, if the system is <= 7 and the action is not nil, we associate ourself to the calling view controller using the objc runtime function objc_setAssociatedObject:

Swift

1

2

3

4

5

// extend my life please

ifokAction!=nil{

    assocViewController=viewController

    objc_setAssociatedObject(viewController,&assocObjectHandle,self,objc_AssociationPolicy(OBJC_ASSOCIATION_RETAIN_NONATOMIC))

}

Having declared the two properties:

Swift

1

2

3

4

// Declare a global var to produce a unique address as the assoc object handle

private var assocObjectHandle: UInt8 = 0

// The current view controller we associate to

private var assocViewController: UIViewController?

(assocObjectHandle is simply a key we use as a reference of the association)

We then remove the association after the closure execution in the delegate’s alertView using objc_setAssociatedObject:

Swift

1

2

3

4

ifassocViewController!=nil{

    objc_setAssociatedObject(assocViewController,&assocObjectHandle,nil,objc_AssociationPolicy(OBJC_ASSOCIATION_RETAIN_NONATOMIC));

    assocViewController=nil

}

And now the code works right also for iOS7 and the callback action is called when the user press “OK”.

You can find the complete code of the class in the GitHub project SevenEightAlert.

And, as usual, if you have comments please feel free to contribute.