Java BluetoothSocket类代码示例

import android.bluetooth.BluetoothSocket; //导入依赖的package包/类
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;
}
 

import android.bluetooth.BluetoothSocket; //导入依赖的package包/类
/**
     * 连接蓝牙（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;
}
 

import android.bluetooth.BluetoothSocket; //导入依赖的package包/类
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;
}
 

import android.bluetooth.BluetoothSocket; //导入依赖的package包/类
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;
}
 

import android.bluetooth.BluetoothSocket; //导入依赖的package包/类
/**
 * 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;
}
 

import android.bluetooth.BluetoothSocket; //导入依赖的package包/类
/**
 * 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);
}
 

import android.bluetooth.BluetoothSocket; //导入依赖的package包/类
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;
}
 

import android.bluetooth.BluetoothSocket; //导入依赖的package包/类
/**
 * 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();
}
 

import android.bluetooth.BluetoothSocket; //导入依赖的package包/类
@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);
}
 

import android.bluetooth.BluetoothSocket; //导入依赖的package包/类
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));
	}
}
 

import android.bluetooth.BluetoothSocket; //导入依赖的package包/类
@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;
			}
		}
	}
}
 

import android.bluetooth.BluetoothSocket; //导入依赖的package包/类
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;
}
 

import android.bluetooth.BluetoothSocket; //导入依赖的package包/类
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();
}
 

import android.bluetooth.BluetoothSocket; //导入依赖的package包/类
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;
}
 

import android.bluetooth.BluetoothSocket; //导入依赖的package包/类
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;
}