android 蓝牙通讯

1.client:

package com.wistron.cschat;import java.io.IOException;import java.io.InputStream;import java.io.OutputStream;import java.lang.reflect.InvocationTargetException;import java.lang.reflect.Method;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.Handler;import android.util.Log;public class BluetoothChatClient {    // Debugging    private static final String TAG = "BluetoothChatService";    private static final boolean D = true;    private static final String NAME_SECURE = "BluetoothChatSecure";    private static final String NAME_INSECURE = "BluetoothChatInsecure";    // Unique UUID for this application    private static final UUID MY_UUID_SECURE =        UUID.fromString("fa87c0d0-afac-11de-8a39-0800200c9a66");    private static final UUID MY_UUID_INSECURE =UUID.fromString("8ce255c0-200a-11e0-ac64-0800200c9a66");    // Member fields    private final BluetoothAdapter mAdapter;    private AcceptThread mSecureAcceptThread;    private AcceptThread mInsecureAcceptThread;    private ConnectThread mConnectThread;    private ConnectedThread mConnectedThread;    private int mState;    // Constants that indicate the current connection state    public static final int STATE_NONE = 0;       // we're doing nothing    public static final int STATE_LISTEN = 1;     // now listening for incoming connections    public static final int STATE_CONNECTING = 2; // now initiating an outgoing connection    public static final int STATE_CONNECTED = 3;  // now connected to a remote device        public Handler mHandler;    /**     * Constructor. Prepares a new BluetoothChat session.     * @param context  The UI Activity Context     * @param handler  A Handler to send messages back to the UI Activity     */    public BluetoothChatClient(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;        // Give the new state to the Handler so the UI Activity can update    }    /**     * Return the current connection state. */    public synchronized int getState() {        return mState;    }    public synchronized void start() {        if (D) Log.d(TAG, "start");        // Cancel any thread attempting to make a connection        if (mConnectThread != null) {mConnectThread.cancel(); mConnectThread = null;}        // Cancel any thread currently running a connection        if (mConnectedThread != null) {mConnectedThread.cancel(); mConnectedThread = null;}        setState(STATE_LISTEN);        // Start the thread to listen on a BluetoothServerSocket        if (mInsecureAcceptThread == null) {            mInsecureAcceptThread = new AcceptThread(false);            mInsecureAcceptThread.start();        }    }    public synchronized void connect(BluetoothDevice device, boolean secure) {        if (D) Log.d(TAG, "connect to: " + device);        // Cancel any thread attempting to make a connection        if (mState == STATE_CONNECTING) {            if (mConnectThread != null) {mConnectThread.cancel(); mConnectThread = null;}        }        // Cancel any thread currently running a connection        if (mConnectedThread != null) {mConnectedThread.cancel(); mConnectedThread = null;}        // Start the thread to connect with the given device        mConnectThread = new ConnectThread(device, secure);        mConnectThread.start();                mHandler.obtainMessage(ActivityFragment.MSG_CLIENT_START_CONNECT_THREAD).sendToTarget();        setState(STATE_CONNECTING);    }    public synchronized void connected(BluetoothSocket socket, BluetoothDevice            device, final String socketType) {        if (D) Log.d(TAG, "connected, Socket Type:" + socketType);        // Cancel the thread that completed the connection        if (mConnectThread != null) {mConnectThread.cancel(); mConnectThread = null;}        // Cancel any thread currently running a connection        if (mConnectedThread != null) {mConnectedThread.cancel(); mConnectedThread = null;}        // Cancel the accept thread because we only want to connect to one device        if (mSecureAcceptThread != null) {            mSecureAcceptThread.cancel();            mSecureAcceptThread = null;        }        if (mInsecureAcceptThread != null) {            mInsecureAcceptThread.cancel();            mInsecureAcceptThread = null;        }        // Start the thread to manage the connection and perform transmissions        mConnectedThread = new ConnectedThread(socket, socketType);        mConnectedThread.start();        mHandler.obtainMessage(ActivityFragment.MSG_CLIENT_CONNECT_SUCCESS).sendToTarget();        // Send the name of the connected device back to the UI Activity        setState(STATE_CONNECTED);    }    /**     * Stop all threads     */    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 (mSecureAcceptThread != null) {            mSecureAcceptThread.cancel();            mSecureAcceptThread = null;        }        if (mInsecureAcceptThread != null) {            mInsecureAcceptThread.cancel();            mInsecureAcceptThread = null;        }        setState(STATE_NONE);    }    public void write(byte[] out) {        // Create temporary object        ConnectedThread r;        // Synchronize a copy of the ConnectedThread        synchronized (this) {            if (mState != STATE_CONNECTED) return;            r = mConnectedThread;        }        // Perform the write unsynchronized        r.write(out);    }    private class AcceptThread extends Thread {        // The local server socket        private final BluetoothServerSocket mmServerSocket;        private String mSocketType;        public AcceptThread(boolean secure) {            BluetoothServerSocket tmp = null;            mSocketType = secure ? "Secure":"Insecure";            // Create a new listening server socket            try {                if (secure) {                    tmp = mAdapter.listenUsingRfcommWithServiceRecord(NAME_SECURE,                        MY_UUID_SECURE);                } else {                    tmp = mAdapter.listenUsingInsecureRfcommWithServiceRecord(                            NAME_INSECURE, MY_UUID_INSECURE);                }            } catch (IOException e) {                Log.e(TAG, "Socket Type: " + mSocketType + "listen() failed", e);            }            mmServerSocket = tmp;        }        public void run() {            if (D) Log.d(TAG, "Socket Type: " + mSocketType +                    "BEGIN mAcceptThread" + this);            setName("AcceptThread" + mSocketType);            BluetoothSocket socket = null;            // Listen to the server socket if we're not connected            while (mState != STATE_CONNECTED) {                try {                    // This is a blocking call and will only return on a                    // successful connection or an exception                    socket = mmServerSocket.accept();                } catch (IOException e) {                    Log.e(TAG, "Socket Type: " + mSocketType + "accept() failed", e);                    break;                }                // If a connection was accepted                if (socket != null) {                    synchronized (BluetoothChatClient.this) {                        switch (mState) {                        case STATE_LISTEN:                        case STATE_CONNECTING:                            // Situation normal. Start the connected thread.                            connected(socket, socket.getRemoteDevice(),                                    mSocketType);                            break;                        case STATE_NONE:                        case STATE_CONNECTED:                            // Either not ready or already connected. Terminate new socket.                            try {                                socket.close();                            } catch (IOException e) {                                Log.e(TAG, "Could not close unwanted socket", e);                            }                            break;                        }                    }                }            }            if (D) Log.i(TAG, "END mAcceptThread, socket Type: " + mSocketType);        }        public void cancel() {            if (D) Log.d(TAG, "Socket Type" + mSocketType + "cancel " + this);            try {                mmServerSocket.close();            } catch (IOException e) {                Log.e(TAG, "Socket Type" + mSocketType + "close() of server failed", e);            }        }    }    private class ConnectThread extends Thread {        private final BluetoothSocket mmSocket;        private final BluetoothDevice mmDevice;        private String mSocketType;        public ConnectThread(BluetoothDevice device, boolean secure) {            mmDevice = device;            BluetoothSocket tmp = null;            mSocketType = secure ? "Secure" : "Insecure";            // Get a BluetoothSocket for a connection with the            // given BluetoothDevice//            try {//                if (secure) {//                    tmp = device.createRfcommSocketToServiceRecord(//                            MY_UUID_SECURE);//                } else {//                    tmp = device.createInsecureRfcommSocketToServiceRecord(//                            MY_UUID_INSECURE);//                }//            } catch (IOException e) {//                Log.e(TAG, "Socket Type: " + mSocketType + "create() failed", e);//            }                        try {            // secureMethod method = device.getClass().getMethod("createRfcommSocket", new Class[]{int.class});            tmp = (BluetoothSocket)method.invoke(device, Integer.valueOf(29));} catch (NoSuchMethodException e) {// TODO Auto-generated catch blocke.printStackTrace();} catch (IllegalArgumentException e) {// TODO Auto-generated catch blocke.printStackTrace();} catch (IllegalAccessException e) {// TODO Auto-generated catch blocke.printStackTrace();} catch (InvocationTargetException e) {// TODO Auto-generated catch blocke.printStackTrace();}                        mmSocket = tmp;        }        public void run() {            Log.i(TAG, "BEGIN mConnectThread SocketType:" + mSocketType);            setName("ConnectThread" + mSocketType);            // Always cancel discovery because it will slow down a connection            mAdapter.cancelDiscovery();            // Make a connection to the BluetoothSocket            try {                // This is a blocking call and will only return on a                // successful connection or an exception                mmSocket.connect();            } catch (IOException e) {                // Close the socket            e.printStackTrace();                try {                    mmSocket.close();                } catch (IOException e2) {                    Log.e(TAG, "unable to close() " + mSocketType +                            " socket during connection failure", e2);                }                mHandler.obtainMessage(ActivityFragment.MSG_CLIENT_CONNECT_FAIL,String.valueOf(e)).sendToTarget();                return;            }            // Reset the ConnectThread because we're done            synchronized (BluetoothChatClient.this) {                mConnectThread = null;            }            // Start the connected thread            connected(mmSocket, mmDevice, mSocketType);        }        public void cancel() {            try {                mmSocket.close();            } catch (IOException e) {                Log.e(TAG, "close() of connect " + mSocketType + " socket failed", e);            }        }    }    private class ConnectedThread extends Thread {        private final BluetoothSocket mmSocket;        private final InputStream mmInStream;        private final OutputStream mmOutStream;        public ConnectedThread(BluetoothSocket socket, String socketType) {            Log.d(TAG, "create ConnectedThread: " + socketType);            mmSocket = socket;            InputStream tmpIn = null;            OutputStream tmpOut = null;            // Get the BluetoothSocket input and output streams            try {                tmpIn = socket.getInputStream();                tmpOut = socket.getOutputStream();            } catch (IOException e) {                Log.e(TAG, "temp sockets not created", e);            }            mmInStream = tmpIn;            mmOutStream = tmpOut;        }        public void run() {            Log.i(TAG, "BEGIN mConnectedThread");            byte[] buffer = new byte[1024];            int bytes;            // Keep listening to the InputStream while connected            while (true) {                try {                    // Read from the InputStream                    bytes = mmInStream.read(buffer);                                                            // Send the obtained bytes to the UI Activity                    mHandler.obtainMessage(ActivityFragment.MSG_CLIENT_READ_INFO, bytes, -1, buffer).sendToTarget();                } catch (IOException e) {                    Log.e(TAG, "disconnected", e);//                    connectionLost();                    // Start the service over to restart listening mode//                    BluetoothChatService.this.start();                    break;                }            }        }        public void write(byte[] buffer) {            try {                mmOutStream.write(buffer);                // Share the sent message back to the UI Activity//                mHandler.obtainMessage(BluetoothChat.MESSAGE_WRITE, -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);            }        }    }}

2.Server:

package com.wistron.cschat;import java.io.IOException;import java.io.InputStream;import java.io.OutputStream;import java.lang.reflect.InvocationTargetException;import java.lang.reflect.Method;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.Handler;import android.util.Log;public class BluetoothChatServer {    // Debugging    private static final String TAG = "BluetoothChatService";    private static final boolean D = true;    // Name for the SDP record when creating server socket    private static final String NAME_SECURE = "BluetoothChatSecure";    private static final String NAME_INSECURE = "BluetoothChatInsecure";    // Unique UUID for this application    private static final UUID MY_UUID_SECURE =        UUID.fromString("fa87c0d0-afac-11de-8a39-0800200c9a66");    private static final UUID MY_UUID_INSECURE =UUID.fromString("8ce255c0-200a-11e0-ac64-0800200c9a66");    // Member fields    private final BluetoothAdapter mAdapter;//    private final Handler mHandler;    private AcceptThread mSecureAcceptThread;    private AcceptThread mInsecureAcceptThread;    private ConnectThread mConnectThread;    private ConnectedThread mConnectedThread;    private int mState;    // Constants that indicate the current connection state    public static final int STATE_NONE = 0;       // we're doing nothing    public static final int STATE_LISTEN = 1;     // now listening for incoming connections    public static final int STATE_CONNECTING = 2; // now initiating an outgoing connection    public static final int STATE_CONNECTED = 3;  // now connected to a remote device        public Context mContext;    public Handler mHandler;    public BluetoothChatServer(Context context, Handler handler) {        mAdapter = BluetoothAdapter.getDefaultAdapter();        mState = STATE_NONE;        mHandler = handler;        mContext = context;    }        private synchronized void setState(int state) {        if (D) Log.d(TAG, "setState() " + mState + " -> " + state);        mState = state;        // Give the new state to the Handler so the UI Activity can update//        mHandler.obtainMessage(mContext.MESSAGE_STATE_CHANGE, state, -1).sendToTarget();    }    /**     * Return the current connection state. */    public synchronized int getState() {        return mState;    }    public synchronized void start() {        if (D) Log.d(TAG, "start");        // Cancel any thread attempting to make a connection        if (mConnectThread != null) {mConnectThread.cancel(); mConnectThread = null;}        // Cancel any thread currently running a connection        if (mConnectedThread != null) {mConnectedThread.cancel(); mConnectedThread = null;}        setState(STATE_LISTEN);        // Start the thread to listen on a BluetoothServerSocket        if (mSecureAcceptThread == null) {            mSecureAcceptThread = new AcceptThread(false);            mSecureAcceptThread.start();//            mHandler.obtainMessage(ActivityFragment.MSG_SERVER_OTHER_MESSAGE, "Start Accept").sendToTarget();        }           }    public synchronized void connect(BluetoothDevice device, boolean secure) {        if (D) Log.d(TAG, "connect to: " + device);        // Cancel any thread attempting to make a connection        if (mState == STATE_CONNECTING) {            if (mConnectThread != null) {mConnectThread.cancel(); mConnectThread = null;}        }        // Cancel any thread currently running a connection        if (mConnectedThread != null) {mConnectedThread.cancel(); mConnectedThread = null;}        // Start the thread to connect with the given device        mConnectThread = new ConnectThread(device, secure);        mConnectThread.start();        setState(STATE_CONNECTING);    }    public synchronized void connected(BluetoothSocket socket, BluetoothDevice            device, final String socketType) {        if (D) Log.d(TAG, "connected, Socket Type:" + socketType);        // Cancel the thread that completed the connection        if (mConnectThread != null) {mConnectThread.cancel(); mConnectThread = null;}        // Cancel any thread currently running a connection        if (mConnectedThread != null) {mConnectedThread.cancel(); mConnectedThread = null;}        // Cancel the accept thread because we only want to connect to one device        if (mSecureAcceptThread != null) {            mSecureAcceptThread.cancel();            mSecureAcceptThread = null;        }        if (mInsecureAcceptThread != null) {            mInsecureAcceptThread.cancel();            mInsecureAcceptThread = null;        }        // Start the thread to manage the connection and perform transmissions        mConnectedThread = new ConnectedThread(socket, socketType);        mConnectedThread.start();        mHandler.obtainMessage(ActivityFragment.MSG_SERVER_CONNECT_SUCCESS).sendToTarget();        setState(STATE_CONNECTED);    }    /**     * Stop all threads     */    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 (mSecureAcceptThread != null) {            mSecureAcceptThread.cancel();            mSecureAcceptThread = null;        }        if (mInsecureAcceptThread != null) {            mInsecureAcceptThread.cancel();            mInsecureAcceptThread = null;        }        setState(STATE_NONE);    }    public void write(byte[] out) {        // Create temporary object        ConnectedThread r;        // Synchronize a copy of the ConnectedThread        synchronized (this) {            if (mState != STATE_CONNECTED) return;            r = mConnectedThread;        }        // Perform the write unsynchronized        r.write(out);    }    private void connectionFailed() {        // Send a failure message back to the Activity//        Message msg = mHandler.obtainMessage(BluetoothChat.MESSAGE_TOAST);//        Bundle bundle = new Bundle();//        bundle.putString(BluetoothChat.TOAST, "Unable to connect device");//        msg.setData(bundle);//        mHandler.sendMessage(msg);        // Start the service over to restart listening mode        BluetoothChatServer.this.start();    }    /**     * Indicate that the connection was lost and notify the UI Activity.     */    private void connectionLost() {        // Send a failure message back to the Activity//        Message msg = mHandler.obtainMessage(BluetoothChat.MESSAGE_TOAST);//        Bundle bundle = new Bundle();//        bundle.putString(BluetoothChat.TOAST, "Device connection was lost");//        msg.setData(bundle);//        mHandler.sendMessage(msg);        // Start the service over to restart listening mode        BluetoothChatServer.this.start();    }    private class AcceptThread extends Thread {        // The local server socket        private final BluetoothServerSocket mmServerSocket;        private String mSocketType;        public AcceptThread(boolean secure) {            BluetoothServerSocket tmp = null;            mSocketType = secure ? "Secure":"Insecure";            // Create a new listening server socket//            try {//                if (secure) {//                    tmp = mAdapter.listenUsingRfcommWithServiceRecord(NAME_SECURE,//                        MY_UUID_SECURE);//                } else {//                    tmp = mAdapter.listenUsingInsecureRfcommWithServiceRecord(//                            NAME_INSECURE, MY_UUID_INSECURE);//                }//            } catch (IOException e) {//                Log.e(TAG, "Socket Type: " + mSocketType + "listen() failed", e);//                String msg = "Socket Type: " + mSocketType + "listen() failed";//                mHandler.obtainMessage(BTServer.MSG_EXCEPTION, msg).sendToTarget();//            }                        try {            // secureMethod method = mAdapter.getClass().getMethod("listenUsingRfcommOn", new Class[]{int.class});tmp = (BluetoothServerSocket)method.invoke(mAdapter,new Object[]{29});} catch (NoSuchMethodException e) {// TODO Auto-generated catch blocke.printStackTrace();mHandler.obtainMessage(ActivityFragment.MSG_SERVER_OTHER_MESSAGE, String.valueOf(e)).sendToTarget();} catch (IllegalArgumentException e) {// TODO Auto-generated catch blocke.printStackTrace();mHandler.obtainMessage(ActivityFragment.MSG_SERVER_OTHER_MESSAGE, String.valueOf(e)).sendToTarget();} catch (IllegalAccessException e) {// TODO Auto-generated catch blocke.printStackTrace();mHandler.obtainMessage(ActivityFragment.MSG_SERVER_OTHER_MESSAGE, String.valueOf(e)).sendToTarget();} catch (InvocationTargetException e) {// TODO Auto-generated catch blocke.printStackTrace();mHandler.obtainMessage(ActivityFragment.MSG_SERVER_OTHER_MESSAGE, String.valueOf(e)).sendToTarget();}                        mmServerSocket = tmp;        }        public void run() {            if (D) Log.d(TAG, "Socket Type: " + mSocketType +                    "BEGIN mAcceptThread" + this);            setName("AcceptThread" + mSocketType);            BluetoothSocket socket = null;            // Listen to the server socket if we're not connected            while (mState != STATE_CONNECTED) {                try {                    // This is a blocking call and will only return on a                    // successful connection or an exception                    socket = mmServerSocket.accept();                } catch (IOException e) {                    Log.e(TAG, "Socket Type: " + mSocketType + "accept() failed", e);                    String msg = "Socket Type: " + mSocketType + "accept() failed";//                    mHandler.obtainMessage(ActivityFragment.MSG_EXCEPTION, msg).sendToTarget();                    break;                }                // If a connection was accepted                if (socket != null) {                    synchronized (BluetoothChatServer.this) {                        switch (mState) {                        case STATE_LISTEN:                        case STATE_CONNECTING:                            // Situation normal. Start the connected thread.                            connected(socket, socket.getRemoteDevice(),                                    mSocketType);                            break;                        case STATE_NONE:                        case STATE_CONNECTED:                            // Either not ready or already connected. Terminate new socket.                            try {                                socket.close();                            } catch (IOException e) {                                Log.e(TAG, "Could not close unwanted socket", e);                            }                            break;                        }                    }                }            }            if (D) Log.i(TAG, "END mAcceptThread, socket Type: " + mSocketType);        }        public void cancel() {            if (D) Log.d(TAG, "Socket Type" + mSocketType + "cancel " + this);            try {                mmServerSocket.close();//                mHandler.obtainMessage(ActivityFragment.MSG_SERVER_OTHER_MESSAGE, "Stop Accept").sendToTarget();            } catch (IOException e) {                Log.e(TAG, "Socket Type" + mSocketType + "close() of server failed", e);                mHandler.obtainMessage(ActivityFragment.MSG_SERVER_EXCEPTION, String.valueOf(e)).sendToTarget();            }        }    }    private class ConnectThread extends Thread {        private final BluetoothSocket mmSocket;        private final BluetoothDevice mmDevice;        private String mSocketType;        public ConnectThread(BluetoothDevice device, boolean secure) {            mmDevice = device;            BluetoothSocket tmp = null;            mSocketType = secure ? "Secure" : "Insecure";            // Get a BluetoothSocket for a connection with the            // given BluetoothDevice            try {                if (secure) {                    tmp = device.createRfcommSocketToServiceRecord(                            MY_UUID_SECURE);                } else {                    tmp = device.createInsecureRfcommSocketToServiceRecord(                            MY_UUID_INSECURE);                }            } catch (IOException e) {                Log.e(TAG, "Socket Type: " + mSocketType + "create() failed", e);            }            mmSocket = tmp;        }        public void run() {            Log.i(TAG, "BEGIN mConnectThread SocketType:" + mSocketType);            setName("ConnectThread" + mSocketType);            // Always cancel discovery because it will slow down a connection            mAdapter.cancelDiscovery();            // Make a connection to the BluetoothSocket            try {                // This is a blocking call and will only return on a                // successful connection or an exception                mmSocket.connect();            } catch (IOException e) {                // Close the socket                try {                    mmSocket.close();                } catch (IOException e2) {                    Log.e(TAG, "unable to close() " + mSocketType +                            " socket during connection failure", e2);                }                connectionFailed();                return;            }            // Reset the ConnectThread because we're done            synchronized (BluetoothChatServer.this) {                mConnectThread = null;            }            // Start the connected thread            connected(mmSocket, mmDevice, mSocketType);        }        public void cancel() {            try {                mmSocket.close();            } catch (IOException e) {                Log.e(TAG, "close() of connect " + mSocketType + " socket failed", e);            }        }    }    private class ConnectedThread extends Thread {        private final BluetoothSocket mmSocket;        private final InputStream mmInStream;        private final OutputStream mmOutStream;        public ConnectedThread(BluetoothSocket socket, String socketType) {            Log.d(TAG, "create ConnectedThread: " + socketType);            mmSocket = socket;            InputStream tmpIn = null;            OutputStream tmpOut = null;            // Get the BluetoothSocket input and output streams            try {                tmpIn = socket.getInputStream();                tmpOut = socket.getOutputStream();            } catch (IOException e) {                Log.e(TAG, "temp sockets not created", e);            }            mmInStream = tmpIn;            mmOutStream = tmpOut;        }        public void run() {            Log.i(TAG, "BEGIN mConnectedThread");            byte[] buffer = new byte[1024];            int bytes;            // Keep listening to the InputStream while connected            while (true) {                try {                    // Read from the InputStream                    bytes = mmInStream.read(buffer);                    // Send the obtained bytes to the UI Activity                    mHandler.obtainMessage(ActivityFragment.MSG_SERVER_READ_INFO, bytes, -1, buffer).sendToTarget();                } catch (IOException e) {                    Log.e(TAG, "disconnected", e);                    connectionLost();                    // Start the service over to restart listening mode                    BluetoothChatServer.this.start();                    break;                }            }        }        public void write(byte[] buffer) {            try {                mmOutStream.write(buffer);                // Share the sent message back to the UI Activity//                mHandler.obtainMessage(BluetoothChat.MESSAGE_WRITE, -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);            }        }    }}

3.实例化对象。

BluetoothChatServer mBluetoothChatServer = new BluetoothChatServer(mContext, mHandler);BluetoothChatClient mBluetoothChatClient = new BluetoothChatClient(mContext, mClientHandler);

4.发送消息。

String msg = mInputMsgEditText.getText().toString().trim();mBluetoothChatServer.write(msg.getBytes());// clientmBluetoothChatClient.write(msg.getBytes());

5.接受消息：

public Handler mClientHandler = new Handler() {@Overridepublic void handleMessage(Message msg) {// TODO Auto-generated method stubsuper.handleMessage(msg);switch (msg.what) {case MSG_CLIENT_READ_INFO:byte[] readBuf = (byte[]) msg.obj;String readMessage = new String(readBuf, 0, msg.arg1);                Toast.makeText(mContext, readMessage, Toast.LENGTH_SHORT).show();break;default:break;}}};

更多相关文章

随机推荐