Android CS323 Cornez

Lab 7: Working with 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.

Exercise 4: Fling a Billiard Ball

This exercise allows users to fling a billiard ball across the screen in any direction. When the billiard ball hits the edges of the screen, it reverses direction as if it is bouncing off a wall. Friction should be applied to movement so that the ball eventually comes to a halt.

Research GestureDetector and OnGestureListener.

NOTE: Rename billiardball so that it reads ball.

Create the following files:
ball_layout.xml

This XML file is an ImageView layout that holds the billiardball.png.

main_layout.xml

FrameLayout

table.png

frameLayout

NOTE: The FrameLayout uses a coordinate system with 0,0 in the center.

Ball.java

        public class Ball {
          public int mX;
          public int mY;
          public int mRadius;
          public double mVelocityX;
          public double mVelocityY;
          public int left, right, top, bottom;
    
          public Ball(int mX, int mY, int mRadius, double mVelocityX, double mVelocityY){
            this.mX = mX;
            this.mY = mY;
            this.mRadius = mRadius;
            this.mVelocityX = mVelocityX;
            this.mVelocityY = mVelocityY;
          }
    
          public void move(){
            mX += mVelocityX;
            mY += mVelocityY;
    
            //COLLISIONS - REVERSE DIRECTIONS
            if (mX < left){
              mX = left;
              mVelocityX *= -1;
            }
            else if (mX > right){
              mX = right;
              mVelocityX *= -1;
            }
            if (mY < top){
              mY = top;
              mVelocityY *= -1;
            }
            else if (mY > bottom){
              mY = bottom;
              mVelocityY *= -1;
            }
    
            //APPLY FRICTION TO THE VELOCITY
            mVelocityX *= .93;
            mVelocityY *= .93;
            if (Math.abs(mVelocityX) < 1) mVelocityX = 0;
            if (Math.abs(mVelocityY) < 1) mVelocityY = 0;
    
          }
          public void setCollisionBoundaries( int windowWidth, int windowHeight){
            left = -windowWidth / 2 + mRadius;
            right = windowWidth / 2 - mRadius;
            top = -windowHeight / 2 + mRadius;
            bottom = windowHeight / 2 - mRadius;
          }
        }

MainActivity.java

        import android.content.Context;
        import android.os.Bundle;
        import android.os.Handler;
        import android.support.v7.app.AppCompatActivity;
        import android.util.DisplayMetrics;
        import android.view.GestureDetector;
        import android.view.LayoutInflater;
        import android.view.MotionEvent;
        import android.view.Window;
        import android.view.WindowManager;
        import android.widget.FrameLayout;
        import android.widget.ImageView;
    
        public class MainActivity extends AppCompatActivity implements GestureDetector.OnGestureListener {
    
          private GestureDetector aGesture;
    
          private FrameLayout mainLayout;
          private Thread backgroundThread;
          private ImageView ballImageView;
          private Ball mBall;
    
          private int left, right, top, bottom;
    
          @Override
          protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
    
            //TASK 1: SET THE LAYOUT AND THE WINDOW ELEMENTS
            requestWindowFeature(Window.FEATURE_NO_TITLE);
            getSupportActionBar().hide();
            setContentView(R.layout.main_layout);
            getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN);
            mainLayout = (FrameLayout) findViewById(R.id.frameLayout);
    
            //TASK 2: CREATE A BILLIARD BALL
            buildBilliardBall();
    
            //TASK 3: CREATE A GESTURE DETECTOR
            aGesture = new GestureDetector(this, this);
    
            //TASK 4: CREATE THE BACKGROUND THREAD
            backgroundThread = new Thread(calculateAction);
            backgroundThread.start();
          }
    
          private void buildBilliardBall() {
            //TASK 1: THE CREATE THE DATA MODEL FOR THE BILLIARD BALL
            mBall = new Ball(0, 0, 150, 0, 0);
            DisplayMetrics metrics = new DisplayMetrics();
            getWindowManager().getDefaultDisplay().getMetrics(metrics);
            mBall.setCollisionBoundaries(metrics.widthPixels, metrics.heightPixels);
    
            //TASK 2: CREATE A LAYOUT INFLATER TO ADD THE BILLIARD BALL IMAGEVIEW TO THE LAYOUT
            LayoutInflater layoutInflater;
            layoutInflater = (LayoutInflater) getSystemService(Context.LAYOUT_INFLATER_SERVICE);
    
            //TASK 3: ADD THE BALL TO THE LAYOUT
            ballImageView = (ImageView) layoutInflater.inflate(R.layout.ball_layout, null);
            ballImageView.setScaleX((float) .3);
            ballImageView.setScaleY((float) .3);
            ballImageView.setX((float) mBall.mX);
            ballImageView.setY((float) mBall.mY);
            mainLayout.addView(ballImageView, 0);
          }
    
    
          //**************** RUNNABLE **********************
          private Runnable calculateAction = new Runnable() {
            private static final int DELAY = 50;
            public void run() {
              try {
                while (true) {
                  mBall.move();
                  Thread.sleep(DELAY);
                  threadHandler.sendEmptyMessage(0);
                }
              } catch (InterruptedException e) {
              }
            }
          };
          //****** HANDLER FOR UPDATING THE IMAGEVIEW CONTAINING THE BILLIARD BALL******
          public Handler threadHandler = new Handler() {
            public void handleMessage(android.os.Message msg) {
              //UPDATE BALL LOCATION
              ballImageView.setX((float) mBall.mX);
              ballImageView.setY((float) mBall.mY);
            }
          };
    
    
    
          //***********************TOUCH GESTURES*************************
          @Override
          public boolean onTouchEvent(MotionEvent event) {
            return aGesture.onTouchEvent(event);
          }
          @Override
          public boolean onFling(MotionEvent event1, MotionEvent event2, float velocityX, float velocityY) {
            final float ADJUST = 0.025f;
            mBall.mVelocityX = (int) velocityX * ADJUST;
            mBall.mVelocityY = (int) velocityY * ADJUST;
            return true;
          }
          @Override
          public void onLongPress(MotionEvent event) {}
          @Override
          public void onShowPress(MotionEvent event) {}
          @Override
          public boolean onDown(MotionEvent event) {return false;}
          @Override
          public boolean onScroll(MotionEvent e1, MotionEvent e2,float distanceX, float distanceY) {return false;}
          @Override
          public boolean onSingleTapUp(MotionEvent event) {return false;}
        }