Vamos acelerar

Como é do conhecimento geral os telemóveis Android têm um sensor designado de acelerómetro.
Este sensor permite avaliar os movimentos a que o dispositivo está sujeito num sistema de três eixos.
O eixo dos x permite avaliar a inclinação do dispositivo para a esquerda ou para a direita. O eixo dos y é controlado pela inclinação do dispositivo para a frente ou para trás. O eixo dos z reflete o movimento para cima e para baixo.

Para este pequeno projeto vamos fazer um labirinto cujo objetivo é levar uma esfera até ao buraco inclinando o dispositivo tal como  se se trata-se um jogo físico.

Primeiro vamos criar um projeto novo.

Na atividade principal (MainActivity) vamos implementar uma função que fica associada ao sensor, é o que se designa por SensorEventListener.

Assim alteramos a declaração da class para

       public class MainActivity extends Activity implements SensorEventListener{

De seguida na função onCreate temos de "capturar" o sensor, para isso criamos um objeto SensorManager e outro objeto Sensor.


        mSensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
        mSensor = mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
        mSensorManager.registerListener(this,mSensor,SensorManager.SENSOR_DELAY_NORMAL);


Posto isto temos de implementar a função onSensorChanged, que vai receber os valores do sensor sempre que este sofrer alterações.


public void onSensorChanged(SensorEvent event) {
//recolher os três valores para as variáveis
x=event.values[0];
y=event.values[1];
z=event.values[2];
}

Com estas funções implementadas vamos passar à fase gráfica, para implementar a interface vamos utilizar uma ImageView que depois associamos ao xml do layout do programa.

Vamos, então, adicionar uma class nova que vai implementar a lógica e os gráficos.

public class ecran extends ImageView{

Nesta class vamos implementar a função onSizeChanged que vai permitir saber o tamanho do ecrã, para, em função desse tamanho, implementarmos as paredes do labirinto.

Precisamos, ainda, da função onDraw, que além de desenhar tudo no ecrã vai calcular a posição da esfera em função dos valores do sensor. Como o sensor é controlado na MainActivity é necessário implementar três métodos públicos na MainActivity para podermos aceder aos valores do sensor.
Primeiro um método que nos dá a instancia atual.


public static MainActivity getInstance(){
return instance;
}

Este método vai permitir à class ecran, que é a que desenha no ecrã do dispositivo, ter acesso aos outros dois métodos, um que devolve o valor x e outro para o valor y do sensor.


public float getX()
{
return x;
}
public float getY()
{
return y;
}
No projeto também está implementado o método para o z mas não é utilizado.

Para as paredes do labirinto criei um vetor de retângulos.
As paredes são definidas por código e desenhadas com a cor vermelha.

A função principal é a onDraw que trata de:
1º desenhar o buraco de saída do labirinto.
2º desenhar as paredes.
3º receber os valores da inclinação do dispositivo.
4º calcular a nova posição da esfera calculado se esta bate em alguma parede.
5º se a esfera está suficientemente perto do buraco para declarar vitória.

Por fim o layout da atividade que fica assim:

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    android:orientation="vertical"    
    android:background="#FFFFFF">
    <edu.pjcferreira.labirinto.ecran
        android:id="@+id/ecran"
        android:layout_height="fill_parent"
        android:layout_width="fill_parent"/>
</LinearLayout>


É um layout linear que associa a class ecran ao ecrã.

Em resumo: este projeto demonstra como desenhar no ecrã utilizando as funções gráficas do sistema operativo Android, desde imagens a figuras geométricas bem como escrever texto e ainda a utilização do sensor acelerómetro.

O projeto e a aplicação.