Android 后退按钮不调用暂停

我有一个活动，它显示传感器值并将它们从

onSensorChanged

方法发送到同步队列。我在发布到队列上有一个超时，这样当队列阻塞时，

onSensorChanged

方法不会阻塞。然后，我希望按下后退按钮时会调用

onPause

方法，但实际上没有，屏幕只是挂起而没有返回到上一个屏幕。知道为什么会这样吗

顺便说一句，当队列没有阻塞（数据被订阅者删除）时，所有功能都会按预期工作，当按下后退按钮时，

onPause

被调用

public void onSensorChanged(SensorEvent event) {
    TextView tvX = (TextView) findViewById(R.id.textViewRemLinAccX);
    TextView tvY = (TextView) findViewById(R.id.textViewRemLinAccY);
    TextView tvZ = (TextView) findViewById(R.id.textViewRemLinAccZ);
    String x = String.format(format, event.values[0]);
    String y = String.format(format, event.values[1]);
    String z = String.format(format, event.values[2]);
    tvX.setText(x);
    tvY.setText(y);
    tvZ.setText(z);

    try {
        if (btConnection.isRunning()) {
            Log.i(TAG, "+++ queue values");
            queue.offer(constructData(x, y, z), 1, TimeUnit.SECONDS);
        }
    } catch (InterruptedException e) {
        Log.e(TAG, "+++  err " + e.toString());
    }

}

---

如果您正在使用其他操作（当您在主线程上执行某些操作时）阻止UI，则“后退”按钮将不起作用，您应该在后台线程上执行任何需要时间的操作。

这似乎已得到解决，但我不太清楚我是如何做到的，因此已包含供其他人使用的代码。我做了很多重构来确保连接资源得到了正确的清理，现在按下后退按钮时会调用onPause和onDestroy方法

public void onSensorChanged(SensorEvent event) {
    TextView tvX = (TextView) findViewById(R.id.textViewRemLinAccX);
    TextView tvY = (TextView) findViewById(R.id.textViewRemLinAccY);
    TextView tvZ = (TextView) findViewById(R.id.textViewRemLinAccZ);
    String x = String.format(format, event.values[0]);
    String y = String.format(format, event.values[1]);
    String z = String.format(format, event.values[2]);
    tvX.setText(x);
    tvY.setText(y);
    tvZ.setText(z);

    try {
        if (btConnection.isRunning()) {
            Log.i(TAG, "+++ queue values");
            queue.offer(constructData(x, y, z), 1, TimeUnit.SECONDS);
        }
    } catch (InterruptedException e) {
        Log.e(TAG, "+++  err " + e.toString());
    }

}

仅供参考，此活动将打开蓝牙连接，并将传感器数据发送到另一台计算机，以用于控制乐高NXT机器人

package uk.co.moonsit.apps.sensors.remote;

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.TimeUnit;

import uk.co.moonsit.apps.sensors.R;
import uk.co.moonsit.bluetooth.BluetoothConnection;
import android.hardware.Sensor;
import android.hardware.SensorEvent;
import android.hardware.SensorEventListener;
import android.hardware.SensorManager;
import android.os.Bundle;
import android.app.Activity;
import android.content.Context;
import android.util.Log;
import android.view.Menu;
import android.view.WindowManager;
import android.widget.TextView;

public class RemoteLinearAccelerationActivity extends Activity implements
        SensorEventListener {

    private static final String TAG = "RemoteLinearAccelerationActivity";

    private BlockingQueue<String> queue;
    private SensorManager mSensorManager;
    private Sensor mLinAcc;
    private String format = "%.3f";
    private String type;
    private BluetoothConnection btConnection;
    private String delimiter = "|";
    private String cr;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_remote_linear_acceleration);
        getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
        byte[] crb = new byte[1];
        crb[0] = 13;
        cr = new String(crb);
        mSensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
        mLinAcc = mSensorManager.getDefaultSensor(Sensor.TYPE_LINEAR_ACCELERATION);
        queue = new SynchronousQueue<String>();
        type = "LinAcc";
        btConnection = new BluetoothConnection(queue, "00001101-0000-1000-8000-00805F9B34FB", "<MAC address here>", "11", "28,13");
        Log.i(TAG, "+++ onCreate ");

    }

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        // Inflate the menu; this adds items to the action bar if it is present.
        getMenuInflater().inflate(R.menu.remote_linear_acceleration, menu);
        return true;
    }

    @Override
    public void onAccuracyChanged(Sensor arg0, int arg1) {
    }

    @Override
    public void onSensorChanged(SensorEvent event) {
        TextView tvX = (TextView) findViewById(R.id.textViewRemLinAccX);
        TextView tvY = (TextView) findViewById(R.id.textViewRemLinAccY);
        TextView tvZ = (TextView) findViewById(R.id.textViewRemLinAccZ);
        String x = String.format(format, event.values[0]);
        String y = String.format(format, event.values[1]);
        String z = String.format(format, event.values[2]);
        tvX.setText(x);
        tvY.setText(y);
        tvZ.setText(z);

        try {
            String msg = constructData(x, y, z);
            if (btConnection.isRunning()) {
                Log.i(TAG, "+++ queue values");
                queue.offer(msg, 10, TimeUnit.SECONDS);
            }
        } catch (InterruptedException e) {
            Log.e(TAG, "+++  err " + e.toString());
        }

    }

    private String constructData(String x, String y, String z) {
        StringBuilder sb = new StringBuilder();
        sb.append(type + delimiter);
        sb.append(x + delimiter);
        sb.append(y + delimiter);
        sb.append(z);
        sb.append(cr);
        return sb.toString();
    }

    @Override
    protected void onPause() {
        super.onPause();
        Log.i(TAG, "+++ onPause unregisterListener ");
        mSensorManager.unregisterListener(this);
    }

    @Override
    protected void onResume() {
        super.onResume();
        Log.i(TAG, "+++ onResume registerListener ");
        mSensorManager.registerListener(this, mLinAcc, SensorManager.SENSOR_DELAY_NORMAL);
        Log.i(TAG, "+++ onResume start btConnection");
        new Thread(btConnection).start();
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        Log.i(TAG, "+++ onDestroy closing btConnection");
        btConnection.stop();
    }

}



package uk.co.moonsit.bluetooth;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.util.UUID;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.TimeUnit;

import uk.co.moonsit.messaging.BeginEndEnvelope;

import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothDevice;
import android.bluetooth.BluetoothSocket;
//import android.os.ParcelUuid;
import android.util.Log;

public class BluetoothConnection implements Runnable {
    private static final String TAG = "BluetoothConnection";

    private final BlockingQueue<String> queue;
    private BluetoothAdapter mBluetoothAdapter;
    private BluetoothDevice device;
    private BluetoothSocket clientSocket;
    private DataInputStream in = null;
    private DataOutputStream out = null;
    private String address;
    private boolean isConnected = false;
    private BeginEndEnvelope envelope;
    private String uuid;
    private boolean isRunning = true;

    public BluetoothConnection(BlockingQueue<String> q, String ud, String a,
            String start, String end) {
        uuid = ud;
        queue = q;
        address = a;
        mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
        envelope = new BeginEndEnvelope(start, end);
    }

    private void getDevice() throws IOException {
        device = mBluetoothAdapter.getRemoteDevice(address);
    }

    private void getSocket() throws IOException {
        clientSocket = device.createRfcommSocketToServiceRecord(UUID.fromString(uuid));
        mBluetoothAdapter.cancelDiscovery();
    }

    private boolean connect() {

        if (!isConnected) {
            Log.i(TAG, "+++ connecting");
            try {
                getSocket();

                Log.i(TAG, "+++ b4 connect");
                clientSocket.connect();
                Log.i(TAG, "+++ connected");

                isConnected = true;

                in = new DataInputStream(clientSocket.getInputStream());
                out = new DataOutputStream(clientSocket.getOutputStream());
                Log.i(TAG, "+++ streams created");

            } catch (IOException e) {
                Long sleep = (long) 10000;
                Log.e(TAG, "+++ connection failed, sleep for " + sleep);
                try {
                    Thread.sleep(sleep);
                } catch (InterruptedException e1) {
                    e1.printStackTrace();
                }
            }
        }
        return isConnected;
    }

    public void run() {

        try {
            getDevice();
        } catch (IOException e) {
            Log.e(TAG, "+++  device error " + e.toString());
        }
        while (isRunning) {
            try {
                processData();
            } catch (Exception e) {
                Log.e(TAG, "+++  data error " + e.toString());
            }
        }
        close();
        Log.i(TAG, "+++  ending bluetooth run");
    }

    private void closeSocket() {
        if (clientSocket != null)
            try {
                clientSocket.close();
                Log.d(TAG, "+++  socket closed");

            } catch (IOException e) {
                e.printStackTrace();
            }
    }

    private void closeStreams() {
        if (in != null)
            try {
                in.close();
                Log.d(TAG, "+++  input stream closed");
            } catch (IOException e) {
                Log.e(TAG, "+++  input stream not closed " + e.toString());
            }

        if (out != null)
            try {
                out.close();
                Log.d(TAG, "+++  output stream closed");
            } catch (IOException e) {
                Log.e(TAG, "+++  output stream not closed " + e.toString());
            }
    }

    private void close() {
        closeStreams();
        closeSocket();

        isConnected = false;
    }

    public void stop() {
        isRunning = false;
    }

    public boolean isRunning() {
        return isRunning;
    }

    public void setRunning(boolean isRunning) {
        this.isRunning = isRunning;
    }

    private void processData() throws Exception {

        try {

            String outData = null;
            int timer = 0;
            while (outData == null) {
                if (!connect())
                    return;
                Log.i(TAG, "+++ waiting on queue ");
                outData = queue.poll(1, TimeUnit.SECONDS);// .take();
                if (timer++ > 15) {
                    return;
                }
            }
            envelope.sendMessage(outData, out);
            String inData = envelope.receiveMessage(in);
            Log.i(TAG, "+++ response " + inData);
        } catch (Exception e) {
            Log.e(TAG, "+++ processData error " + e.toString());
            close();
            throw e;
        }

    }

}

package uk.co.moonsit.apps.sensors.remote；
导入java.util.concurrent.BlockingQueue；
导入java.util.concurrent.SynchronousQueue；
导入java.util.concurrent.TimeUnit；
导入uk.co.moonsit.apps.sensors.R；
导入uk.co.moonsit.bluetooth.BluetoothConnection；
导入android.hardware.Sensor；
导入android.hardware.SensorEvent；
导入android.hardware.SensorEventListener；
导入android.hardware.SensorManager；
导入android.os.Bundle；
导入android.app.Activity；
导入android.content.Context；
导入android.util.Log；
导入android.view.Menu；
导入android.view.WindowManager；
导入android.widget.TextView；
公共类RemoteLinearAccelerationActivity扩展了活动实现
SensorEventListener{
私有静态最终字符串标记=“RemoteLinearAccelerationActivity”；
私有阻塞队列；
私人传感器管理器；
专用传感器；
私有字符串格式=“%.3f”；
私有字符串类型；
私人蓝牙连接；
专用字符串分隔符=“|”；
私有字符串cr；
@凌驾
创建时受保护的void（Bundle savedInstanceState）{
super.onCreate（savedInstanceState）；
setContentView（R.layout.activity\u remote\u linear\u acceleration）；
getWindow（）.addFlags（WindowManager.LayoutParams.FLAG\u保持屏幕打开）；
字节[]crb=新字节[1]；
crb[0]=13；
cr=新字符串（crb）；
msSensorManager=（SensorManager）getSystemService（Context.SENSOR\u服务）；
mLinAcc=mSensorManager.getDefaultSensor（传感器类型为线性加速度）；
队列=新的SynchronousQueue（）；
type=“LinAcc”；
btConnection=新的蓝牙连接（队列“00001101-0000-1000-8000-00805F9B34FB”、“11”、“28,13”）；
Log.i（标记“+++onCreate”）；
}
@凌驾
公共布尔onCreateOptions菜单（菜单）{
//为菜单充气；这会将项目添加到操作栏（如果存在）。
getMenuInflater（）.充气（右菜单、远程线性加速、菜单）；
返回true；
}
@凌驾
已更改准确性上的公共无效信息（传感器arg0、内部arg1）{
}
@凌驾
传感器更改时的公共无效（传感器事件）{
TextView tvX=（TextView）findViewById（R.id.textViewRemLinAccX）；
TextView tvY=（TextView）findViewById（R.id.TextView remlinaccy）；
TextView tvZ=（TextView）findViewById（R.id.textViewRemlinacz）；
String x=String.format（格式，event.values[0]）；
字符串y=String.format（格式，event.values[1]）；
String z=String.format（格式，event.values[2]）；
tvX.setText（x）；
tvY.setText（y）；
tvZ.setText（z）；
试一试{
字符串msg=constructData（x，y，z）；
if（btConnection.isRunning（））{
Log.i（标记“+++队列值”）；
报价（消息，10，时间单位，秒）；
}
}捕捉（中断异常e）{
Log.e（标记“+++err”+e.toString（））；
}
}
私有字符串数据（字符串x、字符串y、字符串z）{
StringBuilder sb=新的StringBuilder（）；
sb.追加（类型+分隔符）；
sb.追加（x+分隔符）；
sb.追加（y+分隔符）；
sb.追加（z）；
sb.append（cr）；
使某人返回字符串（）；
}
@凌驾
受保护的void onPause（）{
super.onPause（）；
Log.i（标记，“+++onPause unregisterelistener”）；
mSensorManager.unregisterListener（此）；
}
@凌驾
受保护的void onResume（）{
super.onResume（）；
Log.i（标记“+++onResume registerListener”）；
MSSensorManager.registerListener（此、mLinAcc、SensorManager.SENSOR\u延迟\u正常）；
Log.i（标记“+++onResume-start-btConnection”）；
新线程（btConnection）.start（）；
}
@凌驾
受保护的空onDestroy（）{
super.ondestory（）；
Log.i（标记“+++onDestroy关闭btConnection”）；
btConnection.stop（）；
}
}
包uk.co.moonsit.bluetooth；
导入java.io.DataInputStream；
导入java.io.DataOutputStream；
导入java.io.IOException；
导入java.util.UUID；
导入java.util.concurrent.BlockingQueue；
导入java.util.concurrent.TimeUnit；
导入uk.co.moonsit.messaging.beginendevelope；
导入android.bluetooth.BluetoothAdapter；
导入android.bluetooth.bluetooth设备；
导入android.bluetooth.BluetoothSocket；
//导入android.os.parceluid；
导入android.util.Log；
公共类BluetoothConnection实现可运行{
私有静态最终字符串TAG=“BluetoothConnection”；
私有最终阻塞队列；
私人蓝牙适配器mBluetoothAdapter；
私人蓝