Contente

• Quais sensores Android posso usar?
• Sensores ambientais: medindo a luz ambiente
• Exibindo seus dados do sensor
• Comunicação com um sensor: SensorManager, SensorEvents e listeners
• 1. Obtenha uma instância do SensorManager
• 2. Obtenha uma referência ao lightTextView
• 3. Verifique se o sensor existe no dispositivo atual
• 4. Registre os ouvintes do seu sensor
• 5. Implemente os retornos de chamada SensorEventListener
• onSensorChanged ()
• onAccuracyChanged ()
• 6. Recupere o valor do sensor
• 7. Cancele o registro de seus ouvintes
• Usando os sensores de luz do Android: código concluído
• Teste seu aplicativo de sensor Android completo
• Medindo a distância, com os sensores de proximidade do Android
• Criando a interface do usuário
• Obtendo dados do sensor de proximidade
• Teste: quão perto o usuário está do dispositivo?
• Sensores de movimento: Processando matrizes multidimensionais
• Exibindo dados de pitch and roll em tempo real
• Usando o sensor de vetor de rotação no seu aplicativo
• 1. Use o TYPE_ROTATION_VECTOR
• 2. Traduza os dados do sensor
• 3. Atualize as strings de espaço reservado
• Exibindo vários dados do sensor: código concluído
• Testando nosso aplicativo final de sensor Android
• Empacotando

Hoje, a maioria dos dispositivos Android modernos são equipados com vários sensores.

Você pode usar essas informações de várias maneiras diferentes - seja monitorando os níveis de luz, para que seu aplicativo possa ajustar automaticamente seu brilho ou esquema de cores; permitindo que o usuário interaja com seu jogo para celular usando gestos como inclinar o dispositivo; ou usando o sensor de proximidade para desativar automaticamente os eventos de toque sempre que o usuário coloca o dispositivo no ouvido.

Neste artigo, criaremos três aplicativos que recuperam dados de luz, proximidade e movimento de uma variedade de sensores de hardware e software. Também monitoraremos esses sensores Android em tempo real, para que seu aplicativo sempre tenha acesso às informações mais recentes.

No final deste artigo, você saberá como extrair um único dado de um sensor Android e como lidar com sensores que fornecem dados na forma de uma matriz multidimensional.

Quais sensores Android posso usar?

Os sensores Android podem ser divididos nas seguintes categorias:

• Sensores ambientais. Eles medem as condições ambientais, como temperatura do ar, pressão, umidade e níveis de luz ambiente.

• Sensores de posição. Esta categoria inclui sensores que medem a posição física do dispositivo, como sensores de proximidade e sensores de campo geomagnético.
  Sensores de movimento. Esses sensores medem o movimento do dispositivo e incluem acelerômetros, sensores de gravidade, giroscópios e sensores vetoriais de rotação.

Além disso, os sensores podem ser:

• Baseado em hardware. Esses são componentes físicos incorporados ao dispositivo e medem diretamente propriedades específicas, como aceleração ou força dos campos geomagnéticos circundantes.
• Baseado em software, às vezes conhecido como sensores virtuais ou sensores compostos. Normalmente, eles coletam dados de vários sensores baseados em hardware. No final deste artigo, trabalharemos com o sensor de vetor de rotação, que é um sensor de software que combina dados do acelerômetro, magnetômetro e giroscópio do dispositivo.

Sensores ambientais: medindo a luz ambiente

O sensor de luz do Android mede a luz ambiente em unidades "lux", que é a intensidade da luz percebida pelo olho humano. O valor lux relatado por um sensor pode variar entre os dispositivos; portanto, se seu aplicativo exigir valores consistentes, você poderá precisar manipular os dados brutos antes de usá-los em seu aplicativo.

Nesta seção, criaremos um aplicativo que recupera o valor lux atual do sensor de luz do dispositivo, o exibe em um TextView e atualiza o TextView à medida que novos dados se tornam disponíveis.Você pode usar essas informações em vários aplicativos. Por exemplo, você pode criar um aplicativo de tocha que extrai informações do sensor de luz e ajusta automaticamente a força de seu feixe com base nos níveis atuais de luz.

Crie um novo projeto Android com as configurações de sua escolha e vamos começar!

Exibindo seus dados do sensor

Vou adicionar um TextView que eventualmente exibirá os dados que extraímos do sensor de luz. Este TextView será atualizado sempre que novos dados estiverem disponíveis, para que o usuário sempre tenha acesso às informações mais recentes.

Abra o arquivo activity_main.xml do seu projeto e adicione o seguinte:

Em seguida, precisamos criar o recurso de string "light_sensor" que é mencionado em nosso layout. Abra o arquivo strings.xml do seu projeto e adicione o seguinte:

Sensor de luz:% 1 $ .2f

O "% 1 $ .2f" é um espaço reservado que especifica as informações que queremos exibir e como elas devem ser formatadas:

• %1. Você pode inserir vários espaços reservados no mesmo recurso de seqüência de caracteres; "% 1" indica que estamos usando um único espaço reservado.
• $.2. Isso especifica como nosso aplicativo deve formatar cada valor de ponto flutuante de entrada. O "$ .2" indica que o valor deve ser arredondado para duas casas decimais.
• F. Formate o valor como um número de ponto flutuante.

Embora alguns sensores sejam mais comuns que outros, você nunca deve assumir que todos os dispositivos têm acesso exatamente ao mesmo hardware e software. A disponibilidade do sensor pode até variar entre as diferentes versões do Android, pois alguns sensores não foram introduzidos até versões posteriores da plataforma Android.

Você pode verificar se um sensor específico está presente em um dispositivo, usando a estrutura do sensor Android. Em seguida, você pode desativar ou ativar partes do seu aplicativo com base na disponibilidade do sensor ou exibir uma explicação de que alguns dos recursos do seu aplicativo não funcionam conforme o esperado.

Enquanto temos nosso arquivo strings.xml aberto, vamos criar uma string "no_sensor", que será exibida se o sensor de luz estiver indisponível:

Nenhum sensor de luz disponível

Se seu aplicativo não puder fornecer uma boa experiência do usuário sem ter acesso a um sensor específico, você precisará adicionar essas informações ao seu manifesto. Por exemplo, se seu aplicativo requer acesso a um sensor de bússola, você pode usar o seguinte:

Agora, seu aplicativo pode ser baixado apenas em dispositivos que possuem um sensor de bússola.

Embora isso possa limitar seu público, é muito menos prejudicial do que permitir que alguém faça o download do seu aplicativo quando estiver garantido ter uma experiência ruim, devido à configuração do sensor do dispositivo.

Comunicação com um sensor: SensorManager, SensorEvents e listeners

Para se comunicar com o sensor de luz do dispositivo, você precisa concluir as seguintes etapas:

1. Obtenha uma instância do SensorManager

O SensorManager fornece todos os métodos necessários para acessar toda a gama de sensores do dispositivo.

Para começar, crie uma variável que mantenha uma instância do SensorManager:

privado SensorManager lightSensorManager;

Em seguida, você precisa obter uma instância do SensorManager, chamando o método Context.getSystemService e passando o argumento Context.SENSOR_SERVICE:

lightSensorManager = (SensorManager) getSystemService (Context.SENSOR_SERVICE);

2. Obtenha uma referência ao lightTextView

Em seguida, precisamos criar uma variável de membro privada que mantenha nossos objetos TextView e atribuí-la ao nosso TextView:

TextView privado lightTextView; ... ... ... lightTextView = (TextView) findViewById (R.id.lightTextView);

3. Verifique se o sensor existe no dispositivo atual

Você pode obter acesso a um sensor específico chamando o método getDefaultSensor () e passando o sensor em questão. A constante de tipo para o sensor de luz é TYPE_LIGHT, portanto, precisamos usar o seguinte:

lightSensor = lightSensorManager.getDefaultSensor (Sensor.TYPE_LIGHT);

Se o sensor não existir neste dispositivo, o método getDefaultSensor () retornará nulo e exibiremos a string "no_sensor":

String sensor_error = getResources (). GetString (R.string.no_sensor); if (lightSensor == null) {lightTextView.setText (sensor_erro); }}

4. Registre os ouvintes do seu sensor

Sempre que um sensor possui novos dados, o Android gera um objeto SensorEvent. Este objeto SensorEvent inclui o sensor que gerou o evento, um registro de data e hora e o novo valor dos dados.

Inicialmente, focaremos nos sensores de luz e proximidade, que retornam um único dado. No entanto, alguns sensores fornecem matrizes multidimensionais para cada SensorEvent, incluindo o sensor de vetor de rotação, que exploraremos no final deste artigo.

Para garantir que nosso aplicativo seja notificado sobre esses objetos SensorEvent, precisamos registrar um ouvinte para esse evento específico do sensor, usando o registerListener () do SensorManager.

O método registerListener () usa os seguintes argumentos:

• Um aplicativo ou contexto de atividade.
• O tipo de sensor que você deseja monitorar.
• A taxa na qual o sensor deve enviar novos dados. Uma taxa mais alta fornecerá ao seu aplicativo mais dados, mas também usará mais recursos do sistema, especialmente a duração da bateria. Para ajudar a preservar a bateria do dispositivo, você deve solicitar a quantidade mínima de dados que seu aplicativo exige. Vou usar o SensorManager.SENSOR_DELAY_NORMAL, que envia novos dados uma vez a cada 200.000 microssegundos (0,2 segundos).

Como ouvir um sensor descarrega a bateria do dispositivo, você nunca deve registrar ouvintes no método onCreate () do seu aplicativo, pois isso fará com que os sensores continuem enviando dados, mesmo quando o aplicativo estiver em segundo plano.

Em vez disso, você deve registrar seus sensores no método de ciclo de vida onStart () do aplicativo:

@ Substituir void protegido onStart () {super.onStart (); // Se o sensor estiver disponível no dispositivo atual ... // if (lightSensor! = Null) {//…. Então comece a ouvir // lightSensorManager.registerListener (this, lightSensor, SensorManager.SENSOR_DELAY_NORMAL); }}

5. Implemente os retornos de chamada SensorEventListener

SensorEventListener é uma interface que recebe notificações do SensorManager
sempre que novos dados estiverem disponíveis ou a precisão do sensor for alterada.

A primeira etapa é modificar nossa assinatura de classe para implementar a interface SensorEventListener:

classe pública MainActivity estende AppCompatActivity implementa SensorEventListener {

Em seguida, precisamos implementar os seguintes métodos de retorno de chamada:

onSensorChanged ()

Este método é chamado em resposta a cada novo SensorEvent.

Os dados do sensor geralmente podem mudar rapidamente, portanto, seu aplicativo pode estar chamando o método onSensorChanged () regularmente. Para ajudar a manter seu aplicativo funcionando sem problemas, você deve executar o mínimo de trabalho possível dentro do método onSensorChanged ().

@Override public void onSensorChanged (SensorEvent sensorEvent) {// Para fazer //}

onAccuracyChanged ()

Se a precisão do sensor melhorar ou diminuir, o Android chamará o método onAccuracyChanged () e passará a ele um objeto Sensor que contém o novo valor de precisão, como SENSOR_STATUS_UNRELIABLE ou SENSOR_STATUS_ACCURACY_HIGH.

O sensor de luz não relata alterações de precisão; portanto, deixarei o retorno de chamada onAccuracyChanged () vazio:

@Override public void onAccuracyChanged (Sensor sensor, int i) {// Para fazer //}}

6. Recupere o valor do sensor

Sempre que temos um novo valor, precisamos chamar o método onSensorChanged () e recuperar a string "light_sensor". Em seguida, podemos substituir o texto do espaço reservado da string (% 1 $ .2f) e exibir a string atualizada como parte do nosso TextView:

@Override public void onSensorChanged (SensorEvent sensorEvent) {// O valor atual do sensor // float currentValue = sensorEvent.values; // Recupere a string “light_sensor”, insira o novo valor e exiba-o para o usuário // lightTextView.setText (getResources (). GetString (R.string.light_sensor, currentValue)); }

7. Cancele o registro de seus ouvintes

Os sensores podem gerar grandes quantidades de dados em um curto período de tempo. Portanto, para ajudar a preservar os recursos do dispositivo, você precisa cancelar o registro de seus ouvintes quando eles não forem mais necessários.

Para parar de ouvir eventos de sensor quando seu aplicativo estiver em segundo plano, adicione unregisterListener () ao método de ciclo de vida onStop () do seu projeto:

@ Substituir void protegido onStop () {super.onStop (); lightSensorManager.unregisterListener (this); }

Observe que você não deve cancelar o registro de seus ouvintes na onPause (), pois no Android 7.0 e superior, os aplicativos podem ser executados nos modos tela dividida e imagem na imagem, onde estão em estado de pausa, mas permanecem visíveis na tela.

Usando os sensores de luz do Android: código concluído

Depois de concluir todas as etapas acima, a MainActivity do seu projeto deve ter a seguinte aparência:

importar android.support.v7.app.AppCompatActivity; importar android.os.Bundle; importar android.content.Context; importar android.hardware.Sensor; importar android.hardware.SensorEvent; importar android.hardware.SensorEventListener; importar android.hardware.SensorManager; importar android.widget.TextView; public class MainActivity estende AppCompatActivity // Implementa a interface SensorEventListener // implementa SensorEventListener {// Crie suas variáveis ​​// private Sensor lightSensor; privado SensorManager lightSensorManager; TextView privado lightTextView; @Override void protegido onCreate (Bundle savedInstanceState) {super.onCreate (savedInstanceState); setContentView (R.layout.activity_main); lightTextView = (TextView) findViewById (R.id.lightTextView); // Obtém uma instância do SensorManager // lightSensorManager = (SensorManager) getSystemService (Context.SENSOR_SERVICE); // Verifique se há um sensor de luz // lightSensor = lightSensorManager.getDefaultSensor (Sensor.TYPE_LIGHT); // Se o sensor de luz não existir, exibirá um erro // String sensor_error = getResources (). GetString (R.string.no_sensor); if (lightSensor == null) {lightTextView.setText (sensor_erro); }} @ Substituir nulo protegido onStart () {super.onStart (); // Se o sensor estiver disponível no dispositivo atual ... // if (lightSensor! = Null) {//…. Registre um ouvinte // lightSensorManager.registerListener (this, lightSensor, // Especifique com que frequência você deseja receber novos dados // SensorManager.SENSOR_DELAY_NORMAL); }} @Obsride void protegido onStop () {super.onStop (); // Cancele o registro do seu ouvinte // lightSensorManager.unregisterListener (this); } @Override public void onSensorChanged (SensorEvent sensorEvent) {// O valor atual do sensor // float currentValue = sensorEvent.values; // Recupere a string “light_sensor”, insira o novo valor e atualize o TextView // lightTextView.setText (getResources (). GetString (R.string.light_sensor, currentValue)); } @Override // Se a precisão do sensor mudar… .// public void onAccuracyChanged (Sensor sensor, int i) {// TO DO //}}

Teste seu aplicativo de sensor Android completo

Para testar este aplicativo em um smartphone ou tablet Android físico:

• Instale o projeto no seu dispositivo (selecionando "Executar> Executar" na barra de ferramentas do Android Studio).
• Embora varie entre os dispositivos, o sensor de luz geralmente está localizado no canto superior direito da tela. Para manipular os níveis de luz, aproxime o dispositivo e afaste-o de uma fonte de luz. Como alternativa, você pode tentar cobrir o dispositivo com a mão para bloquear a luz. O valor "Sensor de luz" deve aumentar e diminuir, dependendo da quantidade de luz disponível.

Se você estiver usando um dispositivo virtual Android (AVD), o emulador possui um conjunto de controles de sensor virtual que você pode usar para simular vários eventos do sensor. Você acessa esses controles de sensor virtual, através da janela "Controles estendidos" do emulador:

• Instale o aplicativo no seu AVD.
• Ao lado do AVD, você verá uma faixa de botões. Encontre o botão "Mais" com três pontos (onde o cursor está posicionado na captura de tela a seguir) e clique nele. Isso inicia a janela "Controles estendidos".

• No menu à esquerda, selecione "Sensores virtuais".
• Selecione a guia "Sensores adicionais". Essa guia contém vários controles deslizantes que você pode usar para simular diferentes posições e eventos do sensor ambiental.

• Localize o controle deslizante "Light (lux)" e arraste-o para a esquerda e direita, para alterar os níveis de luz simulados. Seu aplicativo deve exibir esses valores alterados, em tempo real.

Você pode baixar o projeto concluído no GitHub.

Medindo a distância, com os sensores de proximidade do Android

Agora, vimos como recuperar informações de um sensor ambiental. Vamos ver como você aplicaria esse conhecimento a um posição sensor.

Nesta seção, usaremos o sensor de proximidade do dispositivo para monitorar a distância entre seu smartphone ou tablet e outros objetos. Se o seu aplicativo tiver algum tipo de funcionalidade de voz, o sensor de proximidade poderá ajudá-lo a determinar quando o smartphone está sendo mantido no ouvido do usuário, por exemplo, quando eles estão tendo uma conversa telefônica. Em seguida, você pode usar essas informações para desativar os eventos de toque, para que o usuário não desligue acidentalmente ou ative outros eventos indesejados no meio da conversa.

Criando a interface do usuário

Vou exibir os dados de proximidade na tela para que você possa vê-los atualizados em tempo real. Para ajudar a simplificar, vamos reutilizar grande parte do layout do nosso aplicativo anterior:

Em seguida, abra o arquivo strings.xml e crie uma string "proximidade_sensor". Mais uma vez, essa sequência precisa conter um espaço reservado, que será preenchido por dados extraídos do sensor de proximidade:

Sensor de proximidade Sensor de proximidade:% 1 $ .2f Nenhum sensor de proximidade disponível

Obtendo dados do sensor de proximidade

Semelhante ao sensor de luz, o sensor de proximidade do Android retorna um único valor de dados, o que significa que podemos reutilizar grande parte do código do nosso aplicativo anterior. No entanto, existem algumas diferenças importantes, além de algumas alterações relacionadas ao nome que facilitam o acompanhamento deste código:

• Crie uma instância do SensorManager, que desta vez vou nomear "proximidadeSensorManager".
• Obtenha uma instância do "proximidadeSensorManager".
• Crie uma referência para o "proximidadeTextView".
• Chame o método getDefaultSensor () e passe-o para o sensor TYPE_PROXIMITY.
• Registre e cancele o registro de ouvintes para o sensor de proximidade.

Depois de fazer esses ajustes, você deve terminar com o seguinte:

importar android.support.v7.app.AppCompatActivity; importar android.os.Bundle; importar android.content.Context; importar android.hardware.Sensor; importar android.hardware.SensorEvent; importar android.hardware.SensorManager; importar android.hardware.SensorEventListener; importar android.widget.TextView; public class MainActivity estende AppCompatActivity // Implementa a interface SensorEventListener // implementa SensorEventListener {// Crie suas variáveis ​​// private Sensor proximidadeSensor; privado SensorManager proximidadeSensorManager; TextView privado proximidadeTextView; @Override void protegido onCreate (Bundle savedInstanceState) {super.onCreate (savedInstanceState); setContentView (R.layout.activity_main); proximidadeTextView = (TextView) findViewById (R.id.proximityTextView); // Obtém uma instância do SensorManager // proximidadeSensorManager = (SensorManager) getSystemService (Context.SENSOR_SERVICE); // Verifique se há um sensor de proximidade // proximidadeSensor = proximidadeSensorManager.getDefaultSensor (Sensor.TYPE_PROXIMITY); // Se o sensor de proximidade não existir, exibirá um erro // String sensor_error = getResources (). GetString (R.string.no_sensor); if (proximidadeSensor == nulo) {proximidadeTextView.setText (sensor_erro); }} @ Substituir nulo protegido onStart () {super.onStart (); // Se o sensor estiver disponível no dispositivo atual ... // if (proximidadeSensor! = Nulo) {//…. Registre um ouvinte // proximidadeSensorManager.registerListener (this, proximidadeSensor, // Especifique com que frequência deseja receber novos dados // SensorManager.SENSOR_DELAY_NORMAL); }} @Obsride void protegido onStop () {super.onStop (); // Cancele o registro do seu ouvinte para preservar os recursos do sistema // proximidadeSensorManager.unregisterListener (this); } @Override public void onSensorChanged (SensorEvent sensorEvent) {// O valor atual do sensor // float currentValue = sensorEvent.values; // Recupere a string “proximidade_sensor”, insira o novo valor e atualize o TextView // proximidadeTextView.setText (getResources (). GetString (R.string.proximity_sensor, currentValue)); } @Override // Se a precisão do sensor mudar… .// public void onAccuracyChanged (Sensor sensor, int i) {//...TO DO //}}

Teste: quão perto o usuário está do dispositivo?

Para testar esse aplicativo em um smartphone ou tablet Android físico, instale o aplicativo no dispositivo e experimente movendo a mão na direção da tela e afastando-a novamente. O valor “Sensor de proximidade” deve registrar seus movimentos.

Esteja ciente de que os sensores de proximidade podem variar entre os dispositivos. Alguns dispositivos podem exibir apenas dois valores de proximidade - um para indicar "Próximo" e outro para "Longe" -, portanto, não se surpreenda se você não encontrar muita variedade no seu dispositivo Android físico.

Para testar este aplicativo em um emulador:

• Instale seu aplicativo em um AVD.
• Encontre o botão "Mais" com três pontos e clique nele, o que abre a janela "Controles estendidos".
• No menu esquerdo da janela, selecione "Sensores virtuais".
• Selecione a guia "Sensores adicionais".
• Localize o controle deslizante "Proximidade" e arraste-o para a esquerda e direita para emular um objeto que se aproxima mais do dispositivo e depois para mais longe. Os valores do “Sensor de proximidade” devem mudar, à medida que você manipula o controle deslizante.

Você pode baixar o projeto concluído no GitHub.

Sensores de movimento: Processando matrizes multidimensionais

Até o momento, focamos nos sensores que fornecem um único item de dados, mas existem alguns sensores que fornecem matrizes multidimensionais para cada SensorEvent. Esses sensores multidimensionais incluem sensores de movimento, nos quais focaremos nesta seção final.

Os sensores de movimento podem ajudá-lo a:

• Forneça um método alternativo de entrada do usuário. Por exemplo, se você estiver desenvolvendo um jogo para celular, o usuário poderá mover seu personagem pela tela inclinando o dispositivo.
• Inferir atividade do usuário. Se você criou um aplicativo de rastreamento de atividades, os sensores de movimento podem ajudá-lo a avaliar se o usuário está viajando de carro, correndo ou sentado em sua mesa.
• Determine com mais precisão a orientação.É possível extrair coordenadas dos sensores de movimento de um dispositivo e traduzi-las com base no sistema de coordenadas da Terra, para obter uma visão mais precisa da orientação atual do dispositivo.

Nesta seção final, usaremos o sensor de vetor de rotação (TYPE_ROTATION_VECTOR). Ao contrário dos sensores de luz e proximidade, este é um sensor de software que coleta dados dos sensores do acelerômetro, magnetômetro e giroscópio do dispositivo. Embora o trabalho com esse sensor muitas vezes exija que você realize conversões e transformações matemáticas, ele também pode fornecer uma variedade de informações altamente precisas sobre o dispositivo.

Criaremos um aplicativo que usa o sensor de vetor de rotação para medir:

• Arremesso. Essa é a inclinação de cima para baixo do dispositivo.
• Lista. Essa é a inclinação da esquerda para a direita do dispositivo.

Exibindo dados de pitch and roll em tempo real

Como medimos duas métricas, precisamos criar dois TextViews e dois recursos de string correspondentes:

Abra o arquivo strings.xml e adicione o seguinte:

MotionSensors Sensor de inclinação:% 1 $ .2f Sensor de rotação:% 1 $ .2f Nenhum sensor de movimento disponível

Usando o sensor de vetor de rotação no seu aplicativo

Reutilizaremos parte do código de nossos aplicativos anteriores. Portanto, vamos nos concentrar nas áreas em que a comunicação com o sensor de vetor de rotação é significativamente diferente do que vimos anteriormente.

1. Use o TYPE_ROTATION_VECTOR

Como estamos trabalhando com o sensor de vetor de rotação, precisamos chamar o método getDefaultSensor () e passá-lo para a constante TYPE_ROTATION_VECTOR:

positionSensorManager.getDefaultSensor (Sensor.TYPE_ROTATION_VECTOR);

2. Traduza os dados do sensor

Ao contrário dos sensores de luz e proximidade anteriores, os sensores de movimento retornam matrizes multidimensionais dos valores dos sensores para cada SensorEvent. Esses valores são formatados usando o sistema de coordenadas padrão "X, Y, Z", que é calculado em relação ao dispositivo quando ele é mantido em sua orientação "natural" padrão.

O Android não alterna essas coordenadas X, Y e Z para corresponder à orientação atual do dispositivo, para que o eixo "X" permaneça o mesmo, independentemente de o dispositivo estar no modo retrato ou paisagem. Ao usar o sensor de vetor de rotação, pode ser necessário converter os dados recebidos para corresponder à rotação atual do dispositivo.

Retrato é a orientação padrão para a maioria dos smartphones, mas você não deve assumir que esse será o caso de todos Dispositivos Android, particularmente tablets. Neste artigo, usaremos uma matriz de rotação para converter os dados do sensor dos originais, dispositivo sistema de coordenadas, Da terra sistema de coordenadas, que representa o movimento e a posição do dispositivo em relação à Terra. Se necessário, podemos remapear os dados do sensor, com base na orientação atual do dispositivo.

Em primeiro lugar, o sistema de coordenadas do dispositivo é um sistema de coordenadas X, Y, Z padrão de 3 eixos, em que cada ponto em cada um dos três eixos é representado por um vetor 3D. Isso significa que precisamos criar uma matriz de 9 valores flutuantes:

float rotationMatrix = novo flutuador;

Podemos então passar essa matriz para o método getRotationMatrix ():

SensorManager.getRotationMatrixFromVector (rotationMatrix, vectors); int worldAxisX = SensorManager.AXIS_X; int worldAxisZ = SensorManager.AXIS_Z;

A próxima etapa é usar o método SensorManager.remapCoordinateSystem () para remapear os dados do sensor, com base na orientação atual do dispositivo.

O método SensorManager.remapCoordinateSystem () usa os seguintes argumentos:

• A matriz de rotação original.
• Os eixos que você deseja remapear.
• A matriz que você está preenchendo com esses novos dados.

Aqui está o código que vou usar no meu aplicativo:

float ajustadoRotationMatrix = novo float; SensorManager.remapCoordinateSystem (rotationMatrix, worldAxisX, worldAxisZ, ajustadoRotationMatrix);

Por fim, chamaremos SensorManager.getOrientation e informaremos para usar o ajustadoRotationMatrix:

SensorManager.getOrientation (drivenRotationMatrix, orientação);

3. Atualize as strings de espaço reservado

Como temos dois conjuntos de dados (pitch and roll), precisamos recuperar duas seqüências de espaço reservado separadas, preenchê-las com os valores corretos e atualizar o TextView correspondente:

pitchTextView.setText (getResources (). getString (R.string.pitch_sensor, pitch)); rollTextView.setText (getResources (). getString (R.string.roll_sensor, rolo));

Exibindo vários dados do sensor: código concluído

Depois de executar as etapas acima, sua MainActivity deve ficar assim:

importar android.app.Activity; importar android.os.Bundle; importar android.hardware.Sensor; importar android.hardware.SensorEvent; importar android.hardware.SensorEventListener; importar android.hardware.SensorManager; importar android.widget.TextView; classe pública MainActivity estende Atividade implementa SensorEventListener {private SensorManager motionSensorManager; sensor privado motionSensor; TextView privado pitchTextView; TextView privado rollTextView; final estático privado int SENSOR_DELAY = 500 * 1000; final estático privado int FROM_RADS_TO_DEGS = -57; @Override void protegido onCreate (Bundle savedInstanceState) {super.onCreate (savedInstanceState); setContentView (R.layout.activity_main); pitchTextView = (TextView) findViewById (R.id.pitchTextView); rollTextView = (TextView) findViewById (R.id.rollTextView); tente {motionSensorManager = (SensorManager) getSystemService (Activity.SENSOR_SERVICE); motionSensor = motionSensorManager.getDefaultSensor (Sensor.TYPE_ROTATION_VECTOR); motionSensorManager.registerListener (this, motionSensor, SENSOR_DELAY); } catch (exceção e) {pitchTextView.setText (R.string.no_sensor); rollTextView.setText (R.string.no_sensor); }} @Override public void onAccuracyChanged (Sensor sensor, precisão int) {// Tarefa //} @Override public void onSensorChanged (evento SensorEvent) {if (event.sensor == motionSensor) {update (event.values); }} private void update (vetores flutuantes) {// Calcula a matriz de rotação // float rotationMatrix = new float; SensorManager.getRotationMatrixFromVector (rotationMatrix, vectors); int worldAxisX = SensorManager.AXIS_X; int worldAxisZ = SensorManager.AXIS_Z; // Remapea a matriz com base na orientação atual da atividade // float ajustadoRotationMatrix = new float; SensorManager.remapCoordinateSystem (rotationMatrix, worldAxisX, worldAxisZ, ajustadoRotationMatrix); // Calcula a orientação dos dispositivos // float direction = new float; // Fornece a matriz de valores flutuantes ao método getOrientation () // SensorManager.getOrientation (ajustadoRotationMatrix, orientação); pitch flutuante = orientação * FROM_RADS_TO_DEGS; rolo flutuante = orientação * FROM_RADS_TO_DEGS; // Atualize os TextViews com os valores de pitch and roll // pitchTextView.setText (getResources (). GetString (R.string.pitch_sensor, pitch)); rollTextView.setText (getResources (). getString (R.string.roll_sensor, rolo)); }}

Você pode baixar o projeto concluído no GitHub.

Testando nosso aplicativo final de sensor Android

Para testar esse aplicativo de sensor Android com vetor de rotação em um smartphone ou tablet Android físico:

• Instale o aplicativo no seu dispositivo.
• Coloque seu smartphone ou tablet em uma superfície plana. Observe que os sensores de movimento são extremamente sensíveis, portanto, não é incomum um dispositivo aparentemente imóvel relatar flutuações nos valores de inclinação e rotação.
• Para testar a afinação, levante a parte inferior do dispositivo para que fique inclinado para longe de você. O valor do tom deve mudar drasticamente.
• Para testar o rolo, tente levantar o lado esquerdo do seu dispositivo, para que ele incline para a esquerda - fique de olho nesse valor do rolo!

Se você estiver testando seu projeto em um emulador:

• Instale o aplicativo no seu AVD.
• Selecione "Mais", que abre a janela "Controles estendidos".
• No menu à esquerda, selecione "Sensores virtuais".
• Verifique se a guia "Acelerômetro" está selecionada. Essa guia contém controles que podem simular alterações na posição e orientação do dispositivo.
• Tente experimentar os vários controles deslizantes (Girar: Z-Rot, X-Rot, Y-Rot; e Mover: X, Y e Z) e os vários botões "Rotação do dispositivo", para ver como eles afetam o "Sensor de rolo do aplicativo" "E" Sensor de inclinação ".

Empacotando

Neste artigo, vimos como recuperar dados das três principais categorias de sensores Android: ambiente, posição e movimento e como monitorar esses dados em tempo real.

Você já viu algum aplicativo Android que usa sensores de maneiras interessantes ou exclusivas? Deixe-nos saber nos comentários abaixo!