ความเข้ากันได้ของอินพุตบนหน้าจอขนาดใหญ่

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

• ทดสอบการรองรับแป้นพิมพ์พื้นฐาน เช่น Ctrl+Z สำหรับเลิกทำ Ctrl+C สำหรับคัดลอก และ Ctrl+S สำหรับบันทึก ดูรายการแป้นพิมพ์ลัดเริ่มต้นได้ที่ จัดการการดำเนินการของแป้นพิมพ์
• ทดสอบการรองรับแป้นพิมพ์ขั้นสูง เช่น การนำทางด้วยแป้นพิมพ์โดยใช้แป้น Tab และ แป้นลูกศร การยืนยันการป้อนข้อความด้วยแป้น Enter และการเล่นและหยุดชั่วคราวในแอปสื่อด้วย แป้นเว้นวรรค
• ทดสอบการโต้ตอบพื้นฐานของเมาส์ ซึ่งรวมถึงการคลิกขวาเพื่อเปิดเมนูตามบริบท การเปลี่ยนแปลงไอคอนเมื่อวางเมาส์ และเหตุการณ์การเลื่อนล้อของเมาส์หรือแทร็กแพดในคอมโพเนนต์ที่กำหนดเอง
• ทดสอบอุปกรณ์อินพุตเฉพาะแอป เช่น สไตลัส ตัวควบคุมเกม และตัวควบคุม MIDI ของแอปเพลง
• พิจารณาการรองรับอินพุตขั้นสูง ที่อาจทำให้แอปโดดเด่นในสภาพแวดล้อมเดสก์ท็อป เช่น แทร็กแพดเป็นครอสเฟดเดอร์สำหรับแอป DJ การจับเมาส์สำหรับเกม และแป้นพิมพ์ลัดสำหรับผู้ใช้ที่เน้นการใช้แป้นพิมพ์

แป้นพิมพ์

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

การนำทาง

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

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

yourView.isFocusable = true

yourView.setFocusable(true);

หรือจะตั้งค่าแอตทริบิวต์ focusable ในไฟล์เลย์เอาต์ก็ได้

android:focusable="true"

ดูข้อมูลเพิ่มเติมได้ที่การจัดการการโฟกัส

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

// Arrow keys
yourView.nextFocusLeftId = R.id.view_to_left
yourView.nextFocusRightId = R.id.view_to_right
yourView.nextFocusTopId = R.id.view_above
yourView.nextFocusBottomId = R.id.view_below
// Tab key
yourView.nextFocusForwardId = R.id.next_view

// Arrow keys
yourView.setNextFocusLeftId(R.id.view_to_left);
yourView.setNextFocusRightId(R.id.view_to_left);
yourView.setNextFocusTopId(R.id.view_to_left);
yourView.setNextFocusBottomId(R.id.view_to_left);
// Tab key
yourView.setNextFocusForwardId(R.id.next_view);

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

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

การกดแป้นพิมพ์

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

ตัวอย่างเช่น แอปแชทที่ใช้แป้น Enter เพื่อส่งข้อความ แอปสื่อที่เริ่มและหยุดการเล่นด้วย แป้นเว้นวรรค และเกม ที่ควบคุมการเคลื่อนไหวด้วยแป้น w, a, s และ d

แอปส่วนใหญ่จะลบล้างการเรียกกลับ onKeyUp() และเพิ่มลักษณะการทำงานที่คาดไว้ สำหรับรหัสแป้นแต่ละรายการที่ได้รับ

@Override
public boolean onKeyUp(int keyCode, KeyEvent event) {
    if (keyCode == KeyEvent.KEYCODE_ENTER) {
        sendMessage();
        return true;
    } else if (KeyEvent.KEYCODE_SPACE){
        playOrPauseMedia();
        return true;
    } else {
        return super.onKeyUp(keyCode, event);
    }
}

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

ดูข้อมูลเพิ่มเติมได้ที่จัดการการดำเนินการของแป้นพิมพ์

แป้นพิมพ์ลัด

ผู้ใช้คาดหวังว่าจะได้ใช้แป้นพิมพ์ลัดทั่วไปที่มีแป้น Ctrl, Alt, Shift และ Meta เมื่อใช้แป้นพิมพ์ฮาร์ดแวร์ หากแอปไม่ได้ใช้แป้นพิมพ์ลัด ผู้ใช้อาจรู้สึกหงุดหงิด นอกจากนี้ ผู้ใช้ขั้นสูงยังชื่นชอบแป้นพิมพ์ลัดสำหรับงานเฉพาะแอปที่ใช้บ่อย แป้นพิมพ์ลัดทำให้แอปใช้งานง่ายขึ้นและแตกต่างจากแอปที่ไม่มีแป้นพิมพ์ลัด

แป้นพิมพ์ลัดทั่วไปบางรายการ ได้แก่ Ctrl+S (บันทึก) Ctrl+Z (เลิกทำ) และ Ctrl+Shift+Z (ทำซ้ำ) ดูรายการแป้นพิมพ์ลัดเริ่มต้นได้ที่ จัดการการดำเนินการของแป้นพิมพ์

คุณเปิดใช้แป้นพิมพ์ลัดได้โดยใช้ dispatchKeyShortcutEvent() เพื่อ สกัดกั้นการผสมแป้นทั้งหมด (Alt, Ctrl, Shift และ Meta) สำหรับรหัสแป้นที่กำหนด หากต้องการตรวจสอบแป้นกดร่วมที่เฉพาะเจาะจง ให้ใช้คำสั่งต่อไปนี้

• KeyEvent.isCtrlPressed(),
• KeyEvent.isShiftPressed(),
• KeyEvent.isAltPressed(),
• KeyEvent.isMetaPressed()หรือ

• KeyEvent.hasModifiers()

override fun dispatchKeyShortcutEvent(event: KeyEvent): Boolean {
  return when (event.keyCode) {
    KeyEvent.KEYCODE_O -> {
      openFile() // Ctrl+O, Shift+O, Alt+O
      true
    }
    KeyEvent.KEYCODE_Z-> {
      if (event.isCtrlPressed) {
        if (event.isShiftPressed) {
          redoLastAction() // Ctrl+Shift+Z pressed
          true
        } else {
          undoLastAction() // Ctrl+Z pressed
          true
        }
      }
    }
    else -> {
      return super.dispatchKeyShortcutEvent(event)
    }
  }
}

@Override
public boolean dispatchKeyShortcutEvent(KeyEvent event) {
  if (event.getKeyCode() == KeyEvent.KEYCODE_O) {
      openFile(); // Ctrl+O, Shift+O, Alt+O
      return true;
  } else if(event.getKeyCode() == KeyEvent.KEYCODE_Z) {
      if (event.isCtrlPressed()) {
          if (event.isShiftPressed()) {
              redoLastAction();
              return true;
          }
          else {
              undoLastAction();
              return true;
          }
      }
  }
  return super.dispatchKeyShortcutEvent(event);
}

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

อย่างไรก็ตาม คุณยังใช้แป้นพิมพ์ลัดใน onKeyUp() ได้ด้วยการตรวจสอบ KeyEvent.isCtrlPressed(), KeyEvent.isShiftPressed() หรือ KeyEvent.isAltPressed() วิธีนี้อาจดูแลรักษาง่ายกว่าหากลักษณะการทำงานของแป้นที่ปรับเปลี่ยนเป็นการเปลี่ยนแปลงลักษณะการทำงานของแอปมากกว่าแป้นพิมพ์ลัด ตัวอย่างเช่น ใน เกมที่ W หมายถึง "เดินไปข้างหน้า" และ Shift+W หมายถึง "วิ่ง ไปข้างหน้า"

override fun onKeyUp(keyCode: Int, event: KeyEvent): Boolean {
  return when(keyCode) {
    KeyEvent.KEYCODE_W-> {
      if (event.isShiftPressed) {
        if (event.isCtrlPressed) {
          flyForward() // Ctrl+Shift+W pressed
          true
        } else {
          runForward() // Shift+W pressed
          true
        }
      } else {
        walkForward() // W pressed
        true
      }
    }
    else -> super.onKeyUp(keyCode, event)
  }
}

@Override
public boolean onKeyUp(int keyCode, KeyEvent event) {
    if (keyCode == KeyEvent.KEYCODE_W) {
        if (event.isShiftPressed()) {
            if (event.isCtrlPressed()) {
                flyForward(); // Ctrl+Shift+W pressed
                return true;
            } else {
                runForward(); // Shift+W pressed
                return true;
            }
        } else {
            walkForward();
            return true;
        }
    }
    return super.onKeyUp(keyCode, event);
}

ดูตัวช่วยแป้นพิมพ์ลัดด้วย

สไตลัส

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

ระบบจะรายงานเหตุการณ์สไตลัสเป็นเหตุการณ์หน้าจอสัมผัสโดย View#onTouchEvent() หรือ View#onGenericMotionEvent() และมี MotionEvent#getSource() ประเภท SOURCE_STYLUS

ออบเจ็กต์ MotionEvent มีข้อมูลเกี่ยวกับเหตุการณ์ ดังนี้

• MotionEvent#getToolType() จะแสดง TOOL_TYPE_FINGER, TOOL_TYPE_STYLUS หรือ TOOL_TYPE_ERASER ขึ้นอยู่กับเครื่องมือที่ สัมผัสจอแสดงผล
• MotionEvent#getPressure() จะรายงานแรงกดทางกายภาพที่ใช้กับปากกาสไตลัส (หากรองรับ)
• MotionEvent#getAxisValue() ที่มี MotionEvent.AXIS_TILT และ MotionEvent.AXIS_ORIENTATION จะแสดงการเอียงและการวางแนวทางกายภาพ ของสไตลัส (หากรองรับ)

จุดประวัติ

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

• MotionEvent#getHistoricalX()
• MotionEvent#getHistoricalY()
• MotionEvent#getHistoricalPressure()
• MotionEvent#getHistoricalAxisValue()

การปฏิเสธการสัมผัสด้วยฝ่ามือ

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

Android จะยกเลิกเหตุการณ์การสัมผัสด้วยฝ่ามือโดยส่ง MotionEvent หากแอปได้รับ ACTION_CANCEL ให้ยกเลิกท่าทางสัมผัส หากแอปได้รับ ACTION_POINTER_UP ให้ตรวจสอบว่าได้ตั้งค่า FLAG_CANCELED หรือไม่ หากตั้งค่าไว้ ให้ยกเลิกท่าทางสัมผัส

อย่าตรวจสอบเพียงแค่ FLAG_CANCELED ใน Android 13 (ระดับ API 33) ขึ้นไป ระบบจะตั้งค่า FLAG_CANCELED สำหรับเหตุการณ์ ACTION_CANCEL แต่ระบบจะไม่ตั้งค่าแฟล็กใน Android เวอร์ชันที่ต่ำกว่า

Android 12

ใน Android 12 (ระดับ API 32) ลงไป การตรวจหาการปฏิเสธการสัมผัสด้วยฝ่ามือจะทำได้เฉพาะเหตุการณ์การสัมผัสแบบตัวชี้เดียวเท่านั้น หากการสัมผัสด้วยฝ่ามือเป็น Pointer เดียว ระบบจะยกเลิกเหตุการณ์โดยตั้งค่า ACTION_CANCEL ในออบเจ็กต์เหตุการณ์การเคลื่อนไหว หากมีตัวชี้อื่นๆ อยู่ ระบบจะตั้งค่า ACTION_POINTER_UP ซึ่งไม่เพียงพอสำหรับการตรวจหาการปฏิเสธการสัมผัสด้วยฝ่ามือ

Android 13

ใน Android 13 (ระดับ API 33) ขึ้นไป หากการสัมผัสด้วยฝ่ามือเป็นตัวชี้เดียว ระบบจะยกเลิกเหตุการณ์โดยตั้งค่า ACTION_CANCEL และ FLAG_CANCELED ในออบเจ็กต์เหตุการณ์การเคลื่อนไหว หากมีตัวชี้อื่นๆ อยู่ ระบบจะตั้งค่า ACTION_POINTER_UP และ FLAG_CANCELED

เมื่อใดก็ตามที่แอปได้รับเหตุการณ์การเคลื่อนไหวที่มี ACTION_POINTER_UP ให้ตรวจสอบ FLAG_CANCELED เพื่อดูว่าเหตุการณ์นั้นบ่งบอกถึงการปฏิเสธการสัมผัสด้วยฝ่ามือ (หรือการยกเลิกเหตุการณ์อื่นๆ) หรือไม่

แอปจดบันทึก

ChromeOS มี Intent พิเศษที่แสดงแอปจดบันทึกที่ลงทะเบียนไว้ต่อผู้ใช้ หากต้องการลงทะเบียนแอปเป็นแอปจดบันทึก ให้เพิ่มโค้ดต่อไปนี้ลงในไฟล์ Manifest ของแอป

<intent-filter>
    <action android:name="org.chromium.arc.intent.action.CREATE_NOTE" />
    <category android:name="android.intent.category.DEFAULT" />
</intent-filter>

เมื่อลงทะเบียนแอปกับระบบแล้ว ผู้ใช้จะเลือกแอปดังกล่าวเป็นแอปจดบันทึกเริ่มต้นได้ เมื่อมีการขอโน้ตใหม่ แอปควรสร้างโน้ตเปล่าที่พร้อมรับอินพุตจากสไตลัส เมื่อผู้ใช้ต้องการใส่คำอธิบายประกอบในรูปภาพ (เช่น ภาพหน้าจอหรือรูปภาพที่ดาวน์โหลด) แอปจะเปิดขึ้นพร้อมกับ ClipData ที่มีรายการอย่างน้อย 1 รายการที่มี URI content:// แอปควรสร้างโน้ตที่ใช้รูปภาพแรกที่แนบเป็นรูปภาพพื้นหลังและเข้าสู่โหมดที่ผู้ใช้สามารถวาดบนหน้าจอด้วยสไตลัสได้

ทดสอบ Intent การจดบันทึกโดยไม่มีสไตลัส

หากต้องการทดสอบว่าแอปตอบสนองต่อ Intent การจดบันทึกอย่างถูกต้องโดยไม่มีสไตลัสที่ใช้งานอยู่หรือไม่ ให้ใช้วิธีต่อไปนี้เพื่อแสดงตัวเลือกการจดบันทึกใน ChromeOS

1. เปลี่ยนเป็นโหมดนักพัฒนาซอฟต์แวร์และทำให้อุปกรณ์เขียนได้
2. กด Ctrl+Alt+F2 เพื่อเปิดเทอร์มินัล
3. เรียกใช้คำสั่ง sudo vi /etc/chrome_dev.conf
4. กด i เพื่อแก้ไขและเพิ่ม --ash-enable-palette ลงในบรรทัดใหม่ที่ส่วนท้ายของ ไฟล์
5. บันทึกโดยกด Esc แล้วพิมพ์ :, w, q และกด Enter
6. กด Ctrl+Alt+F1 เพื่อกลับไปที่ UI ปกติของ ChromeOS
7. ออกจากระบบแล้วเข้าสู่ระบบอีกครั้ง

ตอนนี้เมนูสไตลัสควรปรากฏใน Shelf แล้ว

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

การรองรับเมาส์และทัชแพด

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

คลิกขวา

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

หากต้องการจัดการเหตุการณ์การคลิกขวา แอปควรลงทะเบียน a View.OnContextClickListener ดังนี้

yourView.setOnContextClickListener {
    showContextMenu()
    true
}

yourView.setOnContextClickListener(v -> {
    showContextMenu();
    return true;
});

ดูรายละเอียดเกี่ยวกับการสร้างเมนูตามบริบทได้ที่สร้างเมนูตามบริบท

วางเหนือ

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

// Change the icon to a "hand" pointer on hover.
// Highlight the view by changing the background.
yourView.setOnHoverListener { view, _ ->
    addVisualHighlighting(true)
    view.pointerIcon =
        PointerIcon.getSystemIcon(view.context, PointerIcon.TYPE_HAND)
    true // Listener consumes the event.
}

// Change the icon to a "hand" pointer on hover.
// Highlight the view by changing the background.
yourView.setOnHoverListener((view, event) -> {
    addVisualHighlighting(true);
    view.setPointerIcon(
        PointerIcon.getSystemIcon(view.getContext(), PointerIcon.TYPE_HAND)
    );
    return true; // Listener consumes the event.
});

ตัวอย่างที่พบบ่อยที่สุด 2 ตัวอย่าง ได้แก่

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

ลากและวาง

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

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

หากต้องการเพิ่มการรองรับการลากและวาง โปรดดูที่ เปิดใช้การลากและวาง และอ่านโพสต์ในบล็อก Android on ChromeOS — Implementing Drag & Drop

ข้อควรพิจารณาพิเศษสำหรับ ChromeOS

• อย่าลืมขอสิทธิ์ด้วย requestDragAndDropPermissions() เพื่อ เข้าถึงรายการที่ลากจากภายนอกแอป

• รายการต้องมีแฟล็ก View.DRAG_FLAG_GLOBAL จึงจะ ลากไปยังแอปพลิเคชันอื่นๆ ได้

การรองรับตัวชี้ขั้นสูง

แอปที่จัดการอินพุตจากเมาส์และทัชแพดขั้นสูงควรใช้ตัวปรับแต่ง View#onGenericMotionEvent() และใช้ [MotionEvent.getSource()][] เพื่อ แยกความแตกต่างระหว่าง SOURCE_MOUSE กับ SOURCE_TOUCHSCREEN

ตรวจสอบออบเจ็กต์ MotionEvent เพื่อใช้ลักษณะการทำงานที่จำเป็น ดังนี้

• การเคลื่อนไหวจะสร้างเหตุการณ์ ACTION_HOVER_MOVE
• ปุ่มจะสร้างเหตุการณ์ ACTION_BUTTON_PRESS และ ACTION_BUTTON_RELEASE นอกจากนี้ คุณยังตรวจสอบสถานะปัจจุบันของปุ่มเมาส์และแทร็กแพดทั้งหมดได้โดยใช้ getButtonState()
• การเลื่อนล้อของเมาส์จะสร้างเหตุการณ์ ACTION_SCROLL

ตัวควบคุมเกม

อุปกรณ์ Android หน้าจอขนาดใหญ่บางเครื่องรองรับตัวควบคุมเกมสูงสุด 4 ตัว ใช้ API ตัวควบคุมเกมมาตรฐานของ Android เพื่อจัดการเกมคอนโทรลเลอร์ (ดูการรองรับเกมคอนโทรลเลอร์)

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

โหมดการแปลอินพุต

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

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

<uses-feature
    android:name="android.hardware.type.pc"
    android:required="false" />

แหล่งข้อมูลเพิ่มเติม

• ความเข้ากันได้ของอินพุตใน ChromeOS