Visão geral de sensores

A maioria dos dispositivos Android tem sensores integrados que medem movimento, orientação, e diversas condições ambientais. Esses sensores são capazes de fornecer dados brutos com alta precisão e precisão e são úteis se você deseja monitorar o movimento tridimensional do dispositivo ou do dispositivo ou se quiser monitorar mudanças no ambiente próximo a um dispositivo. Por exemplo, jogo pode rastrear leituras do sensor de gravidade de um dispositivo para inferir gestos complexos do usuário e movimentos, como inclinação, trepidação, rotação ou balanço. Da mesma forma, um aplicativo meteorológico pode usar uma o sensor de temperatura e de umidade do dispositivo para calcular e informar o ponto de condensação ou uma viagem o aplicativo pode usar o sensor de campo geomagnético e o acelerômetro para indicar uma bússola rolamento.

A plataforma Android é compatível com três categorias amplas de sensores:

• Sensores de movimento

  Esses sensores medem forças rotacionais e de aceleração em três eixos. Isso inclui acelerômetros, sensores de gravidade, giroscópios e vetor de rotação ou sensores.

• Sensores ambientais

  Esses sensores medem vários parâmetros ambientais, como a temperatura do ar ambiente e pressão, iluminação e umidade. Essa categoria inclui barômetros, fotômetros e termômetros.

• Sensores de posição

  Esses sensores medem a posição física de um dispositivo. Essa categoria inclui sensores de orientação e magnetômetros.

É possível acessar os sensores disponíveis no dispositivo e coletar dados brutos usando a API framework de sensor. O framework de sensor oferece várias classes e interfaces que ajudam você a realizar uma variedade de tarefas relacionadas aos sensores. Por exemplo, você pode usar o framework para as seguintes ações:

• Determinar quais sensores estão disponíveis em um dispositivo.
• Determinar os recursos de um sensor individual, como alcance máximo, fabricante, potência requisitos e resolução.
• Coletar dados brutos do sensor e definir a taxa mínima de velocidade dessa coleta.
• Registrar e cancelar o registro dos listeners de eventos que monitoram mudanças do sensor.

Esse tópico traz uma visão geral dos sensores disponíveis na plataforma Android. Ele também oferece uma introdução ao framework de sensor.

Introdução aos sensores

O framework de sensor do Android permite acessar vários tipos de sensores. Alguns desses sensores são são baseados em hardware e outros em software. Sensores baseados em hardware são componentes físicos criados em um celular ou tablet. Elas derivam os dados medindo diretamente como aceleração, intensidade do campo geomagnético ou mudança angular. Baseado em software não são dispositivos físicos, embora imitem sensores baseados em hardware. Sensores baseados em software derivam dados de um ou mais sensores baseados em hardware e às vezes são chamados ou sintéticos. Os sensores de aceleração linear e de gravidade são exemplos de ou sensores baseados em software. A Tabela 1 resume os sensores com suporte no Android de plataforma.

Alguns dispositivos Android têm todos os tipos de sensores. Por exemplo, a maioria dos celulares e tablets têm um acelerômetro e um magnetômetro, mas menos dispositivos têm barômetros ou termômetros. Além disso, um dispositivo pode ter mais de um sensor de um determinado tipo. Para por exemplo, um dispositivo pode ter dois sensores de gravidade, cada um com um alcance diferente.

Tabela 1. Tipos de sensor compatíveis com a plataforma Android.

Framework de sensor

É possível acessar esses sensores e coletar dados brutos por meio do framework de sensor do Android. O framework do sensor faz parte do pacote android.hardware e inclui o seguinte: classes e interfaces:

SensorManager

Use esta classe para criar uma instância do serviço do sensor. Essa classe fornece vários métodos para acessar e listar sensores, registrar e cancelar o registro de eventos do sensor ouvintes e adquirindo informações de orientação. Essa classe também oferece diversas constantes de sensor que são usados para informar a precisão do sensor, definir taxas de aquisição de dados e calibrar os sensores.

Sensor

Use esta classe para criar uma instância de um sensor específico. Essa classe fornece várias métodos que permitem determinar os recursos de um sensor.

SensorEvent

O sistema usa essa classe para criar um objeto de evento do sensor, que fornece informações sobre um evento do sensor. Um objeto de evento do sensor inclui as seguintes informações: os dados brutos do sensor, o tipo de sensor que gerou o evento, a precisão dos dados e o carimbo de data/hora do evento.

SensorEventListener

É possível usar essa interface para criar dois métodos de callback que recebem notificações (sensor eventos) quando os valores do sensor ou a precisão dele mudam.

Em um aplicativo normal, essas APIs relacionadas ao sensor são usadas para realizar duas tarefas básicas:

• Como identificar sensores e recursos do sensor

  Identificar sensores e recursos do sensor no ambiente de execução é útil se seu aplicativo que dependem de tipos ou recursos de sensores específicos. Por exemplo, talvez você queira identificar todos os sensores presentes em um dispositivo e desativar todos os recursos do aplicativo que dependem de sensores ausentes. Da mesma forma, talvez você queira identificar todos os sensores de um determinado tipo para que você possa escolher a implementação do sensor que tem o desempenho ideal para seu aplicativo.

• Monitorar eventos do sensor

  Para coletar dados brutos, você monitora os eventos do sensor. Um evento do sensor ocorre sempre que um sensor detecta uma mudança nos parâmetros que está medindo. Um evento do sensor oferece com quatro informações: o nome do sensor que acionou o evento, o carimbo de data/hora do evento, a precisão do evento e os dados brutos do sensor que acionaram o evento.

Disponibilidade do sensor

Embora a disponibilidade do sensor varie de acordo com o dispositivo, ela também pode variar entre dispositivos Android mais recentes. Isso ocorre porque os sensores do Android foram introduzidos ao longo de várias de entrada e saída de plataformas. Por exemplo, muitos sensores foram introduzidos no Android 1.5 (API de nível 3), mas alguns não foram implementados e não estavam disponíveis para uso até o Android 2.3 (API de nível 9). Da mesma forma, vários sensores foram introduzidos no Android 2.3 (API de nível 9) e no Android 4.0 (API de nível 14). Duas sensores foram descontinuados e substituídos por sensores mais novos e melhores.

A Tabela 2 resume a disponibilidade de cada sensor de acordo com a plataforma. Apenas quatro plataformas estão listadas porque são as plataformas que envolveram alterações de sensores. Os sensores que são listados como descontinuados ainda estarão disponíveis nas plataformas subsequentes (desde que o sensor está presente em um dispositivo), o que está de acordo com a política de compatibilidade com versões futuras do Android.

Tabela 2. Disponibilidade do sensor por plataforma.

¹ Esse tipo de sensor foi adicionado no Android 1.5 (API de nível 3) mas não estava disponível para uso até o Android 2.3 (API de nível 9).

² Esse sensor está disponível, mas foi descontinuada.

Identificar sensores e recursos do sensor

O framework de sensor do Android oferece vários métodos que facilitam determinar de execução que os sensores estão no dispositivo. A API também fornece métodos que permitem determinar capacidades de cada sensor, como alcance máximo, resolução e potência e cumprimento de requisitos regulatórios.

Para identificar os sensores de um dispositivo, primeiro você precisa fazer uma referência a eles serviço. Para isso, crie uma instância da classe SensorManager chamando o método getSystemService() e passando no argumento SENSOR_SERVICE. Exemplo:

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

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

Em seguida, você pode obter uma listagem de cada sensor em um dispositivo chamando o método getSensorList() e usando a constante TYPE_ALL. Exemplo:

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

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

Para listar todos os sensores de um determinado tipo, você pode usar outra constante em vez de TYPE_ALL, como TYPE_GYROSCOPE, TYPE_LINEAR_ACCELERATION ou TYPE_GRAVITY.

Você também pode determinar se um tipo específico de sensor existe em um dispositivo usando o método getDefaultSensor() e transmitindo o tipo constante para um sensor específico. Caso um dispositivo tenha mais de um sensor de um determinado tipo, um dos precisam ser designados como o sensor padrão. Se um sensor padrão não existir para um determinado tipo de sensor, a chamada do método retorna nulo, o que significa que o dispositivo não tem esse tipo de sensor Por exemplo, o código a seguir verifica se há um magnetômetro em um dispositivo:

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.
}

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.
}

Observação:o Android não exige que os fabricantes dos dispositivos criem de tipos específicos de sensores nos dispositivos com Android. Assim, os dispositivos podem ter uma ampla gama configurações de sensores.

Além de listar os sensores de um dispositivo, você pode usar os métodos públicos do Sensor para determinar as capacidades e os atributos de indivíduos ou sensores. Isso é útil se você quiser que seu aplicativo se comporte de maneira diferente com base em quais sensores ou disponíveis em um dispositivo. Por exemplo, é possível usar getResolution() e getMaximumRange() métodos para obter a resolução de um sensor e o intervalo máximo de medição. Você também pode usar o Método getPower() para saber os requisitos de energia de um sensor.

Dois dos métodos públicos são especialmente úteis se você quiser otimizar seu aplicativo para diferentes sensores do fabricante ou versões diferentes de um sensor. Por exemplo, se o aplicativo precisar monitorar gestos do usuário, como inclinação e agitação, crie um conjunto de filtros de dados e otimizações para dispositivos mais recentes que tenham um sensor de gravidade de um fornecedor específico e outra de regras de filtragem de dados e otimizações para dispositivos que não têm sensor de gravidade e apenas um acelerômetro. O exemplo de código a seguir mostra como usar os métodos getVendor() e getVersion() para fazer isso. Neste exemplo, procuramos um sensor de gravidade que liste a Google LLC como fornecedor e tem o número de versão 3. Se esse sensor específico não estiver presente no dispositivo, tentaremos usar o acelerômetro.

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

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.
    }
}

Outro método útil é o getMinDelay(), que retorna o intervalo de tempo mínimo (em microssegundos) que um sensor pode usar para detectar dados. Qualquer sensor que retorna um valor diferente de zero para a getMinDelay() é um streaming sensor Os sensores de streaming detectam dados em intervalos regulares e foram introduzidos no Android 2.3 (API nível 9). Se um sensor retornar zero quando você chamar o método getMinDelay(), isso significa que o não é um sensor de streaming porque relata dados somente quando há uma mudança no parâmetros que ele detecta.

O método getMinDelay() é útil porque permite você determina a taxa máxima em que um sensor pode coletar dados. Se determinados recursos do aplicativo exigirem muitos dados de entrada ou de streaming, você pode usar esse método para determinar se um sensor atenda a esses requisitos e ative ou desative os recursos relevantes em seu aplicativo de maneira adequada.

Atenção:a taxa máxima de aquisição de dados de um sensor não é necessariamente a taxa em que o framework de sensor fornece dados do sensor para seu aplicativo. A o framework do sensor relata dados por meio de eventos do sensor, e vários fatores influenciam a taxa em que seu aplicativo recebe eventos de sensor. Para saber mais, consulte Monitorar eventos do sensor.

Monitorar eventos do sensor

Para monitorar dados brutos do sensor, é preciso implementar dois métodos de callback que são expostos por Interface SensorEventListener: onAccuracyChanged() e onSensorChanged(). O sistema Android chama esses métodos sempre que ocorrer o seguinte:

• A precisão de um sensor muda.

  Nesse caso, o sistema invoca o método onAccuracyChanged(), fornecendo uma referência ao objeto Sensor que mudou e o nova precisão do sensor. A precisão é representada por uma das quatro constantes de status: SENSOR_STATUS_ACCURACY_LOW, SENSOR_STATUS_ACCURACY_MEDIUM, SENSOR_STATUS_ACCURACY_HIGH, ou SENSOR_STATUS_UNRELIABLE.

• Um sensor informa um novo valor.

  Nesse caso, o sistema invoca o método onSensorChanged(), fornecendo os um objeto SensorEvent. Um objeto SensorEvent contém informações sobre os novos dados do sensor, incluindo: precisão dos dados, sensor que gerou os dados, o carimbo de data/hora em que os dados foram gerados e o novo dados que o sensor registrou.

O código a seguir mostra como usar o método onSensorChanged() para monitorar dados de o sensor de luz. Este exemplo mostra os dados brutos do sensor em um TextView que é definido no arquivo main.xml como sensor_data.

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

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

Nesse exemplo, o atraso de dados padrão (SENSOR_DELAY_NORMAL) é especificado quando o método registerListener() é invocado. Os dados O atraso (ou taxa de amostragem) controla o intervalo em que os eventos do sensor são enviados ao aplicativo pelo método de callback onSensorChanged(). O padrão o atraso de dados é adequado para monitoramento a orientação típica da tela muda e usa um atraso de 200.000 microssegundos. É possível especificar outras atrasos de dados, como SENSOR_DELAY_GAME (20.000 microssegundos) atraso), SENSOR_DELAY_UI (atraso de 60.000 microssegundos) ou SENSOR_DELAY_FASTEST (atraso de 0 microssegundo). A partir do Android 3.0 (API nível 11), você também pode especificar o atraso como um valor absoluto (em microssegundos).

O atraso especificado é apenas uma sugestão. O sistema Android e outros aplicativos pode alterar esse atraso. Como prática recomendada, especifique o maior atraso possível, porque o sistema normalmente usa um atraso menor do que o especificado (ou seja, você deve escolher taxa de amostragem mais lenta que ainda atende às necessidades do seu aplicativo). Usar um atraso maior impõe uma carga menor no processador e, portanto, usa menos energia.

Não existe um método público para determinar a taxa em que o framework do sensor está enviando eventos de sensor para seu aplicativo. No entanto, é possível usar os carimbos de data/hora associados a cada do sensor para calcular a taxa de amostragem em vários eventos. Não é necessário alterar taxa de amostragem (atraso) depois que ela for definida. Se, por algum motivo, você precisar alterar o atraso, é necessário cancelar o registro e registrar de novo o listener do sensor.

Também é importante observar que este exemplo usa o onResume() e onPause() métodos de callback para registrar e cancelar o registro do evento do sensor ouvinte. Recomendamos sempre desativar os sensores desnecessários, principalmente atividade seja pausada. Não fazer isso pode descarregar a bateria em apenas algumas horas porque alguns sensores têm requisitos de energia substanciais e podem consumir energia da bateria rapidamente. O sistema não vai desativar os sensores automaticamente quando a tela for desligada.

Gerenciar diferentes configurações de sensores

O Android não especifica uma configuração de sensor padrão para dispositivos, o que significa que os fabricantes de dispositivos podem incorporar a configuração de sensor que quiserem Aparelhos com tecnologia Android. Por isso, os dispositivos podem incluir diversos de sensores em diversas configurações. Caso seu aplicativo dependa de um tipo específico de sensor, é preciso garantir que o sensor está presente em um dispositivo para que seu aplicativo possa ser executado corretamente.

Há duas opções para verificar se um determinado sensor está presente em um dispositivo:

• Detectar os sensores durante a execução e ativar ou desativar os recursos do aplicativo conforme apropriado.
• Usar os filtros do Google Play para segmentar os dispositivos que têm configurações de sensor específicas.

Cada opção é discutida nas seções a seguir.

Detectar sensores durante a execução

Se o seu aplicativo usa um tipo específico de sensor, mas não depende dele, você pode usar o framework de sensor para detectar o sensor durante a execução e desativar ou ativar os recursos do aplicativo conforme apropriado. Por exemplo, um aplicativo de navegação pode usar o sensor de temperatura, sensor de pressão, sensor de GPS e sensor de campo geomagnético para exibir a temperatura, sensor barométrico pressão, localização e direção da bússola. Se um dispositivo não tiver um sensor de pressão, você pode usar o para detectar a ausência do sensor de pressão no tempo de execução e desativar o parte da interface do aplicativo que exibe pressão. Por exemplo, o código a seguir verifica se há um sensor de pressão em um dispositivo:

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.
}

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.
}

Usar os filtros do Google Play para segmentar configurações de sensor específicas

Se você estiver publicando seu aplicativo no Google Play, poderá usar o <uses-feature> no arquivo de manifesto para filtrar o aplicativo dos dispositivos que não tenha a configuração de sensor apropriada para seu aplicativo. A O elemento <uses-feature> tem vários descritores de hardware que permitem filtrar aplicativos com base na presença de sensores específicos. Os sensores que você pode listar incluem: acelerômetro, barômetro, bússola (campo geomagnético), giroscópio, luz e proximidade. A Veja a seguir um exemplo de entrada de manifesto que filtra apps que não têm um acelerômetro:

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

Se você adicionar esse elemento e descritor ao manifesto do aplicativo, os usuários verão seus aplicativo no Google Play apenas se o dispositivo tiver um acelerômetro.

Defina o descritor como android:required="true" somente se seu aplicativo depende inteiramente de um sensor específico. Se seu aplicativo usa um sensor para alguma funcionalidade, mas ainda funcionar sem o sensor, liste-o no <uses-feature> mas defina o descritor como android:required="false". Isso ajuda a garantir os dispositivos podem instalar o app mesmo que não tenham o sensor específico. Esta também é uma práticas recomendadas de gerenciamento de projetos que ajudam a acompanhar os recursos que seu aplicativo usa. Tenha em mente que, se seu aplicativo usa um sensor específico, mas ainda funciona sem o sensor, você deve detectar o sensor durante a execução e desativar ou ativar os recursos do aplicativo apropriados.

Sistema de coordenadas do sensor

Em geral, o framework do sensor usa um sistema de coordenadas padrão de três eixos para expressar valores de dados. Na maioria dos sensores, o sistema de coordenadas é definido em relação à tela do dispositivo quando ele é mantida na orientação padrão (veja a figura 1). Quando um dispositivo é mantido na orientação padrão, o eixo X é horizontal e aponta para a direita, o eixo Y é vertical e aponta para cima, e o eixo Z é eixo aponta para fora da face da tela. Neste sistema, as coordenadas atrás da tela têm valores de Z negativos. Esse sistema de coordenadas é usado pelos seguintes sensores:

Figura 1. Sistema de coordenadas (relativo a um dispositivo) usado pelo sensor API.

• Aceleração sensor
• Gravidade sensor
• Giroscópio
• Aceleração linear sensor
• Campo geomagnético sensor

O ponto mais importante a se entender sobre esse sistema de coordenadas é que os eixos não são trocada quando a orientação da tela do dispositivo mudar, ou seja, o sistema de coordenadas do sensor nunca muda quando o dispositivo é movido. Este comportamento é igual ao do OpenGL sistema de coordenadas.

Outro ponto a ser compreendido é que seu aplicativo não deve presumir que a interface natural (padrão) a orientação é retrato. A orientação natural de muitos tablets é a paisagem. E o sistema de coordenadas do sensor é sempre baseado na orientação natural do dispositivo.

Por fim, se seu aplicativo relaciona os dados do sensor à exibição na tela, você precisa usar o getRotation() para determinar a rotação da tela. Depois, use o Método remapCoordinateSystem() para mapear de coordenadas do sensor a coordenadas da tela. É necessário fazer isso mesmo que o manifesto especifique modo retrato.

Observação:alguns sensores e métodos usam um sistema de coordenadas que é relativo ao frame de referência do mundo (em oposição ao frame de referência do dispositivo). Esses sensores e métodos retornam dados que representam o movimento ou a posição do dispositivo em relação ao terra. Para mais informações, consulte o método getOrientation(), o método getRotationMatrix(), Orientação Sensor e Vetor de rotação Sensor.

Limitação de taxa do sensor

Para proteger informações potencialmente sensíveis dos usuários, caso seu app seja direcionado No Android 12 (nível 31 da API) ou versões mais recentes, o sistema impõe um limite na atualização taxa de dados de certos sensores de movimento e de posição. Esses dados inclui os valores registrados pelo acelerômetro, giroscópio campo geomagnético sensor.

O limite da taxa de atualização depende de como você acessa os dados do sensor:

• Se você chamar o método registerListener() para monitorar eventos do sensor, a taxa de amostragem do sensor será limitado a 200 Hz. Isso é válido para todas as variantes sobrecarregadas registerListener().
• Se você usar a classe SensorDirectChannel, a taxa de amostragem do sensor ficará limitada a RATE_NORMAL, que é geralmente cerca de 50 Hz.

Se o app precisar coletar dados do sensor de movimento a uma taxa mais alta, será necessário declarar o HIGH_SAMPLING_RATE_SENSORS permissão, conforme mostrado no snippet de código a seguir. Caso contrário, se o app tentar para coletar dados do sensor de movimento com uma taxa mais alta sem declarar essa permissão, ocorre um SecurityException.

AndroidManifest.xml

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

Práticas recomendadas para acessar e usar sensores

Ao projetar a implementação do sensor, siga as diretrizes discutidas na nesta seção. Essas diretrizes são práticas recomendadas para quem usa o sensor para acessar sensores e coletar dados deles.

Coletar dados do sensor apenas no primeiro plano

Em dispositivos com o Android 9 (nível 28 da API) ou versões mais recentes, os apps em execução no plano de fundo têm as seguintes restrições:

• Os sensores que usam o contínua modo de relatório, como acelerômetros e giroscópios, não recebem eventos.
• Os sensores que usam o ao mudar ou one-shot não recebem eventos.

Com essas restrições, é melhor detectar eventos do sensor quando seu está em primeiro plano ou como parte de um serviço em primeiro plano.

Cancelar o registro de listeners de sensor

Cancele o registro do listener de um sensor quando terminar de usar o sensor ou quando ele atividades pausadas. Se um listener do sensor for registrado e a atividade dele for pausada, o sensor continuará coletando dados e usando recursos da bateria, a menos que você cancele o registro do sensor. O seguinte O código mostra como usar o método onPause() para cancelar o registro de um listener:

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

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

Para mais informações, consulte unregisterListener(SensorEventListener).

Testar com o Android Emulator

O Android Emulator inclui um conjunto de controles de sensor virtual que permitem para testar sensores como o acelerômetro, a temperatura ambiente, o magnetômetro, proximidade, luz e muito mais.

O emulador usa uma conexão com um dispositivo Android que está executando o SdkControllerSensor (link em inglês) app. Esse aplicativo só está disponível em dispositivos com Android 4.0 (API nível 14) ou superior. Se o dispositivo estiver executando o Android 4.0, ele deverá ter Revisão 2 instalada. O app SdkControllerSensor monitora mudanças no os sensores do dispositivo e os transmite ao emulador. O emulador é depois transformados com base nos novos valores recebidos dos sensores seu dispositivo.

Você pode ver o código-fonte do app SdkControllerSensor na seguinte local:

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

Para transferir dados entre o dispositivo e o emulador, siga estas instruções etapas:

1. Verifique se a opção USB a depuração está ativada no dispositivo.
2. Conecte o dispositivo à máquina de desenvolvimento por meio de um cabo USB.
3. Abra o app SdkControllerSensor no dispositivo.
4. No app, selecione os sensores que você quer emular.

5. Execute este comando do adb:

$ adb forward tcp:1968 tcp:1968

6. Inicie o emulador. Agora você deve conseguir aplicar transformações à interface movendo o dispositivo.

Observação : se os movimentos que você faz nas dispositivo físico não estiver transformando o emulador, tente executar o adb da etapa 5 novamente.

Para mais informações, consulte a documentação do Android Guia do emulador.

Não bloqueie o método onSensorChanged()

Os dados do sensor podem mudar a uma taxa alta, o que significa que o sistema pode chamar o método onSensorChanged(SensorEvent) com bastante frequência. Como prática recomendada, deve fazer o mínimo possível dentro do método onSensorChanged(SensorEvent) para que ele não seja bloqueado. Se as aplicativo exigir que você faça alguma filtragem de dados ou redução de dados do sensor, você deve realizar que funcionam fora do método onSensorChanged(SensorEvent).

Evite usar métodos ou tipos de sensores obsoletos

Vários métodos e constantes tiveram o uso suspenso. Especificamente, o TYPE_ORIENTATION O tipo de sensor foi descontinuado. Para coletar dados de orientação, use o método getOrientation(). Da mesma forma, O tipo de sensor TYPE_TEMPERATURE foi descontinuado. Você deve usar o tipo de sensor TYPE_AMBIENT_TEMPERATURE em vez de dispositivos que executam o Android 4.0.

Verifique os sensores antes de usá-los

Sempre verifique se o sensor existe no dispositivo antes de tentar coletar dados dele. O que não fazer supor que um sensor existe simplesmente por ser usado com frequência. Os fabricantes de dispositivos não precisam fornecer sensores específicos nos dispositivos.

Tenha cuidado ao escolher os atrasos do sensor

Ao registrar um sensor com o método registerListener(), escolha uma taxa de envio adequada para sua ou caso de uso. Os sensores podem fornecer dados a taxas muito altas. Permitir que o sistema envie dados extras desnecessários desperdiçam recursos do sistema e consomem energia da bateria.