Forem: Wesley de Groot

Exploring ControlGroup in SwiftUI

Wesley de Groot — Fri, 07 Feb 2025 15:31:42 +0000

In SwiftUI, a ControlGroup provides a way to visually group controls together, making your UI more intuitive and structured. It helps you present related controls in a unified manner, enhancing the user experience by logically grouping similar actions.

Syntax Overview

Here's a basic example of how to use a ControlGroup:

import SwiftUI

struct ContentView: View {
    var body: some View {
        VStack {
            ControlGroup {
                Button("Action 1") {
                    // Action 1 code
                }
                Button("Action 2") {
                    // Action 2 code
                }
            }
            .controlGroupStyle(.automatic)
        }
    }
}

In this example, we create a ControlGroup inside a VStack, containing two buttons. The .controlGroupStyle(.automatic) modifier ensures that the group adopts the appropriate style based on the context it's used in.

Customizing `ControlGroup`

While the automatic style is convenient, you can customize ControlGroup to match your app's design. SwiftUI offers different styles, such as navigation and compact.

import SwiftUI

struct ContentView: View {
    var body: some View {
        VStack {
            ControlGroup {
                Button("Action 1") {
                    // Action 1 code
                }
                Button("Action 2") {
                    // Action 2 code
                }
            }
            .controlGroupStyle(.navigation)
        }
    }
}

In the example above, we use .controlGroupStyle(.navigation) to give the control group a navigation-based appearance, suitable for toolbar items.

Practical Example

Consider an app where users frequently perform text formatting actions. You can use a ControlGroup to group formatting buttons together, providing a clean and organized interface:

import SwiftUI

struct FormattingView: View {
    var body: some View {
        VStack {
            Text("Formatted Text")
                .font(.title)

            ControlGroup {
                Button(action: boldText) {
                    Image(systemName: "bold")
                }
                Button(action: italicizeText) {
                    Image(systemName: "italic")
                }
                Button(action: underlineText) {
                    Image(systemName: "underline")
                }
            }
            .controlGroupStyle(.menu)
        }
    }

    func boldText() {
        // Bold text code
    }

    func italicizeText() {
        // Italicize text code
    }

    func underlineText() {
        // Underline text code
    }
}

.menu:

.compactMenu

In this FormattingView, we group three formatting actions—bold, italic, and underline—using ControlGroup with a .menu / .compactMenu style, making the actions easily accessible and visually appealing.

Interesing Use Cases

Control groups work great on (context) menu's, see the following example:

import SwiftUI

struct ContextMenuView: View {
    var body: some View {
        VStack {
            Text("Right-click (or long press) to show context menu")
                .contextMenu {
                    ControlGroup {
                        Button {
                             // Cut action
                        } label: {
                             Label("Cut", systemImage: "scissors")
                        }

                        Button {
                            // Copy action
                        } label: {
                            Label("Copy", systemImage: "doc.on.doc")
                        }

                        Button {
                            // Paste action
                        } label: {
                            Label("Paste", systemImage: "doc.on.clipboard")
                        }
                    }
                }
        }
    }
}

Conclusion

ControlGroup is a powerful feature in SwiftUI that enhances the organization of controls in your app. By logically grouping related actions, you can improve the user experience and create a more intuitive interface. Experiment with different control group styles to find the best fit for your app's design.

JavaScriptCore

Wesley de Groot — Thu, 09 Jan 2025 22:30:56 +0000

Whether you love it or hate it, JavaScript has become the most important language for developers in the world today. Yet despite any efforts we may take to change or replace it we’d be hard-pressed to deny its usefulness.

What is `JavaScriptCore`?

JavaScriptCore is a framework that provides a JavaScript engine for macOS and iOS. It allows developers to run JavaScript code within their applications. JavaScriptCore is a part of the WebKit framework and is used by Safari, Mail, and many other applications on macOS and iOS.

JavaScriptCore / Objective-C / Swift Types

JavaScriptCore uses a set of types to represent JavaScript values in Objective-C and Swift. These types are used to interact with JavaScript code and pass values between JavaScript and native code.

Here is a table that shows the mapping between JavaScript types and Objective-C/Swift types:

JavaScript Type	JSValue method	Objective-C Type	Swift Type
string	toString	NSString	String!
boolean	toBool	BOOL	Bool
number	toNumber	NSNumber	NSNumber!
number	toDouble	double	Double
number	toInt32	int32_t	Int32
number	toUInt32	uint32_t	UInt32
date	toDate	NSDate	Date?
array	toArray	NSArray	[Any]!
object	toDictionary	NSDictionary	[AnyHashable: Any]!
class	toObject	custom type	custom type

Simple Example

Here’s a simple example that evaluates a JavaScript expression and prints the result:

import JavaScriptCore

let context = JSContext()!
let result = context.evaluateScript("1 + 2 + 3")
result?.toInt32() // 6

Handling Exceptions

If a script throws an exception, JavaScriptCore calls the exception handler you provide. The handler receives the context and the exception object, which you can use to get the exception message.

below is an example how to create an exception handler:

import JavaScriptCore

let context = JSContext()!
context.exceptionHandler = { context, exception in
    print(exception!.toString())
}

context.evaluateScript(" **INVALID**")
// Prints "SyntaxError: Unexpected token '**'"

Note: You can’t tell whether a script evaluated successfully based on its return value. For instance, both variable assignment and syntax errors produce undefined return values.

(Hacky) Way to dertimine if a script was evaluated successfully

If we want to determine if a script was evaluated successfully, we can set a variable in the script and then check if that variable exists in the context.

if the variable exists, the script was evaluated successfully.

import JavaScriptCore

let context = JSContext()!
let result = context.evaluateScript("1 + 2 + 3; var didRun = true;")
let didRun = context.objectForKeyedSubscript("didRun")?.toBool()

Virtual Machines and Contexts

JavaScriptCore uses a virtual machine to manage memory and resources. A virtual machine can have multiple contexts, each of which is a separate JavaScript environment. Contexts are isolated from each other, so they can’t share variables or functions.

let queue = DispatchQueue(label: "myVirtualMachineQueue")
let vm = queue.sync { JSVirtualMachine()! }
let context = JSContext(virtualMachine: vm)!

Creating a function in JavaScript

JavaScript evaluation isn’t limited to single statements. When you evaluate code that declares a function or variable, it’s saved into the context’s object space.

context.evaluateScript("""
function twoTimes(number) {
    return number * 2;
}
""")

context.evaluateScript("twoTimes(5)")?
       .toInt32() // 10

Getting JavaScript Context Values from Swift

You can access named values from a JSContext by calling the objectForKeyedSubscript(_:) method. This method returns a JSValue object that represents the value in the context.

context.evaluateScript("var twoTimesFive = twoTimes(5)")

context.objectForKeyedSubscript("twoTimesFive")?
       .toInt32() // 10

Setting Swift Values on a JavaScript Context

You can set a Swift value in a JSContext by calling the setObject(_:forKeyedSubscript:) method. This method creates a new variable in the context with the given name and value.

context.setObject(10, forKeyedSubscript: "swiftValue")

context.evaluateScript("swiftValue")?
       .toInt32() // 10

Passing Functions between Swift and JavaScript

You can pass Swift functions to JavaScript by creating a JSValue object from a block. This object can be called from JavaScript as if it were a regular JavaScript function.

let swiftFunction: @convention(block) (Int) -> Int = { 
    return $0 * 2
}
let jsFunction = JSValue(object: swiftFunction, in: context)
context.setObject(swiftFunction,
                  forKeyedSubscript: "swiftFunction" as NSString)

context.evaluateScript("swiftFunction(5)")?
       .toInt32() // 10

context.objectForKeyedSubscript("swiftFunction")?
       .call(withArguments: [6]) // 12

Passing Swift Objects between Swift and JavaScript

To improve interoperability between language contexts, JavaScriptCore provides the JSExport protocol, which allows native classes to be mapped and initialized directly.

import JavaScriptCore

@objc protocol MyExport: JSExport {
    var value: Int { get set }
    func doubleValue() -> Int
    func doubleTheValue(value: Int) -> Int
}

class MyObject: NSObject, MyExport {
    var value: Int = 0

    func doubleValue() -> Int {
        return value * 2
    }

    func doubleTheValue(value: Int) -> Int {
        return value * 2
    }
}

let context = JSContext()!
context.setObject(
    MyObject.self, 
    forKeyedSubscript: "myObject" as NSString
)

context.evaluateScript("""
var obj = new myObject();
obj.value = 5;
obj.doubleValue(); // 10
""")

context.evaluateScript("""
myObject.doubleTheValue(5) // 10
""")

Conclusion

JavaScriptCore is a powerful framework that allows you to run JavaScript code within your applications.

JavaScriptCore provides a simple API for evaluating JavaScript code, handling exceptions, creating functions, and passing values between Swift and JavaScript. By using JavaScriptCore, you can add dynamic scripting capabilities to your applications and create powerful, interactive user experiences.

Resources:

Expressible Literals

Wesley de Groot — Thu, 09 Jan 2025 22:30:55 +0000

Expressible Literals in Swift are a powerful feature that allows you to create custom types that can be initialized using literals.

This post will show you how to create your own custom types that can be initialized using literals.

What is a literal?

A literal is a notation for representing a fixed value such as integers, strings, and booleans.

Literals in Swift are made possible by several available protocols.

Standard types conform to these protocols and allow us to initialize values as follows:

var integer = 0 // ExpressibleByIntegerLiteral
var string = "Hello!" // ExpressibleByStringLiteral
var array = [0, 1, 2] // ExpressibleByArrayLiteral
var dictionary = ["Key": "Value"] // ExpressibleByDictionaryLiteral
var boolean = true // ExpressibleByBooleanLiteral

How to create a custom type that can be initialized using literals

// ExpressibleBy..Literal protocol is used to create custom types that can be initialized using literals
extension CLASS: ExpressibleByStringLiteral {
    // Required initializer for ExpressibleBy...Literal
    public init(stringLiteral value: String) {
        // Initialize the class with the ... value
        self.init(value)
    }
}

Example 1: Image

Before:

import SwiftUI

let myImage = Image(named: "imageName")

Using ExpressibleByStringLiteral:

import SwiftUI
extension Image: ExpressibleByStringLiteral {
    public init(stringLiteral value: String) {
        self.init(value)
    }
}

let myImage: Image = "imageName"

Example 2: URL

Before:

let myURL = URL(string: "https://wesleydegroot.nl")

Using ExpressibleByStringLiteral:

extension URL: ExpressibleByStringLiteral {
    public init(stringLiteral value: String) {
        self.init(string: value)!
    }
}

let myURL: URL = "https://wesleydegroot.nl"

Example 3: Date

Before:

let formatter = DateFormatter()
formatter.dateFormat = "dd-MM-yyyy"
formatter.locale = Locale(identifier: "en_US_POSIX")
formatter.timeZone = TimeZone(secondsFromGMT: 0)

let date = formatter.date(from: "03-08-1990")
print(date) // Prints: 1990-08-03 00:00:00 +0000

Using ExpressibleByStringLiteral:

extension Date: ExpressibleByStringLiteral {
    public init(stringLiteral value: String) {
        let formatter = DateFormatter()
        formatter.dateFormat = "dd-MM-yyyy"
        formatter.locale = Locale(identifier: "en_US_POSIX")
        formatter.timeZone = TimeZone(secondsFromGMT: 0)
        self = formatter.date(from: value)!
    }
}

let date: Date = "03-08-1990"
print(date) // Prints: 1990-08-03 00:00:00 +0000

Conclusion

Expressible Literals in Swift are a powerful feature that allows you to create custom types that can be initialized using literals.

Resources:

Controllig login and background items

Wesley de Groot — Thu, 09 Jan 2025 22:30:54 +0000

In This post, we'll take a look at how to control login and background items on macOS.

When you start your Mac, you may have noticed that some apps or items automatically start up or appear in the background. This can be useful for apps that you use frequently, but it can also slow down your Mac or clutter your desktop.

Difference between Login Items and Background Items

Login Items : These are apps or items that automatically start up when you log in to your Mac. They can be useful for apps that you use frequently, such as messaging apps, email clients, or productivity tools.
Background Items : These are apps or items that run in the background when you start your Mac. They can be useful for apps that need to perform tasks in the background, such as cloud storage services, backup utilities, or system utilities.

* You can add or remove login items in the Users & Groups preferences pane in System Preferences. You can also use the sfltool command-line tool to list, add, remove, or reset login items, this is the tool we will use in this post.

How to List Login Items

This command will list all the login items that are set to start up when you log in to your Mac.

Open terminal
Type sudo sfltool dumpbtm

* Tip: Export the output to a text file, so you can read the values if you have resetted the login items.

Dump Login Items to a Text File

This can be useful if you want to save the list of login items to a text file for reference before making any changes.

Open terminal
Type sudo sfltool dumpbtm > ~/Desktop.login_items.txt
Open the file login_items.txt on your desktop to see the list of login items.

How to Add Login Items

Adding login items to start those apps when you log in to your Mac.

Open terminal
Type sudo sfltool add --label "App Name" -a "/Applications/AppName.app"

How to Remove Login Items

Removing login items to stop those apps from starting when you log in to your Mac.

Open terminal
Type sudo sfltool remove --label "App Name"

Reset Login Items

If you see a whole bunch of login items that you don't recognize or can't remove, you can reset the login items list to the default settings.

Open terminal
Type sudo sfltool reset

`launchctl` Command (Background Items)

You can use the launchctl command-line tool to manage background items on macOS. Here are some useful commands:

launchctl list - List all background items.
launchctl start <label> - Start a background item.
launchctl stop <label> - Stop a background item.
launchctl remove <label> - Remove a background item.
launchctl load <path> - Load a background item from a property list file.
launchctl unload <path> - Unload a background item from a property list file.
launchctl print <label> - Print the properties of a background item.

Items loaded by launchctl are usually controlled by Property Lists installed in the ~/Library/LaunchAgents folder.

Example Launch Agent.

Here is an example of a Launc Agent file that imports screenshots i've taken into my photo library using Apples Shortcuts Application with this shortcut.

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
  <dict>
     <key>Label</key>
     <string>nl.wesleydegroot.ImportScreenshotsShortcut</string>
     <key>ProgramArguments</key>
     <array>
        <string>/usr/bin/shortcuts</string>
        <string>run</string>
        <string>Import Screenshots</string>
     </array>
     <key>RunAtLoad</key>
     <true />
     <key>StandardErrorPath</key>
     <string>/dev/null</string>
     <key>StandardOutPath</key>
     <string>/dev/null</string>
     <key>StartInterval</key>
     <integer>30</integer>
  </dict>
</plist>

This file is saved as ~/Library/LaunchAgents/nl.wesleydegroot.ImportScreenshotsShortcut.plist and is loaded using launchctl load ~/Library/LaunchAgents/nl.wesleydegroot.ImportScreenshotsShortcut.plist.

Explanation of the keys in the Property List:

Label: A unique identifier for the item.
ProgramArguments: The command to run when the item needs to be started.
RunAtLoad: Whether the item should be started when the system starts.
StandardErrorPath: The file to write standard error output to. (/dev/null means discard the output).
StandardOutPath: The file to write standard output to. (/dev/null means discard the output).
StartInterval: The interval at which the item should be started (in seconds).

Extra facts

Background items are mostly controlled using Property Lists traditionally installed in LaunchAgents and LaunchDaemons folders.
You can use the launchctl command-line tool to manage background items.
You can use the Activity Monitor app to see which apps are running in the background and how much system resources they are using.

iOS App States

Wesley de Groot — Thu, 09 Jan 2025 22:30:54 +0000

When you're developing an iOS app, it's important to understand the different states that your app can be in, to handle them correctly and provide a smooth user experience. In this post, we'll take a look at the different app states in iOS and how you can work with them.

Not Running

The app is not running. This is the initial state of the app when it's not launched or has been terminated by the system.

Inactive

The app is running in the foreground but is not receiving events. This can happen when the app is transitioning to a different state, such as when a phone call or SMS message is received, pr when Control Center or Notification Center is displayed.

Active

The app is running in the foreground and is receiving events. This is the normal state for the app when it's active and the user is interacting with it.

Background

The app is running in the background (not visible for the user) and performing background tasks. This can happen when the user switches to another app or when the app is suspended by the system.

Suspended

The app is in the background but is not executing tasks. This is the state when the app is in the background but is not performing any tasks. The system can terminate the app in this state to free up resources.

The OS can move the app to this state after it has been in the background for a while and is not performing any tasks.

Responding to App State Changes

You can respond to app state changes by adding the following modifiers to your SwiftUI views:

    .onReceive(NotificationCenter.default.publisher(
        for: UIApplication.willResignActiveNotification
    )) { _ in
        // app is going to the background, so do something
    }
    .onReceive(NotificationCenter.default.publisher(
        for: UIApplication.willEnterForegroundNotification
    )) { _ in
        // app is coming to the foreground, so do something else
    }

.onAppear - Called when the view appears on the screen.
.onDisappear - Called when the view disappears from the screen.
.onReceive - Called when the view receives a notification.
.onReceive(NotificationCenter.default.publisher(for: UIApplication.willEnterForegroundNotification)) - Called when the app is about to enter the foreground.
.onReceive(NotificationCenter.default.publisher(for: UIApplication.didEnterBackgroundNotification)) - Called when the app enters the background.
.onReceive(NotificationCenter.default.publisher(for: UIApplication.willResignActiveNotification)) - Called when the app is about to become inactive.
.onReceive(NotificationCenter.default.publisher(for: UIApplication.didBecomeActiveNotification)) - Called when the app becomes active.
.onReceive(NotificationCenter.default.publisher(for: UIApplication.willTerminateNotification)) - Called when the app is about to be terminated.
.onReceive(NotificationCenter.default.publisher(for: UIApplication.didFinishLaunchingNotification)) - Called when the app has finished launching.
.onReceive(NotificationCenter.default.publisher(for: UIApplication.willEnterForegroundNotification)) - Called when the app is about to enter the foreground.
.onReceive(NotificationCenter.default.publisher(for: UIApplication.didEnterBackgroundNotification)) - Called when the app enters the background.
.onReceive(NotificationCenter.default.publisher(for: UIApplication.willResignActiveNotification)) - Called when the app is about to become inactive.
.onReceive(NotificationCenter.default.publisher(for: UIApplication.didBecomeActiveNotification)) - Called when the app becomes active.

Resources:

https://developer.apple.com/documentation/uikit/app_and_environment/managing_your_app_s_life_cycle

Accessibility in SwiftUI

Wesley de Groot — Thu, 09 Jan 2025 22:30:53 +0000

Accessibility in app development is all about making sure everyone, regardless of their abilities, can use your app. Apple’s SwiftUI framework makes integrating accessibility features more streamlined. Here, we'll explore key strategies to make your SwiftUI apps more inclusive.

Understanding Accessibility

Accessibility isn't just a checklist; it’s a mindset. Think of it as designing for the broadest range of human abilities and environments. It's about empathy, respecting your users, and enabling them to interact with your app seamlessly.

Accessibility in SwiftUI: Getting Started

SwiftUI simplifies the process with built-in accessibility modifiers.

Let’s cover some of the fundamental elements.

1. Labeling and Identifying Elements

The .accessibility(label:) modifier help users with assistive technologies understand your UI.

Text("Play")
    .accessibilityLabel(label: Text("Play button"))
    .accessibilityIdentifier("play_button")

.accessibilityIdentifier(_:) is useful for UI testing.

2. Providing Hints

Hints can help users understand the purpose of interactive elements.

The .accessibilityHint(_:) modifier provides additional information.

Button(action: {
    // Action
}) {
    Image(systemName: "trash")
}
.accessibilityHint(Text("Deletes the current item"))

3. Grouping Elements

Use the .accessibilityElement(children:) modifier to logically group UI elements together, improving navigation.

VStack {
    Text("Name")
    TextField("Enter your name", text: $name)
}
.accessibilityElement(children: .combine)

4. Hide non-essential Elements

Use the .accessibilityHidden(_:) modifier to hide non-essential elements from assistive technologies.

Text("I am here only for the fancy design!")
    .accessibilityHidden(true)

5. Accessibility speach language

Use the .accessibilityLanguage modifier to set the language of the accessibility label.

let attributedString = AttributedString(
    "Nederland is bekend om zijn tulpen en windmolens.",
    attributes: AttributeContainer([
        .accessibilitySpeechLanguage: "nl_NL"
    ])
)

Text(attributedString)

6. Accessibility Actions

You can create custom actions that VoiceOver users can trigger using the .accessibilityAction(named:_:) modifier.

Image(systemName: "heart")
    .accessibilityAction(named: Text("Like song")) {
        // Handle action
    }

7. Accesibility Announcements

Use AccessibilityNotification to provide custom announcements for VoiceOver users.

@State
private var isLoading = false

var body: some View {
    VStack {
        Button("Search catalog") {
            isLoading = true
        }

        if isLoading {
            ProgressView()
        }
    }
    // Track state changes
    .onChange(of: isLoading) { _, isLoading in
        if isLoading {
            UIAccessibility.post(
                notification: .announcement, 
                argument: "Search in progress"
            )
        }
    }
}

8. Accessibility focus state

Use the @AccessibilityFocusState and .accessibilityFocused(_:) modifier to manage the focus state of an element.

@AccessibilityFocusState
private var isEmailFocused: Bool

@State
private var email = ""

var body: some View {
    Form {
        TextField("Email", text: $email, prompt: Text("Email"))
            // Binds the focus state of this TextField to the 'isEmailFocused' property.
            .accessibilityFocused($isEmailFocused)
            // The border color changes based on whether the TextField is focused:
            .border(isEmailFocused ? .red : .clear)
    }
}

Sample taken from: https://appt.org/en/docs/swiftui/samples/accessibility-focus-indicator

9. Accessibility sort priority

Use the accessibilitySortPriority(_:) modifier to set the sort priority of an accessibility element.

VStack {
    Text("First Element")
        .accessibilitySortPriority(2) // Reads second
    Text("Second Element")
        .accessibilitySortPriority(3) // Reads first
    Text("Third Element")
        .accessibilitySortPriority(1) // Reads third
}
.accessibilityElement(children: .contain) // Groups the stack's children

10. Accessibility traits

Use the accessibilityAddTraits(_:) modifier to set the traits of an accessibility element.

// Button Trait
Text("Tap Me")
    .accessibilityAddTraits(.isButton)

// Header Trait
Text("Section Header")
    .font(.headline)
    .accessibilityAddTraits(.isHeader)

// Link Trait
Text("Visit Website")
    .foregroundColor(.blue)
    .underline()
    .accessibilityAddTraits(.isLink)

// Image Trait
Image(systemName: "star.fill")
    .accessibilityAddTraits(.isImage)

// Custom Checkbox Trait
@State
private var isSelected: Bool = false

var body: some View {
    CustomCheckbox(isSelected: $isSelected)
        .accessibilityAddTraits(isSelected ? [.isSelected] : [])
}

11. Accessibility value

Use the accessibilityValue(_:) modifier to set the value of an accessibility element.

@State
private var progress: Double = 0

var body: some View {
    MySlider(value: $progress)
        .accessibilityValue("\(progress)")
}

12. Dynamic Type

Support Dynamic Type by using the font modifier with the .largeTitle, .title, .headline, .body, or .caption text styles.

Text("Hello, World!")
    .font(.largeTitle)

14. Autocomplete

Autocompletion is an accessibility feature that helps users complete text input.

Use the .searchSuggestions(_:) modifier to provide search suggestions.

ProductList()
    .searchable(text: $text)
    // Provide search suggestions
    .searchSuggestions {
        Text("🍎").searchCompletion("apple")
        Text("🍐").searchCompletion("pear")
        Text("🍌").searchCompletion("banana")
    }

15. Dark Mode

Dark mode is an accessibility feature that helps users with light sensitivity or visual impairments.

@Environment(\.colorScheme)
var colorScheme

var body: some View {
    HStack {
        if colorScheme == .dark {
            // Show moon icon (dark mode)
            Image(systemName: "moon.fill")
        } else {
            // Show sun icon (light mode)
            Image(systemName: "sun.max.fill")
        }

        Text(colorScheme == .dark ? "In dark mode" : "In light mode")
    }   
}

16. Sensory Feedback

Sensory feedback, like haptic feedback, can help users with visual impairments navigate your app.

This can be achived using the UIImpactFeedbackGenerator and UINotificationFeedbackGenerator classes.

Button("Tap Me for Haptic Feedback") {
    UIImpactFeedbackGenerator(style: .heavy)
        .impactOccurred()

    // Action
}

Button("Tap Me for Success") {
    UINotificationFeedbackGenerator()
        .notificationOccurred(.success)

    // Action
}

Testing Accessibility

Regularly test your app's accessibility using tools like VoiceOver.

Navigate through your app and ensure that every element makes sense and that there are no barriers to interaction.

Conclusion

Accessibility is integral to creating inclusive, user-friendly apps. With SwiftUI's robust accessibility features, there's no excuse for not making your app usable by everyone. It's about designing with empathy and making sure your app stands out by being accessible to all.

Tip:

Use the Accessibility Inspector in Xcode to check your app's accessibility, and enable and disable accessibility features to see how your app behaves.

Resources:

Using MetricKit

Wesley de Groot — Thu, 09 Jan 2025 22:30:53 +0000

In this post, I will show you how to use MetricKit to collect and analyze performance data from your app.

What is MetricKit?

MetricKit is a framework introduced in iOS 13 that allows you to collect and analyze performance data from your app.

It provides a set of APIs to access metrics such as CPU usage, memory usage, disk I/O, and network I/O.

You can use this data to identify performance bottlenecks, optimize your app, and improve the user experience.

What metrics can you collect?

MetricKit provides APIs to collect the following metrics:

Diagnostics for crashes
Hangs
Energy
Disk writes

How to use MetricKit?

To use MetricKit in your app, you need to follow these steps:

Step 1: Import MetricKit

import MetricKit

Step 2: Register for metric updates

To receive metric updates, you need to create a class that conforms to the MXMetricManagerSubscriber protocol and register your class with the MXMetricManager singleton object in your app's main entry point.

@main
struct DinnerConnectApp: App {
    private var metrics = MetricSubscriber()

    var body: some Scene {
        WindowGroup {
            MyAppView()
                .onAppear {
                    MXMetricManager.shared.add(metrics)
                }
        }
    }
}

Step 3: Implement the MetricSubscriber protocol

We create a MetricSubscriber class that conforms to the MXMetricManagerSubscriber protocol to receive metric payloads.

class MetricSubscriber: NSObject, MXMetricManagerSubscriber {
    func didReceive(_ payloads: [MXMetricPayload]) {
        print("didReceive MXMetricPayload")
        guard let firstPayload = payloads.first else { return }

        if let jsonString = String(
            data: firstPayload.jsonRepresentation(), 
            encoding: .utf8
        ) {
            print(jsonString)
        } else {
            print("Failed to encode")
        }
    }

    func didReceive(_ payloads: [MXDiagnosticPayload]) {
        print("didReceive MXDiagnosticPayload")
        guard let firstPayload = payloads.first else { return }

        if let jsonString = String(
            data: firstPayload.jsonRepresentation(), 
            encoding: .utf8
        ) {
            print(jsonString)
        } else {
            print("Failed to encode")
        }
    }
}

Debugging MetricKit

MetricKit will only work on a real device, not on the simulator.

To send a metric payload to your app, you can go to Debug > Simulate MetricKit Payloads in Xcode.

References/resources:

Contact Provider Extension

Wesley de Groot — Thu, 09 Jan 2025 22:30:53 +0000

The ContactProvider framework lets your app create (business) contacts on the user's device.

It is the prefered way to add contacts to the user's address book without interferring with their (personal) address book.

In this post we will create a simple app that uses the ContactProvider framework to add a business contact to the user's address book.

How are we going to setup our application?

We want these features:

Adding a contact.
Reset the contacts database.
Sync to the contact provider extension (yes for this demo we'll do it manually).

We need a way to easily add and fetch contacts from our app's "database".

We will create an observable object that will hold the contacts.

Required actions for the app and extension

In our app we need to do the following actions:

We need to tell the system that we are able to provide contacts.
We need to synchronize the contacts with the system.

In our extension we need to conform to the ContactItemEnumerator protocol.

enumeratecontent(in:for:) for syncing the initial contacts.
enumeratechanges(startingat:for:) for syncing the changes.

Building the app

Add the `Contact Provider Extension` in your app.

To enable ContactProvider in your app, you need to add the Contact Provider Extension to your app.

Setup an App Group

To enable communication between your app and the Contact Provider Extension, you need to setup an App Group.

For this example we will use the group.nl.wesleydegroot.contactproviderdemo App Group.

Building the main application

import ContactProvider

struct ContentView: View {
    /// The database that holds the contacts.
    @ObservedObject
    var database = ContactItemDatabase()

    @State var firstName: String = ""
    @State var lastName: String = ""
    @State var email: String = ""
    @State var phoneNumber: String = ""

    /// The contact provider manager.
    let manager = try! ContactProviderManager()

    var body: some View {
        VStack {
            Button("Send to contact provider") {
                Task {
                    // Synchronise contacts
                    await synchroniseContacts() 
                }
            }
            .buttonStyle(.borderedProminent)
            Button("Reset Database") {
                Task {
                    // Reset the database
                    database.reset() 

                    // Reset all previously known contacts.
                    try? await manager.reset() 
                }
            }
            .buttonStyle(.borderedProminent)

            List {
                ForEach(database.contactItemsJSON, id: \.firstName) { item in
                    Text("\(item.firstName) \(item.lastName)")
                }
            }

            GroupBox {
                TextField("First name", text: $firstName)
                TextField("Last name", text: $lastName)
                TextField("Email", text: $email)
                TextField("Phone number", text: $phoneNumber)

                Button("Add") {
                    saveToDatabase()
                }
            }
            .task {
                randomContact()
            }
            .background(.secondary)
        }
        .padding()
        .task {
            do {
                // May prompt the person to enable the default domain.
                try await manager.enable()
            } catch {
                // Handle the error.
            }
        }
    }

    func saveToDatabase() {
        database.save(
            .init(
                firstName: firstName,
                lastName: lastName,
                phoneNumber: phoneNumber == "" ? nil : phoneNumber,
                emailAddress: email == "" ? nil : email
            )
        )

        Task {
            randomContact()
        }
    }

    func randomContact() {
        firstName = ["John", "Jane", "Wesley", "Alice", "Bob"].randomElement()!
            lastName = ["Doe", "Smith", "de Groot", "Johnson", "Williams"].randomElement()!
            email = "\(firstName.lowercased()).\(lastName.lowercased())@example.com"
            phoneNumber = "+31612345678"
    }

    func synchroniseContacts() async {
        do {
            try await manager.signalEnumerator()
        } catch {
            // Handle the error.
            print(error)
        }
    }
}

Building the "middleware" `ContactItemDatabase`

import Foundation
import Contacts
import ContactProvider

class ContactItemDatabase: ObservableObject {
    // The items that will be synchronised to the Contact Provider extension.
    @Published public var contactItems: [ContactItem] = []

    // The items that will be saved to the database.
    @Published public var contactItemsJSON: [ContactItemJSON] = []

    // The url of our shared database. (App Group)
    private let fileURL = FileManager.default.containerURL(
        // App Group identifier.
        forSecurityApplicationGroupIdentifier: "group.nl.wesleydegroot.contactproviderdemo"
    )?.appendingPathComponent("ContactItems").appendingPathExtension("json")

    // The JSON struct that will be saved to the database.
    struct ContactItemJSON: Codable, Hashable {
        /// The identifier of the contact.
        var identifier: String = UUID().uuidString

        /// The first name of the contact. (givenName)
        var firstName: String

        /// The last name of the contact.
        var lastName: String

        /// The phone number of the contact.
        var phoneNumber: String?

        /// The email address of the contact.
        var emailAddress: String?
    }

    init() {
        guard let fileURL else {
            print("Could not find file URL; is the App Group identifier correct?")
            return
        }

        // Load the contents of our json (database) file.
        if let data = try? Data(contentsOf: fileURL) {
            let decoder = JSONDecoder()
            // Decode the JSON data from our ContactItemJSON struct.
            if let decoded = try? decoder.decode([ContactItemJSON].self, from: data) {
                // Save the decoded data to our contactItemsJSON array.
                // And remove any duplicates Array(Set(...)).
                contactItemsJSON = Array(Set(decoded)) 

                // Walk trough our contacts
                for item in contactItemsJSON {
                    // Create a new contact.
                    let contact: CNMutableContact = .init()

                    // Set the first name of the contact.
                    contact.givenName = item.firstName

                    // Set the last name of the contact.
                    contact.familyName = item.lastName

                    // If the contact has a phone number, add it to the contact.
                    if let phoneNumber = item.phoneNumber {
                        contact.phoneNumbers = [
                            .init(
                                label: "Mobile",
                                value: CNPhoneNumber(stringValue: phoneNumber)
                            )
                        ]
                    }

                    // If the contact has an email address, add it to the contact.
                    if let emailAddress = item.emailAddress {
                        contact.emailAddresses = [
                            .init(
                                label: "Email",
                                value: emailAddress as NSString
                            )
                        ]
                    }

                    // Create a new contact item identifier, from the contact identifier.
                    let identifier: ContactItem.Identifier = .init(item.identifier)

                    // Add the contact to the contactItems array.
                    contactItems.append(
                        .contact(contact, identifier)
                    )
                }
            }
        }
    }

    /// Reset the database.
    func reset() {
        // Remove all `ContactItem` items.
        contactItems.removeAll()

        // Remove all `ContactItemJSON` items.
        contactItemsJSON.removeAll()

        // Save the empty array to the database.
        try? JSONEncoder().encode(contactItemsJSON).write(to: fileURL!)
    }

    func save(_ contactItem: ContactItemJSON) {
        // Append the new contact to the contactItemsJSON array.
        contactItemsJSON.append(contactItem)

        // Save the new contact to the database.
        try? JSONEncoder().encode(contactItemsJSON).write(to: fileURL!)
    }
}

Building the ContactProvider Extension

import Foundation
import ContactProvider
import Contacts
import OSLog

@main
class Provider: ContactProviderExtension {
    private let rootContainerEnumerator: ProviderRootContainerEnumerator

    required init() {
        rootContainerEnumerator = ProviderRootContainerEnumerator()
    }

    func configure(for domain: ContactProviderDomain) {
        rootContainerEnumerator.configure(for: domain)
    }

    func enumerator(for collection: ContactItem.Identifier) -> ContactItemEnumerator {
        return rootContainerEnumerator
    }

    func invalidate() async throws {
        // TODO: Stop any enumeration and cleanup as the extension will be terminated.
    }
}

class ProviderRootContainerEnumerator: ContactItemEnumerator {
    /// The database that holds the contacts.
    private let database = ContactItemDatabase()

    func configure(for domain: ContactProviderDomain) {
        // TODO: If needed, configure your enumerator for the domain.
    }

    func enumerateContent(in page: ContactItemPage, for observer: ContactItemContentObserver) async {
        // Send the current contacts to the observer.
        observer.didEnumerate(self.database.contactItems)

        // Signal that we are done with the enumeration.
        observer.didFinishEnumeratingContent(upTo: "<currentDatabaseGenerationMarker>".data(using: .utf8)!)
    }

    func enumerateChanges(startingAt syncAnchor: ContactItemSyncAnchor, for observer: ContactItemChangeObserver) async {
        // Send the changes to the observer.
        observer.didUpdate(self.database.contactItems)

        // In this demo we dont support "remove" altough it can be implemented by giving the identifiers for the deleted items
        // observer.didDelete(self.database.deletedItemIdentifiers)

        // Signal that we are done with the enumeration.
        observer.didFinishEnumeratingChanges(
            upTo: ContactItemSyncAnchor(generationMarker: "<lastChangeGenerationMarker>".data(using: .utf8)!, offset: 0),
            moreComing: false
        )
    }

    func invalidate() async {
        // TODO: Stop the enumeration and cleanup as the extension will be terminated.
    }
}

Wrap up

You can download the full project from https://github.com/0xWDG/ContactProviderDemo.

Conclusion

ContactProvider is a great way to add contacts to the user's address book without interferring with their (personal) address book.

The finish signals are a bit confusing, but once you get the hang of it, it is a great way to add contacts to the user's address book.

Resources:

Navigation in SwiftUI

Wesley de Groot — Sun, 15 Dec 2024 12:25:44 +0000

Navigating the World of SwiftUI: A Comprehensive Guide

SwiftUI, Apple's declarative framework for building user interfaces, has revolutionized the way developers create apps for iOS, macOS, watchOS, and tvOS. One of the core components of SwiftUI is its navigation system, which allows users to move seamlessly between different views. In this blog post, we'll explore the various navigation tools available in SwiftUI, including NavigationView, NavigationLink, and the newer NavigationStack introduced in iOS 16.

1. Understanding NavigationView

NavigationView is the foundational component for navigation in SwiftUI. It provides a container that manages a stack of views, allowing users to push and pop views as they navigate through the app.

import SwiftUI

struct ContentView: View {
    var body: some View {
        NavigationView {
            VStack {
                Text("Home View")
                NavigationLink(destination: DetailView()) {
                    Text("Go to Detail View")
                }
            }
            .navigationTitle("Home")
        }
    }
}

struct DetailView: View {
    var body: some View {
        Text("Detail View")
            .navigationTitle("Detail")
    }
}

In this example, NavigationView wraps the content, and NavigationLink creates a link to the DetailView. When the link is tapped, the DetailView is pushed onto the navigation stack.

2. Using NavigationLink

NavigationLink is a powerful tool that allows you to create links between views. It can be used in various ways, including programmatically.

NavigationLink(destination: Text("New View")) {
    Text("Tap to navigate")
}

You can also use NavigationLink with more complex views and data passing.

struct Item: Identifiable {
    var id = UUID()
    var name: String
}

struct ContentView: View {
    let items = [Item(name: "Item 1"), Item(name: "Item 2")]

    var body: some View {
        NavigationView {
            List(items) { item in
                NavigationLink(destination: Text(item.name)) {
                    Text(item.name)
                }
            }
            .navigationTitle("Items")
        }
    }
}

3. Introducing NavigationStack

With iOS 16, Apple introduced NavigationStack, which provides more flexibility and control over navigation. It allows for programmatic navigation and supports complex navigation paths.

import SwiftUI

struct ContentView: View {
    @State private var path = NavigationPath()

    var body: some View {
        NavigationStack(path: $path) {
            VStack {
                Button("Go to Detail") {
                    path.append("Detail")
                }
            }
            .navigationDestination(for: String.self) { value in
                if value == "Detail" {
                    DetailView()
                }
            }
        }
    }
}

struct DetailView: View {
    var body: some View {
        Text("Detail View")
    }
}

In this example, NavigationStack is used with a NavigationPath to manage the navigation state. The navigationDestination modifier specifies the destination view for each type of data in the path.

I go into more detail about NavigationStack in my NavigationStack post.

4. Best Practices for Navigation in SwiftUI

Avoid Nesting NavigationViews : Nesting NavigationView inside another NavigationView can lead to unexpected behavior. Instead, use a single NavigationView at the root of your view hierarchy.
Use Navigation Titles : Always set a navigation title for your views to provide context to the user.
Handle Deep Links : Ensure your app can handle deep links by properly managing the navigation state.

Conclusion

SwiftUI's navigation system is both powerful and flexible, allowing developers to create intuitive and seamless user experiences. Whether you're using NavigationView for simple navigation or NavigationStack for more complex scenarios, understanding these tools is essential for building modern SwiftUI apps.

Building Calendo

Wesley de Groot — Mon, 18 Nov 2024 15:01:02 +0000

In this blog post, we'll explore the process of building Calendo, a calendar app that helps users view their schedules quickly and efficiently. We'll cover the key features of Calendo, the technologies used to develop it, and how you can get started with building your own calendar app.

The app idea "Calendo"

I really like to schedule my day, and I wanted to create a calendar app that would help me view my schedule quickly and efficiently. I wanted to create an app that would be easy to use, visually appealing, and provide a seamless experience for managing appointments and events.

Building Calendo

Creating the User Interface

I wanted to create a clean and intuitive user interface for Calendo, I wanted to prototype the app quickly and therefore I decided to use SwiftUI.

The main screen of Calendo displays a monthly calendar view with the current month and year at the top. Users can scroll through the calendar to view different months and tap on specific dates to view their appointments.

Textual representation of the view i wanted.

< August 2024 > [action]

Wk Mon Tue Wed Thu Fri Sat Sun 
31 29 30 31 1 2 3 4
32 5 6 7 8 9 10 11
33 12 13 14 15 16 17 18
34 19 20 21 22 23 24 25
35 26 27 28 29 30 31 1
36 2 3 4 5 6 7 8
===============================
03 August 2024 - All day
Wesley's 34th Birthday

07 August 2024 - 19:00 - 23:00
Weekly Meeten en Drinken
Cafe BAX, Ten Katestraat 119.

14 August 2024 - 19:00 - 23:00
Weekly Meeten en Drinken
Cafe BAX, Ten Katestraat 119.

....

I wanted the days of the past and future to be dimmed out, and the current day to be highlighted.

I also wanted to display appointments for each day in a list below the calendar view.

A textual representation of the view i wanted for birthdays.

< Back ✏️
Wesley's 34th Birthday

        PHOTO 🎈
      OF CONTACT

Saturday, 3 August 2024
All day
Recurring, yearly.

 [Calendar: Birthdays]
 [Notifications: No]
 [Recurring: Yearly]
 [Show as: Free]
 [Status: Appointment]

A textual representation of the view i wanted for appointments.

< Back ✏️
Weekly Meeten en Drinken

Wednesday, 7 August 2024
19:00 - 23:00
Recurring, weekly.

= MAP VIEW MAP VIEW =
= MAP VIEW MAP VIEW =
= +Look Around+ MAP VIEW =
= +Look Around+ MAP VIEW =
= Addres.... [NAVIGATE] =

 [Calendar: Calendar]
 [Notifications: No]
 [Recurring: Weekly]
 [Show as: Busy]
 [Status: Appointment]

Implementing Core Features

I wanted Calendo to have the following core features:

Viewing Appointments : Users can view their appointments for a specific day by tapping on a date in the calendar.
Adding Appointments : Users can add new appointments by tapping on a date in the calendar and entering the details.
Editing Appointments : Users can edit existing appointments by tapping on an appointment in the list view.

I also wanted to include additional features like:

Lookaround, a feature that provides you with a 360-degree view of the location of your appointment.
Scroll trough your appointments and update the higlighted day in the calendar.

Problems encountered

I encountered several challenges while building Calendo, including:

Slow performance when loading large datasets.

Optimized data loading by using pagination (minus and plus one month).
Crashes due to specific appointments.

Fixed crashes by handling edge cases in the appointment data.
Slow performance when scrolling through the calendar.

Improved snappyness by doing certain calculations on the background, and only push the update back to the @Published variable.
Incorrect display of calendar view

On smaller screens, the calendar view was not displayed correctly.

I use a GeometryReader to calculate the size of the calendar view and adjust the layout accordingly.

But on smaller screens the text size was bigger than the available space, so i had to adjust the font size based on the available space.

Translations

Calendo is available in multiple languages.

English with help from Jake Ruston
Dutch (Nederlands)
German (Deutsch)
French (Français)
Greek (Ελληνικά) with help from Theo Palios
Italian (Italiano) with help from AngelK90
Portuguese (Português)
Spanish (Español)
Chinese (中文)
Arabic (العربية)

German, French, Italian, Portugese, Spanish, Chinese, Arabic are translated using Apple's Localisation framework, read more about it here (Translation framework in Swift).

Download Calendo

You can download Calendo from the AppStore!.

Technologies/Frameworks Used

Foundation

Foundation is the base layer of all Apple frameworks, providing basic functionality like data storage, networking, and more.
SwiftUI

SwiftUI is Apple's declarative framework for building user interfaces across all Apple platforms.
Swift

Swift is a Apple's programming language.
EventKit

EventKit is a framework that allows you to access and manipulate calendar events and reminders.
EventKitUI

EventKitUI is a framework that provides a user interface for viewing and editing calendar events and reminders.
MapKit

MapKit is a framework that allows you to embed Apple Maps directly into your app.
OSLog

OSLog is a unified logging system that provides a way to log messages from your app.
OSLogViewer

OSLogViewer is a tool that allows you to view and filter OSLog messages on your device.
OnboardingKit

OnboardingKit is a library that provides a customizable onboarding experience for your app.
Admob_SwiftUI

Admob_SwiftUI is a library that allows you to easily integrate Google AdMob ads into your SwiftUI app.

Apple version numbers

Wesley de Groot — Sun, 20 Oct 2024 13:22:08 +0000

As you may know, Apple releases new versions of its operating systems every year. The version numbers are not always the same across all platforms, and they don't always follow the same pattern. Here is a list of the version numbers for Apple's operating systems, starting from 2007.

Year	iOS	iPadOS	macOS	tvOS	visionOS	watchOS	Xcode	iPhone
2024	18	18	macOS 15: Sequoia	18	2	11	16	16
2023	17	17	macOS 14: Sonoma	17	1	10	15	15
2022	16	16	macOS 13: Ventura	16		9	14	14
2021	15	15	macOS 12: Monterey	15		8	13	13
2020	14	14	macOS 11: Big Sur	14		7	12	12
2019	13	13	macOS 10.15: Catalina	13		6	11	11
2018	12		macOS 10.14: Mojave	12		5	10	XR & XS
2017	11		macOS 10.13: High Sierra	11		4	9	8 & X
2016	10		macOS 10.12: Sierra	10		3	8	7
2015	9		OS X 10.11: El Capitan	9		2	7	6s
2014	8		OS X 10.10: Yosemite			1*	6	6
2013	7		OS X 10.9: Mavericks				4.6 & 5.0	5s & 5c
2012	6		OS X 10.8: Mountain Lion				4.3, 4.4, 4.5	5
2011	5		OS X 10.7: Lion				4 & 4.1	4s
2010	4						3.2	4
2009	3		OS X 10.6: Snow Leopard				5?	3GS
2008	2						3.1	3G
2007	1		OS X 10.5: Leopard				3	2G

Mastering animations in SwiftUI

Wesley de Groot — Tue, 01 Oct 2024 18:28:15 +0000

SwiftUI, Apple's declarative framework for building user interfaces, offers powerful and flexible tools for creating animations. Whether you're looking to add subtle transitions or complex, interactive animations, SwiftUI has you covered. In this blog post, we'll explore the basics of animations in SwiftUI, delve into more advanced techniques, and provide practical examples to help you get started.

Understanding Animations in SwiftUI

Animations in SwiftUI can be broadly categorized into two types: implicit and explicit animations.

Implicit Animations : These are the simplest form of animations in SwiftUI. You define them using the .animation() modifier. When you apply this modifier to a view, any changes to animatable properties (like position, size, or color) will automatically animate from their old values to the new ones.
Explicit Animations : These give you more control over the animation process. You use the withAnimation function to explicitly define when and how the animation should occur.

Advanced Animation Techniques

SwiftUI also supports more advanced animations, such as spring animations and custom transitions.

Spring Animations : These animations simulate the effect of a spring, providing a more natural and dynamic feel. You can customize the stiffness and damping of the spring to achieve the desired effect.
Custom Transitions : Transitions define how a view appears and disappears. SwiftUI provides several built-in transitions, but you can also create custom transitions by combining existing ones.

Practical Examples

Let's look at a practical example that combines several animation techniques to create a more complex and interactive UI.

struct ComplexAnimationView: View {
    @State
    private var isAnimating = false

    var body: some View {
        VStack {
            Spacer()
            HStack {
                ForEach(0..<5) { index in
                    Circle()
                        .fill(isAnimating ? Color.red : Color.blue)
                        .frame(width: 50, height: 50)
                        .offset(y: isAnimating ? -100 : 0)
                        .animation(
                            .easeInOut(duration: 1.0)
                                .repeatForever(autoreverses: true)
                                .delay(Double(index) * 0.2),
                            value: isAnimating
                        )
                }
            }
            Spacer()
            Button("Start Animation") {
                isAnimating.toggle()
            }
            .padding()
        }
    }
}

In this example, we create a row of circles that bounce up and down with a delay between each circle, creating a wave-like effect. The animation repeats indefinitely, reversing direction each time.

Conclusion

SwiftUI's animation capabilities are both powerful and easy to use, allowing you to create engaging and dynamic user interfaces with minimal code. By understanding the basics of implicit and explicit animations, and exploring more advanced techniques like spring animations and custom transitions, you can bring your SwiftUI apps to life.

For more detailed information and examples, you can refer to the Apple Developer Documentation and other resources like Hacking with Swift.

Forem: Wesley de Groot

Exploring ControlGroup in SwiftUI

Syntax Overview

Customizing ControlGroup

Practical Example

Interesing Use Cases

Conclusion

JavaScriptCore

What is JavaScriptCore?

JavaScriptCore / Objective-C / Swift Types

Simple Example

Handling Exceptions

(Hacky) Way to dertimine if a script was evaluated successfully

Virtual Machines and Contexts

Creating a function in JavaScript

Getting JavaScript Context Values from Swift

Setting Swift Values on a JavaScript Context

Passing Functions between Swift and JavaScript

Passing Swift Objects between Swift and JavaScript

Conclusion

Expressible Literals

What is a literal?

How to create a custom type that can be initialized using literals

Example 1: Image

Example 2: URL

Example 3: Date

Conclusion

Controllig login and background items

Difference between Login Items and Background Items

How to List Login Items

Dump Login Items to a Text File

How to Add Login Items

How to Remove Login Items

Reset Login Items

launchctl Command (Background Items)

Example Launch Agent.

Extra facts

iOS App States

Not Running

Inactive

Active

Background

Suspended

Responding to App State Changes

Accessibility in SwiftUI

Understanding Accessibility

Accessibility in SwiftUI: Getting Started

1. Labeling and Identifying Elements

2. Providing Hints

3. Grouping Elements

4. Hide non-essential Elements

5. Accessibility speach language

6. Accessibility Actions

7. Accesibility Announcements

8. Accessibility focus state

9. Accessibility sort priority

10. Accessibility traits

11. Accessibility value

12. Dynamic Type

14. Autocomplete

15. Dark Mode

16. Sensory Feedback

Testing Accessibility

Conclusion

Tip:

Using MetricKit

What is MetricKit?

What metrics can you collect?

How to use MetricKit?

Step 1: Import MetricKit

Step 2: Register for metric updates

Step 3: Implement the MetricSubscriber protocol

Debugging MetricKit

References/resources:

Contact Provider Extension

How are we going to setup our application?

Required actions for the app and extension

Building the app

Add the Contact Provider Extension in your app.

Setup an App Group

Customizing `ControlGroup`

What is `JavaScriptCore`?

`launchctl` Command (Background Items)

Add the `Contact Provider Extension` in your app.

Building the "middleware" `ContactItemDatabase`