Android 在我的一个蓝牙课程中遇到一个奇怪的NPE，它没有'；以前不会发生

我使用Android的蓝牙聊天示例应用程序作为指南，尝试为我正在开发的应用程序创建自己的蓝牙功能

昨晚我用两部Android手机测试了它，发现了一些问题，但没有强制关闭。当我要求它连接我的设备时，它根本没有连接。我进去添加了几行日志，以确保程序遵循正确的路线。当我今天在手机上重新安装并启动应用程序时，我在尝试打开蓝牙时遇到了一个强制关闭错误，这是我昨晚根本没有遇到的问题。我唯一更改的代码是添加了2-3个日志命令。我检查了logcat，得到以下信息：

如您所见，问题是由第185行的NPE引起的。这是我为BluetoothService类编写的代码，我将在下面重新发布问题的特定区域

package com.tagapp.android;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.UUID;

import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothDevice;
import android.bluetooth.BluetoothServerSocket;
import android.bluetooth.BluetoothSocket;
import android.content.Context;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.util.Log;

public class BluetoothService {

    private static final String TAG = "BluetoothService";
    private static final boolean D = true;
    private static final String NAME = "BluetoothTag";
    private static final UUID MY_UUID = 
        UUID.fromString("93845760-234e-11e0-ac64-0800200c9a66");

    private final BluetoothAdapter mAdapter;
    private final Handler mHandler;
    private AcceptThread mAcceptThread;
    private ConnectThread mConnectThread;
    private ConnectedThread mConnectedThread;
    private int mState;

    public static final int STATE_NONE = 0;
    public static final int STATE_LISTEN = 1;
    public static final int STATE_CONNECTING = 2;
    public static final int STATE_CONNECTED = 3;

    public BluetoothService(Context context, Handler handler) {
        mAdapter = BluetoothAdapter.getDefaultAdapter();
        mState = STATE_NONE;
        mHandler = handler;
    }

    private synchronized void setState(int state) {
        if (D) Log.d(TAG, "setState() " + mState + " -> " + state);
        mState = state;
        mHandler.obtainMessage(BluetoothTransfer.MESSAGE_STATE_CHANGE, state, -1).sendToTarget();
    }

    public synchronized int getState() {
        return mState;
    }

    public synchronized void start() {
        if (D) Log.d(TAG, "start");

        if(mConnectThread != null) {
            mConnectThread.cancel();
            mConnectThread = null;
        }

        if(mConnectedThread != null) {
            mConnectedThread.cancel();
            mConnectedThread = null;
        }

        if(mAcceptThread == null) {
            mAcceptThread = new AcceptThread();
            mAcceptThread.start();
        }
        setState(STATE_LISTEN);
    }

    public synchronized void connect(BluetoothDevice device) {
        if (D) Log.d(TAG, "connect to: " + device);
        if(mState == STATE_CONNECTING) {
            if(mConnectThread != null) {
                mConnectThread.cancel();
                mConnectThread = null;
            }
        }
        if(mConnectedThread != null) {
            mConnectedThread.cancel();
            mConnectedThread = null;
        }
        mConnectThread = new ConnectThread(device);
        mConnectThread.start();
        setState(STATE_CONNECTING);
    }

    public synchronized void connected(BluetoothSocket socket, BluetoothDevice device) {
        if (D) Log.d(TAG, "connected");

        if(mConnectThread != null) {
            mConnectThread.cancel();
            mConnectThread = null;
        }

        if(mConnectedThread != null) {
            mConnectedThread.cancel();
            mConnectedThread = null;
        }

        if(mAcceptThread != null) {
            mAcceptThread.cancel();
            mAcceptThread = null;
        }
        mConnectedThread = new ConnectedThread(socket);
        mConnectedThread.start();
        Message msg = mHandler.obtainMessage(BluetoothTransfer.MESSAGE_DEVICE_NAME);
        Bundle bundle = new Bundle();
        bundle.putString(BluetoothTransfer.DEVICE_NAME, device.getName());
        msg.setData(bundle);
        mHandler.sendMessage(msg);
        setState(STATE_CONNECTED);
    }

    public synchronized void stop() {
        if (D) Log.d(TAG, "stop");

        if(mConnectThread != null) {
            mConnectThread.cancel();
            mConnectThread = null;
        }

        if(mConnectedThread != null) {
            mConnectedThread.cancel();
            mConnectedThread = null;
        }

        if(mAcceptThread != null) {
            mAcceptThread.cancel();
            mAcceptThread = null;
        }
        setState(STATE_NONE);
    }

    public void write(byte[] out) {
        ConnectedThread ct;
        synchronized(this) {
            if(mState != STATE_CONNECTED) return;
            ct = mConnectedThread;
        }
        ct.write(out);
    }

    private void connectionFailed() {
        setState(STATE_LISTEN);
        Message msg = mHandler.obtainMessage(BluetoothTransfer.MESSAGE_TOAST);
        Bundle bundle = new Bundle();
        bundle.putString(BluetoothTransfer.TOAST, "Unable to connect device");
        msg.setData(bundle);
        mHandler.sendMessage(msg);
    }

    private void connectionLost() {
        setState(STATE_LISTEN);
        Message msg = mHandler.obtainMessage(BluetoothTransfer.MESSAGE_TOAST);
        Bundle bundle = new Bundle();
        bundle.putString(BluetoothTransfer.TOAST, "Device connection was lost");
        msg.setData(bundle);
        mHandler.sendMessage(msg);
    }

    private class AcceptThread extends Thread {
        private final BluetoothServerSocket mmServerSocket;

        public AcceptThread() {
            BluetoothServerSocket tmp = null;
            try {
                tmp = mAdapter.listenUsingRfcommWithServiceRecord(NAME, MY_UUID);
            }
            catch (IOException e) {
                Log.e(TAG, "listen() failed", e);
            }
            mmServerSocket = tmp;
        }

        public void run() {
            if (D) Log.d(TAG, "BEGIN mAcceptThread" + this);
            setName("AcceptThread");
            BluetoothSocket socket = null;
            while (mState != STATE_CONNECTED) {
                try {
                    socket = mmServerSocket.accept();
                }
                catch (IOException e) {
                    Log.e(TAG, "accept() failed", e);
                    break;
                }
                if(socket != null) {
                    synchronized (BluetoothService.this) {
                        switch(mState) {
                        case STATE_LISTEN :
                        case STATE_CONNECTING :
                            connected(socket, socket.getRemoteDevice());
                            break;
                        case STATE_NONE :
                        case STATE_CONNECTED :
                            try {
                                socket.close();
                            }
                            catch (IOException e) {
                                Log.e(TAG, "Could not close unwanted socket", e);
                            }
                            break;
                        }
                    }
                }
            }
            if (D) Log.i(TAG, "END mAcceptThread");
        }

        public void cancel() {
            if (D) Log.d(TAG, "cancel " + this);
            try {
                mmServerSocket.close();
            }
            catch (IOException e) {
                Log.e(TAG, "close() of server failed", e);
            }
        }
    }

    private class ConnectThread extends Thread {
        private final BluetoothSocket mmSocket;
        private final BluetoothDevice mmDevice;

        public ConnectThread(BluetoothDevice device) {
            mmDevice = device;
            BluetoothSocket tmp = null;
            try {
                tmp = device.createRfcommSocketToServiceRecord(MY_UUID);
            }
            catch (IOException e) {
                Log.e(TAG, "create() failed", e);
            }
            mmSocket = tmp;
        }

        public void run() {
            Log.i(TAG, "BEGIN mConnectThread");
            setName("ConnectThread");
            mAdapter.cancelDiscovery();
            try {
                mmSocket.connect();
            }
            catch (IOException e) {
                connectionFailed();
                try {
                    mmSocket.close();
                }
                catch (IOException e2) {
                    Log.e(TAG, "unable to close() socket during connection failure", e2);
                }
            BluetoothService.this.start();
            return;
            }
            synchronized (BluetoothService.this) {
                mConnectThread = null;
            }
            connected(mmSocket, mmDevice);
        }

        public void cancel() {
            try {
                mmSocket.close();
            }
            catch (IOException e) {
                Log.e(TAG, "close() of connect socket failed", e);
            }
        }
    }

    private class ConnectedThread extends Thread {

        private final BluetoothSocket mmSocket;
        private final InputStream mmInStream;
        private final OutputStream mmOutStream;

        public ConnectedThread(BluetoothSocket socket) {
            Log.d(TAG, "create ConnectedThread");
            mmSocket = socket;
            InputStream tmpIn = null;
            OutputStream tmpOut = null;
            try {
                tmpIn = socket.getInputStream();
                tmpOut = socket.getOutputStream();
            }
            catch (IOException e) {
                Log.e(TAG, "tempt sockets not created", e);
            }
            mmInStream = tmpIn;
            mmOutStream = tmpOut;
        }

        public void run() {
            Log.i(TAG, "BEGIN mConnectedThread");
            byte[] buffer = new byte[1024];
            int bytes;
            while (true) {
                try {
                    bytes = mmInStream.read(buffer);
                    mHandler.obtainMessage(BluetoothTransfer.CONTACT_RECEIVE, bytes, -1, buffer).sendToTarget();
                }
                catch (IOException e) {
                    Log.e(TAG, "disconnected", e);
                    connectionLost();
                    break;
                }
            }
        }

        public void write(byte[] buffer) {
            try {
                mmOutStream.write(buffer);
                mHandler.obtainMessage(BluetoothTransfer.CONTACT_SEND, -1, -1, buffer).sendToTarget();
            }
            catch (IOException e) {
                Log.e(TAG, "exception during write", e);
            }
        }

        public void cancel() {
            try {
                mmSocket.close();
            }
            catch (IOException e) {
                Log.e(TAG, "close() of connect socket failed", e);
            }
        }
    }
}

导致NPE（AcceptThread）的行：

对象套接字应该初始化为@null，但应该尝试socket=mmServerSocket.accept（）

这直接来自Android开发者网站上提供的谷歌示例应用程序。我有两个顾虑：1，为什么这不起作用，2，为什么几个小时前它还可以工作

谢谢你的帮助。

关于“奇怪的NPE”-一点也不奇怪。你在这条线上得到NPE的原因是什么

socket = mmServerSocket.accept(); //THIS LINE CAUSES NPE

非常明显-变量mmServerSocket等于NULL，这是在这行代码中获取NPE的唯一可能原因。mmServerSocket等于NULL的原因也很简单-看看类的构造函数：

public AcceptThread() {
    BluetoothServerSocket tmp = null;
    try {
        tmp = mAdapter.listenUsingRfcommWithServiceRecord(NAME, MY_UUID);
    }
    catch (IOException e) {
        Log.e(TAG, "listen() failed", e);
    }
    mmServerSocket = tmp;
}

您正在调用方法

listenUsingRfcommWithServiceRecord

，该方法抛出IOException，您将捕获此异常，正如我们在logcat中清楚看到的那样。接下来，

tmp

变量保持初始化为NULL，与

mmServerSocket

相同，这将导致上述NPE

listenusingrfcommwithservicecerecord

的原因是引发IOException，因为蓝牙已关闭，正如您在问题中提到的。Android文档中没有提到您的假设，即如果蓝牙关闭，该方法将自动打开蓝牙。我认为在调用

listenUsingRfcommWithServiceRecord

之前，您应该手动检查蓝牙是否已关闭并手动打开

---

您可以找到如何检查蓝牙是否已打开/关闭，以及如何打开和

请注意，实际的异常似乎是

listen（）

上的

IOException

，尽管您的应用程序似乎应该处理该异常。蓝牙是否已关闭？是的，蓝牙已关闭，但应用程序应将其打开。昨晚，当我在同一部手机上运行它时，它提示我打开蓝牙，并且没有出现错误。我同意@Daniel。这个问题很可能是因为您有一个蓝牙服务问题。

accept（）

调用引发了一个

IOException

，从文档中可以看出，此类异常的原因是“错误”，例如蓝牙不可用或权限不足，有没有可能你的应用程序的另一个实例正在运行，或者有其他服务绑定到它？我不这么认为。我尝试重新启动手机，使用ATK关闭所有程序，等等。当我运行之前启动的蓝牙应用程序时，它运行正常。此外，当我在发生错误时强制关闭应用程序（此时蓝牙将已启动）也不会导致（至少是明显的）问题。当蓝牙处于关闭状态时，如果出现此问题，则会尝试启动蓝牙。应该有适当的权限。有什么想法吗？谢谢Austin编辑我的问题来展示我的想法。这个解释对我很有用。启用BTadapter后，问题（即NPE错误）得到解决。

public AcceptThread() {
    BluetoothServerSocket tmp = null;
    try {
        tmp = mAdapter.listenUsingRfcommWithServiceRecord(NAME, MY_UUID);
    }
    catch (IOException e) {
        Log.e(TAG, "listen() failed", e);
    }
    mmServerSocket = tmp;
}