android.bluetooth.BluetoothSocket Java Examples

public ConnectedThread(BluetoothSocket socket) {
    Log.d(TAG, "create ConnectedThread");
    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;
}
 

/**
 * Start the CommunicationThread to begin managing a Bluetooth connection
 *
 * @param socket The BluetoothSocket on which the connection was made
 * @param device The BluetoothDevice that has been connected
 */
private synchronized void connected(BluetoothSocket socket, BluetoothDevice device, final String socketType) {
    if (_debug) Log.d(TAG, "connected: ");

    cancelConnectThread();
    cancelCommunicationThread(_communicationThread);

    _communicationThread = createCommunicationThread(socket, device);

    // Send the name of the connected device back to the UI Activity
    Bundle bundle = new Bundle();
    bundle.putString(ServiceMessageKeys.DEVICE_NAME, device.getName());
    bundle.putString(ServiceMessageKeys.DEVICE_ADDRESS, device.getAddress());
    sendMessage(ServiceMessageType.MESSAGE_DEVICE_CONNECTED, bundle);

    setState(STATE_CONNECTED);
}
 

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

    changeStatus(CONNECTED, device);
    mDevice = device;

    // Cancel the thread that completed the connection
    if (mConnectingThread != null) {
        mConnectingThread.cancel();
        mConnectingThread = null;
    }

    // Cancel any thread currently running mContext connection
    if (mConnectedThread != null) {
        mConnectedThread.cancel();
        mConnectedThread = null;
    }

    // Start the thread to manage the connection and perform transmissions
    mConnectedThread = new ConnectedThread(socket, device);
    mConnectedThread.start();
}
 

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, "temp sockets not created", e);
    }

    mmInStream = tmpIn;
    mmOutStream = tmpOut;
}
 

public ConnectedThread(BluetoothSocket socket, Context context,Handler handler) {
    vibrator = (Vibrator) context.getSystemService(VIBRATOR_SERVICE);
    mSocket = socket;//被管理的Socket
    mHandler=handler;
    this.context=context;
    InputStream tmpIn = null;
    OutputStream tmpOut = null;
    //无论是客户端的Socket还是服务端的Socket，都有输入输出流
    try {
        tmpIn = socket.getInputStream();
        tmpOut = socket.getOutputStream();
    } catch (IOException e) {  }
    mInStream = tmpIn;
    mOutStream = tmpOut;
    // 获得远程设备的输出缓存字符流，相当于找了一个大的管道，可以通向远程设备，发数据的必经管道
    mBw = new BufferedWriter(new PrintWriter(mOutStream));

    //mHandler=new Handler(Looper.getMainLooper());
}
 

private synchronized void onDeviceConnected(BluetoothSocket socket, BluetoothDevice device) {
  cancelAllThreads();

  listenThread = new ListenThread(socket);
  listenThread.start();

  listenThread = new ListenThread(socket);
  listenThread.start();

  if (deviceCallbacks != null) {
    mainHandler.post(new Runnable() {
      @Override
      public void run() {
        deviceCallbacks.onConnected();
      }
    });
  }
  Log.e(TAG, "Device " + device.getName() + " [" + device.getAddress() + "] — connected");
  this.setState(STATE_CONNECTED);
}
 

public ConnectedThread(BluetoothSocket socket, Handler handler) {
    mmSocket = socket;
    mHandler = handler;
    InputStream tmpIn = null;
    OutputStream tmpOut = null;

    // Get the input and output streams, using temp objects because
    // member streams are final
    try {
        tmpIn = socket.getInputStream();
        tmpOut = socket.getOutputStream();
    } catch (IOException e) { }

    mmInStream = tmpIn;
    mmOutStream = tmpOut;
}
 

public ConnectedThread(BluetoothSocket socket) {
    mmSocket = socket;
    InputStream tmpIn = null;
    OutputStream tmpOut = null;

    // Get the input and output streams, using temp objects because
    // member streams are final
    try {
        tmpIn = socket.getInputStream();
        tmpOut = socket.getOutputStream();
    } catch (IOException e) {
        Log.e(Constants.TAG, "Temp sockets not created", e);
    }

    mmInStream = tmpIn;
    mmOutStream = tmpOut;
}
 

public ConnectedThread(BluetoothSocket socket) {
    Log.d(TAG, "create ConnectedThread");
    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 ConnectThread(BluetoothDevice device) {
    mmDevice = device;
    BluetoothSocket tmp = null;

    // Get a BluetoothSocket for a connection with the
    // given BluetoothDevice
    try {
        tmp = device.createRfcommSocketToServiceRecord(MY_UUID);
    } catch (IOException e) {
        Log.e(TAG, "create() failed", e);
    }
    mmSocket = tmp;
}
 

public ClientThread(BluetoothAdapter bluetoothAdapter, BluetoothDevice device,
                    Handler handler) {
    this.bluetoothAdapter = bluetoothAdapter;
    this.device = device;
    this.uiHandler = handler;
    BluetoothSocket tmp = null;
    try {
        tmp = device.createRfcommSocketToServiceRecord(UUID.fromString(Params.UUID));
    } catch (IOException e) {
        e.printStackTrace();
    }
    socket = tmp;
}
 

@Override
protected BluetoothSocket doInBackground(Void... params) 
{
	if(this._socket == null)
	{
		this._error = "Socket not created correctly.";
		return null;
	}
	
	try
	{
		_socket.connect();
		return _socket;
	}
	catch(IOException eConnect)
	{
		this._error = eConnect.getMessage();
		
		try
		{
			_socket.close();
		}
		catch(IOException eClose)
		{
			this._error += " " + eClose.getMessage();
			Log.e(LOG_TAG, "Failed to close socket. " + eClose.getMessage());
		}
		return null;
	}
}
 

public synchronized void BTconnected(BluetoothSocket socket, BluetoothDevice device, String autoconfigmodel) {
    //Log.i(BTAG, "Connected");
    // Cancel the thread that completed the connection
    if (mBTConnectThread != null) {mBTConnectThread.cancel(); mBTConnectThread = null;}
    // Cancel any thread currently running a connection
    if (mBTConnectedThread != null) {mBTConnectedThread.cancel(); mBTConnectedThread = null;}

    // Start the thread to manage the connection and perform transmissions
    mBTConnectedThread = new BTConnectedThread(socket, autoconfigmodel);
    mBTConnectedThread.start();

    setBTState(STATE_CONNECTED);
}
 

@Override
protected void onPostExecute(BluetoothSocket result) {
	
	btSocket = result;
	//Enable Button
	btToggle.setEnabled(true);
	
}
 

protected ConnectThread(BluetoothDevice device) {
    BluetoothSocket tmp = null;
    mmDevice = device;

    try {
        tmp = device.createRfcommSocketToServiceRecord(UUID.fromString(CHARACTERISTIC_UUID));
    } catch (IOException e) {
        Log.e(TAG, e.getMessage());
    }
    mmSocket = tmp;
}
 

public ConnectThread(BluetoothDevice device) {
    mmDevice = device;
    BluetoothSocket tmp = null;

    // Get a BluetoothSocket for a connection with the
    // given BluetoothDevice
    try {
        tmp = device.createRfcommSocketToServiceRecord(MainActivity.MY_UUID);
    } catch (IOException e) {
        mkmsg("Client connection failed: " + e.getMessage() + "\n");
    }
    socket = tmp;

}
 

public void run() {
    MLog.d(TAG, "bbt run " + mServerStarted);
    mServerStarted = true;
    MLog.d(TAG, "bbt run " + mServerStarted);

    while (mServerStarted) {
        try {
            BluetoothSocket serverSocket = mBluetoothServer.accept();
            MLog.d(TAG, "bbt accepting connection " + serverSocket.getRemoteDevice().getAddress());
            connectToClient(serverSocket); // since this is blocking, once we get a client we connect it
        } catch (IOException e) {
            MLog.d(TAG, "bbt BLUETOOTH error:" + e.getMessage());
        }
    }
}
 

public ConnectedThreadClass_Read(BluetoothSocket socket) {
    mmSocket = socket;
    InputStream tmpIn = null;
    // Get the input and output streams, using temp objects because
    // member streams are final
    try {
        tmpIn = mmSocket.getInputStream();
    } catch (IOException e) {
    }
    mmInStream = tmpIn;
    isInStreamConnected = true;
}
 

@Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
//                case TASK_RECV_MSG://接收到对方的蓝牙信息
//                    String rcv= (String) msg.obj;  // 获得远程设备发送的消息
//                    Toast.makeText(getContext(),rcv,Toast.LENGTH_SHORT).show();
//                    if (!mApplication.getPhoneState())
//                        handleReceivedBleMsg(rcv);
//                    break;
                case TASK_GET_SOCKET:
                    mApplication.setBluetoothSocket((BluetoothSocket) msg.obj);
                    mApplication.setHandler(mHandler);
//                    mangerThread= new ConnectedThread(app.getBluetoothSocket(),getContext(),app.getHandler());
//                    mangerThread.start();
                    iv_connect.setBackgroundResource(R.drawable.connect_success);
                   // mBtn_searchBle.setText("一切准备就绪");
                    mCpb_connect.setProgress(100);
                    mRequestThread=null;//置空连接线程
                    break;
                case TASK_GET_SOCKET_FAILED:
                   // iv_connect.setBackgroundResource(R.drawable.);
                    mCpb_connect.setProgress(-1);
                    mRequestThread=null;//置空连接线程，为重新请求连接做准备
                    Toast.makeText(getActivity(), "连接失败，请重试！", Toast.LENGTH_SHORT).show();
                    break;
                case TASK_DISCONNECT:
                    mCpb_connect.setProgress(0);
                    break;
            }
        }
 

public ConnectThread(BluetoothDevice device) {
    this.mmDevice = device;
    BluetoothSocket tmp = null;

    try {
        tmp = device.createRfcommSocketToServiceRecord(MY_UUID);
    } catch (IOException e) {
        Log.e(TAG, "create() failed", e);
    }
    mmSocket = tmp;
}
 

@RequiresPermission("android.permission.BLUETOOTH")
public synchronized void connected(BluetoothSocket socket,
                                   BluetoothDevice device) {
    Log.d(TAG, "connected");

    // Cancel the thread that completed the connection
    if (this.mConnectThread != null) {
        this.mConnectThread.cancel();
        this.mConnectThread = null;
    }

    // Cancel any thread currently running a connection
    if (this.mConnectedThread != null) {
        this.mConnectedThread.cancel();
        this.mConnectedThread = null;
    }

    // Cancel
    if(this.mAcceptThread != null) {
        this.mAcceptThread.cancel();
        this.mAcceptThread = null;
    }

    // Start the thread to manage the connection and perform transmissions
    mConnectedThread = new BluetoothService.ConnectedThread(socket);
    mConnectedThread.start();
    Message msg = this.mHandler.obtainMessage(BluetoothPlugin.MESSAGE_DEVICE_NAME);
    Bundle bundle = new Bundle();
    bundle.putString(DEVICE_NAME, device.getName());
    msg.setData(bundle);
    this.mHandler.sendMessage(msg);
    setState(STATE_CONNECTED);
}
 

/**
 * Start the ConnectedThread to begin managing a Bluetooth connection
 *
 * @param socket The BluetoothSocket on which the connection was made
 */
private synchronized void connected(BluetoothSocket socket) {
    if (DEBUG) Log.d(TAG, "connected");

    // 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;
    }

    // Start listening thread if there is no one already running.
    if (mAcceptThread == null) {
        mAcceptThread = new AcceptThread();
        mAcceptThread.start();
    }

    // Start the thread to manage the connection and perform transmissions.
    mConnectedThread = new ConnectedThread(socket);
    mConnectedThread.start();

    startBluetoothHack();

    updateDeviceState(STATE_CONNECTED);
}
 

BtConnectThread(BluetoothDevice device, boolean secure)
{
	mmDevice = device;
	BluetoothSocket tmp = null;
	mSocketType = secure ? "Secure" : "Insecure";

	// Modified to work with SPP Devices
	final UUID SPP_UUID = UUID
		.fromString("00001101-0000-1000-8000-00805F9B34FB");
	
	// Get a BluetoothSocket for a connection with the
	// given BluetoothDevice
	try
	{
		if (secure)
		{
			tmp = device.createRfcommSocketToServiceRecord(SPP_UUID);
		} else
		{
			tmp = device.createInsecureRfcommSocketToServiceRecord(SPP_UUID);
		}
	} catch (IOException e)
	{
		log.log(Level.SEVERE, "Socket Type: " + mSocketType + "create() failed", e);
	}
	mmSocket = tmp;

	logSocketUuids(mmSocket, "BT socket");
}
 

/**
 * Starts the ConnectedThread to read data.
 * 
 * @param bluetoothSocket the bluetooth socket
 * @param bluetoothDevice the bluetooth device
 */
private synchronized void connected(
    BluetoothSocket bluetoothSocket, BluetoothDevice bluetoothDevice) {
  cancelThreads();

  connectedThread = new ConnectedThread(bluetoothSocket);
  connectedThread.start();

  // Send the device name to the handler
  Message message = handler.obtainMessage(MESSAGE_DEVICE_NAME);
  Bundle bundle = new Bundle();
  bundle.putString(KEY_DEVICE_NAME, bluetoothDevice.getName());
  message.setData(bundle);
  handler.sendMessage(message);

  setState(Sensor.SensorState.CONNECTED);
}
 

/**
 * Start the ConnectedThread to begin managing a Bluetooth connection
 * @param socket  The BluetoothSocket on which the connection was made
 * @param device  The BluetoothDevice that has been connected
 */
public synchronized void connected(BluetoothSocket socket, BluetoothDevice device) {
	Log.d(TAG, "connected");

    // 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 (mAcceptThread != null) {mAcceptThread.cancel(); mAcceptThread = null;}

    // Start the thread to manage the connection and perform transmissions
    mConnectedThread = new ConnectedThread(socket);
    mConnectedThread.start();

    // Send the name of the connected device back to the UI Activity
    Message msg = mHandler.obtainMessage(MESSAGE_DEVICE_NAME);
    Bundle bundle = new Bundle();
    bundle.putString(SERVICE_HANDLER_MSG_KEY_DEVICE_ADDRESS, device.getAddress());
    bundle.putString(SERVICE_HANDLER_MSG_KEY_DEVICE_NAME, device.getName());
    msg.setData(bundle);
    mHandler.sendMessage(msg);

    setState(STATE_CONNECTED);
}
 

/**
 * Start the ConnectedThread to begin managing a Bluetooth connection
 * @param socket  The BluetoothSocket on which the connection was made
 * @param device  The BluetoothDevice that has been connected
 */
public synchronized void connected(BluetoothSocket socket, BluetoothDevice device) {
	Logs.d(TAG, "connected");

    // 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 (mAcceptThread != null) {mAcceptThread.cancel(); mAcceptThread = null;}

    // Start the thread to manage the connection and perform transmissions
    mConnectedThread = new ConnectedThread(socket);
    mConnectedThread.start();

    // Send the name of the connected device back to the UI Activity
    Message msg = mHandler.obtainMessage(MESSAGE_DEVICE_NAME);
    Bundle bundle = new Bundle();
    bundle.putString(Constants.SERVICE_HANDLER_MSG_KEY_DEVICE_ADDRESS, device.getAddress());
    bundle.putString(Constants.SERVICE_HANDLER_MSG_KEY_DEVICE_NAME, device.getName());
    msg.setData(bundle);
    mHandler.sendMessage(msg);

    setState(STATE_CONNECTED);
}
 

public ConnectedThread(BluetoothSocket socket) {
    Log.d(TAG, "create ConnectedThread");
    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;
}
 

@Override
        public void run() {

            //只要当前状态不等连接状态
            while (mBluetoothServer != null && (mBluetoothServer.getCurrentState() == BluetoothState.LISTEN == true)) {
                try {
//                    Log.i("Infoss", "开始监听 state:" + mBluetoothServer.getCurrentState() + "  thread:" + Thread.currentThread().getName());
                    mBluetoothServerSocket = mBluetoothAdapter.listenUsingInsecureRfcommWithServiceRecord(name, BluetoothServer.UUID_SECURE);
//                    Log.i("Infoss", "等待连接...");
                    BluetoothSocket mBluetoothSocket;
                    mBluetoothSocket = mBluetoothServerSocket.accept(); //Thread come to block
                    if (mBluetoothSocket != null) {

                        mBluetoothServer.connected(mBluetoothSocket);

                    }
                } catch (Exception e) {
//                    Log.i("Infoss", "接受失败.." + e);
                    e.printStackTrace();

                } finally {
                    try {
//                        Log.i("Infoss", "关闭了... state:" + mBluetoothServer.getCurrentState());
                        if (mBluetoothServerSocket != null) {
                            mBluetoothServerSocket.close();

                        }
                    } catch (IOException e1) {
                        e1.printStackTrace();
//                        Log.i("Infoss", "失败...");
                        break;
                    }
                }

            }
        }
 

protected BluetoothCommunicationThread createCommunicationThread(BluetoothSocket socket, final BluetoothDevice device) {
    BluetoothCommunicationThread communicationThread = new BluetoothCommunicationThread(socket, device.getAddress(), _handler, _debug);
    communicationThread.setDebug(_debug);
    communicationThread.setConnectionLostListener(new BluetoothCommunicationThread.ConnectionLostListener() {
        @Override
        public void onConnectionLost() {
            connectionLost(device);
        }
    });
    communicationThread.start();

    return communicationThread;
}
 

public SerialIOThread(BluetoothSocket rfcommSocket, MessageHashTableBase hashTable) {
    super();
    this.hashTable = hashTable;

    mRfCommSocket = rfcommSocket;
    try {
        mOutputStream = mRfCommSocket.getOutputStream();
        mInputStream = mRfCommSocket.getInputStream();
    } catch (IOException e) {
        log.error("Unhandled exception", e);
    }
    this.start();
}