Fase 3: Integrazione di Intune SDK nell'app iOS

Obiettivi di fase

• Scaricare Intune App SDK.
• Informazioni sui file inclusi in Intune App SDK.
• Fare riferimento a Intune App SDK nell'applicazione.
• Verificare che Intune App SDK sia incluso correttamente nella compilazione.
• Registrare nuovi account per la gestione MAM dopo l'autenticazione con MSAL.
• Per rimuovere i dati aziendali, annullare la registrazione degli account al disconnessione
• (Scelta consigliata) Incorporare l'accesso MAM nell'app.

Prerequisiti

• È necessario un computer macOS con Xcode 14.0 o versione successiva installato.

• L'app deve essere destinata a iOS 14.0 o versione successiva.

• Esaminare Intune App SDK per le condizioni di licenza per iOS. Stampare e conservare una copia delle condizioni di licenza per i record. Scaricando e usando Intune App SDK per iOS, si accettano tali condizioni di licenza. Se non li accetti, non usare il software.

• Scaricare i file per Intune App SDK per iOS in GitHub.

Informazioni sul repository SDK

• IntuneMAMSwift.xcframework: framework dinamico di Intune App SDK. È consigliabile collegare questo framework all'app o alle estensioni per abilitare la gestione delle applicazioni client di Intune. Tuttavia, alcuni sviluppatori potrebbero preferire i vantaggi in termini di prestazioni del framework statico (IntuneMAMStatic.xcframework). Vedere di seguito.

• IntuneMAMStatic.xcframework: framework statico di Intune App SDK. Gli sviluppatori possono scegliere di collegare il framework statico anziché il framework dinamico. Poiché il codice eseguibile di un framework statico viene incorporato direttamente nel file binario dell'app o dell'estensione in fase di compilazione, l'uso della libreria statica offre alcuni vantaggi in termini di prestazioni in fase di avvio. Tuttavia, se l'app include estensioni, il collegamento del framework statico all'app e alle estensioni comporta dimensioni del bundle dell'app maggiori, poiché il codice eseguibile viene incorporato in ogni file binario di app/estensione. Al contrario, quando si usa il framework dinamico, le app e le estensioni possono condividere lo stesso file binario di Intune SDK, con conseguente riduzione delle dimensioni dell'app.

• IntuneMAMSwiftStub.xcframework: framework Stub Swift di Intune App SDK. Questo framework è una dipendenza obbligatoria di IntuneMAMSwift.xcframework e IntuneMAMStatic.xcframework a cui devono essere collegati app/estensioni.

• IntuneMAMConfigurator: strumento usato per configurare Info.plist dell'app o dell'estensione con le modifiche minime necessarie per la gestione di Intune. A seconda della funzionalità dell'app o dell'estensione, potrebbe essere necessario apportare modifiche più manuali a Info.plist.

• libIntuneMAMSwift.xcframework: libreria statica di Intune App SDK. Questa variante di Intune MAM iOS SDK è deprecata e verrà rimossa in un aggiornamento futuro. È consigliabile non collegare la libreria statica e collegare invece l'app o le estensioni al framework dinamico (IntuneMAMSwift.xcframework) o al framework statico (IntuneMAMStatic.xcframework) menzionato in precedenza.

• IntuneMAMResources.bundle: bundle di risorse che contiene le risorse su cui si basa l'SDK. Il bundle di risorse è necessario solo per le app che integrano la libreria statica deprecata (libIntuneMAMSwift.xcframework) e verrà rimosso in un aggiornamento futuro.

Funzionamento di Intune App SDK

L'obiettivo di Intune App SDK per iOS è aggiungere funzionalità di gestione alle applicazioni iOS con modifiche minime al codice. Meno il codice cambia meno tempo sul mercato, ma senza influire sulla coerenza e la stabilità dell'applicazione per dispositivi mobili.

Flusso di processo

Il diagramma seguente fornisce il flusso di processo di Intune App SDK per iOS:

Compilare l'SDK nell'app per dispositivi mobili

Per abilitare Intune App SDK, seguire questa procedura:

1. IntuneMAMSwift.xcframework Collegamento o IntuneMAMStatic.xcframework alla destinazione: trascinare il bundle xcframework nell'elenco Framework, Librerie e Contenuto incorporato della destinazione del progetto. Ripetere questi passaggi per IntuneMAMSwiftStub.xcframework. Per l'app principale, selezionare "Incorpora & segno" nella colonna "Incorpora" per entrambi gli xcframework aggiunti. Per tutte le estensioni, selezionare "Non incorporare".

   

2. Aggiungere questi framework iOS al progetto:

   • MessageUI.framework
   • Security.framework
   • CoreServices.framework
   • SystemConfiguration.framework
   • libsqlite3.tbd
   • libc++.tbd
   • ImageIO.framework
   • LocalAuthentication.framework
   • AudioToolbox.framework
   • QuartzCore.framework
   • WebKit.framework
   • MetricKit.framework

3. Abilitare la condivisione keychain (se non è già abilitata) scegliendo Funzionalità in ogni destinazione del progetto e abilitando l'opzione Condivisione portachiava . La condivisione del portachiavi è necessaria per procedere al passaggio successivo.

   Nota

   Il profilo di provisioning deve supportare i nuovi valori di condivisione keychain. I gruppi di accesso keychain devono supportare un carattere jolly. È possibile verificarlo aprendo il file con estensione mobileprovision in un editor di testo, cercando keychain-access-groups e verificando di avere un carattere jolly. Ad esempio:

   <key>keychain-access-groups</key>
   <array>
   <string>YOURBUNDLESEEDID.*</string>
   </array>
   

4. Dopo aver abilitato la condivisione keychain, seguire la procedura per creare un gruppo di accesso separato in cui Intune App SDK archivierà i dati. È possibile creare un gruppo di accesso keychain usando l'interfaccia utente o il file entitlements. Se si usa l'interfaccia utente per creare il gruppo di accesso keychain, assicurarsi di seguire questa procedura:

   1. Se l'app per dispositivi mobili non ha gruppi di accesso keychain definiti, aggiungere l'ID bundle dell'app come primo gruppo.

   2. Aggiungere il gruppo com.microsoft.intune.mam keychain condiviso ai gruppi di accesso esistenti. Intune App SDK usa questo gruppo di accesso per archiviare i dati.

   3. Aggiungere com.microsoft.adalcache ai gruppi di accesso esistenti.

      

   4. Se si modifica direttamente il file entitlements, anziché usare l'interfaccia utente Xcode illustrata in precedenza per creare i gruppi di accesso keychain, anteporre i gruppi di accesso keychain con $(AppIdentifierPrefix) (Xcode lo gestisce automaticamente). Ad esempio:

      • $(AppIdentifierPrefix)com.microsoft.intune.mam
      • $(AppIdentifierPrefix)com.microsoft.adalcache

      Nota

      Un file entitlements è un file XML univoco per l'applicazione per dispositivi mobili. Viene usato per specificare autorizzazioni e funzionalità speciali nell'app iOS. Se l'app non aveva in precedenza un file entitlements, l'abilitazione della condivisione keychain (passaggio 3) avrebbe dovuto causare la generazione di Xcode per l'app. Verificare che l'ID bundle dell'app sia la prima voce nell'elenco.

5. Includi ogni protocollo a UIApplication canOpenURL cui l'app passa nella LSApplicationQueriesSchemes matrice del file Info.plist dell'app. Per ogni protocollo elencato in questa matrice, è necessario aggiungere anche una copia del protocollo aggiunto -intunemam alla matrice. Inoltre, , , , , , , , lacoonsecuritywandera, , lookoutwork-ase, skycure, betteractiveshield, , smsec, mvisionmobile, , scmxe intunemam-mtd devono essere aggiunti alla matrice. zipssmart-nsmicrosoft-edge-https-intunemammicrosoft-edge-http-intunemamhttps-intunemamhttp-intunemam Se l'app usa il protocollo mailto: , ms-outlook-intunemam deve essere aggiunto anche alla matrice. Assicurarsi di salvare le modifiche prima di procedere al passaggio successivo.

   Se l'app esaurisce lo spazio nell'elenco LSApplicationQueriesSchemes, può rimuovere gli schemi "-intunemam" per le app che sono note per implementare anche Intune MAM SDK. Quando l'app rimuove "scheme-intunemam" dall'elenco LSApplicationQueriesSchemes, canOpenURL() può restituire risposte non corrette per tali schemi. Per risolvere questo problema, l'app deve invece chiamare [IntuneMAMPolicy isURLAllowed:url isKnownManagedAppScheme:YES] per tale schema. Questa chiamata restituisce NO se il criterio blocca l'apertura dell'URL. Se restituisce true, l'app può chiamare canOpenURL() con un'identità vuota per determinare se l'URL può essere aperto. Ad esempio:

   BOOL __block canOpen = NO;
   if([policy isURLAllowed:urlForKnownManagedApp isKnownManagedAppScheme:YES])
   {
       [[IntuneMAMPolicyManager instance] setCurrentThreadAccountId:"" forScope:^{
       canOpen = [[UIApplication sharedApplication] canOpenURL:urlForKnownManagedApp];
       }];
   }
   

6. Se l'app non usa già FaceID, assicurarsi che la chiave NSFaceIDUsageDescription Info.plist sia configurata con un messaggio predefinito. Questo passaggio è necessario in modo che iOS possa comunicare all'utente come l'app intende usare FaceID. Un'impostazione dei criteri di protezione delle app di Intune consente l'uso di FaceID come metodo per l'accesso alle app quando configurato dall'amministratore IT.

7. Usare lo strumento IntuneMAMConfigurator incluso nel repository SDK per completare la configurazione di Info.plist dell'app. Lo strumento ha tre parametri:

   Proprietà	Come usarlo
   -io	<Path to the input plist>
   - e	<Path to the entitlements file>
   - o	(Facoltativo) <Path to the output plist>

   Se il parametro '-o' non è specificato, il file di input verrà modificato sul posto. Lo strumento è idempotente e deve essere eseguito di nuovo ogni volta che sono state apportate modifiche a Info.plist o diritti dell'app. È anche necessario scaricare ed eseguire la versione più recente dello strumento durante l'aggiornamento di Intune SDK, nel caso in cui i requisiti di configurazione di Info.plist siano stati modificati nella versione più recente.

Impostazioni di compilazione Xcode

L'app deve avere sia "Strip Swift Symbols"(STRIP_SWIFT_SYMBOLS) che "Enable Bitcode"(ENABLE_BITCODE) impostato su NO.

Integrazione di un'estensione del provider di file

Le estensioni del provider di file hanno determinati requisiti di memoria che potrebbero rendere difficile l'integrazione dell'SDK completo. Per semplificare questa operazione, è disponibile una libreria libIntuneMAMSwiftFileProvider.xcframework statica che è una versione rimossa dell'SDK specificamente per le estensioni del provider di file. Si noti che si tratta della parte non dell'interfaccia utente dell'estensione FileProvider. È necessario integrare l'SDK completo nell'estensione dell'interfaccia utente del provider di file.

Per integrare una di queste librerie con l'estensione provider di file, seguire la procedura per l'integrazione dell'SDK come libreria statica, come illustrato in precedenza. Assicurarsi di includere ContainingAppBundleId l'impostazione.

Integrazione di un'estensione del provider di file non replicata

L'app usa un provider di file non replicato se implementa il protocollo NSFileProviderExtension. Tutti i provider di file creati prima di iOS 16.0 non vengono replicati.

In - startProvidingItemAtURL:completionHandler: verificare se è necessario crittografare i file usando [[Istanza di IntuneMAMPolicy]shouldFileProviderEncryptFiles]]. Usare encryptFile:forAccountId: API in IntuneMAMFileProtectionManager per la crittografia effettiva dei file. Inoltre, condividere una copia del file quando è necessaria la crittografia perché non si vuole archiviare una copia crittografata del file nell'archiviazione cloud.

In - importDocumentAtURL:toParentItemIdentifier:completionHandler: verificare se il file è crittografato usando isFileEncrytped: API in IntuneMAMFileProtectionManager. Se viene quindi decrittografato usando decryptFile:toCopyPath: API di IntuneMAMFileProtectionManager. Nelle app multi-identità controllare anche l'API canReceiveSharedFile: in IntuneMAMPolicy del proprietario di destinazione per verificare se il proprietario può ricevere il file.

Integrazione di un'estensione del provider di file replicato

L'app usa un provider di file replicato se implementa il protocollo NSFileProviderReplicatedExtension (aggiunto in iOS 16.0).

In - fetchContentsForItemWithIdentifier:version:request:completionHandler: verificare se è necessario crittografare i file usando [[Istanza di IntuneMAMPolicy]shouldFileProviderEncryptFiles]]. Usare encryptFile:forAccountId: API in IntuneMAMFileProtectionManager per la crittografia effettiva dei file. Inoltre, condividere una copia del file quando è necessaria la crittografia perché non si vuole archiviare una copia crittografata del file nell'archiviazione cloud.

In - createItemBasedOnTemplate:fields:contents:options:request:completionHandler: controllare se il file è crittografato usando isFileEncrypted: API in IntuneMAMFileProtectionManager. Se viene quindi decrittografato usando decryptFile:toCopyPath: API di IntuneMAMFileProtectionManager. Nelle app multi-identità controllare anche l'API canReceiveSharedFile: in IntuneMAMPolicy del proprietario di destinazione per verificare se il proprietario può ricevere il file.

Ovunque il provider di file replicato crei e passi un oggetto NSFileProviderItem al sistema, chiama l'API protectFileProviderItem:forAccountId: di IntuneMAMFileProtectionManager con l'identità del proprietario dell'elemento. A seconda della posizione in cui l'oggetto NSFileProviderItem viene creato e salvato in modo permanente all'interno dell'estensione, potrebbe essere necessario eseguire questa operazione in ognuno dei metodi di protocollo NSFileProviderReplicatedExtension.

Configurare le impostazioni per Intune App SDK

È possibile usare il dizionario IntuneMAMSettings nel file Info.plist dell'applicazione per configurare e configurare Intune App SDK. Se il dizionario IntuneMAMSettings non viene visualizzato nel file Info.plist, è necessario crearlo.

Nel dizionario IntuneMAMSettings è possibile definire le impostazioni supportate seguenti per configurare Intune App SDK.

Alcune di queste impostazioni potrebbero essere state descritte nelle sezioni precedenti e altre non si applicano a tutte le app.

Ricevere i criteri di protezione delle app

Panoramica

Per ricevere i criteri di protezione delle app di Intune, le app devono avviare una richiesta di registrazione con il servizio MAM di Intune. Le app possono essere configurate nell'interfaccia di amministrazione di Intune per ricevere i criteri di protezione delle app con o senza registrazione del dispositivo. Gestione applicazioni mobili (MAM) consente di gestire le app da Intune senza la necessità di registrare il dispositivo nella gestione dei dispositivi mobili (MDM) di Intune. In entrambi i casi, la registrazione con il servizio MAM di Intune è necessaria per ricevere i criteri.

App che usano già ADAL o MSAL

Le app che usano già MSAL devono chiamare il registerAndEnrollAccountId metodo nell'istanza IntuneMAMEnrollmentManager dopo che l'utente è stato autenticato correttamente:

/*
 *  This method will add the account to the list of registered accounts.
 *  An enrollment request will immediately be started.
 *  @param accountId The Entra object ID of the account to be registered with the SDK
 */

(void)registerAndEnrollAccountId:(NSString *_Nonnull)accountId;

Al termine dell'accesso, MSAL restituisce il risultato nell'oggetto MSALResult. Usare tenantProfile.identifier all'interno di MSALResult come parametro accountId per l'API precedente.

Chiamando il registerAndEnrollAccountId metodo , l'SDK registrerà l'account utente e tenterà di registrare l'app per conto di questo account. Se la registrazione non riesce per qualsiasi motivo, l'SDK ritenterà automaticamente la registrazione 24 ore dopo. A scopo di debug, l'app può ricevere notifiche, tramite un delegato, sui risultati di qualsiasi richiesta di registrazione.

Dopo che questa API è stata richiamata, l'app può continuare a funzionare normalmente. Se la registrazione ha esito positivo, l'SDK informerà l'utente che è necessario un riavvio dell'app. In quel momento, l'utente può riavviare immediatamente l'app.

[[IntuneMAMEnrollmentManager instance] registerAndEnrollAccountId:@"3ec2c00f-b125-4519-acf0-302ac3761822"];

App che non usano ADAL o MSAL

Le app che non accedono all'utente usando ADAL o MSAL possono comunque ricevere i criteri di protezione delle app dal servizio MAM di Intune chiamando l'API per avere l'SDK per gestire l'autenticazione. Le app devono usare questa tecnica quando non hanno autenticato un utente con l'ID Microsoft Entra, ma devono comunque recuperare i criteri di protezione delle app per proteggere i dati. Un esempio è se viene usato un altro servizio di autenticazione per l'accesso all'app o se l'app non supporta affatto l'accesso. A tale scopo, l'applicazione può chiamare il loginAndEnrollAccount metodo nell'istanza IntuneMAMEnrollmentManager di :

/**
 *  Creates an enrollment request which is started immediately.
 *  If no token can be retrieved for the identity, the user will be prompted
 *  to enter their credentials, after which enrollment will be retried.
 *  @param identity The UPN of the account to be logged in and enrolled.
 */
 (void)loginAndEnrollAccount: (NSString *)identity;

Chiamando questo metodo, l'SDK richiederà all'utente le credenziali se non è stato trovato alcun token esistente. L'SDK tenterà quindi di registrare l'app con il servizio MAM di Intune per conto dell'account utente fornito. Il metodo può essere chiamato con "nil" come identità. In tal caso, l'SDK verrà registrato con l'utente gestito esistente nel dispositivo (nel caso di MDM) o richiederà all'utente un nome utente se non viene trovato alcun utente esistente.

Se la registrazione non riesce, l'app dovrebbe prendere in considerazione la possibilità di chiamare di nuovo questa API in un momento successivo, a seconda dei dettagli dell'errore. L'app può ricevere notifiche, tramite un delegato, sui risultati di qualsiasi richiesta di registrazione.

Dopo che questa API è stata richiamata, l'app può continuare a funzionare normalmente. Se la registrazione ha esito positivo, l'SDK informerà l'utente che è necessario un riavvio dell'app. Dopo aver gestito l'app, è necessario eseguire query sul valore dell'ID dell'oggetto IntuneMAMEnrollmentManagerEntra usando enrolledAccountId in . Usare questa opzione per tutte le API MAM SDK usate dall'app per questo account registrato.

Esempio:

[[IntuneMAMEnrollmentManager instance] loginAndEnrollAccount:@"user@foo.com"];

Consentire a Intune di gestire l'autenticazione e la registrazione all'avvio

Se si vuole che Intune SDK gestisca tutta l'autenticazione con ADAL/MSAL e la registrazione prima che l'app termini l'avvio e l'app richiede sempre i criteri APP, non è necessario usare l'API loginAndEnrollAccount . Puoi semplicemente impostare le due impostazioni seguenti su SÌ nel dizionario IntuneMAMSettings nell'info.plist dell'app.

Se scegli questa opzione per la tua app, non devi gestire il riavvio dell'app dopo la registrazione.

Annullare la registrazione degli account utente

Prima che un utente si disconnetta da un'app, l'app deve annullare la registrazione dell'utente dall'SDK. In questo modo si verificherà quanto segue:

1. I tentativi di registrazione non verranno più eseguiti per l'account dell'utente.

2. I criteri di protezione delle app verranno rimossi.

3. Tutti i dati aziendali vengono eliminati se l'app avvia una cancellazione selettiva (facoltativo).

Prima della disconnessione dell'utente, l'app deve chiamare il metodo seguente nell'istanza IntuneMAMEnrollmentManager di :

/*
 *  This method will remove the provided account from the list of
 *  registered accounts.  Once removed, if the account has enrolled
 *  the application, the account will be un-enrolled.
 *  @note In the case where an un-enroll is required, this method will block
 *  until the Intune APP AAD token is acquired, then return.  This method must be called before  
 *  the user is removed from the application (so that required AAD tokens are not purged
 *  before this method is called).
 *  @param accountId The object ID of the account to be removed.
 *  @param doWipe  If YES, a selective wipe if the account is un-enrolled
 */
(void)deRegisterAndUnenrollAccountId:(NSString *)accountId withWipe:(BOOL)doWipe;

Questo metodo deve essere chiamato prima dell'eliminazione dei token Microsoft Entra dell'account utente. L'SDK richiede i token Microsoft Entra dell'account utente per effettuare richieste specifiche al servizio MAM di Intune per conto dell'utente.

Se l'app eliminerà autonomamente i dati aziendali dell'utente, il doWipe flag può essere impostato su false. In caso contrario, l'app può fare in modo che l'SDK avvii una cancellazione selettiva. Ciò comporta una chiamata al delegato di cancellazione selettiva dell'app.

Esempio:

[[IntuneMAMEnrollmentManager instance] deRegisterAndUnenrollAccountId:@"3ec2c00f-b125-4519-acf0-302ac3761822" withWipe:YES];

Notifiche di stato, risultati e debug

L'app può ricevere notifiche di stato, risultati e debug relative alle richieste seguenti al servizio MAM di Intune:

• Richieste di registrazione
• Richieste di aggiornamento dei criteri
• Richieste di annullamento della registrazione

Le notifiche vengono presentate tramite metodi delegati in IntuneMAMEnrollmentDelegate.h:

/**
 *  Called when an enrollment request operation is completed.
 * @param status status object containing debug information
 */

(void)enrollmentRequestWithStatus:(IntuneMAMEnrollmentStatus *)status;

/**
 *  Called when a MAM policy request operation is completed.
 *  @param status status object containing debug information
 */
(void)policyRequestWithStatus:(IntuneMAMEnrollmentStatus *)status;

/**
 *  Called when a un-enroll request operation is completed.
 *  @Note: when a user is un-enrolled, the user is also de-registered with the SDK
 *  @param status status object containing debug information
 */

(void)unenrollRequestWithStatus:(IntuneMAMEnrollmentStatus *)status;

Questi metodi delegati restituiscono un IntuneMAMEnrollmentStatus oggetto con le informazioni seguenti:

• AccountId (ID oggetto) dell'account associato alla richiesta
• Identità (UPN) dell'account associato alla richiesta
• Codice di stato che indica il risultato della richiesta
• Stringa di errore con una descrizione del codice di stato
• Oggetto NSError . Questo oggetto è definito in IntuneMAMEnrollmentStatus.h, insieme ai codici di stato specifici che possono essere restituiti.

Codice di esempio

Di seguito sono riportate le implementazioni di esempio dei metodi delegati:

- (void)enrollmentRequestWithStatus:(IntuneMAMEnrollmentStatus*)status
{
    NSLog(@"enrollment result for identity %@ with status code %ld", status.accountId, (unsigned long)status.statusCode);
    NSLog(@"Debug Message: %@", status.errorString);
}

- (void)policyRequestWithStatus:(IntuneMAMEnrollmentStatus*)status
{
    NSLog(@"policy check-in result for identity %@ with status code %ld", status.accountId, (unsigned long)status.statusCode);
    NSLog(@"Debug Message: %@", status.errorString);
}

- (void)unenrollRequestWithStatus:(IntuneMAMEnrollmentStatus*)status
{
    NSLog(@"un-enroll result for identity %@ with status code %ld", status.accountId, (unsigned long)status.statusCode);
    NSLog(@"Debug Message: %@", status.errorString);
}

Riavvio dell'applicazione

Quando un'app riceve i criteri MAM per la prima volta, deve essere riavviato per applicare gli hook necessari. Per notificare all'app che deve essere eseguito un riavvio, l'SDK fornisce un metodo delegato in IntuneMAMPolicyDelegate.h.

 - (BOOL) restartApplication

Il valore restituito di questo metodo indica all'SDK se l'applicazione deve gestire il riavvio richiesto:

• Se viene restituito true, l'applicazione deve gestire il riavvio.

• Se viene restituito false, l'SDK riavvierà l'applicazione dopo la restituzione di questo metodo. L'SDK visualizza immediatamente una finestra di dialogo che indica all'utente di riavviare l'applicazione.

Criteri di uscita

Dopo aver configurato il plug-in di compilazione o aver integrato lo strumento da riga di comando nel processo di compilazione, verificare che sia in esecuzione correttamente:

• Assicurarsi che la compilazione venga compilata e compilata correttamente.
• Avviare l'app compilata, accedere con un utente di Microsoft Entra non destinato ai criteri di protezione delle app e verificare che l'app funzioni come previsto.
• Disconnettersi e ripetere questo test con un utente di Microsoft Entra destinato ai criteri di protezione delle app e verificare che l'app sia ora gestita da Intune e riavviata.

A questo punto dell'integrazione, l'app può ora ricevere e applicare i criteri di protezione delle app. Eseguire i test seguenti per convalidare l'integrazione.

Primo test dell'applicazione dei criteri

Eseguire prima di tutto il test seguente per acquisire familiarità con l'esperienza utente finale completa dell'applicazione dei criteri all'interno dell'app:

1. Creare criteri di protezione delle app iOS nell'interfaccia di amministrazione di Microsoft Intune. Per questo test, configurare i criteri:
   • In Requisiti di accesso lasciare le impostazioni predefinite. In particolare, "PIN for Access" deve essere "Require".
2. Verificare che i criteri di protezione delle app siano destinati all'applicazione. Potrebbe essere necessario aggiungere manualmente l'ID bundle dell'applicazione nella creazione guidata dei criteri.
3. Assegnare i criteri di protezione delle app a un gruppo di utenti contenente l'account di test.
4. Installare l'applicazione.
5. Accedere all'applicazione con l'account di test destinato ai criteri di protezione delle app.
6. Verificare che venga visualizzata una schermata gestita di Intune e confermare che il prompt riavvia l'app. Questa schermata indica che l'SDK recupera correttamente i criteri per questo account.
7. Creare un PIN quando viene richiesto di impostare un PIN dell'app.
8. Disconnettere l'account gestito dall'applicazione.
9. Esplorare l'applicazione e verificare che l'app funzioni come previsto, se possibile, senza eseguire l'accesso.

Questo elenco di passaggi è un test *bare minimum- per verificare che l'app registri correttamente l'account, registri il callback di autenticazione e annulla la registrazione dell'account. Eseguire i test seguenti per convalidare in modo più approfondito il modo in cui altre impostazioni dei criteri di protezione delle app modificano il comportamento dell'applicazione.

Operazioni successive

Dopo aver completato tutti i criteri di uscita, passare alla fase 4: Funzionalità di partecipazione alle app.