This lesson teaches you to
- Prepare to Abstract APIs for Game Controller Suppport
- Add an Interface for Backward Compatibility
- Implement the Interface on Android 4.1 and Higher
- Implement the Interface on Android 2.3 up to Android 4.0
- Use the Version-Specific Implementations
Try it out
ControllerSample.zip
If you are supporting game controllers in your game, it's your responsibility to make sure that your game responds to controllers consistently across devices running on different versions of Android. This lets your game reach a wider audience, and your players can enjoy a seamless gameplay experience with their controllers even when they switch or upgrade their Android devices.
This lesson demonstrates how to use APIs available in Android 4.1 and higher in a backward compatible way, enabling your game to support the following features on devices running Android 2.3 and higher:
- The game can detect if a new game controller is added, changed, or removed.
- The game can query the capabilities of a game controller.
- The game can recognize incoming motion events from a game controller.
The examples in this lesson are based on the reference implementation
provided by the sample ControllerSample.zip
available for download
above. This sample shows how to implement the InputManagerCompat
interface to support different versions of Android. To compile the sample, you
must use Android 4.1 (API level 16) or higher. Once compiled, the sample app
runs on any device running Android 2.3 (API level 9) or higher as the build
target.
Prepare to Abstract APIs for Game Controller Support
Suppose you want to be able to determine if a game controller's connection status has changed on devices running on Android 2.3 (API level 9). However, the APIs are only available in Android 4.1 (API level 16) and higher, so you need to provide an implementation that supports Android 4.1 and higher while providing a fallback mechanism that supports Android 2.3 up to Android 4.0.
To help you determine which features require such a fallback mechanism for older versions, table 1 lists the differences in game controller support between Android 2.3 (API level 9), 3.1 (API level 12), and 4.1 (API level 16).
Table 1. APIs for game controller support across different Android versions.
Controller Information | Controller API | API level 9 | API level 12 | API level 16 |
---|---|---|---|---|
Device Identification | getInputDeviceIds() |
• | ||
getInputDevice() |
• | |||
getVibrator() |
• | SOURCE_JOYSTICK |
• | • |
SOURCE_GAMEPAD |
• | • | ||
Connection Status | onInputDeviceAdded() |
• | ||
onInputDeviceChanged() |
• | |||
onInputDeviceRemoved() |
• | |||
Input Event Identification | D-pad press (
KEYCODE_DPAD_UP ,
KEYCODE_DPAD_DOWN ,
KEYCODE_DPAD_LEFT ,
KEYCODE_DPAD_RIGHT ,
KEYCODE_DPAD_CENTER ) |
• | • | • |
Gamepad button press (
BUTTON_A ,
BUTTON_B ,
BUTTON_THUMBL ,
BUTTON_THUMBR ,
BUTTON_SELECT ,
BUTTON_START ,
BUTTON_R1 ,
BUTTON_L1 ,
BUTTON_R2 ,
BUTTON_L2 ) |
• | • | ||
Joystick and hat switch movement (
AXIS_X ,
AXIS_Y ,
AXIS_Z ,
AXIS_RZ ,
AXIS_HAT_X ,
AXIS_HAT_Y ) |
• | • | ||
Analog trigger press (
AXIS_LTRIGGER ,
AXIS_RTRIGGER ) |
• | • |
You can use abstraction to build version-aware game controller support that works across platforms. This approach involves the following steps:
- Define an intermediary Java interface that abstracts the implementation of the game controller features required by your game.
- Create a proxy implementation of your interface that uses APIs in Android 4.1 and higher.
- Create a custom implementation of your interface that uses APIs available between Android 2.3 up to Android 4.0.
- Create the logic for switching between these implementations at runtime, and begin using the interface in your game.
For an overview of how abstraction can be used to ensure that applications can work in a backward compatible way across different versions of Android, see Creating Backward-Compatible UIs.
Add an Interface for Backward Compatibility
To provide backward compatibility, you can create a custom interface then add version-specific implementations. One advantage of this approach is that it lets you mirror the public interfaces on Android 4.1 (API level 16) that support game controllers.
// The InputManagerCompat interface is a reference example. // The full code is provided in the ControllerSample.zip sample. public interface InputManagerCompat { ... public InputDevice getInputDevice(int id); public int[] getInputDeviceIds(); public void registerInputDeviceListener( InputManagerCompat.InputDeviceListener listener, Handler handler); public void unregisterInputDeviceListener( InputManagerCompat.InputDeviceListener listener); public void onGenericMotionEvent(MotionEvent event); public void onPause(); public void onResume(); public interface InputDeviceListener { void onInputDeviceAdded(int deviceId); void onInputDeviceChanged(int deviceId); void onInputDeviceRemoved(int deviceId); } ... }
The InputManagerCompat
interface provides the following methods:
getInputDevice()
- Mirrors
getInputDevice()
. Obtains theInputDevice
object that represents the capabilities of a game controller. getInputDeviceIds()
- Mirrors
getInputDeviceIds()
. Returns an array of integers, each of which is an ID for a different input device. This is useful if you're building a game that supports multiple players and you want to detect how many controllers are connected. registerInputDeviceListener()
- Mirrors
registerInputDeviceListener()
. Lets you register to be informed when a new device is added, changed, or removed. unregisterInputDeviceListener()
- Mirrors
unregisterInputDeviceListener()
. Unregisters an input device listener. onGenericMotionEvent()
- Mirrors
onGenericMotionEvent()
. Lets your game intercept and handleMotionEvent
objects and axis values that represent events such as joystick movements and analog trigger presses. onPause()
- Stops polling for game controller events when the main activity is paused, or when the game no longer has focus.
onResume()
- Starts polling for game controller events when the main activity is resumed, or when the game is started and runs in the foreground.
InputDeviceListener
- Mirrors the
InputManager.InputDeviceListener
interface. Lets your game know when a game controller has been added, changed, or removed.
Next, create implementations for InputManagerCompat
that work
across different platform versions. If your game is running on Android 4.1 or
higher and calls an InputManagerCompat
method, the proxy implementation
calls the equivalent method in InputManager
.
However, if your game is running on Android 2.3 up to Android 4.0, the custom implementation processes calls to InputManagerCompat
methods by using
only APIs introduced no later than Android 2.3. Regardless of which
version-specific implementation is used at runtime, the implementation passes
the call results back transparently to the game.
![](../../images/training/backward-compatible-inputmanager.png)
Figure 1. Class diagram of interface and version-specific implementations.
Implement the Interface on Android 4.1 and Higher
InputManagerCompatV16
is an implementation of the
InputManagerCompat
interface that proxies method calls to an
actual InputManager
and InputManager.InputDeviceListener
. The
InputManager
is obtained from the system
Context
.
// The InputManagerCompatV16 class is a reference implementation. // The full code is provided in the ControllerSample.zip sample. public class InputManagerV16 implements InputManagerCompat { private final InputManager mInputManager; private final MapmListeners; public InputManagerV16(Context context) { mInputManager = (InputManager) context.getSystemService(Context.INPUT_SERVICE); mListeners = new HashMap (); } @Override public InputDevice getInputDevice(int id) { return mInputManager.getInputDevice(id); } @Override public int[] getInputDeviceIds() { return mInputManager.getInputDeviceIds(); } static class V16InputDeviceListener implements InputManager.InputDeviceListener { final InputManagerCompat.InputDeviceListener mIDL; public V16InputDeviceListener(InputDeviceListener idl) { mIDL = idl; } @Override public void onInputDeviceAdded(int deviceId) { mIDL.onInputDeviceAdded(deviceId); } // Do the same for device change and removal ... } @Override public void registerInputDeviceListener(InputDeviceListener listener, Handler handler) { V16InputDeviceListener v16Listener = new V16InputDeviceListener(listener); mInputManager.registerInputDeviceListener(v16Listener, handler); mListeners.put(listener, v16Listener); } // Do the same for unregistering an input device listener ... @Override public void onGenericMotionEvent(MotionEvent event) { // unused in V16 } @Override public void onPause() { // unused in V16 } @Override public void onResume() { // unused in V16 } }
Implementing the Interface on Android 2.3 up to Android 4.0
The InputManagerV9
implementation uses APIs introduced no later
than Android 2.3. To create an implementation of InputManagerCompat
that supports Android 2.3 up to Android 4.0, you can use
the following objects:
- A
SparseArray
of device IDs to track the game controllers that are connected to the device. - A
Handler
to process device events. When an app is started or resumed, theHandler
receives a message to start polling for game controller disconnection. TheHandler
will start a loop to check each known connected game controller and see if a device ID is returned. Anull
return value indicates that the game controller is disconnected. TheHandler
stops polling when the app is paused. - A
Map
ofInputManagerCompat.InputDeviceListener
objects. You will use the listeners to update the connection status of tracked game controllers.
// The InputManagerCompatV9 class is a reference implementation. // The full code is provided in the ControllerSample.zip sample. public class InputManagerV9 implements InputManagerCompat { private final SparseArraymDevices; private final Map mListeners; private final Handler mDefaultHandler; … public InputManagerV9() { mDevices = new SparseArray (); mListeners = new HashMap (); mDefaultHandler = new PollingMessageHandler(this); } }
Implement a PollingMessageHandler
object that extends
Handler
, and override the
handleMessage()
method. This method checks if an attached game controller has been
disconnected and notifies registered listeners.
private static class PollingMessageHandler extends Handler { private final WeakReferencemInputManager; PollingMessageHandler(InputManagerV9 im) { mInputManager = new WeakReference (im); } @Override public void handleMessage(Message msg) { super.handleMessage(msg); switch (msg.what) { case MESSAGE_TEST_FOR_DISCONNECT: InputManagerV9 imv = mInputManager.get(); if (null != imv) { long time = SystemClock.elapsedRealtime(); int size = imv.mDevices.size(); for (int i = 0; i < size; i++) { long[] lastContact = imv.mDevices.valueAt(i); if (null != lastContact) { if (time - lastContact[0] > CHECK_ELAPSED_TIME) { // check to see if the device has been // disconnected int id = imv.mDevices.keyAt(i); if (null == InputDevice.getDevice(id)) { // Notify the registered listeners // that the game controller is disconnected ... imv.mDevices.remove(id); } else { lastContact[0] = time; } } } } sendEmptyMessageDelayed(MESSAGE_TEST_FOR_DISCONNECT, CHECK_ELAPSED_TIME); } break; } } }
To start and stop polling for game controller disconnection, override these methods:
private static final int MESSAGE_TEST_FOR_DISCONNECT = 101; private static final long CHECK_ELAPSED_TIME = 3000L; @Override public void onPause() { mDefaultHandler.removeMessages(MESSAGE_TEST_FOR_DISCONNECT); } @Override public void onResume() { mDefaultHandler.sendEmptyMessageDelayed(MESSAGE_TEST_FOR_DISCONNECT, CHECK_ELAPSED_TIME); }
To detect that an input device has been added, override the
onGenericMotionEvent()
method. When the system reports a motion event,
check if this event came from a device ID that is already tracked, or from a
new device ID. If the device ID is new, notify registered listeners.
@Override public void onGenericMotionEvent(MotionEvent event) { // detect new devices int id = event.getDeviceId(); long[] timeArray = mDevices.get(id); if (null == timeArray) { // Notify the registered listeners that a game controller is added ... timeArray = new long[1]; mDevices.put(id, timeArray); } long time = SystemClock.elapsedRealtime(); timeArray[0] = time; }
Notification of listeners is implemented by using the
Handler
object to send a DeviceEvent
Runnable
object to the message queue. The DeviceEvent
contains a reference to an InputManagerCompat.InputDeviceListener
. When
the DeviceEvent
runs, the appropriate callback method of the listener
is called to signal if the game controller was added, changed, or removed.
@Override public void registerInputDeviceListener(InputDeviceListener listener, Handler handler) { mListeners.remove(listener); if (handler == null) { handler = mDefaultHandler; } mListeners.put(listener, handler); } @Override public void unregisterInputDeviceListener(InputDeviceListener listener) { mListeners.remove(listener); } private void notifyListeners(int why, int deviceId) { // the state of some device has changed if (!mListeners.isEmpty()) { for (InputDeviceListener listener : mListeners.keySet()) { Handler handler = mListeners.get(listener); DeviceEvent odc = DeviceEvent.getDeviceEvent(why, deviceId, listener); handler.post(odc); } } } private static class DeviceEvent implements Runnable { private int mMessageType; private int mId; private InputDeviceListener mListener; private static QueuesObjectQueue = new ArrayDeque (); ... static DeviceEvent getDeviceEvent(int messageType, int id, InputDeviceListener listener) { DeviceEvent curChanged = sObjectQueue.poll(); if (null == curChanged) { curChanged = new DeviceEvent(); } curChanged.mMessageType = messageType; curChanged.mId = id; curChanged.mListener = listener; return curChanged; } @Override public void run() { switch (mMessageType) { case ON_DEVICE_ADDED: mListener.onInputDeviceAdded(mId); break; case ON_DEVICE_CHANGED: mListener.onInputDeviceChanged(mId); break; case ON_DEVICE_REMOVED: mListener.onInputDeviceRemoved(mId); break; default: // Handle unknown message type ... break; } // Put this runnable back in the queue sObjectQueue.offer(this); } }
You now have two implementations of InputManagerCompat
: one that
works on devices running Android 4.1 and higher, and another
that works on devices running Android 2.3 up to Android 4.0.
Use the Version-Specific Implementation
The version-specific switching logic is implemented in a class that acts as a factory.
public static class Factory { public static InputManagerCompat getInputManager(Context context) { if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN) { return new InputManagerV16(context); } else { return new InputManagerV9(); } } }
Now you can simply instantiate an InputManagerCompat
object and
register an InputManagerCompat.InputDeviceListener
in your main
View
. Because of the version-switching logic you set
up, your game automatically uses the implementation that's appropriate for the
version of Android the device is running.
public class GameView extends View implements InputDeviceListener { private InputManagerCompat mInputManager; ... public GameView(Context context, AttributeSet attrs) { mInputManager = InputManagerCompat.Factory.getInputManager(this.getContext()); mInputManager.registerInputDeviceListener(this, null); ... } }
Next, override the
onGenericMotionEvent()
method in your main view, as described in
Handle a MotionEvent from a Game
Controller. Your game should now be able to process game controller events
consistently on devices running Android 2.3 (API level 9) and higher.
@Override public boolean onGenericMotionEvent(MotionEvent event) { mInputManager.onGenericMotionEvent(event); // Handle analog input from the controller as normal ... return super.onGenericMotionEvent(event); }
You can find a complete implementation of this compatibility code in the
GameView
class provided in the sample ControllerSample.zip
available for download above.