I am writing a basic application to test the behavior of the accelerometer. Currently I am registering and unregistering the accelerometer like this:
public void pause() {
mSensorManager.unregisterListener(this);
}
public void resume(Context context) {
mSensorManager.registerListener(this, mAccelerometer,
SensorManager.SENSOR_DELAY_FASTEST);
}
I have the pause and resume methods triggered by the Activity, as the accelerometer is running in a child class. When I lock the screen the screen, the program breaks. I actually have to end the process to get the program to work again. I am currently using WidgetLocker. The program works fine with the stock lockscreen. My assumption is that resume is never being run.
Is there a way to make sure that the sensor will be reregisterd? I don't want my program to break if they are using anything outside of the normal lockscreen.
EDIT: Full Source Added. The main logic regarding this issue takes place at the bottom of MainGamePanel.java
TiltBallActivity.java
package com.tornquist.nathan;
import android.app.Activity;
import android.content.pm.ActivityInfo;
import android.os.Bundle;
import android.view.Window;
import android.view.WindowManager;
public class TiltBallActivity extends Activity{
/** Called when the activity is first created. */
MainGamePanel viewPanel;
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
//Window state functions.
requestWindowFeature(Window.FEATURE_NO_TITLE);
getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN);
setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
//This works without declaring a viewPanel instance here.
//The instance declaration is needed to pass the
//onPause and onResume commands though.
viewPanel = new MainGamePanel(this);
setContentView(viewPanel);
}
//Restarts the accelerometer after onPause
protected void onResume() {
viewPanel.resume(this);
super.onResume();
}
//Standard Method run when the Application loses focus.
//This runs the pause() function in the viewPanel so that
//the accelerometer can be paused.
protected void onPause() {
viewPanel.pause();
super.onPause();
}
}
MainThread.java
package com.tornquist.nathan;
import com.tornquist.nathan.MainGamePanel;
import android.graphics.Canvas;
import android.view.SurfaceHolder;
public class MainThread extends Thread {
private SurfaceHolder surfaceHolder;
private MainGamePanel gamePanel;
private boolean running;
public void setRunning(boolean running) {
this.running = running;
}
public MainThread(SurfaceHolder surfaceHolder, MainGamePanel gamePanel) {
super();
this.surfaceHolder = surfaceHolder;
this.gamePanel = gamePanel;
}
@Override
public void run()
{
Canvas canvas;
while (running) {
canvas = null;
// try locking the canvas for exclusive pixel editing on the surface
try {
canvas = this.surfaceHolder.lockCanvas();
synchronized (surfaceHolder) {
// update game state
this.gamePanel.update();
// draws the canvas on the panel
this.gamePanel.onDraw(canvas);
}
} finally {
// in case of an exception the surface is not left in
// an inconsistent state
if (canvas != null) {
surfaceHolder.unlockCanvasAndPost(canvas);
}
} // end finally
}
}
}
MainGamePanel.java
package com.tornquist.nathan;
import android.app.Activity;
import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.Paint.Style;
import android.hardware.Sensor;
import android.hardware.SensorEvent;
import android.hardware.SensorEventListener;
import android.hardware.SensorManager;
import android.view.Display;
import android.view.MotionEvent;
import android.view.SurfaceHolder;
import android.view.SurfaceView;
public class MainGamePanel extends SurfaceView implements SensorEventListener, SurfaceHolder.Callback
{
//Variable Declarations.
private MainThread thread;
public int xColor;
public int yColor;
public int zColor;
public float xPos;
public float yPos;
public float oldXPos;
public float oldYPos;
public int screenWidth;
public int screenHeight;
private SensorManager mSensorManager;
private Sensor mAccelerometer;
Paint paint;
public MainGamePanel(Context context)
{
//Standard Initialization
super(context);
//This line adds a callback for the touch screen.
//This allows you to actually capture touch input.
getHolder().addCallback(this);
thread = new MainThread(getHolder(),this);
xColor = 100;
yColor = 100;
zColor = 100;
paint = new Paint();
paint.setAntiAlias(true);
Display display = ((Activity) context).getWindowManager().getDefaultDisplay();
screenWidth = display.getWidth();
screenHeight = display.getHeight();
yPos = screenHeight/2;
xPos = screenWidth/2;
oldYPos = yPos;
oldXPos = xPos;
//This registers the accelerometer. Without registering it, the onSensorChanged
//event will never be called, and you cannot get the accelerometer values.
mSensorManager = (SensorManager) context.getSystemService(Context.SENSOR_SERVICE);
mAccelerometer = mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
mSensorManager.registerListener(this, mAccelerometer, SensorManager.SENSOR_DELAY_FASTEST);
//Also required for touch input.
setFocusable(true);
}
@Override
public void surfaceChanged(SurfaceHolder holder, int format, int width,
int height) {
}
@Override
public void surfaceCreated(SurfaceHolder holder) {
// at this point the surface is created and
// we can safely start the game loop
thread.setRunning(true);
thread.start();
}
@Override
public void surfaceDestroyed(SurfaceHolder holder) {
boolean retry = true;
while (retry) {
try {
thread.join();
retry = false;
} catch (InterruptedException e) {
// try again shutting down the thread
}
}
}
@Override
public boolean onTouchEvent(MotionEvent event) {
if (event.getAction() == MotionEvent.ACTION_DOWN) {
// check if in the lower part of the screen we exit
if (event.getY() > getHeight() - 50) {
thread.setRunning(false);
((Activity)getContext()).finish();
}
if (xColor < 235)
xColor = xColor + 20;
else
xColor = 0;
if (yColor < 235)
yColor = yColor + 20;
else
yColor = 0;
if (zColor < 235)
zColor = zColor + 20;
else
zColor = 0;
yPos = event.getY();
xPos = event.getX();
}
return true;
}
@Override
protected void onDraw(Canvas canvas)
{
//canvas.drawColor(Color.CYAN);
canvas.drawColor(Color.rgb(xColor, yColor, zColor));
int xInvert = (int) (255 - xColor);
int yInvert = (int) (255 - yColor);
int zInvert = (int) (255 - zColor);
paint.setColor(Color.rgb(xInvert, yInvert, zInvert));
paint.setStyle(Style.FILL);
canvas.drawCircle(xPos, yPos, 50, paint);
}
public void update() {
}
@Override
public void onAccuracyChanged(Sensor sensor, int accuracy) {
}
@Override
public void onSensorChanged(SensorEvent event) {
oldYPos = yPos;
oldXPos = xPos;
xColor = (int) (255 + (event.values[0])*11);
if (xColor > 255)
xColor = 255;
if (xColor < 0)
xColor = 0;
yColor = (int) (255 + (event.values[1])*11);
if (yColor > 255)
yColor = 255;
if (yColor < 0)
yColor = 0;
zColor = (int) (255 + (event.values[2])*11);
if (zColor > 255)
zColor = 255;
if (zColor < 0)
zColor = 0;
xPos = xPos + -1*(event.values[0])*5;
yPos = yPos + event.values[1]*5;
if (xPos < 50)
xPos = 50;
if (xPos > screenWidth - 50)
xPos = screenWidth - 50;
if (yPos < 50)
yPos = 50;
if (yPos > screenHeight - 50)
yPos = screenHeight - 50;
if ((oldYPos == yPos) && (oldXPos == xPos))
{
invalidate();
}
}
public void pause() {
mSensorManager.unregisterListener(this);
//thread.setRunning(false);
//((Activity)getContext()).finish();
}
public void resume(Context context) {
//mSensorManager = (SensorManager) context.getSystemService(Context.SENSOR_SERVICE);
//mAccelerometer = mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
mSensorManager.registerListener(this, mAccelerometer, SensorManager.SENSOR_DELAY_FASTEST);
}
}
I think you could use the ACTION_SCREEN_ON and ACTION_SCREEN_OFF Intent actions and you don't have to deal with onPause and onResume thing. So something like this:
mReceiver = new BroadcastReceiver() {
public void onReceive(Context context, Intent intent) {
String action = intent.getAction();
if (Intent.ACTION_SCREEN_OFF.equals(action)) {
//deregister
}
else if (Intent.ACTION_SCREEN_ON.equals(action)) {
//register
}
}};
IntentFilter filter = new IntentFilter(Intent.ACTION_SCREEN_ON);
registerReceiver(mReceiver, filter);
filter = new IntentFilter(Intent.ACTION_SCREEN_OFF);
registerReceiver(mReceiver, filter);
and deregister this receiver in the onDestroy() method
Ok I think I found a solution. The thread.join part in the onSurfaceDestroyed method code blocks the activity somehow. I made a few modifications on your code and this works for me:
public MainGamePanel(Context context)
{
...
//Also required for touch input.
setFocusable(true);
//start thread
thread.setRunning(true);
thread.start();
}
@Override
public void surfaceChanged(SurfaceHolder holder, int format, int width,
int height) {
}
@Override
public void surfaceCreated(SurfaceHolder holder) {
//continue the thread
synchronized (thread) {
thread.pleaseWait = false;
thread.notifyAll();
}
}
@Override
public void surfaceDestroyed(SurfaceHolder holder) {
//pause the thread
synchronized (thread) {
thread.pleaseWait = true;
}
}
And the thread class
public class MainThread extends Thread {
private SurfaceHolder surfaceHolder;
private MainGamePanel gamePanel;
private boolean running;
public boolean pleaseWait = true;
public void setRunning(boolean running) {
this.running = running;
}
public MainThread(SurfaceHolder surfaceHolder, MainGamePanel gamePanel) {
super();
this.surfaceHolder = surfaceHolder;
this.gamePanel = gamePanel;
}
@Override
public void run()
{
Canvas canvas;
while (running) {
if(!pleaseWait) {
canvas = null;
// try locking the canvas for exclusive pixel editing on the surface
try {
canvas = this.surfaceHolder.lockCanvas();
synchronized (surfaceHolder) {
// update game state
this.gamePanel.update();
// draws the canvas on the panel
this.gamePanel.onDraw(canvas);
}
} finally {
// in case of an exception the surface is not left in
// an inconsistent state
if (canvas != null) {
surfaceHolder.unlockCanvasAndPost(canvas);
}
} // end finally
}
else {
synchronized (this) {
try {
wait();
} catch (Exception e) { }
}
}
}
}
}
And destroy the thread in the onDestroy method