samples/Compass/src/com/example/android/compass/CompassActivity.java - platform/development - Git at Google


            
            /*

            
             * Copyright (C) 2008 The Android Open Source Project

            
             *

            
             * Licensed under the Apache License, Version 2.0 (the "License");

            
             * you may not use this file except in compliance with the License.

            
             * You may obtain a copy of the License at

            
             *

            
             *      http://www.apache.org/licenses/LICENSE-2.0

            
             *

            
             * Unless required by applicable law or agreed to in writing, software

            
             * distributed under the License is distributed on an "AS IS" BASIS,

            
             * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

            
             * See the License for the specific language governing permissions and

            
             * limitations under the License.

            
             */


            package com.example.android.compass;


            import java.nio.ByteBuffer;

            
            import java.nio.ByteOrder;

            
            import java.nio.FloatBuffer;


            import javax.microedition.khronos.egl.EGL10;

            
            import javax.microedition.khronos.egl.EGLConfig;

            
            import javax.microedition.khronos.opengles.GL10;

            
            import static javax.microedition.khronos.opengles.GL10.*;


            import android.app.Activity;

            
            import android.content.Context;

            
            import android.hardware.Sensor;

            
            import android.hardware.SensorEvent;

            
            import android.hardware.SensorEventListener;

            
            import android.hardware.SensorManager;

            
            import android.opengl.GLSurfaceView;

            
            import android.opengl.GLSurfaceView.Renderer;

            
            import android.os.Bundle;

            
            import android.util.Log;


            /**

            
             * This class provides a basic demonstration of how to use the

            
             * {@link android.hardware.SensorManager SensorManager} API to draw

            
             * a 3D compass.

            
             */

            
            public class CompassActivity extends Activity implements Renderer, SensorEventListener {

            
                private GLSurfaceView mGLSurfaceView;

            
                private SensorManager mSensorManager;

            
                private float[] mGData = new float[3];

            
                private float[] mMData = new float[3];

            
                private float[] mR = new float[16];

            
                private float[] mI = new float[16];

            
                private FloatBuffer mVertexBuffer;

            
                private FloatBuffer mColorBuffer;

            
                private ByteBuffer mIndexBuffer;

            
                private float[] mOrientation = new float[3];

            
                private int mCount;


                public CompassActivity() {

            
                }


                /** Called with the activity is first created. */

            
                @Override

            
                public void onCreate(Bundle savedInstanceState) {

            
                    super.onCreate(savedInstanceState);


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

            
                    mGLSurfaceView = new GLSurfaceView(this);

            
                    mGLSurfaceView.setRenderer(this);

            
                    setContentView(mGLSurfaceView);

            
                }


                @Override

            
                protected void onResume() {

            
                    // Ideally a game should implement onResume() and onPause()

            
                    // to take appropriate action when the activity looses focus

            
                    super.onResume();

            
                    mGLSurfaceView.onResume();

            
                    Sensor gsensor = mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);

            
                    Sensor msensor = mSensorManager.getDefaultSensor(Sensor.TYPE_MAGNETIC_FIELD);

            
                    mSensorManager.registerListener(this, gsensor, SensorManager.SENSOR_DELAY_GAME);

            
                    mSensorManager.registerListener(this, msensor, SensorManager.SENSOR_DELAY_GAME);

            
                }


                @Override

            
                protected void onPause() {

            
                    // Ideally a game should implement onResume() and onPause()

            
                    // to take appropriate action when the activity looses focus

            
                    super.onPause();

            
                    mGLSurfaceView.onPause();

            
                    mSensorManager.unregisterListener(this);

            
                }


                public void onDrawFrame(GL10 gl) {

            
                    /*

            
                     * Usually, the first thing one might want to do is to clear

            
                     * the screen. The most efficient way of doing this is to use

            
                     * glClear().

            
                     */


                    gl.glClear(GL10.GL_COLOR_BUFFER_BIT | GL10.GL_DEPTH_BUFFER_BIT);


                    /*

            
                     * Now we're ready to draw some 3D objects

            
                     */


                    gl.glMatrixMode(GL10.GL_MODELVIEW);

            
                    gl.glLoadIdentity();

            
                    gl.glTranslatef(0, 0, -2);


                    /*

            
                     * All the magic happens here. The rotation matrix mR reported by

            
                     * SensorManager.getRotationMatrix() is a 4x4 row-major matrix.

            
                     * We need to use its inverse for rendering. The inverse is

            
                     * simply calculated by taking the matrix' transpose. However, since

            
                     * glMultMatrixf() expects a column-major matrix, we can use mR

            
                     * directly!

            
                     */

            
                    gl.glMultMatrixf(mR, 0);

            
                    // some test code which will be used/cleaned up before we ship this.

            
                    //gl.glMultMatrixf(mI, 0);


                    gl.glVertexPointer(3, GL_FLOAT, 0, mVertexBuffer);

            
                    gl.glColorPointer(4, GL_FLOAT, 0, mColorBuffer);

            
                    gl.glDrawElements(GL_LINES, 6, GL_UNSIGNED_BYTE, mIndexBuffer);

            
                }


                public void onSurfaceChanged(GL10 gl, int width, int height) {

            
                    gl.glViewport(0, 0, width, height);


                    /*

            
                     * Set our projection matrix. This doesn't have to be done

            
                     * each time we draw, but usually a new projection needs to

            
                     * be set when the viewport is resized.

            
                     */


                    float ratio = (float) width / height;

            
                    gl.glMatrixMode(GL10.GL_PROJECTION);

            
                    gl.glLoadIdentity();

            
                    gl.glFrustumf(-ratio, ratio, -1, 1, 1, 10);

            
                }


                public void onSurfaceCreated(GL10 gl, EGLConfig config) {

            
                    /*

            
                     * By default, OpenGL enables features that improve quality

            
                     * but reduce performance. One might want to tweak that

            
                     * especially on software renderer.

            
                     */

            
                    gl.glDisable(GL10.GL_DITHER);


                    /*

            
                     * Some one-time OpenGL initialization can be made here

            
                     * probably based on features of this particular context

            
                     */

            
                    gl.glClearColor(1,1,1,1);

            
                    gl.glEnable(GL10.GL_CULL_FACE);

            
                    gl.glShadeModel(GL10.GL_SMOOTH);

            
                    gl.glEnable(GL10.GL_DEPTH_TEST);


                    /*

            
                     * create / load the our 3D models here

            
                     */


                    gl.glEnableClientState(GL10.GL_VERTEX_ARRAY);

            
                    gl.glEnableClientState(GL10.GL_COLOR_ARRAY);


                    float vertices[] = {

            
                            0,0,0,

            
                            1,0,0,

            
                            0,1,0,

            
                            0,0,1

            
                    };

            
                    float colors[] = {

            
                            0,0,0,0,

            
                            1,0,0,1,

            
                            0,1,0,1,

            
                            0,0,1,1

            
                    };

            
                    byte indices[] = { 0, 1, 0, 2, 0, 3 };


                    // Buffers to be passed to gl*Pointer() functions

            
                    // must be direct, i.e., they must be placed on the

            
                    // native heap where the garbage collector cannot

            
                    // move them.

            
                    //

            
                    // Buffers with multi-byte datatypes (e.g., short, int, float)

            
                    // must have their byte order set to native order


                    ByteBuffer vbb;

            
                    vbb = ByteBuffer.allocateDirect(vertices.length*4);

            
                    vbb.order(ByteOrder.nativeOrder());

            
                    mVertexBuffer = vbb.asFloatBuffer();

            
                    mVertexBuffer.put(vertices);

            
                    mVertexBuffer.position(0);


                    vbb = ByteBuffer.allocateDirect(colors.length*4);

            
                    vbb.order(ByteOrder.nativeOrder());

            
                    mColorBuffer = vbb.asFloatBuffer();

            
                    mColorBuffer.put(colors);

            
                    mColorBuffer.position(0);


                    mIndexBuffer = ByteBuffer.allocateDirect(indices.length);

            
                    mIndexBuffer.put(indices);

            
                    mIndexBuffer.position(0);

            
                }


                public void onAccuracyChanged(Sensor sensor, int accuracy) {

            
                }


                public void onSensorChanged(SensorEvent event) {

            
                    int type = event.sensor.getType();

            
                    float[] data;

            
                    if (type == Sensor.TYPE_ACCELEROMETER) {

            
                        data = mGData;

            
                    } else if (type == Sensor.TYPE_MAGNETIC_FIELD) {

            
                        data = mMData;

            
                    } else {

            
                        // we should not be here.

            
                        return;

            
                    }

            
                    for (int i=0 ; i<3 ; i++)

            
                        data[i] = event.values[i];


                    SensorManager.getRotationMatrix(mR, mI, mGData, mMData);

            
            // some test code which will be used/cleaned up before we ship this.

            
            //        SensorManager.remapCoordinateSystem(mR,

            
            //                SensorManager.AXIS_X, SensorManager.AXIS_Z, mR);

            
            //        SensorManager.remapCoordinateSystem(mR,

            
            //                SensorManager.AXIS_Y, SensorManager.AXIS_MINUS_X, mR);

            
                    SensorManager.getOrientation(mR, mOrientation);

            
                    float incl = SensorManager.getInclination(mI);


                    if (mCount++ > 50) {

            
                        final float rad2deg = (float)(180.0f/Math.PI);

            
                        mCount = 0;

            
                        Log.d("Compass", "yaw: " + (int)(mOrientation[0]*rad2deg) +

            
                                "  pitch: " + (int)(mOrientation[1]*rad2deg) +

            
                                "  roll: " + (int)(mOrientation[2]*rad2deg) +

            
                                "  incl: " + (int)(incl*rad2deg)

            
                                );

            
                    }

            
                }

            
            }
	/*
	* Copyright (C) 2008 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package com.example.android.compass;

	import java.nio.ByteBuffer;
	import java.nio.ByteOrder;
	import java.nio.FloatBuffer;

	import javax.microedition.khronos.egl.EGL10;
	import javax.microedition.khronos.egl.EGLConfig;
	import javax.microedition.khronos.opengles.GL10;
	import static javax.microedition.khronos.opengles.GL10.*;

	import android.app.Activity;
	import android.content.Context;
	import android.hardware.Sensor;
	import android.hardware.SensorEvent;
	import android.hardware.SensorEventListener;
	import android.hardware.SensorManager;
	import android.opengl.GLSurfaceView;
	import android.opengl.GLSurfaceView.Renderer;
	import android.os.Bundle;
	import android.util.Log;

	/**
	* This class provides a basic demonstration of how to use the
	* {@link android.hardware.SensorManager SensorManager} API to draw
	* a 3D compass.
	*/
	public class CompassActivity extends Activity implements Renderer, SensorEventListener {
	private GLSurfaceView mGLSurfaceView;
	private SensorManager mSensorManager;
	private float[] mGData = new float[3];
	private float[] mMData = new float[3];
	private float[] mR = new float[16];
	private float[] mI = new float[16];
	private FloatBuffer mVertexBuffer;
	private FloatBuffer mColorBuffer;
	private ByteBuffer mIndexBuffer;
	private float[] mOrientation = new float[3];
	private int mCount;

	public CompassActivity() {
	}

	/** Called with the activity is first created. */
	@Override
	public void onCreate(Bundle savedInstanceState) {
	super.onCreate(savedInstanceState);

	mSensorManager = (SensorManager)getSystemService(Context.SENSOR_SERVICE);
	mGLSurfaceView = new GLSurfaceView(this);
	mGLSurfaceView.setRenderer(this);
	setContentView(mGLSurfaceView);
	}

	@Override
	protected void onResume() {
	// Ideally a game should implement onResume() and onPause()
	// to take appropriate action when the activity looses focus
	super.onResume();
	mGLSurfaceView.onResume();
	Sensor gsensor = mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
	Sensor msensor = mSensorManager.getDefaultSensor(Sensor.TYPE_MAGNETIC_FIELD);
	mSensorManager.registerListener(this, gsensor, SensorManager.SENSOR_DELAY_GAME);
	mSensorManager.registerListener(this, msensor, SensorManager.SENSOR_DELAY_GAME);
	}

	@Override
	protected void onPause() {
	// Ideally a game should implement onResume() and onPause()
	// to take appropriate action when the activity looses focus
	super.onPause();
	mGLSurfaceView.onPause();
	mSensorManager.unregisterListener(this);
	}

	public void onDrawFrame(GL10 gl) {
	/*
	* Usually, the first thing one might want to do is to clear
	* the screen. The most efficient way of doing this is to use
	* glClear().
	*/

	gl.glClear(GL10.GL_COLOR_BUFFER_BIT \| GL10.GL_DEPTH_BUFFER_BIT);

	/*
	* Now we're ready to draw some 3D objects
	*/

	gl.glMatrixMode(GL10.GL_MODELVIEW);
	gl.glLoadIdentity();
	gl.glTranslatef(0, 0, -2);

	/*
	* All the magic happens here. The rotation matrix mR reported by
	* SensorManager.getRotationMatrix() is a 4x4 row-major matrix.
	* We need to use its inverse for rendering. The inverse is
	* simply calculated by taking the matrix' transpose. However, since
	* glMultMatrixf() expects a column-major matrix, we can use mR
	* directly!
	*/
	gl.glMultMatrixf(mR, 0);
	// some test code which will be used/cleaned up before we ship this.
	//gl.glMultMatrixf(mI, 0);

	gl.glVertexPointer(3, GL_FLOAT, 0, mVertexBuffer);
	gl.glColorPointer(4, GL_FLOAT, 0, mColorBuffer);
	gl.glDrawElements(GL_LINES, 6, GL_UNSIGNED_BYTE, mIndexBuffer);
	}

	public void onSurfaceChanged(GL10 gl, int width, int height) {
	gl.glViewport(0, 0, width, height);

	/*
	* Set our projection matrix. This doesn't have to be done
	* each time we draw, but usually a new projection needs to
	* be set when the viewport is resized.
	*/

	float ratio = (float) width / height;
	gl.glMatrixMode(GL10.GL_PROJECTION);
	gl.glLoadIdentity();
	gl.glFrustumf(-ratio, ratio, -1, 1, 1, 10);
	}

	public void onSurfaceCreated(GL10 gl, EGLConfig config) {
	/*
	* By default, OpenGL enables features that improve quality
	* but reduce performance. One might want to tweak that
	* especially on software renderer.
	*/
	gl.glDisable(GL10.GL_DITHER);

	/*
	* Some one-time OpenGL initialization can be made here
	* probably based on features of this particular context
	*/
	gl.glClearColor(1,1,1,1);
	gl.glEnable(GL10.GL_CULL_FACE);
	gl.glShadeModel(GL10.GL_SMOOTH);
	gl.glEnable(GL10.GL_DEPTH_TEST);

	/*
	* create / load the our 3D models here
	*/

	gl.glEnableClientState(GL10.GL_VERTEX_ARRAY);
	gl.glEnableClientState(GL10.GL_COLOR_ARRAY);

	float vertices[] = {
	0,0,0,
	1,0,0,
	0,1,0,
	0,0,1
	};
	float colors[] = {
	0,0,0,0,
	1,0,0,1,
	0,1,0,1,
	0,0,1,1
	};
	byte indices[] = { 0, 1, 0, 2, 0, 3 };

	// Buffers to be passed to gl*Pointer() functions
	// must be direct, i.e., they must be placed on the
	// native heap where the garbage collector cannot
	// move them.
	//
	// Buffers with multi-byte datatypes (e.g., short, int, float)
	// must have their byte order set to native order

	ByteBuffer vbb;
	vbb = ByteBuffer.allocateDirect(vertices.length*4);
	vbb.order(ByteOrder.nativeOrder());
	mVertexBuffer = vbb.asFloatBuffer();
	mVertexBuffer.put(vertices);
	mVertexBuffer.position(0);

	vbb = ByteBuffer.allocateDirect(colors.length*4);
	vbb.order(ByteOrder.nativeOrder());
	mColorBuffer = vbb.asFloatBuffer();
	mColorBuffer.put(colors);
	mColorBuffer.position(0);

	mIndexBuffer = ByteBuffer.allocateDirect(indices.length);
	mIndexBuffer.put(indices);
	mIndexBuffer.position(0);
	}

	public void onAccuracyChanged(Sensor sensor, int accuracy) {
	}

	public void onSensorChanged(SensorEvent event) {
	int type = event.sensor.getType();
	float[] data;
	if (type == Sensor.TYPE_ACCELEROMETER) {
	data = mGData;
	} else if (type == Sensor.TYPE_MAGNETIC_FIELD) {
	data = mMData;
	} else {
	// we should not be here.
	return;
	}
	for (int i=0 ; i<3 ; i++)
	data[i] = event.values[i];

	SensorManager.getRotationMatrix(mR, mI, mGData, mMData);
	// some test code which will be used/cleaned up before we ship this.
	// SensorManager.remapCoordinateSystem(mR,
	// SensorManager.AXIS_X, SensorManager.AXIS_Z, mR);
	// SensorManager.remapCoordinateSystem(mR,
	// SensorManager.AXIS_Y, SensorManager.AXIS_MINUS_X, mR);
	SensorManager.getOrientation(mR, mOrientation);
	float incl = SensorManager.getInclination(mI);

	if (mCount++ > 50) {
	final float rad2deg = (float)(180.0f/Math.PI);
	mCount = 0;
	Log.d("Compass", "yaw: " + (int)(mOrientation[0]*rad2deg) +
	" pitch: " + (int)(mOrientation[1]*rad2deg) +
	" roll: " + (int)(mOrientation[2]*rad2deg) +
	" incl: " + (int)(incl*rad2deg)
	);
	}
	}
	}