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

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

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

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

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

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

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

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

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

ผู้ผลิตอุปกรณ์ 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 การดูแลระบบอุปกรณ์รองรับ

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

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

นอกจากจะรองรับนโยบายที่ระบุไว้ในตารางด้านบนแล้ว 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>

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

ดูการอภิปรายเพิ่มเติมเกี่ยวกับไฟล์ Manifest ได้ในคู่มือสำหรับนักพัฒนาแอป Android

การใช้โค้ด

API การดูแลระบบอุปกรณ์มีคลาสต่อไปนี้

DeviceAdminReceiver

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

DevicePolicyManager

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

DeviceAdminInfo

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

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

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

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

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

Kotlin

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

Java

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() Callback ระบบจะเรียกใช้แฮนเดิลนี้เมื่อผู้ใช้เปลี่ยนค่าของ Preference นี้ และกำลังจะตั้งค่าและ/หรือบันทึกค่า หากผู้ใช้เปิดใช้แอป จอแสดงผลจะเปลี่ยนไปแจ้งให้ผู้ใช้เปิดใช้งานแอปผู้ดูแลระบบในอุปกรณ์ ดังที่แสดงในรูปที่ 2 มิเช่นนั้น ระบบจะปิดใช้แอปผู้ดูแลระบบอุปกรณ์

Kotlin

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
}

Java

@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 คอมโพเนนต์เป็นอาร์กิวเมนต์

Kotlin

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

Java

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

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

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

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

Kotlin

dpm = getSystemService(Context.DEVICE_POLICY_SERVICE) as DevicePolicyManager

Java

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

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

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

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

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

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

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

Kotlin

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

Java

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

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

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

PASSWORD_QUALITY_ALPHABETIC

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

PASSWORD_QUALITY_ALPHANUMERIC

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

PASSWORD_QUALITY_NUMERIC

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

PASSWORD_QUALITY_COMPLEX

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

PASSWORD_QUALITY_SOMETHING

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

PASSWORD_QUALITY_UNSPECIFIED

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

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

Kotlin

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

Java

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

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

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

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

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

Kotlin

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

Java

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

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

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

Kotlin

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

Java

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

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

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

Kotlin

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

Java

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

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

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

Kotlin

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

Java

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

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

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

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

Kotlin

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

Java

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

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

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

Kotlin

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

Java

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

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

Kotlin

private lateinit var dpm: DevicePolicyManager
dpm.lockNow()

Java

DevicePolicyManager dpm;
dpm.lockNow();

ล้างข้อมูล

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

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

Kotlin

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

Java

DevicePolicyManager dpm;
dpm.wipeData(0);

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

ปิดใช้กล้อง

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

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

Kotlin

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

Java

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

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

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

เช่น

Kotlin

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

Java

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

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

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

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