Panoramica dei sensori

La maggior parte dei dispositivi Android è dotata di sensori integrati che misurano il movimento, l'orientamento e varie condizioni ambientali. Questi sensori sono in grado di fornire dati non elaborati con precisione e accuratezza elevata e sono utili se vuoi monitorare il movimento o il posizionamento tridimensionale dei dispositivi oppure i cambiamenti nell'ambiente ambientale vicino a un dispositivo. Ad esempio, un gioco potrebbe monitorare le letture del sensore di gravità di un dispositivo per dedurre gesti e movimenti complessi degli utenti, come inclinazioni, scuotimenti, rotazione o oscillazione. Analogamente, un'applicazione meteo potrebbe utilizzare un sensore di temperatura e di umidità di un dispositivo per calcolare e segnalare il punto di rugiada, oppure un'applicazione di viaggio potrebbe utilizzare il sensore del campo geomagnetico e l'accelerometro per segnalare il cuscinetto della bussola.

La piattaforma Android supporta tre ampie categorie di sensori:

  • Sensori di movimento

    Questi sensori misurano le forze di accelerazione e rotazionali lungo tre assi. Questa categoria include accelerometri, sensori di gravità, giroscopi e sensori di vettore di rotazione.

  • Sensori ambientali

    Questi sensori misurano vari parametri ambientali, come pressione e temperatura dell'aria ambientale, illuminazione e umidità. Questa categoria include barometri, fotometri e termometri.

  • Sensori di posizione

    Questi sensori misurano la posizione fisica di un dispositivo. Questa categoria include sensori di orientamento e magnetometri.

Puoi accedere ai sensori disponibili sul dispositivo e acquisire dati non elaborati dei sensori utilizzando il framework dei sensori Android. Il framework dei sensori offre diverse classi e interfacce che ti aiutano a eseguire una vasta gamma di attività relative ai sensori. Ad esempio, puoi utilizzare la struttura del sensore per:

  • Stabilire quali sensori sono disponibili su un dispositivo.
  • Determina le capacità di un singolo sensore, ad esempio portata massima, produttore, requisiti di alimentazione e risoluzione.
  • Acquisire i dati non elaborati dei sensori e definire la velocità minima di acquisizione dei dati dei sensori.
  • Consente di registrare e annullare la registrazione dei listener di eventi dei sensori che monitorano le modifiche dei sensori.

Questo argomento fornisce una panoramica dei sensori disponibili sulla piattaforma Android. Offre inoltre un'introduzione alla struttura dei sensori.

Introduzione ai sensori

La struttura dei sensori Android ti consente di accedere a molti tipi di sensori. Alcuni di questi sensori sono basati su hardware, altri su software. I sensori basati su hardware sono componenti fisici integrati in uno smartphone o tablet. I dati ricavano i dati misurando direttamente proprietà ambientali specifiche, come accelerazione, intensità del campo geomagnetico o variazione angolare. I sensori basati su software non sono dispositivi fisici, sebbene imitano i sensori basati su hardware. I sensori basati su software ricavano i propri dati da uno o più sensori basati su hardware e sono talvolta denominati sensori virtuali o sensori sintetici. Il sensore di accelerazione lineare e il sensore di gravità sono esempi di sensori basati su software. La tabella 1 riassume i sensori supportati dalla piattaforma Android.

Pochi dispositivi Android dispongono di sensori di ogni tipo. Ad esempio, la maggior parte dei telefoni e tablet dispone di accelerometro e magnetometro, ma meno dispositivi dispongono di barometri o termometri. Inoltre, un dispositivo può avere più di un sensore di un determinato tipo. Ad esempio, un dispositivo può avere due sensori di gravità, ciascuno con un raggio d'azione diverso.

Tabella 1. Tipi di sensori supportati dalla piattaforma Android.

Sensore Tipo Descrizione Utilizzi comuni
TYPE_ACCELEROMETER Hardware Misura la forza di accelerazione in m/s2 applicata a un dispositivo su tutti e tre gli assi fisici (x, y e z), inclusa la forza di gravità. Rilevamento dei movimenti (scuotimento, inclinazione e così via).
TYPE_AMBIENT_TEMPERATURE Hardware Misura la temperatura ambiente della stanza in gradi Celsius (°C). Vedi la nota sotto. Monitoraggio della temperatura dell'aria.
TYPE_GRAVITY Software o hardware Misura la forza di gravità in m/s2 applicata a un dispositivo su tutti e tre gli assi fisici (x, y, z). Rilevamento dei movimenti (scuotimento, inclinazione e così via).
TYPE_GYROSCOPE Hardware Misura la velocità di rotazione di un dispositivo in rad/s attorno a ciascuno dei tre assi fisici (x, y e z). Rilevamento della rotazione (rotazione, svolta, ecc.).
TYPE_LIGHT Hardware Misura il livello di luce ambientale (illuminazione) in lx. Controllo della luminosità dello schermo.
TYPE_LINEAR_ACCELERATION Software o hardware Misura la forza di accelerazione in m/s2 applicata a un dispositivo su tutti e tre gli assi fisici (x, y e z), escludendo la forza di gravità. Monitoraggio dell'accelerazione su un singolo asse.
TYPE_MAGNETIC_FIELD Hardware Misura il campo geomagnetico ambientale per tutti e tre gli assi fisici (x, y, z) in μT. Creazione di una bussola.
TYPE_ORIENTATION streaming Misura i gradi di rotazione realizzati da un dispositivo intorno a tutti e tre gli assi fisici (x, y, z). A partire dal livello API 3, puoi ottenere la matrice di inclinazione e la matrice di rotazione per un dispositivo utilizzando il sensore di gravità e il sensore di campo geomagnetico in combinazione con il metodo getRotationMatrix(). Rilevamento della posizione del dispositivo in corso...
TYPE_PRESSURE Hardware Misura la pressione dell'aria ambiente in hPa o mbar. Monitoraggio delle variazioni della pressione atmosferica.
TYPE_PROXIMITY Hardware Misura la vicinanza di un oggetto in cm rispetto alla schermata di visualizzazione di un dispositivo. Questo sensore viene generalmente utilizzato per determinare se uno smartphone viene premuto verso l'orecchio di una persona. Posizione del telefono durante una chiamata.
TYPE_RELATIVE_HUMIDITY Hardware Misura l'umidità relativa ambiente in percentuale (%). Monitoraggio del punto di rugiada, dell'umidità assoluta e dell'umidità relativa.
TYPE_ROTATION_VECTOR Software o hardware Misura l'orientamento di un dispositivo fornendo i tre elementi del vettore di rotazione del dispositivo. Rilevamento dei movimenti e rilevamento della rotazione.
TYPE_TEMPERATURE Hardware Misura la temperatura del dispositivo in gradi Celsius (°C). L'implementazione del sensore varia in base al dispositivo e questo sensore è stato sostituito con il sensore TYPE_AMBIENT_TEMPERATURE nel livello API 14 Monitoraggio delle temperature in corso.

Struttura dei sensori

Puoi accedere a questi sensori e acquisire dati non elaborati dei sensori utilizzando il framework dei sensori Android. Il framework del sensore fa parte del pacchetto android.hardware e include le seguenti classi e interfacce:

SensorManager
Puoi utilizzare questa classe per creare un'istanza del servizio di sensore. Questa lezione offre vari metodi per accedere ai sensori e elencarli, registrare e annullare la registrazione degli ascoltatori di eventi dei sensori e acquisire informazioni di orientamento. Questa classe fornisce anche diverse costanti dei sensori utilizzate per segnalare la precisione dei sensori, impostare le frequenze di acquisizione dati e calibrare i sensori.
Sensor
Puoi utilizzare questa classe per creare un'istanza di un sensore specifico. Questa classe fornisce vari metodi per determinare le funzionalità di un sensore.
SensorEvent
Il sistema utilizza questa classe per creare un oggetto evento sensore, che fornisce informazioni su un evento sensore. Un oggetto evento del sensore include le seguenti informazioni: dati non elaborati del sensore, il tipo di sensore che ha generato l'evento, la precisione dei dati e il timestamp dell'evento.
SensorEventListener
Puoi utilizzare questa interfaccia per creare due metodi di callback che ricevono notifiche (eventi dei sensori) quando i valori del sensore cambiano o quando la precisione del sensore cambia.

In un'applicazione tipica si utilizzano queste API relative ai sensori per eseguire due attività di base:

  • Identificazione di sensori e funzionalità dei sensori

    Identificare i sensori e le funzionalità dei sensori in fase di runtime è utile se l'applicazione ha funzionalità che si basano su funzionalità o tipi di sensori specifici. Ad esempio, potresti voler identificare tutti i sensori presenti su un dispositivo e disabilitare tutte le funzionalità dell'applicazione che si basano su sensori non presenti. Allo stesso modo, potresti voler identificare tutti i sensori di un determinato tipo per scegliere l'implementazione dei sensori con le prestazioni ottimali per la tua applicazione.

  • Monitorare gli eventi dei sensori

    Il monitoraggio degli eventi dei sensori è il modo in cui acquisisci i dati non elaborati dei sensori. Un evento del sensore si verifica ogni volta che un sensore rileva una modifica nei parametri che sta misurando. Un evento del sensore fornisce quattro informazioni: il nome del sensore che ha attivato l'evento, il timestamp dell'evento, l'accuratezza dell'evento e i dati non elaborati del sensore che hanno attivato l'evento.

Disponibilità dei sensori

La disponibilità dei sensori varia da un dispositivo all'altro, ma può variare anche tra le versioni di Android. Questo perché i sensori Android sono stati introdotti nel corso di diverse release della piattaforma. Ad esempio, molti sensori sono stati introdotti in Android 1.5 (livello API 3), ma alcuni non sono stati implementati e non erano disponibili per l'uso fino ad Android 2.3 (livello API 9). Analogamente, sono stati introdotti diversi sensori in Android 2.3 (livello API 9) e Android 4.0 (livello API 14). Due sensori sono stati deprecati e sostituiti con sensori più recenti e migliori.

La Tabella 2 riassume la disponibilità di ciascun sensore piattaforma per piattaforma. Sono elencate solo quattro piattaforme perché sono quelle che hanno comportato le modifiche dei sensori. I sensori elencati come deprecati sono ancora disponibili sulle piattaforme successive (a condizione che sia presente su un dispositivo), il che è in linea con i criteri di compatibilità diretta di Android.

Tabella 2. Disponibilità dei sensori per piattaforma.

Sensore Android 4.0
(livello API 14)
Android 2.3
(livello API 9)
Android 2.2
(livello API 8)
Android 1.5
(livello API 3)
TYPE_ACCELEROMETER
TYPE_AMBIENT_TEMPERATURE n/a n/d n/a
TYPE_GRAVITY n/a n/a
TYPE_GYROSCOPE N/D1 N/D1
TYPE_LIGHT
TYPE_LINEAR_ACCELERATION n/a n/a
TYPE_MAGNETIC_FIELD
TYPE_ORIENTATION 2 2 2
TYPE_PRESSURE N/D1 N/D1
TYPE_PROXIMITY
TYPE_RELATIVE_HUMIDITY n/a n/d n/a
TYPE_ROTATION_VECTOR n/a n/a
TYPE_TEMPERATURE 2

1 Questo tipo di sensore è stato aggiunto in Android 1.5 (livello API 3), ma è stato reso disponibile solo per Android 2.3 (livello API 9).

2 Questo sensore è disponibile, ma è stato ritirato.

Identificazione di sensori e capacità dei sensori

Il framework dei sensori Android offre diversi metodi che ti consentono di determinare facilmente in tempo di esecuzione quali sensori si trovano su un dispositivo. L'API fornisce anche metodi che consentono di determinare le funzionalità di ciascun sensore, ad esempio l'intervallo massimo, la risoluzione e i requisiti di potenza.

Per identificare i sensori che si trovano su un dispositivo, devi prima ottenere un riferimento al servizio dei sensori. Per farlo, puoi creare un'istanza della classe SensorManager chiamando il metodo getSystemService() e passando l'argomento SENSOR_SERVICE. Ecco alcuni esempi:

Kotlin

private lateinit var sensorManager: SensorManager
...
sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager

Java

private SensorManager sensorManager;
...
sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);

Dopodiché puoi ottenere un elenco di tutti i sensori presenti su un dispositivo chiamando il metodo getSensorList() e utilizzando la costante TYPE_ALL. Ecco alcuni esempi:

Kotlin

val deviceSensors: List<Sensor> = sensorManager.getSensorList(Sensor.TYPE_ALL)

Java

List<Sensor> deviceSensors = sensorManager.getSensorList(Sensor.TYPE_ALL);

Per elencare tutti i sensori di un determinato tipo, puoi utilizzare un'altra costante al posto di TYPE_ALL, ad esempio TYPE_GYROSCOPE, TYPE_LINEAR_ACCELERATION o TYPE_GRAVITY.

Puoi anche determinare se su un dispositivo è presente un tipo specifico di sensore utilizzando il metodo getDefaultSensor() e trasmettendo la costante di tipo per un sensore specifico. Se un dispositivo è dotato di più sensori di un determinato tipo, uno dei sensori deve essere designato come sensore predefinito. Se per un determinato tipo di sensore non esiste un sensore predefinito, la chiamata al metodo restituisce null, il che significa che il dispositivo non dispone di quel tipo di sensore. Ad esempio, il seguente codice controlla se su un dispositivo è presente un magnetometro:

Kotlin

private lateinit var sensorManager: SensorManager
...
sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
if (sensorManager.getDefaultSensor(Sensor.TYPE_MAGNETIC_FIELD) != null) {
    // Success! There's a magnetometer.
} else {
    // Failure! No magnetometer.
}

Java

private SensorManager sensorManager;
...
sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
if (sensorManager.getDefaultSensor(Sensor.TYPE_MAGNETIC_FIELD) != null){
    // Success! There's a magnetometer.
} else {
    // Failure! No magnetometer.
}

Nota: Android non richiede ai produttori di integrare determinati tipi di sensori nei propri dispositivi Android, di conseguenza i dispositivi possono avere una vasta gamma di configurazioni dei sensori.

Oltre a elencare i sensori che si trovano su un dispositivo, puoi utilizzare i metodi pubblici della classe Sensor per determinare le funzionalità e gli attributi dei singoli sensori. Questo è utile se vuoi che l'applicazione si comporti in modo diverso in base ai sensori o alle funzionalità dei sensori disponibili su un dispositivo. Ad esempio, puoi utilizzare i metodi getResolution() e getMaximumRange() per ottenere la risoluzione e l'intervallo massimo di misurazione di un sensore. Puoi anche utilizzare il metodo getPower() per conoscere i requisiti di alimentazione di un sensore.

Due dei metodi pubblici sono particolarmente utili se vuoi ottimizzare l'applicazione per sensori di produttori diversi o per versioni differenti di un sensore. Ad esempio, se la tua applicazione deve monitorare i gesti dell'utente, come l'inclinazione e lo scuotimento, puoi creare un insieme di regole e ottimizzazioni di filtraggio dei dati per i dispositivi più recenti dotati di sensore di gravità di uno specifico fornitore e un altro insieme di regole e ottimizzazioni di filtraggio dei dati per i dispositivi che non hanno un sensore di gravità ma hanno solo un accelerometro. Il seguente esempio di codice mostra come utilizzare i metodi getVendor() e getVersion() per eseguire questa operazione. In questo esempio stiamo cercando un sensore di gravità che indichi Google LLC come fornitore e ha il numero di versione 3. Se quel particolare sensore non è presente sul dispositivo, proviamo a utilizzare l'accelerometro.

Kotlin

private lateinit var sensorManager: SensorManager
private var mSensor: Sensor? = null

...

sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager

if (sensorManager.getDefaultSensor(Sensor.TYPE_GRAVITY) != null) {
    val gravSensors: List<Sensor> = sensorManager.getSensorList(Sensor.TYPE_GRAVITY)
    // Use the version 3 gravity sensor.
    mSensor = gravSensors.firstOrNull { it.vendor.contains("Google LLC") && it.version == 3 }
}
if (mSensor == null) {
    // Use the accelerometer.
    mSensor = if (sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER) != null) {
        sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER)
    } else {
        // Sorry, there are no accelerometers on your device.
        // You can't play this game.
        null
    }
}

Java

private SensorManager sensorManager;
private Sensor mSensor;

...

sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
mSensor = null;

if (sensorManager.getDefaultSensor(Sensor.TYPE_GRAVITY) != null){
    List<Sensor> gravSensors = sensorManager.getSensorList(Sensor.TYPE_GRAVITY);
    for(int i=0; i<gravSensors.size(); i++) {
        if ((gravSensors.get(i).getVendor().contains("Google LLC")) &&
           (gravSensors.get(i).getVersion() == 3)){
            // Use the version 3 gravity sensor.
            mSensor = gravSensors.get(i);
        }
    }
}
if (mSensor == null){
    // Use the accelerometer.
    if (sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER) != null){
        mSensor = sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
    } else{
        // Sorry, there are no accelerometers on your device.
        // You can't play this game.
    }
}

Un altro metodo utile è il metodo getMinDelay(), che restituisce l'intervallo di tempo minimo (in microsecondi) che un sensore può utilizzare per rilevare i dati. Qualsiasi sensore che restituisce un valore diverso da zero per il metodo getMinDelay() è un sensore di streaming. I sensori di streaming rilevano i dati a intervalli regolari e sono stati introdotti in Android 2.3 (Livello API 9). Se un sensore restituisce zero quando chiami il metodo getMinDelay(), significa che il sensore non è un sensore di streaming perché segnala i dati solo quando si verifica una variazione nei parametri che rileva.

Il metodo getMinDelay() è utile perché consente di determinare la frequenza massima con cui un sensore può acquisire dati. Se determinate funzionalità della tua applicazione richiedono tassi di acquisizione dati elevati o un sensore di streaming, puoi utilizzare questo metodo per determinare se un sensore soddisfa quei requisiti e poi abilitare o disabilitare le funzionalità pertinenti nella tua applicazione di conseguenza.

Attenzione: la velocità massima di acquisizione dati di un sensore non corrisponde necessariamente a quella con cui il framework del sensore invia i dati del sensore alla tua applicazione. Il framework dei sensori segnala i dati tramite eventi dei sensori e diversi fattori influenzano la frequenza con cui l'applicazione riceve eventi dei sensori. Per ulteriori informazioni, consulta la sezione Monitoraggio degli eventi dei sensori.

Monitoraggio degli eventi dei sensori

Per monitorare i dati non elaborati dei sensori, devi implementare due metodi di callback esposti tramite l'interfaccia SensorEventListener: onAccuracyChanged() e onSensorChanged(). Il sistema Android chiama questi metodi ogni volta che si verifica quanto segue:

Il seguente codice mostra come utilizzare il metodo onSensorChanged() per monitorare i dati provenienti dal sensore di luce. Questo esempio mostra i dati non elaborati del sensore in un elemento TextView definito nel file main.xml come sensor_data.

Kotlin

class SensorActivity : Activity(), SensorEventListener {
    private lateinit var sensorManager: SensorManager
    private var mLight: Sensor? = null

    public override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.main)

        sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
        mLight = sensorManager.getDefaultSensor(Sensor.TYPE_LIGHT)
    }

    override fun onAccuracyChanged(sensor: Sensor, accuracy: Int) {
        // Do something here if sensor accuracy changes.
    }

    override fun onSensorChanged(event: SensorEvent) {
        // The light sensor returns a single value.
        // Many sensors return 3 values, one for each axis.
        val lux = event.values[0]
        // Do something with this sensor value.
    }

    override fun onResume() {
        super.onResume()
        mLight?.also { light ->
            sensorManager.registerListener(this, light, SensorManager.SENSOR_DELAY_NORMAL)
        }
    }

    override fun onPause() {
        super.onPause()
        sensorManager.unregisterListener(this)
    }
}

Java

public class SensorActivity extends Activity implements SensorEventListener {
    private SensorManager sensorManager;
    private Sensor mLight;

    @Override
    public final void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
        mLight = sensorManager.getDefaultSensor(Sensor.TYPE_LIGHT);
    }

    @Override
    public final void onAccuracyChanged(Sensor sensor, int accuracy) {
        // Do something here if sensor accuracy changes.
    }

    @Override
    public final void onSensorChanged(SensorEvent event) {
        // The light sensor returns a single value.
        // Many sensors return 3 values, one for each axis.
        float lux = event.values[0];
        // Do something with this sensor value.
    }

    @Override
    protected void onResume() {
        super.onResume();
        sensorManager.registerListener(this, mLight, SensorManager.SENSOR_DELAY_NORMAL);
    }

    @Override
    protected void onPause() {
        super.onPause();
        sensorManager.unregisterListener(this);
    }
}

In questo esempio, viene specificato il ritardo predefinito per i dati (SENSOR_DELAY_NORMAL) quando viene richiamato il metodo registerListener(). Il ritardo dei dati (o frequenza di campionamento) controlla l'intervallo con cui gli eventi dei sensori vengono inviati alla tua applicazione tramite il metodo di callback onSensorChanged(). Il ritardo predefinito dei dati è adatto per monitorare le variazioni tipiche dell'orientamento dello schermo e utilizza un ritardo di 200.000 microsecondi. Puoi specificare altri ritardi dei dati, ad esempio SENSOR_DELAY_GAME (ritardo di 20.000 microsecondi), SENSOR_DELAY_UI (ritardo di 60.000 microsecondi) o SENSOR_DELAY_FASTEST (ritardo di 0 microsecondi). A partire da Android 3.0 (Livello API 11) puoi anche specificare il ritardo come valore assoluto (in microsecondi).

Il ritardo specificato è solo un ritardo suggerito. Il sistema Android e altre applicazioni possono alterare questo ritardo. Come best practice, devi specificare il ritardo massimo possibile perché il sistema di solito utilizza un ritardo minore di quello specificato (ovvero, dovresti scegliere la frequenza di campionamento più lenta che soddisfa comunque le esigenze della tua applicazione). L'uso di un ritardo maggiore impone un carico inferiore al processore e pertanto consuma meno energia.

Non esiste un metodo pubblico per determinare la frequenza con cui il framework dei sensori invia eventi dei sensori alla tua applicazione. Tuttavia, puoi utilizzare i timestamp associati a ciascun evento del sensore per calcolare la frequenza di campionamento su più eventi. Una volta impostata, non dovresti modificare la frequenza di campionamento (ritardo). Se per qualche motivo è necessario modificare il ritardo, dovrai annullare la registrazione e registrare di nuovo il listener del sensore.

È inoltre importante notare che in questo esempio vengono utilizzati i metodi di callback onResume() e onPause() per registrare e annullare la registrazione dell'ascoltatore di eventi del sensore. Come best practice, dovresti sempre disattivare i sensori non necessari, soprattutto quando l'attività è in pausa. Se non lo fai, la batteria potrebbe scaricarsi in poche ore, perché alcuni sensori hanno un consumo elevato e possono esaurire velocemente la batteria. Il sistema non disattiverà automaticamente i sensori allo spegnimento dello schermo.

Gestione di diverse configurazioni dei sensori

Android non specifica una configurazione standard dei sensori per i dispositivi, il che significa che i produttori di dispositivi possono incorporare qualsiasi configurazione di sensore desiderata nei loro dispositivi Android. Di conseguenza, i dispositivi possono includere una varietà di sensori in un'ampia gamma di configurazioni. Se la tua applicazione si basa su un tipo specifico di sensore, devi assicurarti che il sensore sia presente su un dispositivo in modo che l'app possa funzionare correttamente.

Per assicurare che un determinato sensore sia presente su un dispositivo, hai due possibilità:

  • Rileva i sensori in fase di runtime e abilita o disabilita le funzionalità delle applicazioni in base alle esigenze.
  • Utilizza i filtri di Google Play per scegliere come target dispositivi con configurazioni di sensori specifiche.

Ogni opzione è descritta nelle sezioni seguenti.

Rilevamento dei sensori in fase di runtime

Se l'applicazione utilizza un tipo specifico di sensore, ma non si basa su di esso, puoi utilizzare il framework del sensore per rilevare il sensore in fase di runtime e quindi disabilitare o abilitare le funzionalità dell'applicazione in base alle esigenze. Ad esempio, un'applicazione di navigazione potrebbe utilizzare il sensore di temperatura, il sensore di pressione, il sensore GPS e il sensore del campo geomagnetico per visualizzare temperatura, pressione barometrica, posizione e rilevamento della bussola. Se un dispositivo non dispone di un sensore di pressione, puoi utilizzare il framework del sensore per rilevare l'assenza del sensore di pressione in fase di runtime e quindi disabilitare la porzione dell'UI della tua applicazione che mostra la pressione. Ad esempio, il codice seguente verifica se su un dispositivo è presente un sensore di pressione:

Kotlin

private lateinit var sensorManager: SensorManager
...
sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager

if (sensorManager.getDefaultSensor(Sensor.TYPE_PRESSURE) != null) {
    // Success! There's a pressure sensor.
} else {
    // Failure! No pressure sensor.
}

Java

private SensorManager sensorManager;
...
sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
if (sensorManager.getDefaultSensor(Sensor.TYPE_PRESSURE) != null){
    // Success! There's a pressure sensor.
} else {
    // Failure! No pressure sensor.
}

Utilizzare i filtri di Google Play per scegliere come target configurazioni di sensori specifiche

Se pubblichi la tua applicazione su Google Play, puoi utilizzare l'elemento <uses-feature> nel file manifest per filtrare l'applicazione dai dispositivi che non hanno la configurazione del sensore appropriata per la tua applicazione. L'elemento <uses-feature> ha diversi descrittori hardware che ti permettono di filtrare le applicazioni in base alla presenza di sensori specifici. I sensori che puoi elencare includono: accelerometro, barometro, bussola (campo geomagnetico), giroscopio, luce e prossimità. Di seguito è riportata una voce manifest di esempio che filtra le app che non hanno un accelerometro:

<uses-feature android:name="android.hardware.sensor.accelerometer"
              android:required="true" />

Se aggiungi questo elemento e descrittore al file manifest della tua applicazione, gli utenti vedranno la tua applicazione su Google Play soltanto se il loro dispositivo ha un accelerometro.

Devi impostare il descrittore su android:required="true" solo se la tua applicazione si basa interamente su un sensore specifico. Se l'applicazione utilizza un sensore per alcune funzionalità, ma continua a funzionare senza il sensore, devi elencare il sensore nell'elemento <uses-feature>, ma impostare il descrittore su android:required="false". Ciò contribuisce a garantire che i dispositivi possano installare la tua app anche se non dispongono di quel sensore specifico. È anche una best practice per la gestione dei progetti che ti aiuta a tenere traccia delle funzionalità utilizzate dalla tua applicazione. Tieni presente che se l'applicazione utilizza un determinato sensore, ma continua a funzionare senza il sensore, dovrai rilevare il sensore in fase di runtime e disabilitare o abilitare le funzionalità dell'applicazione in base alle esigenze.

Sistema di coordinate dei sensori

In generale, la struttura del sensore utilizza un sistema di coordinate standard a 3 assi per esprimere i valori dei dati. Per la maggior parte dei sensori, il sistema di coordinate viene definito in base allo schermo del dispositivo quando quest'ultimo viene mantenuto nell'orientamento predefinito (vedi la Figura 1). Quando un dispositivo viene tenuto nell'orientamento predefinito, l'asse X è orizzontale e punta a destra, l'asse Y è verticale e punta verso l'alto e l'asse Z è rivolto verso l'esterno dello schermo. In questo sistema, le coordinate dietro lo schermo hanno valori Z negativi. Questo sistema di coordinate viene utilizzato dai seguenti sensori:

Figura 1. Sistema di coordinate (relativo a un dispositivo) utilizzato dall'API Sensor.

Il punto più importante da capire di questo sistema di coordinate è che gli assi non vengono alterati quando l'orientamento dello schermo del dispositivo cambia, ovvero il sistema di coordinate del sensore non cambia mai con il movimento del dispositivo. Questo comportamento è uguale a quello del sistema di coordinate OpenGL.

Un altro punto da capire è che l'applicazione non deve presupporre che l'orientamento naturale (predefinito) di un dispositivo sia verticale. L'orientamento naturale di molti tablet è orizzontale. Inoltre, il sistema di coordinate dei sensori si basa sempre sull'orientamento naturale di un dispositivo.

Infine, se l'applicazione abbina i dati del sensore al display sullo schermo, devi utilizzare il metodo getRotation() per determinare la rotazione dello schermo e poi il metodo remapCoordinateSystem() per mappare le coordinate del sensore alle coordinate dello schermo. Devi farlo anche se il tuo manifest specifica la visualizzazione solo verticale.

Nota: alcuni sensori e metodi utilizzano un sistema di coordinate relativo al quadro di riferimento globale (anziché a quello del dispositivo). Questi sensori e metodi restituiscono dati che rappresentano il movimento o la posizione del dispositivo rispetto alla Terra. Per ulteriori informazioni, consulta i metodi getOrientation(), getRotationMatrix(), Orientation Sensor e Rotazione Vector Sensor.

Limitazione di frequenza del sensore

Per proteggere le informazioni potenzialmente sensibili sugli utenti, se la tua app ha come target Android 12 (livello API 31) o versioni successive, il sistema impone un limite alla frequenza di aggiornamento dei dati provenienti da determinati sensori di movimento e sensori di posizione. Questi dati includono valori registrati dall'accelerometro, dal giroscopio e dal sensore di campo geomagnetico del dispositivo.

Il limite di frequenza di aggiornamento dipende dal modo in cui accedi ai dati dei sensori:

Se la tua app deve raccogliere dati dei sensori di movimento a una velocità superiore, devi dichiarare l'autorizzazione HIGH_SAMPLING_RATE_SENSORS come mostrato nel seguente snippet di codice. In caso contrario, se la tua app cerca di raccogliere i dati dei sensori di movimento a una velocità superiore senza dichiarare questa autorizzazione, si verifica un errore SecurityException.

AndroidManifest.xml

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

Best practice per accedere e utilizzare i sensori

Quando progetti l'implementazione del sensore, assicurati di seguire le linee guida descritte in questa sezione. Queste linee guida sono best practice consigliate per chiunque utilizzi il framework dei sensori per accedere ai sensori e acquisire i relativi dati.

Raccogli soltanto i dati dei sensori in primo piano

Sui dispositivi con Android 9 (livello API 28) o versioni successive, le app eseguite in background hanno le seguenti limitazioni:

  • I sensori che utilizzano la modalità di segnalazione continua, ad esempio accelerometri e giroscopi, non ricevono eventi.
  • I sensori che utilizzano le modalità di reporting al cambiamento o one-shot non ricevono eventi.

Date queste restrizioni, è meglio rilevare gli eventi dei sensori quando la tua app è in primo piano o nell'ambito di un servizio in primo piano.

Annulla la registrazione dei listener dei sensori

Assicurati di annullare la registrazione dell'ascoltatore di un sensore quando hai finito di utilizzare il sensore o quando l'attività del sensore viene messa in pausa. Se un listener del sensore è registrato e la sua attività viene messa in pausa, il sensore continuerà ad acquisire dati e a utilizzare le risorse della batteria, a meno che non annulli la registrazione del sensore. Il seguente codice mostra come utilizzare il metodo onPause() per annullare la registrazione di un listener:

Kotlin

private lateinit var sensorManager: SensorManager
...
override fun onPause() {
    super.onPause()
    sensorManager.unregisterListener(this)
}

Java

private SensorManager sensorManager;
...
@Override
protected void onPause() {
    super.onPause();
    sensorManager.unregisterListener(this);
}

Per ulteriori informazioni, vedi unregisterListener(SensorEventListener).

Esegui test con l'emulatore Android

L'emulatore Android include una serie di controlli dei sensori virtuali che consentono di testare sensori come accelerometro, temperatura ambiente, magnetometro, prossimità, luce e altro ancora.

L'emulatore utilizza una connessione con un dispositivo Android su cui è in esecuzione l'app SdkControllerSensor. Tieni presente che questa app è disponibile solo su dispositivi con Android 4.0 (livello API 14) o versioni successive. Se sul dispositivo è installato Android 4.0, deve essere installata la Revisione 2. L'app SdkControllerSensor monitora le modifiche nei sensori del dispositivo e le trasmette all'emulatore. L'emulatore viene poi trasformato in base ai nuovi valori che riceve dai sensori sul tuo dispositivo.

Puoi visualizzare il codice sorgente per l'app SdkControllerSensor in questa posizione:

$ your-android-sdk-directory/tools/apps/SdkController

Per trasferire dati tra il tuo dispositivo e l'emulatore, segui questi passaggi:

  1. Verifica che il debug USB sia attivo sul dispositivo.
  2. Collega il dispositivo alla macchina di sviluppo utilizzando un cavo USB.
  3. Avvia l'app SdkControllerSensor sul dispositivo.
  4. Nell'app, seleziona i sensori che vuoi emulare.
  5. Esegui questo comando adb:

  6. $ adb forward tcp:1968 tcp:1968
    
  7. Avvia l'emulatore. Ora dovresti essere in grado di applicare le trasformazioni all'emulatore spostando il dispositivo.

Nota: se i movimenti che fai sul dispositivo fisico non stanno trasformando l'emulatore, prova a eseguire di nuovo il comando adb del passaggio 5.

Per ulteriori informazioni, consulta la guida dell'emulatore Android.

Non bloccare il metodo onSensorChanged()

I dati dei sensori possono cambiare ad alta frequenza, il che significa che il sistema potrebbe chiamare il metodo onSensorChanged(SensorEvent) abbastanza spesso. Come best practice, dovresti fare il meno possibile all'interno del metodo onSensorChanged(SensorEvent) per non bloccarlo. Se la tua applicazione richiede l'applicazione di filtri o riduzione dei dati dei sensori, dovresti eseguire questa operazione al di fuori del metodo onSensorChanged(SensorEvent).

Evita di utilizzare metodi o tipi di sensori obsoleti

Diversi metodi e costanti sono stati ritirati. In particolare, il tipo di sensore TYPE_ORIENTATION è stato ritirato. Per ottenere dati sull'orientamento, usa invece il metodo getOrientation(). Analogamente, il tipo di sensore TYPE_TEMPERATURE è stato ritirato. Dovresti usare il tipo di sensore TYPE_AMBIENT_TEMPERATURE sui dispositivi con Android 4.0.

Verifica i sensori prima di usarli

Verifica sempre che su un dispositivo sia presente un sensore prima di tentare di acquisire dati dal dispositivo. Non dare per scontato che un sensore esista semplicemente perché è un sensore utilizzato di frequente. I produttori di dispositivi non sono tenuti a fornire sensori specifici nei loro dispositivi.

Scegli attentamente i ritardi del sensore

Quando registri un sensore con il metodo registerListener(), assicurati di scegliere una tariffa di consegna adatta alla tua applicazione o al tuo caso d'uso. I sensori possono fornire dati a velocità molto elevate. Consentire al sistema di inviare dati aggiuntivi che non hai bisogno di spreca risorse di sistema e consuma energia a batteria.