Google ใช้เทคโนโลยี AI เพื่อแปลเนื้อหาเป็นภาษาที่คุณต้องการ การแปลโดย AI อาจมีข้อผิดพลาด

Device Trust from Android Enterprise - คู่มือการผสานรวม

สำคัญ: การเข้าถึงสัญญาณความน่าเชื่อถือของอุปกรณ์จากภายในโปรไฟล์ส่วนตัวหรือในอุปกรณ์ที่ไม่มีการจัดการกำหนดให้แอปพลิเคชันของคุณต้องอยู่ในรายการที่อนุญาต แอปพลิเคชันที่ได้รับมอบหมายบทบาท COMPANION_APP ในอุปกรณ์ที่จัดการโดย AMAPI จะเข้าถึงสัญญาณได้โดยไม่ต้องอยู่ในรายการที่อนุญาตในอุปกรณ์ที่มีการจัดการครบวงจรหรือจากภายในโปรไฟล์งาน (จำกัดเฉพาะโปรไฟล์งาน) ดูรายละเอียดได้ที่หัวข้อ Device Trust from Android Enterprise - การเข้าถึงสัญญาณ

เอกสารนี้ควรเป็นคู่มือหลักสำหรับการใช้งาน AMAPI SDK เพื่อวัตถุประสงค์ในการรับสัญญาณความน่าเชื่อถือของอุปกรณ์

AMAPI SDK ช่วยให้แอปพลิเคชันของคุณเข้าถึงสัญญาณความน่าเชื่อถือของอุปกรณ์จากแอป Android Device Policy (ADP) ได้ จากนั้นแอปของคุณจะใช้สัญญาณเหล่านี้เพื่อคำนวณสถานะความน่าเชื่อถือของอุปกรณ์และใช้ตรรกะทางธุรกิจตามที่เลือกได้

ข้อกำหนดเบื้องต้น

แอปพลิเคชันของคุณต้องได้รับสิทธิ์ในการอ่านสัญญาณความน่าเชื่อถือของอุปกรณ์ ดังนี้
- แอปที่ใช้ร่วมกันในอุปกรณ์ที่จัดการโดย AMAPI: แอปพลิเคชันที่ได้รับบทบาท COMPANION_APP ในนโยบายจะเข้าถึงสัญญาณความน่าเชื่อถือของอุปกรณ์ได้โดยไม่ต้องอยู่ในรายการที่อนุญาตในอุปกรณ์ที่มีการจัดการครบวงจรหรือจากภายในโปรไฟล์งาน (โดยจำกัดการเข้าถึงเฉพาะสัญญาณจากโปรไฟล์งาน) โปรดดูรายละเอียดที่หัวข้อจัดการบทบาทของแอปพลิเคชัน, การกำหนดค่านโยบาย และเข้าถึงสัญญาณจากแอปที่ใช้ร่วมกัน
- แอปพลิเคชันและสภาพแวดล้อมอื่นๆ ทั้งหมด: การเข้าถึงสัญญาณความน่าเชื่อถือของอุปกรณ์จากภายในโปรไฟล์ส่วนตัว ในอุปกรณ์ที่ไม่มีการจัดการ ในอุปกรณ์ที่จัดการโดย DPC ที่กำหนดเอง หรือไม่มีบทบาท COMPANION_APP กำหนดให้แอปพลิเคชันของคุณต้องอยู่ในรายการที่อนุญาต ดูข้อมูลเกี่ยวกับวิธีสมัครได้ที่หน้าการเข้าถึงสัญญาณความน่าเชื่อถือของอุปกรณ์
Android Enterprise ขอแนะนำให้ผสานรวมชุด API ของ Play Integrity เข้ากับแอปพลิเคชันไคลเอ็นต์ของคุณ และอ้างอิงผลลัพธ์ก่อนที่จะอ่านและใช้สัญญาณความน่าเชื่อถือของอุปกรณ์ ไม่ควรเชื่อถืออุปกรณ์ที่ไม่ผ่านการตรวจสอบ Play Integrity API และไม่ควรใช้สัญญาณใดๆ ที่ได้มาจากอุปกรณ์ดังกล่าวเพื่อกำหนดสถานะความน่าเชื่อถือ ดูรายละเอียดเพิ่มเติมได้ในเอกสารประกอบของ Play Integrity

ผสานรวมกับ AMAPI SDK ในแอปพลิเคชันของคุณ

หากต้องการเข้าถึงสัญญาณความน่าเชื่อถือของอุปกรณ์ แอปพลิเคชันของคุณต้องผสานรวมกับ AMAPI SDK ดูข้อมูลเพิ่มเติมเกี่ยวกับไลบรารีนี้และวิธีเพิ่มไลบรารีลงในแอปพลิเคชันได้ในคู่มือการผสานรวม AMAPI SDK

เพิ่มสิทธิ์ที่จำเป็น

สัญญาณบางอย่างที่แสดงผลจาก Device Trust from Android Enterprise API กำหนดให้แอปต้องประกาศสิทธิ์เดียวกันกับที่จำเป็นสำหรับการเข้าถึงข้อมูลนี้ตั้งแต่แรก โดยเฉพาะอย่างยิ่งสิทธิ์ต่อไปนี้

สัญญาณ	สิทธิ์ที่จำเป็น
สถานะเครือข่าย	`ACCESS_NETWORK_STATE`
ความซับซ้อนของการล็อกหน้าจอ	`REQUEST_PASSWORD_COMPLEXITY`

หากสิทธิ์เหล่านี้ไม่ได้รวมอยู่ใน AndroidManifest.xml ของแอป Device Trust from Android Enterprise API จะแสดงผล PERMISSION_ISSUE ในข้อมูลเมตาของสัญญาณที่เกี่ยวข้อง ดังนี้

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

ดูรายละเอียดเพิ่มเติมได้ที่รายการสัญญาณความน่าเชื่อถือของอุปกรณ์ที่พร้อมใช้งาน

ขั้นตอนในการเข้าถึงสัญญาณความน่าเชื่อถือของอุปกรณ์

แอปพลิเคชันในรายการที่อนุญาต (รวมถึงแอปที่ทำงานภายในโปรไฟล์ส่วนตัวหรือในอุปกรณ์ที่ไม่มีการจัดการ) ต้องยืนยันว่าสภาพแวดล้อมของไคลเอ็นต์เป็นเวอร์ชันล่าสุด และเตรียมสภาพแวดล้อมดังกล่าวหากจำเป็นก่อนที่จะขอสัญญาณ

ขั้นตอนสำหรับแอปพลิเคชันในรายการที่อนุญาตเพื่อเข้าถึงสัญญาณความน่าเชื่อถือของอุปกรณ์มีดังนี้

ยืนยันสภาพแวดล้อมของไคลเอ็นต์
เตรียมสภาพแวดล้อมของไคลเอ็นต์
เข้าถึงสัญญาณความน่าเชื่อถือของอุปกรณ์

ขั้นตอนในการเข้าถึงสัญญาณความน่าเชื่อถือของอุปกรณ์

ยืนยันสภาพแวดล้อมของไคลเอ็นต์

ตัวอย่างโค้ดต่อไปนี้แสดงวิธีใช้ getEnvironment เพื่ออ่านสถานะปัจจุบันของแอป ADP จากนั้นแอปพลิเคชันของคุณจะใช้อินสแตนซ์ deviceClient ที่แคชไว้เพื่อเข้าถึงสัญญาณความน่าเชื่อถือของอุปกรณ์ได้หากสภาพแวดล้อมพร้อมและเป็นเวอร์ชันล่าสุด (ดูหัวข้อเข้าถึงสัญญาณความน่าเชื่อถือของอุปกรณ์)

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)
        } 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..
                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 แล้วแต่ยังไม่ใช่เวอร์ชันล่าสุด แอปพลิเคชันของคุณควรเรียกใช้ prepareEnvironment เพื่ออัปเดตแอป ADP แบบเงียบโดยไม่ต้องให้ผู้ใช้ดำเนินการ

หากไม่ได้ติดตั้งแอป ADP ไว้ แอปพลิเคชันของคุณจะเรียกใช้ prepareEnvironment เพื่อแจ้งให้ผู้ใช้ติดตั้งแอป ADP ได้ ดูหัวข้อเตรียมสภาพแวดล้อมของไคลเอ็นต์

เตรียมสภาพแวดล้อมของไคลเอ็นต์

หากติดตั้งแอป ADP ไว้แล้ว API จะอัปเดตแอปโดยไม่มีการแทรกแซงจากผู้ใช้
หากไม่ได้ติดตั้งแอป ADP ไว้ API จะแจ้งให้ผู้ใช้ยอมรับการติดตั้งแอป ADP

ติดตั้ง Android Device Policy

คุณสามารถลงทะเบียน Callback เพื่อตรวจสอบตัวเลือกของผู้ใช้ได้ ดูรายละเอียดเพิ่มเติมได้ที่ติดตามการโต้ตอบของผู้ใช้ระหว่างการติดตั้งแอป ADP

เราขอแนะนำให้เรียกใช้ prepareEnvironment จากกระบวนการที่ทำงานอยู่เบื้องหน้าในระหว่างขั้นตอน UX ของการเริ่มต้นใช้งาน เพื่อไม่ให้ผู้ใช้ตกใจกับกล่องโต้ตอบโมดัลติดตั้ง Android Device Policy หากไม่สามารถเรียกจากกระบวนการที่ทำงานอยู่เบื้องหน้าได้เนื่องจากเป็นขั้นตอนบนเว็บและคอมโพเนนต์ Android ไม่มี UI ระบบจะอนุญาตให้เรียกจากเบื้องหลังได้โดยมีข้อกำหนดว่าการดำเนินการนี้ต้องเกิดขึ้นระหว่างขั้นตอน UX ของการเตรียมความพร้อมผู้ใช้งานใหม่

หมายเหตุ: ในอุปกรณ์ที่มีการจัดการ เราขอแนะนำให้ผู้ดูแลระบบไอทีติดตั้งใช้งานแอป ADP ในอุปกรณ์ที่มีการจัดการโดยไม่แจ้งให้ผู้ใช้ทราบโดยใช้ Managed Play Managed Play มีการควบคุมเพิ่มเติมที่ผู้ดูแลระบบไอทีอาจใช้ได้ ดังนี้

policy.productPolicy[].autoInstallPolicy - ควบคุมลำดับความสำคัญและสถานการณ์ในการติดตั้งแอป
policy.productPolicy[].autoUpdateMode - ควบคุมลำดับความสำคัญของการอัปเดตแอป ผู้ดูแลระบบไอทีอาจตั้งค่านี้เป็น AUTO_UPDATE_HIGH_PRIORITY

เมื่อตั้งค่าสภาพแวดล้อมอย่างถูกต้องแล้ว คุณจะเข้าถึงสัญญาณความน่าเชื่อถือของอุปกรณ์ได้ โปรดดูหัวข้อเข้าถึงสัญญาณความน่าเชื่อถือของอุปกรณ์

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)
    } 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..
                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());
}

เข้าถึงสัญญาณความน่าเชื่อถือของอุปกรณ์

คำแนะนำการใช้งาน DeviceClient

การสร้างอินสแตนซ์ deviceClient (หรืออินสแตนซ์ EnvironmentClient) จะสร้างช่องทางการสื่อสารกับแอป Android Device Policy (ADP) ที่จะยกเลิกการเชื่อมโยงโดยอัตโนมัติเมื่อไม่มีการใช้งาน เนื่องจากอินสแตนซ์ไคลเอ็นต์ไม่ได้แสดงเมธอดการปิดอย่างชัดเจน การสร้างและทิ้งอินสแตนซ์หลายรายการจึงทำให้แชแนลที่ไม่มีเจ้าของถูกรวบรวมเป็นขยะ

หากต้องการเพิ่มประสิทธิภาพและหลีกเลี่ยงแชแนลที่ไม่มีเจ้าของ ให้สร้างอินสแตนซ์เดียวของ DeviceClient ที่ขอบเขตแอปพลิเคชันโดยใช้ DeviceClientFactory.create(context.applicationContext) และแคชไว้เพื่อนำมาใช้ซ้ำทั่วทั้งแอปพลิเคชัน เช่น เป็นซิงเกิลตันที่กำหนดขอบเขตแอปพลิเคชันหรือใช้การแทรกทรัพยากร Dependency

หากต้องการเข้าถึงสัญญาณความน่าเชื่อถือของอุปกรณ์ที่คุณสนใจ ให้ใช้อินสแตนซ์ deviceClient ที่แคชไว้เพื่อขอออบเจ็กต์ Device

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)
}

Java

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, t.toString());
    }
}, MoreExecutors.directExecutor());

สัญญาณการเข้าถึงจากแอปที่ใช้ร่วมกัน

ในอุปกรณ์ที่มีการจัดการครบวงจรหรือจากภายในโปรไฟล์งานที่จัดการด้วย Android Management API (AMAPI) แอปพลิเคชันที่ได้รับบทบาท COMPANION_APP จะอ่านสัญญาณความน่าเชื่อถือของอุปกรณ์ได้โดยไม่ต้องลงทะเบียนในรายการที่อนุญาต

เมื่อเรียกใช้จากภายในโปรไฟล์งาน (ในอุปกรณ์ของบริษัทหรืออุปกรณ์ส่วนตัว) แอปของคุณต้องทำงานภายในโปรไฟล์งาน และการเข้าถึงจะจำกัดเฉพาะสัญญาณจากโปรไฟล์งาน (เช่น สถานะการจัดการ ความซับซ้อนของการล็อกหน้าจอ และแอปพลิเคชันที่ติดตั้งจะแสดงเฉพาะโปรไฟล์งานเท่านั้น)

1. มอบหมายบทบาท COMPANION_APP ในนโยบาย

กำหนดค่านโยบาย EMM เพื่อให้สิทธิ์ roleType: "COMPANION_APP" แก่แอปพลิเคชันของคุณในรายการนโยบาย applications ดังนี้

หากต้องการกำหนดค่าไฟล์ Manifest ของแอปและฟังการมอบหมายบทบาท (ไม่บังคับ) โปรดดูหัวข้อจัดการบทบาทของแอปพลิเคชัน
ดูไวยากรณ์การกำหนดค่านโยบายได้ที่การกำหนดค่านโยบาย

2. อ่านสัญญาณโดยตรงด้วย DeviceClient

สำคัญ: อย่าเรียกใช้ EnvironmentClient จากแอปที่ใช้ร่วมกันซึ่งไม่ได้อยู่ในรายการที่อนุญาต ในอุปกรณ์และโปรไฟล์งานที่จัดการโดย AMAPI แอป ADP จะได้รับการติดตั้งอยู่แล้ว โดยจะจัดการอุปกรณ์หรือโปรไฟล์ และอัปเดตโดยอัตโนมัติ COMPANION_APP ผู้โทรที่ไม่ได้อยู่ในรายการที่อนุญาตจะไม่ได้รับอนุญาตให้โทร EnvironmentClient: getEnvironment จะไม่รายงาน READY และ prepareEnvironment จะแสดง SecurityException

สร้างและแคชอินสแตนซ์ deviceClient รายการเดียวที่ขอบเขตแอปพลิเคชันโดยใช้ DeviceClientFactory.create (ดูคำแนะนำการใช้งาน DeviceClient) จากนั้นขอออบเจ็กต์ Device โดยตรง

Kotlin

import android.content.Context
import android.util.Log
import com.google.android.managementapi.device.DeviceClient
import com.google.android.managementapi.device.DeviceClientFactory
import com.google.android.managementapi.device.model.GetDeviceRequest

// Instantiate once at application scope (for example, using dependency injection)
// to reuse a single DeviceClient instance across your app.
class DeviceTrustRepository(context: Context) {
    private val deviceClient: DeviceClient =
        DeviceClientFactory.create(context.applicationContext)

    suspend fun readSignalsFromCompanionApp() {
        runCatching {
            deviceClient.getDeviceAwait(GetDeviceRequest.getDefaultInstance())
        }.onSuccess { device ->
            Log.d(TAG, "Device signals: $device")
        }.onFailure { t ->
            Log.e(TAG, "Failed to read device signals", t)
        }
    }

    companion object {
        private const val TAG = "DeviceTrustRepository"
    }
}

Java

import android.content.Context;
import android.util.Log;
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.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.MoreExecutors;

// Instantiate once at application scope (for example, using dependency injection)
// to reuse a single DeviceClient instance across your app.
public class DeviceTrustRepository {
    private static final String TAG = "DeviceTrustRepository";
    private final DeviceClient deviceClient;

    public DeviceTrustRepository(Context context) {
        this.deviceClient = DeviceClientFactory.create(context.getApplicationContext());
    }

    public void readSignalsFromCompanionApp() {
        ListenableFuture deviceFuture =
                deviceClient.getDevice(GetDeviceRequest.getDefaultInstance());

        Futures.addCallback(deviceFuture, new FutureCallback() {
            @Override
            public void onSuccess(Device device) {
                Log.d(TAG, "Device signals: " + device);
            }

            @Override
            public void onFailure(Throwable t) {
                Log.e(TAG, "Failed to read device signals", t);
            }
        }, MoreExecutors.directExecutor());
    }
}

จัดการข้อผิดพลาด

หากแอปส่งคำขอความน่าเชื่อถือของอุปกรณ์และการเรียกใช้ไม่สำเร็จ แอปจะได้รับข้อยกเว้น ข้อยกเว้นเหล่านี้อาจเกิดขึ้นได้จากหลายสาเหตุ เช่น

SecurityException - แอปของคุณไม่ได้รับอนุญาตให้ส่งคำขอ (เช่น แอปของคุณไม่ได้ลงทะเบียนในรายการที่อนุญาตเมื่อจำเป็น ไม่ได้รับมอบหมายบทบาท COMPANION_APP ในอุปกรณ์ที่จัดการโดย AMAPI หรือเรียกใช้ prepareEnvironment เป็นแอปที่ใช้ร่วมกันซึ่งไม่ได้อยู่ในรายการที่อนุญาต) ดูการเข้าถึงสัญญาณความน่าเชื่อถือของอุปกรณ์และการเข้าถึงสัญญาณจากแอปที่ใช้ร่วมกัน
คลาสย่อยของ AmapiSdkException - ADP ไม่มีอยู่หรือไม่พร้อมใช้งาน ซึ่งอาจเกิดจากสภาวะชั่วคราวและคุณควรลองโทรอีกครั้ง

กลยุทธ์การลองใหม่

สำหรับข้อยกเว้นเนื่องจากสภาวะชั่วคราว ให้ใช้กลยุทธ์การลองใหม่ด้วย Exponential Backoff หลังจากดำเนินการไม่สำเร็จครั้งแรก ให้เริ่มด้วยการหน่วงเวลาเริ่มต้น 5 วินาทีก่อนลองอีกครั้ง

ใช้กลยุทธ์การลองใหม่โดยกำหนดจำนวนครั้งสูงสุดเป็นเงื่อนไขการออก โดยใช้การหน่วงเวลาที่เพิ่มขึ้นแบบทวีคูณในแต่ละครั้ง (10 วินาที, 20 วินาที ฯลฯ)

ติดตามการโต้ตอบของผู้ใช้ระหว่างการติดตั้งแอป ADP

หากอุปกรณ์จำเป็นต้องติดตั้งแอป ADP ในระหว่างprepareEnvironment แอปพลิเคชันของคุณจะติดตามการโต้ตอบของผู้ใช้ได้โดยใช้ 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");
        }
    }
}

ปัญหาที่ทราบ

ขณะนี้ยังไม่มีปัญหาที่ทราบ