android.bluetooth.BluetoothSocket Java Examples

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) {
    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 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();
}
 

/**
 * 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 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());
}
 

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 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 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, final String socketType) {
    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();

    // Send the name of the connected device back to the UI Activity
    Message msg = mHandler.obtainMessage(Constants.MESSAGE_DEVICE_NAME);
    Bundle bundle = new Bundle();
    bundle.putString(Constants.DEVICE_NAME, device.getName());
    msg.setData(bundle);
    mHandler.sendMessage(msg);
    // Update UI title
    updateUserInterfaceTitle();
}
 

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();
}
 

ConnectionThread(BluetoothSocket socket, Handler handler){
	super();
	mBluetoothSocket = socket;
	mHandler = handler;
	try {
		mInStream = mBluetoothSocket.getInputStream();
		mOutStream = mBluetoothSocket.getOutputStream();
	} catch (IOException e) {
	}
}
 

/**
 * 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) {
    if (D) 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(CaptureActivity.MESSAGE_DEVICE_NAME);
    Bundle bundle = new Bundle();
    bundle.putString(CaptureActivity.DEVICE_NAME, device.getName());
    msg.setData(bundle);
    mHandler.sendMessage(msg);

    setState(STATE_CONNECTED);
}
 

public Connect(BluetoothSocket socket) {
    executor = Executors.newFixedThreadPool(2);
    writeThread = new ConnectedThread(socket, ConnectedThread.WRITE, null);
    readThread = new ConnectedThread(socket, ConnectedThread.READ, null);
    executor.execute(writeThread);
    executor.execute(readThread);

}
 

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 ConnectThread(BluetoothDevice device) {
    BluetoothSocket tmp = null;

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

static void sendPacket(BluetoothSocket socket, byte[] data) throws IOException, InterruptedException {
        OutputStream o = socket.getOutputStream();
        InputStream i = socket.getInputStream();
        byte[] packet = new byte[data.length + 3];
        packet[0] = 0x3e;
        packet[packet.length - 1] = 0x3c;
        byte crc = 0;
        for (int j = 0; j < data.length; j++) {
            crc += data[j];
            packet[j + 1] = data[j];
        }
        packet[packet.length - 2] = crc;
        o.write(packet);

        byte[] buffer = new byte[256];
        Date date = new Date();
        while (new Date().getTime() - date.getTime() < 200) {
            if (i.available() > 0) {
                int r = i.read(buffer);
                StringBuilder sb = new StringBuilder();
                for (int j = 0; j < r; j++) {
                    sb.append(String.format(" %02x", buffer[j]));
                }
//                Log.i(TAG, "Read: " + r + " bytes:" + sb);
                break;
            }
            Thread.sleep(50);
        }
    }
 

/**
 * Start the BtWorkerThread 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)
{
	log.log(Level.FINE, "connected, Socket Type:" + socketType);

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

	// Cancel any thread currently running a connection
	if (mBtWorkerThread != null)
	{
		mBtWorkerThread.cancel();
		mBtWorkerThread = null;
	}
	// Start the thread to manage the connection and perform transmissions
	mBtWorkerThread = new BtWorkerThread(socket, socketType);
	mBtWorkerThread.start();

       // we are connected -> signal connection established
       connectionEstablished(device.getName());
   }
 

protected SocketRunnable(StringBuffer throttle, StringBuffer steering, StringBuffer roverFace, StringBuffer servo, BluetoothSocket socket, StringBuffer exit,StringBuffer connectedStatus){
    this.mThrottle = throttle;
    this.mSteering = steering;
    this.mRoverFace = roverFace;
    this.mBluetoothSocket = socket;
    this.mServo = servo;
    this.mExit = exit;
    this.mConnectedStatus = connectedStatus;
}
 

/**
 * 初始化
 *
 * @return
 */
public void init(BluetoothAdapter bluetoothAdapter, BluetoothDevice device, ConnectDeviceCallback callBack) {
    mCallBack = callBack;
    if (mBluetoothDevice != null) {
        if (mBluetoothDevice.getAddress().equals(device.getAddress())) {
            mCallBack.connectSuccess(mBluetoothSocket, mBluetoothDevice);
            return;
        } else {
            cancel();
        }
    }

    mBluetoothAdapter = bluetoothAdapter;
    mBluetoothDevice = device;
    BluetoothSocket tmp = null;
    try {
        //尝试建立安全的连接
        tmp = mBluetoothDevice.createRfcommSocketToServiceRecord(CbtConstant.CBT_UUID);
    } catch (IOException e) {
        mCallBack.connectError(e);
    }
    mBluetoothSocket = tmp;
    connect();
}
 

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(MainActivity.MESSAGE_DEVICE_NAME);
	Bundle bundle = new Bundle();
	bundle.putString(MainActivity.DEVICE_NAME, device.getName());
	msg.setData(bundle);
	mHandler.sendMessage(msg);

	setState(STATE_CONNECTED);
}
 

public ConnectedThread(BluetoothSocket socket) {
            mmSocket = socket;
            bluetoothSocket = 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.d("ConnectedThread", e.getMessage());
            }

            mInputStream = tmpIn;
            mOutputStream = tmpOut;
        }
 

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

            if(!btAdapter.isEnabled())
            {
                mmSocket = null;
                this.cancel();
//                mConnectedThread.cancel();
                PodEmuService.stopService(baseContext);
                return;
            }

            // Get a BluetoothSocket for a connection with the
            // given BluetoothDevice
            try
            {
                PodEmuLog.debug("SIBT: ConnectThread connecting with btdev_uuid_idx=" + btdev_uuid_idx);
                setState(STATE_CONNECTING);
                tmp = device.createRfcommSocketToServiceRecord(BTDEV_UUID[btdev_uuid_idx]);
            }
            catch (IOException e)
            {
                PodEmuLog.debug("SIBT: ConnectThread createRfcomm() failed");
                PodEmuLog.printStackTrace(e);
            }
            mmSocket = tmp;
        }
 

/**
 * 初始化列表
 */
private void initList() {
    mRv.setLayoutManager(new LinearLayoutManager(mContext));
    mRv.addItemDecoration(new DividerItemDecoration(mContext, DividerItemDecoration.VERTICAL));
    mBondedListAdapter = new BondedListAdapter(null);
    mRv.setAdapter(mBondedListAdapter);
    mBondedListAdapter.setOnItemClickListener(
            (adapter, view, position) -> {
                BluetoothDevice item = mBondedListAdapter.getItem(position);
                CbtManager
                        .getInstance()
                        .connectDevice(item, new ConnectDeviceCallback() {
                            @Override
                            public void connectSuccess(BluetoothSocket socket, BluetoothDevice device) {
                                Toast.makeText(mContext, "连接成功！", Toast.LENGTH_SHORT).show();
                                startActivity(new Intent(mContext, SendDataActivity.class));
                            }

                            @Override
                            public void connectError(Throwable throwable) {
                                CbtLogs.e(throwable.getMessage());
                                Toast.makeText(mContext, throwable.getMessage(), Toast.LENGTH_SHORT).show();
                            }
                        });
            }
    );

    List<BluetoothDevice> bondedDevices = CbtManager.getInstance().getBondedDevices();
    mBondedListAdapter.setNewData(bondedDevices);
}
 

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

    mInputStream = tmpIn;
    mOutputStream = tmpOut;
}
 

private void sendMessage(BluetoothSocket socket, String message) {
  OutputStream outputStream;
  try {
    outputStream = socket.getOutputStream();

    // Add a stop character.
    byte[] byteArray = (message + " ").getBytes();
    byteArray[byteArray.length-1] = 0;
    outputStream.write(byteArray);
  } catch (IOException e) {
    Log.e(TAG, "Failed to send message: " + message, e);
  }
}
 

private synchronized void accepted(BluetoothSocket socket, BluetoothDevice device, String socketType) {
    if (_debug) Log.d(TAG, "accepted, Socket Type:" + socketType);

    // Start the thread to manage the connection and perform transmissions
    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_ADDED, bundle);
}
 

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) {
        mkmsg("Client connection failed: "+e.getMessage().toString()+"\n");
    }
    socket = tmp;
 
}
 

public ConnectThread(BluetoothDevice device, MainActivity ac) {
	// Use a temporary object that is later assigned to mmSocket,
	// because mmSocket is final
	Log.i("ConnectThread", "Starting connectThread");
	this.ac=ac;
	BluetoothSocket tmp = null;
	mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter();

	// Get a BluetoothSocket to connect with the given BluetoothDevice
	try {
		// MY_UUID is the app's UUID string, also used by the server code
		UUID MY_UUID = UUID.fromString("00001101-0000-1000-8000-00805F9B34FB");
		tmp = device.createRfcommSocketToServiceRecord(MY_UUID);
	} catch (IOException ignored) {
		Log.e("ConnectThread", "Error on getting the device");
	}
	mmSocket = tmp;

}
 

public FallbackBluetoothSocket(BluetoothSocket tmp) throws FallbackException {
    super(tmp);
    try {
        Class<?> clazz = tmp.getRemoteDevice().getClass();
        Class<?>[] paramTypes = new Class<?>[]{Integer.TYPE};
        Method m = clazz.getMethod("createRfcommSocket", paramTypes);
        Object[] params = new Object[]{Integer.valueOf(1)};
        fallbackSocket = (BluetoothSocket) m.invoke(tmp.getRemoteDevice(), params);
    } catch (Exception e) {
        throw new FallbackException(e);
    }
}