Device Trust from Android Enterprise - इंटिग्रेशन गाइड

अहम जानकारी: बिना अनुमति के इस्तेमाल को रोकने के लिए, AMAPI SDK में डिवाइस के भरोसे के सिग्नल का ऐक्सेस सीमित किया गया है. ज़्यादा जानकारी के लिए, यह लेख पढ़ें: Device Trust from Android Enterprise - सिग्नल का ऐक्सेस.

डिवाइस के भरोसे के सिग्नल पाने के लिए, AMAPI SDK का इस्तेमाल करने के लिए, यह दस्तावेज़ आपकी मुख्य गाइड होनी चाहिए.

AMAPI SDK टूल, आपके ऐप्लिकेशन (जिसे कभी-कभी "साथी" ऐप्लिकेशन भी कहा जाता है) को ADP (Android डिवाइस नीति) ऐप्लिकेशन से डिवाइस के भरोसे के सिग्नल ऐक्सेस करने की सुविधा देता है. इसके बाद, आपका ऐप्लिकेशन इन सिग्नल का इस्तेमाल करके, डिवाइस के भरोसे की स्थिति का हिसाब लगा सकता है और चुने गए बिज़नेस लॉजिक को लागू कर सकता है.

ज़रूरी शर्तें

• डिवाइस के भरोसेमंद सिग्नल का ऐक्सेस सीमित है, ताकि बिना अनुमति के उनका इस्तेमाल न किया जा सके. आवेदन करने के तरीके के बारे में जानने के लिए, डिवाइस के भरोसे के सिग्नल का ऐक्सेस पेज पर जाएं.
• Android Enterprise का सुझाव है कि आप अपने क्लाइंट ऐप्लिकेशन में, Play Integrity API के सुइट को इंटिग्रेट करें. साथ ही, डिवाइस के भरोसे के सिग्नल को पढ़ने और उन पर भरोसा करने से पहले, नतीजे देखें. Play Integrity API की जांच में फ़ेल होने वाले डिवाइसों पर भरोसा नहीं किया जाना चाहिए. साथ ही, डिवाइस से मिले ऐसे किसी भी सिग्नल पर भरोसा नहीं किया जाना चाहिए जिसका इस्तेमाल, डिवाइस की सुरक्षा की स्थिति तय करने के लिए किया गया हो. ज़्यादा जानकारी के लिए, Play Integrity का दस्तावेज़ देखें.

ध्यान दें: Device Trust from Android Enterprise का इस्तेमाल करने के लिए, Android 10 या इसके बाद का वर्शन ज़रूरी है.

अपने ऐप्लिकेशन में AMAPI SDK टूल के साथ इंटिग्रेट करना

डिवाइस के भरोसे के सिग्नल ऐक्सेस करने के लिए, आपके ऐप्लिकेशन को AMAPI SDK टूल के साथ इंटिग्रेट करना होगा. इस लाइब्रेरी के बारे में ज़्यादा जानकारी और इसे अपने ऐप्लिकेशन में जोड़ने का तरीका जानने के लिए, AMAPI SDK टूल इंटिग्रेशन गाइड देखें.

ध्यान दें: इस प्रोसेस के लिए, AMAPI SDK लाइब्रेरी का 1.3.0 या इसके बाद का वर्शन ज़रूरी है. AMAPI SDK लाइब्रेरी के रिलीज़ नोट में, उपलब्ध सबसे नई रिलीज़ देखी जा सकती है.
हमारा सुझाव है कि हमेशा लाइब्रेरी के सबसे नए वर्शन का इस्तेमाल करें, ताकि बग ठीक करने और लाइब्रेरी को बेहतर बनाने के लिए उपलब्ध सुविधाओं का फ़ायदा लिया जा सके.

ज़रूरी अनुमतियां जोड़ना

Android Enterprise API के डिवाइस ट्रस्ट से मिले कुछ सिग्नल के लिए, ऐप्लिकेशन को वही अनुमति देनी होगी जो इस जानकारी को ऐक्सेस करने के लिए ज़रूरी है. खास तौर पर:

सिग्नल	ज़रूरी अनुमति
नेटवर्क की स्थिति	ACCESS_NETWORK_STATE
स्क्रीन लॉक कितना मुश्किल है	REQUEST_PASSWORD_COMPLEXITY

अगर ये अनुमतियां ऐप्लिकेशन के AndroidManifest.xml में शामिल नहीं हैं, तो Android Enterprise API से डिवाइस ट्रस्ट, इससे जुड़े सिग्नल के मेटाडेटा में PERMISSION_ISSUE दिखाएगा:

internalDeviceSettings=DeviceSettings{
  screenLockComplexity=COMPLEXITY_UNSPECIFIED,
  internalScreenLockComplexityMetadata=Metadata{
    dataIssues=[
      DataIssue{
        issueType=PERMISSION_ISSUE,
        issueLevel=WARNING,
        issueDetails=IssueDetailsCase{none}
      }
    ]
  },

ज़्यादा जानकारी के लिए, डिवाइस के लिए उपलब्ध भरोसे के सिग्नल की सूची देखें.

डिवाइस के भरोसे के सिग्नल ऐक्सेस करने का तरीका

जिन ऐप्लिकेशन को डिवाइस के भरोसे के सिग्नल ऐक्सेस करने हैं उन्हें यह पुष्टि करनी होगी कि क्लाइंट एनवायरमेंट अप-टू-डेट है. साथ ही, ज़रूरत पड़ने पर उसे अपडेट करना होगा.

डिवाइस ट्रस्ट सिग्नल ऐक्सेस करने का तरीका:

• क्लाइंट एनवायरमेंट की पुष्टि करना
• क्लाइंट एनवायरमेंट तैयार करना
• डिवाइस के ट्रस्ट सिग्नल ऐक्सेस करना

क्लाइंट एनवायरमेंट की पुष्टि करना

ध्यान दें: एपीआई के सही तरीके से काम करने के लिए, डिवाइस पर GMSCore और ADP ऐप्लिकेशन का अप-टू-डेट वर्शन होना ज़रूरी है. डिवाइस की मौजूदा स्थिति देखने के लिए, EnvironmentClient के getEnvironment तरीके का इस्तेमाल करें. इससे यह पता चलेगा कि अनुरोध किए गए Role के लिए, ADP ऐप्लिकेशन इंस्टॉल है या नहीं और वह अप-टू-डेट है या नहीं.

नीचे दिए गए कोड के उदाहरण में, ADP ऐप्लिकेशन की मौजूदा स्थिति को पढ़ने के लिए, getEnvironment का इस्तेमाल करने का तरीका बताया गया है. इसके बाद, अगर एनवायरमेंट तैयार और अप-टू-डेट है, तो आपका ऐप्लिकेशन डिवाइस के भरोसे के सिग्नल ऐक्सेस करने के लिए, deviceClient बना सकता है (डिवाइस के भरोसे के सिग्नल ऐक्सेस करना देखें).

अहम जानकारी: Role सेट किए बिना getEnvironment या prepareEnvironment को कॉल करने पर, InvalidArgumentException दिखेगा.

Kotlin

import com.google.android.managementapi.common.model.Role
import com.google.android.managementapi.device.DeviceClient
import com.google.android.managementapi.device.DeviceClientFactory
import com.google.android.managementapi.device.model.GetDeviceRequest
import com.google.android.managementapi.environment.EnvironmentClient
import com.google.android.managementapi.environment.EnvironmentClientFactory
import com.google.android.managementapi.environment.model.Environment.AndroidDevicePolicyEnvironment.State.INSTALLED
import com.google.android.managementapi.environment.model.Environment.AndroidDevicePolicyEnvironment.State.NOT_INSTALLED
import com.google.android.managementapi.environment.model.Environment.AndroidDevicePolicyEnvironment.State.READY
import com.google.android.managementapi.environment.model.Environment.AndroidDevicePolicyEnvironment.Version.UP_TO_DATE
import com.google.android.managementapi.environment.model.GetEnvironmentRequest
import com.google.android.managementapi.environment.model.PrepareEnvironmentRequest

try {
    val context = applicationContext

    val roles = listOf(Role.builder().setRoleType(Role.RoleType.IDENTITY_PROVIDER).build())
    val request = GetEnvironmentRequest.builder().setRoles(roles).build()
    val environmentClient = EnvironmentClientFactory.create(context)
    val environmentResponse = environmentClient.getEnvironment(request)

    if (environmentResponse.hasAndroidDevicePolicyEnvironment()) {
        val adpEnvironment = environmentResponse.androidDevicePolicyEnvironment

        if (adpEnvironment.state == READY && adpEnvironment.version == UP_TO_DATE) {
            // AMAPI Environment State OK, Version OK.  Requesting Device signals..
            checkDevice(deviceClient = DeviceClientFactory.create(context))
        } else if (adpEnvironment.state == INSTALLED) {
            // prepareEnvironment should be called, calling
            // prepareEnvironment won't show the UI
            prepareEnvironment(context, environmentClient)
        } else if (adpEnvironment.state == NOT_INSTALLED) {
            // prepareEnvironment should be called, calling
            // prepareEnvironment will show the UI
            prepareEnvironment(context, environmentClient)
        }
    }
} catch (e: Exception) {
    Log.e(TAG, "Exception", e)
}

Java

import static com.google.android.managementapi.environment.model.Environment.AndroidDevicePolicyEnvironment.State.INSTALLED;
import static com.google.android.managementapi.environment.model.Environment.AndroidDevicePolicyEnvironment.State.NOT_INSTALLED;
import static com.google.android.managementapi.environment.model.Environment.AndroidDevicePolicyEnvironment.State.READY;
import static com.google.android.managementapi.environment.model.Environment.AndroidDevicePolicyEnvironment.Version.UP_TO_DATE;

import com.google.android.managementapi.common.model.Role;
import com.google.android.managementapi.device.DeviceClient;
import com.google.android.managementapi.device.DeviceClientFactory;
import com.google.android.managementapi.device.model.Device;
import com.google.android.managementapi.device.model.GetDeviceRequest;
import com.google.android.managementapi.environment.EnvironmentClient;
import com.google.android.managementapi.environment.EnvironmentClientFactory;
import com.google.android.managementapi.environment.model.Environment;
import com.google.android.managementapi.environment.model.Environment.AndroidDevicePolicyEnvironment;
import com.google.android.managementapi.environment.model.GetEnvironmentRequest;
import com.google.android.managementapi.environment.model.PrepareEnvironmentRequest;
import com.google.android.managementapi.environment.model.PrepareEnvironmentResponse;

try {
    Context context = getApplicationContext();

    ImmutableList roles = new ImmutableList.Builder()
            .add(Role.builder()
                    .setRoleType(Role.RoleType.IDENTITY_PROVIDER)
                    .build())
            .build();

    EnvironmentClient environmentClient = EnvironmentClientFactory.create(context);
    GetEnvironmentRequest request = GetEnvironmentRequest.builder()
            .setRoles(roles)
            .build();

    ListenableFuture getEnvironmentFuture = environmentClient.getEnvironmentAsync(request);
    Futures.addCallback(getEnvironmentFuture, new FutureCallback<>() {
        @Override
        public void onSuccess(Environment environment) {
            AndroidDevicePolicyEnvironment adpEnvironment = environment.getAndroidDevicePolicyEnvironment();

            AndroidDevicePolicyEnvironment.State state = adpEnvironment.getState();
            AndroidDevicePolicyEnvironment.Version version = adpEnvironment.getVersion();
            if (state == READY && version == UP_TO_DATE) {
                // AMAPI Environment State OK, Version OK.  Requesting Device signals..
                DeviceClient deviceClient = DeviceClientFactory.create(context);
                checkDevice(deviceClient);
            } else if (state == INSTALLED) {
                // prepareEnvironment should be called, calling
                // prepareEnvironment won't show the UI
                prepareEnvironment(context, environmentClient);
            } else if (state == NOT_INSTALLED) {
                // prepareEnvironment should be called, calling
                // prepareEnvironment will show the UI
                prepareEnvironment(context, environmentClient);
            }
        }

        @Override
        public void onFailure(Throwable t) {
            Log.d(TAG, t.toString());
        }
    }, MoreExecutors.directExecutor());
} catch (Exception e) {
    Log.d(TAG, e.toString());
}

अगर ADP ऐप्लिकेशन इंस्टॉल है, लेकिन वह अप-टू-डेट नहीं है, तो उपयोगकर्ता के इंटरैक्शन के बिना ADP ऐप्लिकेशन को अपडेट करने के लिए, आपके ऐप्लिकेशन को prepareEnvironment को कॉल करना चाहिए.

अगर ADP ऐप्लिकेशन इंस्टॉल नहीं है, तो उपयोगकर्ता को ADP ऐप्लिकेशन इंस्टॉल करने के लिए कहने के लिए, आपका ऐप्लिकेशन prepareEnvironment को कॉल कर सकता है. क्लाइंट एनवायरमेंट तैयार करना देखें.

क्लाइंट एनवायरमेंट तैयार करना

ध्यान दें: अगर डिवाइस पर क्लाइंट एनवायरमेंट तैयार नहीं है, तो डिवाइस के ट्रस्ट सिग्नल ऐक्सेस करने से पहले, prepareEnvironment को कॉल करके ADP ऐप्लिकेशन को इंस्टॉल या अपडेट करना ज़रूरी है.

• अगर ADP ऐप्लिकेशन पहले से इंस्टॉल है, तो एपीआई उसे बिना किसी उपयोगकर्ता के इंटरवेंशन के अपडेट कर देगा.

• अगर ADP ऐप्लिकेशन इंस्टॉल नहीं है, तो एपीआई उपयोगकर्ता से ADP ऐप्लिकेशन को इंस्टॉल करने की अनुमति मांगेगा.

उपयोगकर्ता की पसंद को मॉनिटर करने के लिए, कॉलबैक रजिस्टर किया जा सकता है. ज़्यादा जानकारी के लिए, ADP ऐप्लिकेशन इंस्टॉल करने के दौरान उपयोगकर्ता के इंटरैक्शन को ट्रैक करना देखें.

हमारा सुझाव है कि prepareEnvironment कॉल को फ़ोरग्राउंड प्रोसेस से किया जाए. ऐसा, उपयोगकर्ता को Android डिवाइस की नीति इंस्टॉल करें मॉडल डायलॉग से अचानक नहीं चौंकाने के लिए किया जाता है. अगर फ़ोरग्राउंड प्रोसेस से कॉल करना मुमकिन नहीं है, क्योंकि यह वेब फ़्लो है और Android कॉम्पोनेंट में कोई यूज़र इंटरफ़ेस (यूआई) नहीं है, तो बैकग्राउंड से कॉल करने की अनुमति है. हालांकि, इसके लिए ज़रूरी है कि यह ऑनबोर्डिंग यूज़र इंटरफ़ेस (यूआई) फ़्लो के दौरान हो.

ध्यान दें: हमारा सुझाव है कि मैनेज किए जा रहे डिवाइसों पर, आईटी एडमिन कारोबार के लिए उपलब्ध Play का इस्तेमाल करके, ADP ऐप्लिकेशन को चुपचाप डिप्लॉय करे. मैनेज किए जा रहे Play के साथ, ऐसे अन्य कंट्रोल उपलब्ध होते हैं जिनका इस्तेमाल आईटी एडमिन कर सकता है:

• policy.productPolicy[].autoInstallPolicy - ऐप्लिकेशन इंस्टॉल करने की प्राथमिकता और स्थिति को कंट्रोल करता है
• policy.productPolicy[].autoUpdateMode - ऐप्लिकेशन अपडेट की प्राथमिकता को कंट्रोल करता है. आईटी एडमिन इसे AUTO_UPDATE_HIGH_PRIORITY पर सेट कर सकता है

एनवायरमेंट सही तरीके से सेट अप होने के बाद, डिवाइस के भरोसेमंद सिग्नल ऐक्सेस किए जा सकते हैं. डिवाइस के ट्रस्ट सिग्नल ऐक्सेस करना लेख पढ़ें.

अहम जानकारी: Role सेट किए बिना getEnvironment या prepareEnvironment को कॉल करने पर, InvalidArgumentException दिखेगा.

Kotlin

try {
    val myNotificationReceiverService = ComponentName(
        context, MyNotificationReceiverService::class.java
    )

    val roles = listOf(Role.builder().setRoleType(Role.RoleType.IDENTITY_PROVIDER).build())
    val request = PrepareEnvironmentRequest.builder().setRoles(roles).build()

    val response =
        environmentClient.prepareEnvironment(request, myNotificationReceiverService)

    val environment = response.environment
    val adpEnvironment = environment.androidDevicePolicyEnvironment

    val state = adpEnvironment.state
    val version = adpEnvironment.version
    if (state == READY && version == UP_TO_DATE) {
        // Environment is prepared, access device posture signals using
        // DeviceClient.
        checkDevice(deviceClient = DeviceClientFactory.create(context))
    } else {
        // The prepareEnvironment call failed to prepare
        Log.w(
            TAG, "AMAPI environment was not ready: " + state + " - " + version
        )
    }

} catch (e: java.lang.Exception) {
    Log.d(TAG, e.toString())
}

Java

try {
    ComponentName myNotificationReceiverService = new ComponentName(
            context,
            MyNotificationReceiverService.class
    );

    ImmutableList roles = new ImmutableList.Builder()
            .add(Role.builder()
                    .setRoleType(Role.RoleType.IDENTITY_PROVIDER)
                    .build())
            .build();


    PrepareEnvironmentRequest request = PrepareEnvironmentRequest.builder()
            .setRoles(roles)
            .build();

    ListenableFuture environmentFuture =
            environmentClient.prepareEnvironmentAsync(
                    request,
                    myNotificationReceiverService
            );

    Futures.addCallback(environmentFuture, new FutureCallback<>() {
        @Override
        public void onSuccess(PrepareEnvironmentResponse response) {
            Environment environment = response.getEnvironment();
            AndroidDevicePolicyEnvironment adpEnvironment = environment.getAndroidDevicePolicyEnvironment();

            AndroidDevicePolicyEnvironment.State state = adpEnvironment.getState();
            AndroidDevicePolicyEnvironment.Version version = adpEnvironment.getVersion();
            if (state == READY && version == UP_TO_DATE) {
                // AMAPI Environment State OK, Version OK.  Requesting Device signals..
                DeviceClient deviceClient = DeviceClientFactory.create(context);
                checkDevice(deviceClient);
            } else {
                // The prepareEnvironment call failed to prepare
                Log.w(
                        TAG, "AMAPI environment was not ready: "
                        + adpEnvironment.getState() + " - " + adpEnvironment.getVersion()
                );
            }
        }

        @Override
        public void onFailure(@NonNull Throwable t) {
            // Handle the error
            Log.d(TAG, "AMAPI response did not contain an ADP environment");
        }
    }, MoreExecutors.directExecutor());
} catch (Exception e) {
    Log.d(TAG, e.toString());
}

डिवाइस के ट्रस्ट सिग्नल ऐक्सेस करना

ध्यान दें: डिवाइस के भरोसे के सिग्नल ऐक्सेस करने के लिए, अप-टू-डेट एनवायरमेंट की ज़रूरत होती है. डिवाइस के पोज़िशन की जानकारी ऐक्सेस करने से पहले, हमेशा क्लाइंट एनवायरमेंट की पुष्टि करें सेक्शन में बताए गए तरीके से एनवायरमेंट की जांच करें.

अपने हिसाब से डिवाइस के भरोसे के सिग्नल ऐक्सेस करने के लिए, Device ऑब्जेक्ट का अनुरोध करने के लिए, पिछले चरण में देखे गए deviceClient इंस्टेंस का इस्तेमाल किया जा सकता है.

Kotlin

try {
    kotlin.runCatching {
        deviceClient.getDeviceAwait(GetDeviceRequest.getDefaultInstance())
    }.onFailure { t ->
        Log.d(TAG, t.toString())
    }.onSuccess { device ->
        // Access device posture signals available in device
        val deviceString = device.toString()
        Log.d(TAG, deviceString)
    }
} catch (e: java.lang.Exception) {
    Log.d(TAG, e.toString())
}

Java

try {
    ListenableFuture deviceFuture =
            deviceClient.getDevice(GetDeviceRequest.getDefaultInstance());

    Futures.addCallback(deviceFuture, new FutureCallback() {
        @Override
        public void onSuccess(Device device) {
            // Access device posture signals available in device
            String deviceString = device.toString();
            Log.d(TAG, deviceString);
        }

        @Override
        public void onFailure(Throwable t) {
            Log.d(TAG, Log.d(TAG, t.toString());
        }
    }, MoreExecutors.directExecutor());
} catch (Exception e) {
    Log.d(TAG, e.toString());
}

ADP ऐप्लिकेशन इंस्टॉल करने के दौरान उपयोगकर्ता के इंटरैक्शन को ट्रैक करना

अगर prepareEnvironment के दौरान डिवाइस को ADP ऐप्लिकेशन इंस्टॉल करना है, तो आपका ऐप्लिकेशन उपयोगकर्ता के इंटरैक्शन को ट्रैक कर सकता है. इसके लिए, NotificationReceiverService लागू करें, ताकि getPrepareEnvironmentListener को बदलकर सूचनाएं मिल सकें:

Kotlin

import android.util.Log
import com.google.android.managementapi.environment.EnvironmentListener
import com.google.android.managementapi.environment.model.EnvironmentEvent.EventCase.Kind.ANDROID_DEVICE_POLICY_INSTALL_CONSENT_ACCEPTED
import com.google.android.managementapi.environment.model.EnvironmentEvent
import com.google.android.managementapi.notification.NotificationReceiverService

class MyNotificationReceiverService : NotificationReceiverService() {
    override fun getPrepareEnvironmentListener(): EnvironmentListener {
        return MyEnvironmentListener()
    }
}

class MyEnvironmentListener : EnvironmentListener {
    override fun onEnvironmentEvent(
        event: EnvironmentEvent
    ) {
        if (event.event.kind == ANDROID_DEVICE_POLICY_INSTALL_CONSENT_ACCEPTED) {
            Log.d(TAG, "User provided install consent")
        } else {
            Log.d(TAG, "User rejected install consent")
        }
    }

    companion object {
        private val TAG: String = MyEnvironmentListener::class.java.simpleName
    }
}

Java

import static com.google.android.managementapi.environment.model.EnvironmentEvent.EventCase.Kind.ANDROID_DEVICE_POLICY_INSTALL_CONSENT_ACCEPTED;

import android.util.Log;
import androidx.annotation.NonNull;
import com.google.android.managementapi.environment.EnvironmentListener;
import com.google.android.managementapi.environment.model.EnvironmentEvent;
import com.google.android.managementapi.notification.NotificationReceiverService;

class MyNotificationReceiverService extends NotificationReceiverService {
    @NonNull
    @Override
    protected EnvironmentListener getPrepareEnvironmentListener() {
        return new MyEnvironmentListener();
    }
}
class MyEnvironmentListener implements EnvironmentListener {
    final private String TAG = MyEnvironmentListener.class.getSimpleName();

    @Override
    public void onEnvironmentEvent(EnvironmentEvent event) {
        if (event.getEvent().getKind() == ANDROID_DEVICE_POLICY_INSTALL_CONSENT_ACCEPTED)
        {
            Log.d(TAG, "User provided install consent");
        } else {
            Log.d(TAG, "User rejected install consent");
        }
    }
}

ज्ञात समस्याएं

फ़िलहाल, कोई समस्या नहीं है.