Shyngys Kassymov

iOS Custom Keyboard Guide

2018-05-26T00:00:00+00:00

Starting with iOS 8, Apple introduced iOS App Extensions which includes Custom Keyboard functionality. From that moment developers are able to create their own implementation of keyboards which users can use instead of system one. This the win for both sides.

The API which Apple provides to build custom keyboard is not big and it’s easy to learn it quickly, but there are many caveats you will meet to build really user-friendly one. Therefore in this article, you will find additional information on specific topics which I hope will speed up your custom keyboard development process.

I assume that you already know the basics of iOS and Objective-C (or Swift) programming language. The knowledge of iOS Keyboard extension development is preferred but not mandatory. However, if you’re not familiar with it the best place to start is official documentation. Also, the provided solutions work in iOS 10 and above. Some things may work and can be true for older versions as well.

Please note that solutions will not be rejected by Apple review team because they are already included in my App Store shipped application. Therefore do not hesitate to include these code recipes to your project.

Understanding the permissions

Many iOS developers including me wrongly understand what does the RequestsOpenAccess flag do in Info.plist file.

As the documentation says:

RequestsOpenAccess — This Boolean value, NO by default, expresses whether a custom keyboard wants to enlarge its sandbox beyond that needed for a basic keyboard.

In other words, by setting the value to YES you will be able to use the below capabilities:

Access to Location Services, the Address Book database, and the Camera Roll
Option to use a shared container with the keyboard containing app
Play sound on key press
Make network requests
Use UIPasteboard
Access to iCloud, Game Center and In-App Purchase
Work with managed apps

Right? Yes and no. Some of these capabilities can be accessed after you set this flag to YES and others will still need a user to enable this by hand.

Specifically, after enabling RequestsOpenAccess flag you will get access to these features for free:

Play sound on key press
Partially use a shared container. You will be able to read and write from containing app but the extension will be able only to read.

Other features can be accessed only if the user enabled the Allow Full Access flag in iOS device settings for your keyboard.

How to know if a user allowed a full access?

After reading the above paragraph you may ask then how to check if a user allowed a full access?

Well, there is a main tricky method to check for a full access. It tries to call UIPasteboard class methods which are available only if user allowed full access to your keyboard. If methods work then your extension has a full access and opposite otherwise.

Note that starting from iOS 11 there is a variable called hasFullAccess in UIInputViewController instances which is already returning the needed result. However, for previous iOS versions, you need to implement that function by yourself.

Here is a sample implementation in Objective-C:

- (BOOL)openAccessIsEnabled {
    BOOL hasFullAccess = false;
    if (@available(iOS 11.0, *)) {
        hasFullAccess = [self hasFullAccess];
    } else {
        if (@available(iOS 10.0, *)) {
            UIPasteboard *pasty = [UIPasteboard generalPasteboard];
            NSString *previousString = pasty.string;
            pasty.string = @"TEST";
            if (pasty.hasStrings) {
                hasFullAccess = true;
                pasty.string = previousString;
            }
        } else if ([UIPasteboard generalPasteboard]) {
            hasFullAccess = true;
        }
    }

    return hasFullAccess;
}

Swift version:

override var hasFullAccess: Bool {
    if #available(iOS 11.0, *) {
        return super.hasFullAccess
    }
    if #available(iOS 10.0, *) {
        let original: String? = UIPasteboard.general.string
        UIPasteboard.general.string = " "
        let val: Bool = UIPasteboard.general.hasStrings
        if let str = original {
            UIPasteboard.general.string = str
        }
        return val
    }
    return UIPasteboard.general.isKind(of: UIPasteboard.self)
}

Another note is that that this method works only from extension side. Unfortunately, I didn’t find the way to check full access from the containing app. If you have the better solution you can share it with others in comments :)

Also, if you’re checking the full access very often in iOS 10 and older versions then it’s good to create a variable which will contain the cached version of above method.

Is keyboard on?

Next popular question is to know from containing app if your iOS Keyboard extension is enabled in Settings. There is no official way to do this. However, there is a method proposed in Stack Overflow which works like a charm.

Here it is (Objective-C version):

- (BOOL)isKeyboardEnabled {
    NSArray *keyboards = [[NSUserDefaults standardUserDefaults] objectForKey:@"AppleKeyboards"];
    NSUInteger index = [keyboards indexOfObject:@"YOUR_KEYBOARD_EXTENSION_BUNDLE_ID"];

    return index != NSNotFound;
}

Swift version:

func isKeyboardEnabled() -> Bool {
    guard let keyboards = UserDefaults.standard.object(forKey: "AppleKeyboards") as? [String] else {
        return false
    }
    return keyboards.contains("YOUR_KEYBOARD_EXTENSION_BUNDLE_ID")
}

As you may guess the AppleKeyboards key in standard NSUserDefaults will return array of bundle ids of all enabled keyboards. The only thing to do there is to check if the list contains your keyboard extension bundle id.

Is keyboard currently active?

As you may see the iOS Keyboard extension is very limited. There is no direct way to communicate with your containing app and the extension. You may create an App Group and save your app settings in NSUserDefaults like so:

NSUserDefaults *userDefaults = [[NSUserDefaults alloc] initWithSuiteName:@"YOUR_APP_GROUP_ID"];
[userDefaults setObject:@"SOME_VALUE" forKey:@"SOME_KEY"];
[userDefaults synchronize];

But if full access is not given it will be one-way communication. Specifically, from you containing app to the keyboard extension.

To overcome the problem, you may use deep linking to send events from extension to your containing app. Use this method carefully because it’ll open and switch to containing app if keyboard extension currently is shown in another app.

For example, if you need to know when your keyboard extension will be visible/activated in order to show a welcome message or do other action you can do the following:

Create a custom URL scheme, i.e with identifier mykeyboard.

To catch the link call implement the - (BOOL)application:(UIApplication *)app openURL:(NSURL *)url options:(NSDictionary<UIApplicationOpenURLOptionsKey, id> *)options; method in containing app AppDelegate class:

 - (BOOL)application:(UIApplication *)app openURL:(NSURL *)url options:(NSDictionary<UIApplicationOpenURLOptionsKey,id> *)options {
     if ([url.absoluteString isEqualToString:@"SET_KEYBOARD_ACTIVATED"]) {
         [[NSNotificationCenter defaultCenter] postNotificationName:@"KEYBOARD_ACTIVATED_NOTIFICATION" object:nil];
         return true;
     }
     return false;
 }

Swift version:

 func application(_ app: UIApplication, open url: URL, options: [UIApplicationOpenURLOptionsKey : Any] = [:]) -> Bool {
     if url.absoluteString == "SET_KEYBOARD_ACTIVATED" {
         NotificationCenter.default.post(name: NSNotification.Name(rawValue: "KEYBOARD_ACTIVATED_NOTIFICATION"), object: nil)
         return true;
     }
     return false;
 }

Get shared UIApplication from keyboard extension and call the needed URL.

 NSUserDefaults *userDefaults = [[NSUserDefaults alloc] initWithSuiteName:@"YOUR_APP_GROUP_ID"];

 if (![userDefaults boolForKey:@"IS_KEYBOARD_ACTIVATED"]) {
     UIResponder *responder = self;
     NSURL *url = [NSURL URLWithString:@"SET_KEYBOARD_ACTIVATED"];
     while ((responder = [responder nextResponder]) != nil) {
         if ([responder respondsToSelector:@selector(openURL:)]) {
             [responder performSelector:@selector(openURL:) withObject:url];
         }
     }
 }

Swift version:

 let userDefaults = UserDefaults(suiteName: "YOUR_APP_GROUP_ID")
 let url = URL(string: "SET_KEYBOARD_ACTIVATED")

 if let isKeyboardActivated = userDefaults?.bool(forKey: "IS_KEYBOARD_ACTIVATED"),
     isKeyboardActivated,
     let aUrl = url {
     var responder: UIResponder? = self
     while responder != nil {
         if let application = responder as? UIApplication {
             application.perform("openURL:", with: aUrl)
         }
         responder = responder?.next
     }
 }

In above steps, we assume that:

The SET_KEYBOARD_ACTIVATED string value is your URL scheme. For example, mykeyboard://set_keyboard_activated.
KEYBOARD_ACTIVATED_NOTIFICATION is the name of notification you want to post.
YOUR_APP_GROUP_ID the unique identifier of your created App Group. For example, group.com.myapp.Keyboard.
IS_KEYBOARD_ACTIVATED in this sample is just a key in NSUserDefaults to know if the welcome message was shown before or not.

Open Settings

By knowing that some of the functionality in your iOS Keyboard extension will need a full access you may be interested in a way how to easily navigate users to your keyboard preferences in iOS Settings app.

Before asking for a full access the best practice is to explain why you need it and guarantee or show that you don’t use users keystrokes to get private data from them. Assuming you’ve already done it, let me show you the way how to open the Settings app and navigate to your keyboard preferences.

For iOS 11 and above we will use the UIApplicationOpenSettingsURLString key to open your app preferences in the Settings app. However, for below iOS versions, there is no way to directly open your app preferences in the Settings app. Instead, we can open Keyboard settings where a user can add your keyboard and allow full access. Do do this, first of all, you need to add a couple of additional URL schemes with identifiers App-Prefs and prefs. The App-Prefs will be used for iOS 10 and in other hand prefs will be used for iOS 9 and below.

Then we can start to implement the method which will navigate us to your keyboard settings:

- (void)openAppSettings {
    if (@available(iOS 11.0, *)) {
        [[UIApplication sharedApplication] openURL:[NSURL URLWithString:UIApplicationOpenSettingsURLString] options:@{} completionHandler:nil];
    } else if (@available(iOS 10.0, *)) {
        [[UIApplication sharedApplication] openURL:[NSURL URLWithString:@"App-Prefs:root=General&path=Keyboard/KEYBOARDS"] options:@{} completionHandler:nil];
    } else {
        [[UIApplication sharedApplication] openURL:[NSURL URLWithString:@"prefs:root=General&path=Keyboard/KEYBOARDS"] options:@{} completionHandler:nil];
    }
}

Swift version:

func openAppSettings() {
    var responder: UIResponder? = self
    var sharedApplication: UIResponder?
    while responder != nil {
        if let application = responder as? UIApplication {
            sharedApplication = application
            break
        }
        responder = responder?.next
    }

    guard let application = sharedApplication else { return }

    if #available(iOS 11.0, *) {
        application.perform("openURL:", with: URL(string: UIApplicationOpenSettingsURLString))
    } else {
        if #available(iOS 10.0, *) {
            application.perform("openURL:", with: URL(string: "App-Prefs:root=General&path=Keyboard/KEYBOARDS"))
        } else {
            application.perform("openURL:", with: URL(string: "prefs:root=General&path=Keyboard/KEYBOARDS"))
        }
    }
}

As you can see for iOS 10 and below the difference is very small. The path idea is in root=General&path=Keyboard/KEYBOARDS. The prefix like App-Prefs or prefs will open the Settings app. Then it will navigate to General section of Settings app. After it will open Keyboard preferences and in the end show us Keyboards settings. In that window, you will see a list of all enabled keyboards. A user will be able to add your keyboard to the list or by pressing on your keyboard option see the allow full access option to enable it.

The difference for iOS 11 is that you will be navigated directly to your app settings. The user will need then to press on Keyboards option in that window and then enable full access. There is a small detail. While testing sometimes your app settings not shown in the main Settings app list. To fix this you may need to close Settings app or in the worst scenario restart you simulator or the device. I didn’t encounter this problem in production.

Playing sound

As the official documentation says you can play key press sound using method of the UIDevice playInputClick. However, you are not limited. The playIntputClick plays only the sound of character keys. For other types of keys like space, delete, or shift you may want to use sounds like in default keyboard.

First of all, let’s add AudioToolbox framework, import it and then assume that you have these key types:

typedef enum KeyType: NSInteger {
    KeyTypeDefault,
    KeyTypeCapsLock,
    KeyTypeDelete,
    KeyTypeExtraSymbolsSwitch,
    KeyTypeSymbolsSwitch,
    KeyTypeLettersSwitch,
    KeyTypeNextKeyboard,
    KeyTypeEmojis,
    KeyTypeSpace,
    KeyTypePunctuations,
    KeyTypeReturn
} KeyType;

Swift version:

enum KeyType: Int {
    case defaultKey,
    capsLock,
    delete,
    extraSymbolsSwitch,
    symbolsSwitch,
    lettersSwitch,
    nextKeyboard,
    emojis,
    space,
    punctuations,
    returnKey
}

Then to play sounds like in the default keyboard you may implement function like this:

- (void)playSound:(KeyType)keyType {
    if (soundIsOn) {
        SystemSoundID clickPress = 1123;
        SystemSoundID deletePress = 1155;
        SystemSoundID modifierPress = 1156;

        SystemSoundID current = clickPress;

        if (keyType == KeyTypeDelete) {
            current = deletePress;
        } else if (keyType != KeyTypeDefault) {
            current = modifierPress;
        }

        // fallback for iOS 9 and below
        if (@available(iOS 10.0, *)) {
        } else {
            current = 1104;
        }
       dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
            AudioServicesPlaySystemSound(current);
        });
    }
}

Swift version:

func playSound(_ keyType: KeyType) {
    if soundIsOn {
        let clickPress: SystemSoundID = 1123;
        let deletePress: SystemSoundID = 1155;
        let modifierPress: SystemSoundID = 1156;

        var current: SystemSoundID = clickPress;

        if keyType == .delete {
            current = deletePress
        } else if keyType != .defaultKey {
            current = modifierPress
        }

        // fallback for iOS 9 and below
        if #available(iOS 10.0, *) {
        } else {
            current = 1104;
        }

        DispatchQueue.global().async {
            AudioServicesPlaySystemSound(current)
        }
    }
}

The SystemSoundID ids like 1123, 1155, and 1156 are present for iOS 10 and above. For older versions you may use id 1104.

Handing auto capitalization, text field and return key types

The best way to handle the auto capitalization and the change of text field or return key type is in UITextInputDelegate delegate method called -(void)textDidChange:(id<UITextInput>)textInput in your UIInputViewController instance class.

For example, like this:

- (void)textDidChange:(id<UITextInput>)textInput {
    if (self.textDocumentProxy && self.currentKeyboard.keyboardType != self.textDocumentProxy.keyboardType) {
        [self setKeyboardType];
    }
    if (self.textDocumentProxy && self.currentKeyboard.returnKeyType != self.textDocumentProxy.returnKeyType) {
        [self setReturnKeyType];
    }
    [self setCapsIfNeeded];
}

Swift version:

override func textDidChange(_ textInput: UITextInput?) {
    if textDocumentProxy && currentKeyboard.keyboardType != textDocumentProxy.keyboardType {
        setKeyboardType()
    }
    if textDocumentProxy && currentKeyboard.returnKeyType != textDocumentProxy.returnKeyType {
        setReturnKeyType()
    }
    setCapsIfNeeded()
}

In above sample code, the currentKeyboard is just a custom class that wraps keyboard logic and contains variables called keyboardType and returnKeyType which are instances of UIKeyboardType and UIReturnKeyType respectivetly. Methods like setKeyboardType and setReturnKeyType can be implemented differently. In best scenario they should change the interface of your keyboard properly regarding the text field and return key types.

In setCapsIfNeeded method you will need to do these three steps:

Check the UITextAutocapitalizationType property like this self.textDocumentProxy.autocapitalizationType
Get text before cursor like this self.textDocumentProxy.documentContextBeforeInput
Decide to use lower or upper case

Note, that you also need to set keyboard and return key types, and set correct capitalization in the beginning when you initialize the keyboard. For example, in - (void)viewDidLoad method.

Conclusion

I hope after reading this article you now know more information how to build your custom iOS Keyboard extension or have an idea how to solve your problems.

To build fully featured keyboard you will need also add functionality like auto correction, word suggestions, one-handed swipe typing and more. But these topics are big on their own and need a separate article.

To guide a little bit more I suggest also to explore UILexicon and UITextChecker classes API if you want to build auto correction and suggestion functionality with the iOS internal tools. But note, that these APIs are limited and in most scenarios you will need to implement auto correction and suggestion functionality by yourself.

Here are some useful links:

Official documentation
Tasty Imitation Keyboard - the custom iOS Keyboard extension which tries to imitate the default system keyboard.

Getting the frame of UIBarButtonItem

2017-09-21T00:00:00+00:00

In this post, I want to share my experience of finding the frame of UIBarButtonItem.

You probably already know that unfortunately UIBarButtonItem doesn’t subclass the UIView class and doesn’t contain frame property. There are some historical reasons for that. Therefore developers who need to get frame of UIBarButtonItem are using different hacks or ways to accomplish this task.

I couldn’t find the one solution which fully solves my problems. Therefore in the below paragraphs, you can find my approach for this uncommon issue and which is working on iOS 11.

UIViewController extension which I used to get the frame of UIBarButtonItem in UINavigationBar or UITolbar:

/* In UIViewController+UIBarButtonItemFrame.h */

#import <UIKit/UIKit.h>

#define SYSTEM_VERSION_LESS_THAN(v) ([[[UIDevice currentDevice] systemVersion] compare:v options:NSNumericSearch] == NSOrderedAscending)

@interface UIViewController (UIBarButtonItemFrame)

- (CGRect)frameForNavBarItem:(UIBarButtonItem *)item;
- (CGRect)frameForToolbarItem:(UIBarButtonItem *)item flexibleSpaceItem:(UIBarButtonItem *)flexibleSpaceItem;

@end


/* In UIViewController+UIBarButtonItemFrame.m */

#import "UIViewController+UIBarButtonItemFrame.h"

@implementation UIViewController (Extensions)

- (CGRect)frameForView:(UIView *)view {
    return [view convertRect:view.bounds toView:nil];;
}

- (void)buttonsForView:(UIView *)view buttons:(NSMutableArray<UIView *> *)buttons {
    for (UIView *subview in view.subviews) {
        if ([subview isKindOfClass:[UIControl class]]) {
            [buttons addObject:subview];
        } else {
            [self buttonsForView:subview buttons:buttons];
        }
    }
}

- (NSArray<UIControl *> *)buttonsForView:(UIView *)view {
    NSMutableArray *buttons = [[NSMutableArray alloc] init];
    [self buttonsForView:view buttons:buttons];

    if (SYSTEM_VERSION_LESS_THAN(@"11.0")) {
        [buttons sortUsingComparator:^NSComparisonResult(UIControl *obj1, UIControl *obj2) {
            if (obj1.frame.origin.x > obj2.frame.origin.x) {
                return NSOrderedDescending;
            } else if (obj1.frame.origin.x < obj2.frame.origin.x) {
                return NSOrderedAscending;
            }
            return NSOrderedSame;
        }];
    }

    return buttons;
}

- (CGRect)frameForNavBarItem:(UIBarButtonItem *)item {
    NSArray<UIControl *> *buttons = [self buttonsForView:self.navigationController.navigationBar];

    NSMutableArray *items = [NSMutableArray new];
    [items addObjectsFromArray:self.navigationItem.leftBarButtonItems];
    [items addObjectsFromArray:[[self.navigationItem.rightBarButtonItems reverseObjectEnumerator] allObjects]];

    NSUInteger index = [items indexOfObject:item];
    if (index < buttons.count) {
        UIView *view = buttons[index];
        return [self frameForView:view];
    }

    return [self frameForView:self.navigationController.navigationBar];
}

- (CGRect)frameForToolbarItem:(UIBarButtonItem *)item flexibleSpaceItem:(UIBarButtonItem *)flexibleSpaceItem {
    NSArray<UIControl *> *buttons = [self buttonsForView:self.navigationController.toolbar];

    NSMutableArray *toolbarItems = [NSMutableArray arrayWithArray:self.toolbarItems];
    NSMutableArray *itemsToRemove = [NSMutableArray new];
    for (UIBarButtonItem *barButtonItem in toolbarItems) {
        if (barButtonItem == flexibleSpaceItem) {
            [itemsToRemove addObject:barButtonItem];
        }
    }
    [toolbarItems removeObjectsInArray:itemsToRemove];

    NSUInteger index = [toolbarItems indexOfObject:item];
    if (index < buttons.count) {
        UIView *view = buttons[index];
        return [self frameForView:view];
    }

    return [self frameForView:self.navigationController.toolbar];
}

@end

- (CGRect)frameForView:(UIView *)view; - This method is straightforward. It returns the frame of UIView in device screen space.
- (void)buttonsForView:(UIView *)view buttons:(NSMutableArray<UIView *> *)buttons; - This method takes UINavigationBar or UIToolbar instance as a parameter and then iterates through their subviews until finds all subviews of UIControl subclass. In other words, this method will find all views of UIBarButtonItems.
- (void)buttonsForView:(UIView *)view - This method calls the previous one and returns the list of views in sorted order by x-axis.
- (CGRect)frameForNavBarItem:(UIBarButtonItem *)item - This method takes a parameter of type UIBarButtonItem, then calls our third method to get all views of UIBarButtonItems of UINavigationBar. After the method combines leftBarButtonItems and rightBarButtonItems to one array. Note that rightBarButtonItems are reversed, this decision was made after testing. Then the method simply tries to get the index of input UIBarButtonItem instance in the combined array, and if it is found and the index is smaller than the size of the array of views of UIBarButtonItems in UINavigationBar the method returns the corresponding view. Otherwise, the frame of whole UINavigationBar is returned.
- (CGRect)frameForToolbarItem:(UIBarButtonItem *)item flexibleSpaceItem:(UIBarButtonItem *)flexibleSpaceItem - This method is almost identical to 3rd one. The difference is that it takes UIToolbar to find views of UIBarButtonItems, and also removes unneeded UIBarButtonItems from toolbarItems. In my case, it was UIBarButtonItem with the type of UIBarButtonSystemItemFlexibleSpace. You can have another one(s).

Another thing to note is that I had a logic where UINavigationBar or UIToolbar items were changed over time. When I called the above methods after changing UIBarButtonItem list I noticed that the views were not created immediately (or maybe had zero frames). Therefore in that scenario, you will want to call methods to update the layout of UINavigationBar or UIToolbar before calling above methods. For example, like this:

[self setToolbarItems:SOME_ITEMS animated:false];

[self.navigationController.toolbar setNeedsDisplay];
[self.navigationController.toolbar setNeedsLayout];
[self.navigationController.toolbar layoutIfNeeded];

// then get frames

So, that was a description of my solution. It works nicely to solve my problems. I hope that solution will give you an idea of how to approach the problem of finding UIBarButtonItem frame.

Authentication with client private certificate using AFNetworking

2017-03-27T00:00:00+00:00

In this post, I want to share useful code snippet for authentication with client private certificate using AFNetworking. This is a combined solution which is built from few existing solutions found on Github.

Authentication is one of the most crucial parts of many iOS applications. In some cases, the application needs to do it using client private certificate.

Here I will show you how to solve the above problem using popular and one of the most used libraries in iOS applications - AFNetworking.

The good thing is that AFNetworking provides us with a block called setSessionDidReceiveAuthenticationChallengeBlock: to deal with such situation. We will use it and implement in such way so that as user credentials certificate data will be sent to the server.

First of all, let’s assume you have a simple API manager:

AFHTTPSessionManager *clientManager; // your API client

Subclass of AFHTTPSessionManager is also enough for this implementation.

Next, in one place where you create your API manager, we must set setSessionDidReceiveAuthenticationChallengeBlock: block.

[clientManager setSessionDidReceiveAuthenticationChallengeBlock:^NSURLSessionAuthChallengeDisposition(NSURLSession * _Nonnull session, NSURLAuthenticationChallenge * _Nonnull challenge, NSURLCredential *__autoreleasing  _Nullable * _Nullable credential) {
	// auth logic goes here
}];

As you can guess when the server will ask your API manager for authentication credentials this block will be fired.

NSURLSession *session - your client session, which you can use for example to cancel ongoing tasks and invalidate the current session.
NSURLAuthenticationChallenge *challenge - this parameter can be used to determine which kind of credential is needed to pass.
NSURLCredential *credential - this parameter is used to pass specific credentials back to the server.

Then we need to start to implement that block. Inside paste this snippet:

// This is checking the server certificate
if ([challenge.protectionSpace.authenticationMethod isEqualToString:NSURLAuthenticationMethodServerTrust]) {
    SecTrustResultType result;
    // This takes the serverTrust object and checkes it against your keychain
    SecTrustEvaluate(challenge.protectionSpace.serverTrust, &result);
    
    // If we want to ignore invalid server for certificates, we just accept the server
    if (result == kSecTrustResultProceed || result == kSecTrustResultUnspecified) {
        // When testing this against a trusted server I got kSecTrustResultUnspecified every time. But the other two match the description of a trusted server
        *credential = [NSURLCredential credentialForTrust:challenge.protectionSpace.serverTrust];
    }
    
    return NSURLSessionAuthChallengeUseCredential;
}

I kept the original comments because think they explain what is done here very well. In brief, this if statement checks trust or not to the server you are talking with and passes the credentials from Keychain if the trust is OK or is unspecified.

The next if statement will check if authentication challenge is asking for the client certificate. If it is, we just pass user certificate credentials.

if ([[challenge protectionSpace] authenticationMethod] == NSURLAuthenticationMethodClientCertificate) {
    // This handles authenticating the client certificate

    // Here you should pass reference for client private certificate, it can be done in many ways
    SecIdentityRef identityApp;
    SecCertificateRef certRef;
    SecIdentityCopyCertificate(identityApp, &certRef);
    
    SecCertificateRef certArray[1] = { certRef };
    CFArrayRef myCerts = CFArrayCreate(NULL, (void *)certArray, 1, NULL);
    CFRelease(certRef);
        
    NSURLCredential *userCredential = [NSURLCredential credentialWithIdentity:identityApp certificates:(__bridge NSArray *)myCerts persistence:NSURLCredentialPersistenceForSession];
    CFRelease(myCerts);
        
    *credential = userCredential;
        
    return NSURLSessionAuthChallengeUseCredential;
}

In the next condition, we look if authentication method is the default. In that situation, we can return NSURLSessionAuthChallengePerformDefaultHandling to use basic authentication or ignore it.

if ([[challenge protectionSpace] authenticationMethod] == NSURLAuthenticationMethodDefault || [[challenge protectionSpace] authenticationMethod] == NSURLAuthenticationMethodNTLM) {
    // For normal authentication based on username and password. This could be NTLM or Default.
    
    return NSURLSessionAuthChallengePerformDefaultHandling;
}

If none of above will be called we return NSURLSessionAuthChallengeCancelAuthenticationChallenge to cancel authentication process.

// If everything fails, we cancel the challenge.
return NSURLSessionAuthChallengeCancelAuthenticationChallenge;

So, this how looks minimal implementation of the client certificate based authentication. The final code will look like this:

AFHTTPSessionManager *clientManager; // your API client

[clientManager setSessionDidReceiveAuthenticationChallengeBlock:^NSURLSessionAuthChallengeDisposition(NSURLSession * _Nonnull session, NSURLAuthenticationChallenge * _Nonnull challenge, NSURLCredential *__autoreleasing  _Nullable * _Nullable credential) {
    // This is checking the server certificate
    if ([challenge.protectionSpace.authenticationMethod isEqualToString:NSURLAuthenticationMethodServerTrust]) {
        SecTrustResultType result;
        // This takes the serverTrust object and checkes it against your keychain
        SecTrustEvaluate(challenge.protectionSpace.serverTrust, &result);
        
        // If we want to ignore invalid server for certificates, we just accept the server
        if (result == kSecTrustResultProceed || result == kSecTrustResultUnspecified) {
            // When testing this against a trusted server I got kSecTrustResultUnspecified every time. But the other two match the description of a trusted server
            
            *credential = [NSURLCredential credentialForTrust:challenge.protectionSpace.serverTrust];
        }
        
        return NSURLSessionAuthChallengeUseCredential;
    } else if ([[challenge protectionSpace] authenticationMethod] == NSURLAuthenticationMethodClientCertificate) {
        // This handles authenticating the client certificate
        
        // Here you should pass reference for client private certificate, it can be done in many ways
        SecIdentityRef identityApp;
        SecCertificateRef certRef;
        SecIdentityCopyCertificate(identityApp, &certRef);
    
        SecCertificateRef certArray[1] = { certRef };
        CFArrayRef myCerts = CFArrayCreate(NULL, (void *)certArray, 1, NULL);
        CFRelease(certRef);
        
        NSURLCredential *userCredential = [NSURLCredential credentialWithIdentity:identityApp certificates:(__bridge NSArray *)myCerts persistence:NSURLCredentialPersistenceForSession];
        CFRelease(myCerts);
        
        *credential = userCredential;
        
        return NSURLSessionAuthChallengeUseCredential;
    } else if ([[challenge protectionSpace] authenticationMethod] == NSURLAuthenticationMethodDefault || [[challenge protectionSpace] authenticationMethod] == NSURLAuthenticationMethodNTLM) {
        
        // For normal authentication based on username and password. This could be NTLM or Default.
        
        return NSURLSessionAuthChallengePerformDefaultHandling;
    }
    
    // If everything fails, we cancel the challenge.
    return NSURLSessionAuthChallengeCancelAuthenticationChallenge;
}];

Useful links

The main reference - it is the link of Github issue with a couple of code snippets written in older versions of AFNetworking.

UITextField & Auto Suggestion

2017-01-29T00:00:00+00:00

One of the time-consuming parts of any application for users is text fields. To save invaluable time for users it’s often a good idea to provide helper tools for them. In this article, I gonna show you how to make auto suggestion feature for UITextField. For instance, we can use it as the additional feature for the search field.

Quick Introduction

To interest you, that’s how the final project will look like:

In the beginning, let’s define what our auto suggestion feature will do:

The auto suggestion will appear and disappear when user will begin and end typing to UITextField accordingly.
Data to be shown as suggestions will be taken from a local source or by the network.
Communication between auto suggestion and UIViewController will be through a protocol.
UI will consist from:
- UIView container for UITableView to set rounded corners on two sides instead all four sides
- UITableView to show the list of suggestions
- UIActivityIndicatorView to show loading state, if we need to make network connection
- Two UIView for dim effect (One to darken and disable other parts of the screen, second for loading state of UITableView)

Implementation

Let’s create the new category for UITextField called AutoSuggestion. This will make our solution for this problem more flexible. Alternatively, you can create a subclass of UITextField if you think auto suggestion feature is too big for a category.

//  UITextField+AutoSuggestion.h

#import <UIKit/UIKit.h>

@interface UITextField (AutoSuggestion)
@end

//  UITextField+AutoSuggestion.m

#import "UITextField+AutoSuggestion.h"
@implementation UITextField (AutoSuggestion)
@end

Next, we need to add some properties. By default in Objective-C categories can not contain properties, but we can achieve that by using <objc/runtime.h> library. It creates properties on runtime, Captain Obvious :)

// inside @interface in UITextField+AutoSuggestion.h
@interface UITextField (AutoSuggestion)

@property (nonatomic, strong) UIView *tableContainerView; // 1
@property (nonatomic, strong) UITableView *tableView; // 2
@property (nonatomic, strong) UIView *tableAlphaView; // 3
@property (nonatomic, strong) UIActivityIndicatorView *spinner; // 4
@property (nonatomic, strong) UIView *alphaView; // 5
@property BOOL autoSuggestionIsShowing; // 6
@property CGRect textFieldRectOnWindow; // 7
@property CGRect keyboardFrameBeginRect; // 8
@property (nonatomic, strong) NSString *fieldIdentifier; // 9
@property NSInteger maxNumberOfRows; // 10

@end

Explanation:

tableContainerView is a view to hold our UITableView. We will set rounded corners on two sides instead of four by applying the mask to view using UIBezierPath. If we set rounded corners by this strategy to UITableView instead than part of UITableView will not be seen while scrolling.
This is our UITableView to present data.
tableAlphaView will be used to show loading state effect.
spinner also will be used to show loading state effect.
alphaView is a view to darken and disable outer parts of UITextField and suggestion view while editing.
autoSuggestionIsShowing is a flag to store current state of suggestion view.
textFieldRectOnWindow is a CGRect of UITextField where to show suggestion view. Needed to calculate size and position of suggestion view.
keyboardFrameBeginRect is a CGRect of keyboard. Needed to calculate size and position of suggestion view.
fieldIdentifier helper variable to differentiate fields.
maxNumberOfRows is a variable to provide maximum number of rows to show in suggestion view instead of default number.

Now to finish we need to provide getters and setters using <objc/runtime.h> which will be used at runtime. Below are few examples how it can be achieved for variables of type BOOL, CGRect, and UITableView:

// in UITextField+AutoSuggestion.m
- (BOOL)autoSuggestionIsShowing {
    return [objc_getAssociatedObject(self, @selector(autoSuggestionIsShowing)) boolValue];
}

- (void)setAutoSuggestionIsShowing:(BOOL)autoSuggestionIsShowing {
    objc_setAssociatedObject(self, @selector(autoSuggestionIsShowing), @(autoSuggestionIsShowing), OBJC_ASSOCIATION_RETAIN_NONATOMIC);
}

- (UITableView *)tableView {
    return objc_getAssociatedObject(self, @selector(tableView));
}

- (void)setTableView:(UITableView *)tableView {
    objc_setAssociatedObject(self, @selector(tableView), tableView, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
}

- (CGRect)textFieldRectOnWindow {
    NSValue *textFieldRectOnWindowValue = (NSValue *)objc_getAssociatedObject(self, &textFieldRectOnWindowKey);
    
    if (textFieldRectOnWindowValue != nil) {
        return [textFieldRectOnWindowValue CGRectValue];
    } else {
        return CGRectZero;
    }
}

- (void)setTextFieldRectOnWindow:(CGRect)textFieldRectOnWindow {
    NSValue *textFieldRectOnWindowValue = [NSValue valueWithCGRect:textFieldRectOnWindow];
    objc_setAssociatedObject(self, &textFieldRectOnWindowKey, textFieldRectOnWindowValue, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
}

As you can see from above code snippet, we use two methods:

objc_setAssociatedObject(_:_:_:_:)

From documentation:

Sets an associated value for a given object using a given key and association policy.
objc_getAssociatedObject(_:_:).

From documentation:

Returns the value associated with a given object for a given key.

From my knowledge almost all type of variables can be stored and retrieved using these two methods.

Other properties implementation is straightforward, you can use above examples and try yourself.

Next steps are to present suggestion view. Therefore we need to calculate position and size for views. Since it heavily depends on keyboard frame let’s first of all create method to get keybord height. We will use observer on UIKeyboardDidShowNotification notification to get keyboard frame.

// in UITextField+AutoSuggestion.h
@interface UITextField (AutoSuggestion)
// previous stuff
- (void)observeTextFieldChanges; // 1
@end

// in UITextField+AutoSuggestion.m
// 2
- (void)observeTextFieldChanges {
[[NSNotificationCenter defaultCenter] addObserver:self
                                             selector:@selector(getKeyboardHeight:)
                                                 name:UIKeyboardDidShowNotification
                                               object:nil];
}

// 3
- (void)getKeyboardHeight:(NSNotification*)notification {
    NSDictionary* keyboardInfo = [notification userInfo];
    NSValue* keyboardFrameBegin = [keyboardInfo valueForKey:UIKeyboardFrameBeginUserInfoKey];
    self.keyboardFrameBeginRect = [keyboardFrameBegin CGRectValue];
}

Explanation:

We define observeTextFieldChanges() method in the header file because we need to start observing changes in UITextField from other places.
Also, this method will be extended in next steps. For now, it only contains the line to observe changes for UIKeyboardDidShowNotification notifications.
To get the frame of the keyboard we need to get its value from the dictionary by key named UIKeyboardFrameBeginUserInfoKey.

Next step is to implement the logic of showing and hiding suggestions view.

// in UITextField+AutoSuggestion.m

// 1
- (void)observeTextFieldChanges {
	// previous stuff
	[[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(toggleAutoSuggestion:) name:UITextFieldTextDidChangeNotification object:self];
	[[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(hideAutoSuggestion) name:UITextFieldTextDidEndEditingNotification object:self];
}

// 2
- (void)createSuggestionView {
    UIWindow *appDelegateWindow = [UIApplication sharedApplication].keyWindow;
    self.textFieldRectOnWindow = [self convertRect:self.bounds toView:nil];
    
    if (!self.tableContainerView) {
        self.tableContainerView = [UIView new];
        self.tableContainerView.backgroundColor = [UIColor whiteColor];
    }
    
    if (!self.tableView) {
        self.tableView = [[UITableView alloc] initWithFrame:self.textFieldRectOnWindow style:UITableViewStylePlain];
        self.tableView.tableFooterView = [[UIView alloc] initWithFrame:CGRectZero];
        self.tableView.delegate = self;
        self.tableView.dataSource = self;
        self.tableView.tableFooterView = [UIView new];
    }
    
    if (!self.alphaView) {
        self.alphaView = [[UIView alloc] initWithFrame:appDelegateWindow.bounds];
        self.alphaView.userInteractionEnabled = true;
        self.alphaView.backgroundColor = [[UIColor blackColor] colorWithAlphaComponent:0.5];
        [appDelegateWindow addSubview:self.alphaView];
    }
    
    self.tableView.frame = self.textFieldRectOnWindow;
    [self.tableContainerView addSubview:self.tableView];
    self.tableContainerView.frame = self.textFieldRectOnWindow;
    [appDelegateWindow addSubview:self.tableContainerView];
}

// 3
- (void)showAutoSuggestion {
    if (!self.autoSuggestionIsShowing) {
        [self createSuggestionView];
        self.autoSuggestionIsShowing = YES;
    }
    
    [self reloadContents];
}

// 4
- (void)hideAutoSuggestion {
    if (self.autoSuggestionIsShowing) {
        
        [self.alphaView removeFromSuperview];
        self.alphaView = nil;
        
        [self.tableView removeFromSuperview];
        self.tableView = nil;
        
        [self.tableContainerView removeFromSuperview];
        self.tableContainerView = nil;
        
        self.autoSuggestionIsShowing = NO;
    }
}

// 5
- (void)toggleAutoSuggestion:(NSNotification *)notification {
    if (self.text.length > 0) {
        [self showAutoSuggestion];
    } else {
        [self hideAutoSuggestion];
    }
}

// 6 
- (void)reloadContents {
    [self updateHeight];
    [self updateCornerRadius];
    [self checkForEmptyState];
    
    [self.tableView reloadData];
}

// 7
- (void)updateHeight {
    NSInteger numberOfResults = [self tableView:self.tableView numberOfRowsInSection:0];
    NSInteger maxRowsToShow = self.maxNumberOfRows != 0 ? self.maxNumberOfRows : DEFAULT_MAX_NUM_OF_ROWS;
    CGFloat cellHeight = DEFAULT_ROW_HEIGHT;
    if ([self.tableView numberOfRowsInSection:0] > 0) {
        cellHeight = [self tableView:self.tableView heightForRowAtIndexPath:[NSIndexPath indexPathForRow:0 inSection:0]];
    }
    CGFloat height = MIN(maxRowsToShow, numberOfResults) * cellHeight; // check if numberOfResults < maxRowsToShow
    height = MAX(height, cellHeight); // if 0 results, set height = `cellHeight`
    
    CGRect frame = self.textFieldRectOnWindow;
    
    if ([self showSuggestionViewBelow]) {
        CGFloat maxHeight = [UIScreen mainScreen].bounds.size.height - (frame.origin.y + frame.size.height) - INSET - self.keyboardFrameBeginRect.size.height; // max possible height
        height = MIN(height, maxHeight); // set height = `maxHeight` if it's smaller than current `height`
        
        frame.origin.y += frame.size.height;
    } else {
        CGFloat maxHeight = frame.origin.y - INSET;  // max possible height
        height = MIN(height, maxHeight); // set height = `maxHeight` if it's smaller than current `height`
        
        frame.origin.y -= height;
    }
    
    frame.size.height = height;
    self.tableView.frame = CGRectMake(0, 0, frame.size.width, frame.size.height);
    self.tableContainerView.frame = frame;
}

// 8
- (void)updateCornerRadius {
    // code snippet from SO answer (http://stackoverflow.com/a/13163693/1760199)
    UIRectCorner corners = (UIRectCornerBottomLeft | UIRectCornerBottomRight);
    if (![self showSuggestionViewBelow]) {
        corners = (UIRectCornerTopLeft | UIRectCornerTopRight);
    }
    
    UIBezierPath *maskPath = [UIBezierPath
                              bezierPathWithRoundedRect:self.tableContainerView.bounds
                              byRoundingCorners:corners
                              cornerRadii:CGSizeMake(6, 6)
                              ];
    
    CAShapeLayer *maskLayer = [CAShapeLayer layer];
    
    maskLayer.frame = self.bounds;
    maskLayer.path = maskPath.CGPath;
    
    self.tableContainerView.layer.mask = maskLayer;
}

// 9
- (void)checkForEmptyState {
    if ([self tableView:self.tableView numberOfRowsInSection:0] == 0) {
        UILabel *emptyTableLabel = [[UILabel alloc] initWithFrame:self.tableView.bounds];
        emptyTableLabel.textAlignment = NSTextAlignmentCenter;
        emptyTableLabel.font = [UIFont systemFontOfSize:16];
        emptyTableLabel.textColor = [UIColor grayColor];
        emptyTableLabel.text = @"No matches";
        self.tableView.backgroundView = emptyTableLabel;
    } else {
        self.tableView.backgroundView = nil;
    }
}

// 10
- (BOOL)showSuggestionViewBelow {
    CGRect frame = self.textFieldRectOnWindow;
    return frame.origin.y + frame.size.height/2.0 < ([UIScreen mainScreen].bounds.size.height - self.keyboardFrameBeginRect.size.height)/2.0;
}

Explanation:

Add extra observers to handle UITextField changes.
In this method, we create all base views and setting initial frames.
Method to show suggestion view.
Method to hide suggestion view.
Use above two methods to toggle between states.
This method calls other methods to recalculate suggestion view frame, update corners and set text if data is empty.
In this method, we decide where suggestion view should be shown (above or below) and also calculate the size.
This method used to set corners on top or bottom regarding the position of suggestion view.
Helper method to set text if data is empty.
Another helper method to decide where to show suggestion view.

Sorry, if too many lines of code are present. I’ve very little experience in writing tutorials. I hope you will understand and forgive me :).

Now we need to implement UITableViewDatasource and UITableViewDelegate protocols but before let’s define our own. It will be used to interact with outer classes. Data to be shown will be passed through the protocol and also it will notify when something changed.

// in UITextField+AutoSuggestion.h
@protocol UITextFieldAutoSuggestionDataSource <NSObject>
- (UITableViewCell *)autoSuggestionField:(UITextField *)field tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath forText:(NSString *)text; // 1
- (NSInteger)autoSuggestionField:(UITextField *)field tableView:(UITableView *)tableView numberOfRowsInSection:(NSInteger)section forText:(NSString *)text; // 2
@optional
- (void)autoSuggestionField:(UITextField *)field textChanged:(NSString *)text; // 3
- (CGFloat)autoSuggestionField:(UITextField *)field tableView:(UITableView *)tableView heightForRowAtIndexPath:(NSIndexPath *)indexPath forText:(NSString *)text; // 4
- (void)autoSuggestionField:(UITextField *)field tableView:(UITableView *)tableView didSelectRowAtIndexPath:(NSIndexPath *)indexPath forText:(NSString *)text; // 5
@end

@interface UITextField (AutoSuggestion)
// previous stuff
@property (weak, nonatomic) id<UITextFieldAutoSuggestionDataSource> autoSuggestionDataSource; // 6
@end

// in UITextField+AutoSuggestion.m
// 7
- (id<UITextFieldAutoSuggestionDataSource>)autoSuggestionDataSource {
    return objc_getAssociatedObject(self, @selector(autoSuggestionDataSource));
}

- (void)setAutoSuggestionDataSource:(id<UITextFieldAutoSuggestionDataSource>)autoSuggestionDataSource {
    objc_setAssociatedObject(self, @selector(autoSuggestionDataSource), autoSuggestionDataSource, OBJC_ASSOCIATION_ASSIGN);
}

Explanation:

Using this method developers will have an opportunity to provide their custom designed cells.
This method will ask the number of suggestions to show.
This and below two methods are optional. We can use this method to handle field changes.
Custom height for UITableViewCell. By default, height is 44 points.
Do something if the cell was selected.
This is a variable to store our data source.
Again we must define getter and setter for the new property.

Let’s now implement UITableViewDatasource and UITableViewDelegate methods combining with our own protocol.

// in UITextField+AutoSuggestion.h
// 1
- (NSInteger)numberOfSectionsInTableView:(UITableView *)tableView {
    return 1;
}

// 2
- (NSInteger)tableView:(UITableView *)tableView numberOfRowsInSection:(NSInteger)section {
    BOOL implementsDatasource = self.autoSuggestionDataSource && [self.autoSuggestionDataSource respondsToSelector:@selector(autoSuggestionField:tableView:numberOfRowsInSection:forText:)];
    NSAssert(implementsDatasource, @"UITextField must implement data source before using auto suggestion.");
    
    return [self.autoSuggestionDataSource autoSuggestionField:self tableView:tableView numberOfRowsInSection:section forText:self.text];
}

// 3
- (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath {
    BOOL implementsDatasource = self.autoSuggestionDataSource && [self.autoSuggestionDataSource respondsToSelector:@selector(autoSuggestionField:tableView:cellForRowAtIndexPath:forText:)];
    NSAssert(implementsDatasource, @"UITextField must implement data source before using auto suggestion.");
                                                
    return [self.autoSuggestionDataSource autoSuggestionField:self tableView:tableView cellForRowAtIndexPath:indexPath forText:self.text];
}

// 4
- (CGFloat)tableView:(UITableView *)tableView heightForRowAtIndexPath:(NSIndexPath *)indexPath {
    if (self.autoSuggestionDataSource && [self.autoSuggestionDataSource respondsToSelector:@selector(autoSuggestionField:tableView:heightForRowAtIndexPath:forText:)]) {
        [self.autoSuggestionDataSource autoSuggestionField:self tableView:tableView heightForRowAtIndexPath:indexPath forText:self.text];
    }
    
    return DEFAULT_ROW_HEIGHT;
}

// 5
- (void)tableView:(UITableView *)tableView didSelectRowAtIndexPath:(NSIndexPath *)indexPath {
    [tableView deselectRowAtIndexPath:indexPath animated:YES];
    if (self.autoSuggestionDataSource && [self.autoSuggestionDataSource respondsToSelector:@selector(autoSuggestionField:tableView:didSelectRowAtIndexPath:forText:)]) {
        [self.autoSuggestionDataSource autoSuggestionField:self tableView:tableView didSelectRowAtIndexPath:indexPath forText:self.text];
    }
    
    [self hideAutoSuggestion];
}

// 6
- (void)toggleAutoSuggestion:(NSNotification *)notification {
    if (self.text.length > 0) {
        [self showAutoSuggestion];
        
        if ([self.autoSuggestionDataSource respondsToSelector:@selector(autoSuggestionField:textChanged:)]) {
            [self.autoSuggestionDataSource autoSuggestionField:self textChanged:self.text];
        }
    } else {
        [self hideAutoSuggestion];
    }
}

Explanation:

The number of sections always will be 1.
The number of rows will be asked from UITextField data source we created. If not implemented, assert will stop the application and show the error message.
The same as above but instead this method will ask for UITableViewCell.
Height for cells. By default is DEFAULT_ROW_HEIGHT which is equal to 44 points.
This method will hide auto suggestion view and call data source method if implemented.
In above code snippets, we already implemented this method. Now we extend it by adding our data source to it. Data source method will be fired if implemented.

And the last step is to add loading state.

// in UITextField+AutoSuggestion.h
- (void)setLoading:(BOOL)loading;

// in UITextField+AutoSuggestion.m
- (void)setLoading:(BOOL)loading {
    if (loading) {
        if (!self.tableAlphaView) {
            self.tableAlphaView = [[UIView alloc] initWithFrame:self.tableView.bounds];
            self.tableAlphaView.backgroundColor = [[UIColor whiteColor] colorWithAlphaComponent:0.8];
            [self.tableView addSubview:self.tableAlphaView];
            
            self.spinner = [[UIActivityIndicatorView alloc] initWithFrame:CGRectMake(0, 0, 24, 24)];
            self.spinner.center = self.tableAlphaView.center;
            self.spinner.color = [UIColor blackColor];
            [self.tableAlphaView addSubview:self.spinner];
            
            [self.spinner startAnimating];
        }
    } else {
        if (self.tableAlphaView) {
            [self.spinner startAnimating];
            
            [self.spinner removeFromSuperview];
            self.spinner = nil;
            
            [self.tableAlphaView removeFromSuperview];
            self.tableAlphaView = nil;
        }
    }
}

To use this category we should specify which class will conform to the data source and implement its methods.

For example in demo project it looks like this:

// 1
@interface ViewController () </* other protocols */, UITextFieldAutoSuggestionDataSource>
@end

@implementation ViewController

// in `viewDidLoad:` or any other method where views are loaded
// 2
- (void)viewDidLoad {
	// other stuff
	self.textField1.autoSuggestionDataSource = self;
    self.textField1.fieldIdentifier = @"FIELD_ID";
    [self.textField1 observeTextFieldChanges];
}

@end

#pragma mark - UITextFieldAutoSuggestionDataSource

// 3
- (UITableViewCell *)autoSuggestionField:(UITextField *)field tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath forText:(NSString *)text {
	static NSString *cellIdentifier = @"AutoSuggestionCell";
    UITableViewCell *cell = [tableView dequeueReusableCellWithIdentifier:cellIdentifier];
    
    if (!cell) {
        cell = [[UITableViewCell alloc] initWithStyle:UITableViewCellStyleDefault reuseIdentifier:cellIdentifier];
    }
    
    // configure cell and fill with some data
    cell.textLabel.text = @"some data";
    
    return cell;
}

// 4
- (NSInteger)autoSuggestionField:(UITextField *)field tableView:(UITableView *)tableView numberOfRowsInSection:(NSInteger)section forText:(NSString *)text {
	return DATA.count; // where DATA is your suggestion model
}

// 5
- (CGFloat)autoSuggestionField:(UITextField *)field tableView:(UITableView *)tableView heightForRowAtIndexPath:(NSIndexPath *)indexPath forText:(NSString *)text {
    return 50; // as an example
}

// 6
- (void)autoSuggestionField:(UITextField *)field tableView:(UITableView *)tableView didSelectRowAtIndexPath:(NSIndexPath *)indexPath forText:(NSString *)text {
    self.textField2.text = DATA.count[indexPath.row];
}

Explanation:

Conforming to the protocol of our category.
Setting which field should have auto suggestion feature and calling observeTextFieldChanges() method to start observing changes.

Steps 3, 4, 5 and 6 and just implementations of data source methods.

That’s it! It was good experience writing our own UITextField category.

Conclusion

As we can see categories are the powerful feature of the Objective-C language. By using it we can extend the functionality of any base API class.

But they should be used carefully. For example, when I first implemented auto suggestion feature I implemented the dealloc method. After that, strange memory crashes occurred. Which means - do not override dealloc method in categories.

Thank you for your attention!

PS: Full code can be found at this link.

Common issues of UIStackView

2016-12-01T00:00:00+00:00

I want to share my experience using of UIStackView in my last projects. This post will be about common issues and problems that arise when using UIStackView.

Note: Most of the solutions to problems I met can be found in Stack Overflow, blogs or other web resources. My aim is to collect solutions for frequent issues.

NSLayoutConstraint Warnings

Most of the developers using UIStackView for its flexibility. You can add or insert view to a specific position, remove needed views or just make view hidden without extra work. UIStackView has good API, but sometimes developers should do some preprocessing to avoid unneeded behavior and console warnings.

Often I needed to add views to UIStackView in particular order and then just make some views hidden or not hidden. For example, to show error message below UITextField or disclaimer with some text.

You may saw some warnings when you make some arranged subview of UIStackView hidden. In most cases, it happens because your view has subviews, and positions are specified by Auto Layout.

This is an example warning:

Probably at least one of the constraints in the following list is one you don't want. Try this: (1) look at each constraint and try to figure out which you don't expect; (2) find the code that added the unwanted constraint or constraints and fix it. (Note: If you're seeing NSAutoresizingMaskLayoutConstraints that you don't understand, refer to the documentation for the UIView property translatesAutoresizingMaskIntoConstraints) 
(
    "<NSLayoutConstraint:0x7fa3a5004310 V:[App.DummyView:0x7fa3a5003fd0(40)]>",
    "<NSLayoutConstraint:0x7fa3a3e44190 'UISV-hiding' V:[App.DummyView:0x7fa3a5003fd0(0)]>"
)

To avoid these warnings you should change the priority of your NSLayoutConstraint’s from 1000 (required) to 999.

self.labelHeightConstraint.priority = 999;

You can ask me, for which constraints? It depends. If you are using vertical UIStackView you should reduce priorities of your height, top, and bottom constraints. In the other hand for horizontal UIStackView, you need to reduce priorities of width, left and right constraints. In some cases, all constraint priorities should be reduced.

Therefore you can add a category for UIView class for convenience. For example:

/* In .h file */
#import <UIKit/UIKit.h>

@interface UIView (Extensions)

/**
 Method to set UILayoutPriority for all UIView's constraints.
 Purpose of this method is to avoid warnings when using view inside UIStackView and
 calling methods hidden = true/false.
 @param priority UILayoutPriority value
 */
- (void)setAllConstraintsPriorityTo:(UILayoutPriority)priority;

@end

/* In .m file */
#import "UIView+Extensions.h"

@implementation UIView (Extensions)

- (void)setAllConstraintsPriorityTo:(UILayoutPriority)priority {
    for (NSLayoutConstraint *constraint in self.constraints) {
        constraint.priority = priority;
    }
}

@end

Above solution will resolve many warnings, but we also have the special case. It will be described in the below section.

Nested UIStackView

Sometimes we need to combine multiple UIStackView. For example, use horizontal one inside of vertical and in other scenarios.

To avoid NSLayoutConstraint warnings you need to wrap your child UIStackView with UIView. And do not forget to reduce constraint priorities.

Again, for convenience you, can create a subclass of UIView with UIStackView inside it. For instance:

/* In .h file */
#import <UIKit/UIKit.h>

@interface StackedView : UIView
@property (nonatomic, strong, readonly) UIStackView *stackView;
@end

/* In .m file */
#import "StackedView.h"
#import "UIView+Extensions.h"
#import "PureLayout.h"

@implementation StackedView {

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

- (instancetype)initWithCoder:(NSCoder *)aDecoder {
    self = [super initWithCoder:aDecoder];
    
    if (self) {
        [self setup];
    }
    
    return self;
}

- (void)setup {
    _stackView = [UIStackView newAutolayoutView];
    self.stackView.alignment = UIStackViewAlignmentFill;
    self.stackView.distribution = UIStackViewDistributionFill;
    self.stackView.axis = UILayoutConstraintAxisVertical;
    [self addSubview:self.stackView];
    [self.stackView autoPinEdgesToSuperviewEdges];
    
    [self setAllConstraintsPriorityTo:999];
}

@end

That’s it about NSLayoutConstraint warnings which appear when using UIStackView.

UIStackView inside UIScrollView

Since the size of device screens are limited UIStackView is useless if we have big content. You may correctly guess that this problem can be solved by putting stack view inside UIScrollView.

There are a number of approaches to do this. This is my favorite:

/* In .h file */
#import <UIKit/UIKit.h>

typedef enum ScrollDirection: NSInteger {
    ScrollDirectionVertical,
    ScrollDirectionHorizontal
} ScrollDirection;

@interface StackedScrollView : UIScrollView

- (instancetype)initWithScrollDirection:(ScrollDirection)scrollDirection;

@property (nonatomic, strong, readonly) UIStackView *stackView;
@property (nonatomic) ScrollDirection scrollDirection;

@end

/* In .m file */
#import "StackedScrollView.h"
#import "UIView+Extensions.h"
#import "PureLayout.h"

@interface StackedScrollView ()
@property (nonatomic, strong) NSMutableArray *stackViewConstraints;
@end

@implementation StackedScrollView

- (instancetype)initWithScrollDirection:(ScrollDirection)scrollDirection {
    self = [super init];
    
    if (self) {
        [self setup];
        
        self.scrollDirection = scrollDirection;
    }
    
    return self;
}

- (void)setup {
    self.stackViewConstraints = [NSMutableArray new];
    self.stackView = [UIStackView new];
    self.stackView.alignment = UIStackViewAlignmentFill;
    self.stackView.distribution = UIStackViewDistributionFill;
    [self addSubview:self.stackView];
}

- (void)layoutSubviews {
    [super layoutSubviews];
    
    self.contentSize = self.stackView.frame.size;
}

#pragma mark - Setters

- (void)setScrollDirection:(ScrollDirection)scrollDirection {
    _scrollDirection = scrollDirection;
    
    if (self.stackViewConstraints) {
        [self.stackViewConstraints autoRemoveConstraints];
    }
    if (self.stackView) {
        if (self.scrollDirection == ScrollDirectionHorizontal) {
            self.stackView.axis = UILayoutConstraintAxisHorizontal;
            
            [self.stackViewConstraints addObject:[self.stackView autoPinEdgeToSuperviewEdge: ALEdgeTop]];
            [self.stackViewConstraints addObject:[self.stackView autoPinEdgeToSuperviewEdge:ALEdgeLeft]];
            [self.stackViewConstraints addObject:[self.stackView autoPinEdgeToSuperviewEdge: ALEdgeBottom]];
        } else {
            self.stackView.axis = UILayoutConstraintAxisVertical;
            
            [self.stackViewConstraints addObject:[self.stackView autoPinEdgeToSuperviewEdge:ALEdgeTop]];
            [self.stackViewConstraints addObject:[self.stackView autoPinEdgeToSuperviewEdge:ALEdgeLeft]];
            [self.stackViewConstraints addObject:[self.stackView autoPinEdgeToSuperviewEdge:ALEdgeRight]];
        }
    }
    
    [self setAllConstraintsPriorityTo:999];
	
    [self setNeedsLayout];
    [self layoutIfNeeded];
}

@end

Removing Arranged Subviews

And the last thing to mention is the proper way to remove arranged subviews from UIStackView. It may be seen stupid, but I didn’t understand initially why removed arranged subviews by method removeArrangedSubview: are still appearing on the screen. Only be reading the documentation of this method I understood that we also have to remove it from view hierarchy by hand.

As Apple documentation says on removeArrangedSubview: method:

This method removes the provided view from the stack’s arrangedSubviews array. The view’s position and size will no longer be managed by the stack view. However, this method does not remove the provided view from the stack’s subviews array; therefore, the view is still displayed as part of the view hierarchy.

To prevent the view from appearing on screen after calling the stack’s removeArrangedSubview: method, explicitly remove the view from the subviews array by calling the view’s removeFromSuperview method, or set the view’s hidden property to YES.

Therefore to completely remove your view just call removeFromSuperview method.