Funzionalità aggiuntive del controller

I controller di gioco sono dotati di funzionalità aggiuntive che migliorano notevolmente l'interazione e l'immersione dei giocatori. Le funzionalità aptiche, i sensori di movimento e le luci dei controller di gioco Android sono particolarmente utili per approfondire e arricchire l'esperienza di gioco. Ogni funzionalità stimola in modo univoco i sensi del giocatore, favorendo interazioni più significative e intuitive all'interno del gioco.

Per dichiarare che la tua app supporta i controller di gioco, aggiungi la funzionalità android.hardware.gamepad al file manifest dell'app:

<manifest ...>
  ...
  <uses-feature android:name="android.hardware.gamepad" android:required="false"/>
  ...
</manifest>

Nota: quando specifichi il supporto di android.hardware.gamepad, imposta android:required su "false" se il supporto del controller di gioco è facoltativo. Imposta android:required su "true" solo se è necessario un controller di gioco per giocare al tuo gioco. Anche se l'impostazione di android:required="true" non limiterà la distribuzione della tua app, Google Play potrebbe mostrare un badge "Controller richiesto" nella scheda del Play Store e avvisare gli utenti prima dell'installazione.

Tecnologia aptica

La funzionalità aptica dei controller di gioco Android è una tecnologia fondamentale che fornisce un feedback tattile realistico durante il gameplay.

La tecnologia aptica trasmette sensazioni fisiche all'utente tramite vibrazioni o movimenti. Ad esempio, quando si verifica un'esplosione nel gioco, il controller vibra, consentendo al giocatore di sentire l'impatto in modo realistico. Inoltre, le vibrazioni sottili possono essere sincronizzate con il suono di un personaggio che cammina o corre, offrendo un'esperienza più realistica. Questo tipo di feedback aptico consente ai giocatori di sentire fisicamente i vari eventi che si verificano all'interno del gioco.

Questa tecnologia massimizza l'immersione del giocatore, amplifica le risposte emotive e arricchisce le dinamiche del gioco. Le impostazioni aptiche dei controller di gioco Android non solo ampliano le possibilità creative per gli sviluppatori di giochi, ma offrono anche ai giocatori un'esperienza di gioco più realistica che mai.

Kotlin

fun triggerVibrationMultiChannel(
  deviceId: Int, leftIntensity: Int, leftDuration: Int,
  rightIntensity: Int, rightDuration: Int) {
  val inputDevice = InputDevice.getDevice(deviceId)
  val vibratorManager = inputDevice!!.vibratorManager
  if (vibratorManager != null) {
    val vibratorIds = vibratorManager.vibratorIds
    val vibratorCount = vibratorIds.size
    if (vibratorCount > 0) {
      // We have an assumption that game controllers have two vibrators
      // corresponding to a left motor and a right motor, and the left
      // motor will be first.
      updateVibrator(vibratorManager.getVibrator(vibratorIds  [0]), leftIntensity, leftDuration)
      if (vibratorCount > 1) {
        updateVibrator(vibratorManager.getVibrator(vibratorIds[1]), rightIntensity, rightDuration)
      }
    }
  }
}

fun updateVibrator(vibrator: Vibrator?, intensity: Int, duration: Int) {
  if (vibrator != null) {
    if (intensity == 0) {
      vibrator.cancel()
    } else if (duration > 0) {
      vibrator.vibrate(VibrationEffect.createOneShot(duration.toLong(), intensity))
    }
  }
}

Java

public void triggerVibrationMultiChannel(
    int deviceId, int leftIntensity, int leftDuration,
    int rightIntensity, int rightDuration) {

    InputDevice inputDevice = InputDevice.getDevice(deviceId);

    // Check if device exists to avoid NullPointerException
    if (inputDevice == null) {
      return;
    }

    VibratorManager vibratorManager = inputDevice.getVibratorManager();
    if (vibratorManager != null) {
        int[] vibratorIds = vibratorManager.getVibratorIds();
        int vibratorCount = vibratorIds.length;

        if (vibratorCount > 0) {
            // We have an assumption that game controllers have two vibrators
            // corresponding to a left motor and a right motor, and the left
            // motor will be first.
            updateVibrator(vibratorManager.getVibrator(vibratorIds[0]), leftIntensity, leftDuration);

            if (vibratorCount > 1) {
                updateVibrator(vibratorManager.getVibrator(vibratorIds[1]), rightIntensity, rightDuration);
            }
        }
    }
}

public void updateVibrator(Vibrator vibrator, int intensity, int duration) {
    if (vibrator != null) {
        if (intensity == 0) {
            vibrator.cancel();
        } else if (duration > 0) {
            vibrator.vibrate(VibrationEffect.createOneShot. ((long) duration, intensity));
        }
    }
}

Per utilizzare la vibrazione, imposta una funzionalità e un'autorizzazione.

<manifest ...>
  ...
  <uses-permission android:name="android.permission.VIBRATE"/>
  ...
</manifest>

Per saperne di più su VibratorManager e sul file manifest dell'app.

Sensori di movimento

Una delle tecnologie più innovative che migliorano le esperienze di gioco è il controller di gioco Android dotato di sensori di movimento. Questa tecnologia rileva con precisione i movimenti fisici degli utenti e traduce questi dati in azioni all'interno del gioco, fornendo un'esperienza di gioco più intuitiva e coinvolgente. In questa introduzione, esploreremo il funzionamento delle funzionalità dei sensori di movimento nei controller di gioco Android.

I sensori di movimento in genere incorporano giroscopi e accelerometri per rilevare i movimenti e gli orientamenti degli utenti.

È necessario implementare le classi di listener di accelerazione e giroscopio e registrarle con il gestore dei sensori del controller.

Kotlin

fun setIntegratedAccelerometerActive(deviceId: Int) {
  val device = InputDevice.getDevice(deviceId)
  val sensorManager = device?.sensorManager
  val accelerometer = sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER)
  if (accelerometer != null) {
    val accelerometerListener =
      GameControllerAccelerometerListener(accelerometer)
    sensorManager.registerListener(
      accelerometerListener, accelerometer,
      SensorManager.SENSOR_DELAY_GAME
    )
  }
}

fun setIntegratedGyroscopeActive(deviceId: Int) {
  val device = InputDevice.getDevice(deviceId)
  val sensorManager = device?.sensorManager
  val gyroscope = sensorManager?.getDefaultSensor(Sensor.TYPE_GYROSCOPE)
  if (gyroscope != null) {
    val gyroscopeListener = GameControllerGyroscopeListener(gyroscope)
    sensorManager.registerListener(
      gyroscopeListener, gyroscope,
      SensorManager.SENSOR_DELAY_GAME
    )
  }
}

class GameControllerAccelerometerListener(private val listenerAccelerometer: Sensor?) :
  SensorEventListener {
  override fun onSensorChanged(event: SensorEvent) {
    if (listenerAccelerometer != null) {
      synchronized(listenerAccelerometer) {
        if (event.sensor == listenerAccelerometer) {
          Log.d("Accelerometer",
            "onSensorChanged " + event.values[0] + ", "
            + event.values[1] + ", " + event.values[2])
        }
      }
    }
  }

  override fun onAccuracyChanged(sensor: Sensor, accuracy: Int) {
  }
}

class GameControllerGyroscopeListener(private val listenerGyroscope: Sensor?) :
  SensorEventListener {
  override fun onSensorChanged(event: SensorEvent) {
    if (listenerGyroscope != null) {
      synchronized(listenerGyroscope) {
        if (event.sensor == listenerGyroscope) {
          Log.d("Gyroscope",
            "onSensorChanged " + event.values[0] + ", " +
            event.values[1] + ", " + event.values[2])
        }
      }
    }
 }

  override fun onAccuracyChanged(sensor: Sensor, accuracy: Int) {
  }
}

Java

public void setIntegratedAccelerometerActive(int deviceId) {
    InputDevice device = InputDevice.getDevice(deviceId);
    // Safe handling for null device or sensor manager
    if (device == null) {
      return;
    }
    SensorManager sensorManager = device.getSensorManager();
    if (sensorManager == null) {
      return;
    }

    Sensor accelerometer = sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
    if (accelerometer != null) {
      GameControllerAccelerometerListener   accelerometerListener =
          new GameControllerAccelerometerListener(accelerometer);
        sensorManager.registerListener(
          accelerometerListener, accelerometer,
          SensorManager.SENSOR_DELAY_GAME
        );
    }
}

public void setIntegratedGyroscopeActive(int deviceId) {
    InputDevice device = InputDevice.getDevice(deviceId);
    if (device == null) {
        return;
    }
    SensorManager sensorManager = device.getSensorManager();
    if (sensorManager == null) {
        return;
    }
    Sensor gyroscope = sensorManager.getDefaultSensor(Sensor.TYPE_GYROSCOPE);
    if (gyroscope != null) {
        GameControllerGyroscopeListener gyroscopeListener =
          new GameControllerGyroscopeListener(gyroscope);
        sensorManager.registerListener(
          gyroscopeListener, gyroscope,
          SensorManager.SENSOR_DELAY_GAME
        );
    }
}

public static class GameControllerAccelerometerListener implements SensorEventListener {
    private final Sensor listenerAccelerometer;
    public GameControllerAccelerometerListener(Sensor   listenerAccelerometer) {
        this.listenerAccelerometer = listenerAccelerometer;
    }
    @Override
    public void onSensorChanged(SensorEvent event) {
        if (listenerAccelerometer != null) {
            synchronized (listenerAccelerometer) {
                if (event.sensor == listenerAccelerometer) {
                    Log.d("Accelerometer",
                      "onSensorChanged " + event.values[0] + ", "
                      + event.values[1] + ", " + event.values[2]);
                }
            }
        }
    }
    @Override
    public void onAccuracyChanged(Sensor sensor, int accuracy) {
    }
}

public static class GameControllerGyroscopeListener implements SensorEventListener {
    private final Sensor listenerGyroscope;

    public GameControllerGyroscopeListener(Sensor listenerGyroscope) {
        this.listenerGyroscope = listenerGyroscope;
    }
    @Override
    public void onSensorChanged(SensorEvent event) {
        if (listenerGyroscope != null) {
            synchronized (listenerGyroscope) {
                if (event.sensor == listenerGyroscope) {
                    Log.d("Gyroscope",
                      "onSensorChanged " + event.values[0] +  ", " +
                        event.values[1] + ", " + event.values  [2]);
                }
            }
        }
    }
    @Override
    public void onAccuracyChanged(Sensor sensor, int accuracy) {
    }
}

Per saperne di più su sensori di movimento e su SensorEventListener.

Luci

Le impostazioni del colore delle luci sui controller di gioco Android aggiungono una nuova dimensione di immersione al gameplay tramite elementi visivi.

La funzionalità del colore delle luci utilizza le luci LED integrate nel controller per visualizzare vari colori, che rispondono in modo dinamico a diversi scenari di gioco. Ad esempio, le luci potrebbero lampeggiare in rosso quando la salute del giocatore è critica o diventare verdi al completamento di una missione specifica, fornendo un feedback visivo basato sugli eventi in-game. Queste impostazioni del colore delle luci aumentano il coinvolgimento degli utenti, aumentano la suspense e il divertimento del gioco e aiutano i giocatori a immergersi completamente nel mondo di gioco.

Le funzionalità del colore delle luci nei controller di gioco Android non hanno solo uno scopo decorativo, ma svolgono un ruolo importante nella creazione dell'atmosfera del gioco e nel miglioramento dell'esperienza utente.

Kotlin

fun changeControllerLightColor(deviceId: Int, color: Int) {
  val device = InputDevice.getDevice(deviceId)
  device?.let {
    if (it.sources and InputDevice.SOURCE_JOYSTICK == InputDevice.SOURCE_JOYSTICK) {
      val lightsManager = device.lightsManager
      lightsManager?.let { manager ->
        manager.lights.forEach { light ->
          val stateBuilder = LightState.Builder()
          stateBuilder.setColor(color)
          val requestBuilder = LightsRequest.Builder()
          requestBuilder.addLight(light, stateBuilder.build())
          val lightsSession = lightsManager.openSession()
          lightsSession.requestLights(requestBuilder.build())
        }
      }
    }
  }
}

Java

public void changeControllerLightColor(int deviceId, int  color) {
    InputDevice device = InputDevice.getDevice(deviceId);

    if (device != null) {
      // Check if the device is a joystick.
      // Note: Parentheses are required around the bitwise AND operation in Java
      // because == has higher precedence than &.
        if ((device.getSources() & InputDevice.  SOURCE_JOYSTICK) == InputDevice.SOURCE_JOYSTICK) {
            LightsManager lightsManager = device.getLightsManager();

            if (lightsManager != null) {
                for (Light light : lightsManager.getLights()) {
                    LightState.Builder stateBuilder = new   LightState.Builder();
                    stateBuilder.setColor(color);

                    LightsRequest.Builder requestBuilder = new LightsRequest.Builder();
                    requestBuilder.addLight(light, stateBuilder.build());

                    LightsManager.Session lightsSession =   lightsManager.openSession();
                    lightsSession.requestLights(requestBuilder.build());
                }
            }
        }
    }
}

Per utilizzare le luci del controller, dichiara la funzionalità del gamepad e l'autorizzazione LIGHTS nel file manifest:

<manifest ...>
  ...
  <uses-permission android:name="android.permission.LIGHTS" />
  ...
</manifest>

Per saperne di più su LightsManager e su file manifest dell'app.

Touchpad del controller

Alcuni controller di gioco includono un touchpad che può essere utilizzato per una serie di azioni in-game, come navigare nei menu o controllare i personaggi del gioco in modo più intuitivo.

Figura 1. Touchpad sul controller di gioco.

I controller di gioco con touchpad integrati offrono il controllo diretto del dispositivo su Android. Toccando il touchpad viene generato un puntatore del mouse sullo schermo, consentendo una navigazione intuitiva simile a quella del mouse.