เพิ่มประสิทธิภาพแอปสำหรับการป้อนข้อความอัตโนมัติ

แอปที่ใช้มุมมองมาตรฐานจะทำงานร่วมกับเฟรมเวิร์กการป้อนข้อความอัตโนมัติได้โดยไม่ต้องมีการกำหนดค่าพิเศษ นอกจากนี้ คุณยังเพิ่มประสิทธิภาพการทำงานของแอปกับ เฟรมเวิร์กได้ด้วย

ตั้งค่าสภาพแวดล้อมการป้อนอัตโนมัติ

ส่วนนี้อธิบายวิธีตั้งค่าฟังก์ชันการเติมข้อความอัตโนมัติพื้นฐานสำหรับแอป

กำหนดค่าบริการป้อนข้อความอัตโนมัติ

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

หลังจากติดตั้งบริการป้อนข้อความอัตโนมัติทดสอบจากแอปตัวอย่างแล้ว ให้เปิดใช้บริการป้อนข้อความอัตโนมัติโดยไปที่การตั้งค่า > ระบบ > ภาษาและการป้อนข้อมูล > ขั้นสูง > ความช่วยเหลือในการป้อนข้อมูล > บริการป้อนข้อความอัตโนมัติ

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

ให้คำแนะนำสำหรับการป้อนข้อความอัตโนมัติ

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

คุณตั้งค่าคำแนะนำในการป้อนข้อความอัตโนมัติได้โดยใช้แอตทริบิวต์ android:autofillHints ตัวอย่างต่อไปนี้จะตั้งค่าคำใบ้ "password" ใน EditText 

<EditText
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:autofillHints="password" />

นอกจากนี้ คุณยังตั้งค่าคำแนะนำแบบเป็นโปรแกรมได้โดยใช้เมธอด setAutofillHints() ดังตัวอย่างต่อไปนี้

Kotlin

val password = findViewById<EditText>(R.id.password)
password.setAutofillHints(View.AUTOFILL_HINT_PASSWORD)

Java

EditText password = findViewById(R.id.password);
password.setAutofillHints(View.AUTOFILL_HINT_PASSWORD);

รวมค่าคงที่คำใบ้ที่กำหนดไว้ล่วงหน้า

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

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

ข้อมูลเข้าสู่ระบบของบัญชี

ในแบบฟอร์มการเข้าสู่ระบบ คุณสามารถใส่คำแนะนำสำหรับข้อมูลเข้าสู่ระบบของบัญชี เช่น AUTOFILL_HINT_USERNAME และ AUTOFILL_HINT_PASSWORD

หากต้องการสร้างบัญชีใหม่ หรือเมื่อผู้ใช้เปลี่ยนชื่อผู้ใช้และรหัสผ่าน คุณสามารถใช้ AUTOFILL_HINT_NEW_USERNAME และ AUTOFILL_HINT_NEW_PASSWORD

ข้อมูลบัตรเครดิต

เมื่อขอข้อมูลบัตรเครดิต คุณสามารถใช้คำใบ้ เช่น AUTOFILL_HINT_CREDIT_CARD_NUMBER และ AUTOFILL_HINT_CREDIT_CARD_SECURITY_CODE

สำหรับวันที่บัตรเครดิตหมดอายุ ให้ทำอย่างใดอย่างหนึ่งต่อไปนี้

ที่อยู่จริง

สำหรับช่องแบบฟอร์มที่อยู่จริง คุณสามารถใช้คำแนะนำต่อไปนี้ได้

ชื่อบุคคล

เมื่อขอชื่อบุคคล คุณสามารถใช้คำใบ้ต่อไปนี้

หมายเลขโทรศัพท์

สำหรับหมายเลขโทรศัพท์ คุณใช้ข้อมูลต่อไปนี้ได้

รหัสผ่านที่สามารถใช้งานได้เพียงครั้งเดียว (OTP)

หากต้องการใช้รหัสผ่านที่สามารถใช้งานได้เพียงครั้งเดียวในมุมมองเดียว คุณสามารถใช้ AUTOFILL_HINT_SMS_OTP

สำหรับหลายๆ มุมมองที่แต่ละมุมมองแมปกับตัวเลขเดียวของ OTP คุณสามารถใช้วิธี generateSmsOtpHintForCharacterPosition() เพื่อสร้างคำใบ้ต่ออักขระได้

เชื่อมโยงข้อมูลเว็บไซต์และแอปบนอุปกรณ์เคลื่อนที่

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

หากต้องการเชื่อมโยงแอป Android กับเว็บไซต์ ให้โฮสต์ Digital Asset Link ที่มี delegate_permission/common.get_login_creds relation ในเว็บไซต์ จากนั้น ประกาศการเชื่อมโยงในไฟล์ AndroidManifest.xml ของแอป ดูวิธีการเชื่อมโยงเว็บไซต์กับแอป Android แบบละเอียดได้ที่เปิดใช้การลงชื่อเข้าใช้โดยอัตโนมัติในแอปและเว็บไซต์

ทําเวิร์กโฟลว์การป้อนข้อความอัตโนมัติให้เสร็จสมบูรณ์

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

พิจารณาว่าเปิดใช้การป้อนข้อความอัตโนมัติหรือไม่

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

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

หากต้องการให้ประสบการณ์การลงชื่อสมัครใช้และเข้าสู่ระบบได้รับการเพิ่มประสิทธิภาพสำหรับผู้ใช้ที่ไม่ได้ใช้การป้อนข้อความอัตโนมัติ ให้ใช้การลงชื่อเข้าใช้ด้วย One Tap

บังคับคำขอป้อนข้อความอัตโนมัติ

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

Kotlin

fun eventHandler(view: View) {
    val afm = requireContext().getSystemService(AutofillManager::class.java)
    afm?.requestAutofill(view)
}

Java

public void eventHandler(View view) {
    AutofillManager afm = context.getSystemService(AutofillManager.class);
    if (afm != null) {
        afm.requestAutofill(view);
    }
}

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

ใช้ประเภทการป้อนข้อความอัตโนมัติที่ถูกต้องสำหรับข้อมูลในการควบคุมเครื่องมือเลือก

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

ออบเจ็กต์ EditText คาดหวังข้อมูลการป้อนข้อความอัตโนมัติประเภท AUTOFILL_TYPE_TEXT โดยค่าเริ่มต้น หากใช้ข้อมูลประเภทอื่น ให้สร้างมุมมองที่กําหนดเองซึ่งรับค่าจาก EditText และใช้เมธอดที่จําเป็นในการจัดการข้อมูลประเภทที่เกี่ยวข้อง เช่น หากคุณมีช่องวันที่ ให้ใช้วิธีการที่มี ตรรกะที่จัดการค่าประเภท AUTOFILL_TYPE_DATE ได้อย่างถูกต้อง

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

ป้อนข้อความอัตโนมัติให้เสร็จสมบูรณ์

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

การรองรับมุมมองที่กำหนดเอง

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

หากแอปใช้มุมมองที่กําหนดเอง ให้พิจารณาสถานการณ์ต่อไปนี้

  • มุมมองที่กำหนดเองมีโครงสร้างมุมมองมาตรฐานหรือโครงสร้างมุมมองเริ่มต้น
  • มุมมองที่กำหนดเองมีโครงสร้างเสมือนหรือโครงสร้างมุมมองที่เฟรมเวิร์กการป้อนข้อความอัตโนมัติไม่สามารถเข้าถึงได้

มุมมองที่กำหนดเองที่มีโครงสร้างมุมมองมาตรฐาน

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

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

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

มุมมองต้องระบุประเภทและค่าการป้อนข้อความอัตโนมัติโดยการลบล้างเมธอด getAutofillType() และ getAutofillValue() ตามลำดับ

สุดท้ายนี้ การป้อนข้อความอัตโนมัติต้องไม่ป้อนข้อมูลในมุมมองหากผู้ใช้ระบุค่าสำหรับ มุมมองในสถานะปัจจุบันไม่ได้ เช่น หากปิดใช้มุมมอง ในกรณีเหล่านี้ getAutofillType() ต้องแสดงผล AUTOFILL_TYPE_NONE getAutofillValue() ต้องแสดงผล null และ autofill() ไม่ต้องดำเนินการใดๆ

ในกรณีต่อไปนี้ คุณจะต้องทำตามขั้นตอนเพิ่มเติมเพื่อให้ทำงานได้อย่างถูกต้องภายใน เฟรมเวิร์ก

  • คุณแก้ไขมุมมองที่กำหนดเองได้
  • มุมมองที่กำหนดเองมีข้อมูลที่ละเอียดอ่อน

มุมมองที่กำหนดเองแก้ไขได้

หากแก้ไขมุมมองได้ ให้แจ้งเฟรมเวิร์กการป้อนข้อความอัตโนมัติเกี่ยวกับการเปลี่ยนแปลง โดยเรียกใช้ notifyValueChanged() ในออบเจ็กต์ AutofillManager

มุมมองที่กำหนดเองมีข้อมูลที่ละเอียดอ่อน

หากมุมมองมีข้อมูลส่วนบุคคลที่ระบุตัวบุคคลนั้นได้ (PII) เช่น อีเมล หมายเลขบัตรเครดิต และรหัสผ่าน คุณต้องทํามาร์กว่ามีความละเอียดอ่อน

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

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

หากต้องการทำเครื่องหมายว่ามุมมองมีข้อมูลที่ละเอียดอ่อนหรือไม่ ให้ใช้ onProvideAutofillStructure() และเรียกใช้ setDataIsSensitive() ในออบเจ็กต์ ViewStructure

ตัวอย่างโค้ดต่อไปนี้แสดงวิธีทําเครื่องหมายข้อมูลในโครงสร้างมุมมองเป็น ไม่ละเอียดอ่อน

Kotlin

override fun onProvideAutofillStructure(structure: ViewStructure, flags: Int) {
    super.onProvideAutofillStructure(structure, flags)

    structure.setDataIsSensitive(false)
}

Java

@Override
public void onProvideAutofillStructure(ViewStructure structure, int flags) {
    super.onProvideAutofillStructure(structure, flags);

    structure.setDataIsSensitive(false);
}

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

มุมมองที่ใช้อะแดปเตอร์ เช่น Spinner ก็เป็นกรณีที่คล้ายกัน ตัวอย่างเช่น สปินเนอร์ที่แสดงปีที่สร้างแบบไดนามิกตามปีปัจจุบัน เพื่อใช้ในช่องวันหมดอายุของบัตรเครดิตสามารถ ใช้เมธอด getAutofillOptions() ของอินเทอร์เฟซ Adapter เพื่อแสดงรายการปี ได้

มุมมองที่ใช้ ArrayAdapter ยังระบุรายการค่าได้ด้วย ArrayAdapter จะตั้งค่าตัวเลือกการป้อนข้อความอัตโนมัติสำหรับทรัพยากรแบบคงที่โดยอัตโนมัติ หากระบุค่าแบบไดนามิก ให้ลบล้าง getAutofillOptions()

มุมมองที่กำหนดเองที่มีโครงสร้างเสมือน

เฟรมเวิร์กการป้อนอัตโนมัติต้องมีโครงสร้างมุมมองก่อนจึงจะแก้ไขและบันทึก ข้อมูลใน UI ของแอปได้ เฟรมเวิร์กจะใช้โครงสร้างมุมมองไม่ได้ในกรณีต่อไปนี้

  • แอปใช้เครื่องมือการแสดงผลระดับต่ำ เช่น OpenGL เพื่อแสดงผล UI
  • แอปใช้อินสแตนซ์ของ Canvas เพื่อวาด UI

ในกรณีเหล่านี้ คุณสามารถระบุโครงสร้างมุมมองได้โดยการติดตั้งใช้งาน onProvideAutofillVirtualStructure() และทำตามขั้นตอนต่อไปนี้

  1. เพิ่มจำนวนองค์ประกอบย่อยของโครงสร้างมุมมองโดยเรียกใช้ addChildCount()
  2. เพิ่มบุตรหลานโดยการโทรไปที่ newChild()
  3. ตั้งค่ารหัสการป้อนข้อความอัตโนมัติสำหรับองค์กรย่อยโดยเรียกใช้ setAutofillId()
  4. ตั้งค่าพร็อพเพอร์ตี้ที่เกี่ยวข้อง เช่น ค่าและการป้อนข้อความอัตโนมัติ
  5. หากข้อมูลในบุตรหลานเสมือนเป็นข้อมูลที่ละเอียดอ่อน ให้ส่ง true ไปยัง setDataIsSensitive() มิฉะนั้น ให้ส่ง false

ข้อมูลโค้ดต่อไปนี้แสดงวิธีสร้างองค์ประกอบย่อยใหม่ในโครงสร้างเสมือน

Kotlin

override fun onProvideAutofillVirtualStructure(structure: ViewStructure, flags: Int) {

    super.onProvideAutofillVirtualStructure(structure, flags)

    // Create a new child in the virtual structure.
    structure.addChildCount(1)
    val child = structure.newChild(childIndex)

    // Set the autofill ID for the child.
    child.setAutofillId(structure.autofillId!!, childVirtualId)

    // Populate the child by providing properties such as value and type.
    child.setAutofillValue(childAutofillValue)
    child.setAutofillType(childAutofillType)

    // Some children can provide a list of values, such as when the child is
    // a spinner.
    val childAutofillOptions = arrayOf<CharSequence>("option1", "option2")
    child.setAutofillOptions(childAutofillOptions)

    // Just like other types of views, mark the data as sensitive when
    // appropriate.
    val sensitive = !contentIsSetFromResources()
    child.setDataIsSensitive(sensitive)
}

Java

@Override
public void onProvideAutofillVirtualStructure(ViewStructure structure, int flags) {

    super.onProvideAutofillVirtualStructure(structure, flags);

    // Create a new child in the virtual structure.
    structure.addChildCount(1);
    ViewStructure child =
            structure.newChild(childIndex);

    // Set the autofill ID for the child.
    child.setAutofillId(structure.getAutofillId(), childVirtualId);

    // Populate the child by providing properties such as value and type.
    child.setAutofillValue(childAutofillValue);
    child.setAutofillType(childAutofillType);

    // Some children can provide a list of values, such as when the child is
    // a spinner.
    CharSequence childAutofillOptions[] = { "option1", "option2" };
    child.setAutofillOptions(childAutofillOptions);

    // Just like other types of views, mark the data as sensitive when
    // appropriate.
    boolean sensitive = !contentIsSetFromResources();
    child.setDataIsSensitive(sensitive);
}

เมื่อองค์ประกอบในโครงสร้างเสมือนมีการเปลี่ยนแปลง ให้แจ้งเฟรมเวิร์กโดย ทํางานต่อไปนี้

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

ใช้ Callback ในเหตุการณ์การป้อนข้อความอัตโนมัติ

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

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

คุณสามารถลงทะเบียนการเรียกกลับได้โดยใช้เมธอด registerCallback() ของคลาส AutofillManager ตัวอย่างโค้ดต่อไปนี้แสดง วิธีประกาศการเรียกกลับสำหรับเหตุการณ์การป้อนข้อความอัตโนมัติ

Kotlin

val afm = context.getSystemService(AutofillManager::class.java)

afm?.registerCallback(object : AutofillManager.AutofillCallback() {
    // For virtual structures, override
    // onAutofillEvent(View view, int childId, int event) instead.
    override fun onAutofillEvent(view: View, event: Int) {
        super.onAutofillEvent(view, event)
        when (event) {
            EVENT_INPUT_HIDDEN -> {
                // The autofill affordance associated with the view was hidden.
            }
            EVENT_INPUT_SHOWN -> {
                // The autofill affordance associated with the view was shown.
            }
            EVENT_INPUT_UNAVAILABLE -> {
                // Autofill isn't available.
            }
        }

    }
})

Java

AutofillManager afm = getContext().getSystemService(AutofillManager.class);

afm.registerCallback(new AutofillManager.AutofillCallback() {
    // For virtual structures, override
    // onAutofillEvent(View view, int childId, int event) instead.
    @Override
    public void onAutofillEvent(@NonNull View view, int event) {
        super.onAutofillEvent(view, event);
        switch (event) {
            case EVENT_INPUT_HIDDEN:
                // The autofill affordance associated with the view was hidden.
                break;
            case EVENT_INPUT_SHOWN:
                // The autofill affordance associated with the view was shown.
                break;
            case EVENT_INPUT_UNAVAILABLE:
                // Autofill isn't available.
                break;
        }
    }
});

เมื่อถึงเวลาที่จะนำการเรียกกลับออก ให้ใช้วิธี unregisterCallback()

ปรับแต่ง Drawable ที่ไฮไลต์การป้อนข้อความอัตโนมัติ

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

res/values/styles.xml

<resources>
    <style name="MyAutofilledHighlight" parent="...">
        <item name="android:autofilledHighlight">@drawable/my_drawable</item>
    </style>
</resources>

res/drawable/my_drawable.xml

<shape xmlns:android="http://schemas.android.com/apk/res/android">
    <solid android:color="#4DFF0000" />
</shape>

AndroidManifest.xml

<application ...
    android:theme="@style/MyAutofilledHighlight">
<!-- or -->
<activity ...
    android:theme="@style/MyAutofilledHighlight">

ตรวจสอบสิทธิ์สำหรับการป้อนข้อความอัตโนมัติ

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

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

คุณสามารถยืนยันลักษณะการทำงานของแอปเมื่อบริการป้อนข้อความอัตโนมัติต้องมีการ ตรวจสอบสิทธิ์ได้โดยใช้ HeuristicsService จากตัวอย่าง AutofillFramework และกำหนดค่าให้ต้องมีการตรวจสอบสิทธิ์การตอบกลับการป้อน นอกจากนี้ คุณยังใช้BadViewStructureCreationSignInActivity sample เพื่อจำลองปัญหานี้ได้ด้วย

กำหนดรหัสการป้อนข้อความอัตโนมัติให้กับมุมมองที่รีไซเคิล

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

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

หากต้องการแก้ปัญหานี้ในอุปกรณ์ที่ใช้ Android 9 (API ระดับ 28) ขึ้นไป ให้จัดการรหัสการป้อนข้อความอัตโนมัติของมุมมองที่ใช้โดย RecyclerView อย่างชัดเจนโดยใช้วิธีต่อไปนี้

  • เมธอด getNextAutofillId() จะรับรหัสการป้อนข้อความอัตโนมัติใหม่ที่ไม่ซ้ำกันสำหรับกิจกรรม
  • เมธอด setAutofillId() จะตั้งค่ารหัสการป้อนข้อความอัตโนมัติเชิงตรรกะที่ไม่ซ้ำกันของมุมมองนี้ ในกิจกรรม

แก้ไขปัญหาที่ทราบ

ส่วนนี้จะแสดงวิธีแก้ปัญหาเบื้องต้นสำหรับปัญหาที่ทราบภายในเฟรมเวิร์กการป้อนข้อความอัตโนมัติ

การป้อนข้อความอัตโนมัติทำให้แอปขัดข้องใน Android 8.0, 8.1

ใน Android 8.0 (API ระดับ 26) และ 8.1 (API ระดับ 27) การป้อนข้อความอัตโนมัติอาจทำให้แอปขัดข้องในบางสถานการณ์ หากต้องการหลีกเลี่ยงปัญหาที่อาจเกิดขึ้น ให้ติดแท็กการดูที่ไม่ได้กรอกข้อมูลอัตโนมัติด้วย importantForAutofill=no นอกจากนี้ คุณยังติดแท็ก กิจกรรมทั้งหมดด้วย importantForAutofill=noExcludeDescendants ได้ด้วย

ระบบจะไม่พิจารณากล่องโต้ตอบที่ปรับขนาดแล้วสำหรับการป้อนข้อความอัตโนมัติ

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

หากต้องการแก้ไขปัญหานี้ ให้แทนที่พร็อพเพอร์ตี้ token ของพารามิเตอร์กล่องโต้ตอบด้วยพร็อพเพอร์ตี้ token ของกิจกรรมที่สร้างกล่องโต้ตอบ หลังจากตรวจสอบว่าได้เปิดใช้การป้อนข้อความอัตโนมัติแล้ว ให้บันทึกพารามิเตอร์หน้าต่างในเมธอด onWindowAttributesChanged() ของคลาสที่รับค่ามาจาก Dialog จากนั้นแทนที่พร็อพเพอร์ตี้ token ของพารามิเตอร์ที่บันทึกไว้ด้วยพร็อพเพอร์ตี้ token ของกิจกรรมระดับบนในเมธอด onAttachedToWindow()

ข้อมูลโค้ดต่อไปนี้แสดงคลาสที่ใช้การแก้ปัญหานี้

Kotlin

class MyDialog(context: Context) : Dialog(context) {

    // Used to store the dialog window parameters.
    private var token: IBinder? = null

    private val isDialogResizedWorkaroundRequired: Boolean
        get() {
            if (Build.VERSION.SDK_INT != Build.VERSION_CODES.O || Build.VERSION.SDK_INT != Build.VERSION_CODES.O_MR1) {
                return false
            }
            val autofillManager = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
                context.getSystemService(AutofillManager::class.java)
            } else {
                null
            }
            return autofillManager?.isEnabled ?: false
        }

    override fun onWindowAttributesChanged(params: WindowManager.LayoutParams) {
        if (params.token == null && token != null) {
            params.token = token
        }

        super.onWindowAttributesChanged(params)
    }

    override fun onAttachedToWindow() {
        if (isDialogResizedWorkaroundRequired) {
            token = ownerActivity!!.window.attributes.token
        }

        super.onAttachedToWindow()
    }

}

Java

public class MyDialog extends Dialog {

    public MyDialog(Context context) {
        super(context);
    }

    // Used to store the dialog window parameters.
    private IBinder token;

    @Override
    public void onWindowAttributesChanged(WindowManager.LayoutParams params) {
        if (params.token == null && token != null) {
            params.token = token;
        }

        super.onWindowAttributesChanged(params);
    }

    @Override
    public void onAttachedToWindow() {
        if (isDialogResizedWorkaroundRequired()) {
            token = getOwnerActivity().getWindow().getAttributes().token;
        }

        super.onAttachedToWindow();
    }

    private boolean isDialogResizedWorkaroundRequired() {
        if (Build.VERSION.SDK_INT != Build.VERSION_CODES.O
                || Build.VERSION.SDK_INT != Build.VERSION_CODES.O_MR1) {
            return false;
        }
        AutofillManager autofillManager =
                null;
        if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.M) {
            autofillManager = getContext().getSystemService(AutofillManager.class);
        }
        return autofillManager != null && autofillManager.isEnabled();
    }

}

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

Kotlin

// AutofillExtensions.kt

fun Context.isDialogResizedWorkaroundRequired(): Boolean {
    // After the issue is resolved on Android, check whether the
    // workaround is still required for the current device.
    return isAutofillAvailable()
}

fun Context.isAutofillAvailable(): Boolean {
    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) {
        // The autofill framework is available on Android 8.0
        // or higher.
        return false
    }

    val afm = getSystemService(AutofillManager::class.java)
    // Return true if autofill is supported by the device and enabled
    // for the current user.
    return afm != null && afm.isEnabled
}

Java

public class AutofillHelper {

    public static boolean isDialogResizedWorkaroundRequired(Context context) {
        // After the issue is resolved on Android, check whether the
        // workaround is still required for the current device.
        return isAutofillAvailable(context);
    }

    public static boolean isAutofillAvailable(Context context) {
        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) {
            // The autofill framework is available on Android 8.0
            // or higher.
            return false;
        }

        AutofillManager afm = context.getSystemService(AutofillManager.class);
        // Return true if autofill is supported by the device and enabled
        // for the current user.
        return afm != null && afm.isEnabled();
    }
}

ทดสอบแอปด้วยการป้อนข้อความอัตโนมัติ

หลังจากเพิ่มประสิทธิภาพแอปให้ทำงานร่วมกับบริการป้อนข้อความอัตโนมัติแล้ว ให้ทดสอบว่าแอปทำงานร่วมกับบริการป้อนข้อความอัตโนมัติได้ตามที่ตั้งใจไว้หรือไม่

ใช้อีมูเลเตอร์หรืออุปกรณ์จริงที่ใช้ Android 8.0 (API ระดับ 26) ขึ้นไปเพื่อทดสอบแอป ดูข้อมูลเพิ่มเติมเกี่ยวกับวิธีสร้างอีมูเลเตอร์ได้ที่สร้างและจัดการอุปกรณ์เสมือน

ติดตั้งบริการป้อนข้อความอัตโนมัติ

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

คุณสามารถใช้ตัวอย่างเฟรมเวิร์กการป้อนข้อความอัตโนมัติของ Android ใน Java เพื่อทดสอบแอปกับบริการป้อนข้อความอัตโนมัติ แอปตัวอย่างมีบริการป้อนข้อความอัตโนมัติ และคลาสไคลเอ็นต์ Activity ที่คุณใช้ทดสอบเวิร์กโฟลว์ได้ ก่อนที่จะใช้กับแอปของคุณ หน้านี้อ้างอิงถึงแอปตัวอย่าง android-AutofillFramework

หลังจากติดตั้งแอปแล้ว ให้เปิดใช้บริการป้อนข้อความอัตโนมัติในการตั้งค่าระบบของโปรแกรมจำลองโดยไปที่การตั้งค่า > ระบบ > ภาษาและการป้อนข้อมูล > ขั้นสูง > ความช่วยเหลือในการป้อนข้อมูล > บริการป้อนข้อความอัตโนมัติ

วิเคราะห์ข้อกำหนดด้านข้อมูล

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

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

ทำการทดสอบ

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

บันทึกข้อมูลในบริการ

หากต้องการบันทึกข้อมูลในบริการป้อนข้อความอัตโนมัติที่ใช้งานอยู่ในปัจจุบัน ให้ทำดังนี้

  1. เปิดแอปที่มีมุมมองที่คาดหวังประเภทข้อมูลที่คุณต้องการใช้ ระหว่างการทดสอบ แอปตัวอย่าง android-AutofillFramework มี UI พร้อมมุมมองที่คาดหวังข้อมูลหลายประเภท เช่น หมายเลขบัตรเครดิตและ ชื่อผู้ใช้
  2. แตะมุมมองที่มีประเภทข้อมูลที่คุณต้องการ
  3. ป้อนค่าลงในมุมมอง
  4. แตะปุ่มยืนยัน เช่น ลงชื่อเข้าใช้หรือส่ง โดยปกติแล้ว คุณจะต้องส่งแบบฟอร์มก่อนที่บริการจะบันทึกข้อมูล
  5. ยืนยันคำขอสิทธิ์จากกล่องโต้ตอบของระบบ กล่องโต้ตอบของระบบจะแสดงชื่อของบริการที่ใช้งานอยู่และถามว่านี่คือบริการที่คุณต้องการใช้ในการทดสอบหรือไม่ หากต้องการใช้บริการ ให้แตะบันทึก

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

ทริกเกอร์การป้อนข้อความอัตโนมัติในแอป

หากต้องการเรียกใช้การป้อนข้อความอัตโนมัติในแอป ให้ทำดังนี้

  1. เปิดแอปแล้วไปที่กิจกรรมที่มีการดูที่คุณต้องการทดสอบ
  2. แตะมุมมองที่ต้องกรอกข้อมูล
  3. ระบบจะแสดง UI การป้อนข้อความอัตโนมัติซึ่งมีชุดข้อมูลที่ สามารถป้อนข้อมูลในมุมมองได้ ดังที่แสดงในรูปที่ 1
  4. แตะชุดข้อมูลที่มีข้อมูลที่ต้องการใช้ มุมมอง จะแสดงข้อมูลที่จัดเก็บไว้ก่อนหน้านี้ในบริการ
UI การป้อนข้อความอัตโนมัติแสดง "dataset-2" เป็นชุดข้อมูลที่ใช้ได้
รูปที่ 1 UI การป้อนข้อความอัตโนมัติแสดงชุดข้อมูลที่ใช้ได้

หาก Android ไม่แสดง UI การป้อนข้อความอัตโนมัติ คุณสามารถลองใช้ตัวเลือกการแก้ปัญหาต่อไปนี้

  • ตรวจสอบว่ามุมมองในแอปใช้ค่าที่ถูกต้องในแอตทริบิวต์ android:autofillHints ดูรายการค่าที่เป็นไปได้สำหรับแอตทริบิวต์ ได้ที่ค่าคงที่ที่ขึ้นต้นด้วย AUTOFILL_HINT ในคลาส View
  • ตรวจสอบว่าแอตทริบิวต์ android:importantForAutofill ตั้งค่าเป็นค่าอื่นที่ไม่ใช่ no ในมุมมองที่ต้องกรอก หรือตั้งค่าเป็นค่าอื่นที่ไม่ใช่ noExcludeDescendants ในมุมมองหรือมุมมองระดับบนสุด