1. 包列表
  2. 类列表
  3. android.bluetooth.BluetoothSocket

Java 类android.bluetooth.BluetoothSocket 实例源码

项目：bluetooth-chat-appliction    文件：BluetoothChatService.java    
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;
    mState = STATE_CONNECTED;
}
项目：BluetoothAPP    文件：BluetoothUtil.java    
/**
     * 连接蓝牙（2）
     *
     * @return
     */
    public static BluetoothSocket connectDevice(final Handler handler) {
        BluetoothSocket socket = null;
        try {
            Comment.SPP_UUID = UUID.fromString("00001106-0000-1000-8000-00805F9B34FB");
            socket = Comment.bluetoothDevice.createRfcommSocketToServiceRecord(Comment.SPP_UUID);
            socket.connect();
            handler.sendEmptyMessage(Comment.CONNECT);
        } catch (Exception e) {
            handler.sendEmptyMessage(2);
            try {
                if (socket!=null)
                socket.close();
            } catch (Exception closeException) {

            }
        }
        return socket;
}
项目：ELM327    文件：BluetoothIOGateway.java    
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)
    {
        MyLog.e(TAG, "Socket Type: " + mSocketType + " create() failed", e);
    }

    mmSocket = tmp;
}
项目：dab-iot    文件：BluetoothChatService.java    
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;
    mState = STATE_CONNECTED;
}
项目：VR-One    文件：BluetoothListener.java    
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;
    mState = STATE_CONNECTING;
}
项目：VR-One    文件：BluetoothListener.java    
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;
    mState = STATE_CONNECTED;
}
项目：AndroidSDK2.0    文件：BTAdt.java    
/**
 * Bind boolean.
 *
 * @param socket the socket
 * @return the boolean
 */
public boolean bind( BluetoothSocket socket )
{

    mmSocket = socket;
    macAddress = mmSocket.getRemoteDevice().getAddress();

    // Get the BluetoothSocket input and output streams
    try
    {
        mmInStream = socket.getInputStream();
        mmOutStream = socket.getOutputStream();

        this.isRunning = true;
        // 펜 연결 후 맨 처음 펜정보를 요청한다.(프로토콜 2.0)
        startConnect();
        return true;
    }
    catch ( IOException e )
    {
        NLog.e( "[BTAdt/ConnectedThread] temporary sockets is not created", e );
    }

    return false;
}
项目：Presenter-Client-Android    文件：BluetoothPresenterControl.java    
/**
 * Creates the connection thread that will connect to a given device.
 *
 * @param device The device to connect to
 */
ConnectThread(BluetoothDevice device) {
    mmDevice = device;
    BluetoothSocket tmp = null;

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

    // Notifiy the user that we are now connecting
    android.os.Message userNotification
            = mHandler.obtainMessage(ServiceState.CONNECTING.ordinal());
    mHandler.sendMessage(userNotification);
}
项目：SmartRC    文件：BluetoothChatService.java    
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;
}
项目：Presenter-Client-Android    文件：BluetoothPresenterControl.java    
/**
 * 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
 */
private synchronized void connected(BluetoothSocket socket, BluetoothDevice device) {
    // 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 the thread to manage the connection and perform transmissions
    mConnectedThread = new ConnectedThread(socket, this, device);
    mConnectedThread.start();
}
项目：Nird2    文件：DroidtoothPlugin.java    
@Override
public DuplexTransportConnection createKeyAgreementConnection(
        byte[] commitment, BdfList descriptor, long timeout) {
    if (!isRunning()) return null;
    String address;
    try {
        address = parseAddress(descriptor);
    } catch (FormatException e) {
        LOG.info("Invalid address in key agreement descriptor");
        return null;
    }
    // No truncation necessary because COMMIT_LENGTH = 16
    UUID uuid = UUID.nameUUIDFromBytes(commitment);
    if (LOG.isLoggable(INFO))
        LOG.info("Connecting to key agreement UUID " + uuid);
    BluetoothSocket s = connect(address, uuid.toString());
    if (s == null) return null;
    return new DroidtoothTransportConnection(this, s);
}
项目：Nird2    文件：DroidtoothPlugin.java    
private void acceptContactConnections() {
    while (isRunning()) {
        BluetoothSocket s;
        try {
            s = socket.accept();
        } catch (IOException e) {
            // This is expected when the socket is closed
            if (LOG.isLoggable(INFO)) LOG.info(e.toString());
            return;
        }
        if (LOG.isLoggable(INFO)) {
            String address = s.getRemoteDevice().getAddress();
            LOG.info("Connection from " + scrubMacAddress(address));
        }
        backoff.reset();
        callback.incomingConnectionCreated(wrapSocket(s));
    }
}
项目：Nird2    文件：DroidtoothPlugin.java    
@Override
public DuplexTransportConnection createKeyAgreementConnection(
        byte[] commitment, BdfList descriptor, long timeout) {
    if (!isRunning()) return null;
    String address;
    try {
        address = parseAddress(descriptor);
    } catch (FormatException e) {
        LOG.info("Invalid address in key agreement descriptor");
        return null;
    }
    // No truncation necessary because COMMIT_LENGTH = 16
    UUID uuid = UUID.nameUUIDFromBytes(commitment);
    if (LOG.isLoggable(INFO))
        LOG.info("Connecting to key agreement UUID " + uuid);
    BluetoothSocket s = connect(address, uuid.toString());
    if (s == null) return null;
    return new DroidtoothTransportConnection(this, s);
}
项目：Nird2    文件：DroidtoothPlugin.java    
@Override
public BluetoothSocket call() throws Exception {
    // Repeat discovery until we connect or get interrupted
    while (true) {
        // Discover nearby devices
        LOG.info("Discovering nearby devices");
        List<String> addresses = discoverDevices();
        if (addresses.isEmpty()) {
            LOG.info("No devices discovered");
            continue;
        }
        // Connect to any device with the right UUID
        for (String address : addresses) {
            BluetoothSocket s = connect(address, uuid);
            if (s != null) {
                LOG.info("Outgoing connection");
                return s;
            }
        }
    }
}
项目：Snach-Android    文件：BluetoothActivity.java    
public ConnectThread(BluetoothDevice device) {
    // Use a temporary object that is later assigned to mmSocket,
    // because mmSocket is final
    BluetoothSocket tmp = null;
    mmDevice = device;

    /*try {
        tmp = createBluetoothSocket(device);
    } catch (IOException e1) {
        e1.printStackTrace();
    }*/

    try {
        tmp = device.createInsecureRfcommSocketToServiceRecord(MY_UUID);
    } catch (IOException e) { e.printStackTrace(); }

    /*try {
        tmp = createBluetoothSocket(device);
    } catch (IOException e) {
        e.printStackTrace();
    }*/

    mmSocket = tmp;
}
项目：phonk    文件：PBluetoothServer.java    
private void connectToClient(final BluetoothSocket btSocketClient) throws IOException {
    MLog.d(TAG, "bbt connection to device: " + btSocketClient.getRemoteDevice().getName());

    final ConnectedDevice connectedDevice = new ConnectedDevice(btSocketClient);
    mServerConnections.add(connectedDevice);

    // callback
    if (mCallbackOnNewConnection != null) {
        mHandler.post(new Runnable() {
            @Override
            public void run() {
                ReturnObject ret = new ReturnObject();
                ret.put("device", connectedDevice);
                ret.put("name", btSocketClient.getRemoteDevice().getName());
                ret.put("mac", btSocketClient.getRemoteDevice().getAddress());
                mCallbackOnNewConnection.event(ret);
            }
        });

    }

    connectedDevice.startThread();
}
项目：SecretTalk    文件：BluetoothChatService.java    
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;
    mState = STATE_CONNECTING;
}
项目：grblcontroller    文件：SerialThreadService.java    
public ConnectThread(BluetoothDevice device, boolean secure) {
    mmDevice = device;
    BluetoothSocket tmp = null;
    mSocketType = secure ? "Secure" : "Insecure";

    try {
        if (secure) {
            tmp = device.createRfcommSocketToServiceRecord(MY_UUID_SECURE);
        } else {
            tmp = device.createInsecureRfcommSocketToServiceRecord(MY_UUID_INSECURE);
        }
    } catch (IOException | NullPointerException e) {
        Log.e(TAG, "Socket Type: " + mSocketType + "create() failed", e);
    }
    mmSocket = tmp;
    mState = STATE_CONNECTING;
}
项目：grblcontroller    文件：SerialThreadService.java    
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 | NullPointerException e) {
        Log.e(TAG, "temp sockets not created", e);
    }

    mmInStream = tmpIn;
    mmOutStream = tmpOut;
    mState = STATE_CONNECTED;
}
项目：Lazy-Switches    文件：BluetoothService.java    
public ConnectThread(BluetoothDevice device) {
    // Use a temporary object that is later assigned to mmSocket,
    // because mmSocket is final
    BluetoothSocket tmp = null;
    mmDevice = device;

    // 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 uuid = Constants.myUUID;
        tmp = device.createRfcommSocketToServiceRecord(uuid);
    } catch (IOException e) {
        Log.e(Constants.TAG, "Create RFcomm socket failed", e);
    }
    mmSocket = tmp;
}
项目：Lazy-Switches    文件：BluetoothService.java    
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;
}
项目：LittleBitLouder    文件：ClientThread.java    
public ClientThread(BluetoothDevice device, Handler handler, boolean secure) {
    BluetoothSocket tempSocket = null;
    this.handler = handler;
    this.secure = secure;
    this.device = device;

    try {
        if (secure)
            tempSocket = device.createRfcommSocketToServiceRecord(UUID.fromString(Constants.UUID_STRING));
        else
            tempSocket = device.createInsecureRfcommSocketToServiceRecord(UUID.fromString(Constants.UUID_STRING));

    } catch (Exception e) {
        Log.e(TAG, e.toString());
    }
    this.socket = tempSocket;
}
项目：LittleBitLouder    文件：BluetoothConnector.java    
private boolean selectSocket() throws IOException {
    if (candidate >= uuidCandidates.size()) {
        return false;
    }

    BluetoothSocket tmp;
    UUID uuid = uuidCandidates.get(candidate++);

    Log.e("BT", "===> Attempting to connect to Protocol: " + uuid);
    if (secure) {
        tmp = device.createRfcommSocketToServiceRecord(uuid);
    } else {
        tmp = device.createInsecureRfcommSocketToServiceRecord(uuid);
    }
    bluetoothSocket = new NativeBluetoothSocket(tmp);

    return true;
}
项目：LittleBitLouder    文件：BluetoothConnector.java    
public FallbackBluetoothSocket(BluetoothSocket tmp, boolean isSecure) throws FallbackException {
    super(tmp);
    try {
        Class<?> clazz = tmp.getRemoteDevice().getClass();
        Class<?>[] paramTypes = new Class<?>[]{Integer.TYPE};

        String methodName = "createInsecureRfcommSocket";
        if (isSecure)
            methodName = "createRfcommSocket";

        Method m = clazz.getMethod(methodName, paramTypes);
        Object[] params = new Object[]{Integer.valueOf(1)};
        fallbackSocket = (BluetoothSocket) m.invoke(tmp.getRemoteDevice(), params);
    } catch (Exception e) {
        throw new FallbackException(e);
    }
}
项目：dab-iot    文件：BluetoothChatService.java    
public ConnectThread(BluetoothDevice device, boolean secure) {
    mmDevice = device;
    BluetoothSocket tmp = null;
    mSocketType = "Insecure";

    // Get a BluetoothSocket for a connection with the
    // given BluetoothDevice
    try {
        tmp = device.createInsecureRfcommSocketToServiceRecord(
                    MY_UUID_INSECURE);

    } catch (IOException e) {
        Log.e(TAG, "Socket Type: " + mSocketType + "create() failed", e);
    }
    mmSocket = tmp;
    mState = STATE_CONNECTING;
}
项目：buildAPKsApps    文件：BluetoothChatService.java    
public void run() {
    if (D) Log.d(TAG, "BEGIN mAcceptThread" + this);
    setName("AcceptThread");
    BluetoothSocket socket = null;
    try {
        // Listen for all 7 UUIDs
        for (int i = 0; i < 7; i++) {
            serverSocket = mAdapter.listenUsingRfcommWithServiceRecord(NAME, mUuids.get(i));
            socket = serverSocket.accept();
            if (socket != null) {
                String address = socket.getRemoteDevice().getAddress();
             mSockets.add(socket);
             mDeviceAddresses.add(address);
             connected(socket, socket.getRemoteDevice());
            }                       
        }
    } catch (IOException e) {
        Log.e(TAG, "accept() failed", e);
    }
    if (D) Log.i(TAG, "END mAcceptThread");
}
项目：buildAPKsApps    文件：BluetoothChatService.java    
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;
}
项目：xlight_android_native    文件：BLEDeviceConnector.java    
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;
}
项目：pass_the_bomb    文件：ReceptionConnectionsThread.java    
/**
 * Set the socket to listen and accept incoming connections
 */
public void run() {
    BluetoothSocket socket = null;
    // Keep listening until exception occurs or a socket is returned
    while (true) {
        try {
            socket = mmServerSocket.accept();
        } catch (IOException e) {
            break;
        }

        // If a connection was accepted
        if (socket != null) {
            // Do work to manage the connection (in a separate thread)
            new MessagingThread(socket).start();
            System.out.println("Socket accepted");
        }
    }
    cancel();
}
项目：pass_the_bomb    文件：ConnectionThread.java    
/**
 * Creates the thread
 * @param playerToConnect player to connect to
 */
public ConnectionThread(Player playerToConnect) {
    //gets the device to connect to (the player's device)
    BluetoothDevice deviceToConnect = BluetoothServices.getmBluetoothAdapter().getRemoteDevice(playerToConnect.getMAC());
    System.out.println("device to connect to");
    System.out.println(deviceToConnect.getAddress());
    System.out.println(deviceToConnect.getName());
    System.out.println(deviceToConnect.toString());
    System.out.println("device to connect to");
    // Use a temporary object that is later assigned to mmSocket,
    // because mmSocket is final
    BluetoothSocket tmp = null;

    // Get a BluetoothSocket to connect with the given BluetoothDevice (that is a player)
    try {
        // MY_UUID is the app's UUID string, also used by the reception part of the code
        // creates and insecure RF socket
        tmp = deviceToConnect.createInsecureRfcommSocketToServiceRecord(MainActivity.uuid);
        System.out.println("Socket found!");

    } catch (IOException e) { }
    mmSocket = tmp;
}
项目：pass_the_bomb    文件：InitialReceptionConnectionsThread.java    
/**
 * Run the socket and start creating connections and messaging threads
 */
public void run() {
    BluetoothSocket socket = null;
    // Keep listening until exception occurs or a socket is returned
    while (true) {
        try {
            socket = mmServerSocket.accept();
        } catch (IOException e) {
            break;
        }
        // If a connection was accepted
        if (socket != null) {
            // Do work to manage the connection (in a separate thread)
            System.out.println("Socket Accepted!!");
            new MessagingThread(socket).start();
            break;
        }
    }
    cancel();
}
项目：pass_the_bomb    文件：MessagingThread.java    
/**
 * Creates a messaging thread with the socket (and player behind socket).
 *
 * @param socket socket that represents the bluetooth connection
 */
public MessagingThread(BluetoothSocket socket) {
    System.out.println("Starting messaging thread " + socket.getRemoteDevice().getName());
    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) { }

    //the streams are used in order to receive and send data
    mmInStream = tmpIn;
    mmOutStream = tmpOut;

    //store this messaging thread in the map with all the messaging threads per player
    remoteDevice = mmSocket.getRemoteDevice();
    BluetoothServices.putInMessagingThreadMap(getRemotePlayer(),this);
}
项目：Blockly    文件：ConnectBluetoothThread.java    
public ConnectBluetoothThread(BluetoothDevice device, BluetoothAdapter mBluetoothAdapter, Handler handler) {
    // Use a temporary object that is later assigned to mmSocket,
    // because mmSocket is final
    this.mBluetoothAdapter=mBluetoothAdapter;
    this.handler=handler;
    mmDevice = device;

    BluetoothSocket tmp = null;
    msg=new Message();

    // Get a BluetoothSocket to connect with the given BluetoothDevice
    try {
        // MY_UUID is the app's UUID string, also used by the server code
        String uuid="00001101-0000-1000-8000-00805f9b34fb";
        tmp = device.createRfcommSocketToServiceRecord(UUID.fromString(uuid));
    } catch (IOException e) {
        Log.d(TAG, "ConnectBluetoothThread: 初始化uuid错误");
    }
    mmSocket = tmp;
}
项目：buildAPKsSamples    文件：BluetoothChatService.java    
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;
}
项目：buildAPKsSamples    文件：BluetoothChatService.java    
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;
}
项目：UnityBluetoothPlugin    文件：BluetoothService.java    
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;
}
项目：ELM327    文件：BluetoothIOGateway.java    
public ConnectedThread(BluetoothSocket socket, String socketType)
{
    MyLog.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)
    {
        MyLog.e(TAG, "temp sockets not created", e);
    }

    mmInStream = tmpIn;
    mmOutStream = tmpOut;
}
项目：VR-One    文件：BluetoothListener.java    
/**
 * 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();
}
项目：bluetooth-chat-appliction    文件：BluetoothChatService.java    
/**
 * 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();
}
项目：noise    文件：BluetoothSyncService.java    
@Override
public void run() {
    BluetoothSocket socket = null;

    while (started) {
        String macAddress = null;
        try {
            // This will block until there is a connection
            Log.d(TAG, "Bluetooth Classic server is listening for a client");
            socket = serverSocket.accept();
            macAddress = socket.getRemoteDevice().getAddress();
            if (!openConnections.containsKey(macAddress)) {
                openConnections.put(macAddress, true);
                StreamSync.bidirectionalSync(socket.getInputStream(), socket.getOutputStream());
            }
            socket.close();
        } catch (IOException connectException) {
            Log.e(TAG, "Failed to start a Bluetooth Classic connection as a server", connectException);

            try {
                if (socket != null)
                    socket.close();
            } catch (IOException closeException) {
                Log.e(TAG, "Failed to close a Bluetooth Classic connection as a server", closeException);
            }
        }
        if (macAddress != null)
            openConnections.remove(macAddress);
    }
}