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

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

การใช้โค้ด

Device Administration 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 อย่าง

PASSWORD_QUALITY_NUMERIC

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

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 ที่กล่าวถึงในหน้านี้เพิ่มเติม