ภาพรวมการดูแลระบบอุปกรณ์

การเลิกใช้งานผู้ดูแลระบบอุปกรณ์ ตั้งแต่ Android 9 (API ระดับ 28) เป็นต้นไป ระบบจะทำเครื่องหมายนโยบายผู้ดูแลระบบบางอย่างว่าเลิกใช้งานแล้วเมื่อ ผู้ดูแลระบบอุปกรณ์เรียกใช้นโยบายดังกล่าว เราขอแนะนำให้คุณเริ่มเตรียมพร้อมสำหรับการเปลี่ยนแปลงนี้ได้เลย ดูข้อมูลเพิ่มเติมและตัวเลือกการย้ายข้อมูลได้ที่ การเลิกใช้งานผู้ดูแลระบบอุปกรณ์

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

เอกสารนี้มีไว้สำหรับนักพัฒนาแอปที่ต้องการพัฒนาโซลูชันระดับองค์กรสำหรับอุปกรณ์ที่ใช้ Android โดยจะอธิบายฟีเจอร์ต่างๆ ที่ Device Administration API มีให้เพื่อเพิ่มความปลอดภัยให้กับ อุปกรณ์ของพนักงานที่ใช้ Android

หมายเหตุ ดูข้อมูลเกี่ยวกับการสร้างเครื่องมือควบคุมนโยบายงาน สำหรับ Android สำหรับการติดตั้งใช้งาน Android for Work ได้ที่ สร้างเครื่องมือควบคุมนโยบายด้านอุปกรณ์

โหมดเจ้าของอุปกรณ์แบบไม่มีส่วนหัว

Android 14 (API ระดับ 34) เปิดตัวโหมดผู้ใช้ระบบแบบไม่มีส่วนหัว (อุปกรณ์ที่ UserManager.isHeadlessSystemUserMode แสดงผลเป็น true) ในโหมดผู้ใช้ระบบแบบไม่มีส่วนหัว ผู้ใช้ระบบจะเป็นผู้ใช้เบื้องหลังและต้องอาศัยผู้ใช้เบื้องหน้าเพิ่มเติมสำหรับการโต้ตอบของผู้ใช้ปลายทาง Android 14 ยังเปิดตัวโหมดที่เชื่อมโยงเจ้าของอุปกรณ์แบบไม่มีส่วนหัว ซึ่งจะเพิ่มเจ้าของโปรไฟล์ให้กับผู้ใช้ที่เชื่อมโยง ทั้งหมดนอกเหนือจากผู้ใช้ระบบที่ตั้งค่าเจ้าของอุปกรณ์ไว้

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

ผู้ผลิตอุปกรณ์ Android อาจดูคำแนะนำที่เผยแพร่ใน source.android.com

ภาพรวมของ Device Administration API

ต่อไปนี้คือตัวอย่างประเภทแอปที่อาจใช้ Device Administration API

• โปรแกรมรับส่งอีเมล
• แอปความปลอดภัยที่ล้างข้อมูลจากระยะไกล
• บริการและแอปการจัดการอุปกรณ์

วิธีการทำงาน

คุณใช้ Device Administration API เพื่อเขียนแอปผู้ดูแลระบบอุปกรณ์ที่ผู้ใช้ ติดตั้งในอุปกรณ์ แอปผู้ดูแลระบบอุปกรณ์จะบังคับใช้นโยบายที่ต้องการ วิธีการมีดังนี้

• ผู้ดูแลระบบจะเขียนแอปผู้ดูแลระบบอุปกรณ์ที่บังคับใช้ นโยบายความปลอดภัยของอุปกรณ์จากระยะไกล/ในเครื่อง นโยบายเหล่านี้อาจมีการฮาร์ดโค้ดไว้ในแอป หรือแอปอาจดึงนโยบายแบบไดนามิกจากเซิร์ฟเวอร์ของบุคคลที่สาม
• ระบบจะติดตั้งแอปในอุปกรณ์ของผู้ใช้ ปัจจุบัน Android ยังไม่มีโซลูชันการจัดสรรอัตโนมัติ วิธีที่ผู้ดูแลระบบอาจใช้ในการ เผยแพร่แอปให้ผู้ใช้มีดังนี้
  • Google Play
  • การเปิดใช้การติดตั้งจากร้านค้าอื่น
  • การเผยแพร่แอปด้วยวิธีอื่นๆ เช่น อีเมลหรือเว็บไซต์
• ระบบจะแจ้งให้ผู้ใช้เปิดใช้แอปผู้ดูแลระบบอุปกรณ์ โดยวิธี และเวลาที่เกิดเหตุการณ์นี้จะขึ้นอยู่กับวิธีที่แอปได้รับการติดตั้งใช้งาน
• เมื่อผู้ใช้เปิดใช้แอปผู้ดูแลระบบอุปกรณ์แล้ว ผู้ใช้จะอยู่ภายใต้นโยบายของแอป การปฏิบัติตามนโยบายเหล่านั้นมักจะให้ประโยชน์ เช่น การเข้าถึงระบบและข้อมูลที่ละเอียดอ่อน

หากผู้ใช้ไม่เปิดใช้แอปผู้ดูแลระบบอุปกรณ์ แอปจะยังคงอยู่ในอุปกรณ์ แต่จะอยู่ในสถานะไม่ได้ใช้งาน ผู้ใช้จะไม่ต้องปฏิบัติตามนโยบายของแอป และในทางกลับกัน ผู้ใช้จะไม่ได้รับสิทธิประโยชน์ใดๆ จากแอป เช่น อาจซิงค์ข้อมูลไม่ได้

หากผู้ใช้ไม่ปฏิบัติตามนโยบาย (เช่น หากผู้ใช้ตั้งรหัสผ่านที่ละเมิดหลักเกณฑ์) แอปจะเป็นผู้พิจารณาว่าจะจัดการกับปัญหานี้อย่างไร แต่โดยปกติแล้ว การดำเนินการนี้จะส่งผลให้ผู้ใช้ซิงค์ข้อมูลไม่ได้

หากอุปกรณ์พยายามเชื่อมต่อกับเซิร์ฟเวอร์ที่ต้องใช้นโยบายที่ Device Administration API ไม่รองรับ ระบบจะไม่อนุญาตให้เชื่อมต่อ ปัจจุบัน Device Administration API ไม่อนุญาตให้มีการจัดสรรบางส่วน กล่าวคือ หากอุปกรณ์ (เช่น อุปกรณ์รุ่นเดิม) ไม่รองรับนโยบายที่ระบุไว้ทั้งหมด ก็จะไม่มีวิธีอนุญาตให้อุปกรณ์เชื่อมต่อ

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

หากต้องการถอนการติดตั้งแอปผู้ดูแลระบบอุปกรณ์ที่มีอยู่ ผู้ใช้ต้อง ยกเลิกการลงทะเบียนแอปในฐานะผู้ดูแลระบบก่อน

นโยบาย

ในการตั้งค่าระดับองค์กร มักจะมีการกำหนดให้อุปกรณ์ของพนักงานต้อง ปฏิบัติตามชุดนโยบายที่เข้มงวดซึ่งควบคุมการใช้อุปกรณ์ Device Administration API รองรับนโยบายที่แสดงในตารางที่ 1 โปรดทราบว่าปัจจุบัน Device Administration API รองรับเฉพาะรหัสผ่านสำหรับการล็อกหน้าจอเท่านั้น

ตารางที่ 1 นโยบายที่ API การดูแลระบบอุปกรณ์รองรับ

ฟีเจอร์อื่นๆ

นอกจากจะรองรับนโยบายที่ระบุไว้ในตารางด้านบนแล้ว Device Administration API ยังช่วยให้คุณทำสิ่งต่อไปนี้ได้ด้วย

• แจ้งให้ผู้ใช้ตั้งรหัสผ่านใหม่
• ล็อกอุปกรณ์ทันที
• ล้างข้อมูลของอุปกรณ์ (เช่น คืนค่าอุปกรณ์เป็นการตั้งค่าเริ่มต้น)

แอปตัวอย่าง

ตัวอย่างที่ใช้ในหน้านี้อิงตามตัวอย่าง Device Administration API ซึ่งรวมอยู่ในตัวอย่าง SDK (พร้อมใช้งานผ่าน Android SDK Manager) และอยู่ในระบบของคุณในรูปแบบ <sdk_root>/ApiDemos/app/src/main/java/com/example/android/apis/app/DeviceAdminSample.java

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

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

รูปที่ 1 ภาพหน้าจอของแอปตัวอย่าง

การพัฒนาแอปการดูแลระบบอุปกรณ์

ผู้ดูแลระบบสามารถใช้ Device Administration API เพื่อเขียนแอป ที่บังคับใช้นโยบายความปลอดภัยของอุปกรณ์จากระยะไกล/ในเครื่อง ส่วนนี้ สรุปขั้นตอนที่เกี่ยวข้องกับการสร้างแอป การดูแลระบบอุปกรณ์

การสร้างไฟล์ Manifest

หากต้องการใช้ Device Administration API แอปต้องมี ไฟล์ Manifest ดังต่อไปนี้

• คลาสย่อยของ DeviceAdminReceiver ซึ่งรวมถึงรายการต่อไปนี้
  • สิทธิ์ BIND_DEVICE_ADMIN
  • ความสามารถในการตอบสนองต่อ Intent ACTION_DEVICE_ADMIN_ENABLED ซึ่งแสดงในไฟล์ Manifest เป็นตัวกรอง Intent
• การประกาศนโยบายความปลอดภัยที่ใช้ในข้อมูลเมตา

ต่อไปนี้เป็นข้อความที่ตัดตอนมาจากไฟล์ Manifest ตัวอย่างการดูแลระบบอุปกรณ์

<activity android:name=".app.DeviceAdminSample"
            android:label="@string/activity_sample_device_admin">
    <intent-filter>
        <action android:name="android.intent.action.MAIN" />
        <category android:name="android.intent.category.SAMPLE_CODE" />
    </intent-filter>
</activity>
<receiver android:name=".app.DeviceAdminSample$DeviceAdminSampleReceiver"
        android:label="@string/sample_device_admin"
        android:description="@string/sample_device_admin_description"
        android:permission="android.permission.BIND_DEVICE_ADMIN">
    <meta-data android:name="android.app.device_admin"
            android:resource="@xml/device_admin_sample" />
    <intent-filter>
        <action android:name="android.app.action.DEVICE_ADMIN_ENABLED" />
    </intent-filter>
</receiver>

ข้อควรทราบ

• แอตทริบิวต์ต่อไปนี้อ้างอิงถึงทรัพยากรสตริงที่อยู่ใน ApiDemos/res/values/strings.xml สำหรับแอปตัวอย่าง ดูข้อมูลเพิ่มเติมเกี่ยวกับทรัพยากรได้ที่ ทรัพยากรของแอปพลิเคชัน
  • android:label="@string/activity_sample_device_admin" หมายถึงป้ายกำกับที่ผู้ใช้สามารถอ่านได้สำหรับกิจกรรม
  • android:label="@string/sample_device_admin" หมายถึง ป้ายกำกับที่ผู้ใช้สามารถอ่านได้สำหรับสิทธิ์
  • android:description="@string/sample_device_admin_description" หมายถึง คำอธิบายสิทธิ์ที่ผู้ใช้อ่านได้ โดยปกติแล้ว คำอธิบายจะยาวกว่าและให้ข้อมูลมากกว่าป้ายกำกับ
• android:permission="android.permission.BIND_DEVICE_ADMIN" เป็นสิทธิ์ที่คลาสย่อย DeviceAdminReceiver ต้องมีเพื่อให้แน่ใจว่ามีเพียงระบบเท่านั้นที่โต้ตอบกับตัวรับได้ (ไม่มีแอปใดได้รับสิทธิ์นี้) ซึ่งจะ ป้องกันไม่ให้แอปอื่นๆ ละเมิดแอปผู้ดูแลระบบอุปกรณ์
• android.app.action.DEVICE_ADMIN_ENABLED เป็นการดำเนินการหลักที่คลาสย่อย DeviceAdminReceiver ต้องจัดการเพื่อให้ได้รับอนุญาตในการจัดการอุปกรณ์ ระบบจะตั้งค่านี้เป็นตัวรับเมื่อผู้ใช้เปิดใช้แอปผู้ดูแลระบบอุปกรณ์ โดยปกติแล้วโค้ดของคุณจะจัดการเรื่องนี้ใน onEnabled() หากต้องการให้ระบบรองรับ ผู้รับจะต้อง กำหนดให้ต้องมีสิทธิ์ BIND_DEVICE_ADMIN ด้วย เพื่อไม่ให้แอปอื่นๆ นำไปใช้ในทางที่ผิด
• เมื่อผู้ใช้เปิดใช้แอปผู้ดูแลระบบอุปกรณ์ จะเป็นการให้สิทธิ์ผู้รับ ในการดำเนินการเพื่อตอบสนองต่อการออกอากาศของเหตุการณ์ระบบ ที่เฉพาะเจาะจง เมื่อเกิดเหตุการณ์ที่เหมาะสม แอปจะบังคับใช้นโยบายได้ ตัวอย่างเช่น หากผู้ใช้พยายามตั้งรหัสผ่านใหม่ที่ไม่เป็นไปตามข้อกำหนดของนโยบาย แอปจะแจ้งให้ผู้ใช้เลือกรหัสผ่านอื่นที่เป็นไปตามข้อกำหนดได้
• หลีกเลี่ยงการเปลี่ยนชื่อตัวรับหลังจากเผยแพร่แอปแล้ว หากชื่อในไฟล์ manifest มีการเปลี่ยนแปลง ระบบจะปิดใช้ผู้ดูแลระบบอุปกรณ์เมื่อผู้ใช้อัปเดตแอป ดูข้อมูลเพิ่มเติมได้ที่ <receiver>
• android:resource="@xml/device_admin_sample" ประกาศนโยบายความปลอดภัยที่ใช้ในข้อมูลเมตา ข้อมูลเมตาจะให้ข้อมูลเพิ่มเติม ที่เฉพาะเจาะจงสำหรับผู้ดูแลระบบอุปกรณ์ตามที่DeviceAdminInfo คลาสแยกวิเคราะห์ เนื้อหาของ device_admin_sample.xml มีดังนี้

<device-admin xmlns:android="http://schemas.android.com/apk/res/android">
  <uses-policies>
    <limit-password />
    <watch-login />
    <reset-password />
    <force-lock />
    <wipe-data />
    <expire-password />
    <encrypted-storage />
    <disable-camera />
  </uses-policies>
</device-admin>

เมื่อออกแบบแอปการดูแลระบบอุปกรณ์ คุณไม่จำเป็นต้อง รวมนโยบายทั้งหมด เพียงแค่รวมนโยบายที่เกี่ยวข้องกับแอปของคุณ

การใช้โค้ด

Device Administration API มีคลาสต่อไปนี้

DeviceAdminReceiver

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

DevicePolicyManager

คลาสสำหรับการจัดการนโยบายที่บังคับใช้ในอุปกรณ์ ไคลเอ็นต์ส่วนใหญ่ของ คลาสนี้ต้องเผยแพร่ DeviceAdminReceiver ที่ผู้ใช้ เปิดใช้อยู่ในปัจจุบัน DevicePolicyManager จัดการนโยบายสำหรับ อินสแตนซ์ DeviceAdminReceiver อย่างน้อย 1 รายการ

DeviceAdminInfo

คลาสนี้ใช้เพื่อระบุข้อมูลเมตา สำหรับคอมโพเนนต์ผู้ดูแลระบบอุปกรณ์

คลาสเหล่านี้เป็นรากฐานของแอปการดูแลระบบอุปกรณ์ที่ทำงานได้อย่างเต็มที่ ส่วนที่เหลือของส่วนนี้จะอธิบายวิธีใช้ API DeviceAdminReceiver และ DevicePolicyManager เพื่อเขียนแอปผู้ดูแลระบบอุปกรณ์

การสร้างคลาสย่อยของ DeviceAdminReceiver

หากต้องการสร้างแอปผู้ดูแลระบบอุปกรณ์ คุณต้องสร้างคลาสย่อยของ DeviceAdminReceiver DeviceAdminReceiver คลาส ประกอบด้วยชุดการเรียกกลับที่ทริกเกอร์เมื่อเกิดเหตุการณ์ที่เฉพาะเจาะจง

ในDeviceAdminReceiverคลาสย่อยของคลาสนี้ แอปตัวอย่าง จะแสดงToastการแจ้งเตือนเพื่อตอบสนองต่อเหตุการณ์ที่เฉพาะเจาะจง เช่น

class DeviceAdminSample : DeviceAdminReceiver() {

    private fun showToast(context: Context, msg: String) {
        context.getString(R.string.admin_receiver_status, msg).let { status ->
            Toast.makeText(context, status, Toast.LENGTH_SHORT).show()
        }
    }

    override fun onEnabled(context: Context, intent: Intent) =
            showToast(context, context.getString(R.string.admin_receiver_status_enabled))

    override fun onDisableRequested(context: Context, intent: Intent): CharSequence =
            context.getString(R.string.admin_receiver_status_disable_warning)

    override fun onDisabled(context: Context, intent: Intent) =
            showToast(context, context.getString(R.string.admin_receiver_status_disabled))

    override fun onPasswordChanged(context: Context, intent: Intent, userHandle: UserHandle) =
            showToast(context, context.getString(R.string.admin_receiver_status_pw_changed))
...
}

public class DeviceAdminSample extends DeviceAdminReceiver {

    void showToast(Context context, String msg) {
        String status = context.getString(R.string.admin_receiver_status, msg);
        Toast.makeText(context, status, Toast.LENGTH_SHORT).show();
    }

    @Override
    public void onEnabled(Context context, Intent intent) {
        showToast(context, context.getString(R.string.admin_receiver_status_enabled));
    }

    @Override
    public CharSequence onDisableRequested(Context context, Intent intent) {
        return context.getString(R.string.admin_receiver_status_disable_warning);
    }

    @Override
    public void onDisabled(Context context, Intent intent) {
        showToast(context, context.getString(R.string.admin_receiver_status_disabled));
    }

    @Override
    public void onPasswordChanged(Context context, Intent intent, UserHandle userHandle) {
        showToast(context, context.getString(R.string.admin_receiver_status_pw_changed));
    }
...
}

การเปิดใช้แอป

เหตุการณ์สำคัญอย่างหนึ่งที่แอปผู้ดูแลระบบอุปกรณ์ต้องจัดการคือการที่ผู้ใช้ เปิดใช้แอป ผู้ใช้ต้องเปิดใช้แอปอย่างชัดเจน จึงจะบังคับใช้นโยบายได้ หากผู้ใช้เลือกที่จะไม่เปิดใช้แอป แอปจะยังคงอยู่ในอุปกรณ์ แต่จะไม่มีการบังคับใช้นโยบายของแอป และผู้ใช้จะไม่ได้รับสิทธิประโยชน์ใดๆ จากแอป

กระบวนการเปิดใช้แอปจะเริ่มต้นเมื่อผู้ใช้ดำเนินการที่ทริกเกอร์ Intent ของ ACTION_ADD_DEVICE_ADMIN ใน แอปตัวอย่าง เหตุการณ์นี้จะเกิดขึ้นเมื่อผู้ใช้คลิกช่องทำเครื่องหมายเปิดใช้ ผู้ดูแลระบบ

เมื่อผู้ใช้คลิกช่องทําเครื่องหมายเปิดใช้ผู้ดูแลระบบ จอแสดงผลจะเปลี่ยนไปแจ้งให้ผู้ใช้เปิดใช้งานแอปผู้ดูแลระบบอุปกรณ์ ดังที่แสดงในรูปที่ 2

รูปที่ 2 แอปตัวอย่าง: การเปิดใช้งานแอป

ด้านล่างนี้คือโค้ดที่จะดำเนินการเมื่อผู้ใช้คลิกช่องทําเครื่องหมายเปิดใช้ผู้ดูแลระบบ ซึ่งจะทริกเกอร์ onPreferenceChange() การเรียกกลับ ระบบจะเรียกใช้การเรียกกลับนี้เมื่อผู้ใช้เปลี่ยนค่าของ Preference นี้ และกำลังจะตั้งค่าและ/หรือบันทึกค่า หากผู้ใช้เปิดใช้แอป จอแสดงผลจะเปลี่ยนไปแจ้งให้ผู้ใช้เปิดใช้งานแอปผู้ดูแลระบบในอุปกรณ์ ดังที่แสดงในรูปที่ 2 มิเช่นนั้น ระบบจะปิดใช้แอปผู้ดูแลระบบอุปกรณ์

override fun onPreferenceChange(preference: Preference, newValue: Any): Boolean {
    if (super.onPreferenceChange(preference, newValue)) return true
    val value = newValue as Boolean
    if (preference == enableCheckbox) {
        if (value != adminActive) {
            if (value) {
                // Launch the activity to have the user enable our admin.
                val intent = Intent(DevicePolicyManager.ACTION_ADD_DEVICE_ADMIN).apply {
                    putExtra(DevicePolicyManager.EXTRA_DEVICE_ADMIN, deviceAdminSample)
                    putExtra(DevicePolicyManager.EXTRA_ADD_EXPLANATION,
                            activity.getString(R.string.add_admin_extra_app_text))
                }
                startActivityForResult(intent, REQUEST_CODE_ENABLE_ADMIN)
                // return false - don't update checkbox until we're really active
                return false
            } else {
                dpm.removeActiveAdmin(deviceAdminSample)
                enableDeviceCapabilitiesArea(false)
                adminActive = false
            }
        }
    } else if (preference == disableCameraCheckbox) {
        dpm.setCameraDisabled(deviceAdminSample, value)
    }
    return true
}

@Override
public boolean onPreferenceChange(Preference preference, Object newValue) {
    if (super.onPreferenceChange(preference, newValue)) {
        return true;
    }
    boolean value = (Boolean) newValue;
    if (preference == enableCheckbox) {
        if (value != adminActive) {
            if (value) {
                // Launch the activity to have the user enable our admin.
                Intent intent = new Intent(DevicePolicyManager.ACTION_ADD_DEVICE_ADMIN);
                intent.putExtra(DevicePolicyManager.EXTRA_DEVICE_ADMIN, deviceAdminSample);
                intent.putExtra(DevicePolicyManager.EXTRA_ADD_EXPLANATION,
                        activity.getString(R.string.add_admin_extra_app_text));
                startActivityForResult(intent, REQUEST_CODE_ENABLE_ADMIN);
                // return false - don't update checkbox until we're really active
                return false;
            } else {
                dpm.removeActiveAdmin(deviceAdminSample);
                enableDeviceCapabilitiesArea(false);
                adminActive = false;
            }
        }
    } else if (preference == disableCameraCheckbox) {
        dpm.setCameraDisabled(deviceAdminSample, value);
    }
    return true;
}

บรรทัด intent.putExtra(DevicePolicyManager.EXTRA_DEVICE_ADMIN, mDeviceAdminSample) ระบุว่า mDeviceAdminSample (ซึ่งเป็นคอมโพเนนต์ DeviceAdminReceiver) เป็นนโยบายเป้าหมาย บรรทัดนี้จะเรียกใช้อินเทอร์เฟซผู้ใช้ที่แสดงในรูปที่ 2 ซึ่งจะแนะนำผู้ใช้ในการ เพิ่มผู้ดูแลระบบอุปกรณ์ลงในระบบ (หรืออนุญาตให้ปฏิเสธ)

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

private lateinit var dpm: DevicePolicyManager
...
private fun isActiveAdmin(): Boolean = dpm.isAdminActive(deviceAdminSample)

DevicePolicyManager dpm;
...
private boolean isActiveAdmin() {
    return dpm.isAdminActive(deviceAdminSample);
}

การจัดการนโยบาย

DevicePolicyManager เป็นคลาสสาธารณะสำหรับการจัดการนโยบาย ที่บังคับใช้ในอุปกรณ์ DevicePolicyManager จัดการนโยบายสำหรับอินสแตนซ์ DeviceAdminReceiver อย่างน้อย 1 รายการ

คุณจะได้รับแฮนเดิลของ DevicePolicyManager ดังนี้

dpm = getSystemService(Context.DEVICE_POLICY_SERVICE) as DevicePolicyManager

DevicePolicyManager dpm =
    (DevicePolicyManager)getSystemService(Context.DEVICE_POLICY_SERVICE);

ส่วนนี้จะอธิบายวิธีใช้ DevicePolicyManager เพื่อทำงานด้านการดูแลระบบ ดังนี้

• กำหนดนโยบายรหัสผ่าน
• ตั้งค่าการล็อกอุปกรณ์
• ล้างข้อมูล

ตั้งค่านโยบายรหัสผ่าน

DevicePolicyManager มี API สำหรับการตั้งค่าและบังคับใช้นโยบายรหัสผ่านของอุปกรณ์ ใน Device Administration API รหัสผ่านจะมีผลกับการล็อกหน้าจอเท่านั้น ส่วนนี้จะอธิบายงานที่เกี่ยวข้องกับรหัสผ่านที่พบบ่อย

ตั้งรหัสผ่านสำหรับอุปกรณ์

โค้ดนี้จะแสดงอินเทอร์เฟซผู้ใช้ที่แจ้งให้ผู้ใช้ตั้งรหัสผ่าน

Intent(DevicePolicyManager.ACTION_SET_NEW_PASSWORD).also { intent ->
    startActivity(intent)
}

Intent intent = new Intent(DevicePolicyManager.ACTION_SET_NEW_PASSWORD);
startActivity(intent);

ตั้งค่าคุณภาพรหัสผ่าน

คุณภาพของรหัสผ่านอาจเป็นค่าคงที่ DevicePolicyManager ค่าใดค่าหนึ่งต่อไปนี้

PASSWORD_QUALITY_ALPHABETIC

ผู้ใช้ต้องป้อน รหัสผ่านที่มีอักขระที่เป็นตัวอักษร (หรือสัญลักษณ์อื่นๆ) อย่างน้อย 1 ตัว

PASSWORD_QUALITY_ALPHANUMERIC

ผู้ใช้ต้องป้อนรหัสผ่านที่มีอักขระที่เป็นตัวเลขและตัวอักษร (หรือสัญลักษณ์อื่นๆ) ทั้ง 2 อย่างอย่างน้อย 1 ตัว

PASSWORD_QUALITY_NUMERIC

ผู้ใช้ต้องป้อนรหัสผ่าน ที่มีอักขระที่เป็นตัวเลขอย่างน้อย 1 ตัว

PASSWORD_QUALITY_COMPLEX

ผู้ใช้ ต้องป้อนรหัสผ่านที่มีตัวอักษร ตัวเลข และ สัญลักษณ์พิเศษอย่างน้อย 1 ตัว

PASSWORD_QUALITY_SOMETHING

นโยบายกำหนดให้ต้องมีรหัสผ่านบางประเภท แต่ไม่ได้กำหนดว่าต้องเป็นรหัสผ่านใด

PASSWORD_QUALITY_UNSPECIFIED

นโยบายไม่มีข้อกำหนดสำหรับรหัสผ่าน

ตัวอย่างเช่น วิธีตั้งค่านโยบายรหัสผ่านให้กำหนดรหัสผ่านที่เป็นตัวอักษรและตัวเลขคละกันมีดังนี้

private lateinit var dpm: DevicePolicyManager
private lateinit var deviceAdminSample: ComponentName
...
dpm.setPasswordQuality(deviceAdminSample, DevicePolicyManager.PASSWORD_QUALITY_ALPHANUMERIC)

DevicePolicyManager dpm;
ComponentName deviceAdminSample;
...
dpm.setPasswordQuality(deviceAdminSample, DevicePolicyManager.PASSWORD_QUALITY_ALPHANUMERIC);

ตั้งข้อกำหนดเนื้อหาของรหัสผ่าน

ตั้งแต่ Android 3.0 เป็นต้นมา DevicePolicyManager คลาส มีเมธอดที่ช่วยให้คุณปรับแต่งเนื้อหาของรหัสผ่านได้ ตัวอย่างเช่น คุณอาจตั้งนโยบายที่ระบุว่ารหัสผ่านต้องมีตัวอักษรพิมพ์ใหญ่อย่างน้อย n ตัว วิธีปรับแต่งเนื้อหาของรหัสผ่านมีดังนี้

• setPasswordMinimumLetters()
• setPasswordMinimumLowerCase()
• setPasswordMinimumUpperCase()
• setPasswordMinimumNonLetter()
• setPasswordMinimumNumeric()
• setPasswordMinimumSymbols()

เช่น ข้อมูลโค้ดนี้ระบุว่ารหัสผ่านต้องมีตัวอักษรพิมพ์ใหญ่อย่างน้อย 2 ตัว

private lateinit var dpm: DevicePolicyManager
private lateinit var deviceAdminSample: ComponentName
private val pwMinUppercase = 2
...
dpm.setPasswordMinimumUpperCase(deviceAdminSample, pwMinUppercase)

DevicePolicyManager dpm;
ComponentName deviceAdminSample;
int pwMinUppercase = 2;
...
dpm.setPasswordMinimumUpperCase(deviceAdminSample, pwMinUppercase);

ตั้งค่าความยาวขั้นต่ำของรหัสผ่าน

คุณระบุได้ว่ารหัสผ่านต้องมีความยาวอย่างน้อยตามความยาวขั้นต่ำที่ระบุ เช่น

private lateinit var dpm: DevicePolicyManager
private lateinit var deviceAdminSample: ComponentName
private val pwLength: Int = ...
...
dpm.setPasswordMinimumLength(deviceAdminSample, pwLength)

DevicePolicyManager dpm;
ComponentName deviceAdminSample;
int pwLength;
...
dpm.setPasswordMinimumLength(deviceAdminSample, pwLength);

กำหนดจำนวนครั้งที่ป้อนรหัสผ่านไม่ถูกต้องสูงสุด

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

val dPM:DevicePolicyManager
private lateinit var dpm: DevicePolicyManager
private lateinit var deviceAdminSample: ComponentName
private val maxFailedPw: Int = ...
...
dpm.setMaximumFailedPasswordsForWipe(deviceAdminSample, maxFailedPw)

DevicePolicyManager dpm;
ComponentName deviceAdminSample;
int maxFailedPw;
 ...
dpm.setMaximumFailedPasswordsForWipe(deviceAdminSample, maxFailedPw);

ตั้งค่าระยะหมดเวลาของรหัสผ่าน

ตั้งแต่ Android 3.0 เป็นต้นไป คุณสามารถใช้เมธอด setPasswordExpirationTimeout() เพื่อกำหนดเวลาที่รหัสผ่านจะหมดอายุได้ โดยแสดงเป็นส่วนต่างในหน่วยมิลลิวินาทีจากเวลาที่ผู้ดูแลระบบอุปกรณ์ตั้งค่าระยะหมดเวลาการหมดอายุ เช่น

private lateinit var dpm: DevicePolicyManager
private lateinit var deviceAdminSample: ComponentName
private val pwExpiration: Long = ...
...
dpm.setPasswordExpirationTimeout(deviceAdminSample, pwExpiration)

DevicePolicyManager dpm;
ComponentName deviceAdminSample;
long pwExpiration;
...
dpm.setPasswordExpirationTimeout(deviceAdminSample, pwExpiration);

จำกัดรหัสผ่านตามประวัติ

ตั้งแต่ Android 3.0 เป็นต้นไป คุณสามารถใช้วิธี setPasswordHistoryLength() เพื่อจำกัดความสามารถของผู้ใช้ ในการใช้รหัสผ่านเดิมซ้ำ เมธอดนี้ใช้พารามิเตอร์ความยาว ซึ่งระบุจำนวนรหัสผ่านเก่า ที่จัดเก็บ เมื่อนโยบายนี้มีผล ผู้ใช้จะป้อนรหัสผ่านใหม่ที่ตรงกับรหัสผ่าน n รายการล่าสุดไม่ได้ ซึ่งจะช่วยป้องกันไม่ให้ ผู้ใช้ใช้รหัสผ่านเดียวกันซ้ำๆ โดยปกติแล้ว นโยบายนี้จะใช้ร่วมกับ setPasswordExpirationTimeout() ซึ่งบังคับให้ผู้ใช้ อัปเดตรหัสผ่านหลังจากผ่านไประยะเวลาหนึ่ง

ตัวอย่างเช่น ข้อมูลโค้ดนี้จะห้ามไม่ให้ผู้ใช้นำรหัสผ่าน 5 ครั้งล่าสุดกลับมาใช้อีก

private lateinit var dpm: DevicePolicyManager
private lateinit var deviceAdminSample: ComponentName
private val pwHistoryLength = 5
...
dpm.setPasswordHistoryLength(deviceAdminSample, pwHistoryLength)

DevicePolicyManager dpm;
ComponentName deviceAdminSample;
int pwHistoryLength = 5;
...
dpm.setPasswordHistoryLength(deviceAdminSample, pwHistoryLength);

ตั้งค่าการล็อกอุปกรณ์

คุณสามารถกำหนดระยะเวลาสูงสุดที่ผู้ใช้ไม่มีการใช้งานก่อนที่อุปกรณ์จะล็อกได้ เช่น

private lateinit var dpm: DevicePolicyManager
private lateinit var deviceAdminSample: ComponentName
private val timeMs: Long = 1000L * timeout.text.toString().toLong()
...
dpm.setMaximumTimeToLock(deviceAdminSample, timeMs)

DevicePolicyManager dpm;
ComponentName deviceAdminSample;
...
long timeMs = 1000L*Long.parseLong(timeout.getText().toString());
dpm.setMaximumTimeToLock(deviceAdminSample, timeMs);

นอกจากนี้ คุณยังตั้งโปรแกรมให้อุปกรณ์ล็อกทันทีได้ด้วย

private lateinit var dpm: DevicePolicyManager
dpm.lockNow()

DevicePolicyManager dpm;
dpm.lockNow();

ล้างข้อมูล

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

คุณล้างข้อมูลได้ดังนี้

private lateinit var dpm: DevicePolicyManager
dpm.wipeData(0)

DevicePolicyManager dpm;
dpm.wipeData(0);

เมธอด wipeData() ใช้พารามิเตอร์เป็นบิตมาสก์ของตัวเลือกเพิ่มเติม ปัจจุบันค่าต้องเป็น 0

ปิดใช้กล้อง

คุณปิดใช้กล้องได้ตั้งแต่ Android 4.0 เป็นต้นไป โปรดทราบว่าคุณไม่จำเป็นต้องปิดใช้ถาวร คุณเปิด/ปิดใช้กล้องแบบไดนามิกได้ตามบริบท เวลา และอื่นๆ

คุณควบคุมได้ว่าจะปิดใช้กล้องหรือไม่โดยใช้วิธี setCameraDisabled() เช่น ข้อมูลโค้ดนี้จะตั้งค่าให้เปิดหรือปิดใช้กล้องตามการตั้งค่าช่องทำเครื่องหมาย

private lateinit var disableCameraCheckbox: CheckBoxPreference
private lateinit var dpm: DevicePolicyManager
private lateinit var deviceAdminSample: ComponentName
...
dpm.setCameraDisabled(deviceAdminSample, mDisableCameraCheckbox.isChecked)

private CheckBoxPreference disableCameraCheckbox;
DevicePolicyManager dpm;
ComponentName deviceAdminSample;
...
dpm.setCameraDisabled(deviceAdminSample, mDisableCameraCheckbox.isChecked());

การเข้ารหัสพื้นที่เก็บข้อมูล

ตั้งแต่ Android 3.0 เป็นต้นไป คุณสามารถใช้เมธอด setStorageEncryption() เพื่อตั้งค่านโยบายที่กำหนดให้เข้ารหัสพื้นที่เก็บข้อมูลได้ในกรณีที่ระบบรองรับ

เช่น

private lateinit var dpm: DevicePolicyManager
private lateinit var deviceAdminSample: ComponentName
...
dpm.setStorageEncryption(deviceAdminSample, true)

DevicePolicyManager dpm;
ComponentName deviceAdminSample;
...
dpm.setStorageEncryption(deviceAdminSample, true);

ดูตัวอย่าง Device Administration API เพื่อดูตัวอย่างที่สมบูรณ์เกี่ยวกับวิธีเปิดใช้การเข้ารหัสพื้นที่เก็บข้อมูล

ตัวอย่างโค้ดเพิ่มเติม

ตัวอย่าง Android AppRestrictionEnforcer และ DeviceOwner แสดงให้เห็นถึงการใช้ API ที่กล่าวถึงในหน้านี้เพิ่มเติม