Android 蓝牙应用程序致命错误

提前谢谢你的帮助。我正在构建一个应用程序，允许我使用蓝牙从一个设备向另一个设备发送消息。这是我的密码

import android.app.Activity;
import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothDevice;
import android.bluetooth.BluetoothServerSocket;
import android.bluetooth.BluetoothSocket;
import android.content.BroadcastReceiver;
import android.content.ClipData;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.os.AsyncTask;
import android.os.Bundle;
import android.os.Parcelable;
import android.util.Log;
import android.view.KeyEvent;
import android.view.View;
import android.widget.AdapterView;
import android.widget.ArrayAdapter;
import android.widget.Button;
import android.widget.EditText;
import android.widget.ListView;
import android.widget.TextView;
import android.os.Handler;

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

public class MainActivity extends Activity {
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        configureBluetooth();
        setupListView();
        setupSearchButton();
        setupListenButton();
    }

    private BluetoothAdapter bluetooth;
    private BluetoothSocket socket;
    private UUID uuid = UUID.fromString("a60f35f0-b93a-11de-8a39-08002009c666");
    private void configureBluetooth() {
        bluetooth = BluetoothAdapter.getDefaultAdapter();
    }

    private Handler handler = new Handler();
    private void switchUI() {
        final TextView messageText = (TextView)findViewById(R.id.messageview);
        final EditText textEntry = (EditText)findViewById(R.id.messagetext);
        messageText.setVisibility(View.VISIBLE);
        list.setVisibility(View.GONE);
        textEntry.setEnabled(true);
        textEntry.setOnKeyListener(new View.OnKeyListener() {
            public boolean onKey(View view, int keyCode, KeyEvent keyEvent) {
                if ((keyEvent.getAction() == KeyEvent.ACTION_DOWN) &&
                        (keyCode == KeyEvent.KEYCODE_DPAD_CENTER)) {
                    sendMessage(socket, textEntry.getText().toString());
                    textEntry.setText("");
                    return true;
                }
                return false;
            }
        });

        BluetoothSocketListener bsl = new BluetoothSocketListener(socket,
                handler, messageText);
        Thread messageListener = new Thread(bsl);
        messageListener.start();

    }

    private void sendMessage(BluetoothSocket socket, String msg) {
        OutputStream outStream;
        try {
            outStream = socket.getOutputStream();
            byte[] stringAsBytes = (msg + " ").getBytes();
            stringAsBytes[stringAsBytes.length - 1] = 0;
            outStream.write(stringAsBytes);
        } catch (IOException e) {
            Log.d("BLUETOOTH_COMMS", e.getMessage());
        }
    }

    private static int DISCOVERY_REQUEST = 1;

    private void setupListenButton() {
        Button listenButton = (Button) findViewById(R.id.listen_button);
        listenButton.setOnClickListener(new View.OnClickListener() {
            public void onClick(View view) {
                Intent disc;
                disc = new Intent(BluetoothAdapter.ACTION_REQUEST_DISCOVERABLE);
                startActivityForResult(disc, DISCOVERY_REQUEST);
            }
        });
    }

    @Override
    protected void onActivityResult(int requestCode, int resultCode, Intent
            data) {
        if (requestCode == DISCOVERY_REQUEST) {
            boolean isDiscoverable = resultCode > 0;
            if (isDiscoverable) {
                String name = "bluetoothserver";
                try {
                    final BluetoothServerSocket btserver =
                            bluetooth.listenUsingRfcommWithServiceRecord(name, uuid);
                    AsyncTask<Integer, Void, BluetoothSocket> acceptThread =
                            new AsyncTask<Integer, Void, BluetoothSocket>() {
                                @Override
                                protected BluetoothSocket doInBackground(Integer... params) {

                                    try {
                                        socket = btserver.accept(params[0] * 1000);
                                        return socket;
                                    } catch (IOException e) {
                                        Log.d("BLUETOOTH", e.getMessage());
                                    }

                                    return null;
                                }

                                @Override
                                protected void onPostExecute(BluetoothSocket result) {
                                    if (result != null)
                                        switchUI();
                                }
                            };
                    acceptThread.execute(resultCode);
                } catch (IOException e) {
                    Log.d("BLUETOOTH", e.getMessage());
                }
            }
        }
    }

    private ArrayList<BluetoothDevice> foundDevices;
    private ArrayAdapter<BluetoothDevice> aa;
    private ListView list;

    BroadcastReceiver discoveryResult = new BroadcastReceiver() {
        @Override
        public void onReceive(Context context, Intent intent) {
            BluetoothDevice remoteDevice;
            remoteDevice = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
            if (bluetooth.getBondedDevices().contains(remoteDevice)) {
                foundDevices.add(remoteDevice);
                aa.notifyDataSetChanged();
            }
        }
    };

    private void setupListView() {
        aa = new ArrayAdapter<BluetoothDevice>(this, android.R.layout.simple_list_item_1, foundDevices);
        list = (ListView) findViewById(R.id.list_discovered);
        list.setAdapter(aa);
        list.setOnItemClickListener(new AdapterView.OnItemClickListener() {
            public void onItemClick(AdapterView<?> arg0, View view,
                                    int index, long arg3) {
                AsyncTask<Integer, Void, Void> connectTask =
                        new AsyncTask<Integer, Void, Void>() {
                            @Override
                            protected Void doInBackground(Integer... params) {
                                try {
                                    BluetoothDevice device = foundDevices.get(params[0]);
                                    socket = device.createRfcommSocketToServiceRecord(uuid);
                                    socket.connect();
                                } catch (IOException e) {
                                    Log.d("BLUETOOTH_CLIENT", e.getMessage());
                                }
                                return null;
                            }

                            @Override
                            protected void onPostExecute(Void result) {

                                switchUI();
                            }
                        };
                connectTask.execute(index);
            }
        });
    }

    private void setupSearchButton() {
        Button searchButton = (Button) findViewById(R.id.search_button);
        searchButton.setOnClickListener(new View.OnClickListener() {
            public void onClick(View view) {
                registerReceiver(discoveryResult, new IntentFilter(BluetoothDevice.ACTION_FOUND));
                if (!bluetooth.isDiscovering()) {
                    foundDevices.clear();
                    bluetooth.startDiscovery();
                }
            }
        });
    }

    private class MessagePoster implements Runnable {
        private TextView textView;
        private String message;
        public MessagePoster(TextView textView, String message) {
            this.textView = textView;
            this.message = message;
        }
        public void run() {
            textView.setText(message);
        }
    }

    private class BluetoothSocketListener implements Runnable {
        private BluetoothSocket socket;
        private TextView textView;
        private Handler handler;
        public BluetoothSocketListener(BluetoothSocket socket,
                                       Handler handler, TextView textView) {
            this.socket = socket;
            this.textView = textView;
            this.handler = handler;
        }

        public void run() {
            int bufferSize = 1024;
            byte[] buffer = new byte[bufferSize];
            try {
                InputStream instream = socket.getInputStream();
                int bytesRead = - 1;
                String message = "";
                while (true) {
                    message = "";
                    bytesRead = instream.read(buffer);
                    if (bytesRead != -1) {
                        while ((bytesRead==bufferSize)&&(buffer[bufferSize-1] != 0)) {
                            message = message + new String(buffer, 0, bytesRead);
                            bytesRead = instream.read(buffer);
                        }
                        message = message + new String(buffer, 0, bytesRead - 1);
                        handler.post(new MessagePoster(textView, message));
                        socket.getInputStream();
                    }
                }
            } catch (IOException e) {
                Log.d("BLUETOOTH_COMMS", e.getMessage());
            }
        }
    }
}

导入android.app.Activity；
导入android.bluetooth.BluetoothAdapter；
导入android.bluetooth.bluetooth设备；
导入android.bluetooth.BluetoothServerSocket；
导入android.bluetooth.BluetoothSocket；
导入android.content.BroadcastReceiver；
导入android.content.ClipData；
导入android.content.Context；
导入android.content.Intent；
导入android.content.IntentFilter；
导入android.os.AsyncTask；
导入android.os.Bundle；
导入android.os.Parcelable；
导入android.util.Log；
导入android.view.KeyEvent；
导入android.view.view；
导入android.widget.AdapterView；
导入android.widget.ArrayAdapter；
导入android.widget.Button；
导入android.widget.EditText；
导入android.widget.ListView；
导入android.widget.TextView；
导入android.os.Handler；
导入java.io.IOException；
导入java.io.InputStream；
导入java.io.OutputStream；
导入java.util.ArrayList；
导入java.util.UUID；
公共类MainActivity扩展了活动{
@凌驾
创建时的公共void（Bundle savedInstanceState）{
super.onCreate（savedInstanceState）；
setContentView（R.layout.activity_main）；
配置蓝牙（）；
setupListView（）；
setupSearchButton（）；
setupListenButton（）；
}
私人蓝牙适配器；
私人蓝牙插座；
专用UUID UUID=UUID.fromString（“a60f35f0-b93a-11de-8a39-08002009c666”）；
私有void配置Bluetooth（）{
bluetooth=BluetoothAdapter.getDefaultAdapter（）；
}
私有处理程序=新处理程序（）；
私有void switchUI（）{
final TextView messageText=（TextView）findViewById（R.id.messageview）；
final EditText textEntry=（EditText）findViewById（R.id.messagetext）；
messageText.setVisibility（View.VISIBLE）；
list.setVisibility（View.GONE）；
textEntry.setEnabled（true）；
textEntry.setOnKeyListener（新视图.OnKeyListener（）{
公共布尔onKey（视图、int-keyCode、KeyEvent-KeyEvent）{
if（（keyEvent.getAction（）==keyEvent.ACTION\u向下）&&
（keyCode==KeyEvent.keyCode\u DPAD\u CENTER））{
sendMessage（套接字，textEntry.getText（）.toString（））；
textEntry.setText（“”）；
返回true；
}
返回false；
}
});
BluetoothSocketListener bsl=新的BluetoothSocketListener（套接字，
处理程序，messageText）；
Thread messageListener=新线程（bsl）；
messageListener.start（）；
}
私有void发送消息（BluetoothSocket套接字，字符串消息）{
输出流外流；
试一试{
outStream=socket.getOutputStream（）；
字节[]字符串字节=（消息+“”）。getBytes（）；
stringAsBytes[stringAsBytes.length-1]=0；
扩展流。写入（stringAsBytes）；
}捕获（IOE异常）{
Log.d（“蓝牙通信”，例如getMessage（））；
}
}
私有静态int发现_请求=1；
私有void setupListenButton（）{
按钮listenButton=（按钮）findViewById（R.id.listen_按钮）；
setOnClickListener（新视图.OnClickListener（）{
公共void onClick（视图）{
意向盘；
disc=新意图（BluetoothAdapter.ACTION\u REQUEST\u DISCOVERABLE）；
startActivityForResult（光盘、发现请求）；
}
});
}
@凌驾
ActivityResult上受保护的void（int requestCode、int resultCode、Intent
（数据）{
if（requestCode==发现请求）{
布尔isDiscoverable=resultCode>0；
如果（isDiscoverable）{
String name=“bluetoothserver”；
试一试{
最终BluetoothServerSocket btserver=
bluetooth.listenUsingRfcommWithServiceRecord（名称、uuid）；
异步任务接受线程=
新建异步任务（）{
@凌驾
受保护的BluetoothSocket doInBackground（整数…参数）{
试一试{
socket=btserver.accept（参数[0]*1000）；
返回插座；
}捕获（IOE异常）{
Log.d（“蓝牙”，例如getMessage（））；
}
返回null；
}
@凌驾
受保护的void onPostExecute（BluetoothSocket结果）{
如果（结果！=null）
switchUI（）；
}
};
acceptThread.execute（resultCode）；
}捕获（IOE异常）{
Log.d（“蓝牙”，例如getMessage（））；
}
}
}
}
专用ArrayList设备；
私人阵列适配器aa；
私有列表视图列表；
BroadcastReceiver discoveryResult=新的BroadcastReceiver（）{
@凌驾
公共void onReceive（上下文、意图）{
蓝牙设备；
remoteDevice=intent.getParcelableExtra（BluetoothDevice.EXTRA\u设备）；
如果（bluetooth.getBondedDevices（）包含（remoteDevice））{
foundDevices.add（远程设备）；
aa.notifyDataSetChanged（）；
}
}
};
私有void setupListView（）{
aa=新的ArrayAdapter（这是android.R.layout.simple\u list\u item\u 1，foundDevices）；
名单=
BroadcastReceiver discoveryResult = new BroadcastReceiver() {
        @Override
        public void onReceive(Context context, Intent intent) {
            BluetoothDevice remoteDevice;
            remoteDevice = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
            if (bluetooth.getBondedDevices().contains(remoteDevice)) {
                foundDevices.add(remoteDevice);
                aa.notifyDataSetChanged();
            }
        }
    };

    private void setupListView() {
        aa = new ArrayAdapter<BluetoothDevice>(this, android.R.layout.simple_list_item_1, foundDevices);

  ArrayList<MyClass> mObjList;

  public void writeToParcel(Parcel out, int flags) {
      out.writeTypedList(mObjList);
  }

  protected MyClass(Parcel in) {
      mObjList = new ArrayList<>(); //non-null reference is required
      in.readTypedList(mObjList, MyClass.CREATOR);
  }