Issue 161.  May 2nd 2024

Solve missing API declaration using required reason (ITMS-91053)

You might be getting this error with app submission on the app store. This update requires explaining why your app uses certain user data (like user defaults).

What to do:

• Understand the Error: You'll receive an email with details on missing explanations (e.g., for user defaults).
• Create a Privacy Manifest: (if missing) In Xcode, go to File > New File, search "privacy," and choose App Privacy.
• Find Required Reasons: Use Apple's documentation to find the reason matching your app's data usage.
• Add Reasons to Manifest: In your "PrivacyInfo.xcprivacy" file, list the API category (e.g., user defaults) and the reason (e.g., App Group access).

Deadline: May 1, 2024 (after this, apps without explanations will be rejected).

This guide simplifies the process. Resources and contact info are provided for further assistance.

Swift 6: Access level on import statements

Swift 6 introduces more control over what parts of your dependencies are visible. It changes the default import access level to internal (from public). Explicitly mark public imports to avoid errors.

Previously, sharing code from other sources (like libraries) was like leaving everything out in the open. Now, you can choose what parts to share:

• Secret Tools: Keep hidden helper functions private, like a secret toolbox.
• Public Tools: Share important functions everyone can use, like a public toolkit.
• Less Waiting: Sharing less code might make your project build faster.

This might require some tweaks to existing projects, but overall, it keeps your code cleaner and more organized!

Actor reentrancy in Swift explained

Swift actors are a powerful tool for managing concurrent code with shared state. However, a concept called "actor reentrancy" can introduce unexpected behavior, especially when using asynchronous operations within actors.

Why it matters:

• Imagine an actor that caches data locally and fetches it from a remote server if unavailable and an async read function handles these operations.
• With concurrent read calls, reentrancy can lead to issues like multiple unnecessary network requests are made, wasting resources and slowing down your app. And The actor's state might change during the suspension of the async function (e.g., while waiting for the network call). This can cause unexpected behavior when the function resumes.
• Solution for that: By tracking ongoing tasks within the actor, we can ensure that only one network request happens per data key, even with reentrant calls. This way, the actor reuses existing tasks instead of starting new ones for the same operation.

Understanding actor reentrancy is crucial when using async functions inside actors. By carefully considering state changes and reentrancy implications, you can avoid these pitfalls and write robust concurrent code in Swift.

Safe array subscription in Swift

This post offers a clever solution to prevent app crashes when accessing elements in your Swift arrays.

Using the standard [] subscript on arrays can crash if you try to access an element that doesn't exist.

A custom subscript extension for Collection allows you to access elements safely. It checks the index first and only returns the element if it's valid. Otherwise, it returns nil.

This extension promotes safer and more reliable Swift code by preventing crashes due to out-of-bounds array access.