A Microsoft Intune App SDK Androidon – útmutató fejlesztőknekMicrosoft Intune App SDK for Android developer guide

Megjegyzés

Kezdésként érdemes lehet elolvasni Az Intune APP SDK áttekintése című cikket, amely ismerteti az SDK aktuálisan elérhető funkcióit, valamint az integrációval kapcsolatos előkészületeket a támogatott platformokon.You might want to first read the Intune App SDK overview, which covers the current features of the SDK and describes how to prepare for integration on each supported platform.

Az Androidhoz készült Microsoft Intune App SDK révén Intune-os alkalmazásvédelmi szabályzatokat (más néven APP- vagy MAM-szabályzatokat) építhet be natív Android-alkalmazásába.The Microsoft Intune App SDK for Android lets you incorporate Intune app protection policies (also known as APP or MAM policies) into your native Android app. Intune-kompatibilisnek az Intune App SDK-val integrált alkalmazásokat nevezzük.An Intune-enlightened application is one that is integrated with the Intune App SDK. A rendszergazdák egyszerűen telepíthetnek alkalmazásvédelmi szabályzatokat az Intune-kompatibilis alkalmazáshoz, ha az Intune aktívan felügyeli az alkalmazást.Intune administrators can easily deploy app protection policies to your Intune-enlightened app when Intune actively manages the app.

Az SDK tartalmaWhat's in the SDK

Az Intune App SDK-ban a következő fájlok találhatók:The Intune App SDK consists of the following files:

  • Microsoft.Intune.MAM.SDK.aar: Az SDK-összetevők a Support.V4 és Support.V7 JAR-fájlok kivételével.Microsoft.Intune.MAM.SDK.aar: The SDK components, with the exception of the Support.V4 and Support.V7 JAR files. Ez a fájl az egyes összetevők helyett használható, ha a buildelési rendszer támogatja az AAR-fájlokat.This file can be used in place of the individual components if your build system supports AAR files.
  • Microsoft.Intune.MAM.SDK.Support.v4.jar: A MAM azon alkalmazásokban való engedélyezéséhez szükséges felületek, amelyek az Android v4 támogatási függvénytárat használják.Microsoft.Intune.MAM.SDK.Support.v4.jar: The interfaces necessary to enable MAM in apps that use the Android v4 support library. Az ezt a támogatást igénylő alkalmazásoknak közvetlenül kell hivatkozniuk a jar-fájlra.Apps that need this support must reference the JAR file directly.
  • Microsoft.Intune.MAM.SDK.Support.v7.jar: A MAM azon alkalmazásokban való engedélyezéséhez szükséges felületek, amelyek az Android v7 támogatási függvénytárat használják.Microsoft.Intune.MAM.SDK.Support.v7.jar: The interfaces necessary to enable MAM in apps that use the Android v7 support library. Az ezt a támogatást igénylő alkalmazásoknak közvetlenül kell hivatkozniuk a jar-fájlra.Apps that need this support must reference the JAR file directly.
  • proguard.txt: azokat a ProGuard-szabályokat tartalmazza, amelyek a ProGuarddal való buildeléshez szükségesek.proguard.txt: Contains ProGuard rules which must be applied if building with ProGuard.
  • CHANGELOG.txt: Az egyes SDK-verziók változásait sorolja fel.CHANGELOG.txt: Provides a record of changes made in each SDK version.
  • THIRDPARTYNOTICES. TXT: A harmadik féltől származó és/vagy OSS kódnak az alkalmazásba fordítására vonatkozó tájékoztatás.THIRDPARTYNOTICES.TXT: An attribution notice that acknowledges third-party and/or OSS code that will be compiled into your app.

Ha a buildelőrendszer nem támogatja az AAR-fájlokat, a Microsoft.Intune.MAM.SDK.aar helyett használja az alábbiakat.If your build system does not support AAR files, you may use the following files in place of Microsoft.Intune.MAM.SDK.aar.

  • Microsoft.Intune.MAM.SDK.jar: a MAM, valamint az Intune Céges portál alkalmazással való együttműködés lehetővé tételéhez szükséges interfészek.Microsoft.Intune.MAM.SDK.jar: The interfaces necessary to enable MAM and interoperability with the Intune Company Portal app. Az alkalmazásoknak androidos függvénytár-hivatkozásként kell megadniuk ezt a fájlt.Apps must specify it as an Android library reference.
  • A res könyvtár: Az SDK által alkalmazott erőforrások (például karakterláncok).The res directory: The resources (like strings) on which the SDK relies.
  • AndroidManifest.xml: A további belépési pontokra és a függvénytárra vonatkozó követelmények.AndroidManifest.xml: Entry points and the library requirements.

KövetelményekRequirements

Az Intune App SDK egy lefordított androidos projekt.The Intune App SDK is a compiled Android project. Ez azt jelenti, hogy jelentős mértékben független az alkalmazás által a minimális vagy a cél API-verzióhoz használt Android-verziótól.As a result, it is largely unaffected by the version of Android that the app uses for its minimum or target API versions. Az SDK az Android API 14 (Android 4.0+) és az Android API 25 (Android 7.1) közötti verziókat támogatja.The SDK supports Android API 14 (Android 4.0+) through Android API 25 (Android 7.1).

Vállalati portál alkalmazásCompany Portal app

Az androidos Intune App SDK a Céges portál alkalmazással teszi lehetővé az alkalmazásvédelmi szabályzatok működését.The Intune App SDK for Android relies on the presence of the Company Portal app on the device to enable app protection policies. A Céges portál az Intune szolgáltatástól kéri le az alkalmazásvédelmi szabályzatokat.The Company Portal retrieves app protection policies from the Intune service. Az alkalmazás az inicializáláskor betölti a Céges portálról a szabályzatot és a betartatásához szükséges kódot.When the app initializes, it loads policy and code to enforce that policy from the Company Portal.

Megjegyzés

Ha a Céges portál alkalmazás nincs telepítve az eszközre, akkor az Intune-kompatibilis alkalmazás ugyanúgy működik, mint az általános, az Intune alkalmazásvédelmi szabályzatait nem támogató alkalmazások.When the Company Portal app is not on the device, an Intune-enlightened app behaves the same as a normal app that does not support Intune app protection policies.

Az eszközregisztráció nélküli alkalmazásvédelem esetében a felhasználónak nem kell regisztrálnia az eszközt a Céges portál alkalmazással.For app protection without device enrollment, the user is not required to enroll the device by using the Company Portal app.

SDK-integrációSDK Integration

BuildintegrációBuild integration

Az Intune App SDK for Android egy szabványos, külső függőségek nélküli androidos függvénytár.The Intune App SDK is a standard Android library with no external dependencies. A Microsoft.Intune.MAM.SDK.jar-ban megvannak mind az alkalmazásvédelmi szabályzatok használatát lehetővé tevő interfészek, mind pedig a Microsoft Intune Céges portál alkalmazással való együttműködéshez szükséges kód.Microsoft.Intune.MAM.SDK.jar contains both the interfaces necessary for an app protection policy enablement and the code necessary to interoperate with the Microsoft Intune Company Portal app.

A Microsoft.Intune.MAM.SDK.jar -t androidos függvénytár-hivatkozásként kell megadni.Microsoft.Intune.MAM.SDK.jar must be specified as an Android library reference. Ehhez nyissa meg az alkalmazásprojektet az Android Studióban, válassza a File > New > New module (Fájl > Új > Új modul), majd az Import .JAR/.AAR Package (.JAR-/.AAR-csomag importálása) elemet.To do this, open your app project in Android Studio and go to File > New > New module and select Import .JAR/.AAR Package. Jelölje ki a Microsoft.Intune.MAM.SDK.aar nevű androidos archívumcsomagot.Select our Android archive package Microsoft.Intune.MAM.SDK.aar.

A Microsoft.Intune.MAM.SDK.Support.v4 és a Microsoft.Intune.MAM.SDK.Support.v7 rendre az android.support.v4 és az android.support.v7 Intune-os variánsát tartalmazza.Additionally, Microsoft.Intune.MAM.SDK.Support.v4 and Microsoft.Intune.MAM.SDK.Support.v7 contain Intune variants of android.support.v4 and android.support.v7 respectively. Ezek nem kerültek bele a Microsoft.Intune.MAM.SDK.aar-ba, hogy az alkalmazásoknak ne legyen muszáj tartalmazni a támogatási kódtárakat.They are not built into Microsoft.Intune.MAM.SDK.aar in case an app does not want to include the support libraries. Ezek nem is androidos kódtárprojektek, hanem szabványos JAR-fájlok.They are standard JAR files instead of Android library projects.

ProGuardProGuard

Ha a buildfolyamatnak része a ProGuard (vagy bármelyik másik zsugorítási/rejtjelezési mechanizmus), az Intune SDK osztályait ki kell zárni.If ProGuard (or any other shrinking/obfuscation mechanism) is used as a build step, Intune SDK classes must be excluded. A ProGuard esetében ez az SDK-hoz tartozó proguard.txt-ben lévő szabályok felvételével oldható meg.For ProGuard, this can be accomplished by including the rules from the proguard.txt file distributed with the SDK.

Az Azure Active Directory Authentication Libraries (ADAL) szolgáltatásnak saját ProGuard-korlátozásai lehetnek.The Azure Active Directory Authentication Libraries (ADAL) may have its own ProGuard restrictions. Ha az Ön alkalmazása az ADAL-lal van integrálva, ezen korlátozások tekintetében az ADAL dokumentációja a mérvadó.If your app integrates ADAL, you must follow the ADAL documentation on these restrictions.

Belépési pontokEntry points

Az Azure Active Directory Authentication Library (ADAL) a közvetített hitelesítés végrehajtásához igényli ezeket az engedélyeket.The Azure Active Directory Authentication Library (ADAL) requires these permissions to perform brokered authentication. Ha az alkalmazás nem kapja meg ezeket az engedélyeket, vagy ha a felhasználó visszavonja ezeket az engedélyeket, akkor a közvetítőt igénylő hitelesítési folyamatok (a Munkahelyi portál alkalmazás) le lesznek tiltva.If these permissions are not granted to the app or are revoked by the user, authentication flows that require the broker (the Company Portal app) will be disabled.

Az Intune App SDK az alkalmazás forráskódjának módosítását igényli az Intune alkalmazásvédelmi szabályzatainak engedélyezéséhez.The Intune App SDK requires changes to an app's source code to enable Intune app protection policies. Ez az androidos alaposztályok egyenértékű Intune-osztályokra való cseréjével történik. Utóbbiak nevében a MAM előtag szerepel.This is done through the replacement of the Android base classes with equivalent Intune base classes, whose names have the prefix MAM. Az SDK-osztályok az androidos alaposztály és az alkalmazás saját származtatott verziója között helyezkednek el.The SDK classes live between the Android base class and the app's own derived version of that class. A tevékenységek esetében ez például egy, az alábbihoz hasonló öröklési hierarchiát eredményez: Activity > MAMActivity > AppSpecificActivity.Using an activity as an example, you end up with an inheritance hierarchy that looks like: Activity > MAMActivity > AppSpecificActivity.

Amikor például az AppSpecificActivity interakcióba lép a szülőjével (például meghívja a következőt: super.onCreate()), a MAMActivity lesz a szülőosztály.For example, when AppSpecificActivity interacts with its parent (for example, calling super.onCreate()), MAMActivity is the super class.

Az androidos alkalmazások általában egyszeres módban működnek, és a Context objektumukon keresztül férhetnek hozza a rendszerhez.Typical Android apps have a single mode and can access the system through their Context object. Az Intune App SDK-t integráló alkalmazások viszont kettős módban működhetnek.Apps that have integrated the Intune App SDK, on the other hand, have dual modes. Ezek az alkalmazások a továbbiakban is a Context objektumon keresztül érik el a rendszert.These apps continue to access the system through the Context object. Az Android a használt alapszintű Activity alapján biztosítja a Context objektumot, vagy a rendszer intelligensen multiplexel a rendszer korlátozott nézete, illetve az Android által biztosított Context között.Depending on the base Activity used, the Context object will be provided by Android or will intelligently multiplex between a restricted view of the system and the Android-provided Context. A MAM egyik belépési pontjából történő származtatást követően a megszokott módon használhatja a Context szintet, például elindíthatja az Activity-osztályokat, és használhatja a PackageManager eszközt is.After you derive from one of the MAM entry points, it's safe to use Context as you would normally -- for example, starting Activity classes and using PackageManager.

Az osztályok, a metódusok és a tevékenységek lecserélése a MAM-kompatibilis megfelelőkreReplace classes, methods, and activities with their MAM equivalent

Az androidos alaposztályokat a MAM-megfelelőjükkel kell helyettesíteni.Android base classes must be replaced with their respective MAM equivalents. Ehhez az alábbi táblázatban felsorolt osztályok összes példányát le kell cserélni az Intune App SDK-beli megfelelőjükre.To do so, find all instances of the classes listed in the following table and replace them with the Intune App SDK equivalent.

Androidos alaposztályAndroid base class Intune App SDK-beli helyettesítéseIntune App SDK replacement
android.app.Activityandroid.app.Activity MAMActivityMAMActivity
android.app.ActivityGroupandroid.app.ActivityGroup MAMActivityGroupMAMActivityGroup
android.app.AliasActivityandroid.app.AliasActivity MAMAliasActivityMAMAliasActivity
android.app.Applicationandroid.app.Application MAMApplicationMAMApplication
android.app.DialogFragmentandroid.app.DialogFragment MAMDialogFragmentMAMDialogFragment
android.app.ExpandableListActivityandroid.app.ExpandableListActivity MAMExpandableListActivityMAMExpandableListActivity
android.app.Fragmentandroid.app.Fragment MAMFragmentMAMFragment
android.app.IntentServiceandroid.app.IntentService MAMIntentServiceMAMIntentService
android.app.LauncherActivityandroid.app.LauncherActivity MAMLauncherActivityMAMLauncherActivity
android.app.ListActivityandroid.app.ListActivity MAMListActivityMAMListActivity
android.app.NativeActivityandroid.app.NativeActivity MAMNativeActivityMAMNativeActivity
android.app.PendingIntentandroid.app.PendingIntent MAMPendingIntent (a megjegyzéseket lásd alább)MAMPendingIntent (see notes below)
android.app.Serviceandroid.app.Service MAMServiceMAMService
android.app.TabActivityandroid.app.TabActivity MAMTabActivityMAMTabActivity
android.app.TaskStackBuilderandroid.app.TaskStackBuilder MAMTaskStackBuilderMAMTaskStackBuilder
android.app.backup.BackupAgentandroid.app.backup.BackupAgent MAMBackupAgentMAMBackupAgent
android.app.backup.BackupAgentHelperandroid.app.backup.BackupAgentHelper MAMBackupAgentHelperMAMBackupAgentHelper
android.app.backup.FileBackupHelperandroid.app.backup.FileBackupHelper MAMFileBackupHelperMAMFileBackupHelper
android.app.backup.SharePreferencesBackupHelperandroid.app.backup.SharePreferencesBackupHelper MAMSharedPreferencesBackupHelperMAMSharedPreferencesBackupHelper
android.content.BroadcastReceiverandroid.content.BroadcastReceiver MAMBroadcastReceiverMAMBroadcastReceiver
android.content.ContentProviderandroid.content.ContentProvider MAMContentProviderMAMContentProvider
android.os.Binderandroid.os.Binder MAMBinder (csak akkor szükséges, ha a Binder létrehozása nem androidos interfészdefiníciós nyelvű (AIDL-) interfészből történik)MAMBinder (Only necessary if the Binder is not generated from an Android Interface Definition Language (AIDL) interface)
android.provider.DocumentsProviderandroid.provider.DocumentsProvider MAMDocumentsProviderMAMDocumentsProvider
android.preference.PreferenceActivityandroid.preference.PreferenceActivity MAMPreferenceActivityMAMPreferenceActivity

Microsoft.Intune.MAM.SDK.Support.v4.jar:Microsoft.Intune.MAM.SDK.Support.v4.jar:

Androidos osztály Intune MAMAndroid Class Intune MAM Intune App SDK-beli helyettesítéseIntune App SDK replacement
Android.support.v4.App.DialogFragmentandroid.support.v4.app.DialogFragment MAMDialogFragmentMAMDialogFragment
android.support.v4.app.FragmentActivityandroid.support.v4.app.FragmentActivity MAMFragmentActivityMAMFragmentActivity
android.support.v4.app.Fragmentandroid.support.v4.app.Fragment MAMFragmentMAMFragment
Android.support.v4.App.TaskStackBuilderandroid.support.v4.app.TaskStackBuilder MAMTaskStackBuilderMAMTaskStackBuilder
Android.support.v4.Content.FileProviderandroid.support.v4.content.FileProvider MAMFileProviderMAMFileProvider

Microsoft.Intune.MAM.SDK.Support.v7.jar:Microsoft.Intune.MAM.SDK.Support.v7.jar:

Androidos osztályAndroid Class Intune App SDK-beli helyettesítéseIntune App SDK replacement
Android.support.v7.App.ActionBarActivityandroid.support.v7.app.ActionBarActivity MAMActionBarActivityMAMActionBarActivity

Átnevezett metódusokRenamed Methods

Sok esetben az androidos osztályban rendelkezésre álló metódus végsőként van megjelölve a helyettesítő MAM-osztályban.In many cases, a method available in the Android class has been marked as final in the MAM replacement class. Ebben az esetben a helyettesítő MAM-osztály egy hasonlóan elnevezett metódust biztosít (általában a MAM utótaggal), amelyet felül kell írni.In this case, the MAM replacement class provides a similarly named method (generally suffixed with MAM) that you should override instead. Így például a MAMActivity származtatásakor az onCreate() felülírása, illetve a super.onCreate() metódus hívása helyett az Activity tevékenységnek felül kell írnia az onMAMCreate() metódust, és meg kell hívnia a super.onMAMCreate() metódust.For example, when deriving from MAMActivity, instead of overriding onCreate() and calling super.onCreate(), Activity must override onMAMCreate() and call super.onMAMCreate(). A Java-fordítónak érvényesítenie kell a végső korlátozásokat az eredeti metódus véletlen felülbírálásának elkerülése érdekében az egyenértékű MAM-metódus helyett.The Java compiler should enforce the final restrictions to prevent accidental override of the original method instead of the MAM equivalent.

PendingIntentPendingIntent

A PendingIntent.get* helyett például a MAMPendingIntent.get* metódust kell használni.Instead of PendingIntent.get*, you must use the MAMPendingIntent.get* method. Az így létrejövő PendingIntent már szintén a megszokott módon használható.After this, you can use the resultant PendingIntent as usual.

Cserék a jegyzékbenManifest Replacements

Ne feledje, hogy a fenti osztálycserék egy részét a jegyzékfájlban és a Java-kódban is el kell végezni.Please note that it may be necessary to perform some of the above class replacements in the manifest as well as in Java code. Különösen fontos:Of special note:

  • a jegyzékfájlban szereplő android.support.v4.content.FileProvider-hivatkozásokat le kell cserélni erre: com.microsoft.intune.mam.client.support.v4.content.MAMFileProvider.Manifest references to android.support.v4.content.FileProvider must be replaced with com.microsoft.intune.mam.client.support.v4.content.MAMFileProvider.
  • Ha alkalmazásának nincs szüksége saját származtatott alkalmazásosztályra, a com.microsoft.intune.mam.client.app.MAMApplication beállításban a jegyzékfájlban használt alkalmazásosztály nevét kell beállítani.If your application does not have a need for its own derived Application class, com.microsoft.intune.mam.client.app.MAMApplication must be set as the name of the Application class used in the manifest.

Az SDK engedélyeiSDK permissions

Az Intune App SDK három androidos rendszerengedélyt igényel azokhoz az alkalmazásokhoz, amelyekbe beépül:The Intune App SDK requires three Android system permissions on apps that integrate it:

  • android.permission.GET_ACCOUNTS (kérése futásidőben történik, ha szükség van rá)android.permission.GET_ACCOUNTS (requested at runtime if required)

  • android.permission.MANAGE_ACCOUNTS

  • android.permission.USE_CREDENTIALS

Az Azure Active Directory Authentication Library (ADAL) a közvetített hitelesítés végrehajtásához igényli ezeket az engedélyeket.The Azure Active Directory Authentication Library (ADAL) requires these permissions to perform brokered authentication. Ha az alkalmazás nem kapja meg ezeket az engedélyeket, vagy ha a felhasználó visszavonja ezeket az engedélyeket, akkor a közvetítőt igénylő hitelesítési folyamatok (a Munkahelyi portál alkalmazás) le lesznek tiltva.If these permissions are not granted to the app or are revoked by the user, authentication flows that require the broker (the Company Portal app) will be disabled.

NaplózásLogging

A naplózott adatok maximális hasznossága érdekében a naplózást célszerű korán inicializálni.Logging should be initialized early to get the most value out of logged data. Erre az Application.onMAMCreate() a legalkalmasabb hely.Application.onMAMCreate() is typically the best place to initialize logging.

Ha az alkalmazásban MSM-naplókat szeretne fogadni, hozzon létre Java-kezelőt, és vegye fel a MAMLogHandlerWrapper-be.To receive MAM logs in your app, create a Java Handler and add it to the MAMLogHandlerWrapper. Ez minden naplóüzenetre meghívja a publish() metódust az alkalmazás kezelőjén.This will invoke publish() on the application handler for every log message.

/**
 * Global log handler that enables fine grained PII filtering within MAM logs.  
 *
 * To start using this you should build your own log handler and add it via
 * MAMComponents.get(MAMLogHandlerWrapper.class).addHandler(myHandler, false);  
 *
 * You may also remove the handler entirely via
 * MAMComponents.get(MAMLogHandlerWrapper.class).removeHandler(myHandler);
 */
public interface MAMLogHandlerWrapper {
    /**
     * Add a handler, PII can be toggled.
     *
     * @param handler handler to add.
     * @param wantsPII if PII is desired in the logs.    
     */
    void addHandler(final Handler handler, final boolean wantsPII);

    /**
     * Remove a handler.
     *
     * @param handler handler to remove.
     */
    void removeHandler(final Handler handler);
}

Alkalmazás részvételét igénylő szolgáltatások engedélyezéseEnable features that require app participation

Az SDK számos alkalmazásvédelmi szabályzatot nem tud önállóan implementálni.There are several app protection policies the SDK cannot implement on its own. Az alkalmazás a saját működésének szabályozásával képes e funkciókat biztosítani. Ehhez több API-t használ, amelyek az alábbi AppPolicy felületen találhatók.The app can control its behavior to achieve these features by using several APIs that you can find in the following AppPolicy interface. Egy AppPolicy-példány beolvasásához használja a MAMPolicyManager.getPolicy-t.To retrieve an AppPolicy instance, use MAMPolicyManager.getPolicy.

/**
 * External facing application policies.
 */
public interface AppPolicy {

/**
 * Restrict where an app can save personal data.
 * This function is now deprecated. Please use getIsSaveToLocationAllowed(SaveLocation, String) instead
 * @return True if the app is allowed to save to personal data stores; false otherwise.
 */
@Deprecated
boolean getIsSaveToPersonalAllowed();

/**
 * Check if policy prohibits saving to a content provider location.
 *
 * @param location
 *            a content URI to check
 * @return True if location is not a content URI or if policy does not prohibit saving to the content location.
 */
boolean getIsSaveToLocationAllowed(Uri location);

/**
 * Determines if the SaveLocation passed in can be saved to by the username associated with the cloud service.
 *
 * @param service
 *           see {@link SaveLocation}.
 * @param username
 *           the username/email associated with the cloud service being saved to. Use null if a mapping between
 *           the AAD username and the cloud service username does not exist or the username is not known.
 * @return true if the location can be saved to by the identity, false if otherwise.
 */
boolean getIsSaveToLocationAllowed(SaveLocation service, String username);

/**
 * Whether the SDK PIN prompt is enabled for the app.
 *
 * @return True if the PIN is enabled. False otherwise.
 */
boolean getIsPinRequired();

/**
 * Whether the Intune Managed Browser is required to open web links.
 * @return True if the Managed Browser is required, false otherwise
 */
boolean getIsManagedBrowserRequired();

/**
 * Check if policy allows Contact sync to local contact list.
 *
 * @return True if Contact sync is allowed to save to local contact list; false otherwise.
 */
boolean getIsContactSyncAllowed();

/**
 * Return the policy in string format to the app.
 *  
 * @return The string representing the policy.
 */
String toString();

}

Megjegyzés

A MAMPolicyManager.getPolicy mindig nem null értékű alkalmazásszabályzatot ad vissza – akkor is, ha az eszközre vagy az alkalmazásra nem vonatkozik Intune-beli felügyeleti szabályzat.MAMPolicyManager.getPolicy will always return a non-null App Policy, even if the device or app is not under an Intune management policy.

Példa: annak megállapítása, hogy az alkalmazáshoz szükséges-e PIN-kódExample: Determine if PIN is required for the app

Ha az alkalmazásnak saját felhasználói PIN-kódkezelő funkciója van, akkor azt célszerű letiltani, ha a rendszergazda úgy állította be az SDK-t, hogy az kérjen alkalmazás-PIN-kódot.If the app has its own PIN user experience, you might want to disable it if the IT administrator has configured the SDK to prompt for an app PIN. Az alábbi metódust meghívva állapíthatja meg, hogy a rendszergazda telepített-e alkalmazás-PIN-szabályzatot az alkalmazáshoz az aktuális végfelhasználónál:To determine if the IT administrator has deployed the app PIN policy to this app, for the current end user, call the following method:

MAMComponents.get(AppPolicy.class).getIsPinRequired();

Példa: az elsődleges Intune-felhasználó meghatározásaExample: Determine the primary Intune user

Az egyszerű felhasználónevet (UPN) az AppPolicy-ban elérhető API-kon felül a MAMUserInfo interfészben definiált getPrimaryUser() API is elérhetővé teszi.In addition to the APIs exposed in AppPolicy, the user principal name (UPN) is also exposed by the getPrimaryUser() API defined inside the MAMUserInfo interface. Az UPN-t az alábbi kódot meghívva kérheti le:To get the UPN, call the following:

MAMUserInfo info = MAMComponents.get(MAMUserInfo.class);
if (info != null) return info.getPrimaryUser();

Alább a MAMUserInfo interfész teljes definiálása olvasható:The full definition of the MAMUserInfo interface is below:

/**
 * External facing user informations.
 *
 */
public interface MAMUserInfo {
       /**
        * Get the primary user name.
        *
        * @return the primary user name or null if the device is not enrolled.
        */
       String getPrimaryUser();
}

Példa: annak megállapítása, hogy engedélyezve van-e az eszközre vagy a felhőbeli tárhelyre való mentésExample: Determine if saving to device or cloud storage is permitted

Számos alkalmazás valósít meg olyan funkciókat, amelyek lehetővé teszik a végfelhasználó számára fájlok mentését helyi háttértárra vagy felhőbeli tárolószolgáltatásba.Many apps implement features that allow the end user to save files locally or to a cloud storage service. Az Intune App SDK lehetővé teszi a rendszergazdáknak az adatszivárgás ellen a szervezet igényei szerinti szabályzatkorlátozások alkalmazásával történő védekezést.The Intune App SDK allows IT administrators to protect against data leakage by applying policy restrictions as they see fit in their organization. A rendszergazda által beállítható szabályzatok egyike arra vonatkozik, hogy a felhasználók menthetnek-e fájlokat nem felügyelt személyes adattárba.One of the policies that IT can control is whether the end user can save to a "personal," unmanaged data store. Ide tartoznak a helyi mentési helyek, az SD-kártyák és a harmadik felek biztonsági mentési szolgáltatásai.This includes saving to a local location, SD card, or third-party backup services.

A funkció engedélyezéséhez az alkalmazás részvételére van szükség.App participation is needed to enable the feature. Ha az alkalmazás lehetővé teszi a személyes vagy a felhőbeli helyekre való mentést közvetlenül az alkalmazásból, ezt a funkciót meg kell valósítani annak biztosításához, hogy a rendszergazda szabályozhassa, engedélyezve van-e a mentés az adott helyre.If your app allows saving to personal or cloud locations directly from the app, you must implement this feature to ensure that the IT administrator can control whether saving to a location is allowed. Az alábbi API lehetővé teszi, hogy az alkalmazás megállapítsa, hogy a személyes tárolóba való mentés engedélyezve van-e az aktuális Intune-rendszergazda szabályzata szerint.The API below lets the app know whether saving to a personal store is allowed by the current Intune administrator's policy. Az alkalmazás ekkor érvényesítheti a házirendet, mivel meg tudja állapítani, hogy elérhető-e személyes adattár a felhasználó számára az alkalmazáson keresztül.The app can then enforce the policy, since it is aware of personal data store available to the end user through the app.

Az alábbi hívással állapíthatja meg, hogy a szabályzat be van-e tartatva:To determine if the policy is enforced, make the following call:

MAMComponents.get(AppPolicy.class).getIsSaveToLocationAllowed(
SaveLocation service, String username);

...ahol a service az alábbi SaveLocation értékek valamelyike:... where service is one of the following SaveLocations:

* <span data-ttu-id="cd43c-280">SaveLocation.ONEDRIVE_FOR_BUSINESS</span><span class="sxs-lookup"><span data-stu-id="cd43c-280">SaveLocation.ONEDRIVE_FOR_BUSINESS</span></span>
* <span data-ttu-id="cd43c-281">SaveLocation.LOCAL</span><span class="sxs-lookup"><span data-stu-id="cd43c-281">SaveLocation.LOCAL</span></span>
* <span data-ttu-id="cd43c-282">SaveLocation.SHAREPOINT</span><span class="sxs-lookup"><span data-stu-id="cd43c-282">SaveLocation.SHAREPOINT</span></span>

Korábban ugyanezen AppPolicy osztály getIsSaveToPersonalAllowed() függvényével lehetett megállapítani, hogy az adott felhasználó szabályzata engedélyezi-e a mentést különféle helyekre.The previous method of determining whether a user’s policy allowed them to save data to various locations was getIsSaveToPersonalAllowed() within the same AppPolicy class. Ez a függvény mostanra elavult, és nem szabad használni. Az alábbi kód egyenértékű a getIsSaveToPersonalAllowed() függvénnyel:This function is now deprecated and should not be used, the following invocation is equivalent to getIsSaveToPersonalAllowed():


MAMPolicyManager.getPolicy(currentActivity).getIsSaveToLocationAllowed(SaveLocation.LOCAL, userNameInQuestion);

Megjegyzés

A SaveLocation.OTHER akkor használatos, ha a szóban forgó hely nem szerepel a SaveLocations enumerációban.Use SaveLocation.OTHER if the location in question is not listed in the SaveLocations enum.

Regisztráció az SDK értesítéseireRegister for notifications from the SDK

ÁttekintésOverview

Az Intune App SDK lehetővé teszi, hogy az alkalmazás szabályozza bizonyos szabályzatok, például a szelektív törlési szabályzat működését, ha a rendszergazda telepítette őket.The Intune App SDK allows your app to control the behavior of certain policies, such as selective wipe, when they are deployed by the IT administrator. Amikor a rendszergazda alkalmaz egy ilyen szabályzatot, az Intune szolgáltatás értesítést küld az SDK-nak.When an IT administrator deploys such a policy, the Intune service sends down a notification to the SDK.

Ehhez regisztrálnia kell az SDK által küldött értesítésekre: hozzon létre egy MAMNotificationReceiver osztályt, és regisztrálja a következővel: MAMNotificationReceiverRegistry.Your app must register for notifications from the SDK by creating a MAMNotificationReceiver and registering it with MAMNotificationReceiverRegistry. Ez a fogadó és az App.onCreate metódusban fogadni kívánt értesítés típusának megadásával történik, az alábbi példában látható módon:This is done by providing the receiver and the type of notification desired in App.onCreate, as the example below illustrates:

@Override
public void onCreate() {
    super.onCreate();
    MAMComponents.get(MAMNotificationReceiverRegistry.class)
        .registerReceiver(
            new ToastNotificationReceiver(),
            MAMNotificationType.WIPE_USER_DATA);
    }

MAMNotificationReceiverMAMNotificationReceiver

A MAMNotificationReceiver fogadja az értesítéseket az Intune szolgáltatástól.The MAMNotificationReceiver interface simply receives notifications from the Intune service. Egyes értesítéseket közvetlenül az SDK kezel, míg mások az alkalmazás részvételét igénylik.Some notifications are handled by the SDK directly, while others require the app's participation. Az alkalmazásnak igaz vagy hamis értéket kell visszaadnia az értesítésekből.An app must return either true or false from a notification. Hacsak valamely, általa az értesítés eredményeként megkísérelt művelet sikertelen nem volt, mindig igaz értéket kell visszaadjon.It must always return true unless some action it tried to take as a result of the notification failed.

  • Ez a hiba megjelenhet az Intune szolgáltatásnak küldött jelentésben.This failure may be reported to the Intune service. Jelentendő helyzet lehet például az olyan eset, amikor az alkalmazás nem törli a felhasználói adatokat, miután a rendszergazda kezdeményezte a törlést.An example of a scenario to report is if the app fails to wipe user data after the IT administrator initiates a wipe.

Megjegyzés

A MAMNotificationReceiver.onReceive metódusban biztonságosan blokkolható, mivel a visszahívása nem a felhasználói felület szálán fut.It is safe to block in MAMNotificationReceiver.onReceive because its callback is not running on the UI thread.

Alább látható az SDK-ban ily módon definiált MAMNotificationReceiver interfész:The MAMNotificationReceiver interface as defined in the SDK is included below :

/**
 * The SDK is signaling that a MAM event has occurred.
 *
 */
public interface MAMNotificationReceiver {

    /**
     * A notification was received.
     *
     * @param notification
     *            The notification that was received.
     * @return The receiver should return true if it handled the
     *   notification without error (or if it decided to ignore the
     *   notification). If the receiver tried to take some action in
     *   response to the notification but failed to complete that
     *   action it should return false.
     */
    boolean onReceive(MAMNotification notification);
}

Az értesítések típusaiTypes of notifications

A következő értesítéseket küldi a program az alkalmazásnak, és némelyikük igényelheti az alkalmazás részvételét:The following notifications are sent to the app and some of them may require app participation:

  • WIPE_USER_DATA: ezt az értesítést a rendszer egy MAMUserNotification osztályban küldi el.WIPE_USER_DATA: This notification is sent in a MAMUserNotification class. Az értesítés beérkezésekor az alkalmazásnak a MAMUserNotification osztály által átadott „vállalati” identitáshoz társított összes adatot törölnie kell.When this notification is received, the app is expected to delete all data associated with the "corporate" identity passed with the MAMUserNotification. Az értesítést jelenleg az APP-WE szolgáltatásba való beléptetés megszüntetésekor küldi a program.This notification is currently sent during APP-WE service unenrollment. A regisztrációs folyamat során általában sor kerül a felhasználó elsődleges nevének megadására.The user's primary name is typically specified during the enrollment process. Ha regisztrál erre az értesítésre, az alkalmazásnak kell gondoskodnia az összes felhasználói adat törléséről.If you register for this notification, your app must ensure that all the user's data has been deleted. Ha nem regisztrál, az alapértelmezett szelektív törlési viselkedés érvényesül.If you don't register for it, the default selective wipe behavior will be performed.

  • WIPE_USER_AUXILIARY_DATA: Az alkalmazások akkor regisztrálhatnak erre az értesítésre, ha az cél, hogy az Intune App SDK hajtsa végre az alapértelmezett szelektív törlést, de bizonyos kiegészítő adatokat is törölni kell.WIPE_USER_AUXILIARY_DATA: Apps can register for this notification if they'd like the Intune App SDK to perform the default selective wipe behavior, but would still like to remove some auxiliary data when the wipe occurs.

  • REFRESH_POLICY: Ezt az értesítést a rendszer egy MAMUserNotification osztályban küldi el.REFRESH_POLICY: This notification is sent in a MAMUserNotification. Az értesítés fogadásakor a gyorsítótárban található összes Intune-szabályzatot érvényteleníteni és frissíteni kell.When this notification is received, any cached Intune policy must be invalidated and updated. Ezt általában az SDK kezeli, azonban az alkalmazásnak kell kezelnie, ha a szabályzat valamilyen állandó módon van használva.This is generally handled by the SDK; however, it should be handled by the app if the policy is used in any persistent way.

  • REFRESH_POLICY: Ezt az értesítést a rendszer egy MAMUserNotification osztályban küldi el, és tájékoztatja az alkalmazást, hogy éppen elhagyni készül a felügyeletet.MANAGEMENT_REMOVED: This notification is sent in a MAMUserNotification and informs the app that it is about to become unmanaged. Felügyelet nélkül az alkalmazás nem fogja tudni olvasni a titkosított fájlokat, a MAMDataProtectionManagerrel titkosított adatokat, kezelni a titkosított vágólapot, vagy bármilyen más módon részt venni a felügyelt alkalmazások ökoszisztémájában.Once unmanaged, it will no longer be able to read encrypted files, read data encrypted with MAMDataProtectionManager, interact with the encrypted clipboard, or otherwise participate in the managed-app ecosystem.

Megjegyzés

Az alkalmazások nem regisztrálhatnak egyszerre a WIPE_USER_DATA és a WIPE_USER_AUXILIARY_DATA értesítésre.An app should never register for both the WIPE_USER_DATA and WIPE_USER_AUXILIARY_DATA notifications.

Az Azure Active Directory Authentication Library (ADAL) konfigurálása (nem kötelező)Configure Azure Active Directory Authentication Library (ADAL)

Először olvassa el a GitHub ADAL-kódtárában található ADAL-integrációs irányelveket.First, please read the ADAL integration guidelines found in the ADAL repository on GitHub.

Az SDK a hitelesítési és feltételes indítási forgatókönyvekhez az ADAL-ra támaszkodik, amely a hitelesítéshez megköveteli, hogy az alkalmazásokat az Azure Active Directoryval konfigurálják.The SDK relies on ADAL for its authentication and conditional launch scenarios, which require apps to be configured with Azure Active Directory. A konfigurációs értékeket az SDK az AndroidManifest metaadatain keresztül közli.The configuration values are communicated to the SDK via AndroidManifest metadata.

Az alkalmazás konfigurálásához és a megfelelő hitelesítés engedélyezéséhez vegye fel a következőket az AndroidManifest.xml-be.To configure your app and enable proper authentication, add the following to the app node in AndroidManifest.xml. Ezen konfigurációk némelyike csak akkor szükséges, ha az alkalmazás általánosan az ADAL-t használja hitelesítéshez. Ebben az esetben azokra a konkrét értékekre is szüksége lesz, amelyekkel az alkalmazás az AAD-ben regisztrálja magát.Some of these configurations are only required if your app uses ADAL for authentication in general; in that case, you will need the specific values your app uses to register itself with AAD. Így lehet biztosítani, hogy a rendszer ne kérje kétszer a felhasználó hitelesítését. Az AAD ugyanis két különböző regisztrációs értéket ismer fel: egyet az alkalmazásból, egyet pedig az SDK-ból.This is done to ensure that the end user does not get prompted for authentication twice, due to AAD recognizing two separate registration values: one from the app and one from the SDK.

<meta-data
    android:name="com.microsoft.intune.mam.aad.Authority"
    android:value="https://AAD authority/" />
<meta-data
    android:name="com.microsoft.intune.mam.aad.ClientID"
    android:value="your-client-ID-GUID" />
<meta-data
    android:name="com.microsoft.intune.mam.aad.NonBrokerRedirectURI"
    android:value="your-redirect-URI" />
<meta-data
    android:name="com.microsoft.intune.mam.aad.SkipBroker"
    android:value="[true | false]" />

ADAL-metaadatokADAL metadata

  • Authority: az éppen használatban lévő AAD-szolgáltató.Authority is the current AAD authority in use. Ha meg van adva, akkor azt a saját környezetet kell használni, amelyben az AAD-fiókokat konfigurálták.If present, you should use your own environment where AAD accounts have been configured. Ha ez az érték hiányzik, a rendszer egy Intune-beli alapértelmezett értéket használ.If this value is absent, an Intune default is used.

  • ClientID: a használni kívánt AAD ClientID azonosító.ClientID is the AAD ClientID to be used. Ha regisztrálva van az Azure AD-ben, akkor az alkalmazás saját ClientID-jét kell használni.You should use your own app's ClientID if it is registered with Azure AD. Ha ez az érték hiányzik, a rendszer egy Intune-beli alapértelmezett értéket használ.If this value is absent, an Intune default is used.

  • NonBrokerRedirectURI: a közvetítő nélküli esetekben használandó AAD átirányítási URI.NonBrokerRedirectURI is the AAD redirect URI to use in broker-less cases. Ha nincs megadva, a rendszer az alapértelmezett urn:ietf:wg:oauth:2.0:oob értéket használja.If none is specified, a default value of urn:ietf:wg:oauth:2.0:oob is used. Ez a legtöbb alkalmazáshoz megfelelő.This default is suitable for most apps.

  • SkipBroker: akkor használatos, ha a ClientID nincs a közvetítő átirányítási URI-jának használatára konfigurálva.SkipBroker is used in case the ClientID has not been configured to use the broker redirect URI. Az alapértelmezett érték a „false” (hamis).The default value is "false."

    • Az ADAL-t nem integráló és az eszközszintű közvetített hitelesítésben/SSO-ban részt venni nem kívánó alkalmazások esetében kell „true” (igaz) értékre állítani.For apps that do not integrate ADAL and do not want to participate in device-wide brokered authentication/SSO, this should be set to "true." Ilyen esetben az egyetlen használatos átirányítási URI a NonBrokerRedirectURI lesz.When this value is "true," the only redirect URI that will be used is NonBrokerRedirectURI.

    • Az eszközszintű SSO-közvetítést támogató alkalmazások esetében a „false” értéket kell használni.For apps that do support device-wide SSO brokering, this should be "false." Ilyenkor az SDK választ közvetítőt a com.microsoft.aad.adal.AuthenticationContext.getRedirectUriForBroker() eredménye és a NonBrokerRedirectURI közül a közvetítő rendszerbeli elérhetősége alapján.When the value is "false," the SDK will select a broker between the result of com.microsoft.aad.adal.AuthenticationContext.getRedirectUriForBroker() and NonBrokerRedirectURI, based on the availability of the broker on the system. A közvetítő forrása a legtöbbször a Céges portál alkalmazás vagy az Azure Authenticator alkalmazás lesz.In general, the broker will be available from the Company Portal app or Azure Authenticator app.

Általános ADAL-konfigurációkCommon ADAL configurations

A következőkben az alkalmazások ADAL-konfigurációjának gyakori eseteit mutatjuk be.The following are common ways an app can be configured with ADAL. Keresse meg az alkalmazásához illő esetet, és állítsa be az ADAL (fent ismertetett) metaadat-paramétereit a megfelelő értékekre.Find your app's configuration and make sure to set the ADAL metadata parameters (explained above) to the necessary values.

  1. Az alkalmazás nem integrálja az ADAL-t:App does not integrate ADAL:

    Szükséges ADAL-paraméterRequired ADAL parameter ÉrtékValue
    AuthorityAuthority Az a környezet, amelyben az AAD-fiókokat konfiguráltákDesired environment where AAD accounts have been configured
    SkipBrokerSkipBroker IgazTrue
  2. Az alkalmazás integrálja az ADAL-t:App integrates ADAL:

    Szükséges ADAL-paraméterRequired ADAL parameter ÉrtékValue
    AuthorityAuthority Az a környezet, amelyben az AAD-fiókokat konfiguráltákDesired environment where AAD accounts have been configured
    ClientIDClientID Az alkalmazás ClientID azonosítója (az Azure AD állítja elő az alkalmazás regisztrálásakor)The app's ClientID (generated by Azure AD when the app is registered)
    NonBrokerRedirectURINonBrokerRedirectURI Az alkalmazás érvényes átirányítási URI-ja, vagy urn:ietf:wg:oauth:2.0:oobA valid redirect URI for the app, or urn:ietf:wg:oauth:2.0:oob

    ..

    Ezt az értéket mindenképpen elfogadható átirányítási URI-ként kell beállítani az alkalmazás ClientID azonosítójához.Make sure to configure the value as an acceptable redirect URI for your app's ClientID. | SkipBroker | False || SkipBroker | False |

  3. Az alkalmazás integrálja az ADAL-t, de nem támogatja a közvetített hitelesítést/eszközszintű SSO-t:App integrates ADAL but does not support brokered authentication/device-wide SSO:

    Szükséges ADAL-paraméterRequired ADAL parameter ÉrtékValue
    AuthorityAuthority Az a környezet, amelyben az AAD-fiókokat konfiguráltákDesired environment where AAD accounts have been configured
    ClientIDClientID Az alkalmazás ClientID azonosítója (az Azure AD állítja elő az alkalmazás regisztrálásakor)The app's ClientID (generated by Azure AD when the app is registered)
    NonBrokerRedirectURINonBrokerRedirectURI Az alkalmazás érvényes átirányítási URI-ja, vagy alapértelmezés szerint urn:ietf:wg:oauth:2.0:oob.A valid redirect URI for the app, or urn:ietf:wg:oauth:2.0:oob by default.

    Ezt az értéket mindenképpen elfogadható átirányítási URI-ként kell beállítani az alkalmazás ClientID azonosítójához.Make sure to configure the value as an acceptable redirect URI for your app's ClientID.
    SkipBrokerSkipBroker TrueTrue

Eszközregisztráció nélküli alkalmazásvédelmi szabályzatApp protection policy without device enrollment

ÁttekintésOverview

Az Intune APP-WE vagy MAM-WE néven is ismert eszközbeléptetés nélküli alkalmazásvédelmi szabályzata lehetővé teszi, hogy az Intune anélkül is felügyelhesse az alkalmazásokat, hogy az eszközök az Intune MDM-re regisztrálva lennének.Intune app protection policy without device enrollment, also known as APP-WE or MAM-WE, allows apps to be managed by Intune without the need for the device to be enrolled Intune MDM. Az APP-WE működik eszközbeléptetéssel és anélkül is.APP-WE works with or without device enrollment. A Céges portál alkalmazást továbbra is telepíteni kell az eszközre, de a felhasználónak nem kell bejelentkeznie a Céges portálba és beléptetnie az eszközt.The Company Portal is still required to be installed on the device, but the user does not need to sign into the Company Portal and enroll the device.

Megjegyzés

Az összes alkalmazásnak támogatnia kell az alkalmazásvédelmi szabályzatok eszközbeléptetés nélküli használatát.All apps are required to support app protection policy without device enrollment.

MunkafolyamatWorkflow

Ha egy alkalmazás új felhasználói fiókot hoz létre, azt regisztrálnia kell felügyeletre az Intune App SDK-val.When an app creates a new user account, it should register the account for management with the Intune App SDK. Az SDK kezeli az alkalmazás APP-WE szolgáltatásba való beléptetésének részleteit; szükség esetén a megfelelő időközönként újból megpróbálkozik a beléptetéssel, ha az sikertelen.The SDK will handle the details of enrolling the app in the APP-WE service; if necessary, it will retry any enrollments at appropriate time intervals if failures occur.

Az alkalmazás az Intune App SDK-tól kérdezheti le a regisztrált felhasználók állapotát is, amikor azt próbálja megállapítani, hogy az illetőt el kell-e tiltani a vállalati tartalom elérésétől.The app can also query the Intune App SDK for the status of a registered user to determine if the user should be blocked from accessing corporate content. Több fiókot is lehet felügyeletre regisztrálni, de jelenleg egyszerre csak egy lehet aktívan beléptetve az APP-WE szolgáltatásba,Multiple accounts may be registered for management, but currently only one account can be actively enrolled with the APP-WE service at a time. és így az alkalmazásban is egyszerre csak egy fiók kaphat alkalmazásvédelmi szabályzatot.This means only one account on the app can receive app protection policy at a time.

Az alkalmazásnak visszahívás útján kell megszereznie a megfelelő hozzáférési jogkivonatot az Azure Active Directory Authentication Librarytől (ADAL) az SDK nevében.The app is required to provide a callback to acquire the appropriate access token from the Azure Active Directory Authentication Library (ADAL) on behalf of the SDK. Az alapfeltevés az, hogy az alkalmazás már az ADAL-lal hitelesíti a felhasználókat és szerzi be a saját hozzáférési jogkivonatát.It is assumed that the app already uses ADAL for user authentication and to acquire its own access tokens.

Amikor az alkalmazás teljesen eltávolít egy fiókot, meg kell szüntetnie annak regisztrációját, így jelezve, hogy a továbbiakban az adott felhasználóra nem kell szabályzatot alkalmazni.When the app removes an account completely, it should unregister that account to indicate that the app should no longer apply policy for that user. Ha a felhasználó be volt léptetve a MAM-szolgáltatásba, akkor a beléptetés megszűnik, az alkalmazás pedig törlődik.If the user was enrolled in the MAM service, the user will be unenrolled and the app will be wiped.

Az alkalmazások követelményeinek áttekintéseOverview of app requirements

Az APP-WE-integráció implementálásához az alkalmazásnak a felhasználói fiókot regisztrálnia kell a MAM SDK-val:To implement APP-WE integration, your app must register the user account with the MAM SDK:

  1. Az alkalmazásnak kötelező a MAMServiceAuthenticationCallback interfész egy példányát implementálni és regisztrálni.The app must implement and register an instance of the MAMServiceAuthenticationCallback interface. A visszahívási példányt az alkalmazás életciklusának lehető legkorábbi pontján kell regisztrálni (jellemzően az alkalmazás osztályának onMAMCreate() metódusában).The callback instance should be registered as early as possible in the app's lifecycle (typically in the onMAMCreate() method of the application class).

  2. Felhasználói fiók létrejötte és a felhasználó sikeres ADAL-bejelentkezése után alkalmazásnak kötelező meghívni a registerAccountForMAM() metódust.When a user account is created and the user successfully signs in with ADAL, the app must call the registerAccountForMAM().

  3. Felhasználói fiók teljes eltávolítása után az alkalmazásnak az unregisterAccountForMAM() metódussal kell eltávolítania a fiókot az Intune-felügyeletből.When a user account is completely removed, the app should call unregisterAccountForMAM() to remove the account from Intune management.

    Megjegyzés

    Ha egy felhasználó átmenetileg kijelentkezik az alkalmazásból, akkor nincs szükség az unregisterAccountForMAM() meghívására,If a user signs out of the app temporarily, the app does not need to call unregisterAccountForMAM(). mert előfordulhat, hogy ez törlést kezdeményez, és eltávolítja a felhasználó céges adatait.The call may initiate a wipe to completely remove corporate data for the user.

MAMEnrollmentManagerMAMEnrollmentManager

Az összes szükséges hitelesítési és regisztrációs API a MAMEnrollmentManager interfészben található.All the necessary authentication and registration APIs can be found in the MAMEnrollmentManager interface. MAMEnrollmentManager-hivatkozást az alábbi módon lehet szerezni:A reference to the MAMEnrollmentManager can be obtained as follows:

MAMEnrollmentManager mgr = MAMComponents.get(MAMEnrollmentManager.class);

// make use of mgr

A visszaadott MAMEnrollmentManager-példány garantáltan nem null értékű.The MAMEnrollmentManager instance returned is guaranteed not to be null. Az API-metódusok között vannak hitelesítésre és fiókregisztrációra használatosak.The API methods fall into two categories: authentication and account registration.

Megjegyzés

A MAMEnrollmentManager bizonyos API-metódusai hamarosan el fognak évülni.MAMEnrollmentManager contains some API methods that will be deprecated soon. Az érthetőség kedvéért az alábbi kódmintában csak a releváns metódusok és eredménykódok szerepelnek.For clarity, only the relevant methods and result codes are shown in the code block below.

package com.microsoft.intune.mam.policy;

public interface MAMEnrollmentManager {
    public enum Result {
        AUTHORIZATION_NEEDED,
        NOT_LICENSED,
        ENROLLMENT_SUCCEEDED,
        ENROLLMENT_FAILED,
        WRONG_USER,
        MDM_ENROLLED,
        UNENROLLMENT_SUCCEEDED,
        UNENROLLMENT_FAILED,
        PENDING,
        COMPANY_PORTAL_REQUIRED;
    }

    //Authentication methods
    interface MAMServiceAuthenticationCallback {
        String acquireToken(String upn, String aadId, String resourceId);
    }
    void registerAuthenticationCallback(MAMServiceAuthenticationCallback callback);
    void updateToken(String upn, String aadId, String resourceId, String token);

    //Registration methods
    void registerAccountForMAM(String upn, String aadId, String tenantId);
    void unregisterAccountForMAM(String upn);
    Result getRegisteredAccountStatus(String upn);
}

FiókhitelesítésAccount authentication

Ez a szakasz a MAMEnrollmentManager hitelesítési API-metódusait és azok használatát ismerteti.This section describes the authentication API methods in MAMEnrollmentManager and how to use them.

interface MAMServiceAuthenticationCallback {
        String acquireToken(String upn, String aadId, String resourceId);
}
void registerAuthenticationCallback(MAMServiceAuthenticationCallback callback);
void updateToken(String upn, String aadId, String resourceId, String token);
  1. Az alkalmazásnak a MAMServiceAuthenticationCallback interfész implementálásával kell biztosítania, hogy az SDK kérhessen ADAL-jogkivonatot az adott felhasználóhoz és erőforrás-azonosítóhoz.The app must implement the MAMServiceAuthenticationCallback interface to allow the SDK to request an ADAL token for the given user and resource ID. A MAMEnrollmentManager számára annak registerAuthenticationCallback() metódusát meghívva kell biztosítani a visszahívási példányt.The callback instance must be provided to the MAMEnrollmentManager by calling its registerAuthenticationCallback() method. Az alkalmazás életciklusának már nagyon korai szakaszában is szükség lehet jogkivonatra a beléptetési újrapróbálkozásokhoz vagy az alkalmazásvédelmi szabályzat frissítésének kereséséhez, így a visszahívást ideálisan az alkalmazás MAMApplication alosztályának onMAMCreate() metódusában érdemes regisztrálni.A token may be needed very early in the app lifecycle for enrollment retries or app protection policy refresh check-ins, so the ideal place to register the callback is in the onMAMCreate() method of the app's MAMApplication subclass.

  2. A kért erőforrás-azonosítóra szóló hozzáférési jogkivonatot az acquireToken() metódusnak kell beszereznie az adott felhasználó számára.The acquireToken() method should acquire the access token for the requested resource ID for the given user. Ha ez nem sikerül, a metódusnak null értéket kell visszaadnia.If it can't acquire the requested token, it should return null.

  3. Ha az alkalmazás nem tud jogkivonatot biztosítani, amikor az SDK meghívja az acquireToken() metódust – például mert a csendes hitelesítés sikertelen és éppen nem lehet felhasználói felületet megjeleníteni –, később az updateToken() metódust meghívva teheti ezt meg.In case the app is unable to provide a token when the SDK calls acquireToken() -- for example, if silent authentication fails and it is an inconvenient time to show a UI -- the app can provide a token at a later time by calling the updateToken() method. Az updateToken() metódusnak az acquireToken() korábbi meghívásakor használt UPN-t, AAD-azonosítót és erőforrás-ID kell átadni a végül beszerzett jogkivonattal együtt.The same UPN, AAD ID, and resource ID that were requested by the prior call to acquireToken() must be passed to updateToken(), along with the token that was finally acquired. Az alkalmazásnak a lehető leghamarabb meg kell hívnia ezt a metódust, miután a megadott visszahívás a null értéket adta.The app should call this method as soon as possible after returning null from the provided callback.

Megjegyzés

Az SDK rendszeres időközönként megpróbálja az acquireToken() meghívásával megszerezni a jogkivonatot, így az updateToken() meghívása szigorúan véve nem szükséges,The SDK will call acquireToken() periodically to get the token, so calling updateToken() is not strictly required. ugyanakkor ajánlott, mert elősegítheti a beléptetések és az alkalmazásvédelmiszabályzat-ellenőrzések mielőbbi befejezését.However, it is recommended as it can help enrollments and app protection policy check-ins complete in a timely manner.

FiókregisztrációAccount registration

Ez a szakasz a MAMEnrollmentManager fiókregisztrációs API-metódusait és azok használatát ismerteti.This section describes the account registration API methods in MAMEnrollmentManager and how to use them.

void registerAccountForMAM(String upn, String aadId, String tenantId);
void unregisterAccountForMAM(String upn);
Result getRegisteredAccountStatus(String upn);
  1. A fiókokat az alkalmazásnak a registerAccountForMAM() metódust meghívva kell regisztrálnia a felügyelet alá.To register an account for management, the app should call registerAccountForMAM(). A felhasználói fiókot egyszerű felhasználóneve (UPN) és AAD-s felhasználói azonosítója is azonosítja.A user account is identified by both its UPN and its AAD user ID. A beléptetési adatoknak a felhasználó AAD-bérlőjéhez társításához a bérlőazonosító is szükséges.The tenant ID is also required to associate enrollment data with the user's AAD tenant. Az SDK megpróbálhatja az adott felhasználó számára beléptetni az alkalmazást a MAM-szolgáltatásba. Ha a beléptetés sikertelen, akkor rendszeres időközönként újra fog próbálkozni vele, amíg a fiók regisztrációja meg nem szűnik.The SDK may attempt to enroll the app for the given user in the MAM service; if enrollment fails, it will periodically retry enrollment until the account is unregistered. Az újrapróbálkozások időköze általában 12–24 óra.The retry period will typically be 12-24 hours. Az SDK aszinkron módon, értesítések útján közli a beléptetési kísérletek állapotát.The SDK provides the status of enrollment attempts asynchronously via notifications.

  2. Mivel AAD-hitelesítésre van szükség, a felhasználói fiókot a legjobb akkor regisztrálni, amikor már bejelentkezett az alkalmazásba, és az ADAL-hitelesítés is megtörtént.Because AAD authentication is required, the best time to register the user account is after the user has signed into the app and is successfully authenticated using ADAL.

    • Az ADAL-hitelesítési hívás az AuthenticationResult objektum részeként adja vissza a felhasználó AAD-azonosítóját és bérlőazonosítóját.The user's AAD ID and tenant ID are returned from the ADAL authentication call as part of the AuthenticationResult object. A bérlőazonosító az AuthenticationResult.getTenantID() metódusból származik.The tenant ID comes from the AuthenticationResult.getTenantID() method.
    • A felhasználóval kapcsolatos adatok egy, az AuthenticationResult.getUserInfo() metódusból származó, UserInfo típusú alobjektumban találhatók meg, az AAD-beli felhasználót pedig ebből az objektumból lehet lekérni a UserInfo.getUserId() metódussal.Information about the user is found in a sub-object of type UserInfo that comes from AuthenticationResult.getUserInfo(), and the AAD user ID is retrieved from that object by calling UserInfo.getUserId().
  3. A fiókok Intune-felügyeleti regisztrációját az alkalmazásnak az unregisterAccountForMAM() metódust meghívva kell megszüntetnie.To unregister an account from Intune management, the app should call unregisterAccountForMAM(). Ha a fiók sikeresen be lett léptetve, és felügyelt fiók lett, az SDK fogja megszüntetni a beléptetését és törölni az adatait.If the account has been successfully enrolled and is managed, the SDK will unenroll the account and wipe its data. A rendszeres időközönkénti beléptetési próbálkozások abbamaradnak.Periodic enrollment retries for the account will be stopped. Az SDK aszinkron módon, értesítések útján közli a beléptetés-megszüntetési kérések állapotát.The SDK provides the status of unenrollment request asynchronously via notifications.

Fontos megjegyzések az implementálással kapcsolatbanImportant implementation notes

HitelesítésAuthentication

  • Amikor az alkalmazás meghívja a registerAccountForMAM() metódust, kis idővel utána visszahívást kaphat egy másik szálon a MAMServiceAuthenticationCallback interfészén.When the app calls registerAccountForMAM(), it may receive a callback on its MAMServiceAuthenticationCallback interface shortly thereafter, on a different thread. Ideális esetben az alkalmazás már a fiók regisztrálása előtt beszerezte saját jogkivonatát az ADAL-tól, ezzel meggyorsítva a MAMService-jogkivonat beszerzését.Ideally, the app acquired its own token from ADAL prior to registering the account to expedite the acquisition of the MAMService token. Ha az alkalmazás a visszahívásból érvényes jogkivonatot ad vissza, a beléptetés folytatódik, és az alkalmazás egy értesítésben kapja meg a végeredményt.IF the app returns a valid token from the callback, enrollment will proceed and the app will get the final result via a notification.

  • Ha az alkalmazás nem ad vissza érvényes AAD-jogkivonatot, a beléptetés végeredménye AUTHENTICATION_NEEDED lesz.If the app doesn't return a valid AAD token, the final result from the enrollment attempt will be AUTHENTICATION_NEEDED. Ha az alkalmazás ezt az eredményt kapja meg értesítésben, akkor a MAMService-jogkivonat beszerzésével, valamint az updateToken() metódust meghívva az ismételt kezdeményezéssel meggyorsíthatja a beléptetési folyamatot.If the app receives this Result via notification, it can expedite the enrollment process by acquiring the MAMService token and calling the updateToken() method to initiate the enrollment process again. Ez nem szigorú követelmény, hiszen az SDK szabályos időközönként újrapróbálkozik a beléptetéssel, és a visszahívással próbálja beszerezni a jogkivonatot.This is not a firm requirement, however, since the SDK retries enrollment periodically and invokes the callback to acquire the token.

  • Az alkalmazás regisztrált MAMServiceAuthenticationCallback interfésze is meg lesz hívva az alkalmazásvédelmi szabályzatok frissítéseinek rendszeres kereséséhez szükséges jogkivonat beszerzése céljából. Ha az alkalmazás kérésre nem tudja biztosítani a kért jogkivonatot, akkor nem fog értesítést kapni, de meg kell próbálnia jogkivonatot beszerezni, és a legközelebbi alkalmas időpontban meghívni az updateToken() metódust a beléptetési folyamat meggyorsítása érdekében.The app's registered MAMServiceAuthenticationCallback will also be called to acquire a token for periodic app protection policy refresh check-ins. If the app is unable to provide a token when requested, it will not get a notification, but it should attempt to acquire a token and call updateToken() at the next convenient time to expedite the check-in process. A visszahívás akkor is meg lesz hívva a következő beléptetési kísérletnél, ha nincs jogkivonat.If a token is not provided, the callback will still be called at the next check-in attempt.

RegisztrációRegistration

  • Az egyszerűség kedvéért a regisztrációs metódusok idempotensek. A registerAccountForMAM() például csak akkor regisztrálja a fiókot és próbálja meg beléptetni az alkalmazást, ha a fiók még nincs regisztrálva, az unregisterAccountForMAM() pedig csak akkor törli a fiók regisztrációját, ha az az adott időpontban regisztrálva van.For your convenience, the registration methods are idempotent; for example, registerAccountForMAM()will only register an account and attempt to enroll the app if the account is not already registered, and unregisterAccountForMAM() will only unregister an account if it is currently registered. Az ismételt hívások hatástalanok lesznek, így ezeket a metódusokat következmény nélkül meg lehet hívni többször is.Subsequent calls are no-ops, so there is no harm in calling these methods more than once. Ezenfelül a metódusok meghívása nem feltétlenül vált ki eredménnyel kapcsolatos értesítést, tehát amennyiben a registerAccountForMAM metódust egy már regisztrált identitáshoz hívják meg, akkor az identitás nem feltétlenül kap újabb értesítést.Additionally, correspondence between calls to these methods and notifications of results are not guaranteed: i.e. if registerAccountForMAM is called for an identity that is already registered, the notification may not be sent again for that identity. Lehetnek olyan értesítések is, amelyek nem kapcsolódnak ezen metódusok meghívásához, mivel az SDK rendszeres időközönként próbálkozik beléptetésekkel a háttérben, az Intune szolgáltatástól érkező törlési kérések pedig kiválthatnak beléptetés-visszavonásokat.It is possible that notifications are sent that don't correspond to any calls to these methods, since the SDK may periodically try enrollments in the background, and unenrollments may be triggered by wipe requests received from the Intune service.

  • A regisztrációs metódusokat tetszőleges számú különböző identitáshoz meg lehet hívni, de jelenleg egyszerre csak egy felhasználói fiókot lehet sikeresen beléptetni.The registration methods can be called for any number of different identities, but currently only one user account can become successfully enrolled. Ha több, az Intune-hoz licencelt és alkalmazásvédelmi szabályzattal célzott felhasználói fiókot regisztrálnak egyszerre vagy csaknem egy időben, akkor nem lehet előre tudni, hogy melyik nyeri a versenyt.If multiple user accounts that are licensed for Intune and targeted by app protection policy are registered at or near the same time, there is no guarantee on which one will win the race.

  • Végül a MAMEnrollmentManager interfésztől lehet lekérdezni, hogy egy bizonyos fiók regisztrálva van-e, és a getRegisteredAccountStatus metódussal lehet lekérni az aktuális állapotát.Finally, you can query the MAMEnrollmentManager to see if a particular account is registered and to get its current status using the getRegisteredAccountStatus method. Ha a megadott fiók nincs regisztrálva, a metódus a null értéket adja vissza.If the provided account is not registered, this method will return null. Ha a fiók regisztrálva van, a metódus a MAMEnrollmentManager.Result enumeráció valamely elemével jelzi a fiók állapotát.If the account is registered, this method will return the account's status as one of the members of the MAMEnrollmentManager.Result enumeration.

Eredmény- és állapotkódokResult and status codes

A fiók az első regisztráció során PENDING állapotban kerül be a rendszerbe, jelezvén, hogy a MAM-szolgáltatásba való kezdeti beléptetési kísérlet még nem fejeződött be.When an account is first registered, it begins in the PENDING state, indicating that the initial MAM service enrollment attempt is incomplete. A beléptetési kísérlet befejezése után egy értesítés jön létre az alábbi táblázatban felsorolt eredménykódok valamelyikével.After the enrollment attempt finishes, a notification will be sent with one of the Result codes in the table below. Ezenkívül a getRegisteredAccountStatus() metódus visszaadja a fiók állapotát, hogy az alkalmazás bármikor el tudja dönteni, hogy letiltsa-e az adott felhasználó hozzáférését a vállalati tartalomhoz.In addition, the getRegisteredAccountStatus() method will return the account's status so the app can always determine if access to corporate content is blocked for that user. Ha a beléptetési kísérlet sikertelen, a fiók állapota idővel változhat, amint az SDK a háttérben tovább próbálkozik a beléptetéssel.If the enrollment attempt fails, the account's status may change over time as the SDK retries enrollment in the background.

EredménykódResult code MagyarázatExplanation
AUTHORIZATION_NEEDEDAUTHORIZATION_NEEDED Ez az eredmény azt jelzi, hogy az alkalmazás regisztrált MAMServiceAuthenticationCallback-példánya nem szolgáltatott jogkivonatot, vagy az érvénytelen volt.This result indicates that a token was not provided by the app’s registered MAMServiceAuthenticationCallback instance, or the provided token was invalid. Az alkalmazásnak be kell szereznie egy jogkivonatot, és lehetőség szerint meg kell hívnia az updateToken() metódust.The app should acquire a valid token and call updateToken() if possible.
NOT_LICENSEDNOT_LICENSED A felhasználónak nincs Intune-licence, vagy sikertelen volt az Intune MAM-szolgáltatáshoz való kapcsolódás.The user is not licensed for Intune, or the attempt to contact the Intune MAM service failed. Az alkalmazásnak nem felügyelt (normál) állapotban kell tovább futnia, a felhasználót pedig nem kell blokkolni.The app should continue in an unmanaged (normal) state and the user should not be blocked. Amennyiben később a felhasználónak lesz licence, az SDK rendszeresen próbálkozik a beléptetéssel.Enrollments will be retried periodically in case the user becomes licensed in the future.
ENROLLMENT_SUCCEEDEDENROLLMENT_SUCCEEDED A beléptetési kísérlet sikeres volt, vagy a felhasználó már korábban be lett léptetve.The enrollment attempt succeeded, or the user is already enrolled. Sikeres beléptetés esetén ezt az értesítést megelőzően egy szabályzatfrissítési értesítést is küld a rendszer.In the case of a successful enrollment, a policy refresh notification will be sent before this notification. A vállalati adatokhoz való hozzáférést engedélyezni kell.Access to corporate data should be allowed.
ENROLLMENT_FAILEDENROLLMENT_FAILED A beléptetési kísérlet sikertelen volt.The enrollment attempt failed. A további részletek az eszköznaplókban találhatók.Further details can be found in the device logs. Az alkalmazás ebben az állapotban nem engedélyezheti a vállalati tartalomhoz való hozzáférést, hiszen korábban megállapította, hogy a felhasználónak van Intune-licence.The app should not allow access to corporate in this state, since it was previously determined that the user is licensed for Intune.
WRONG_USERWRONG_USER Egy eszközön minden alkalmazást csak egy felhasználó léptethet be a MAM-szolgáltatásba.Only one user per device can enroll an app with the MAM service. Másik felhasználó csak akkor hajthat végre sikeres beléptetést, ha előbb az összes beléptetett alkalmazás beléptetését megszüntetik.In order to enroll successfully as a different user, all enrolled apps must be unenrolled first. Ellenkező esetben ezt az alkalmazást is csak az elsődleges felhasználó léptetheti be.Otherwise, this app must enroll as the primary user. Ez az ellenőrzés a licencellenőrzés után zajlik le, tehát a felhasználó céges adatokhoz való hozzáférését az alkalmazás sikeres beléptetéséig tiltani kell.This check happens after the license check, so the user should be blocked from accessing corporate data until the app is successfully enrolled.
UNENROLLMENT_SUCCEEDEDUNENROLLMENT_SUCCEEDED A beléptetés megszüntetése sikeres volt.Unenrollment was successful.
UNENROLLMENT_FAILEDUNENROLLMENT_FAILED A beléptetés-megszüntetési kérés sikeres volt.The unenrollment request failed. A további részletek az eszköznaplókban találhatók.Further details can be found in the device logs.
PENDINGPENDING A felhasználó első beléptetési kísérlete folyamatban van.The initial enrollment attempt for the user is in progress. Az alkalmazás a beléptetés eredményének ismertté válásáig letilthatja a vállalati adatokhoz való hozzáférést, de nem köteles így tenni.The app can block access to corporate data until the enrollment result is known, but is not required to do so.
COMPANY_PORTAL_REQUIREDCOMPANY_PORTAL_REQUIRED A felhasználónak van Intune-licence, de az alkalmazást nem lehet beléptetni, amíg a Céges portál alkalmazás nincs telepítve az eszközre.The user is licensed for Intune, but the app cannot be enrolled until the Company Portal app is installed on the device. Az Intune App SDK megpróbálja megtagadni az alkalmazáshoz való hozzáférést az adott felhasználótól, és felszólítani a Céges portál alkalmazás telepítésére (részletek alább).The Intune App SDK will attempt to block access to the app for the given user and direct them to install the Company Portal app (see below for details).

A Céges portál követelményére való figyelmeztetés felülbírálása (nem kötelező)Company Portal requirement prompt override (optional)

COMPANY_PORTAL_REQUIRED eredmény esetén az SDK letiltja az ahhoz az identitáshoz kapcsolódó tevékenységeket, amelynek a beléptetése a kérés tárgya volt.If the COMPANY_PORTAL_REQUIRED Result is received, the SDK will block use of activities that use the identity for which enrollment was requested. Az SDK ezen tevékenységekre válaszul egy, a Céges portál alkalmazás letöltését kérő üzenetet jelenít meg.Instead, the SDK will cause those activities to display a prompt to download the Company Portal. Ha ezt a saját alkalmazásában szeretné elkerülni, a tevékenységek implementálhatják a MAMActivity.onMAMCompanyPortalRequired metódust.If you want to prevent this behavior in your app, activities may implement MAMActivity.onMAMCompanyPortalRequired.

Ennek meghívása még az előtt történik, hogy az SDK megjelenítené az alapértelmezett letiltó felhasználói felületet.This method is called before the SDK displays its default blocking UI. Ha az alkalmazás módosítja a tevékenység identitását, vagy törli a beléptetést megkísérlő felhasználó regisztrációját, az SDK nem fogja letiltani a tevékenységet.If the app changes the activity identity or unregisters the user who attempted to enroll, the SDK will not block the activity. Ebben az esetben az alkalmazás feladata a vállalati adatszivárgás megakadályozása.In this situation, it is up to the app to avoid leaking corporate data.

ÉrtesítésekNotifications

Egy új MAMNotification-típust vezettünk be, amely a beléptetési kérés befejezéséről tájékoztatja az alkalmazást.A new type of MAMNotification has been added in order to inform the app that the enrollment request has completed. A MAMEnrollmentNotification értesítés fogadása a MAMNotificationReceiver interfészen keresztül történik, a Regisztráció az SDK értesítéseire című szakaszban leírtak szerint.The MAMEnrollmentNotification will be received through the MAMNotificationReceiver interface as described in the Register for notifications from the SDK section.

public interface MAMEnrollmentNotification extends MAMUserNotification {
    MAMEnrollmentManager.Result getEnrollmentResult();
}

A getEnrollmentResult() metódus a beléptetési kérés eredményét adja vissza.The getEnrollmentResult() method returns the result of the enrollment request. Mivel a MAMEnrollmentNotification a MAMUserNotification kiterjesztése, a beléptetési kérés által érintett felhasználó identitása is elérhető.Since MAMEnrollmentNotification extends MAMUserNotification, the identity of the user for whom the enrollment was attempted is also available. Az alkalmazásnak ezen értesítések fogadásához a Regisztráció az SDK értesítéseire című szakaszban leírtaknak megfelelően implementálnia kell a MAMNotificationReceiver interfészt.The app must implement the MAMNotificationReceiver interface to receive these notifications, detailed in the Register for notifications from the SDK section.

A regisztrált felhasználói fiók állapota beléptetési értesítés fogadásakor megváltozhat, de bizonyos esetekben ez nem történik meg (ha például az AUTHORIZATION_NEEDED értesítés egy konkrétabb eredménykód, mondjuk a WRONG_USER után érkezik, akkor a fiók állapota továbbra is a konkrétabb eredményt fogja tükrözni).The registered user account's status may change when an enrollment notification is received, but it will not change in some cases (e.g. if AUTHORIZATION_NEEDED notification is received after a more informative result such as WRONG_USER, the more informative result will be maintained as the account's status)

Biztonságimásolat-adatok védelmeProtecting Backup data

Az Android Marshmallow (API 23) esetében az Android két módszert kínál az alkalmazásoknak az adataik biztonsági mentéséhez.As of Android Marshmallow (API 23), Android has two ways for an app to back up its data. Mindegyik lehetőség elérhető az alkalmazás számára, de különböző lépések végrehajtását igényli az Intune-adatvédelem megfelelő megvalósításához.Each option is available to your app and requires different steps to ensure that Intune data protection is correctly implemented. Az alábbi táblázatban áttekintheti a megfelelő adatvédelmi működéshez szükséges műveleteket.You can review the table below on corresponding actions required for correct data protection behavior. A biztonsági mentési módszerek részletes ismertetését az Android API útmutatójában olvashatja el.You can read more about the backup methods in the Android API guide.

Alkalmazások automatikus biztonsági mentéseAuto Backup for Apps

Az Android az Android Marshmallow rendszerű eszközökre telepített alkalmazásokhoz kezdte el kínálni a Google Drive-ra történő automatikus teljes biztonsági mentést, függetlenül az alkalmazások cél API-jától.Android began offering automatic full backups to Google Drive for apps on Android Marshmallow devices, regardless of the app's target API. Ha az AndroidManifest.xml fájlban explicit módon false értékűre állítja az android:allowBackup attribútumot, akkor az alkalmazás soha nem kerül az Android által végrehajtott biztonsági mentések várólistájára, és a „vállalati” adatok megmaradnak az alkalmazásban.In your AndroidManifest.xml, if you explicitly set android:allowBackup to false, then your app will never be queued for backups by Android and "corporate" data will stay within the app. Ebben az esetben nincs további teendő.In this case, no further action is necessary.

Alapértelmezés szerint azonban az android:allowBackup attribútum true értékű még akkor is, ha az android:allowBackup nincs megadva a jegyzékfájlban.However, by default the android:allowBackup attribute is set to true, even if android:allowBackup isn't specified in the manifest file. Ez azt jelenti, hogy az alkalmazások összes adatáról automatikus biztonsági másolat készül a felhasználó Google Drive-fiókjába, és ez olyan alapértelmezett működés, amely adatszivárgási kockázatot vet fel.This means all app data is automatically backed up to the user's Google Drive account, a default behavior that poses a data leak risk. Ezért az SDK az alább leírt módosításokat követeli meg az adatvédelem alkalmazásának biztosításához.Therefore, the SDK requires the changes outlined below to ensure that data protection is applied. Fontos követnie az alábbi az irányelveket az ügyféladatok megfelelő védelme érdekében, ha az alkalmazást Android Marshmallow rendszerű eszközökön szeretné futtatni.It is important to follow the guidelines below to protect customer data properly if you want your app to run on Android Marshmallow devices.

Az Intune lehetővé teszi az Android összes elérhető automatikus biztonsági mentési funkciójának használatát, beleértve az egyéni szabályok definiálását XML-ben, de az adatok védelme érdekében követnie kell az alábbi lépéseket:Intune allows you to utilize all the Auto Backup features available from Android, including the ability to define custom rules in XML, but you must follow the steps below to secure your data:

  1. Ha az alkalmazás nem saját BackupAgentet használ, az alapértelmezett MAMBackupAgent használatával engedélyezheti az Intune szabályzatainak megfelelő automatikus teljes biztonsági mentéseket.If your app does not use its own custom BackupAgent, use the default MAMBackupAgent to allow for automatic full backups that are Intune policy compliant. Ebben az esetben figyelmen kívül hagyhatja a jegyzékfájl android:fullBackupOnly attribútumát, mert az a Microsoft biztonságimásolat-készítő ügynökére nem érvényes.If you do this, you can ignore the android:fullBackupOnly manifest attribute, as it’s not applicable for our backup agent. Helyezze el az alábbi kódrészletet az alkalmazás jegyzékfájljában:Place the following in the app manifest:

    android:backupAgent="com.microsoft.intune.mam.client.app.backup.MAMDefaultBackupAgent"
    
  2. [nem kötelező] Amennyiben saját BackupAgent implementálása mellett döntött, mindenképpen a MAMBackupAgent vagy a MAMBackupAgentHelper osztályt kell használnia.[Optional] If you implemented an optional custom BackupAgent, you need to make sure to use MAMBackupAgent or MAMBackupAgentHelper. Lásd a következő szakaszokat.See the following sections. Fontolja meg az áttérést az Intune (az 1. lépésben ismertetett) MAMDefaultFullBackupAgent osztályának használatára, amely egyszerű biztonsági mentést tesz lehetővé Android M-en és újabb rendszereken.Consider switching to using Intune's MAMDefaultFullBackupAgent (described in step 1) which provides easy back up on Android M and above.

  3. Amikor eldönti, hogy az alkalmazásról milyen típusú teljes biztonsági mentés készüljön (szűretlen, szűrt, semmilyen), az android:fullBackupContent attribútumot be kell állítania igaz vagy hamis értékűre vagy egy XML-erőforrásra az alkalmazásban.When you decide which type of full backup your app should receive (unfiltered, filtered, or none) you'll need to set the attribute android:fullBackupContent to true, false, or an XML resource in your app.

  4. Minden, az android:fullBackupContent attribútumban elhelyezett adatot kötelező egy com.microsoft.intune.mam.FullBackupContent nevű metaadatcímkébe másolni.Then, you must copy whatever you put into android:fullBackupContent into a metadata tag named com.microsoft.intune.mam.FullBackupContent in the manifest.

    1. példa: ha azt szeretné, hogy az alkalmazás kizárás nélkül mindenről teljes biztonsági másolatot készítsen, állítsa mind az android:fullBackupContent attribútumot, mind a com.microsoft.intune.mam.FullBackupContent metaadatcímkét true állapotra:Example 1: If you want your app to have full backups without exclusions, set both the android:fullBackupContent attribute and com.microsoft.intune.mam.FullBackupContent metadata tag to true:

    android:fullBackupContent="true"
    ...
    <meta-data android:name="com.microsoft.intune.mam.FullBackupContent" android:value="true" />  
    

    2. példa: ha azt szeretné, hogy az alkalmazás a saját egyéni BackupAgentjét használja, és lemond az Intune-szabályzatoknak megfelelő, automatikus teljes biztonsági mentésekről, az attribútumot és a metaadatcímkét is false értékre kell állítani:Example 2: If you want your app to use its custom BackupAgent and opt out of full, Intune policy compliant, automatic backups, you must set the attribute and metadata tag to false:

    android:fullBackupContent="false"
    ...
    <meta-data android:name="com.microsoft.intune.mam.FullBackupContent" android:value="false" />  
    

    3. példa: Ha azt szeretné, hogy az alkalmazásról teljes biztonsági mentések készüljenek egy XML-fájlban definiált egyéni szabályoknak megfelelően, akkor az attribútumot és a metaadatcímkét ugyanarra az XML-erőforrásra állítsa be:Example 3: If you want your app to have full backups according to your custom rules defined in an XML file, please set the attribute and metadata tag to the same XML resource:

    android:fullBackupContent="@xml/my_scheme"
    ...
    <meta-data android:name="com.microsoft.intune.mam.FullBackupContent" android:resource="@xml/my_scheme" />  
    

Kulcs/érték biztonsági mentésKey/Value Backup

A Key/Value Backup (Kulcs/érték biztonsági mentés) lehetőség minden 8-as vagy újabb verziójú API számára elérhető, és az Android Backup Service szolgáltatásba tölti fel az adatokat,The Key/Value Backup option is available to all APIs 8+ and uploads app data to the Android Backup Service. felhasználónként legfeljebb 5 MB-nyit.The amount of data per user of your app is limited to 5MB. A Key/Value Backup használata esetén BackupAgentHelper vagy BackupAgent osztályt kell használni.If you use Key/Value Backup, you must use a BackupAgentHelper or a BackupAgent.

BackupAgentHelperBackupAgentHelper

A BackupAgentHelper osztályt mind a natív androidos funkciókat, mind az Intune MAM-integrációt tekintve jóval egyszerűbb implementálni, mint a BackupAgentet.BackupAgentHelper is easier to implement than BackupAgent both in terms of native Android functionality and Intune MAM integration. A BackupAgentHelper lehetővé teszi, hogy a fejlesztő teljes fájlokat és közös beállításokat regisztráljon rendre egy FileBackupHelper és egy SharedPreferencesBackupHelper osztályban, amelyek ezután létrehozáskor hozzáadódnak a BackupAgentHelper osztályhoz.BackupAgentHelper allows the developer to register entire files and shared preferences to a FileBackupHelper and SharedPreferencesBackupHelper (respectively) which are then added to the BackupAgentHelper upon creation. Az alábbi lépéseket követve használhat BackupAgentHelper osztályt az Intune MAM-szolgáltatással:Follow the steps below to use a BackupAgentHelper with Intune MAM:

  1. Ha többidentitásos biztonsági mentést szeretne használni a BackupAgentHelper osztállyal, kövesse az Extending BackupAgentHelper (A BackupAgentHelper kiterjesztése) című angol nyelvű Android-útmutatót.To utilize multi-identity backup with a BackupAgentHelper, follow the Android guide to Extending BackupAgentHelper.

  2. Osztályával terjessze ki a BackupAgentHelper, a FileBackupHelper és a SharedPreferencesBackupHelper osztályok MAM-os megfelelőjét.Have your class extend the MAM equivalent of BackupAgentHelper, FileBackupHelper, and SharedPreferencesBackupHelper.

Androidos osztályAndroid class MAM-os megfelelőMAM equivalent
BackupAgentHelperBackupAgentHelper MAMBackupAgentHelperMAMBackupAgentHelper
FileBackupHelperFileBackupHelper MAMFileBackupHelperMAMFileBackupHelper
SharedPreferencesBackupHelperSharedPreferencesBackupHelper MAMSharedPreferencesBackupHelperMAMSharedPreferencesBackupHelper

Ezen irányelvek betartása elősegíti a sikeres, többidentitásos biztonsági mentést és visszaállítást.Following these guidelines will lead to a successful multi-identity backup and restore.

BackupAgentBackupAgent

A BackupAgent segítségével sokkal egyértelműbben adható meg, hogy mely adatokról készüljön biztonsági mentés.A BackupAgent allows you to be much more explicit about what data is backed up. Mivel az implementálás nagyrészt a fejlesztő felelőssége, több lépésre van szükség az Intune megfelelő adatvédelmének biztosításához.Because the developer is fairly responsible for the implementation, there are more steps required to ensure appropriate data protection from Intune. Azáltal, hogy a munka nagyobb része a fejlesztőre hárul, az Intune-integráció itt valamivel több jelentőséggel bír.Since most of the work is pushed onto you, the developer, Intune integration is slightly more involved.

MAM-integráció:Integrate MAM:

  1. Gondosan tanulmányozza át a Key/Value Backup (Kulcs/érték biztonsági mentés) és főleg az Extending BackupAgent (A BackupAgent kiterjesztése) című Android-útmutatókat annak érdekében, hogy a BackupAgent-implementáció biztosan megfeleljen az androidos irányelveknek.Please carefully read the Android guide for Key/Value Backup and specifically Extending BackupAgent to ensure your BackupAgent implementation follows Android guidelines.

  2. Osztályával terjessze ki a MAMBackupAgent osztályt.Have your class extend MAMBackupAgent.

Többidentitásos biztonsági mentés:Multi-identity Backup:

  1. A biztonsági mentés megkezdése előtt ellenőrizze, hogy a rendszergazda valóban engedélyezte-e a szóban forgó fájlok vagy adatpufferek biztonsági mentését többidentitásos környezetben.Before beginning your backup, check that the files or data buffers you plan to back up are indeed permitted by the IT administrator to be backed up in multi-identity scenarios. Erre a célra szolgál a MAMFileProtectionManager és MAMDataProtectionManager osztályokban szereplő isBackupAllowed függvény.We provide you with the isBackupAllowed function in MAMFileProtectionManager and MAMDataProtectionManager to determine this. Ha valamely fájl vagy adatpuffer biztonsági mentése nem engedélyezett, azt ne vonja be a biztonsági mentésbe.If the file or data buffer is not allowed to be backed up, then you should not continue including it in your backup.

  2. Ha a biztonsági mentés egy pontján biztonsági másolatot szeretne készíteni az 1. lépésben ellenőrzött fájlokhoz tartozó identitásokról, a backupMAMFileIdentity(BackupDataOutput data, File … files) függvényt kell meghívnia azokkal a fájlokkal, amelyekből adatokat szeretne kinyerni.At some point during your backup, if you want to back up the identities for the files you checked in step 1, you must call backupMAMFileIdentity(BackupDataOutput data, File … files) with the files from which you plan to extract data. Ez a művelet automatikusan új biztonsági mentési entitásokat hoz létre, és a BackupDataOutput kimenetre írja azokat.This will automatically create new backup entities and write them to the BackupDataOutput for you. Ezeket az entitásokat automatikusan felhasználja a program a visszaállítás során.These entities will be automatically consumed upon restore.

Többidentitásos visszaállítás:Multi-identity Restore:

Az adatok biztonsági mentésével kapcsolatos Android-útmutatóban meg van adva egy általános algoritmus az alkalmazásadatok visszaállításához, az Extending BackupAgent (A BackupAgent kiterjesztése) című szakaszban pedig kódminta is található.The Data Backup guide specifies a general algorithm for restoring your application’s data and provides a code sample in the Extending BackupAgent section. A sikeres, többidentitásos visszaállítás érdekében kötelező a kódmintában megadott általános struktúrát követni, különös tekintettel az alábbiakra:In order to have a successful multi-identity restore, you must follow the general structure provided in this code sample with special attention to the following:

  1. A biztonsági mentési entitásokon egy while(data.readNextHeader())* ciklussal kell végighaladni.You must utilize a while(data.readNextHeader())* loop to go through the backup entities.

  2. Ha a data.getKey()* nem egyezik meg az onBackup-ba írt kulccsal, akkor meg kell hívni a data.skipEntityData()* függvényt.You must call data.skipEntityData()* if data.getKey()* does not match the key you wrote in onBackup. Enélkül előfordulhat, hogy a visszaállítások nem járnak sikerrel.Without performing this step, your restores may not succeed.

  3. Kerülje a visszatérést a biztonsági mentési entitások while(data.readNextHeader())* szerkezetben való feldolgozása során, mert elveszhetnek az automatikusan kiírt entitások.Avoid returning while consuming backup entities in the while(data.readNextHeader())* construct, as the entities we automatically write will be lost.

  • A data helyére az alkalmazásnak a visszaállításkor átadott BackupDataInput helyi változónevét kell behelyettesíteni.Where data is the local variable name for the BackupDataInput that is passed to your app upon restore.

Több identitás használata (nem kötelező)Multi-identity (optional)

ÁttekintésOverview

Az Intune App SDK alapértelmezés szerint az alkalmazás egészére alkalmazza a szabályzatot.By default, the Intune App SDK will apply policy to the app as a whole. A többszörös identitás az Intune-alkalmazásvédelem választható funkciója, amelynek engedélyezése esetén a szabályzatok identitásonként alkalmazhatók.Multi-identity is an optional Intune app protection feature which can be enabled to allow policy to be applied on a per-identity level. Ez a többi alkalmazásvédelmi funkciónál jelentősen nagyobb mértékű közreműködést igényel az alkalmazástól.This requires significantly more app participation than other app protection features.

Az alkalmazásnak tájékoztatnia kell az SDK-t, ha módosítani kívánja az aktív identitást.The app must inform the SDK when it intends to change the active identity. Egyes esetekben az SDK is értesíti az alkalmazást, ha identitásváltás szükséges.In some cases, the SDK will also notify the app when an identity change is required. A legtöbb esetben azonban MAM nem ismeri a felhasználói felületen éppen megjelenített, vagy egy adott időben egy szálon használt adatokat, és az alkalmazásra hagyatkozik a helyes identitás beállításához az adatvesztés elkerülése érdekében.In most cases, however, MAM cannot know what data is being displayed in the UI or used on a thread at a given time and relies on the app to set the correct identity in order to avoid data leak. A következő szakaszokban néhány, az alkalmazás műveletét igénylő helyzetet tüntetünk fel.In the sections that follow, some particular scenarios which require app action will be called out.

Megjegyzés

Az alkalmazás megfelelő közreműködésének elmulasztása adatszivárgásokat és egyéb biztonsági problémákat okozhat.A lack of the correct app participation can result in data leaks and other security issues.

Ha a felhasználó már beléptette az eszközt vagy az alkalmazást, az SDK regisztrálja ezt az identitást, és ezt tekinti az Intune-ban felügyelt elsődleges identitásnak.Once the user enrolls the device or the app, the SDK registers this identity and considers it the primary Intune managed identity. Az alkalmazás többi felhasználójával nem felügyeltként bánik, szabályzatbeállításaik korlátlanok.Other users in the app will be treated as unmanaged, with unrestricted policy settings.

Megjegyzés

Jelenleg eszközönként csak egy Intune által felügyelt identitás támogatott.Currently, only one Intune managed identity is supported per device.

Felhívjuk, hogy az identitás egyszerűen egy karakterláncként van definiálva.Note that an identity is simply defined as a string. Az identitásokban nem számítanak különbözőnek a kis- és a nagybetűk, és az SDK nem feltétlen olyan kis- és nagybetűkkel adja vissza a tőle kért identitásokat, mint ahogyan az az identitás beállításakor eredetileg meg volt adva.Identities are case-insensitive, and requests to the SDK for an identity may not return the same casing that was originally used when setting the identity.

Több identitás használatának engedélyezéseEnabling Multi-identity

Alapértelmezés szerint az összes alkalmazás egyszeres identitással rendelkező alkalmazásnak minősül.By default, all apps are considered to be single-identity apps. Az AndroidManifest.xml-ben elhelyezett alábbi metaadatokkal lehet jelezni, hogy egy alkalmazás képes több identitás kezelésére.You can declare an app to be multi-identity aware by placing the following metadata in AndroidManifest.xml.

  <meta-data
    android:name="com.microsoft.intune.mam.MAMMultiIdentity"
    android:value="true" />

Az identitás beállításaSetting the Identity

A fejlesztők (csökkenő prioritási sorrendben) a következő szinteken állíthatják be az alkalmazás identitását:Developers can set the identity of the app user on the following levels in descending priority:

  1. Szál szintjeThread level
  2. Környezet (általában tevékenység) szintjeContext (generally Activity) level
  3. Folyamat szintjeProcess level

A szál szintjén beállított identitás felülírja a környezet szintjén beállított identitást, mely utóbbi felülírja a folyamat szintjén beállított identitást.An identity set at the thread level supersedes an identity set at the Context level, which supersedes an identity set at the process level. A környezet szintjén beállított identitás csak a megfelelő társított esetekben használatos.An identity set on a Context is only used in appropriate associated scenarios. A fájlok I/O műveleteihez például nem tartozik környezet.File IO operations, for example, do not have an associated Context. A leggyakrabban az alkalmazások állítják be az adott tevékenységre vonatkozó környezeti identitást.Most commonly, apps will set the Context identity on an Activity. Az alkalmazásnak nem kell megjelenítenie az adatokat egy felügyelt identitás számára, hacsak a tevékenység identitása nem ugyanazon identitásra van beállítva.An app must not display data for a managed identity unless the Activity's identity is set to that same identity. A folyamatszintű identitás általában csak akkor hasznos, ha az alkalmazás egyszerre csak egy-egy felhasználóval működik az összes szálon.In general, the process-level identity is only useful if the app works only with a single user at a time on all threads. Számos alkalmazásnak nem feltétlenül kell igénybe vennie.Many apps may not need to make use of it.

A MAMPolicyManager következő metódusaival lehet beállítani az identitást, illetve beolvasni a korábban beállított identitásértékeket.The following methods in MAMPolicyManager may be used to set the identity and retrieve the identity values previously set.

  public static void setUIPolicyIdentity(final Context context, final String identity, final MAMSetUIIdentityCallback mamSetUIIdentityCallback);

  public static String getUIPolicyIdentity(final Context context);

  public static MAMIdentitySwitchResult setProcessIdentity(final String identity);

  public static String getProcessIdentity();

  public static MAMIdentitySwitchResult setCurrentThreadIdentity(final String identity);

  public static String getCurrentThreadIdentity();

  /**
   * Get the currently applicable app policy. Same as
   * MAMComponents.get(AppPolicy.class). This method does
   * not take the context identity into account.
   */
  public static AppPolicy getPolicy();

  /**
  * Get the current app policy. This does NOT take the UI (Context) identity into account.
   * If the current operation has any context (e.g. an Activity) associated with it, use the overload below.
   */
  public static AppPolicy getPolicy(final Context context);


  public static AppPolicy getPolicyForIdentity(final String identity);

  public static boolean getIsIdentityManaged(final String identity);

Megjegyzés

Az alkalmazás identitását null értékre állítva törölheti.You can clear the identity of the app by setting it to null.

Az üres karakterlánc használható olyan identitásként, amelyre biztosan nem vonatkozik alkalmazásvédelmi szabályzat.The empty string may be used as an identity that will never have app protection policy.

EredményResults

Az identitást beállító összes metódus a MAMIdentitySwitchResult objektummal adja vissza az eredményértékeket.All the methods used to set the identity report back result values via MAMIdentitySwitchResult. Négy visszaadható érték van:There are four values that can be returned:

Visszatérési értékReturn value ForgatókönyvScenario
SUCCEEDEDSUCCEEDED Az identitásváltás sikeres volt.The identity change was successful.
NOT_ALLOWEDNOT_ALLOWED Az identitásváltás nem engedélyezett.The identity change is not allowed. Az identitásváltás nem engedélyezett.The identity change is not allowed. Ez akkor fordul elő, ha valaki a Felhasználói felület (Környezet) identitást próbálja beállítani, amikor egy másik identitás van beállítva az aktuális szálhoz.This occurs if an attempt is made to set the UI (Context) identity when a different identity is set on the current thread.
CANCELLEDCANCELLED A felhasználó megszakította az identitásváltást. Ez általában úgy történik, hogy megnyomja a Vissza gombot egy PIN-kódot kérő vagy hitelesítési üzenetnél.The user cancelled the identity change, generally by pressing the back button on a PIN or authentication prompt.
FAILEDFAILED Az identitásváltás ismeretlen okból nem sikerült.The identity change failed for an unspecified reason.

Az alkalmazásnak a vállalati adatok megjelenítése vagy használata előtt meg kell győződnie az identitásváltás sikerességéről.The app must ensure that an identity switch is successful before displaying or using corporate data. Jelenleg a folyamat- és a szálidentitás-váltások mindig sikeresek lesznek a több identitást támogató alkalmazások esetén, azonban fenntartjuk a jogot hibafeltételek hozzáadására.Currently, process and thread identity switches will always succeed for a multi-identity-enabled app, however we reserve the right to add failure conditions. A felhasználói felület identitásváltása sikertelen lehet érvénytelen argumentumok esetén, ha az ütközne a szálidentitással, vagy ha a felhasználó a feltételes indítási követelményeit megszakítja (pl. a Vissza gombra kattint a PIN-kód képernyőn).The UI identity switch may fail for invalid arguments, if it would conflict with the thread identity, or if the user cancels out of conditional launch requirements (e.g. presses the back button on the PIN screen).

Környezet identitás beállítása esetén az eredmény aszinkron módon jelenik meg.In the case of setting a Context identity, the result is reported asynchronously. Ha a Környezet egy tevékenység, akkor az SDK mindaddig nem tudja, hogy sikeres volt-e az identitásváltás, amíg feltételes indítás történik – itt ugyanis a felhasználónak meg kell adnia a PIN-kódját vagy vállalati hitelesítő adatait.If the Context is an Activity, the SDK doesn't know if the identity change succeeded until after conditional launch is performed -- which may require the user to enter a PIN or corporate credentials. Az alkalmazásnak az elvárások szerint egy MAMSetUIIdentityCallback interfészt implementálva kell fogadnia ezt az eredményt, bár ennél a paraméternél a null érték átadása is megengedett.The app is expected to implement a MAMSetUIIdentityCallback to receive this result, you can pass null for this parameter.

    public interface MAMSetUIIdentityCallback {
        void notifyIdentityResult(MAMIdentitySwitchResult identitySwitchResult);
  }

A tevékenységek identitását közvetlenül a MAMActivity egy metódusával, a MAMPolicyManager.setUIPolicyIdentity meghívása nélkül is beállíthatja.You can also set the identity of an activity directly through a method in MAMActivity instead of calling MAMPolicyManager.setUIPolicyIdentity. A metódus az alábbi:Use following method to do so:

     public final void switchMAMIdentity(final String newIdentity);

Az MAMActivity osztály metódusát felül is lehet bírálni, ha azt szeretné, hogy az alkalmazás értesítést kapjon a tevékenység identitásának módosítására tett kísérletek eredményéről.You can also override a method in MAMActivity if you want the app to be notified of the result of attempts to change the identity of that activity.

    public void onSwitchMAMIdentityComplete(final MAMIdentitySwitchResult result);

Megjegyzés

Előfordulhat, hogy az identitásváltás után újból létre kell hozni a tevékenységet.Switching the identity may require recreating the activity. Ebben az esetben a onSwitchMAMIdentityComplete visszahívása lesz elküldve a tevékenység új példányának.In this case, the onSwitchMAMIdentityComplete callback will be delivered to the new instance of the activity.

Az identitás implicit megváltoztatásaImplicit Identity Changes

Az alkalmazás identitásbeállítási képessége mellett a szálak és a környezetek identitása megváltoztatható a más, alkalmazásvédelmi szabályzattal ellátott Intune-kompatibilis alkalmazásból beérkező adatok alapján is.In addition to the app's ability to set the identity, a thread or a context's identity may change based on data ingress from another Intune-enlightened app that has app protection policy.

PéldákExamples

  1. Ha például egy tevékenység egy másik MAM-alkalmazás által küldött Intent alapján indul el, akkor a tevékenység identitása a másik alkalmazásban az Intent elküldésekor érvényes identitás alapján lesz beállítva.If an activity is launched from an Intent sent by another MAM app, the activity’s identity will be set based on the effective identity in the other app at the point the Intent was sent.

  2. A szolgáltatások esetében a szál identitása hasonlóan lesz beállítva az onStart- vagy az onBind-hívások időtartamára.For services, the thread identity will be set similarly for the duration of an onStart or onBind call. Átmenetileg a Binder-be érkező, az onBind által visszaadott hívások is beállítják a szál identitását.Calls into the Binder returned from onBind will also temporarily set the thread identity.

  3. A beérkező hívások a ContentProvider esetében is hasonlóképpen beállítják a szál identitását az időtartamukra vonatkozóan.Calls into a ContentProvider will similarly set the thread identity for their duration.

Ezenkívül a tevékenységekkel kapcsolatos felhasználói beavatkozások is előidézhetnek implicit identitásváltást.In addition, user interaction with an activity may cause an implicit identity switch.

Példa: ha egy felhasználó a Resume művelet közben megszakítja az engedélyezési kérést, akkor implicit módon üres identitásra való váltást eredményez.Example: A user canceling out of an authorization prompt during Resume will result in an implicit switch to an empty identity.

Lehetőség van arra, hogy az alkalmazás értesüljön ezekről a váltásokról, és szükség esetén megtiltsa őket.The app is given an opportunity to be made aware of these changes, and, if it must, the app can forbid them. A MAMService és a MAMContentProvider a következő, az alosztályok által felülbírálható metódust teszi elérhetővé:MAMService and MAMContentProvider expose the following method that subclasses may override:

public void onMAMIdentitySwitchRequired(final String identity,
  final AppIdentitySwitchResultCallback callback);

A MAMActivity osztályban a metódusnak még egy paramétere van:In the MAMActivity class , an additional parameter is present in the method:

public void onMAMIdentitySwitchRequired(final String identity,
  final AppIdentitySwitchReason reason,
  final AppIdentitySwitchResultCallback callback);
  • Az AppIdentitySwitchReason rögzíti az implicit váltás forrását, és a következő értékeket tudja fogadni: CREATE, RESUME_CANCELLED és NEW_INTENT.The AppIdentitySwitchReason captures the source of the implicit switch, and can accept the values CREATE, RESUME_CANCELLED, and NEW_INTENT. A RESUME_CANCELLED ok akkor használható, amikor a tevékenység folytatása PIN-kódot kérő, hitelesítési vagy egyéb megfelelőségi felhasználói felület megjelenítését idézi elő, és a felhasználó megpróbál kilépni erről a felhasználói felületről, általában a Vissza gomb használatával.The RESUME_CANCELLED reason is used when activity resume causes PIN, authentication, or other compliance UI to be displayed and the user attempts to cancel out of that UI, generally though use of the back button.

  • Az AppIdentitySwitchResultCallback a következőképpen történik:The AppIdentitySwitchResultCallback is as follows:

    public interface AppIdentitySwitchResultCallback {
        /**
         * @param result
         *            whether the identity switch can proceed.
         */
        void reportIdentitySwitchResult(AppIdentitySwitchResult result);
    }
    

    Az AppIdentitySwitchResult értéke vagy SUCCESS, vagy FAILURE.Where AppIdentitySwitchResult is either SUCCESS or FAILURE.

Az onMAMIdentitySwitchRequired metódus hívandó az összes implicit identitásváltás esetében, kivéve azokat, amelyek a MAMService.onMAMBind által visszaadott Binderen keresztül történtek.The method onMAMIdentitySwitchRequired is called for all implicit identity changes except for those made through a Binder returned from MAMService.onMAMBind. Az onMAMIdentitySwitchRequired alapértelmezett implementációi a következő metódusokat hívják meg azonnal:The default implementations of onMAMIdentitySwitchRequired immediately call:

  • reportIdentitySwitchResult(FAILURE) – ha az ok RESUME_CANCELLED.reportIdentitySwitchResult(FAILURE) when the reason is RESUME_CANCELLED.

  • reportIdentitySwitchResult(SUCCESS) – minden más esetben.reportIdentitySwitchResult(SUCCESS) in all other cases.

    Nem valószínű, hogy az alkalmazások többségének másképpen kell blokkolnia vagy késleltetnie az identitásváltást, de ha mégis erre van szükség, akkor a következő szempontokat kell figyelembe venni:It is not expected that most apps will need to block or delay an identity switch in a different manner, but if an app needs to do so, the following points must be considered:

    • Az identitásváltás blokkolásakor az eredmény ugyanaz lesz, mint amikor a Receive megosztási beállítások tiltják le az adatok beérkezését.If an identity switch is blocked, the result is the same as if Receive sharing settings had prohibited the data ingress.

    • Ha egy szolgáltatás a főszálon fut, a reportIdentitySwitchResult hívását kötelező szinkron módon végrehajtani, ellenkező esetben a felhasználói felület szála leáll.If a Service is running on the main thread, reportIdentitySwitchResult must be called synchronously or the UI thread will hang.

    • Tevékenység létrehozásakor az onMAMIdentitySwitchRequired hívása megelőzi az onMAMCreate hívását.For Activity creation, onMAMIdentitySwitchRequired will be called before onMAMCreate. Ha az alkalmazásnak felhasználói felületet kell megjelenítenie annak megállapításához, hogy engedélyezhető-e az identitásváltás, akkor az adott felhasználói felületet egy másik tevékenységgel kell megjeleníteni.If the app must show UI to determine whether to allow the identity switch, that UI must be shown using a different activity.

    • Amikor egy tevékenységben az üres identitásra való váltás oka RESUME_CANCELLED, akkor az alkalmazásnak módosítania kell a folytatott tevékenységet, hogy az adatmegjelenítés az adott identitásváltásnak megfelelő legyen.In an Activity, when a switch to the empty identity is requested with the reason as RESUME_CANCELLED, the app must modify the resumed activity to display data consistent with that identity switch. Ha ez nem lehetséges, az alkalmazásnak el kell utasítania a váltást, és újból kérnie kell a felhasználót a folytatáshoz használt identitás szabályzatának teljesítésére (például a PIN-kód megadását kérő képernyőt megjelenítve).If this is not possible, the app should refuse the switch, and the user will be asked again to comply with policy for the resuming identity (e.g. by being presented with the app PIN entry screen).

      Megjegyzés

      A többszörös identitást támogató alkalmazások mindig fogadják a felügyelt és a nem felügyelt alkalmazásoktól érkező adatokat.A multi-identity app will always receive incoming data from both managed and unmanaged apps. Az alkalmazás feladata, hogy felügyelt módon kezelje a felügyelt identitásokból érkező adatokat.It is the responsibility of the app to treat data from managed identities in a managed manner.

    Ha a kért identitás felügyelt (ezt a MAMPolicyManager.getIsIdentityManaged metódussal lehet ellenőrizni), de az alkalmazás nem tudja használni a fiókot (például mert a fiókokat, így az e-mail-fiókokat először be kell állítani az alkalmazásban), akkor el kell utasítania az identitásváltást.If a requested identity is managed (use MAMPolicyManager.getIsIdentityManaged to check), but the app is not able to use that account (e.g. because accounts, such as email accounts, must be set up in the app first) then the identity switch should be refused.

FájlvédelemFile Protection

Amikor létrehozza a fájlokat, a rendszer identitást társít hozzájuk a szál és a folyamat identitása alapján.Every file has an identity associated with it at the time of creation, based on thread and process identity. Ez az identitás lesz használva a fájltitkosításhoz és a szelektív törléshez is.This identity will be used for both file encryption and selective wipe. Csak azok a fájlok lesznek titkosítva, amelyek identitása felügyelt, és szabályzata előírja a titkosítást.Only files whose identity is managed and has policy requiring encryption will be encrypted. Az SDK alapértelmezett szelektív törlése csak azokat a felügyelt identitáshoz tartozó fájlokat fogja törölni, amelyekre törlést kértek.The SDK's default selective functionality wipe will only wipe files associated with the managed identity for which a wipe has been requested. Az alkalmazás a MAMFileProtectionManager osztállyal kérdezheti le vagy módosíthatja a fájlok identitását.The app may query or change a file’s identity using the MAMFileProtectionManager class.

  public final class MAMFileProtectionManager {
  /**
       * Protect a file. This will synchronously trigger whatever protection is required for the 
         file, and will tag the file for future protection changes.

       *
       * @param identity
       *            Identity to set.
       * @param file
       *            File to protect.
       * @throws IOException
       *             If the file cannot be changed.
       */
      public static void protect(final File file, final String identity) throws IOException;

      /**
      * Protect a file obtained from a content provider. This is intended to be used for
      * sdcard (whether internal or removable) files accessed through the Storage Access Framework.
      * It may also be used with descriptors referring to private files owned by this app.
      * It is not intended to be used for files owned by other apps and such usage will fail. If
      * creating a new file via a content provider exposed by another MAM-integrated app, the new
      * file identity will automatically be set correctly if the ContentResolver in use was
      * obtained via a Context with an identity or if the thread identity is set.
      *
      * This will synchronously trigger whatever protection is required for the file, and will tag
      * the file for future protection changes. If an identity is set on a directory, it is set
      * recursively on all files and subdirectories. If MAM is operating in offline mode, this
      * method will silently do nothing.
      *
      * @param identity
      *       Identity to set.
      * @param file
      *       File to protect.
      *
      * @throws IOException
      *       If the file cannot be protected.

      */
      public static void protect(final ParcelFileDescriptor file, final String identity) throws IOException;

      /**
       * Get the protection info on a file.
       *
       * @param file
       *            File or directory to get information on.
       * @return File protection info, or null if there is no protection info.
       * @throws IOException
       *             If the file cannot be read or opened.
       */
      public static MAMFileProtectionInfo getProtectionInfo(final ParcelFileDescriptor file) throws IOException;

  }

  public interface MAMFileProtectionInfo {
      String getIdentity();
  }

Alkalmazás feladatköreApp Responsibility

A MAM nem következtethet automatikusan kapcsolatra a beolvasott fájlok és egy Activity által megjelenített adatok között.MAM cannot automatically infer a relationship between files being read and data being displayed in an Activity. Az alkalmazásoknak a vállalati adatok megjelenítése előtt be kell állítaniuk a megfelelő felhasználóifelület-identitást.Apps must set the UI identity appropriately before displaying corporate data. Ez érvényes a fájlokból beolvasott adatokra is.This includes data read from files. Az alkalmazáson kívüli forrásból (ami lehet egy ContentProvider vagy egy nyilvánosan írható hely) származó fájlok esetén az alkalmazásnak meg kell kísérelnie a fájl identitásának megállapítását (a MAMFileProtectionManager.getProtectionInfo használatával), mielőtt megjelenítené a fájlból beolvasott információt.If a file comes from outside the app (either from a ContentProvider or read from a publicly writable location), the app must attempt to determine the file identity (using MAMFileProtectionManager.getProtectionInfo) before displaying information read from the file. Ha a getProtectionInfo nem null, nem üres identitást jelez, a felhasználói felület identitását azzal egyezőre kell beállítani (a MAMActivity.switchMAMIdentity vagy a MAMPolicyManager.setUIPolicyIdentity használatával).If getProtectionInfo reports a non-null, non-empty identity, the UI identity must be set to match this identity (using MAMActivity.switchMAMIdentity or MAMPolicyManager.setUIPolicyIdentity). Ha az identitásváltás nem sikerül, a fájl adatait nem szabad megjeleníteni.If the identity switch fails, data from the file must not be displayed.

A folyamat lehet például a következőhöz hasonló:An example flow might look something like the following:

  • A felhasználó kiválaszt egy, az alkalmazásban megnyitandó dokumentumot.User selects a document to open in the app
  • A megnyitási folyamat során az adatok a lemezről való beolvasása előtt az alkalmazás ellenőrzi a tartalom megjelenítésére használandó identitást.During the open flow, prior to reading data from disk, the app confirms the identity that should be used to display the content
    • MAMFileProtectionInfo info = MAMFileProtectionManager.getProtectionInfo(docPath)MAMFileProtectionInfo info = MAMFileProtectionManager.getProtectionInfo(docPath)
    • if(info) MAMPolicyManager.setUIPolicyIdentity(activity, info.getIdentity(), callback)if(info) MAMPolicyManager.setUIPolicyIdentity(activity, info.getIdentity(), callback)
    • Az alkalmazás megvárja, amíg a visszahívás egy eredményt jelez.The app waits until a result is reported to callback
    • Ha a jelentett eredmény hiba, az alkalmazás nem jeleníti meg a dokumentumot.If the reported result is a failure, the app does not display the document.
  • Az alkalmazás megnyílik, és az egész fájlt megjeleníti.The app opens and renders the file

Kapcsolat nélküli forgatókönyvekOffline Scenarios

A fájl identitásának címkézésénél az offline mód különbségnek számít.File identity tagging is sensitive to offline mode. A következő szempontokat kell figyelembe venni:The following points should be taken into account:

  • Ha a Céges portál nincs telepítve, akkor a fájlok nem láthatók el identitáscímkével.If the Company Portal is not installed, files cannot be identity-tagged.

  • Ha a Céges portál telepítve van, de az alkalmazásra nem vonatkozik Intune MAM-szabályzat, akkor a fájlokat nem lehet megbízhatóan ellátni identitáscímkével.If the Company Portal is installed, but the app does not have Intune MAM policy, files cannot be reliably tagged with identity.

  • Amikor elérhetővé válik a fájlok identitáscímkézése, akkor az összes korábban létrehozott fájl személyesként/nem felügyeltként (az üres karakterláncú identitáshoz tartozó fájlként) lesz kezelve, kivéve, ha az alkalmazás korábban egyidentitásos felügyelt alkalmazásként lett telepítve: ebben az esetben a fájlok a beléptetett felhasználóhoz tartozó fájlokként lesznek kezelve.When file identity tagging becomes available, all previously created files are treated as personal/unmanaged (belonging to the empty-string identity) unless the app was previously installed as a single-identity managed app in which case they are treated as belonging to the enrolled user.

KönyvtárvédelemDirectory Protection

A könyvtárakat is a fájlok védelmére szolgáló protect metódussal lehet védeni.Directories may be protected using the same protect method used to protect files. Ne feledje, hogy a könyvtárvédelem rekurzívan érvényes a könyvtárban lévő összes fájlra és alkönyvtárra, illetve a benne létrehozott új fájlokra.Please note that directory protection applies recursively to all files and subdirectories contained in the directory, and to new files created within the directory. Emiatt az igen nagy méretű könyvtárak esetében a protect hívás hosszabb ideig tarthat.Because directory protection is applied recursively, the protect call can take some time to complete for very large directories. Éppen ezért a sok fájlt tartalmazó könyvtárakra védelmet alkalmazó alkalmazásoknak érdemes a protect hívást aszinkron módon, háttérszálon futtatni.For that reason, apps applying protection to a directory that contains a large number of files might wish to run protect asynchronously on a background thread.

AdatvédelemData Protection

A fájlok nem címkézhetők meg több identitáshoz tartozó fájlként.It is not possible to tag a file as belonging to multiple identities. Azok az alkalmazások, amelyeknek egy fájlban kell tárolniuk különböző felhasználók adatait, manuálisan tehetik meg ezt a MAMDataProtectionManager által biztosított szolgáltatásokkal.Apps that must store data belonging to different users in the same file can do so manually, using the features provided by MAMDataProtectionManager. Ez lehetővé teszi az alkalmazás számára az adatok titkosítását és hozzákötését egy adott felhasználóhoz.This allows the app to encrypt data and tie it to a particular user. A titkosított adatok lemezen, fájlban tárolhatók.The encrypted data is suitable for storing to disk in a file. Az identitáshoz tartozó adatokat lekérdezheti, és az adatokat visszafejtheti.You can query the data associated with the identity and the data can be unecrypted later.

A MAMDataProtectionManager osztályt hasznosító alkalmazásoknak fogadót kell implementálniuk a MANAGEMENT_REMOVED értesítéshez.Apps which make use of MAMDataProtectionManager should implement a receiver for the MANAGEMENT_REMOVED notification. Az értesítés lefutása után az ezen osztállyal védett pufferek nem lesznek olvashatóak, ha a fájltitkosítást a pufferek védett állapotában kapcsolták be.After this notification completes, buffers which were protected via this class will no longer be readable if file encryption was enabled when the buffers were protected. Az alkalmazás úgy tudja megoldani ezt a problémát, ha az értesítés időtartama alatt az összes pufferen meghívja a MAMDataProtectionManager.unprotect metódust.An app can remediate this situation by calling MAMDataProtectionManager.unprotect on all buffers during this notification. Ne feledje, hogy az értesítés időtartama alatt a protect metódust is biztonságosan meg lehet hívni, ha az identitásadatokat meg szeretnék őrizni – a titkosítás ez idő alatt garantáltan le van tiltva.Note that it is also safe to call protect during this notification if it is desired to preserve identity information -- encryption is guaranteed to be disabled during the notification.


public final class MAMDataProtectionManager {
    /**
     * Protect a stream. This will return a stream containing the protected
     * input.
     *
     * @param identity
     *            Identity to set.
     * @param input
     *            Input data to protect, read sequentially. This function
     *            will change the position of the stream but may not have
     *            read the entire stream by the time it returns. The
     *            returned stream will wrap this one. Calls to read on the
     *            returned stream may cause further reads on the original
     *            input stream. Callers should not expect to read directly
     *            from the input stream after passing it to this method.
     *            Calling close on the returned stream will close this one.
     * @return Protected input data.
     * @throws IOException
     *             If the data could not be protected
     */
    public static InputStream protect(final InputStream input, final String identity);

    /**
     * Protect a byte array. This will return protected bytes.
     *
     * @param identity
     *            Identity to set.
     * @param input
     *            Input data to protect.
     * @return Protected input data.
     * @throws IOException
     *             If the data could not be protected
     */
    public static byte[] protect(final byte[] input, final String identity) throws IOException;

    /**
     * Unprotect a stream. This will return a stream containing the
     * unprotected input.
     *
     * @param input
     *            Input data to protect, read sequentially.
     * @return Protected input data.
     * @throws IOException
     *             If the data could not be unprotected
     */
    public static InputStream unprotect(final InputStream input) throws IOException;

    /**
     * Unprotect a byte array. This will return unprotected bytes.
     *
     * @param input
     *            Input data to protect.
     * @return Protected input data.
     * @throws IOException
     *             If the data could not be unprotected
     */
    public static byte[] unprotect(final byte[] input) throws IOException;

    /**
     * Get the protection info on a stream.
     *
     * @param input
     *            Input stream to get information on. Either this input
     *            stream must have been returned by a previous call to
     *            protect OR input.markSupported() must return true.
     *            Otherwise it will be impossible to get protection info
     *            without advancing the stream position. The stream must be
     *            positioned at the beginning of the protected data.
     * @return Data protection info, or null if there is no protection
     *            info.
     * @throws IOException
     *             If the input cannot be read.
     */
    public static MAMDataProtectionInfo getProtectionInfo(final InputStream input) throws IOException;

    /**
     * Get the protection info on a stream.
     *
     * @param input
     *            Input bytes to get information on. These must be bytes
     *            returned by a previous call to protect() or a copy of
     *            such bytes.
     * @return Data protection info, or null if there is no protection
     *            info.
     * @throws IOException
     *             If the input cannot be read.
     */
    public static MAMDataProtectionInfo getProtectionInfo(final byte[] input) throws IOException;
}

TartalomszolgáltatókContent Providers

Ha az alkalmazás a ParcelFileDescriptor elemtől különböző vállalati adatokat szolgáltat egy ContentProvider objektumon keresztül, akkor az alkalmazásnak a MAMContentProvider osztály isProvideContentAllowed(String) metódusát meghívva kell átadnia a tartalomtulajdonos identitás UPN-jét (egyszerű felhasználónevét).If the app provides corporate data other than a ParcelFileDescriptor through a ContentProvider, the app must call the method isProvideContentAllowed(String) in MAMContentProvider, passing the owner identity's UPN (user principal name) for the content. Ha ez a függvény hamis értéket ad vissza, akkor a tartalom nem adható vissza a hívónak.If this function returns false, the content may not be returned to the caller. A tartalomszolgáltatón keresztül visszaadott fájlleírók kezelése automatikusan a fájl identitása alapján történik.File descriptors returned through a content provider are handled automatically based on the file identity.

Szelektív törlésSelective Wipe

Ha egy alkalmazás regisztrál a WIPE_USER_DATA értesítésre, akkor nem veheti igénybe az SDK alapértelmezett szelektív törlési funkcióját.If an app registers for the WIPE_USER_DATA notification, it will not receive the benefit of the SDK's default selective wipe behavior. A többidentitásos alkalmazások esetében ez nagyobb jelentőségű tényező lehet, mivel a MAM alapértelmezett szelektív törlése csak a törlendő identitáshoz tartozó fájlokat fogja törölni.For multi-identity aware apps, this loss may be more significant since MAM default selective wipe will wipe only files whose identity is targeted by a wipe.

Ha a többidentitásos alkalmazás szeretné végrehajtatni a MAM alapértelmezett szelektív törlését, és ezenfelül saját törlési műveleteit is végre szeretné hajtani, akkor célszerű feliratkoznia a WIPE_USER_AUXILIARY_DATA értesítésekre.If a multi-identity aware application wishes MAM default selective wipe to be done and wishes to perform its own actions on wipe, it should register for WIPE_USER_AUXILIARY_DATA notifications. Ezt az értesítést az SDK közvetlenül azelőtt küldi el, hogy végrehajtaná a MAM alapértelmezett szelektív törlési műveletét.This notification will be sent immediately by the SDK before it performs the MAM default selective wipe. Egyazon alkamazásnak nem szabad mind a WIPE_USER_DATA, mind a WIPE_USER_AUXILIARY_DATA értesítésre feliratkoznia.An app should never register for both WIPE_USER_DATA and WIPE_USER_AUXILIARY_DATA.

Célzott MAM-konfiguráció engedélyezése Android-alkalmazásokhoz (nem kötelező)Enabling MAM targeted configuration for your Android applications (optional)

Az alkalmazásspecifikus kulcs-érték párok az Intune-konzolon konfigurálhatók.Application-specific key-value pairs may be configured in the Intune console. A kulcs-érték párokat az Intune nem értelmezi, hanem egyszerűen továbbadja az alkalmazásnak.These key-value pairs are not interpreted by Intune at all, but are simply passed on to the app. Azon alkalmazások, amelyek ilyen konfigurációt kívánnak kapni, a MAMAppConfigManager és MAMAppConfig osztályokat használhatják ehhez.Applications which want to receive such configuration can use the MAMAppConfigManager and MAMAppConfig classes to do so. Ha több szabályzat ugyanazon alkalmazást célozza, valószínűleg több ütköző érték érhető el ugyanazon kulcshoz.If multiple policies are targeted at the same app, there may be multiple conflicting values available for the same key.

PéldaExample

MAMAppConfigManager configManager = MAMComponents.get(MAMAppConfigManager.class);
String identity = "user@contoso.com"
MAMAppConfig appConfig = configManager.getAppConfig(identity);
LOGGER.info("App Config Data = " + (appConfig == null ? "null" : appConfig.getFullData()));
String valueToUse = null;
if (appConfig.hasConflict("foo")) {
    List<String> values = appConfig.getAllStringsForKey("foo");
    for (String value : values) {
        if (isCorrectValue(value)) {
            valueToUse = value;
        }
    }
} else {
    valueToUse = appConfig.getStringForKey("foo", MAMAppConfig.StringQueryType.Any);
}
LOGGER.info("Found value " + valueToUse);

MAMAppConfig hivatkozásMAMAppConfig Reference

public interface MAMAppConfig {
    /**
     * Conflict resolution types for Boolean values.
     */
    enum BooleanQueryType {
        /**
         * In case of conflict, arbitrarily picks one. This is not guaranteed to return the same value every time.
         */
        Any,
        /**
         * In case of conflict, returns true if any of the values are true.
         */
        Or,
        /**
         * In case of conflict, returns false if any of the values are false.
         */
        And
    }

    /**
     * Conflict resolution types for integer and double values.
     */
    enum NumberQueryType {
        /**
         * In case of conflict, arbitrarily picks one. This is not guaranteed to return the same value every time.
         */
        Any,
        /**
         * In case of conflict, returns the minimum Integer.
         */
        Min,
        /**
         * In case of conflict, returns the maximum Integer.
         */
        Max
    }

    /**
     * Conflict resolution types for Strings.
     */
    enum StringQueryType {
        /**
         * In case of conflict, arbitrarily picks one. This is not guaranteed to return the same value every time.
         */
        Any,
        /**
         * In case of conflict, returns the first result ordered alphabetically.
         */
        Min,
        /**
         * In case of conflict, returns the last result ordered alphabetically.
         */
        Max
    }

    /**
     * Retrieve the List of Dictionaries containing all the custom
     *  config data sent by the MAMService. This will return every
     * Application Configuration setting available for this user, one
     *  mapping for each policy applied to the user.
     */
    List<Map<String, String>> getFullData();

    /**
     * Returns true if there is more than one targeted custom config setting for the key provided. 
     */
    boolean hasConflict(String key);

    /**
     * @return a Boolean value for the given key if it can be coerced into a Boolean, or 
     * null if none exists or it cannot be coerced.
     */
    Boolean getBooleanForKey(String key, BooleanQueryType queryType);

    /**
     * @return a Long value for the given key if it can be coerced into a Long, or null if none exists or it cannot be coerced.
     */
    Long getIntegerForKey(String key, NumberQueryType queryType);

    /**
     * @return a Double value for the given key if it can be coerced into a Double, or null if none exists or it cannot be coerced.
     */
    Double getDoubleForKey(String key, NumberQueryType queryType);

    /**
     * @return a String value for the given key, or null if none exists.
     */
    String getStringForKey(String key, StringQueryType queryType);

    /**
     * Like getBooleanForKey except returns all values if multiple are present.
     */
    List<Boolean> getAllBooleansForKey(String key);

    /**
     * Like getIntegerForKey except returns all values if multiple are present.
     */
    List<Long> getAllIntegersForKey(String key);

    /**
     * Like getDoubleForKey except returns all values if multiple are present.
     */
    List<Double> getAllDoublesForKey(String key);

    /**
     * Like getStringForKey except returns all values if multiple are present.
     */
    List<String> getAllStringsForKey(String key);
}

ÉrtesítésNotification

Az alkalmazás konfigurációja egy új értesítéstípust ad hozzá:App config adds a new notification type:

  • REFRESH_APP_CONFIG: ezt az értesítést egy MAMUserNotification tartalmazza, és tájékoztatja az alkalmazást, hogy új alkalmazáskonfigurációs adatok érhetők el.REFRESH_APP_CONFIG: This notification is sent in a MAMUserNotification and informs the app that new app config data is available.

A Graph API célzott MAM-konfigurációs értékekre vonatkozó képességeivel kapcsolatos további információért lásd a Graph API-referencia – célzott MAM-konfiguráció témájú weblapot.For more information about the capabilities of the Graph API with respect to the MAM targeted configuration values, see Graph API Reference MAM Targeted Config.

A célzott MAM-alkalmazáskonfigurációs szabályzat Android rendszerben való létrehozásáról lásd A Microsoft Intune alkalmazáskonfigurációs szabályzatainak használata Android rendszerben célzott MAM-alkalmazáskonfigurációról szóló szakaszát.For more information about how to create a MAM targeted app configuration policy in Android, see the section on MAM targeted app config in How to use Microsoft Intune app configuration policies for Android.

Stílus testreszabása (nem kötelező)Style Customization (optional)

A MAM SDK-ban létrehozott nézetek megjelenését testre lehet szabni, hogy jobban illeszkedjenek az SDK-t integráló alkalmazáshoz.Views generated by the MAM SDK can be visually customized to more closely match the app in which it is integrated. Meg lehet szabni az elsődleges, a másodlagos és a háttérszínt, valamint az alkalmazás emblémájának méretét.You can customize primary, secondary, and background colors, as well as the size of the app logo. Ez a testreszabás nem kötelező. Ha nincs konfigurálva egyéni stílus, a rendszer az alapértelmezéseket használja.This style customization is optional and defaults will be used if no custom style is configured.

A testreszabás meneteHow to customize

Ha módosítani szeretné az Intune MAM-nézeteinek stílusát, először készítsen stílus-felülíró XML-fájlt.In order to have style changes apply to the Intune MAM views, you must first create a style override XML file. Ezt helyezze el az alkalmazás „/res/xml” könyvtárában, és adjon neki tetszőleges nevet.This file should be placed in the “/res/xml” directory of your app and you may name it whatever you like. Az alábbi példa bemutatja a fájl szükséges formátumát.Below is an example of the format this file needs to follow.

<?xml version="1.0" encoding="utf-8"?>
<styleOverrides>
    <item
        name="foreground_color"
        resource="@color/red"/>
    <item
        name="accent_color"
        resource="@color/blue"/>
    <item
        name="background_color"
        resource="@color/green"/>
    <item
        name="logo_image"
        resource="@drawable/app_logo"/>
</styleOverrides>

Az alkalmazásban már meglévő erőforrásokat kell újrahasználnia,You must reuse resources that already exist within your app. tehát például a zöld színt a colors.xml fájlban kell definiálni, és itt hivatkozni,For example, you must define the color green in the colors.xml file and reference it here. de a „#0000ff” hexa színkódot itt nem használhatja.You cannot use the Hex color code “#0000ff." Az alkalmazásembléma legfeljebb 110 dip (dp) méretű lehet.The maximum size for the app logo is 110 dip (dp). Kisebb emblémát is megadhat, de az optimális megjelenés érdekében érdemes kihasználni a maximális méretet.You may use a smaller logo image, but adhering to the maximum size will yield the best looking results. Ha túllépi a 110 dipes határt, a képet a rendszer lekicsinyíti, amitől valószínűleg homályos lesz.If you exceed the 110 dip limit, the image will scale down and possibly cause blurring.

Alább felsoroljuk az összes megengedett stílusattribútumot, az általuk szabályozott felületi elemeket, XML-attribútumnevüket és a hozzájuk várt erőforrástípusokat.Below is the complete list of allowed style attributes, the UI elements they control, their XML attribute item names, and the type of resource expected for each.

StílusattribútumStyle attribute Érintett felületi elemUI elements affected Attribútumelem neveAttribute item name Várt erőforrástípusExpected resource type
HáttérszínBackground color A PIN-kódot bekérő képernyő háttérszínePIN screen background color
A PIN-kód mezőjének kitöltőszínePIN box fill color
background_colorbackground_color SzínColor
ElőtérszínForeground color Előtérbeli szöveg színeForeground text color
A PIN-kód mezőjének szegélyszíne alapértelmezett állapotbanPIN box border in default state
A PIN-kód mezőjébe beírt (akár rejtjelezett) karakterek színeCharacters (including obfuscated characters) in PIN box when user enters a PIN
foreground_colorforeground_color SzínColor
KiemelőszínAccent color A PIN-kód mezőjének szegélyszíne kiemelt állapotbanPIN box border when highlighted
HivatkozásokHyperlinks
accent_coloraccent_color SzínColor
Alkalmazás emblémájaApp logo Az Intune PIN-kódot bekérő képernyőjén megjelenő nagy ikonLarge icon that appears in the Intune app PIN screen logo_imagelogo_image RajzolhatóDrawable

KorlátozásokLimitations

Fájlméretre vonatkozó korlátozásokFile Size limitations

A ProGuard nélkül futó nagyméretű kódbázis esetén a Dalvik végrehajtható fájlformátum korlátozásai problémát jelenthetnek.For large code bases that run without ProGuard, the limitations of the Dalvik executable file format become an issue. Konkrétan a következő korlátozások fordulhatnak elő:Specifically, the following limitations may occur:

  1. A mezőkre vonatkozó 65 KB-os korlát.The 65K limit on fields.
  2. A metódusokra vonatkozó 65 KB-os korlát.The 65K limit on methods.

Szabályzatbetartatási korlátozásokPolicy enforcement limitations

  • Képernyőfelvétel: Az SDK nem tud új képernyőfelvétel-beállítási értéket kikényszeríteni azon tevékenységeknél, amelyeknél már lefutott az Activity.onCreate.Screen Capture: The SDK is unable to enforce a new screen capture setting value in Activities that have already gone through Activity.onCreate. Ez olyan időszakot eredményezhet, amikor az alkalmazás a képernyőfelvételek letiltására lett konfigurálva, de továbbra is lehet képernyőfelvételt készíteni.This can result in a period of time where the app has been configured to disable screenshots but screenshots can still be taken.

  • Tartalomfeloldók használata: Az „átvitel vagy fogadás” Intune-szabályzat részben vagy teljesen blokkolhatja más alkalmazások tartalomszolgáltatójának tartalomfeloldóval történő elérését.Using Content Resolvers: The "transfer or receive" Intune policy may block or partially block the use of a content resolver to access the content provider in another app. Ennek következtében a ContentResolver metódusok null vagy hibaértéket fognak visszaadni (például az openOutputStream a FileNotFoundException kivételhibát fogja okozni, ha blokkolva van).This will cause ContentResolver methods to return null or throw a failure value (e.g. openOutputStream will throw FileNotFoundException if blocked). Az alkalmazás a következő hívással állapíthatja meg, hogy a tartalomfeloldón keresztüli adatírás sikertelenségét házirend okozta (vagy hogy egy házirend ilyen hibát okozna):The app can determine whether a failure to write data through a content resolver was caused by policy (or would be caused by policy) by making the call:

    MAMPolicyManager.getPolicy(currentActivity).getIsSaveToLocationAllowed(contentURI);
    

    vagy ha nincs hozzárendelt tevékenységor if there is no associated activity

    MAMPolicyManager.getPolicy().getIsSaveToLocationAllowed(contentURI);
    

    A második esetben a több identitást használó alkalmazásoknak ügyelniük kell a szálidentitás megfelelő beállítására (vagy explicit identitásértéket kell átadniuk a getPolicy metódushívásban).In this second case, multi-identity apps must take care to set the thread identity appropriately (or pass an explicit identity to the getPolicy call).

Exportált szolgáltatásokExported services

Az Intune App SDK-ban szereplő AndroidManifest.xml fájlban szerepel a MAMNotificationReceiverService szolgáltatás, amelynek exportált szolgáltatásnak kell lennie ahhoz, hogy a Céges portál értesítéseket küldhessen a kompatibilis alkalmazásoknak.The AndroidManifest.xml file included in the Intune App SDK contains MAMNotificationReceiverService, which must be an exported service to allow the Company Portal to send notifications to an enlightened app. A szolgáltatás ellenőrzi a hívót annak ellenőrzéséhez, hogy csak a vállalati portál számára engedélyezett-e az értesítések küldése.The service checks the caller to ensure that only the Company Portal is allowed to send notifications.

Az SDK-használók elvárásaiExpectations of the SDK consumer

Az Intune SDK fenntartja az Android API által biztosított szerződést, bár a szabályzatok betartatása miatt gyakrabban léphetnek fel hibaállapotok.The Intune SDK maintains the contract provided by the Android API, though failure conditions may be triggered more frequently as a result of policy enforcement. Az alábbi androidos gyakorlati tanácsok csökkentik a hibák valószínűségét:These Android best practices will reduce the likelihood of failure:

  • Azon androidos SDK-függvények, amelyek null értékkel is visszatérhetnek, nagyobb valószínűséggel lesznek null értékűek.Android SDK functions that may return null have a higher likelihood of being null now. A problémák minimalizálása érdekében biztosítsa, hogy a megfelelő helyeken legyenek null-ellenőrzések.To minimize issues, ensure that null checks are in the right places.

  • A lekérdezhető funkciókat a MAM-os helyettesítő API-kkal kell lekérdezni.Features that can be checked for must be checked for through their MAM replacement APIs.

  • Minden származtatott függvénynek meg kell hívnia a szülőosztálybeli verzióját.Any derived functions must call through to their super class versions.

  • Kerülje az API-k nem egyértelmű módon való használatát.Avoid use of any API in an ambiguous way. Így például az Activity.startActivityForResult requestCode ellenőrzése nélküli használata működésbeli furcsaságokat idézhet elő.For example, using Activity.startActivityForResult without checking the requestCode will cause strange behavior.

TelemetriaTelemetry

Az Androidhoz készült Intune App SDK nem szabályozza az alkalmazásából való adatgyűjtést.The Intune App SDK for Android does not control data collection from your app. Az Céges portál alkalmazás alapértelmezés szerint telemetriai adatokat naplóz.The Company Portal application logs telemetry data by default. Az adatokat az SDK a Microsoft Intune-nak küldi el.This data is sent to Microsoft Intune. A Microsoft szabályzatának megfelelően nem gyűjtünk személyazonosításra alkalmas adatokat (PII).As per Microsoft Policy, we do not collect any personally identifiable information (PII).

Megjegyzés

Ha a végfelhasználók nem szeretnének ilyen adatokat küldeni, ki kell kapcsolniuk a telemetriát a Céges portál alkalmazás Beállítások menüpontjában.If end users choose not to send this data, they must turn off telemetry under Settings on the Company Portal app. További információt A használatra vonatkozó adatok Microsoft általi gyűjtésének kikapcsolása című témakörben találhat.To learn more, see Turn off Microsoft usage data collection.

  • Lehetőség szerint minden kódtárprojektnek azonos android:package csomagot kell használnia.All library projects should share the same android:package where possible. Ez nem fog szórványos hibákat jelenteni futásidőben, mivel ez a probléma pusztán a buildelés során áll fenn.This will not sporadically fail in run-time; this is purely a build-time problem. Az Intune App SDK újabb verziói ki fognak küszöbölni bizonyos párhuzamosságokat.Newer versions of the Intune App SDK will remove some of the redundancy.

  • Mindig az elérhető legújabb Android SDK buildelőeszközeit használja.Use the newest Android SDK build tools.

  • Távolítsa el a felesleges és használaton kívüli kódtárakat (pl. android.support.v4)Remove all unnecessary and unused libraries (e.g. android.support.v4)