Android CS323 Cornez

Lab 13: Sensors

Exercise 1: Detecting a Shake/Jerk Gesture

activity_main.xml

<?xml version="1.0" encoding="utf-8"?>
        <androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
            xmlns:app="http://schemas.android.com/apk/res-auto"
            xmlns:tools="http://schemas.android.com/tools"
            android:layout_width="match_parent"
            android:layout_height="match_parent"
            tools:context=".MainActivity">
        
            <ImageView
                android:id="@+id/imageView"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                app:layout_constraintBottom_toBottomOf="parent"
                app:layout_constraintEnd_toEndOf="parent"
                app:layout_constraintHorizontal_bias="0.0"
                app:layout_constraintStart_toStartOf="parent"
                app:layout_constraintTop_toTopOf="parent"
                app:srcCompat="@drawable/light_off"
                android:background="#020000"/>
        </androidx.constraintlayout.widget.ConstraintLayout>

MyShakeListener.java

import android.hardware.Sensor;
        import android.hardware.SensorEvent;
        import android.hardware.SensorEventListener;
        import android.hardware.SensorManager;
        import android.util.Log;
        
        
        public class MyShakeListener implements SensorEventListener {
        
            private long mTimeOfLastShake;
        
            private static final float SHAKE_THRESHOLD_GRAVITY = 22.0f;
            private static final int SHAKE_TIME_LAPSE = 500;   //IN MILLISECONDS
        
            // OnShakeListener THAT WILL BE NOTIFIED WHEN A SHAKE IS DETECTED
            final OnShakeListener mShakeListener;
        
            // CONSTRUCTOR SETS THE SHAKE LISTENER
            public MyShakeListener(OnShakeListener shakeListener) {
                mShakeListener = shakeListener;
            }
        
            @Override
            public void onSensorChanged(SensorEvent sensorEvent) {
                if (sensorEvent.sensor.getType() == Sensor.TYPE_ACCELEROMETER) {
                    //TASK 1: COLLECT SENSOR VALUES ON ALL THREE AXIS
                    float x = sensorEvent.values[0];
                    float y = sensorEvent.values[1];
                    float z = sensorEvent.values[2];
        
        
                    //TASK 2: COMPUTE  G-FORCE AS A DIRECTIONLESS MEASUREMENT
                    double value = Math.pow(x, 2.0) + Math.pow(y, 2.0) + Math.pow(z, 2.0);
                    float gForce = (float) (Math.sqrt(value)) - SensorManager.GRAVITY_EARTH;
        
                    //TASK 3: DETERMINE IF THE G-FORCE IS ENOUGH TO REGISTER AS A SHAKE
                    if (gForce > SHAKE_THRESHOLD_GRAVITY) {
                        //IGNORE CONTINUOUS SHAKES â€“ CHECK THAT 500 MILLISECONDS HAVE LAPSED
                        final long now = System.currentTimeMillis();
                        if (mTimeOfLastShake + SHAKE_TIME_LAPSE > now) {
                            return;
                        }
                        mTimeOfLastShake = now;
                        //THE LISTENER REGISTERED A SHAKE
                        mShakeListener.onShake();
                    }
                }
            }
        
            @Override
            public void onAccuracyChanged(Sensor sensor, int accuracy) {
            }
        
            public interface OnShakeListener {
                void onShake();
            }
        
        }

MainActivity.java

import androidx.appcompat.app.AppCompatActivity;
        
        import android.content.Context;
        import android.hardware.Sensor;
        import android.hardware.SensorManager;
        import android.os.Bundle;
        import android.widget.ImageView;
        
        public class MainActivity extends AppCompatActivity {
        
            //LIGHT ELEMENTS
            private final int ON = 1;
            private final int OFF = 0;
            private ImageView lightImage;
            private int lightStatus;
        
            //SENSOR SHAKE ELEMENTS
            private SensorManager mSensorManager;
            private Sensor mSensorAccelerometer;
            private MyShakeListener mShakeDetector;
        
            @Override
            protected void onCreate(Bundle savedInstanceState) {
                super.onCreate(savedInstanceState);
                setContentView(R.layout.activity_main);
        
                //TASK 1: INITIALIZE THE LIGHT
                lightStatus = OFF;
                lightImage = findViewById(R.id.imageView);
        
                //TASK 2: REGISTER THE THE SENSOR MANAGER AND SETUP THE SHAKE LISTENER
                mSensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
                mSensorAccelerometer = mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
                mShakeDetector = new MyShakeListener(new MyShakeListener.OnShakeListener() {
                    @Override
                    public void onShake() {
                        if (lightStatus == ON) {
                            lightStatus = OFF;
                            lightImage.setImageResource(R.drawable.light_off);
                        } else {
                            lightStatus = ON;
                            lightImage.setImageResource(R.drawable.light_on);
                        }
                    }
                });
            }
        
            @Override
            protected void onResume() {
                super.onResume();
                mSensorManager.registerListener(mShakeDetector,
                        mSensorAccelerometer, SensorManager.SENSOR_DELAY_UI);
            }
        
            @Override
            protected void onPause() {
                mSensorManager.unregisterListener(mShakeDetector,
                        mSensorAccelerometer);
                super.onPause();
            }
        
        }

Exercise 2: Roaming Bee (or Ball) using the Accelerometer.

This app is created in the textbook Lab Example 8-1

Construct an application containing a bee (or the ball shown below). You can add TextViews to the main layout to provide accelerometer readings.
When the application first launches, the user is presented with the bee or ball positioned at a specific x, y location on the screen.
The TextViews are helpful, as they display the x, y, and z-axis readings from the accelerometer.
As the user tilts and rotates the device, the text fileds will be updatedto show the current accelerometer readings.
In addition, the ball will move in accordance with the tilt and roll of the device, as shown in the figure.
The ball will not be allowed to roll off screen, and will be deterred by the virtual boundaries of the screen.

Bee.java (or Ball.java)

public class Bee {
          public float mX;
          public float mY;
          public int mWidth;
          public float mVelocityX;
          public float mVelocityY;
      
          //COLLISION BOUNDARIES FOR TOP, BOTTOM, LEFT, AND RIGHT
          public int top;
          public int bottom;
          public int left;
          public int right;
      
          public Bee() {
              mX = 250;
              mY = 250;
              mVelocityX = 0;
              mVelocityY = 0;
          }
      
          public void setBoundaries(int top, int bottom, int left, int right){
              mWidth = 504;
              this.top = top;
              this.bottom = bottom - mWidth;
              this.left = left;
              this.right = right - mWidth;
      
      
          }
          public void move() {
              //TASK 1: MOVE THE BEE
              mX = mX - mVelocityX;
              mY = mY + mVelocityY;
      
              //TASK 2: CHECK FOR COLLISION WITH THE TOP AND BOTTOM WALL.
              if (mY < top) {
                  mY = top;
              } else if (mY > bottom) {
                  mY = bottom;
              }
      
              //TASK 3: CHECK FOR COLLISION WITH THE LEFT AND RIGHT WALL.
              if (mX < left) {
                  mX = left;
              } else if (mX > right) {
                  mX = right;
              }
      
          }
      }

MainActivity.java (Needs to be completed)

import androidx.appcompat.app.AppCompatActivity;
      import androidx.constraintlayout.widget.ConstraintLayout;
      
      import android.content.Context;
      import android.content.pm.ActivityInfo;
      import android.content.res.Configuration;
      import android.content.res.Resources;
      import android.graphics.Bitmap;
      import android.graphics.drawable.BitmapDrawable;
      import android.hardware.Sensor;
      import android.hardware.SensorEvent;
      import android.hardware.SensorEventListener;
      import android.hardware.SensorManager;
      import android.os.Bundle;
      import android.os.Looper;
      import android.os.Handler;
      import android.util.DisplayMetrics;
      import android.view.LayoutInflater;
      import android.widget.ImageView;
      
      public class MainActivity extends AppCompatActivity implements SensorEventListener {
          //PART I: CLASS ATTRIBUTES
          private static ImageView beeImageView;
          private static Bee bee;
      
          private SensorManager mSensorManager;
          private Sensor mSensorAccelerometer;
          private Thread backgroundThread;
      
          //************************************
          //PART 2: ON CREATE TASKS
          @Override
          protected void onCreate(Bundle savedInstanceState) {
              super.onCreate(savedInstanceState);
              setContentView(R.layout.activity_main);
      
              //TASK 2: CREATE REFERENCES TO THE ACTIVITY LAYOUT
              ConstraintLayout mainLayout = (ConstraintLayout) findViewById(R.id.container);
      
              //TASK 3: ADD THE BEE IMAGEVIEW TO THE ACTIVITY LAYOUT
              LayoutInflater layoutInflater;
              layoutInflater = (LayoutInflater) getSystemService(Context.LAYOUT_INFLATER_SERVICE);
              beeImageView = (ImageView) layoutInflater.inflate(R.layout.bee_image, null);
              beeImageView.setX((float) 250);
              beeImageView.setY((float) 250);
              mainLayout.addView(beeImageView, 0);
      
              //TASK 4: GET THE DP VALUE FOR THE SCREEN SIZE AND THE BEE WIDTH
              DisplayMetrics screenMetrics = Resources.getSystem().getDisplayMetrics();
              int screenWidth = Math.round(screenMetrics.widthPixels);
              int screenHeight = Math.round(screenMetrics.heightPixels);
      
              //TASK 5: CREATE A BEE DATA OBJECT.  SUPPLY WIDTH AND CANVAS BOUNDARIES.
              bee = new Bee();
              bee.setBoundaries(0, screenHeight, 0, screenWidth);
      
              //TASK 6: REGISTER THE SENSOR MANAGER CREATE A SENSOR MONITOR
              mSensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
              mSensorAccelerometer = mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
      
              //TASK 7: CREATE A BACKGROUND THREAD FOR MOVING THE BEE
              backgroundThread = new Thread(beeMovement);
          }
      
      
      
      
      
      
          //********************************** PART 3: RUNNABLE ****************************
          private Runnable beeMovement = new Runnable() {
              private static final int DELAY = 10;
      
              public void run() {
                  try {
                      while (true) {
                          //TASK 1: MOVE THE BEE
                          bee.move();
                          //TASK 2: ADD A DELAY FOR THE ANIMATION
                          Thread.sleep(DELAY);
                          //TASK 3: UPDATE THE MESSAGE QUEUE
                          ioHandler.sendEmptyMessage(0);
                      }
                  } catch (InterruptedException e) { e.printStackTrace();}
              }
          };
      
          //************************ PART 4:  HANDLER ************************************
          //***** CONSTRUCT HANDLER FOR UPDATING THE BEE BETWEEN SLEEP DELAYS
          //      PASS IT TO THE LOOPER
          public Handler ioHandler = new Handler(Looper.myLooper()) {
              public void handleMessage(android.os.Message msg) {
                  //TASK: SET THE BEE IMAGE AT THE CORRECT XY LOCATION
                  beeImageView.setX((float) bee.mX);
                  beeImageView.setY((float) bee.mY);
              }
          };
      
          //******* PART 5: IMPLEMENTATION FOR ABSTRACT SENSOR EVENT LISTENER METHODS *****
          @Override
          public void onSensorChanged(SensorEvent sensorEvent) {
              if (sensorEvent.sensor.getType() == Sensor.TYPE_ACCELEROMETER) {
                  //TASK: COLLECT SENSOR VALUES ON X AND Y AXIS. CONVERT TO VELOCITIES
                  bee.mVelocityX = sensorEvent.values[0] * 3;
                  bee.mVelocityY = sensorEvent.values[1] * 3;
              }
          }
      
          @Override
          public void onAccuracyChanged(Sensor sensor, int accuracy) {}
      
      
          //***** PART 6 ACTIVITY CALLBACKS ******
          @Override
          protected void onResume() {
              super.onResume();
              mSensorManager.registerListener(this, mSensorAccelerometer, SensorManager.SENSOR_DELAY_UI);
              backgroundThread.start();
          }
      
          @Override
          protected void onPause() {
              mSensorManager.unregisterListener(this, mSensorAccelerometer);
              super.onPause();
          }
      
          public void onConfigurationChanged(Configuration newConfig){
              super.onConfigurationChanged(newConfig);
              setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
          }
      }

Exercise 3: Geomagnetic Rotation - Compass

. Implement a geomagnetic rotation vector for measuring the orientation of an Android device relative to a north, south, east, and west direction.

A geomagnetic rotation vector sensor is a composite sensor that will be defined by the accelerometer in tandem with the magnetometer. The application may need to specify each feature in a separate a uses-feature element within the Manifest file.
Indicate that motion readings will occur from an accelerometer and directional readings from a magnetometer (compass) on the device.
Set a portrait screen orientation for the application.
Use your own art creation for the compass image.