iOS Beginner's Guide 

This guide is for developers, integrators, and solution architects who want to build and integrate the DC iOS SDK.

Overview 

DC iOS SDK is a modular identity platform for iOS apps. It provides the building blocks to:

  • onboard users through identity enrollment,
  • issue and manage credentials in an on-device wallet,
  • handle online authentication and request-driven flows,
  • share identity attributes in person (ISO 18013 scenarios),
  • maintain credential trust over time with update and lifecycle operations.

The SDK is designed so teams can start with core capabilities and add advanced modules incrementally.

Key Features 

  • Modular architecture (Core, Theme, Cryptography, enrollment plugins, in-person sharing).
  • Enrollment orchestration with resumable flows.
  • Document/face/liveness and channel-binding enrollment capabilities (module-based).
  • Wallet and credential lifecycle management.
  • Notification-based online authentication and request handling.
  • In-person sharing sessions and controlled transfer flows.
  • Lifecycle maintenance features like updates and key-rotation support.
  • PIN, face and liveness verification APIs.
  • iOS-focused SDK interfaces suitable for enterprise-grade identity apps.

Requirements 

For iOS integration, it must be performed on macOS with these tools:

  • Xcode 26.0+
  • iOS deployment target: 17.0+ (as defined in current podspecs).
  • Swift toolchain compatibility: 5.3+ (module podspec baseline).
  • iOS device (preferred) or simulator

SDK Plugins 

The SDK is distributed as a set of modules that can be integrated using either CocoaPods or manually.

SDK Plugin
Description
MobileIDEnrollmentPluginDocumentAuthentication (optional)Responsible for the document authentication enrollment step.
MobileIDEnrollmentPluginEmailBinding (optional)Responsible for the email binding enrollment step.
MobileIDEnrollmentPluginFabricPackage (optional)Responsible for the fabric package enrollment step.
MobileIDEnrollmentPluginFaceMatching (optional)Responsible for the face capture/matching enrollment step.
MobileIDEnrollmentPluginFingerCapture (optional)Responsible for the finger capture enrollment step.
MobileIDEnrollmentPluginPhoneBinding (optional)Responsible for the phone binding enrollment step.
MobileIDEnrollmentPluginPrepareLicense (optional)Responsible for the document/face capture license enrollment step.
MobileIDISO18013 (optional)Responsible for ISO 18013 in-person attribute sharing.

Note: The list of required plugins depends on backend services configuration and is provided with your integration configuration.

Integration 

Start with the minimal module set:

  • MobileIDCore
  • Required supporting modules from your chosen distribution package

Then add optional capability modules as needed:

  • Enrollment plugins (document, face matching, phone/email binding, etc.)
  • In-person sharing module
  • Theme/customization layers

Configuration 

Create a dedicated Configuration.swift file in your app target and define a typed MobileIDConfiguration object. This object is the single source of truth for SDK initialization.

Use a structure similar to:

Swift
1import Foundation
2import MobileIDCore
3import MobileIDEnrollmentPluginDocumentAuthentication
4import MobileIDEnrollmentPluginFaceMatching
5import MobileIDEnrollmentPluginPhoneBinding
6import MobileIDTheme
7

8extension MobileIDConfiguration {
9    static let sample: Self = .init(
10        apiKey: "<API_KEY>",
11        appInfo: AppInfoConfiguration(
12            project: "<PROJECT_CODE>"
13        ),
14        authServer: AuthServerConfiguration(
15            configurationEndpoint: URL(string: "https://<AUTH_SERVER_HOST>")!
16        ),
17        baseUrl: URL(string: "https://<BASE_API_HOST>")!,
18        colors: ThemeColorSet(
19            primary: MIDColor(hexString: "#330075"),
20            secondary: MIDColor(hexString: "#430099"),
21            grayscaleDark: MIDColor(hexString: "#101010"),
22            grayscaleMediumDark: MIDColor(hexString: "#4A4A4A"),
23            grayscaleMedium: MIDColor(hexString: "#9b9b9b"),
24            grayscaleLight: MIDColor(hexString: "#b3babe"),
25            accentRed: MIDColor(hexString: "#d0021b"),
26            accentOrange: MIDColor(hexString: "#f68d0c"),
27            accentGreen: MIDColor(hexString: "#429400"),
28            background: MIDColor(hexString: "#ffffff")
29        ),
30        enrollmentPlugins: [
31            MobileIDEnrollmentPluginPhoneBinding.EnrollmentPluginPhoneInfo.self,
32            MobileIDEnrollmentPluginPhoneBinding.EnrollmentPluginPhoneOtp.self,
33            MobileIDEnrollmentPluginDocumentAuthentication.EnrollmentPluginDocumentAuthentication.self,
34            MobileIDEnrollmentPluginFaceMatching.EnrollmentPluginFaceMatching.self,
35            MobileIDEnrollmentPluginFaceMatching.EnrollmentPluginLivenessSessionCreation.self,
36            MobileIDEnrollmentPluginFaceMatching.EnrollmentPluginLivenessMetadataMatching.self,
37            MobileIDEnrollmentPluginDocumentAuthentication.EnrollmentPluginMrzScanning.self,
38            MobileIDEnrollmentPluginDocumentAuthentication.EnrollmentPluginNfcScanning.self
39            ...
40        ],
41        enrollment: EnrollmentServiceConfiguration(
42            messageLevelEncryption: true
43        ),
44        captureSDKConfiguration: CaptureSDKConfiguration(
45            license: CaptureSDKLicense(
46                serverUrl: "https://<CAPTURE_LICENSE_SERVER>",
47                apiKey: "<CAPTURE_LICENSE_API_KEY>",
48                profileId: "<CAPTURE_PROFILE_ID>"
49            ),
50            settings: CustomCaptureSDKSettings(
51                enrollment: CustomLivenessSettings(
52                    livenessType: .active,
53                    targetsNumber: 3,
54                    securityLevel: .low,
55                    numberOfAttempts: 3,
56                    faceAcquisitionTimeout: 30_000,
57                    faceMatchingThreshold: nil,
58                    isIdleTimerDisabled: true
59                )
60            ),
61            sdkExperience: SDKExperienceConfiguration(
62                baseUrl: "https://<PROOFING_HOST>",
63                apiKey: "<PROOFING_API_KEY>"
64            )
65        ),
66        overriddenPreWalletJurisdictionId: nil,
67        walletDownloadConfiguration: .init(
68            overridenUrl: URL(string: "https://<BASE_API_HOST>/.well-known/mid-configuration")!,
69            timeToLiveInMinutes: 1440
70        ),
71        eventEmitterConfiguration: EventEmitterConfiguration(
72            url: "https://<ANALYTICS_HOST>/events",
73            apiKey: "<ANALYTICS_API_KEY>",
74            topic: "com.idemia.identity.mobileid.sdk",
75            analyticsEventsTenantId: "<TENANT_ID>"
76        )
77    )
78}

Then create the SDK main object using:

Swift
1let mobileID = try await MobileIDFactory.create(configuration: .sample)

Configuration checklist:

  • Use environment-specific endpoints for baseUrl and authServer.configurationEndpoint.
  • Register only the enrollment plugins enabled by your backend configuration.
  • Provide valid capture/proofing credentials when document/face flows are enabled.
  • Keep API keys and secrets outside source control (for example via xcconfig, CI secrets, or encrypted config injection).

Architecture 

The SDK is intentionally modular. Core orchestration stays stable while feature-specific capabilities are added as independent modules.

diagram

Architectural Responsibilities 

  • Host app: owns product UX, app navigation, and orchestration of SDK flows.
  • MobileID (entry point): central API surface created by MobileIDFactory; exposes enrollment, wallet, notifications, events, faceManager, pinManager, and pushNotifications.
  • Enrollment domain (mobileID.enrollment): starts/resumes/cancels enrollment, handles deep links, and coordinates plugin-driven enrollment steps.
  • Wallet and credential lifecycle (mobileID.wallet): provides credential inventory and removal; app uses it as the source of truth for credential state.
  • Online requests/authentication (mobileID.notifications): handles fetch/filter of requests and login-session style authentication orchestration.
  • In-person sharing (mobileID.iso()): creates ISO 18013 sessions and manages request/consent/transfer interactions with verifiers.
  • Lifecycle maintenance and trust operations (mobileID.update(), rotateKey, keyRotationStatus, updateMSO): keeps credentials and trust material valid over time.
  • Enrollment plugins + Theme/Security modules: plugins add capability-specific steps (document, face, phone, etc.); theme controls SDK visual consistency; crypto/security modules provide trusted key and data protection foundations.

Integration Pattern (Recommended) 

  1. Keep SDK initialization and configuration centralized.
  2. Wrap SDK calls in your app service layer.
  3. Isolate module adoption per capability (enrollment, notifications, in-person sharing).
  4. Add observability around step outcomes and failure states.
  5. Treat update/lifecycle events as first-class product flows, not background-only concerns.

Licensing 

The SDK is distributed under a proprietary/commercial model in this repository context.

Current module metadata indicates copyright ownership by Idemia.

Practical licensing guidance:

  • Confirm your commercial/license agreement before production use.
  • Validate module entitlement (some capabilities may be contract- or environment-scoped).
  • Review third-party dependency acknowledgements for notice obligations.
  • Ensure legal/security teams approve your deployment topology and redistribution model.

For governance, pair this guide with your organization’s legal onboarding checklist and the SDK’s distribution agreement.