GamepadJoyInput.java

/*
 * Copyright (c) 2009-2012 jMonkeyEngine
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 *
 * * Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 *
 * * Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in the
 *   documentation and/or other materials provided with the distribution.
 *
 * * Neither the name of 'jMonkeyEngine' nor the names of its contributors
 *   may be used to endorse or promote products derived from this software
 *   without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

package com.jme3.input.android;

import android.app.Activity;
import android.content.Context;
import android.hardware.SensorManager;
import android.os.Vibrator;
import android.view.InputDevice;
import android.view.KeyEvent;
import android.view.MotionEvent;
import android.view.Surface;
import android.view.View;
import com.jme3.input.AbstractJoystick;
import com.jme3.input.DefaultJoystickAxis;
import com.jme3.input.DefaultJoystickButton;
import com.jme3.input.InputManager;
import com.jme3.input.JoyInput;
import com.jme3.input.Joystick;
import com.jme3.input.JoystickAxis;
import com.jme3.input.JoystickButton;
import com.jme3.input.SensorJoystickAxis;
import com.jme3.input.RawInputListener;
import com.jme3.input.event.JoyAxisEvent;
import com.jme3.input.event.JoyButtonEvent;
import com.jme3.math.FastMath;
import com.jme3.system.android.JmeAndroidSystem;
import com.jme3.util.IntMap;
import com.jme3.util.IntMap.Entry;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.logging.Level;
import java.util.logging.Logger;
import net.java.games.input.Component;

/**
 * GamepadJoyInput converts the Android Sensor system into Joystick events.
 * A single joystick is configured and includes data for all configured sensors
 * as seperate axes of the joystick.
 *
 * Each axis is named accounting to the static strings in SensorJoystickAxis.
 * Refer to the strings defined in SensorJoystickAxis for a list of supported
 * sensors and their axis data.  Each sensor type defined in SensorJoystickAxis
 * will be attempted to be configured.  If the device does not support a particular
 * sensor, the axis will return null if joystick.getAxis(String name) is called.
 *
 * The joystick.getXAxis and getYAxis methods of the joystick are configured to
 * return the device orientation values in the device's X and Y directions.
 *
 * This joystick also supports the joystick.rumble(rumbleAmount) method.  In this
 * case, when joystick.rumble(rumbleAmount) is called, the Android device will vibrate
 * if the device has a built in vibrate motor.
 *
 * Because Andorid does not allow for the user to define the intensity of the
 * vibration, the rumble amount (ie strength) is converted into vibration pulses
 * The stronger the strength amount, the shorter the delay between pulses.  If
 * amount is 1, then the vibration stays on the whole time.  If amount is 0.5,
 * the vibration will a pulse of equal parts vibration and delay.
 * To turn off vibration, set rumble amount to 0.
 *
 * MainActivity needs the following line to enable Joysticks on Android platforms
 *    joystickEventsEnabled = true;
 * This is done to allow for battery conservation when sensor data is not required
 * by the application.
 *
 * To use the joystick rumble feature, the following line needs to be
 * added to the Android Manifest File
 *     <uses-permission android:name="android.permission.VIBRATE"/>
 *
 * @author iwgeric
 */
public class GamepadJoyInput implements JoyInput, View.OnGenericMotionListener, View.OnKeyListener {
    private final static Logger logger = Logger.getLogger(GamepadJoyInput.class.getName());

    private Activity activity = null;
    private InputManager inputManager = null;
    private android.hardware.input.InputManager androidInputManager = null;
    private int[] devicesIDs;
    private InputDevice inputDevice = null;
    private Vibrator vibrator = null;
    private boolean vibratorActive = false;
    private long maxRumbleTime = 250;  // 250ms
    private RawInputListener listener = null;
    private IntMap<SensorData> sensors = new IntMap<SensorData>();
    private Map<InputDevice, AndroidJoystick> joystickIndex = new HashMap<InputDevice, AndroidJoystick>();
    private AndroidJoystick[] joysticks;
    private int lastRotation = 0;
    private boolean initialized = false;
    private boolean loaded = false;
    private View mView = null;

    private final ArrayList<JoyAxisEvent> eventQueue = new ArrayList<JoyAxisEvent>();
    private final ArrayList<JoyButtonEvent> buttoneventQueue = new ArrayList<JoyButtonEvent>();

    public void setView(View view)
    {
        mView = view;
        if (view != null)
        {
            view.setOnGenericMotionListener(this);
            view.setOnKeyListener(this);
        }
    }

    public boolean onGenericMotion(View view, MotionEvent event)
    {
        boolean success = false;

        SensorData sensorData = sensors.get(inputDevice.getId());

        if (!initialized || !loaded)
        {
            return view.onGenericMotionEvent(event);
        }

        // Check that the event came from a joystick since a generic motion event
        // could be almost anything.
        if ((event.getSource() & InputDevice.SOURCE_GAMEPAD) != 0
                && event.getAction() == MotionEvent.ACTION_MOVE) {
            // Cache the most recently obtained device information.
            // The device information may change over time but it can be
            // somewhat expensive to query.
            if (inputDevice == null || inputDevice.getId() != event.getDeviceId()) {
                inputDevice = event.getDevice();
                // It's possible for the device id to be invalid.
                // In that case, getDevice() will return null.
                if (inputDevice == null) {
                    return false;
                }
            }

            // Process all historical movement samples in the batch.
            final int historySize = event.getHistorySize();
            for (int i = 0; i < historySize; i++) {
                processJoystickInput(event, i, sensorData);
            }

            // Process the current movement sample in the batch.
            processJoystickInput(event, -1, sensorData);
            return true;
        }
        return true;
    }

    private void processJoystickInput(MotionEvent event, int historyPos, SensorData sensorData)
    {

        // Get joystick position.
        // Many game pads with two joysticks report the position of the second joystick
        // using the Z and RZ axes so we also handle those.
        // In a real game, we would allow the user to configure the axes manually.
        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);
        }

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

        if (sensorData != null && sensorData.enabled)
        {

            for (int i=0; i<sensorData.lastValues.length; i++)
            {
                sensorData.lastValues[i] = event.getAxisValue(i);
            }

            if (sensorData != null && sensorData.axes.size() > 0)
            {
                AndroidJoystickAxis axis;
                for (int i=0; i<event.getHistorySize(); i++)
                {
                    axis = sensorData.axes.get(i);
                    if (axis != null) {
                        axis.setCurRawValue(event.getAxisValue(i));
                        if (!sensorData.haveData) {
                            sensorData.haveData = true;
                        } else {
                            synchronized (eventQueue){
                                if (axis.isChanged()) {
                                    eventQueue.add(new JoyAxisEvent(axis, axis.getJoystickAxisValue()));
                                }
                            }
                        }
                    }
                }
            } else if (sensorData != null)
            {
                if (!sensorData.haveData) {
                    sensorData.haveData = true;
                }
            }


        }
    }

    private static float getCenteredAxis(MotionEvent event, InputDevice device,
            int axis, int historyPos) {
        final InputDevice.MotionRange range = device.getMotionRange(axis, event.getSource());
        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.
            // A joystick at rest does not always report an absolute position of (0,0).
            if (Math.abs(value) > flat) {
                return value;
            }
        }
        return 0;
    }

    public boolean onKey(View view, int i, KeyEvent ke)
    {
        int firstButton = 0;
        SensorData sensorData = sensors.get(inputDevice.getId());

        AndroidJoystickButton button = sensorData.buttons.get(firstButton);

        synchronized (buttoneventQueue)
        {
            if(ke.getAction() == KeyEvent.ACTION_DOWN)
            {
                button.setPressed(true);
                buttoneventQueue.add(new JoyButtonEvent(button, button.isPressed()));
            }
            else if(ke.getAction() == KeyEvent.ACTION_UP)
            {
                button.setPressed(false);
                buttoneventQueue.add(new JoyButtonEvent(button, button.isPressed()));
            }
        }

        return true;
    }

    /**
     * Internal class to enclose data for each sensor.
     */
    private class SensorData
    {
        int androidSensorType = -1;
        int androidSensorSpeed = SensorManager.SENSOR_DELAY_GAME;
        InputDevice myinputDevice = null;
        int sensorAccuracy = 0;
        float[] lastValues;
        final Object valuesLock = new Object();
        ArrayList<AndroidJoystickAxis> axes = new ArrayList<AndroidJoystickAxis>();
        ArrayList<AndroidJoystickButton> buttons = new ArrayList<AndroidJoystickButton>();
        boolean enabled = false;
        boolean haveData = false;

        public SensorData(int androidSensorType, InputDevice inputDevice) {
            this.androidSensorType = androidSensorType;
            this.myinputDevice = inputDevice;
        }

    }

    private void initSensorManager() {
        this.activity = JmeAndroidSystem.getActivity();
        // Get instance of Vibrator from current Context
        vibrator = (Vibrator) activity.getSystemService(Context.VIBRATOR_SERVICE);
        if (vibrator == null) {
            logger.log(Level.FINE, "Vibrator Service not found.");
        }
    }

    /**
     * Pauses the sensors to save battery life if the sensors are not needed.
     * Used to pause sensors when the activity pauses
     */
    public void pauseSensors()
    {
        if (vibrator != null && vibratorActive) {
            vibrator.cancel();
        }
    }

    /**
     * Resumes the sensors.
     * Used to resume sensors when the activity comes to the top of the stack
     */
    public void resumeSensors()
    {

    }

    /*
     * Allows the orientation data to be rotated based on the current device
     * rotation.  This keeps the data aligned with the game when the user
     * rotates the device during game play.
     *
     * Android remapCoordinateSystem from the Android docs
     * remapCoordinateSystem(float[] inR, int X, int Y, float[] outR)
     *
     * @param   inR   the rotation matrix to be transformed. Usually it is the matrix
     *          returned by getRotationMatrix(float[], float[], float[], float[]).
     *
     * @param   outR  the transformed rotation matrix. inR and outR can be the same
     *          array, but it is not recommended for performance reason.
     *
     * X     defines on which world (Earth) axis and direction the X axis of the device is mapped.
     * Y     defines on which world (Earth) axis and direction the Y axis of the device is mapped.
     *
     * @return True if successful
     */
    private boolean remapCoordinates(float[] inR, float[] outR) {
        int xDir = SensorManager.AXIS_X;
        int yDir = SensorManager.AXIS_Y;
        int curRotation = getScreenRotation();
        if (lastRotation != curRotation) {
            logger.log(Level.FINE, "Device Rotation changed to: {0}", curRotation);
        }
        lastRotation = curRotation;

//        logger.log(Level.FINE, "Screen Rotation: {0}", getScreenRotation());
        switch (getScreenRotation()) {
            // device natural position
            case Surface.ROTATION_0:
                xDir = SensorManager.AXIS_X;
                yDir = SensorManager.AXIS_Y;
                break;
            // device rotated 90 deg counterclockwise
            case Surface.ROTATION_90:
                xDir = SensorManager.AXIS_Y;
                yDir = SensorManager.AXIS_MINUS_X;
                break;
            // device rotated 180 deg counterclockwise
            case Surface.ROTATION_180:
                xDir = SensorManager.AXIS_MINUS_X;
                yDir = SensorManager.AXIS_MINUS_Y;
                break;
            // device rotated 270 deg counterclockwise
            case Surface.ROTATION_270:
                xDir = SensorManager.AXIS_MINUS_Y;
                yDir = SensorManager.AXIS_X;
                break;
            default:
                break;
        }
        return SensorManager.remapCoordinateSystem(inR, xDir, yDir, outR);
    }

    /**
     * Returns the current device rotation.
     * Surface.ROTATION_0 = device in natural default rotation
     * Surface.ROTATION_90 = device in rotated 90deg counterclockwise
     * Surface.ROTATION_180 = device in rotated 180deg counterclockwise
     * Surface.ROTATION_270 = device in rotated 270deg counterclockwise
     *
     * When the Manifest locks the orientation, this value will not change during
     * gametime, but if the orientation of the screen is based off the sensor,
     * this value will change as the device is rotated.
     * @return Current device rotation amount
     */
    private int getScreenRotation() {
        return activity.getWindowManager().getDefaultDisplay().getRotation();
    }

    // Start of JoyInput methods

    public void setJoyRumble(int joyId, float amount) {
        // convert amount to pulses since Android doesn't allow intensity
        if (vibrator != null) {
            final long rumbleOnDur = (long)(amount * maxRumbleTime); // ms to pulse vibration on
            final long rumbleOffDur = maxRumbleTime - rumbleOnDur; // ms to delay between pulses
            final long[] rumblePattern = {
                0, // start immediately
                rumbleOnDur, // time to leave vibration on
                rumbleOffDur // time to delay between vibrations
            };
            final int rumbleRepeatFrom = 0; // index into rumble pattern to repeat from

            logger.log(Level.FINE, "Rumble amount: {0}, rumbleOnDur: {1}, rumbleOffDur: {2}",
                    new Object[]{amount, rumbleOnDur, rumbleOffDur});

            if (rumbleOnDur > 0) {
                vibrator.vibrate(rumblePattern, rumbleRepeatFrom);
                vibratorActive = true;
            } else {
                vibrator.cancel();
                vibratorActive = false;
            }
        }

    }

    public Joystick[] loadJoysticks(InputManager inputManager) {
        this.inputManager = inputManager;

        androidInputManager = (android.hardware.input.InputManager) JmeAndroidSystem.getActivity().getSystemService(Context.INPUT_SERVICE);

        devicesIDs = new int[androidInputManager.getInputDeviceIds().length];

        System.arraycopy(androidInputManager.getInputDeviceIds(), 0, devicesIDs, 0, androidInputManager.getInputDeviceIds().length);


        for(int index = 0; index < devicesIDs.length; index++)
        {
            inputDevice = androidInputManager.getInputDevice(devicesIDs[index]);
            System.out.println("Input Device Name: " + inputDevice.getName());
        }


        initSensorManager();
        setView(mView);

        int myButtonNumber = 96;

        SensorData sensorData;
        List<Joystick> list = new ArrayList<Joystick>();
        AndroidJoystick joystick;
        AndroidJoystickAxis axis;
        AndroidJoystickButton button;

        joystick = new AndroidJoystick(inputManager,
                                    this,
                                    list.size(),
                                    "AndroidSensorsJoystick");
        list.add(joystick);

        // manually create orientation sensor data since orientation is not a physical sensor
        sensorData = new SensorData(InputDevice.SOURCE_GAMEPAD, inputDevice);

        //sensorData.sensor = sensorManager.getDefaultSensor(sensorType);
        sensorData.enabled = true;

        if (sensorData != null) {
            sensorData.lastValues = new float[2];
            sensors.put(inputDevice.getId(), sensorData);

            axis = joystick.addAxis(SensorJoystickAxis.ORIENTATION_X, SensorJoystickAxis.ORIENTATION_X, joystick.getAxisCount(), FastMath.HALF_PI);
            joystick.setYAxis(axis); // joystick y axis = rotation around device x axis
            sensorData.axes.add(axis);

            button = joystick.addButton(JoystickButton.BUTTON_0, JoystickButton.BUTTON_0, myButtonNumber);
            joystick.setButton(button);
            sensorData.buttons.add(button);

            axis = joystick.addAxis(SensorJoystickAxis.ORIENTATION_Y, SensorJoystickAxis.ORIENTATION_Y, joystick.getAxisCount(), FastMath.HALF_PI);
            joystick.setXAxis(axis); // joystick x axis = rotation around device y axis
            sensorData.axes.add(axis);
        }

        joysticks = list.toArray( new AndroidJoystick[list.size()] );
        loaded = true;
        return joysticks;
    }

    public void initialize()
    {
        initialized = true;
        loaded = false;
    }

    public void update() {
        if (!loaded) {
            return;
        }
        synchronized (eventQueue){
            // flush events to listener
            if (listener != null && eventQueue.size() > 0) {
                for (int i = 0; i < eventQueue.size(); i++){
                    listener.onJoyAxisEvent(eventQueue.get(i));
                }
                eventQueue.clear();
            }
        }

        synchronized (buttoneventQueue)
        {
            // flush events to listener
            if (listener != null && buttoneventQueue.size() > 0) {
                for (int i = 0; i < buttoneventQueue.size(); i++){
                    listener.onJoyButtonEvent(buttoneventQueue.get(i));
                }
                buttoneventQueue.clear();
            }
        }
    }

    public void destroy() {
        logger.log(Level.FINE, "Doing Destroy.");
        pauseSensors();
        sensors.clear();
        eventQueue.clear();
        buttoneventQueue.clear();
        initialized = false;
        loaded = false;
        joysticks = null;
        vibrator = null;
        activity = null;
    }

    public boolean isInitialized() {
        return initialized;
    }

    public void setInputListener(RawInputListener listener) {
        this.listener = listener;
    }

    public long getInputTimeNanos() {
        return System.nanoTime();
    }

    // End of JoyInput methods

    protected class AndroidJoystick extends AbstractJoystick {
        private JoystickAxis nullAxis;
        private JoystickAxis xAxis;
        private JoystickAxis yAxis;
        private JoystickAxis povX;
        private JoystickAxis povY;
        private JoystickButton button;

        private Map<Integer, JoystickButton> buttonIndex = new HashMap<Integer, JoystickButton>();

        public AndroidJoystick( InputManager inputManager, JoyInput joyInput,
                                int joyId, String name){

            super( inputManager, joyInput, joyId, name );

            this.nullAxis = new DefaultJoystickAxis( getInputManager(), this, -1,
                                                     "Null", "null", false, false, 0 );
            this.xAxis = nullAxis;
            this.yAxis = nullAxis;
            this.povX = nullAxis;
            this.povY = nullAxis;

        }

        protected AndroidJoystickAxis addAxis(String axisName, String logicalName, int axisNum, float maxRawValue) {
            AndroidJoystickAxis axis;

            axis = new AndroidJoystickAxis(
                    inputManager,               // InputManager (InputManager)
                    this,                       // parent Joystick (Joystick)
                    axisNum,                    // Axis Index (int)
                    axisName,                   // Axis Name (String)
                    logicalName,                // Logical ID (String)
                    true,                       // isAnalog (boolean)
                    false,                      // isRelative (boolean)
                    0.01f,                      // Axis Deadzone (float)
                    maxRawValue);               // Axis Max Raw Value (float)

            super.addAxis(axis);

            return axis;
        }

        protected AndroidJoystickButton addButton(String buttonName, String logicalName, int buttonNum) {
            AndroidJoystickButton mybutton;

            mybutton = new AndroidJoystickButton(
                    inputManager,               // InputManager (InputManager)
                    this,                       // parent Joystick (Joystick)
                    buttonNum,                    // Axis Index (int)
                    buttonName,                   // Axis Name (String)
                    logicalName);                // Logical ID (String)

            super.addButton(mybutton);

            return mybutton;
        }

        protected void setButton(JoystickButton bttn)
        {
            button = bttn;
        }

        protected void setXAxis(JoystickAxis axis) {
            xAxis = axis;
        }
        protected void setYAxis(JoystickAxis axis) {
            yAxis = axis;
        }

        @Override
        public JoystickAxis getXAxis() {
            return xAxis;
        }

        @Override
        public JoystickAxis getYAxis() {
            return yAxis;
        }

        @Override
        public JoystickAxis getPovXAxis() {
            return povX;
        }

        @Override
        public JoystickAxis getPovYAxis() {
            return povY;
        }

    }

    public class AndroidJoystickAxis extends DefaultJoystickAxis implements SensorJoystickAxis {
        float zeroRawValue = 0f;
        float curRawValue = 0f;
        float lastRawValue = 0f;
        boolean hasChanged = false;
        float maxRawValue = FastMath.HALF_PI;
        boolean enabled = true;

        public AndroidJoystickAxis(InputManager inputManager, Joystick parent,
                           int axisIndex, String name, String logicalId,
                           boolean isAnalog, boolean isRelative, float deadZone,
                           float maxRawValue) {
            super(inputManager, parent, axisIndex, name, logicalId, isAnalog, isRelative, deadZone);

            this.maxRawValue = maxRawValue;
        }

        public float getMaxRawValue() {
            return maxRawValue;
        }

        public void setMaxRawValue(float maxRawValue) {
            this.maxRawValue = maxRawValue;
        }

        protected float getLastRawValue() {
            return lastRawValue;
        }
        protected void setCurRawValue(float rawValue) {
            this.curRawValue = rawValue;
            if (Math.abs(curRawValue - lastRawValue) > getDeadZone()) {
                hasChanged = true;
                lastRawValue = curRawValue;
            } else {
                hasChanged = false;
            }
        }

        protected float getJoystickAxisValue() {
            return (lastRawValue-zeroRawValue) / maxRawValue;
        }

        protected boolean isChanged() {
            return hasChanged;
        }

        public void calibrateCenter() {
            zeroRawValue = lastRawValue;
            logger.log(Level.FINE, "Calibrating axis {0} to {1}",
                    new Object[]{getName(), zeroRawValue});
        }

    }

    public class AndroidJoystickButton extends DefaultJoystickButton
    {
        int keyCode = -1;
        boolean pressed = false;
        boolean hasChanged = false;

        public AndroidJoystickButton(InputManager inputManager, Joystick parent,
                int buttonIndex, String name, String logicalId)
        {
            super(inputManager, parent, buttonIndex, name, logicalId);
        }

        protected boolean isChanged() {
            return hasChanged;
        }

        protected void setPressed (boolean pr)
        {
            pressed = pr;
        }

        protected boolean isPressed()
        {
            return pressed;
        }

        protected int getKeyCode()
        {
            return keyCode;
        }

        protected void setKeyCode(int kc)
        {
            keyCode = kc;
        }
    }
}