admin, autor en Javier iOS Development Blog

Storing in the Sky: iCloud Integration for iOS

This post.demystifies a powerful yet often underused feature in the Apple ecosystem. Many developers find iCloud integration—whether through CloudKit, key-value storage, or iCloud Drive—intimidating due to scattered documentation and complex setup. By offering a clear, beginner-friendly guide with a working example, you not only fill a common knowledge gap but also empower others to build more seamless, cloud-synced experiences across devices. It’s a great way to share practical knowledge, boost your credibility, and contribute to best practices in the iOS dev community.

iCloud

iCloud is Apple’s cloud-based storage and computing service that allows users to securely store data such as documents, photos, music, app data, and backups across all their Apple devices. It provides a seamless way to keep content in sync, making it accessible from iPhones, iPads, Macs, and even Windows PCs. With services like iCloud Drive, iCloud Photos, and iCloud Backup, users benefit from automatic data management and recovery options, which enhances their overall experience with Apple’s ecosystem.

For app developers, integrating iCloud offers a range of benefits that can significantly improve user engagement and satisfaction. By using iCloud technologies such as CloudKit, developers can enable real-time data synchronization and seamless transitions between devices. For instance, a note taken on an iPhone can instantly appear on a Mac or iPad without requiring manual uploads or additional login steps. This functionality not only enhances user convenience but also opens doors for multi-device collaboration and continuity in usage.

Moreover, iCloud integration can simplify backend infrastructure for developers. With CloudKit, developers don’t need to manage their own servers for syncing user data — Apple handles the storage, security, and data transfer. This reduces development time and operational overhead, while still providing users with fast, secure, and reliable cloud features. It also adds credibility to the app by aligning it with Apple’s high standards for privacy and performance, making iCloud integration a smart and strategic choice for apps within the Apple ecosystem.

Setup iCloud on simulator

For start working we need to fulfill 2 basic requirement: First one is having an iOS Development (or Enterprise) account for having access to iCloud console and second in iOS Simulator (or real device) be sure that you have sign in your Apple development account:

Last but not least, be sure that iCloud Drive, Sync this iPhone switch is on:

iOS Ranking app

The app we are going to implement to demonstrate iCloud usage will allow users to enter their name and a point value. This app will be distributed across multiple user devices, enabling each user to submit their name and score. It will also display a global ranking based on the collected data.

Once we have created our blank iOS project, on target signing & capabilities add iCloud:

Add a new container:

Type its container name, has to be prefixed by iCloud. :

Ready:

To update your app when changes occur in iCloud, you need to handle silent push notifications. By default, enabling the iCloud capability also includes Push Notifications. However, Background Modes are not enabled automatically—so be sure to add the Background Modes capability and check the «Remote notifications» option.

For source code app we are going to focus only in CloudkitManager, view is very simple and doest apport too much. Nevertheless you will find code respository GitHub link at the end of the post:

import CloudKit
import Foundation


class RankingViewModel: ObservableObject {
    @Published var scores: [PlayerScore] = []
    private var database = CKContainer(identifier: "iCloud.jca.iCloudRanking").publicCloudDatabase
    
    init() {
        fetchScores()
        setupSubscription()

        NotificationCenter.default.addObserver(
            forName: .cloudKitUpdate,
            object: nil,
            queue: .main
        ) { _ in
            self.fetchScores()
        }
    }

    func fetchScores() {
        let query = CKQuery(recordType: "Score", predicate: NSPredicate(value: true))
        let sort = NSSortDescriptor(key: "points", ascending: false)
        query.sortDescriptors = [sort]

        database.perform(query, inZoneWith: nil) { records, error in
            DispatchQueue.main.async {
                if let records = records {
                    self.scores = records.map { PlayerScore(record: $0) }.sorted { $0.points > $1.points }
                    print("Fetching successfull")
                } else if let error = error {
                    print("Error fetching scores: \(error.localizedDescription)")
                }
            }
        }
    }

    func addScore(name: String, points: Int) {
        let record = CKRecord(recordType: "Score")
        record["name"] = name as CKRecordValue
        record["points"] = points as CKRecordValue

        database.save(record) { _, error in
            if let error = error {
                print("Error saving score: \(error.localizedDescription)")
            } else {
                print("Saving successfull")
                DispatchQueue.main.async { [weak self] in
                    self?.localAddScore(record: record)
                }
            }
        }
    }
    
    private func localAddScore(record: CKRecord) {
        
        scores.append(PlayerScore(record: record))
        scores = scores.sorted { $0.points > $1.points }
    }
    
    func setupSubscription() {
        let subscriptionID = "ranking-changes"

        let predicate = NSPredicate(value: true)
        let subscription = CKQuerySubscription(
            recordType: "Score",
            predicate: predicate,
            subscriptionID: subscriptionID,
            options: [.firesOnRecordCreation, .firesOnRecordUpdate, .firesOnRecordDeletion]
        )

        let notificationInfo = CKSubscription.NotificationInfo()
        notificationInfo.shouldSendContentAvailable = true  // Silent
        subscription.notificationInfo = notificationInfo

        database.save(subscription) { returnedSub, error in
            if let error = error {
                print("❌ Subscription error: \(error.localizedDescription)")
            } else {
                print("✅ Subscription saved!")
            }
        }
    }
}

This Swift code defines a RankingViewModel class that interfaces with Apple’s CloudKit to manage a leaderboard-style ranking system. It fetches, updates, and stores player scores in an iCloud public database (iCloud.jca.iCloudRanking) using CloudKit. When the class is initialized, it automatically retrieves existing scores from CloudKit and sets up a subscription to receive real-time updates when scores are added, modified, or deleted. It also listens for a custom cloudKitUpdate notification and refetches scores when triggered. All fetched scores are stored in the @Published array scores, allowing SwiftUI views observing this view model to update dynamically.

The fetchScores() function queries the CloudKit database for records of type «Score», sorting them by the number of points in descending order. These records are converted into PlayerScore instances (assumed to be a custom data model) and stored in the scores array. The addScore() function allows new scores to be submitted to the database. Once saved, the new score is locally appended and sorted in the scores array via localAddScore(). Additionally, the setupSubscription() method ensures the app receives silent push notifications when there are any changes to the «Score» records in CloudKit, keeping the leaderboard data synchronized across devices.

When we deploy:

Issue, new ranking is not updated and we can read on Console log:

For fixing that we have to make a few adjustments on iCloud Console.

iCloud Console

For having access to iCloud Console, just type ‘https://icloud.developer.apple.com/dashboard’ on your favourite browser and login with your Apple Developer (or Enterprise) account. Later on select the the iCloud containter that the app is being used:

First step is creating a Record Type for taking a look at the recently uploaded user data:

Next step is adding record fields (name and points):

For being able to retrieve data from console we have to create a Querable Index on recordName field from Score Record Type:

Now is time for checking previous stored data:

For retrieve data from device, we have to create a Sortable Index for points filed in Score Record Type:

When we deploy iOS app on a real device:

Finally…

For final validation of the iOS app concept, I deployed the app on two different physical devices. As demonstrated in the video, when a ranking is submitted on one device, the ranking list is updated almost instantly on the other device.

Conclusions

From a programming point of view, working with iCloud is relatively straightforward. What I’ve found a bit cumbersome, however, is setting up the iCloud Console. Overall, though, using iCloud is a good idea if you need to share data across all instances of your app.

You can find source code used for writing this post in following repository.

References

iCloud
Apple Developer Documentation

abril 27, 2025

Less Fetching, More Speed: NSCache in Action

Implementing image caching with NSCache in iOS addresses a common real-world challenge: efficiently loading images without compromising performance or user experience. It’s a lightweight, native solution that avoids third-party dependencies—ideal for developers building lean apps. Additionally, it serves as a natural introduction to memory management concepts, such as how NSCache automatically evicts objects under memory pressure.

This approach helps newer developers avoid common pitfalls like UI flicker or image reloads in scrollable views and sets the stage for more advanced caching strategies, including disk storage or custom loaders.

In this guide, we’ll walk you through a simple iOS app implementation to demonstrate the process step by step.

NSCache

NSCache is a specialized caching class in Apple’s Foundation framework that provides a convenient way to temporarily store key-value pairs in memory. It functions similarly to a dictionary but is optimized for situations where you want the system to manage memory usage more intelligently. One of its biggest advantages is that it automatically evicts stored items when the system is under memory pressure, helping to keep your app responsive and efficient without needing manual intervention.

Unlike regular dictionaries, NSCache is thread-safe, which means you can access and modify it from different threads without adding synchronization logic. It’s designed to work well with class-type keys, such as NSString or NSURL, and object-type values like UIImage or custom model classes. Additionally, you can set limits on how many objects it holds or how much memory it should use, and even assign a «cost» to each object (like its file size) to help the cache prioritize what to keep or remove.

NSCache is especially useful in cases like image loading in SwiftUI apps, where images fetched from the network can be reused rather than redownloaded. However, it only stores data temporarily in memory and doesn’t support expiration dates out of the box, so you’d need to add your own logic if you want time-based invalidation. For long-term storage or persistent caching, developers often combine NSCache with disk storage strategies to create a hybrid caching system.

This is our NSCache wrapping implementation:

import UIKit

actor DiskImageCache {
    static let shared = DiskImageCache()
    
    private let memoryCache = NSCache<NSURL, UIImage>()
    private let fileManager = FileManager.default
    private let cacheDirectory: URL
    private let expiration: TimeInterval = 12 * 60 * 60 // 12 hours
    
    init() {
        let directory = fileManager.urls(for: .cachesDirectory, in: .userDomainMask).first!
        cacheDirectory = directory.appendingPathComponent("ImageCache", isDirectory: true)

        if !fileManager.fileExists(atPath: cacheDirectory.path) {
            try? fileManager.createDirectory(at: cacheDirectory, withIntermediateDirectories: true)
        }
    }
    
    func image(for url: URL) -> UIImage? {
        // 1. Check memory cache
        if let memoryImage = memoryCache.object(forKey: url as NSURL) {
            return memoryImage
        }
        
        // 2. Check disk cache
        let path = cachePath(for: url)
        guard fileManager.fileExists(atPath: path.path) else { return nil }

        // Check expiration
        if let attributes = try? fileManager.attributesOfItem(atPath: path.path),
           let modifiedDate = attributes[.modificationDate] as? Date {
            if Date().timeIntervalSince(modifiedDate) > expiration {
                try? fileManager.removeItem(at: path)
                return nil
            }
        }
        
        // Load from disk
        guard let data = try? Data(contentsOf: path),
              let image = UIImage(data: data) else {
            return nil
        }

        memoryCache.setObject(image, forKey: url as NSURL)
        return image
    }
    
    func store(_ image: UIImage, for url: URL) async {
        memoryCache.setObject(image, forKey: url as NSURL)
        
        let path = cachePath(for: url)
        if let data = image.pngData() {
            try? data.write(to: path)
        }
    }

    private func cachePath(for url: URL) -> URL {
        let fileName = url.absoluteString.addingPercentEncoding(withAllowedCharacters: .alphanumerics) ?? UUID().uuidString
        return cacheDirectory.appendingPathComponent(fileName)
    }
}

Making DiskImageCache an actor is all about thread safety — especially when you’re doing I/O (disk reads/writes) and managing a shared resource (the cache itself).

The code defines a DiskImageCache actor that manages a two-level cache system for images, combining in-memory and disk storage to efficiently store and retrieve images. The actor is implemented as a singleton (shared), ensuring thread-safe access to its caching mechanisms. It uses NSCache for fast in-memory storage of UIImage objects keyed by their URLs, while also maintaining a disk-based cache in the app’s Caches directory under an «ImageCache» subfolder. The disk cache includes an expiration mechanism (12 hours) that automatically removes stale files based on their modification date.

The actor provides two main methods: image(for:) to retrieve an image and store(_:for:) to save an image. When retrieving an image, it first checks the memory cache, then falls back to disk if needed, while also handling cache expiration. When storing an image, it saves to both memory and disk. The disk cache uses URL-encoded filenames derived from the image URLs to maintain unique file paths. This implementation balances performance (with quick memory access) and persistence (with disk storage), while managing resource usage through expiration and proper file system organization.

The viewmodel for AsyncImage View component

The ViewModel is responsible for requesting an image from ImageCache and providing it to the view via @Published. Note that the entire class is executed on the @MainActor, whereas DiskImageCache runs in a separate actor.

The target (and project) is configured for Swift 6 with Strict Concurrency Checking set to Complete. Since the cache operates in a different isolated domain, even though the image function is not explicitly marked as async, the compiler still requires the use of the await keyword when calling it.

import SwiftUI

@MainActor
class AsyncImageLoader: ObservableObject {
    @Published var image: UIImage?
    
    private var url: URL

    init(url: URL) {
        self.url = url
    }

    func load() async {
        if let cached = await DiskImageCache.shared.image(for: url) {
            self.image = cached
            return
        }

        do {
            let (data, _) = try await URLSession.shared.data(from: url)
            guard let downloaded = UIImage(data: data) else { return }

            self.image = downloaded
            await DiskImageCache.shared.store(downloaded, for: url)
        } catch {
            print("Image load failed:", error)
        }
    }
}

AsyncImageView struct defines a custom view for asynchronously loading and displaying an image from a URL using an AsyncImageLoader (assumed to handle the async fetching logic). It uses a placeholder image while the actual image is being fetched, and applies a customizable image styling closure to either the loaded image or the placeholder. The loading is triggered when the view appears, using Swift’s concurrency features (Task and await). It leverages @StateObject to maintain the image loader’s lifecycle across view updates, ensuring image state persists appropriately in the SwiftUI environment.

The AsyncImage view component

Refactored AsyncImageLoader into a standalone component to enable better reusability.

import SwiftUI

struct AsyncImageView: View {
    @StateObject private var loader: AsyncImageLoader
    let placeholder: Image
    let imageStyle: (Image) -> Image

    init(
        url: URL,
        placeholder: Image = Image(systemName: "photo"),
        imageStyle: @escaping (Image) -> Image = { $0 }
    ) {
        _loader = StateObject(wrappedValue: AsyncImageLoader(url: url))
        self.placeholder = placeholder
        self.imageStyle = imageStyle
    }

    var body: some View {
        Group {
            if let uiImage = loader.image {
                imageStyle(Image(uiImage: uiImage).resizable())
            } else {
                imageStyle(placeholder.resizable())
                    .onAppear {
                        Task {
                            await loader.load()
                        }
                    }
            }
        }
    }
}

AsyncImageView struct defines a custom view that asynchronously loads and displays an image from a given URL. It uses an AsyncImageLoader to manage the image fetching logic. Upon initialization, the view sets up the loader with the provided URL and stores a placeholder image and an optional styling closure for the image. In the view’s body, it conditionally displays the downloaded image if available, or the placeholder image otherwise. When the placeholder is shown, it triggers the asynchronous loading of the image via a Task inside onAppear. The imageStyle closure allows the caller to customize how the image (or placeholder) is displayed, such as adding modifiers like .aspectRatio or .frame.

The View

Finally AsyncImageView component is integrated in ContentView in following way:

struct ContentView: View {
    var body: some View {
        AsyncImageView(url: URL(string: "https://picsum.photos/510")!)
            .frame(width: 200, height: 200)
            .clipShape(RoundedRectangle(cornerRadius: 20))
            .shadow(radius: 5)
    }
}

When we deploy iOS app on a real device:

When the app starts up, it displays a placeholder image while the actual image is being fetched. Once the image is displayed, the app is terminated. On the second startup, the app directly shows the previously fetched image.

Conclusions

With that post, I just intended to show how to cache images, or any other resource for making your apps more fluid.

You can find source code used for writing this post in following repository.

References

NSCache
Apple Developer Documentation
iOS Memory Deep Dive
WWDC 2018

abril 22, 2025

Inside the iOS Sandbox: Managing Files and Folders

Sandboxing in iOS is a foundational security mechanism that isolates each app in its own secure environment. This isolation prevents unauthorized access to system resources and user data, ensuring that apps cannot interfere with one another.

For developers, understanding how to manage files and directories within this sandbox is crucial. It determines how and where persistent data, user-generated content, and temporary files are stored—directly affecting app functionality, user privacy, and compliance with App Store requirements.

The goal of this post is to demystify these concepts. By doing so, it empowers developers to build secure, reliable, and user-friendly applications that align with iOS’s strict security model while effectively leveraging the available file system APIs.

The Sandbox

In iOS, a sandbox is a security mechanism that restricts apps to their own designated area, preventing them from accessing files, resources, or data belonging to other apps or the system without explicit permission. This isolation ensures stability, security, and privacy for users.

Key Features of iOS Sandbox:

App Isolation
- Each app runs in its own sandboxed environment with its own directory for files.
- Apps cannot directly read or modify files from other apps.
Controlled Access to System Resources
- Apps must request permissions (via entitlements or user consent) to access sensitive data like:
  - Contacts (Contacts.framework)
  - Photos (PHPhotoLibrary)
  - Location (CoreLocation)
  - Camera & Microphone (AVFoundation)
File System Restrictions
- Apps can only write files in their own sandbox directories, such as:
  - Documents/ (user-generated content, backed up by iTunes/iCloud)
  - Library/ (app support files, some backed up)
  - Caches/ (temporary files, can be purged by the system)
  - tmp/ (short-lived files, not backed up)
No Direct Hardware or Kernel Access
- Apps interact with hardware (e.g., GPU, sensors) only through Apple’s frameworks.
- No root-level system modifications are allowed (unlike jailbroken devices).
Inter-App Communication (Limited & Controlled)
- Apps can share data only via:
  - URL Schemes (custom deep links like myapp://)
  - App Groups (shared containers for related apps)
  - UIActivityViewController (share sheets)
  - Universal Clipboard (limited-time data sharing)

Why Does iOS Use a Sandbox?

Security: Prevents malware from spreading or tampering with other apps.
Privacy: Ensures apps access only permitted user data.
Stability: Crashes or bugs in one app don’t affect others.

Example: Accessing the Sandbox in Code

To get an app’s sandbox directory in Swift:

struct PeopleView: View {
    @StateObject var viewModel = PeopleViewModel()
    
    var body: some View {
        NavigationView {
            ...
        }.onAppear {
            if let documentsPath = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask).first {
                print("📂 Document Directory: \(documentsPath.path)")
            }
        }
    }
}

The snippet is used to retrieve and print the path to the app’s Documents directory on an iOS or macOS device. Its parent folder is the sandbox root folder for your current app.

Exceptions to the Sandbox:

System apps (e.g., Messages, Mail) have broader privileges.
Jailbroken devices bypass sandbox restrictions (but violate Apple’s policies).

The sandbox is a core reason iOS is considered more secure than open platforms. Developers must work within its constraints while using Apple’s APIs for permitted interactions.

Our privacy is compromised the moment a malicious app can access another app’s sandbox. Theoretically, this kind of sandbox breach hasn’t been documented on iOS—at least not to my knowledge. However, the video «Broken Isolation – Draining Your Credentials from Popular macOS Password Managers« by Wojciech Reguła (NSSpain 2024) demonstrates how, on macOS, a malicious app can gain access to the sandboxes of other apps that store user passwords—such as NordPass, KeePass, Proton Pass, and even 1Password.

Sandbox data container folders

Each iOS app has its own container directory with several subdirectories. Here’s a breakdown of the key folders and their purposes:

1. Documents

Path: .../Documents/
Purpose: Stores user-generated content or data that should persist and be backed up to iCloud.
Example: Saved notes, PDFs, exported data.
Backup: ✅ Included in iCloud/iTunes backups.
Access: Read/Write.

2. Library

Path: .../Library/
Purpose: Stores app-specific files and configuration data.
It has two main subfolders:
- Preferences
  - .../Library/Preferences/
  - Stores user settings (e.g., using UserDefaults).
  - Managed automatically by the system.
- Caches
  - .../Library/Caches/
  - Used for data that can be regenerated (e.g., image cache).
  - Not backed up, and iOS may delete files here when space is low.
  - ⚠️ Don’t store critical data here.

4. tmp

Path: .../tmp/
Purpose: Temporary files your app doesn’t need to persist between launches.
Backup: ❌ Not backed up.
Auto-clean: iOS may clean this directory at any time.
Access: Read/Write.

Summary Table

Folder	Purpose	Persistent	Backed Up	iOS May Delete
App Bundle	App code and resources	✅	✅	❌
Documents	User data/files	✅	✅	❌
Library/Preferences	App settings (`UserDefaults`)	✅	✅	❌
Library/Caches	Cached data (non-critical)	✅	❌	✅
tmp	Temporary files	❌	❌	✅

Files operations

For this section, we have developed a sample iOS application that performs storage operations using files. The app displays an empty list with an «Add» button in the navigation bar. Each time the button is pressed, a new person is added to the list. The list of people serves as the model and is persisted as a .json file.

When we deploy on simulator (or real device):

The component that handles files operations:

class FileManagerHelper {
    static let shared = FileManagerHelper()
    
    private let fileName = "people.json"
    
    private var fileURL: URL {
        let documents = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask).first!
        return documents.appendingPathComponent(fileName)
    }

    func save(_ people: [Person]) {
        do {
            let data = try JSONEncoder().encode(people)
            try data.write(to: fileURL)
        } catch {
            print("Error saving file: \(error)")
        }
    }
    
    func load() -> [Person] {
        do {
            let data = try Data(contentsOf: fileURL)
            let people = try JSONDecoder().decode([Person].self, from: data)
            return people
        } catch {
            print("Error reading file: \(error)")
            return []
        }
    }
    
    func deleteFile() {
        do {
            try FileManager.default.removeItem(at: fileURL)
        } catch {
            print("Error deleting file: \(error)")
        }
    }
}

FileManagerHelper is a singleton utility that manages saving, loading, and deleting a JSON file named people.json in the app’s documents directory. It provides methods to encode an array of Person objects into JSON and save it to disk (save), decode and return the array from the saved file (load), and remove the file entirely (deleteFile). It handles errors gracefully by catching exceptions and printing error messages without crashing the app.

Conclusions

With that post, I just intended to give you an overview and demonstrate how easy it is to deal with file persistence as well.

You can find source code used for writing this post in following repository.

References

App Sandbox
Apple Developer Documentation
Broken isolation – draining your credentials ,,, – Wojciech Reguła
NSSpain 2024 speech

abril 21, 2025

Switching App Language on the Fly in Swift

Dynamically switching languages in views and using snapshot testing for multilingual validation it addresses a common challenge in global app development: ensuring seamless localization. Developers often struggle with updating UI text instantly when users change languages, and validating UI consistency across multiple locales can be tedious.

We will cover dynamic language switching for streamlining the user experience, on the other side snapshot testing ensures visual accuracy without manual verification.

Multilanguage iOS app

After creating an iOS sample we are going to include the language catalog:

Next step is adding a new language:

For this example we have chosen Spanish:

Next step we start to fill in string catalog for all languages defined:

Language controller

For implementing languange controller we will make use of Observer pattern, that means that this class state changes then all views subscribed to it will get notified and will be refreshed automatically:

class LocalizationManager: ObservableObject {
    @Published var locale: Locale = .current {
        didSet {
            UserDefaults.standard.set([locale.identifier], forKey: "AppleLanguages")
            UserDefaults.standard.synchronize()
        }
    }
    
    init() {
        if let preferredLanguage = UserDefaults.standard.array(forKey: "AppleLanguages")?.first as? String {
            locale = Locale(identifier: preferredLanguage)
        }
    }
    
    func toggleLanguage() {
        if locale.identifier == "en" {
            locale = Locale(identifier: "es")
        } else {
            locale = Locale(identifier: "en")
        }
    }
}

This Swift class, LocalizationManager, is an ObservableObject that manages the app’s language settings. It stores the current locale in UserDefaults under the key "AppleLanguages", ensuring that the language preference persists across app restarts. The locale property is @Published, so any UI elements observing it will update when the language changes. The initializer retrieves the stored language preference from UserDefaults or defaults to the system’s current locale. The toggleLanguage() method switches between English ("en") and Spanish ("es") by updating locale, which in turn updates UserDefaults. However, changing this value does not dynamically update the app’s language in real-time without restarting.

Finally build and run application:

Multilanguage view

View implementation is following:

struct ContentView: View {
    @StateObject private var localizationManager = LocalizationManager()
    
    var body: some View {
        VStack {
            Text("welcome_message".localized(with: localizationManager.locale))
                .padding()
            
            Button(action: {
                localizationManager.toggleLanguage()
            }) {
                Text("change_language".localized(with: localizationManager.locale))
                    .padding()
                    .background(Color.blue)
                    .foregroundColor(.white)
                    .cornerRadius(8)
            }
        }
        .environmentObject(localizationManager)
    }
}

This SwiftUI ContentView uses a @StateObject called LocalizationManager to manage language localization. It displays a localized welcome message and a button that allows users to toggle the app’s language. The Text elements use a .localized(with:) function to fetch translated strings based on the current locale from LocalizationManager. When the button is tapped, it calls toggleLanguage(), which presumably switches between different languages. The localizationManager is also injected into the SwiftUI environment using .environmentObject(), making it accessible throughout the app.

Finally, cleaner code on view, and it is a practice that I have seen in many projects is to create an extension for finally retrieve string translated, but this time with the add on that is parametrized with location language code:

extension String {
    func localized(with locale: Locale) -> String {
        let language = locale.identifier
        guard let path = Bundle.main.path(forResource: language, ofType: "lproj"),
              let bundle = Bundle(path: path) else {
            return NSLocalizedString(self, comment: "")
        }
        return bundle.localizedString(forKey: self, value: nil, table: nil)
    }
}

The extension adds a localized(with:) function to the String type, allowing it to return a localized version of the string based on the specified Locale. It first retrieves the locale’s language identifier and attempts to find the corresponding .lproj resource bundle in the app’s main bundle. If the bundle exists, it fetches the localized string from it; otherwise, it falls back to NSLocalizedString, which returns the string from the app’s default localization. This enables dynamic localization based on different languages.

Snapshot testing

Last but not least, apart from implementing a user interface that allows user to switch language when something is not propery understood on app regular usage. It opens up a new tesging scenario, we are possible to validate the same view presented in different languages, this will you make easier to detect texts that were not presented properly.

In Visual Regression Testing: Implementing Snapshots test on iOS post I present how to setup and implement snapshoptesting, is very easy setup. So basically we will bypass snapshot setup library and we will focus just only on sntapshots tests:

@Suite("Snapshot tests")
struct DynamicLanguageTests {

    let record = true

    @Test func testContentViewInEnglish() {
            let localizationManager = LocalizationManager()
            localizationManager.locale = Locale(identifier: "en")
            
            let contentView = ContentView()
                .environmentObject(localizationManager)
                .frame(width: 300, height: 200)
            
            let viewController = UIHostingController(rootView: contentView)
            
            assertSnapshot(
                of: viewController,
                as: .image(on: .iPhoneSe),
                named: "ContentView-English",
                record: record
            )
        }

    @Test  func testContentViewInSpanish() {
            let localizationManager = LocalizationManager()
            localizationManager.locale = Locale(identifier: "es")
            
            let contentView = ContentView()
                .environmentObject(localizationManager)
                .frame(width: 300, height: 200)
            
            let viewController = UIHostingController(rootView: contentView)
            
            assertSnapshot(
                of: viewController,
                as: .image(on: .iPhoneSe),
                named: "ContentView-Spanish",
                record: record
            )
        }
}

The DynamicLanguageTests struct, annotated with @Suite("Snapshot tests"), contains two test functions: testContentViewInEnglish() and testContentViewInSpanish(). Each function sets up a LocalizationManager with a specific locale (en for English, es for Spanish), creates a ContentView instance, embeds it in a UIHostingController, and captures a snapshot of the rendered UI on an iPhone SE device. The snapshots are named accordingly («ContentView-English» and «ContentView-Spanish») and compared against previously recorded images to detect unintended visual changes.

Conclusions

Dynamic Language Switch it could be an interesting implementation for allowing user swap view language for beter understaning., but also is more useful when we have to validate that a view is properly presente in all app languages, you can find the source code used for this post in the following repository.

References

Visual Regresion Testing: Implementing Snapshot test on iOS
JaviOS post

abril 7, 2025

Bitrise Magic: One-Click iOS Builds for Your QA Team

Automating iOS app distribution for QA and reviewers using Bitrise addresses a common pain point—manually sharing builds—by streamlining the process through CI/CD. Bitrise simplifies generating signed IPAs (for ad-hoc testing), uploading to TestFlight, and deploying to third-party services like Firebase App Distribution, all while handling code signing, versioning, and notifications automatically.

This post is a step-by-step guide to help developers set up Bitrise to generate an iOS build artifact for distribution to QA or any reviewer.

Getting in context

To develop this post, we need the app for internal distribution, an iOS Developer Program license from Apple, and a free Bitrise account.

The app we will distribute internally is an iOS project called SMOC. SMOC is a head-up display speedometer and dash camera. The app builds without issues, and all unit tests pass. While this may seem obvious, it’s important to ensure that build crashes do not occur during workflow executions.

Being a member of the Apple Developer Program is mandatory because, at some point during the Bitrise setup, you will need to connect to the Apple Developer portal with your credentials. Additionally, you will need to provide an API key (.p8 file) to Bitrise, generated in the Apple Developer portal and also the Development Certificate (.p12 file).

Bitrise offers a 30-day free trial account that allows you to experiment with and initiate iOS app internal distribution.

Generating Apple Developer API Keys

Login in into your Apple developer account:

Select User and Access. On the incoming screen, choose Integrations > App Store Connect API from the left-side menu. Under Equipment Keys, click the Add (+) button to create a new key.

Important point: Access must be set to ‘Administrative’; I was not successful with the ‘Developer’ role. Download the API key (.p8 file) to a secure location, as we will need it to configure Bitrise. The ID Key and Issuer ID have been masked for security reasons, but make sure to take note of them because you will need them later.

In addition to the API key (.p8 file), we also need the Apple Development Certificate (.p12 file). To obtain it, open Keychain and export the certificate. Remember the password you set during the export process, as it will be required when importing the certificate into Bitrise.

If the certificate is not in your keychain, you can create it via Xcode. Go to Settings > Accounts > Manage Certificates, and select Apple Development. The certificate will automatically be added to your local machine’s keychain and uploaded to the Apple Developer Portal.

General iOS Setup

Once logged into your Bitrise account, the first step—before configuring any project—is to set up some global Bitrise configurations that will be needed later. Since our codebase is hosted on GitHub, we will connect our GitHub account.

Now it’s time to add your API key. Go back to the previous screen, select ‘App Store Connect,’ and press the ‘Add API Key’ button.

The name is an identifier of your choice, but the Issuer ID and Key ID are obtained when you create an API key on the Apple Developer portal. Finally:

Following the ‘least privilege principle’, I initially created an API key with a Developer role. However, the workflow execution failed due to insufficient access rights, so I had to generate a new API key, this time with an Administrator role.

Lastly, we need to connect the Bitrise account with our Apple Developer account, just as we did with GitHub. However, this time, we need to go to the top-right user icon menu.

And connect with your Apple Developer (or Enterprise) account:

iOS Project setup

Now is the time to create a new project. Select the dashboard and click the ‘(+) New Project’ button.

Select ‘Add your App’:

Select ‘New project’:

And press Next.

Fill in the app title, mobile platform, and app bundle ID. Then, select ‘Integrations’ from the left menu.

And just indicate which API key you are going to use.

Go to the Dashboard and select ‘Configure’ in the project you’re working on.

Set up the project and access. In our case, we aim to provide CI builds to team members who either do not have access to Bitrise or are not permitted to use it.

In our case, the code repository is GitHub, so we set the URL to point to our repository.

Bitrise authorization is not strictly necessary because the repository is public. However, if it were private, we would need to authorize access. For the «Choose Branch» step, we select «No, skip auto-detection and configure settings manually» because, although the default branch is develop, developers often distribute builds to their QA colleagues based on their working branches rather than the default branch.

In the ‘Default configuration’, we set the project type, project (or workspace) filename, scheme, and distribution method. In our case, we are interested in distributing builds based on development to our QA team.

Next, we select the XCode version to be used as the toolchain and build machine. Due to our account subscription, we are limited to working with only one type of machine.

Set the app icon to add an avatar to the project, then select ‘Register a Webhook’ for me!

Configuration finished just press ‘View CI configuration’.

Configuration is almost complete, but not quite. Next, we need to upload the Development Certificate (.p12 file). To do this, select ‘Code Signing’ and then click ‘Add .p12 File.

Once added:

Even though we set the API key previously, I faced some compilation crashes that failed due to the API key, so I had to specify again which API key I was going to use.

Project configuration is ready. Now, select workflows to create our workflow, which is also known as pipelines in other contexts.

Workflow creation

On workflows select ‘(+) Create Workflow’:

Fill in the name of the workflow, as well as the workflow on which it is based. In our case, it is ‘archive_and_export_app’:

This would be ok in case our project used Cocoapods as a dependency manager, but is our case is not.

So we have to remove Cocoapods step:

Save workflow:

Workflow execution

Setup work finished, now is time to run the workflow, press ‘Start build’ button:

Press ‘Start build’:

After a few minutes….

If everything is set up correctly, the ‘Success’ message should appear. Now, press the ‘Right arrow’ icon to continue with the build distribution.

Install and run

We need to provide the app download URL, either by distributing a QR code or sharing the direct link. Our responsibilities as developers are complete.

As a QA reviewer, once we scan the QR code or enter the link in the device browser, we will see the following. The setup process will only occur the first time the app is installed. Subsequent re-installations (or removal and reinstallation) will not trigger the setup process again.

Select ‘Check compatibility’ and following alert will appear:

Select Allow for installing configutation profile. And Open Device Settings, General:

Select Allow for installing configutation profile. And Open Device Settings, General, VPN & Device Management:

And select ‘Install’. Remember this setup has to be done once per device and app distributed.

And yes, finally press install to begin installing the app on your device. The following animation will show you how the app is installed and execute:

Conclusions

Although the configuration process can be tedious, once it’s set up, the developer only needs to focus on executing the workflow on the desired working branch and providing the workflow or artifact distribution link to QA or any other interested reviewer. On the QA side, they simply need to click the link to install the app and start testing.

References

Bitrise
The CI/CD Platform built for Mobile DevOps
SMOC
Portfolio – On board car clip camera iOS App
SMOC
Apple Store

abril 4, 2025

QR Code Scanning in iOS

Scanning a URL encoded within a QR code and fetching its contents is particularly interesting because it addresses a common real-world scenario faced by developers. QR codes are widely used for sharing links, event details, and more, making it essential for iOS apps to handle them efficiently.

This post will not only guide developers through implementing QR code scanning using native frameworks like AVFoundation but also demonstrate how to seamlessly fetch and process the retrieved URL content using URLSession.

We will implement a client-server application where the server will provide a QR image and implement REST API services encoded within the QR code. The client will be an iOS app that scans the QR code and fetches the REST API service.

QR-Server

For the server, we will implement a Dockerized Node.js server to create a blank project.

npm init -y

Later on, we will need to integrate ‘express’ and ‘qrcode’ into the project.

npm install express qrcode

Server code is following:

const express = require('express');
const QRCode = require('qrcode');
const os = require('os');

const app = express();
const port = 3000;
const hostIP = process.env.HOST_IP || 'Desconocida';

app.get('/', (req, res) => {
    const url = `http://${hostIP}:${port}/data`;
    QRCode.toDataURL(url, (err, qrCode) => {
        if (err) res.send('Error generating QR code');
        res.send(`<!DOCTYPE html><html><body>
        <h2>Scan the QR code:</h2>
        <img src="${qrCode}" />
        </body></html>`);
    });
});

app.get('/data', (req, res) => {
    res.json({ message: 'Hello from QR-API-Server!' });
});

app.listen(port, () => {
    console.log(`Server running on http://${hostIP}:${port}`);
});

This Node.js script sets up an Express.js web server that generates a dynamic QR code. When the root URL («/») is accessed, the server creates a QR code containing a URL pointing to the /data endpoint. The QR code is displayed on an HTML page with the message «Scan the QR code.»

Accessing the /data endpoint returns a JSON object with the message: «Hello from QR-API-Server!». The server listens on port 3000, and the host IP address is either obtained from an environment variable or defaults to 'Desconocida' (Unknown) if not specified.

Next step: set up the Dockerfile.

# Base image for Node.js
FROM node:14

# Create and fix working dirctory
WORKDIR /usr/src/app

# Copy application files
COPY . .

# Install dependencies
RUN npm install

# Expose appliction port
EXPOSE 3000

# Command for starting server application
CMD ["node", "server.js"]

The Dockerfile sets up a Docker image for a Node.js application. It starts by using the official Node.js 14 base image. It then creates and sets the working directory to /usr/src/app. The application files from the local directory are copied into this working directory. Next, it installs the necessary dependencies using npm install. The image exposes port 3000, indicating that the application will listen on that port. Finally, the Docker container will run the Node.js server application by executing node server.js when started.

Get back to command line and create docker image:

docker build -t qr-server .

And finally run the image:

docker run -d -p 3000:3000 \ 
-e HOST_IP=$(ifconfig | grep "inet " | grep -v 127.0.0.1 | awk '{print $2}' | head -n 1) qr-server

You need to provide the host Docker machine’s container runner IP to allow an iOS app running on a real device (due to camera scanning) to access the server.

QR Scaner iOS App

Client is an iOS sample Scan app designed to scan QR codes and call the service endpoint encoded within the QR code. To perform scanning, the app will require access to the camera.

Open target build settings and fill in ‘Privacy – Camera Usage Description’. View code is following:

struct ContentView: View {
    @State private var scannedURL: String? = nil
    @State private var dataFromAPI: String? = nil
    @State private var showAlert = false
    @State private var alertMessage = ""

    var body: some View {
        VStack {
            if let scannedURL = scannedURL {
                Text("URL scanned: \(scannedURL)")
                    
                    .padding()

                Button("Do API Call") {
                    Task {
                        await fetchAPIData(from: scannedURL)
                    }
                }
                .padding()

                if let dataFromAPI = dataFromAPI {
                    Text("Data from API: \(dataFromAPI)")
                        .padding()
                }
            } else {
                ZStack {
                    
                    QRCodeScannerView {
                        self.scannedURL = $0
                    }
                    .edgesIgnoringSafeArea(.all)
                    Text("Scan QR code:")
                }

            }
        }
        .font(.title)
        .alert(isPresented: $showAlert) {
            Alert(title: Text("Error"), message: Text(alertMessage), dismissButton: .default(Text("OK")))
        }
    }

    func fetchAPIData(from url: String) async {
        guard let url = URL(string: url) else { return }

        do {
            let (data, response) = try await URLSession.shared.data(from: url)
            if let result = String(data: data, encoding: .utf8) {
                dataFromAPI = result
            }
        } catch {
            alertMessage = "Error: \(error.localizedDescription)"
            showAlert = true
        }
    }
}

SwiftUI code creates a ContentView that first scans a QR code to extract a URL, displays the scanned URL, and provides a button to fetch data from that URL via an API call, showing the result or an error alert if the request fails. The interface initially shows a QR scanner overlay with the prompt «Scan QR code,» and upon successful scanning, it displays the URL and a button to trigger the API call, which asynchronously retrieves and displays the data or shows an error message in an alert if something goes wrong. The layout uses a vertical stack (VStack) to organize the UI elements and adjusts fonts and padding for better readability.

QRCodeScannerView has to be implemented by using UIKit-UIViewControllerRepresentable bridge compontent:

import SwiftUI
import AVFoundation

struct QRCodeScannerView: UIViewControllerRepresentable {
    class Coordinator: NSObject, AVCaptureMetadataOutputObjectsDelegate {
        var parent: QRCodeScannerView

        init(parent: QRCodeScannerView) {
            self.parent = parent
        }

        func metadataOutput(_ output: AVCaptureMetadataOutput, didOutput metadataObjects: [AVMetadataObject], from connection: AVCaptureConnection) {
            if let metadataObject = metadataObjects.first {
                guard let readableObject = metadataObject as? AVMetadataMachineReadableCodeObject else { return }
                guard let stringValue = readableObject.stringValue else { return }
                AudioServicesPlaySystemSound(SystemSoundID(kSystemSoundID_Vibrate))
                parent.didFindCode(stringValue)
            }
        }
    }

    var didFindCode: (String) -> Void

    func makeCoordinator() -> Coordinator {
        return Coordinator(parent: self)
    }

    func makeUIViewController(context: Context) -> UIViewController {
        let viewController = UIViewController()
        let captureSession = AVCaptureSession()

        guard let videoCaptureDevice = AVCaptureDevice.default(for: .video) else { return viewController }
        let videoDeviceInput: AVCaptureDeviceInput

        do {
            videoDeviceInput = try AVCaptureDeviceInput(device: videoCaptureDevice)
        } catch {
            return viewController
        }

        if (captureSession.canAddInput(videoDeviceInput)) {
            captureSession.addInput(videoDeviceInput)
        } else {
            return viewController
        }

        let metadataOutput = AVCaptureMetadataOutput()

        if (captureSession.canAddOutput(metadataOutput)) {
            captureSession.addOutput(metadataOutput)

            metadataOutput.setMetadataObjectsDelegate(context.coordinator, queue: DispatchQueue.main)
            metadataOutput.metadataObjectTypes = [.qr]
        } else {
            return viewController
        }

        let previewLayer = AVCaptureVideoPreviewLayer(session: captureSession)
        previewLayer.frame = viewController.view.bounds
        previewLayer.videoGravity = .resizeAspectFill
        viewController.view.layer.addSublayer(previewLayer)

        Task {
            captureSession.startRunning()
        }
        return viewController
    }

    func updateUIViewController(_ uiViewController: UIViewController, context: Context) {}
}

The code creates a QR code scanner view that uses AVFoundation to capture and process QR codes, where it sets up a camera preview layer, configures a capture session to detect QR codes, and triggers a vibration and callback function (didFindCode) when a QR code is successfully scanned, passing the decoded string value to the parent view. The UIViewControllerRepresentable protocol bridges UIKit’s AVCaptureMetadataOutput functionality into SwiftUI, with a Coordinator class handling the metadata output delegation to process detected codes.

Important point for scanning you need to deploy on a real iOS device:

As soon as the QR code URL is read, it is presented to the user. When the user presses ‘Do API Call’, the iOS app performs a request to the service.

Conclusions

In this post I have presented how to consume API services where endpoints are could be dynamically provided by server via QR codes. If you’re interested in exploring the implementation further, you can find the source code used for this post in the following repository.

References

Writing a Barcode Reader App in No Time
JaviOS Post

marzo 31, 2025

Decluter Your Codebase: Periphery for Dead Code Detection

Periphery addresses a common challenge faced by developers: maintaining clean, efficient codebases. Periphery, an open-source tool, offers a powerful solution for identifying and eliminating unused code in Swift projects, which can significantly improve app performance, reduce compile times, and enhance overall code quality.

In this post we will explain how to setup Periphery on your iOS project for later on force any code situations to trgger expected warnings.

Setup Periphery

First step is install periphery by using homebrew installation method:

brew install periphery

Next step is creating juts a regular iOS Sample app with XCode:

brew install periphery

Move to the folder where the project was created and type:

And setup periphery for current iOS project:

periphery scan --setup

This will generate a hidden configuration file.

Get back to XCode Project:

And select the target, Build Phases, add (+) and NewScriptPhase. Do not forget unchecking ‘Based on dependency analysis’ option.

Script basically consists in calling periphery for performing and scan. Press CMD+B for build and check if setup was ok:

For fixing this issue just set User Script Sandboxing to No on Build Settings:

Turn to build again for checking that now thi time all works fine:

Detecting dead code

Periphery aims to detect and report unused declarations in your code. These declarations include classes, structs, protocols, functions, properties, constructors, enums, typealiases, and associated types. As expected, Periphery can identify straightforward cases, such as a class that is no longer referenced anywhere in your codebase. For the purpose of this post we have added some dead code for checking that warnings are really trigger every time we build de code (CMD+B).

Now appears new warnings that aims to dead code, but appart from thead code this utility also allows to detectct unused parameters:

Conclusions

Periphery is one of those tools that its setup effort is very low and will help you on removing dead code. If you’re interested in exploring the implementation further, you can find the source code used for this post in the following repository.

References

Periphery
GitHub repository

marzo 26, 2025

Beyond JSON Codables

Explore decoding not just JSON but also CSV, XML, Plist, and YAML using Codable is interesting because developers often work with diverse data formats beyond JSON. While Codable is primarily designed for JSON, showcasing how to extend its functionality to handle other formats efficiently can help developers streamline their data parsing workflow.

In this post, we will build an iOS sample app that will present how to parse codable data text format in JSON, CSV, XML, Plist and Yaml.

JSON

JSON (JavaScript Object Notation) is a lightweight data format used for storing and exchanging data in a human-readable and structured way. It is widely used because of its simplicity, readability, and compatibility with various programming languages. JSON represents data as key-value pairs, similar to a JavaScript object, making it easy to parse and generate. It is commonly used in web APIs, configurations, and data storage due to its efficiency, flexibility, and seamless integration with modern web technologies.

Parsing code is implemented along with with its presentation:

struct JSONView: View {
    @State private var people: [Person] = []

       func loadPeople() {
           let json = """
           [
               {"name": "Juan", "age": 30},
               {"name": "Ana", "age": 25},
               {"name": "Carlos", "age": 35}
           ]
           """
           
           let data = Data(json.utf8)
           
           do {
               let decodedPeople = try JSONDecoder().decode([Person].self, from: data)
               self.people = decodedPeople
           } catch {
               print("\(error)")
           }

       }

       var body: some View {
           NavigationView {
               PeopleListView(people: people)
               .navigationTitle("Persons List (JSON)")
           }
           .task {
               loadPeople()
           }
       }
}

This SwiftUI code defines a JSONView struct that loads and displays a list of people from a hardcoded JSON string. The loadPeople() function decodes the JSON into an array of Person objects and assigns it to the @State variable people. The body property presents a NavigationView containing a PeopleListView, passing the people array to it. The .task modifier ensures loadPeople() runs asynchronously when the view appears, populating the list.

XML

XML (Extensible Markup Language) is a structured text format used to store and transport data in a human-readable and machine-readable way. It organizes data using custom tags that define elements hierarchically, making it widely used for data exchange between systems. XML is closely related to SOAP (Simple Object Access Protocol), as SOAP messages are formatted using XML. SOAP is a protocol for exchanging structured information in web services, relying on XML to define message structure, including headers and body content. This enables platform-independent communication between applications over protocols like HTTP and SMTP.

XML is not supperted natively, so we have to import an SPM package such as SWXMLHash:

Code for parsing and presenting:

struct XMLView: View {
    @State private var people: [Person] = []

    func loadPeople() {
        let xmlString = """
                <Persons>
                    <Person>
                        <Name>Teresa</Name>
                        <Age>35</Age>
                    </Person>
                    <Person>
                        <Name>Ana</Name>
                        <Age>45</Age>
                    </Person>
                    <Person>
                        <Name>Carlos</Name>
                        <Age>35</Age>
                    </Person>
                </Persons>
                """

        let xml = XMLHash.config { _ in }.parse(xmlString)

        do {
            let fetchedPeople: [Person] = try xml["Persons"].children.map { element in
                let name: String = try element["Name"].value() ?? ""
                let age: Int = try element["Age"].value() ?? -1
                return Person(name: name, age: age)
            }
            people = fetchedPeople
        } catch {
            print("Error decoding XML: \(error)")
        }
    }

    var body: some View {
        NavigationView {
            PeopleListView(people: people)
                .navigationTitle("Persons List (XML)")
        }
            .task {
            loadPeople()
        }
    }
}

The XMLView SwiftUI struct parses an XML string containing a list of people and displays them in a PeopleListView. It defines a @State variable people to store the parsed data and a loadPeople() function that uses the XMLHash library to extract names and ages from the XML. The parsed data is then stored in people, which updates the UI. The body consists of a NavigationView that displays PeopleListView, and loadPeople() is called asynchronously using .task {} when the view appears. This setup ensures that the list is populated dynamically from the XML data.

CSV

CSV (Comma-Separated Values) is a widely used data text file format because it is simple, lightweight, and universally compatible across different software and programming languages. It stores tabular data in plain text, making it easy to read, edit, and process without requiring specialized software. CSV files are also highly efficient for data exchange between applications, databases, and spreadsheets since they maintain a structured yet human-readable format. Additionally, their lack of complex metadata or formatting ensures broad support and ease of integration in data processing workflows.

Parse in case of this file is are very simple string processing operations:

struct CSVView: View {
    @State private var people: [Person] = []
    
    func loadPeople() {
        let csvString = """
                name,age
                Ricardo,40
                Priscila,25
                Carlos,35
                """

        let lines = csvString.components(separatedBy: "\n")
            var persons: [Person] = []

            for line in lines.dropFirst() { // Remove header
                let values = line.components(separatedBy: ",")
                if values.count == 2, let age = Int(values[1]) {
                    persons.append(Person(name: values[0], age: age))
                }
            }
        people = persons
    }
    
    var body: some View {
        NavigationView {
            PeopleListView(people: people)
            .navigationTitle("Persons List (CSV)")
        }
        .task {
            loadPeople()
        }
    }
}

The CSVView struct in SwiftUI loads a hardcoded CSV string containing names and ages, parses it into an array of Person objects, and displays them using PeopleListView. It first defines a @State variable people to store the parsed data. The loadPeople() function splits the CSV string into lines, ignores the header, extracts name and age values, converts them into Person objects, and updates people. The body contains a NavigationView that presents PeopleListView, and the .task modifier ensures loadPeople() runs when the view appears, allowing dynamic data population.

Yaml

YAML is a common data text file format because it is human-readable, easy to write, and supports complex data structures like lists and key-value mappings in a simple, indentation-based syntax. It is widely used for configuration files, data serialization, and automation scripts in DevOps, Kubernetes, and CI/CD pipelines due to its readability compared to JSON and XML. Additionally, YAML supports comments, anchors, and references, making it more flexible for structured data representation while remaining easy to integrate with various programming languages.

Yaml, as well as XML, is also not supperted natively, so we have to import an SPM package such as Yams:

Code for parsing and presenting:

struct YamlView: View {
    @State private var people: [Person] = []

       func loadPeople() {
           let json = """
           - name: Sebastián
             age: 32
           - name: Ana
             age: 26
           - name: Pedro
             age: 35
           """
           
           let data = Data(json.utf8)
           
           do {
               let decodedPeople = try YAMLDecoder().decode([Person].self, from: data)
               self.people = decodedPeople
           } catch {
               print("\(error)")
           }

       }

       var body: some View {
           NavigationView {
               PeopleListView(people: people)
               .navigationTitle("Persons List (Yaml)")
           }
           .task {
               loadPeople()
           }
       }
}

This SwiftUI view, YamlView, loads a list of people from a YAML-formatted string and displays them in a PeopleListView. It uses @State to store an array of Person objects and defines a loadPeople() function that converts a hardcoded YAML string into a Data object, decodes it into an array of Person structs using YAMLDecoder(), and updates the state. In the body, it presents a NavigationView with PeopleListView, setting «Persons List (Yaml)» as the navigation title. The .task modifier ensures loadPeople() runs asynchronously when the view appears.

PList

Last but not least, and old fatigue companiong that get along with us during many years in XCode projects.PLIST (Property List) is a common data text file format, especially in Apple’s ecosystem, because it is human-readable, structured, and easily parsed by both machines and developers. It supports hierarchical data storage, making it ideal for configuration files, preferences, and serialization in macOS and iOS applications. PLIST files can be formatted in XML or binary, allowing flexibility in readability and performance. Their native support in Apple frameworks, such as Core Foundation and Swift, makes them a default choice for storing structured data in a standardized way.

A god point it that is supported natively:

struct Plist: View {
    @State private var people: [Person] = []

    func loadPeople() {
        let plist = """
           <?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">
               <array>
                   <dict>
                       <key>name</key>
                       <string>Juan Pérez</string>
                       <key>age</key>
                       <integer>30</integer>
                   </dict>
                   <dict>
                       <key>name</key>
                       <string>Ana Gómez</string>
                       <key>age</key>
                       <integer>25</integer>
                   </dict>
                   <dict>
                       <key>name</key>
                       <string>Sílvia</string>
                       <key>age</key>
                       <integer>55</integer>
                   </dict>
               </array>
           </plist>
           """

        let data = Data(plist.utf8)

        do {
            let decodedPeople = try PropertyListDecoder().decode([Person].self, from: data)
            self.people = decodedPeople
        } catch {
            print("\(error)")
        }

    }

    var body: some View {
        NavigationView {
            PeopleListView(people: people)
                .navigationTitle("Persons List (Plist)")
        }
            .task {
            loadPeople()
        }
    }
}

This SwiftUI View named Plist loads a hardcoded Property List (Plist) containing an array of people, decodes it into an array of Person objects using PropertyListDecoder(), and displays the list using a PeopleListView. The loadPeople() function parses the embedded XML-based Plist data, converting it into Data, decodes it into an array of Person structs, and assigns it to the @State variable people. The body of the view contains a NavigationView that initializes PeopleListView with the decoded list and sets the navigation title. The .task modifier ensures that loadPeople() runs when the view appears, populating the list dynamically. If decoding fails, an error message is printed.

Conclusions

In this project, we have seen the most common data text formats and how to parse them. You can find source code used for writing this post in following repository.

marzo 24, 2025

Visual Regresion Testing: Implementing Snapshot test on iOS

Implementing snapshot tests alongside regular unit tests is valuable because it addresses an often-overlooked aspect of testing: UI consistency. While unit tests verify business logic correctness, snapshot tests capture and compare UI renderings, preventing unintended visual regressions. This is especially useful in dynamic UIs, where small code changes might break layouts without being detected by standard tests.

By demonstrating how to integrate snapshot testing effectively, we aim to help developers enhance app stability, streamline UI testing, and adopt a more comprehensive test-driven approach.

Setup iOS Project

We willl creeate a regular iOS app project, with Swift test target (not XCTest):

To include the swift-snapshot-testing package in your project, add it via Swift Package Manager (SPM) using the following URL: https://github.com/pointfreeco/swift-snapshot-testing.

Important: When adding the package, ensure you assign it to the test target of your project. This is necessary because swift-snapshot-testing is a testing framework and should only be linked to your test bundle, not the main app target.

We will continue by implementing the views that will be validated:

struct RootView: View {
    @State var navigationPath = NavigationPath()

    var body: some View {
        NavigationStack(path: $navigationPath) {
            ContentView(navigationPath: $navigationPath)
                .navigationDestination(for: String.self) { destination in
                    switch destination {
                    case "SecondView":
                        SecondView(navigationPath: $navigationPath)
                    case "ThirdView":
                        ThirdView(navigationPath: $navigationPath)
                    default:
                        EmptyView()
                    }
                }
        }
    }
}

struct ContentView: View {
    @Binding var navigationPath: NavigationPath

    var body: some View {
        VStack {
            Text("First View")
                .font(.largeTitle)
                .padding()
            
            Button(action: {
                navigationPath.append("SecondView")
            }) {
                Text("Go to second viee")
                    .padding()
                    .background(Color.blue)
                    .foregroundColor(.white)
                    .cornerRadius(10)
            }
            .accessibilityIdentifier("incrementButton")
        }
        .navigationTitle("First View")
    }
    
    func testButtonPress() {
        navigationPath.append("SecondView")
    }
}

struct SecondView: View {
    @Binding var navigationPath: NavigationPath

    var body: some View {
        VStack {
            Text("Second View")
                .font(.largeTitle)
                .padding()
            
            Button(action: {
                navigationPath.append("ThirdView")
            }) {
                Text("Go to third view")
                    .padding()
                    .background(Color.green)
                    .foregroundColor(.white)
                    .cornerRadius(10)
            }
        }
        .navigationTitle("Second View")
    }
}

struct ThirdView: View {
    @Binding var navigationPath: NavigationPath

    var body: some View {
        VStack {
            Text("Third View")
                .font(.largeTitle)
                .padding()
            
            Button(action: {
                // Pop to root
                navigationPath.removeLast(navigationPath.count) // Empty stack
            }) {
                Text("Get back to first view")
                    .padding()
                    .background(Color.red)
                    .foregroundColor(.white)
                    .cornerRadius(10)
            }
        }
        .navigationTitle("Third view")
    }
}

The provided SwiftUI code defines a navigation flow where a user can navigate through three views: FirstView, SecondView, and ThirdView. It uses a NavigationStack to manage the navigation path with a NavigationPath that is shared across views. In ContentView, the user can navigate to SecondView by pressing a button. In SecondView, the user can proceed to ThirdView with another button. In ThirdView, there is a button that clears the navigation stack, taking the user back to the FirstView. The navigation path is managed using the navigationPath state, and the specific view to navigate to is determined by the string values in the navigation path.

Snapshop testing

napshot testing in iOS is a method that focuses on verifying the visual elements of an app’s user interface, such as fonts, colors, layouts, and images. It involves capturing a screenshot of the UI and saving it as a reference image, then comparing it pixel by pixel with new screenshots taken during subsequent tests. This technique allows developers to quickly detect unintended visual changes or regressions caused by code modifications, ensuring UI consistency across different versions of the app. By automating visual verification, snapshot testing complements other testing methods, such as unit and integration tests, by specifically addressing the app’s visual aspects and helping maintain a high-quality user experience.

Swift Testing allows test functions to be parameterized. In our case, we will parameterize test functions based on the device screen we are interested in.

protocol TestDevice {
    func viewImageConfig() -> ViewImageConfig
}

struct iPhoneSe: TestDevice  {
     func viewImageConfig() -> ViewImageConfig {
        ViewImageConfig.iPhoneSe
    }
}

struct iPhone13ProMax: TestDevice  {
     func viewImageConfig() -> ViewImageConfig {
        ViewImageConfig.iPhone13ProMax(.portrait)
    }
}

struct iPhone12Landscape: TestDevice  {
     func viewImageConfig() -> ViewImageConfig {
         ViewImageConfig.iPhone12(.landscape)
    }
}

For our sample, we will use an iPhone SE, iPhone 13 Pro Max, and iPhone 12 (in landscape mode). Finally, the test itself:

@MainActor
@Suite("Snapshot tests")
struct SnapshotTests {
    
    var record = true // RECORDING MODE!
    static let devices: [TestDevice] = [iPhoneSe(), iPhone13ProMax(), iPhone12Landscape()]
    
    @Test(arguments: devices) func testFirstView(device: TestDevice) {
        let rootView = RootView()
        let hostingController = UIHostingController(rootView: rootView)
        var named = String(describing: type(of: device))
        assertSnapshot(of: hostingController,
                       as: .image(on: device.viewImageConfig()),
                       named: named,
                       record: record)
    }
    
    @Test(arguments: devices) func testSecondView(device: TestDevice) {
        let secondView = SecondView(navigationPath: .constant(NavigationPath()))
        let hostingController = UIHostingController(rootView: secondView)

        var named = String(describing: type(of: device))
        
        assertSnapshot(of: hostingController,
                       as: .image(on: device.viewImageConfig()),
                       named: named,
                       record: record)
    }
    
    @Test(arguments: devices) func testThirdView(device: TestDevice) {
        let thirdView = ThirdView(navigationPath: .constant(NavigationPath()))
        let hostingController = UIHostingController(rootView: thirdView)

        var named = String(describing: type(of: device))
        
        assertSnapshot(of: hostingController,
                       as: .image(on: device.viewImageConfig()),
                       named: named,
                       record: record)
    }
}

We have defined a test function for each screen to validate. On the first execution, var record = true, meaning that reference screenshots will be taken. Run the test without worrying about failure results.

The important point is that a new folder called __Snapshots__ has been created to store the taken snapshots. These snapshots will serve as reference points for comparisons. Don’t forget to commit the screenshots. Now, switch record to false to enable snapshot testing mode

...
var record = false // SNAPSHOT TESTING MODE!
...

Run the test and now all must be green:

Do test fail!

Now we are going to introduce some changes to the view:

Launch test: We now face issues where the tests validating ContentView are failing:

When we review logs, we can see in which folder the snapshots are stored.

With your favourite folder content comparator compare both folders:

In my case, I use Beyond Compare, click on any file pair:

With the image comparator included in BeyondCompare we can easily see with view components have changed.

Conclusions

Snapshot testing is a valuable complement to unit testing, as it enables you to detect regressions in views more effectively. If you’re interested in exploring the implementation further, you can find the source code used for this post in the following repository.

References

swift-snapshot-testing
GitHub repository
Beyond Compare
Folder, test file, images comparator

marzo 21, 2025

S.O.L.I.D. principles in Swift

Applying SOLID principles to Swift is valuable because it enhances code quality, maintainability, and scalability while leveraging Swift’s unique features like protocols, value types, and strong type safety. Swift’s modern approach to object-oriented and protocol-oriented programming aligns well with SOLID, making it essential for developers aiming to write modular, testable, and flexible code.

In this post we will revieew 5 principles by examples.

S.O.L.I.D. principles

The SOLID principles are a set of five design guidelines that help developers create more maintainable, flexible, and scalable software. These principles were introduced by Robert C. Martin, also known as Uncle Bob, and are widely adopted in object-oriented programming. The acronym SOLID stands for: Single Responsibility Principle (SRP), Open/Closed Principle (OCP), Liskov Substitution Principle (LSP), Interface Segregation Principle (ISP), and Dependency Inversion Principle (DIP). Each principle addresses a specific aspect of software design, such as ensuring that a class has only one reason to change (SRP), allowing systems to be extended without modifying existing code (OCP), ensuring derived classes can substitute their base classes without altering behavior (LSP), creating smaller, more specific interfaces instead of large, general ones (ISP), and depending on abstractions rather than concrete implementations (DIP).

By adhering to the SOLID principles, developers can reduce code complexity, improve readability, and make systems easier to test, debug, and extend. For example, SRP encourages breaking down large classes into smaller, more focused ones, which simplifies maintenance. OCP promotes designing systems that can evolve over time without requiring extensive rewrites. LSP ensures that inheritance hierarchies are robust and predictable, while ISP prevents classes from being burdened with unnecessary dependencies. Finally, DIP fosters loose coupling, making systems more modular and adaptable to change. Together, these principles provide a strong foundation for writing clean, efficient, and sustainable code.

SRP-Single responsability principle

The Single Responsibility Principle (SRP) is one of the SOLID principles of object-oriented design, stating that a class or module should have only one reason to change, meaning it should have only one responsibility or job. This principle emphasizes that each component of a system should focus on a single functionality, making the code easier to understand, maintain, and test. By isolating responsibilities, changes to one part of the system are less likely to affect others, reducing the risk of unintended side effects and improving overall system stability. In essence, SRP promotes modularity and separation of concerns, ensuring that each class or module is cohesive and focused on a specific task.

// Violating SRP
class EmployeeNonSRP {
    let name: String
    let position: String
    let salary: Double
    
    init(name: String, position: String, salary: Double) {
        self.name = name
        self.position = position
        self.salary = salary
    }
    
    func calculateTax() -> Double {
        // Tax calculation logic
        return salary * 0.2
    }
    
    func saveToDatabase() {
        // Database saving logic
        print("Saving employee to database")
    }
    
    func generateReport() -> String {
        // Report generation logic
        return "Employee Report for \(name)"
    }
}

// Adhering to SRP
class Employee {
    let name: String
    let position: String
    let salary: Double
    
    init(name: String, position: String, salary: Double) {
        self.name = name
        self.position = position
        self.salary = salary
    }
}

class TaxCalculator {
    func calculateTax(for employee: Employee) -> Double {
        return employee.salary * 0.2
    }
}

class EmployeeDatabase {
    func save(_ employee: Employee) {
        print("Saving employee to database")
    }
}

class ReportGenerator {
    func generateReport(for employee: Employee) -> String {
        return "Employee Report for \(employee.name)"
    }
}

In the first example, the Employee class violates SRP by handling multiple responsibilities: storing employee data, calculating taxes, saving to a database, and generating reports.

The second example adheres to SRP by separating these responsibilities into distinct classes. Each class now has a single reason to change, making the code more modular and easier to maintain.

OCP-Open/Close principle

The Open/Closed Principle (OCP) is one of the SOLID principles of object-oriented design, stating that software entities (such as classes, modules, and functions) should be open for extension but closed for modification. This means that the behavior of a system should be extendable without altering its existing code, allowing for new features or functionality to be added with minimal risk of introducing bugs or breaking existing functionality. To achieve this, developers often rely on abstractions (e.g., interfaces or abstract classes) and mechanisms like inheritance or polymorphism, enabling them to add new implementations or behaviors without changing the core logic of the system. By adhering to OCP, systems become more flexible, maintainable, and scalable over time.

protocol Shape {
    func area() -> Double
}

struct Circle: Shape {
    let radius: Double
    func area() -> Double {
        return 3.14 * radius * radius
    }
}

struct Square: Shape {
    let side: Double
    func area() -> Double {
        return side * side
    }
}

// Adding a new shape without modifying existing code
struct Triangle: Shape {
    let base: Double
    let height: Double
    func area() -> Double {
        return 0.5 * base * height
    }
}

// Usage
let shapes: [Shape] = [
    Circle(radius: 5),
    Square(side: 4),
    Triangle(base: 6, height: 3)
]

for shape in shapes {
    print("Area: \(shape.area())")
}

In this example the Shape protocol defines a contract for all shapes. New shapes like Circle, Square, and Triangle can be added by conforming to the protocol without modifying existing code. This adheres to OCP by ensuring the system is open for extension (new shapes) but closed for modification (existing code remains unchanged).

LSP-Liksov substitution principle

The Liskov Substitution Principle (LSP) is one of the SOLID principles of object-oriented design, named after Barbara Liskov. It states that objects of a superclass should be replaceable with objects of a subclass without affecting the correctness of the program. In other words, a subclass should adhere to the contract established by its superclass, ensuring that it can be used interchangeably without causing unexpected behavior or violating the assumptions of the superclass. This principle emphasizes the importance of designing inheritance hierarchies carefully, ensuring that derived classes extend the base class’s functionality without altering its core behavior. Violations of LSP can lead to fragile code, bugs, and difficulties in maintaining and extending the system.

protocol Vehicle {
    func move()
}

class Car: Vehicle {
    func move() {
        print("Car is moving")
    }
    
    func honk() {
        print("Honk honk!")
    }
}

class Bicycle: Vehicle {
    func move() {
        print("Bicycle is moving")
    }
    
    func ringBell() {
        print("Ring ring!")
    }
}

func startJourney(vehicle: Vehicle) {
    vehicle.move()
}

let car = Car()
let bicycle = Bicycle()

startJourney(vehicle: car)      // Output: Car is moving
startJourney(vehicle: bicycle)  // Output: Bicycle is moving

In this example, both Car and Bicycle conform to the Vehicle protocol, allowing them to be used interchangeably in the startJourney function without affecting the program’s behavior

ISP-Interface segregation principle

The Interface Segregation Principle (ISP) is one of the SOLID principles of object-oriented design, which states that no client should be forced to depend on methods it does not use. In other words, interfaces should be small, specific, and tailored to the needs of the classes that implement them, rather than being large and monolithic. By breaking down large interfaces into smaller, more focused ones, ISP ensures that classes only need to be aware of and implement the methods relevant to their functionality. This reduces unnecessary dependencies, minimizes the impact of changes, and promotes more modular and maintainable code. For example, instead of having a single interface with methods for printing, scanning, and faxing, ISP would suggest separate interfaces for each responsibility, allowing a printer class to implement only the printing-related methods.

// Violating ISP
protocol Worker {
    func work()
    func eat()
}

class Human: Worker {
    func work() {
        print("Human is working")
    }
    func eat() {
        print("Human is eating")
    }
}

class Robot: Worker {
    func work() {
        print("Robot is working")
    }
    func eat() {
        // Robots don't eat, but forced to implement this method
        fatalError("Robots don't eat!")
    }
}

// Following ISP
protocol Workable {
    func work()
}

protocol Eatable {
    func eat()
}

class Human: Workable, Eatable {
    func work() {
        print("Human is working")
    }
    func eat() {
        print("Human is eating")
    }
}

class Robot: Workable {
    func work() {
        print("Robot is working")
    }
}

In this example, we first violate ISP by having a single Worker protocol that forces Robot to implement an unnecessary eat() method. Then, we follow ISP by splitting the protocol into Workable and Eatable, allowing Robot to only implement the relevant work() method.

DIP-Dependency injection principle

The Dependency Inversion Principle (DIP) is one of the SOLID principles of object-oriented design, which states that high-level modules (e.g., business logic) should not depend on low-level modules (e.g., database access or external services), but both should depend on abstractions (e.g., interfaces or abstract classes). Additionally, abstractions should not depend on details; rather, details should depend on abstractions. This principle promotes loose coupling by ensuring that systems rely on well-defined contracts (interfaces) rather than concrete implementations, making the code more modular, flexible, and easier to test or modify. For example, instead of a high-level class directly instantiating a low-level database class, it would depend on an interface, allowing the database implementation to be swapped or mocked without affecting the high-level logic.

protocol Engine {
    func start()
}

class ElectricEngine: Engine {
    func start() {
        print("Electric engine starting")
    }
}

class Car {
    private let engine: Engine
    
    init(engine: Engine) {
        self.engine = engine
    }
    
    func startCar() {
        engine.start()
    }
}

let electricEngine = ElectricEngine()
let car = Car(engine: electricEngine)
car.startCar() // Output: Electric engine starting

In this example, the Car class depends on the Engine protocol (abstraction) rather than a concrete implementation, adhering to the DIP

Conclusions

We have demonstrated how the SOLID principles align with Swift, so there is no excuse for not applying them. You can find source code used for writing this post in following repository.

References

Clean Code – Uncle Bob / Lesson 1
YouTube

marzo 17, 2025

Autor: admin

iCloud

Setup iCloud on simulator

iOS Ranking app

iCloud Console

Finally…

Conclusions

References

NSCache

The viewmodel for AsyncImage View component

The AsyncImage view component

The View

Conclusions

References

The Sandbox

Key Features of iOS Sandbox:

Why Does iOS Use a Sandbox?

Example: Accessing the Sandbox in Code

Exceptions to the Sandbox:

Sandbox data container folders

1. Documents

2. Library

4. tmp

Summary Table

Files operations

Conclusions

References

Multilanguage iOS app

Language controller

Multilanguage view

Snapshot testing

Conclusions

References

Getting in context

Generating Apple Developer API Keys

General iOS Setup

iOS Project setup

Workflow creation

Workflow execution

Install and run

Conclusions

References

QR-Server

QR Scaner iOS App

Conclusions

References

Setup Periphery

Detecting dead code

Conclusions

References

JSON

XML

CSV

Yaml

PList

Conclusions

Setup iOS Project

Snapshop testing

Do test fail!

Conclusions

References

S.O.L.I.D. principles

SRP-Single responsability principle

OCP-Open/Close principle

LSP-Liksov substitution principle

ISP-Interface segregation principle

DIP-Dependency injection principle

Conclusions

References