Cette page a été traduite par l'API Cloud Translation.

Compatibilité avec les manettes sur toutes les versions d'Android

Si vous acceptez les manettes de jeu dans votre jeu, vous êtes tenu de le faire pour vous assurer que votre jeu réagit aux manettes de manière cohérente sur tous les appareils fonctionnant sous différentes versions d'Android. Cela permet à votre jeu de toucher une audience plus large public, et que vos joueurs bénéficient d'une expérience de jeu fluide avec leur manette même s'ils changent d'appareil Android ou mettent à niveau leur appareil.

Cette leçon explique comment utiliser les API disponibles sur Android 4.1 ou version ultérieure. de manière rétrocompatible, ce qui permet à votre jeu d'accepter sur les appareils équipés d'Android 3.1 ou version ultérieure:

Le jeu peut détecter si une nouvelle manette de jeu est ajoutée, modifiée ou supprimée.
Le jeu peut interroger les capacités d'une manette de jeu.
Le jeu peut reconnaître les événements de mouvement entrants provenant d'une manette de jeu.

Les exemples de cette leçon sont basés sur l'implémentation de référence fourni par l'exemple ControllerSample.zip disponible en téléchargement ci-dessus. Cet exemple montre comment implémenter InputManagerCompat. pour prendre en charge différentes versions d'Android. Pour compiler l'exemple, Utilisez Android 4.1 (niveau d'API 16) ou version ultérieure. Une fois compilé, l'application exemple s'exécute sur n'importe quel appareil équipé d'Android 3.1 (niveau d'API 12) ou version ultérieure. cible.

Se préparer à faire abstraction des API pour la compatibilité avec les manettes de jeu

Supposons que vous souhaitiez déterminer si la connexion d'une manette de jeu a changé sur les appareils équipés d'Android 3.1 (niveau d'API 12). Toutefois, les API ne sont disponibles que sur Android 4.1 (niveau d'API 16) ou version ultérieure. devez fournir une implémentation compatible avec Android 4.1 et versions ultérieures, tout en en fournissant un mécanisme de secours compatible avec Android 3.1 à Android 4.0.

Pour vous aider à déterminer les fonctionnalités nécessitant un tel mécanisme de remplacement versions plus anciennes, le tableau 1 liste les différences de compatibilité avec les manettes de jeu entre Android 3.1 (niveau d'API 12) et 4.1 (niveau d'API) 16).

Tableau 1. API pour la prise en charge des manettes de jeu différentes versions d'Android.

Informations sur le Responsable du traitement	API Controller	Niveau d'API 12	Niveau d'API 16
Identification de l'appareil	`getInputDeviceIds()`		•
	`getInputDevice()`		•
	`getVibrator()`		•
	`SOURCE_JOYSTICK`	•	•
	`SOURCE_GAMEPAD`	•	•
État de la connexion	`onInputDeviceAdded()`		•
	`onInputDeviceChanged()`		•
	`onInputDeviceRemoved()`		•
Saisissez l'identification des événements	Appui sur le pavé directionnel ( `KEYCODE_DPAD_UP`, `KEYCODE_DPAD_DOWN`, `KEYCODE_DPAD_LEFT`, `KEYCODE_DPAD_RIGHT`, `KEYCODE_DPAD_CENTER`)	•	•
	Appui sur le bouton de la manette de jeu ( `BUTTON_A`, `BUTTON_B`, `BUTTON_THUMBL`, `BUTTON_THUMBR`, `BUTTON_SELECT`, `BUTTON_START`, `BUTTON_R1`, `BUTTON_L1`, `BUTTON_R2`, `BUTTON_L2`)	•	•
	Mouvement du joystick et du chapeau ( `AXIS_X`, `AXIS_Y`, `AXIS_Z`, `AXIS_RZ`, `AXIS_HAT_X`, `AXIS_HAT_Y`)	•	•
	Appuyez sur la gâchette analogique ( `AXIS_LTRIGGER`, `AXIS_RTRIGGER`).	•	•

Vous pouvez utiliser une abstraction pour créer une prise en charge de manettes de jeu tenant compte des versions fonctionne sur toutes les plates-formes. Cette approche comprend les étapes suivantes:

Définir une interface Java intermédiaire qui extrait l'implémentation de les fonctionnalités de manette de jeu requises par votre jeu.
Créer une implémentation de proxy de votre interface qui utilise des API dans Android 4.1 et versions ultérieures.
Créez une implémentation personnalisée de votre interface qui utilise les API disponibles. entre Android 3.1 et Android 4.0.
Créer la logique permettant de basculer entre ces implémentations au moment de l'exécution et commencer à utiliser l'interface de votre jeu.

Pour découvrir comment l'abstraction peut être utilisée pour s'assurer que les applications peut fonctionner de manière rétrocompatible avec différentes versions d'Android, consultez Création UI rétrocompatibles

Ajouter une interface pour assurer la rétrocompatibilité

Pour assurer la rétrocompatibilité, vous pouvez créer une interface personnalisée ajouter des implémentations spécifiques à chaque version. L'un des avantages de cette approche vous permet de dupliquer les interfaces publiques sur Android 4.1 (niveau d'API 16) prend en charge les manettes de jeu.

Kotlin

// The InputManagerCompat interface is a reference example.
// The full code is provided in the ControllerSample.zip sample.
interface InputManagerCompat {
    val inputDeviceIds: IntArray
    fun getInputDevice(id: Int): InputDevice

    fun registerInputDeviceListener(
            listener: InputManager.InputDeviceListener,
            handler: Handler?
    )

    fun unregisterInputDeviceListener(listener:InputManager.InputDeviceListener)

    fun onGenericMotionEvent(event: MotionEvent)

    fun onPause()
    fun onResume()

    interface InputDeviceListener {
        fun onInputDeviceAdded(deviceId: Int)
        fun onInputDeviceChanged(deviceId: Int)
        fun onInputDeviceRemoved(deviceId: Int)
    }
}

Java

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

L'interface InputManagerCompat fournit les méthodes suivantes:

getInputDevice(): Reflète getInputDevice(). Récupère InputDevice qui représente les capacités d'une manette de jeu.
getInputDeviceIds(): Reflète getInputDeviceIds(). Renvoie un tableau d'entiers, chacun de qui est l'ID d'un autre périphérique d'entrée. Cela est utile si vous créez un jeu avec plusieurs joueurs et dont vous voulez détecter le nombre manettes de jeu sont connectées.
registerInputDeviceListener(): Reflète registerInputDeviceListener(). Vous permet de vous inscrire pour être informé dès qu'une nouvelle appareil est ajouté, modifié ou supprimé.
unregisterInputDeviceListener(): Reflète unregisterInputDeviceListener(). annule l'enregistrement d'un écouteur de périphérique d'entrée.
onGenericMotionEvent(): Reflète onGenericMotionEvent(). Permet à votre jeu d'intercepter et de gérer Objets MotionEvent et valeurs des axes représentant des événements comme les mouvements du joystick et les appuis sur la gâchette analogique.
onPause(): Arrête de rechercher des événements liés aux manettes de jeu lorsque la activité principale est mise en pause, ou lorsque le jeu n'est plus actif.
onResume(): Démarre la recherche d'événements liés aux manettes de jeu lorsque la l'activité principale reprend, ou lorsque le jeu est lancé et s'exécute dans au premier plan.
InputDeviceListener: Reflète la InputManager.InputDeviceListener de commande. Permet à votre jeu de savoir quand une manette de jeu a été ajoutée, modifiée ou supprimés.

Ensuite, créez des implémentations pour InputManagerCompat qui fonctionnent sur les différentes versions de la plate-forme. Si votre jeu s'exécute sous Android 4.1 ou et appelle une méthode InputManagerCompat, l'implémentation du proxy appelle la méthode équivalente dans InputManager. Toutefois, si votre jeu s'exécute sous Android 3.1 à Android 4.0, l'implémentation personnalisée traite les appels aux méthodes InputManagerCompat à l'aide de que les API introduites à partir d'Android 3.1 ou version ultérieure. Indépendamment de est utilisée au moment de l'exécution, l'implémentation transmet les résultats de l'appel de manière transparente au jeu.

Figure 1 : Schéma de classe de l'interface et de la version spécifique mises en œuvre.

Implémenter l'interface sous Android 4.1 ou version ultérieure

InputManagerCompatV16 est une implémentation de InputManagerCompat qui sert de proxy pour les appels de méthode vers les valeurs InputManager et InputManager.InputDeviceListener réelles. La InputManager est obtenu à partir du système Context

Kotlin

// The InputManagerCompatV16 class is a reference implementation.
// The full code is provided in the ControllerSample.zip sample.
public class InputManagerV16(
        context: Context,
        private val inputManager: InputManager =
            context.getSystemService(Context.INPUT_SERVICE) as InputManager,
        private val listeners:
            MutableMap<InputManager.InputDeviceListener, V16InputDeviceListener> = mutableMapOf()
) : InputManagerCompat {
    override val inputDeviceIds: IntArray = inputManager.inputDeviceIds

    override fun getInputDevice(id: Int): InputDevice = inputManager.getInputDevice(id)

    override fun registerInputDeviceListener(
            listener: InputManager.InputDeviceListener,
            handler: Handler?
    ) {
        V16InputDeviceListener(listener).also { v16listener ->
            inputManager.registerInputDeviceListener(v16listener, handler)
            listeners += listener to v16listener
        }
    }

    // Do the same for unregistering an input device listener
    ...

    override fun onGenericMotionEvent(event: MotionEvent) {
        // unused in V16
    }

    override fun onPause() {
        // unused in V16
    }

    override fun onResume() {
        // unused in V16
    }

}

class V16InputDeviceListener(
        private val idl: InputManager.InputDeviceListener
) : InputManager.InputDeviceListener {

    override fun onInputDeviceAdded(deviceId: Int) {
        idl.onInputDeviceAdded(deviceId)
    }
    // Do the same for device change and removal
    ...
}

Java

// 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 inputManager;
    private final Map<InputManagerCompat.InputDeviceListener,
            V16InputDeviceListener> listeners;

    public InputManagerV16(Context context) {
        inputManager = (InputManager)
                context.getSystemService(Context.INPUT_SERVICE);
        listeners = new HashMap<InputManagerCompat.InputDeviceListener,
                V16InputDeviceListener>();
    }

    @Override
    public InputDevice getInputDevice(int id) {
        return inputManager.getInputDevice(id);
    }

    @Override
    public int[] getInputDeviceIds() {
        return inputManager.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);
        inputManager.registerInputDeviceListener(v16Listener, handler);
        listeners.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
    }

}

Implémenter l'interface sur les appareils équipés d'Android 3.1 à 4.0

Pour créer une implémentation de InputManagerCompat compatible avec Android 3.1 à Android 4.0, vous pouvez utiliser les objets suivants:

Un SparseArray d'ID d'appareils pour suivre les manettes de jeu connectées à l'appareil.
Un Handler pour traiter les événements de l'appareil. Au démarrage d'une application ou réactivées, le Handler reçoit un message pour commencer l'interrogation pour déconnecter la manette de jeu. Le Handler lance un pour vérifier chaque manette de jeu connectée connue et voir si un ID d'appareil est renvoyé. Une valeur renvoyée null indique que la manette de jeu déconnectés. Le Handler arrête d'interroger lorsque l'application est en pause.
Map de InputManagerCompat.InputDeviceListener d'objets. Vous utiliserez les écouteurs pour mettre à jour l'état de connexion des des manettes de jeu.

Kotlin

// The InputManagerCompatV9 class is a reference implementation.
// The full code is provided in the ControllerSample.zip sample.
class InputManagerV9(
        val devices: SparseArray<Array<Long>> = SparseArray(),
        private val listeners:
        MutableMap<InputManager.InputDeviceListener, Handler> = mutableMapOf()
) : InputManagerCompat {
    private val defaultHandler: Handler = PollingMessageHandler(this)
    …
}

Java

// The InputManagerCompatV9 class is a reference implementation.
// The full code is provided in the ControllerSample.zip sample.
public class InputManagerV9 implements InputManagerCompat {
    private final SparseArray<long[]> devices;
    private final Map<InputDeviceListener, Handler> listeners;
    private final Handler defaultHandler;
    …

    public InputManagerV9() {
        devices = new SparseArray<long[]>();
        listeners = new HashMap<InputDeviceListener, Handler>();
        defaultHandler = new PollingMessageHandler(this);
    }
}

Implémentez un objet PollingMessageHandler qui étend Handler, et remplacez les handleMessage() . Cette méthode vérifie si une manette de jeu connectée a été déconnecté et notifie les écouteurs enregistrés.

Kotlin

private class PollingMessageHandler(
        inputManager: InputManagerV9,
        private val mInputManager: WeakReference<InputManagerV9> = WeakReference(inputManager)
) : Handler() {

    override fun handleMessage(msg: Message) {
        super.handleMessage(msg)
        when (msg.what) {
            MESSAGE_TEST_FOR_DISCONNECT -> {
                mInputManager.get()?.also { imv ->
                    val time = SystemClock.elapsedRealtime()
                    val size = imv.devices.size()
                    for (i in 0 until size) {
                        imv.devices.valueAt(i)?.also { lastContact ->
                            if (time - lastContact[0] > CHECK_ELAPSED_TIME) {
                                // check to see if the device has been
                                // disconnected
                                val id = imv.devices.keyAt(i)
                                if (null == InputDevice.getDevice(id)) {
                                    // Notify the registered listeners
                                    // that the game controller is disconnected
                                    imv.devices.remove(id)
                                } else {
                                    lastContact[0] = time
                                }
                            }
                        }
                    }
                    sendEmptyMessageDelayed(MESSAGE_TEST_FOR_DISCONNECT, CHECK_ELAPSED_TIME)
                }
            }
        }
    }
}

Java

private static class PollingMessageHandler extends Handler {
    private final WeakReference<InputManagerV9> inputManager;

    PollingMessageHandler(InputManagerV9 im) {
        inputManager = new WeakReference<InputManagerV9>(im);
    }

    @Override
    public void handleMessage(Message msg) {
        super.handleMessage(msg);
        switch (msg.what) {
            case MESSAGE_TEST_FOR_DISCONNECT:
                InputManagerV9 imv = inputManager.get();
                if (null != imv) {
                    long time = SystemClock.elapsedRealtime();
                    int size = imv.devices.size();
                    for (int i = 0; i < size; i++) {
                        long[] lastContact = imv.devices.valueAt(i);
                        if (null != lastContact) {
                            if (time - lastContact[0] > CHECK_ELAPSED_TIME) {
                                // check to see if the device has been
                                // disconnected
                                int id = imv.devices.keyAt(i);
                                if (null == InputDevice.getDevice(id)) {
                                    // Notify the registered listeners
                                    // that the game controller is disconnected
                                    imv.devices.remove(id);
                                } else {
                                    lastContact[0] = time;
                                }
                            }
                        }
                    }
                    sendEmptyMessageDelayed(MESSAGE_TEST_FOR_DISCONNECT,
                            CHECK_ELAPSED_TIME);
                }
                break;
        }
    }
}

Pour lancer et arrêter la recherche de déconnexions de la manette de jeu, ignorer ces méthodes:

Kotlin

private const val MESSAGE_TEST_FOR_DISCONNECT = 101
private const val CHECK_ELAPSED_TIME = 3000L

class InputManagerV9(
        val devices: SparseArray<Array<Long>> = SparseArray(),
        private val listeners:
        MutableMap<InputManager.InputDeviceListener, Handler> = mutableMapOf()
) : InputManagerCompat {
    ...
    override fun onPause() {
        defaultHandler.removeMessages(MESSAGE_TEST_FOR_DISCONNECT)
    }

    override fun onResume() {
        defaultHandler.sendEmptyMessageDelayed(MESSAGE_TEST_FOR_DISCONNECT, CHECK_ELAPSED_TIME)
    }
    ...
}

Java

private static final int MESSAGE_TEST_FOR_DISCONNECT = 101;
private static final long CHECK_ELAPSED_TIME = 3000L;

@Override
public void onPause() {
    defaultHandler.removeMessages(MESSAGE_TEST_FOR_DISCONNECT);
}

@Override
public void onResume() {
    defaultHandler.sendEmptyMessageDelayed(MESSAGE_TEST_FOR_DISCONNECT,
            CHECK_ELAPSED_TIME);
}

Pour détecter qu'un périphérique d'entrée a été ajouté, ignorez la onGenericMotionEvent(). Lorsque le système signale un événement de mouvement, vérifiez si cet événement provient d'un ID d'appareil déjà suivi ou nouvel ID d'appareil. Si l'ID de l'appareil est nouveau, informez les écouteurs enregistrés.

Kotlin

override fun onGenericMotionEvent(event: MotionEvent) {
    // detect new devices
    val id = event.deviceId
    val timeArray: Array<Long> = mDevices.get(id) ?: run {
        // Notify the registered listeners that a game controller is added
        ...
        arrayOf<Long>().also {
            mDevices.put(id, it)
        }
    }
    timeArray[0] = SystemClock.elapsedRealtime()
}

Java

@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;
}

La notification des écouteurs est mise en œuvre à l'aide de la méthode Objet Handler pour envoyer un DeviceEvent Runnable à la file d'attente des messages. DeviceEvent contient une référence à un InputManagerCompat.InputDeviceListener. Quand ? DeviceEvent s'exécute, la méthode de rappel appropriée de l'écouteur est appelé pour signaler si la manette de jeu a été ajoutée, modifiée ou supprimée.

Kotlin

class InputManagerV9(
        val devices: SparseArray<Array<Long>> = SparseArray(),
        private val listeners:
        MutableMap<InputManager.InputDeviceListener, Handler> = mutableMapOf()
) : InputManagerCompat {
    ...
    override fun registerInputDeviceListener(
            listener: InputManager.InputDeviceListener,
            handler: Handler?
    ) {
        listeners[listener] = handler ?: defaultHandler
    }

    override fun unregisterInputDeviceListener(listener: InputManager.InputDeviceListener) {
        listeners.remove(listener)
    }

    private fun notifyListeners(why: Int, deviceId: Int) {
        // the state of some device has changed
        listeners.forEach { listener, handler ->
            DeviceEvent.getDeviceEvent(why, deviceId, listener).also {
                handler?.post(it)
            }
        }
    }
    ...
}

private val sObjectQueue: Queue<DeviceEvent> = ArrayDeque<DeviceEvent>()

private class DeviceEvent(
        private var mMessageType: Int,
        private var mId: Int,
        private var mListener: InputManager.InputDeviceListener
) : Runnable {

    companion object {
        fun getDeviceEvent(messageType: Int, id: Int, listener: InputManager.InputDeviceListener) =
                sObjectQueue.poll()?.apply {
                    mMessageType = messageType
                    mId = id
                    mListener = listener
                } ?: DeviceEvent(messageType, id, listener)

    }

    override fun run() {
        when(mMessageType) {
            ON_DEVICE_ADDED -> mListener.onInputDeviceAdded(mId)
            ON_DEVICE_CHANGED -> mListener.onInputDeviceChanged(mId)
            ON_DEVICE_REMOVED -> mListener.onInputDeviceChanged(mId)
            else -> {
                // Handle unknown message type
            }
        }
    }

}

Java

@Override
public void registerInputDeviceListener(InputDeviceListener listener,
        Handler handler) {
    listeners.remove(listener);
    if (handler == null) {
        handler = defaultHandler;
    }
    listeners.put(listener, handler);
}

@Override
public void unregisterInputDeviceListener(InputDeviceListener listener) {
    listeners.remove(listener);
}

private void notifyListeners(int why, int deviceId) {
    // the state of some device has changed
    if (!listeners.isEmpty()) {
        for (InputDeviceListener listener : listeners.keySet()) {
            Handler handler = listeners.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 Queue<DeviceEvent> sObjectQueue =
            new ArrayDeque<DeviceEvent>();
    ...

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

Vous avez maintenant deux implémentations de InputManagerCompat: une qui fonctionne sur les appareils équipés d'Android 4.1 ou version ultérieure, qui fonctionne sur les appareils équipés d'Android 3.1 à Android 4.0.

Utiliser l'implémentation propre à la version

La logique de commutation spécifique à la version est implémentée dans une classe qui agit comme une usine.

Kotlin

object Factory {
    fun getInputManager(context: Context): InputManagerCompat =
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN) {
                InputManagerV16(context)
            } else {
                InputManagerV9()
            }
}

Java

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

Vous pouvez maintenant simplement instancier un objet InputManagerCompat et enregistrez un InputManagerCompat.InputDeviceListener dans votre View En raison de la logique de changement de version que vous avez définie votre jeu utilise automatiquement l'implémentation adaptée version d'Android exécutée sur l'appareil.

Kotlin

class GameView(context: Context) : View(context), InputManager.InputDeviceListener {
    private val inputManager: InputManagerCompat = Factory.getInputManager(context).apply {
        registerInputDeviceListener(this@GameView, null)
        ...
    }
    ...
}

Java

public class GameView extends View implements InputDeviceListener {
    private InputManagerCompat inputManager;
    ...

    public GameView(Context context, AttributeSet attrs) {
        inputManager =
                InputManagerCompat.Factory.getInputManager(this.getContext());
        inputManager.registerInputDeviceListener(this, null);
        ...
    }
}

Ensuite, remplacez les onGenericMotionEvent() dans la vue principale, comme décrit dans Gérer un MotionEvent depuis un jeu Manette de jeu. Votre jeu devrait maintenant pouvoir traiter les événements liés aux manettes de jeu systématiquement sur les appareils équipés d'Android 3.1 (niveau d'API 12) ou version ultérieure.

Kotlin

override fun onGenericMotionEvent(event: MotionEvent): Boolean {
    inputManager.onGenericMotionEvent(event)

    // Handle analog input from the controller as normal
    ...
    return super.onGenericMotionEvent(event)
}

Java

@Override
public boolean onGenericMotionEvent(MotionEvent event) {
    inputManager.onGenericMotionEvent(event);

    // Handle analog input from the controller as normal
    ...
    return super.onGenericMotionEvent(event);
}

Vous trouverez une implémentation complète de ce code de compatibilité dans le Classe GameView fournie dans l'exemple ControllerSample.zip téléchargeable ci-dessus.