Google ใช้เทคโนโลยี AI เพื่อแปลเนื้อหาเป็นภาษาที่คุณต้องการ การแปลโดย AI อาจมีข้อผิดพลาด

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

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

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

แป้นพิมพ์

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

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

สำหรับแอปจำนวนมาก เฟรมเวิร์ก Android จะจัดการการไปยังส่วนต่างๆ ด้วยปุ่มลูกศรและปุ่ม Tab โดยอัตโนมัติ ตัวอย่างเช่น 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

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

Kotlin

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 จะเกิดขึ้นเมื่อมีการปล่อยแป้น การใช้ Callback จะช่วยป้องกันไม่ให้แอปต้องประมวลผลเหตุการณ์ onKeyDown หลายรายการหากมีการกดปุ่มค้างไว้หรือปล่อยช้า เกมและแอปที่ต้องตรวจจับช่วงเวลาที่มีการกดแป้นหรือผู้ใช้กดแป้นค้างไว้หรือไม่สามารถฟังเหตุการณ์ onKeyDown และจัดการเหตุการณ์ onKeyDown ที่เกิดซ้ำได้ด้วยตนเอง

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

ทางลัด

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

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

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

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

การปฏิเสธการสัมผัสจากฝ่ามือ

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

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

เมนูสไตลัสควรจะอยู่บนแถบแล้ว:

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

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

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

คลิกขวา

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

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

Kotlin

yourView.setOnContextClickListener {
    showContextMenu()
    true
}

Java

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

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

วางเหนือ

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

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() เพื่อเข้าถึงรายการที่ลากเข้ามาจากภายนอกแอป
รายการต้องมีแฟล็ก 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