Forem: VladislavMokrov

Implementing location search by address into the iOS app. Step-by-Step Guide

VladislavMokrov — Sun, 23 Jul 2023 14:19:22 +0000

Introduction
In this article we take a look at the fun process of implementing location search by address in an iOS app. If you’re developing an app with maps or location-related functionality, this guide will help you get specific coordinates based on the address the user enters in the searchBar.

1. Import into your file
import CoreLocation
import MapKit

What is the difference between CoreLocation and MapKit?
CoreLocation is the processing of location data. It uses all available device components, including cellular equipment, Wi-Fi, Bluetooth, GPS, barometer and magnetometer.
MapKit is all about visual operations such as map rendering, route directions, address finding and user-friendly operations. Anyway, who wants to type in latitude and instead of a readable address?

2. Properties that will be needed
private lazy var completer = MKLocalSearchCompleter()

private lazy var searchResults: [(title: String?, subtitle: String?, coordinate: CLLocationCoordinate2D?)] = []

private var searchCompletion: (([(title: String?, subtitle: String?, coordinate: CLLocationCoordinate2D?)]) -> Void)?

private var userRegionCoordinate: CLLocationCoordinate2D?

3. Problem with geocodeAddressString from CLGeocoder
At the beginning of development, I decided to use the geocodeAddressString method from CLGeocoder in the searchAddressesForText method. However, I ran into a certain problem. This method always returned only one address with coordinates, not providing a complete list of addresses to choose from. For example, in some countries there may be many streets with the same name. If I passed such a string to the method, I received only one CLPlacemark representing a street in a random city. This limitation was not suitable for my application, so I needed to find an alternative solution.

func searchAddressesForText(_ text: String, completion: @escaping ([String]) -> Void) {
        let region = CLCircularRegion(center: userRegionCoordinate, radius: 30000, identifier: "SearchRegion")

        let geocoder = CLGeocoder()
        geocoder.geocodeAddressString(text, in: region, completionHandler: { (placemarks, error) in
            var addresses: [String] = []
            if let placemarks = placemarks {
                for placemark in placemarks {
                    if let thoroughfare = placemark.thoroughfare, let subThoroughfare = placemark.subThoroughfare {
                        let address = "\(thoroughfare), \(subThoroughfare)"
                        addresses.append(address)
                    } else if let thoroughfare = placemark.thoroughfare {
                        let address = "\(thoroughfare)"
                        addresses.append(address)
                    }
                }
            }
            completion(addresses)
        })
    }
}

4. Using MKLocalSearchCompleter
I later discovered that MKLocalSearchCompleter can solve this problem. It provides multiple addresses by closest match, allowing the user to select the correct address from the list. However, this solution has the disadvantage that it does not provide coordinates for each address. Instead, the user must select one of the addresses and then call the searchCoordinatesForAddress method to get the coordinates of the selected address.

func searchAddressesForText(_ text: String,
                            completion: @escaping ([(title: String?,
                                                     subtitle: String?,
                                                     coordinate: CLLocationCoordinate2D?)]) -> Void) {
    completer.delegate = self
    completer.queryFragment = text

    if let userRegionCoordinate = self.userRegionCoordinate {
        let region = MKCoordinateRegion(center: userRegionCoordinate, latitudinalMeters: 5000, longitudinalMeters: 5000)
        completer.region = region
    }

    searchCompletion = completion
}

To use MKLocalSearchCompleter, I have created an instance of MKLocalSearchCompleter and set up its delegate. I then set the search text and region to get the appropriate results. After updating the search results, I retrieve the address list and pass it to the completion unit for further processing or display.

5. MKLocalSearchCompleterDelegate
To overcome the limitation of no coordinates for addresses obtained with MKLocalSearchCompleter, I used MKLocalSearchCompleter to get a list of addresses and then used MKLocalSearch to get the coordinates of the selected address.

extension SomeViewController: MKLocalSearchCompleterDelegate {
    public func completerDidUpdateResults(_ completer: MKLocalSearchCompleter) {
        searchResults = completer.results.compactMap { result in
            let street = result.title
            let subtitle = result.subtitle
            let searchRequest = MKLocalSearch.Request(completion: result)
            let coordinate = searchRequest.region.center

            //If you want to exclude any result
            let isRelevant = number != "find near me"
            guard isRelevant else {
                return nil
            }
            return (title: street, subtitle: number, coordinate: coordinate)
        }
        searchCompletion?(searchResults)
    }

    public func completer(_ completer: MKLocalSearchCompleter, didFailWithError error: Error) {
        searchResults = []
        searchCompletion?(searchResults)
    }
}

6. Getting coordinates
The user is given a list of addresses obtained with MKLocalSearchCompleter and can select one of them. When the user selects an address, I pass it to the searchCoordinatesForAddress method to retrieve the corresponding coordinates using MKLocalSearch. In this way, I combine the advantages of both approaches and get the full functionality of location search by address.

func searchCoordinatesForAddress(_ address: [(title: String?, subtitle: String?)],
                                 completion: @escaping ([(title: String?,
                                                          subtitle: String?,
                                                          coordinate: CLLocationCoordinate2D?)]?) -> Void) {
    let searchRequest = MKLocalSearch.Request()
    let entireAddress = address.title + " " + address.subtitle
    searchRequest.naturalLanguageQuery = entireAddress

    let search = MKLocalSearch(request: searchRequest)
    search.start { response, error in
        if let response = response,
            let firstPlacemark = response.mapItems.first?.placemark {
            let coordinate = firstPlacemark.coordinate
            completion(title: address.title, subtitle: address.subtitle, coordinate: coordinate)
        } else {
            completion(nil)
        }
    }
}

7. Cancel the search if it is no longer required
For example, if the user has typed an address and decides to close the screen immediately.
Or when entering each new character into searchBar in method:
func searchBar( searchBar: UISearchBar, textDidChange searchText: String)_
You must cancel the search with this method.

func cancelSearchAddresses() {
     if completer.isSearching {
         completer.cancel()
     }
}

Conclusion
In this article we looked at the process of implementing location search functionality by address in an iOS application. We found a problem using the geocodeAddressString method from CLGeocoder, which returns only one address, and a solution to this problem using MKLocalSearchCompleter, which provides multiple addresses but no coordinates. We also looked at a combined approach which allows us to get both a list of addresses and the corresponding coordinates of the selected address.

I hope this guide was useful for you and helped you solve the problem of finding a location by address in your iOS app.
If you have any further questions, please feel free to ask.

All about Silent Push Notifications. Step-by-Step Guide

VladislavMokrov — Sun, 23 Jul 2023 10:23:45 +0000

Introduction
In this article I would like to share my experience of implementing Silent Push Notifications in an iOS app. The purpose of using Silent Push Notifications was to solve the problem of some services going to sleep when the phone is idle for a long period of time. Or for example, if you have a messenger app and you want the user to be able to access new/updated content and not have to wait for it to download. Silent Push Notifications allowed us to activate the app once every 21 minutes (the minimum value we picked up so that Apple would not grant a temporary ban) and run the services in the background to update.

Silent Push Notifications
Provide the ability to update the content of your application, make API calls and perform background tasks. They are sent without activating screen beeping or other visible notifications
(In fact, the application goes into an “active” state, and is generally no different from a normal startup. Navigation will function and screens will initialise, although they will not be visible on the screen. All actions called in the “didFinishLaunchingWithOptions” method will also be executed).
Silent push notifications wake up your application in the background, allowing time to download data from the server and perform tasks in the background.

1. Setting up Silent Push Notifications
First, you need to set up support for Silent Push Notifications in your application. Here is a brief overview of the steps you need to follow.

1.1 Developer Portal
Go to the Developer Portal on Apple’s website and make sure Background Modes and Background Fetch support is enabled.

1.2 Provisioning Profile
Ensure that the Provisioning Profile (linked to your App ID) includes support for Background Modes and Background Fetch.

1.3 Enabling Remote Notifications
In your project in Xcode, open the file AppDelegate.swift and add the following code to the method application(_:didFinishLaunchingWithOptions:):

// Registration to receive notifications

let center = UNUserNotificationCenter.current()
center.requestAuthorization(options: [.alert, .badge, .sound]) { (granted, error) in
    if granted {
        DispatchQueue.main.async {
            UIApplication.shared.registerForRemoteNotifications()
        }
    }
}

1.4 Signing&Capabilities
Here you need to give permission to use push notifications
Scroll to the bottom. And tick the box for “Remote notifications”. Check the rest depending on your needs.

2. Handling Silent Push Notifications
After setting up Silent Push Notifications, you’ll need a handler that will respond to receiving such notifications and trigger a some service. Here’s a sample code to add to your AppDelegate.swift

func application(_ application: UIApplication, 
     didReceiveRemoteNotification userInfo: [AnyHashable: Any], 
     fetchCompletionHandler completionHandler: @escaping (UIBackgroundFetchResult) -> Void) {
        // Silent Push Notification processing
    if let silentNotification = userInfo["aps"] as? [String: AnyObject], 
       silentNotification["content-available"] as? Int == 1 {
        // Launch of a some service
        SomeManager.shared.startUpdatingAnything()
    }
        // Ending a background operation
    completionHandler(.noData)
}

Using the completion handler
You only have 30 seconds to execute the background request and you should call the completionHandler on completion.

3. Backend
All the things you should tell your backend developers

3.1 You must tell the backend which body to send, you can add additional fields at your discretion.
For notifications to be silent, you must specify “content-available” : 1.

You can read more about it here.

3.2 If you want to check your notifications without a backend like I do. You will need an application that emulates the backend to check.

I used PushNotifications.
(You can skip this point and go straight to 3.2.1)

Update! On the day I published this article, apple introduced a new tool for push notifications 😅

3.2.1 Push Notifications Console
“The new Push Notifications Console makes it easy to send test notifications to Apple devices through the Apple Push Notification service (APNs). You can access logs that provide insights into the delivery process and leverage tools to generate and validate tokens.” — Taken from Apple’s official website.

Taken from Apple’s official website

You will not need the p8 file for Push Notifications Console. You simply log in to your account and start testing. It’s also very convenient to use push notifications logging.

3.3 Registration token
A registration token is required to send remote notifications.

In order to send notifications to remote devices, your application must receive a registration token that the APNs (Apple Push Notification service) uses to deliver notifications to a specific device. The registration token is a unique identifier tied to the device and your app. When your app is launched, it communicates with APNs to receive a registration token, which can then be sent to your server. Your server uses this token to send notifications to the relevant device.

func application(_ application: UIApplication,
                 didRegisterForRemoteNotificationsWithDeviceToken deviceToken:Data) {
   let pushToken = deviceToken.map { String(format: "%02.2hhx", $0) }.joined()
   self.yourPushNotificationsService.pushTokenDidReceived(pushNotificationToken: pushToken)
}

Once you have a registration token for a particular user, you can send notifications to their remote device via your server, a third-party service (PushNotifications) or Firebase Cloud Messaging.

The process of receiving a token and sending notifications is shown in the diagram below.

Source: https://betterprogramming.pub

3.4 Download the .p8 file
a. If your app already has normal push notifications, request the p8 key from the person in charge of push notifications on the backend or a senior/lead iOS developer.

b. If you are setting up push notifications for the first time, the following instructions are for you:

Go to Apple developer account and go to Certificates, Identifiers & Profiles
Go to Keys section and click on a new key using Add button(+).
Choose a unique name for key and select Apple Push Notification service(APNs) checkbox. Click continue and then confirm.
Note and save the key ID. Click Download to generate and save the key. !!! Please note you have to save the key in a secured place because you can’t download key more than once. Do not rename Auth key file.

4. After installing the app on your physical device
When you install the app be sure to check whether it has Background App Refresh enabled

Settings > (scroll down) > Your app > Background App Refresh (enable)

5. Problems and solutions
In the process of implementing Silent Push Notifications, I have encountered a few problems which may be useful to you.

5.1 Apple’s restrictions
Apple has a strict limit on how often Silent Push Notifications are sent. If several Silent Push Notifications are sent in a row, they may stop reaching the user. To avoid this problem, I used a backend timer to ensure that Silent Push Notifications are only sent once every 21 minutes.

5.2 Error handling
It is important to handle possible errors when processing Silent Push Notifications. For example, if a some service is already active, new Silent Push Notifications should be ignored to avoid having to run the service continuously and using resources unnecessarily.

5.3 Optimise battery usage
Running some services can consume a significant amount of battery power. To minimise this, I have set a limit on the time the service will run after each Silent Push Notification.

It is very important to note the following points:

5.4 The Silent Push does not work in “low power mode”.

5.5 The treatment of the silent-push system depends on several factors:

Amount of free memory available: when you close an application, the system creates a snapshot of the memory used and assigns points to the Silent Push processing speed. If your application is training a machine learning model or using more than 400 MB of memory, the system may refuse to process the push notification. It is therefore recommended that you try to minimise resource usage and free up memory when switching to background mode.
Battery charge level.
Frequency of push notifications: the system can handle silent push notifications no more frequently than once every 20 minutes.
Time of day: the system can change its attitude towards handling push notifications depending on the time of day.
Phone charging status: if the device is on charge, the system may be more prone to handle silent-push.
App crash: if your app crashes, the system will probably not handle the silent-push and may assign penalty points.
So when you put your phone on charge and get your first silent push the next morning, the system will gradually increase the likelihood of handling push notifications and reduce the penalty points over time.

Conclusion
The use of silent Push notifications in the app has solved the problem of some services falling asleep when the phone is left for extended periods. Launching the service every 21 minutes after receiving a silent Push notification updates the data in the app, providing a better experience and usability.

Share your thoughts about the article. Your comments will help me expand on this research and provide additional material on the topic of the article. This will make it more useful.

I would like to dedicate my first technical article to my mentor. I want to express my sincere gratitude for your patience, politeness, and consistency while I was a junior developer.
Keep up the great work!