appmigrationkit

What this skill does

# AppMigrationKit

One-time cross-platform data transfer for app resources. Enables apps to
export data to or import data from another platform (for example, Android)
during device setup or onboarding. AppMigrationKit APIs are iOS 26.0+ /
iPadOS 26.0+; the data-container entitlement is iOS 26.1+ / iPadOS 26.1+ /
Mac Catalyst 26.1+. Swift 6.3.

> **Beta-sensitive.** AppMigrationKit is new in iOS 26 and may change before GM.
> Re-check current Apple documentation before relying on specific API details.

AppMigrationKit uses an app extension model. The system orchestrates the
transfer between devices. The app provides an extension conforming to export
and import protocols, and the system calls that extension at the appropriate
time. The app itself never manages the network connection between devices.

## Contents

- [Architecture Overview](#architecture-overview)
- [Setup and Entitlements](#setup-and-entitlements)
- [App Migration Extension](#app-migration-extension)
- [Exporting Resources](#exporting-resources)
- [Importing Resources](#importing-resources)
- [Migration Status](#migration-status)
- [Progress Tracking](#progress-tracking)
- [Testing](#testing)
- [Common Mistakes](#common-mistakes)
- [Review Checklist](#review-checklist)
- [References](#references)

## Architecture Overview

AppMigrationKit operates through three layers:

1. **App extension** -- An `AppMigrationExtension` conforming type that the
   system invokes during migration. It handles data export and import.
2. **System orchestration** -- The OS manages the device-to-device session,
   transport, and scheduling. The extension does not control when it runs.
3. **Containing app** -- After migration completes, the app checks
   `MigrationStatus.importStatus` on first launch to determine whether
   migration occurred and whether it succeeded.

Key types:

| Type | Role |
|---|---|
| `AppMigrationExtension` | Protocol for the app extension entry point |
| `ResourcesExportingWithOptions` | Protocol for exporting files via archiver |
| `ResourcesExporting` | Simplified export protocol (no custom options) |
| `ResourcesImporting` | Protocol for importing files on the destination |
| `ResourcesArchiver` | Streams files into the export archive |
| `MigrationDataContainer` | Access to the containing app's data directories |
| `MigrationStatus` | Check import result from the containing app |
| `MigrationPlatform` | Identifies the other device's platform (e.g., `.android`) |
| `MigrationAppIdentifier` | Identifies the source app by store and bundle ID |
| `AppMigrationTester` | Test-only actor for validating export/import logic |

## Setup and Entitlements

### Entitlement

The app extension requires the `com.apple.developer.app-migration.data-container-access`
entitlement. Its value is a single-element string array containing the bundle
identifier of the containing app:

```xml
<key>com.apple.developer.app-migration.data-container-access</key>
<array>
    <string>com.example.myapp</string>
</array>
```

No other values are valid. This entitlement grants the extension read access
to the containing app's data container during export and write access during
import. The entitlement itself is available on iOS 26.1+, iPadOS 26.1+,
and Mac Catalyst 26.1+, even though the core AppMigrationKit APIs are
available on iOS 26.0+ and iPadOS 26.0+.

### Extension Target

Add a new App Extension target to the Xcode project. The extension conforms
to one or more of the migration protocols (`ResourcesExportingWithOptions`,
`ResourcesExporting`, `ResourcesImporting`).

## App Migration Extension

The extension entry point conforms to `AppMigrationExtension`. During
migration, the system prevents launching the containing app and its other
extensions to ensure exclusive data access.

### Accessing the Data Container

The extension accesses the containing app's files through `appContainer`:

```swift
import AppMigrationKit

struct MyMigrationExtension: ResourcesExporting {
    var resourcesSizeEstimate: Int { estimateTotalExportSize() }
    var resourcesVersion: String { "1.0" }
    var resourcesCompressible: Bool { true }

    func exportResources(
        to archiver: sending ResourcesArchiver,
        request: MigrationRequest
    ) async throws {
        let container = appContainer

        // container.bundleIdentifier     -- app's bundle ID
        // container.containerRootDirectory -- root of the app container
        // container.documentsDirectory    -- Documents/
        // container.applicationSupportDirectory -- Application Support/
    }
}
```

`MigrationDataContainer` provides `containerRootDirectory`, `documentsDirectory`,
and `applicationSupportDirectory` as `URL` values pointing into the containing
app's sandbox.

## Exporting Resources

Conform to `ResourcesExportingWithOptions` (or `ResourcesExporting` for no
custom options) to package files for transfer. The system calls
`exportResources(to:request:)` with a `ResourcesArchiver` and a
`MigrationRequestWithOptions`.

### Declaring Export Properties

```swift
struct MyMigrationExtension: ResourcesExportingWithOptions {
    typealias OptionsType = MigrationDefaultSupportedOptions

    var resourcesSizeEstimate: Int {
        // Return estimated total bytes of exported data
        calculateExportSize()
    }

    var resourcesVersion: String {
        "1.0"
    }

    var resourcesCompressible: Bool {
        true  // Let the system compress during transport
    }
}
```

- `resourcesSizeEstimate` -- Estimated total bytes. The system uses this for
  progress UI and free-space checks.
- `resourcesVersion` -- Format version string. The import side receives this
  to handle versioned data formats.
- `resourcesCompressible` -- When `true`, the archiver may compress files
  during transport.

### Implementing Export

```swift
func exportResources(
    to archiver: sending ResourcesArchiver,
    request: MigrationRequestWithOptions<MigrationDefaultSupportedOptions>
) async throws {
    let docsDir = appContainer.documentsDirectory

    // Check destination platform if needed
    if request.destinationPlatform == .android {
        // Platform-specific export logic
    }

    // Append files one at a time -- make continuous progress
    let userDataURL = docsDir.appending(path: "user_data.json")
    try await archiver.appendItem(at: userDataURL)

    // Append with a custom archive path
    let settingsURL = docsDir.appending(path: "settings.plist")
    try await archiver.appendItem(at: settingsURL, pathInArchive: "preferences/settings.plist")

    // Append a directory
    let photosDir = docsDir.appending(path: "photos")
    try await archiver.appendItem(at: photosDir, pathInArchive: "media/photos")
}
```

The archiver streams files incrementally. Call `appendItem(at:pathInArchive:)`
repeatedly as each resource is ready. The system may terminate the extension
if it appears hung, so avoid long gaps between append calls.

### Cancellation

`ResourcesArchiver` handles task cancellation automatically by throwing
cancellation errors. Do not catch these errors -- doing so causes the system
to kill the extension.

### Migration Platform

`MigrationRequestWithOptions` exposes `destinationPlatform` as a
`MigrationPlatform` value. Use this to tailor exported data:

```swift
if request.destinationPlatform == .android {
    // Export in a format the Android app expects
}
```

`MigrationPlatform` provides `.android` as a static constant. Custom
platforms can be created with `MigrationPlatform("customPlatform")`.

## Importing Resources

Conform to `ResourcesImporting` to receive transferred files on the
destination device. The system calls `importResources(at:request:)` after
app installation but before the app is launchable.

```swift
struct MyMigrationExtension: ResourcesImporting {
    func importResources(
        at importedDataURL: URL,
        request: ResourcesImportRequest
    ) async throws {
        let sourceVersion = request.sourceVersion
        le