จัดการการทำงานของตัวควบคุม

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

fun getGameControllerIds(): List<Int> {     val gameControllerDeviceIds = mutableListOf<Int>()     val deviceIds = InputDevice.getDeviceIds()     deviceIds.forEach { deviceId ->         InputDevice.getDevice(deviceId).apply {              // Verify that the device has gamepad buttons, control sticks, or both.             if (sources and InputDevice.SOURCE_GAMEPAD == InputDevice.SOURCE_GAMEPAD                     || sources and InputDevice.SOURCE_JOYSTICK == InputDevice.SOURCE_JOYSTICK) {                 // This device is a game controller. Store its device ID.                 gameControllerDeviceIds                         .takeIf { !it.contains(deviceId) }                         ?.add(deviceId)             }         }     }     return gameControllerDeviceIds }

public ArrayList<Integer> getGameControllerIds() {     ArrayList<Integer> gameControllerDeviceIds = new ArrayList<Integer>();     int[] deviceIds = InputDevice.getDeviceIds();     for (int deviceId : deviceIds) {         InputDevice dev = InputDevice.getDevice(deviceId);         int sources = dev.getSources();          // Verify that the device has gamepad buttons, control sticks, or both.         if (((sources & InputDevice.SOURCE_GAMEPAD) == InputDevice.SOURCE_GAMEPAD)                 || ((sources & InputDevice.SOURCE_JOYSTICK)                 == InputDevice.SOURCE_JOYSTICK)) {             // This device is a game controller. Store its device ID.             if (!gameControllerDeviceIds.contains(deviceId)) {                 gameControllerDeviceIds.add(deviceId);             }         }     }     return gameControllerDeviceIds; }

class GameView(...) : View(...) {     ...      override fun onKeyDown(keyCode: Int, event: KeyEvent): Boolean {         var handled = false         if (event.source and InputDevice.SOURCE_GAMEPAD == InputDevice.SOURCE_GAMEPAD) {             if (event.repeatCount == 0) {                 when (keyCode) {                     // Handle gamepad and D-pad button presses to navigate the ship                     ...                      else -> {                         keyCode.takeIf { isFireKey(it) }?.run {                             // Update the ship object to fire lasers                             ...                             handled = true                         }                     }                 }             }             if (handled) {                 return true             }         }         return super.onKeyDown(keyCode, event)     }      // Here we treat Button_A and DPAD_CENTER as the primary action     // keys for the game.     private fun isFireKey(keyCode: Int): Boolean =             keyCode == KeyEvent.KEYCODE_DPAD_CENTER || keyCode == KeyEvent.KEYCODE_BUTTON_A }

public class GameView extends View {     ...      @Override     public boolean onKeyDown(int keyCode, KeyEvent event) {         boolean handled = false;         if ((event.getSource() & InputDevice.SOURCE_GAMEPAD)                 == InputDevice.SOURCE_GAMEPAD) {             if (event.getRepeatCount() == 0) {                 switch (keyCode) {                     // Handle gamepad and D-pad button presses to                     // navigate the ship                     ...                      default:                          if (isFireKey(keyCode)) {                              // Update the ship object to fire lasers                              ...                              handled = true;                          }                      break;                 }             }             if (handled) {                 return true;             }         }         return super.onKeyDown(keyCode, event);     }      private static boolean isFireKey(int keyCode) {         // Here we treat Button_A and DPAD_CENTER as the primary action         // keys for the game.         return keyCode == KeyEvent.KEYCODE_DPAD_CENTER                 || keyCode == KeyEvent.KEYCODE_BUTTON_A;     } }

class Dpad {      private var directionPressed = -1 // initialized to -1      fun getDirectionPressed(event: InputEvent): Int {         if (!isDpadDevice(event)) {             return -1         }          // If the input event is a MotionEvent, check its hat axis values.         (event as? MotionEvent)?.apply {              // Use the hat axis value to find the D-pad direction             val xaxis: Float = event.getAxisValue(MotionEvent.AXIS_HAT_X)             val yaxis: Float = event.getAxisValue(MotionEvent.AXIS_HAT_Y)              directionPressed = when {                 // Check if the AXIS_HAT_X value is -1 or 1, and set the D-pad                 // LEFT and RIGHT direction accordingly.                 xaxis.compareTo(-1.0f) == 0 -> Dpad.LEFT                 xaxis.compareTo(1.0f) == 0 -> Dpad.RIGHT                 // Check if the AXIS_HAT_Y value is -1 or 1, and set the D-pad                 // UP and DOWN direction accordingly.                 yaxis.compareTo(-1.0f) == 0 -> Dpad.UP                 yaxis.compareTo(1.0f) == 0 -> Dpad.DOWN                 else -> directionPressed             }         }         // If the input event is a KeyEvent, check its key code.         (event as? KeyEvent)?.apply {              // Use the key code to find the D-pad direction.             directionPressed = when(event.keyCode) {                 KeyEvent.KEYCODE_DPAD_LEFT -> Dpad.LEFT                 KeyEvent.KEYCODE_DPAD_RIGHT -> Dpad.RIGHT                 KeyEvent.KEYCODE_DPAD_UP -> Dpad.UP                 KeyEvent.KEYCODE_DPAD_DOWN -> Dpad.DOWN                 KeyEvent.KEYCODE_DPAD_CENTER ->  Dpad.CENTER                 else -> directionPressed             }         }         return directionPressed     }      companion object {         internal const val UP = 0         internal const val LEFT = 1         internal const val RIGHT = 2         internal const val DOWN = 3         internal const val CENTER = 4          fun isDpadDevice(event: InputEvent): Boolean =             // Check that input comes from a device with directional pads.             event.source and InputDevice.SOURCE_DPAD != InputDevice.SOURCE_DPAD     } }

public class Dpad {     final static int UP       = 0;     final static int LEFT     = 1;     final static int RIGHT    = 2;     final static int DOWN     = 3;     final static int CENTER   = 4;      int directionPressed = -1; // initialized to -1      public int getDirectionPressed(InputEvent event) {         if (!isDpadDevice(event)) {            return -1;         }          // If the input event is a MotionEvent, check its hat axis values.         if (event instanceof MotionEvent) {              // Use the hat axis value to find the D-pad direction             MotionEvent motionEvent = (MotionEvent) event;             float xaxis = motionEvent.getAxisValue(MotionEvent.AXIS_HAT_X);             float yaxis = motionEvent.getAxisValue(MotionEvent.AXIS_HAT_Y);              // Check if the AXIS_HAT_X value is -1 or 1, and set the D-pad             // LEFT and RIGHT direction accordingly.             if (Float.compare(xaxis, -1.0f) == 0) {                 directionPressed =  Dpad.LEFT;             } else if (Float.compare(xaxis, 1.0f) == 0) {                 directionPressed =  Dpad.RIGHT;             }             // Check if the AXIS_HAT_Y value is -1 or 1, and set the D-pad             // UP and DOWN direction accordingly.             else if (Float.compare(yaxis, -1.0f) == 0) {                 directionPressed =  Dpad.UP;             } else if (Float.compare(yaxis, 1.0f) == 0) {                 directionPressed =  Dpad.DOWN;             }         }          // If the input event is a KeyEvent, check its key code.         else if (event instanceof KeyEvent) {             // Use the key code to find the D-pad direction.             KeyEvent keyEvent = (KeyEvent) event;             if (keyEvent.getKeyCode() == KeyEvent.KEYCODE_DPAD_LEFT) {                 directionPressed = Dpad.LEFT;             } else if (keyEvent.getKeyCode() == KeyEvent.KEYCODE_DPAD_RIGHT) {                 directionPressed = Dpad.RIGHT;             } else if (keyEvent.getKeyCode() == KeyEvent.KEYCODE_DPAD_UP) {                 directionPressed = Dpad.UP;             } else if (keyEvent.getKeyCode() == KeyEvent.KEYCODE_DPAD_DOWN) {                 directionPressed = Dpad.DOWN;             } else if (keyEvent.getKeyCode() == KeyEvent.KEYCODE_DPAD_CENTER) {                 directionPressed = Dpad.CENTER;             }         }         return directionPressed;     }      public static boolean isDpadDevice(InputEvent event) {         // Check that input comes from a device with directional pads.         if ((event.getSource() & InputDevice.SOURCE_DPAD)              != InputDevice.SOURCE_DPAD) {              return true;          } else {              return false;          }      } }

private val dpad = Dpad() ... override fun onGenericMotionEvent(event: MotionEvent): Boolean {     if (Dpad.isDpadDevice(event)) {         when (dpad.getDirectionPressed(event)) {             Dpad.LEFT -> {                 // Do something for LEFT direction press                 ...                 return true             }             Dpad.RIGHT -> {                 // Do something for RIGHT direction press                 ...                 return true             }             Dpad.UP -> {                 // Do something for UP direction press                 ...                 return true             }             ...         }     }      // Check if this event is from a joystick movement and process accordingly.     ... }

Dpad dpad = new Dpad(); ... @Override public boolean onGenericMotionEvent(MotionEvent event) {      // Check if this event if from a D-pad and process accordingly.     if (Dpad.isDpadDevice(event)) {         int press = dpad.getDirectionPressed(event);        switch (press) {             case LEFT:                 // Do something for LEFT direction press                 ...                 return true;             case RIGHT:                 // Do something for RIGHT direction press                 ...                 return true;             case UP:                 // Do something for UP direction press                 ...                 return true;             ...         }     }      // Check if this event is from a joystick movement and process accordingly.     ... }

class GameView(...) : View(...) {      override fun onGenericMotionEvent(event: MotionEvent): Boolean {          // Check that the event came from a game controller         return if (event.source and InputDevice.SOURCE_JOYSTICK == InputDevice.SOURCE_JOYSTICK                 && event.action == MotionEvent.ACTION_MOVE) {              // Process the movements starting from the             // earliest historical position in the batch             (0 until event.historySize).forEach { i ->                 // Process the event at historical position i                 processJoystickInput(event, i)             }              // Process the current movement sample in the batch (position -1)             processJoystickInput(event, -1)             true         } else {             super.onGenericMotionEvent(event)         }     } }

public class GameView extends View {      @Override     public boolean onGenericMotionEvent(MotionEvent event) {          // Check that the event came from a game controller         if ((event.getSource() & InputDevice.SOURCE_JOYSTICK) ==                 InputDevice.SOURCE_JOYSTICK &&                 event.getAction() == MotionEvent.ACTION_MOVE) {              // Process all historical movement samples in the batch             final int historySize = event.getHistorySize();              // Process the movements starting from the             // earliest historical position in the batch             for (int i = 0; i < historySize; i++) {                 // Process the event at historical position i                 processJoystickInput(event, i);             }              // Process the current movement sample in the batch (position -1)             processJoystickInput(event, -1);             return true;         }         return super.onGenericMotionEvent(event);     } }

private fun getCenteredAxis(         event: MotionEvent,         device: InputDevice,         axis: Int,         historyPos: Int ): Float {     val range: InputDevice.MotionRange? = device.getMotionRange(axis, event.source)      // A joystick at rest does not always report an absolute position of     // (0,0). Use the getFlat() method to determine the range of values     // bounding the joystick axis center.     range?.apply {         val value: Float = if (historyPos < 0) {             event.getAxisValue(axis)         } else {             event.getHistoricalAxisValue(axis, historyPos)         }          // Ignore axis values that are within the 'flat' region of the         // joystick axis center.         if (Math.abs(value) > flat) {             return value         }     }     return 0f }

private static float getCenteredAxis(MotionEvent event,         InputDevice device, int axis, int historyPos) {     final InputDevice.MotionRange range =             device.getMotionRange(axis, event.getSource());      // A joystick at rest does not always report an absolute position of     // (0,0). Use the getFlat() method to determine the range of values     // bounding the joystick axis center.     if (range != null) {         final float flat = range.getFlat();         final float value =                 historyPos < 0 ? event.getAxisValue(axis):                 event.getHistoricalAxisValue(axis, historyPos);          // Ignore axis values that are within the 'flat' region of the         // joystick axis center.         if (Math.abs(value) > flat) {             return value;         }     }     return 0; }

private fun processJoystickInput(event: MotionEvent, historyPos: Int) {      val inputDevice = event.device      // Calculate the horizontal distance to move by     // using the input value from one of these physical controls:     // the left control stick, hat axis, or the right control stick.     var x: Float = getCenteredAxis(event, inputDevice, MotionEvent.AXIS_X, historyPos)     if (x == 0f) {         x = getCenteredAxis(event, inputDevice, MotionEvent.AXIS_HAT_X, historyPos)     }     if (x == 0f) {         x = getCenteredAxis(event, inputDevice, MotionEvent.AXIS_Z, historyPos)     }      // Calculate the vertical distance to move by     // using the input value from one of these physical controls:     // the left control stick, hat switch, or the right control stick.     var y: Float = getCenteredAxis(event, inputDevice, MotionEvent.AXIS_Y, historyPos)     if (y == 0f) {         y = getCenteredAxis(event, inputDevice, MotionEvent.AXIS_HAT_Y, historyPos)     }     if (y == 0f) {         y = getCenteredAxis(event, inputDevice, MotionEvent.AXIS_RZ, historyPos)     }      // Update the ship object based on the new x and y values }

private void processJoystickInput(MotionEvent event,         int historyPos) {      InputDevice inputDevice = event.getDevice();      // Calculate the horizontal distance to move by     // using the input value from one of these physical controls:     // the left control stick, hat axis, or the right control stick.     float x = getCenteredAxis(event, inputDevice,             MotionEvent.AXIS_X, historyPos);     if (x == 0) {         x = getCenteredAxis(event, inputDevice,                 MotionEvent.AXIS_HAT_X, historyPos);     }     if (x == 0) {         x = getCenteredAxis(event, inputDevice,                 MotionEvent.AXIS_Z, historyPos);     }      // Calculate the vertical distance to move by     // using the input value from one of these physical controls:     // the left control stick, hat switch, or the right control stick.     float y = getCenteredAxis(event, inputDevice,             MotionEvent.AXIS_Y, historyPos);     if (y == 0) {         y = getCenteredAxis(event, inputDevice,                 MotionEvent.AXIS_HAT_Y, historyPos);     }     if (y == 0) {         y = getCenteredAxis(event, inputDevice,                 MotionEvent.AXIS_RZ, historyPos);     }      // Update the ship object based on the new x and y values }