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

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

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

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

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

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

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

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

ใช้บริบทของกิจกรรมสำหรับมุมมอง

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

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

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

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

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

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

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

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

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

• หากคุณใช้มุมมองเดียวสำหรับวันที่หมดอายุ ให้ใช้ AUTOFILL_HINT_CREDIT_CARD_EXPIRATION_DATE
• หากใช้มุมมองที่แตกต่างกันสำหรับแต่ละส่วนของวันที่หมดอายุ คุณสามารถใช้ AUTOFILL_HINT_CREDIT_CARD_EXPIRATION_DAY, AUTOFILL_HINT_CREDIT_CARD_EXPIRATION_MONTH และ AUTOFILL_HINT_CREDIT_CARD_EXPIRATION_YEAR สำหรับแต่ละมุมมองที่เกี่ยวข้องได้

ที่อยู่จริง

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

• สำหรับที่อยู่ในมุมมองเดียว ให้ใช้ AUTOFILL_HINT_POSTAL_ADDRESS
• เมื่อใช้มุมมองแยกกันสำหรับส่วนต่างๆ ของที่อยู่ คุณจะใช้สิ่งต่อไปนี้ได้
  • AUTOFILL_HINT_POSTAL_ADDRESS_STREET_ADDRESS
  • AUTOFILL_HINT_POSTAL_ADDRESS_EXTENDED_ADDRESS
  • AUTOFILL_HINT_POSTAL_ADDRESS_LOCALITY
  • AUTOFILL_HINT_POSTAL_ADDRESS_REGION
  • AUTOFILL_HINT_POSTAL_ADDRESS_COUNTRY
  • AUTOFILL_HINT_POSTAL_CODE
  • AUTOFILL_HINT_POSTAL_ADDRESS_EXTENDED_POSTAL_CODE

ชื่อบุคคล

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

• หากต้องการป้อนชื่อเต็มของบุคคลโดยอัตโนมัติในมุมมองเดียว ให้ใช้ AUTOFILL_HINT_PERSON_NAME
• หากใช้มุมมองแยกต่างหากสำหรับส่วนต่างๆ ของชื่อ คุณสามารถใช้ตัวเลือกใดก็ได้ต่อไปนี้
  • AUTOFILL_HINT_PERSON_NAME_PREFIX
  • AUTOFILL_HINT_PERSON_NAME_GIVEN
  • AUTOFILL_HINT_PERSON_NAME_MIDDLE
  • AUTOFILL_HINT_PERSON_NAME_MIDDLE_INITIAL
  • AUTOFILL_HINT_PERSON_NAME_FAMILY
  • AUTOFILL_HINT_PERSON_NAME_SUFFIX

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

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

• เมื่อขอหมายเลขโทรศัพท์แบบเต็มในมุมมองเดียว ให้ใช้ AUTOFILL_HINT_PHONE_NUMBER
• หากใช้มุมมองแยกต่างหากสำหรับส่วนต่างๆ ของหมายเลขโทรศัพท์ คุณสามารถใช้มุมมองใดก็ได้ต่อไปนี้
  • AUTOFILL_HINT_PHONE_COUNTRY_CODE
  • AUTOFILL_HINT_PHONE_NATIONAL
  • AUTOFILL_HINT_PHONE_NUMBER_DEVICE

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

สำหรับรหัสผ่านแบบใช้ครั้งเดียวในมุมมองเดียว คุณสามารถใช้ AUTOFILL_HINT_SMS_OTP ได้

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    structure.setDataIsSensitive(false)
}

@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

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

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

@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 ที่แอปของคุณใช้กับมุมมองเสมือนได้ สถานะที่ใช้ได้จะกำหนดเป็นค่าคงที่ใน Callback

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

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

    }
})

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

เมื่อถึงเวลาที่จะนำ Callback ออก ให้ใช้เมธอด unregisterCallback()

ปรับแต่ง 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 เพื่อจำลองปัญหานี้ได้ด้วย

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

คอนเทนเนอร์ที่รีไซเคิลมุมมอง เช่น คลาส 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()

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

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

}

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

}

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

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

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. แตะชุดข้อมูลที่มีข้อมูลที่ต้องการใช้ มุมมองจะแสดงข้อมูลที่จัดเก็บไว้ในบริการก่อนหน้านี้

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

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