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

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

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

แป้นพิมพ์

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

การไปยังรายการต่างๆ

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

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

Kotlin

yourView.isFocusable = true

Java

yourView.setFocusable(true);

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

android:focusable="true"

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

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

Kotlin

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

Java

// 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) เช่น EditText แอปควรทํางานตามที่คาดไว้บนอุปกรณ์หน้าจอขนาดใหญ่โดยไม่ต้องมีการพัฒนาเพิ่มเติม สําหรับการกดแป้นพิมพ์ที่เฟรมเวิร์กคาดการณ์ไม่ได้ แอปจะต้องจัดการลักษณะการทํางานด้วยตนเอง โดยเฉพาะอย่างยิ่งสำหรับแอปที่มีมุมมองที่กำหนดเอง

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

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

Kotlin

override fun onKeyUp(keyCode: Int, event: KeyEvent): Boolean {
    return when (keyCode) {
        KeyEvent.KEYCODE_ENTER -> {
            sendChatMessage()
            true
        }
        KeyEvent.KEYCODE_SPACE -> {
            playOrPauseMedia()
            true
        }
        else -> super.onKeyUp(keyCode, event)
    }
}

Java

@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 ซ้ำได้เอง

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

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

ทางลัด

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

หมายเหตุ: ในแป้นพิมพ์ macOS แป้น Meta คือแป้น Command ในแป้นพิมพ์ Windows คือแป้น Windows ในแป้นพิมพ์ ChromeOS คือแป้นค้นหา

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

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

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

• KeyEvent.hasModifiers()

Kotlin

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

Java

@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 หมายถึง "วิ่งไปข้างหน้า"

Kotlin

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

Java

@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 ครั้งต่อเฟรม ปากกาสไตลัสสามารถรายงานเหตุการณ์ได้บ่อยกว่าจอแสดงผล เมื่อสร้างแอปวาดภาพ ให้ตรวจสอบเหตุการณ์ที่อาจเกิดขึ้นในช่วงที่ผ่านมาโดยใช้ getHistorical API ต่อไปนี้

• 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 แต่จะไม่ตั้งค่า Flag ใน Android เวอร์ชันที่ต่ำกว่า

Android 12

ใน Android 12 (API ระดับ 32) และต่ำกว่า การตรวจจับการปฏิเสธฝ่ามือจะเป็นไปได้สำหรับเหตุการณ์การแตะด้วยปลายนิ้วเพียงนิ้วเดียวเท่านั้น หากการสัมผัสด้วยฝ่ามือเป็นเคอร์เซอร์เพียงอย่างเดียว ระบบจะยกเลิกเหตุการณ์โดยการตั้งค่า 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 เพื่อดูว่าเหตุการณ์บ่งบอกถึงการปฏิเสธฝ่ามือ (หรือการยกเลิกเหตุการณ์อื่นๆ) หรือไม่

หมายเหตุ: วิธีหนึ่งในการป้องกันการแตะด้วยฝ่ามือและนิ้วที่ไม่ต้องการในแอปที่เปิดใช้สไตลัสคือการระบุตัวควบคุม UI ที่เปิดใช้งานโหมดการวาด การเขียน หรือโหมดอินเทอร์แอกทีฟซึ่งปิดใช้เหตุการณ์การแตะและรองรับเฉพาะเหตุการณ์ของสไตลัสเท่านั้น

แอปการจดบันทึก

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:// แอปควรสร้างโน้ตที่ใช้รูปภาพที่แนบมารูปแรกเป็นภาพพื้นหลังและเข้าสู่โหมดที่ผู้ใช้วาดบนหน้าจอด้วยสไตลัสได้

ทดสอบความตั้งใจในการจดบันทึกโดยไม่ต้องใช้สไตลัส

[TBD remove section.]

หากต้องการทดสอบว่าแอปตอบสนองต่อความตั้งใจในการจดบันทึกโดยไม่ใช้ปากกาสไตลัสแบบมีแบตเตอรี่อย่างถูกต้องหรือไม่ ให้ใช้วิธีต่อไปนี้เพื่อแสดงตัวเลือกการจดบันทึกใน 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. ออกจากระบบแล้วลงชื่อเข้าใช้อีกครั้ง

ตอนนี้เมนูสไตลัสควรอยู่บนชั้นวางแล้ว

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

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

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

คลิกขวา

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

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

Kotlin

yourView.setOnContextClickListener {
    showContextMenu()
    true
}

Java

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

หมายเหตุ: มุมมองที่ลงทะเบียนไว้สำหรับเมนูบริบทโดยใช้ Activity.registerForContextMenu() ควรทำงานร่วมกับทั้งการแตะค้างไว้และการคลิกขวาโดยอัตโนมัติโดยไม่ต้องลงทะเบียนตัวรับฟังการคลิกบริบท

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

วางเมาส์

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

Kotlin

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

Java

// 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 ใน ChromeOS - การใช้การลากและวาง

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

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

• รายการต้องมี Flag 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 นิ้วบนทัชแพด การเลื่อนด้วยเม้าส์ และการแมปพิกัดการแสดงผลดิบกับพิกัดของหน้าต่างโดยอัตโนมัติ โดยทั่วไปแล้ว นักพัฒนาแอปไม่จำเป็นต้องใช้ลักษณะการทำงานเหล่านี้ด้วยตนเอง

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

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

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

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