DEV Community: Rizwan Ahmed

Send data Between iOS Apps and Extensions Using Darwin Notifications

Rizwan Ahmed — Wed, 28 Aug 2024 05:22:06 +0000

In iOS development, app extensions run in separate processes from their containing apps. This separation poses a challenge when you need to communicate between the main app and its extensions. While NSNotificationCenter is a common choice for passing data between view controllers within the same app, it falls short when it comes to inter-process communication. Have you ever thought about how to pass data between the main app and its extension? Darwin notifications provide a powerful solution for this scenario. In this post, we'll explore how to implement a Darwin Notifications manager and use it to facilitate real-time data transfer between a main app and its extension.

What are Darwin Notifications a.k.a CFNotificationCenterGetDarwinNotifyCenter?

CFNotificationCenterGetDarwinNotifyCenter is a function in Apple's Core Foundation framework that provides access to the Darwin Notification Center. This notification center is designed for system-wide notifications, allowing different processes (such as your app and its extensions) to communicate with each other.

How Does it Work?

System-Wide Communication: Unlike NSNotificationCenter, which is limited to the app's process, the Darwin Notification Center can send notifications that can be observed by other processes on the device. This makes it ideal for app-to-extension communication.

No UserInfo Dictionary: One limitation is that Darwin notifications do not support sending additional data (like a userInfo dictionary). This means you can only send a simple notification without any extra information. This is because the underlying mechanism, notify_post(), only accepts a string identifier for the notification

A use case for Darwin Notifications

For example, when a broadcast upload extension starts or stops, you can use a Darwin notification to inform the main app. I have seen most of the people use UserDefaults or the Keychain but I personally feel that Darwin notifications are the best fit for this use case.

Implementing the Darwin Notification Manager

To start, we'll create a DarwinNotificationManager class that uses the CFNotificationCenter API to post and observe notifications across processes.

import Foundation

 class DarwinNotificationManager {

    static let shared = DarwinNotificationManager()

    private init() {}


    private var callbacks: [String: () -> Void] = [:]

    // Method to post a Darwin notification
    func postNotification(name: String) {
        let notificationCenter = CFNotificationCenterGetDarwinNotifyCenter()
        CFNotificationCenterPostNotification(notificationCenter, CFNotificationName(name as CFString), nil, nil, true)
    }


    func startObserving(name: String, callback: @escaping () -> Void) {
        callbacks[name] = callback

        let notificationCenter = CFNotificationCenterGetDarwinNotifyCenter()

        CFNotificationCenterAddObserver(notificationCenter,
                                        Unmanaged.passUnretained(self).toOpaque(),
                                        DarwinNotificationManager.notificationCallback,
                                        name as CFString,
                                        nil,
                                        .deliverImmediately)
    }


    func stopObserving(name: String) {
        let notificationCenter = CFNotificationCenterGetDarwinNotifyCenter()
        CFNotificationCenterRemoveObserver(notificationCenter, Unmanaged.passUnretained(self).toOpaque(), CFNotificationName(name as CFString), nil)
        callbacks.removeValue(forKey: name)
    }


    private static let notificationCallback: CFNotificationCallback = { center, observer, name, _, _ in
        guard let observer = observer else { return }
        let manager = Unmanaged<DarwinNotificationManager>.fromOpaque(observer).takeUnretainedValue()

        if let name = name?.rawValue as String?, let callback = manager.callbacks[name] {
            callback()
        }
    }
 }

To understand more about Darwin Notifications, please refer to the original article: ‘Sending Data Between iOS Apps and Extensions Using Darwin Notifications’ available at this link: https://ohmyswift.com/blog/2024/08/27/send-data-between-ios-apps-and-extensions-using-darwin-notifications/

Thanks for reading!

Implementing a custom native calendar using UICalendarView in iOS16 and Swift

Rizwan Ahmed — Sun, 10 Jul 2022 06:19:21 +0000

It was WWDC22 week, and I was browsing through my Twitter feed to get some updates about the latest Apple APIs. A person tweeted, “No matter how experienced you are as an iOS developer, you’ll always look it up how to set up a date formatter.” So I humorously replied to the tweet by saying, “Dates are hard 😜 .”

After a while, something struck my mind, and I was curious to know if Apple had made improvements to the existing date picker. To my surprise, Apple introduced UICalendarView to create custom calendar views from iOS 16.

At that moment, I could realize how easy it would become for an iOS developer to implement and customize calendar views. Previously, we used third-party calendar components, which came with issues and bugs. Let’s see how to implement a custom native calendar using UICalendarView in iOS 16 and Swift.

Setting up UICalendarView

UICalendarView belongs to the UIKit framework and comes with a simple initializer.

let calendarView = UICalendarView()
let gregorianCalendar = Calendar(identifier: .gregorian)
calendarView.calendar = gregorianCalendar

Note: Apple tells us that it is necessary to mention the calendar type explicitly while creating a UICalendarView object. In our example, it will be gregorian calendar.

API availablility: UICalendarView is available from iOS16.0+, iPadOS16.0+, and macCatalyst16.0+

Customizing UICalendarView

UICalendarView supports various customizations like setting the background color, setting the view’s corner radius, changing the calendar’s tint color, and many more.

calendarView.backgroundColor = .secondarySystemBackground
calendarView.layer.cornerCurve = .continuous
calendarView.layer.cornerRadius = 10.0
calendarView.tintColor = UIColor.systemTeal

For further reading visit https://ohmyswift.com/blog/2022/06/12/implementing-a-custom-native-calendar-using-uicalendarview-in-ios16-and-swift/

Customizing UIButton in iOS 15

Rizwan Ahmed — Tue, 24 Aug 2021 09:52:17 +0000

Buttons are an essential element in iOS apps. If you are developing an app using UIKit, you will probably use UIButton class to create buttons.
Creating a button is a straightforward process, but it becomes problematic when it comes to customizations. Soon you will find yourself writing hacks for achieving your desired result. We all have been there, and we have done it. You are not alone. Luckily, iOS 15.0 gives us a new method to customize Buttons much easier using UIButton.Configuration.
Let's get started!

Configuration types in UIButton

UIButton.Configuration comes in four different types, namely plain, filled, gray, and tinted.
In this article, we will be focusing only on filled configuration. I will leave the rest of the configurations for you to experiment.

var configuration = UIButton.Configuration.filled()

Setting a title in a UIButton

Setting a title is done by using the configuration's title property.

configuration.title = "Start download"

Setting a subtitle in a UIButton

Again, we can make use of the configuration's subtitle property to set a subtitle. It would be tough to set a subtitle without the configuration API.

configuration.subtitle = "(Downloads a random image)"

Setting an image in a UIButton

Adding an image to the button and customizing it has become effortless. An important point to note here is that, the image respects the language's direction.

configuration.image = UIImage(systemName: "arrow.down.square.fill")

Padding between an image and a title in a UIButton

The UIButton configuration makes it easy to set a padding between the image and the button's

configuration.imagePadding = 20

Changing the position of an image in a UIButton

The imagePlacement is my favorite property. I have written so many nasty hacks for just changing the position of the image in a UIButton, before iOS 15.0
The imagePlacement property supports the following options - leading, trailing, top, or bottom.

configuration.imagePlacement = .trailing

This article was originally published at ohmyswift.com. Click here to read the full article.

About the author 👨‍💻

Rizwan Ahmed — iOS Engineer.
Twitter 👉 https://twitter.com/rizwanasifahmed
Like our articles? Support us 👉https://www.buymeacoffee.com/ohmyswift

Exploring Deque in Swift Collections

Rizwan Ahmed — Thu, 15 Apr 2021 11:54:11 +0000

Deque (should be pronounced as "deck") is a collection implementing double-ended queues. Deques are similar to arrays, but they have efficient insertions and removal of elements at the beginning and at the end.

The indexing semantics are integer indices that are the same as arrays.
Now let's see a sample implementation of deque.

var colors: Deque = ["Yellow", "Orange"]
print(colors) // [Yellow, Orange]

The above code implements a deque of colors with the strings yellow and orange.

Deque operations

Now let's see some operations or methods unique to deques.

1. prepend - Adding an element at the beginning of the deque.

colors.prepend("Blue") // Blue is added to the beginning

2. append - Adding an element to the end of the deque.

colors.append("White") // White is added to the end

3. popFirst - Removal of an element from the beginning of the deque.

let _ = colors.popFirst() // Blue is removed

4. popLast - Removal of an element from the beginning of the deque.

let _ = colors.popLast() // White is removed
print(colors) // [Yellow, Orange]

This article was originally published at ohmyswift.com. Click here to read the full article.

About the author 👨‍💻

Rizwan Ahmed — iOS Engineer.
Twitter 👉 https://twitter.com/rizwanasifahmed
Like our articles? Support us 👉https://www.buymeacoffee.com/ohmyswift