android.bluetooth.BluetoothServerSocket Java Examples

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;
    mState = STATE_LISTEN;
}
 

/**
 * 初始化
 *
 * @return
 */
public void init(BluetoothAdapter bluetoothAdapter, ServiceListenerCallback callback) {
    mListenerCallback = callback;
    if (mBluetoothAdapter != null || mBluetoothServerSocket != null) {
        return;
    }
    mBluetoothAdapter = bluetoothAdapter;
    BluetoothServerSocket tmp = null;
    try {
        // 明文传输，无需配对
        // adapter.listenUsingInsecureRfcommWithServiceRecord(TAG, SPP_UUID);
        // 加密传输，会自动执行配对
        tmp = mBluetoothAdapter.listenUsingRfcommWithServiceRecord(CbtConstant.CBT_NAME, CbtConstant.CBT_UUID);
    } catch (IOException e) {
        mListenerCallback.onStartError(e);
        CbtLogs.e(e.getMessage());
        return;
    }
    mBluetoothServerSocket = tmp;
    listener();
}
 

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 | NullPointerException e) {
        Log.e(TAG, "Socket Type: " + mSocketType + "listen() failed", e);
    }
    mmServerSocket = tmp;
    mState = STATE_LISTEN;
}
 

/**
 * コンストラクタ
 * @param secure セキュア接続を待機するならtrue
 */
public ListeningThread(final boolean secure) {
	super("ListeningThread:" + mName);

	// Create a new listening server socket
	BluetoothServerSocket tmp = null;
	try {
		if (secure) {
		// セキュアな接続を行うためのBluetoothServerSocketを生成
			tmp = mAdapter.listenUsingRfcommWithServiceRecord(mName, mSecureProfileUUID);
		} else {
			tmp = mAdapter.listenUsingInsecureRfcommWithServiceRecord(mName, mInSecureProfileUUID);
		}
	} catch (final IOException e) {
		Log.w(TAG, e);
	}
	mmServerSocket = tmp;
}
 

public BluetoothServerTask(Context context) throws NoBluetoothException {
	
	Log.i("BluetoothServerTask", "Created");
	mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
	if (mBluetoothAdapter == null) {
	    // Device does not support Bluetooth
		throw new NoBluetoothException();
		
	}
	this.context = context;
	Log.i("BluetoothServerTask", "Got adapter");
    // Use a temporary object that is later assigned to mmServerSocket,
    // because mmServerSocket is final
    BluetoothServerSocket tmp = null;
    try {
        // MY_UUID is the app's UUID string, also used by the client code
        tmp = mBluetoothAdapter.listenUsingInsecureRfcommWithServiceRecord(
        		Remote.BLUETOOTH_NAME, 
        		Remote.BLUETOOTH_UUID);
        Log.i("BluetoothServerTask", "Created insecure server socket");
    } catch (IOException e) { 
    	throw new NoBluetoothException();
    }
    mmServerSocket = tmp;
}
 

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)
    {
        MyLog.e(TAG, "Listen to " + mSocketType + " socket type failed. More: ", e);
    }

    mmServerSocket = tmp;
}
 

public AcceptThread(boolean secure) {
    _socketType = secure ? "Secure" : "Insecure";

    // Create a new listening server socket
    BluetoothServerSocket serverSocket = null;
    try {
        if (secure) {
            if (_debug) Log.d(TAG, "AcceptThread: started listening secure, uuid = " + _secureUuid + ", spd name = " + _secureSPDName);
            serverSocket = _adapter.listenUsingRfcommWithServiceRecord(_secureSPDName, _secureUuid);
        } else {
            if (_debug) Log.d(TAG, "AcceptThread: started listening insecure, uuid = " + _insecureUuid + ", spd name = " + _insecureSPDName);
            serverSocket = _adapter.listenUsingInsecureRfcommWithServiceRecord(_insecureSPDName, _insecureUuid);
        }
    } catch (IOException e) {
        Log.e(TAG, "AcceptThread: listen failed");
        e.printStackTrace();
    }

    _serverSocket = serverSocket;

    _isListening = true;
}
 

public AcceptThread()
{
    BluetoothServerSocket tmp = null;

    // Create a new listening server socket
    try
    {
        PodEmuLog.debug("SIBT: AcceptThread connecting with btdev_uuid_idx=" + btdev_uuid_idx);
        tmp = btAdapter.listenUsingRfcommWithServiceRecord(getName(), BTDEV_UUID[btdev_uuid_idx]);
    }
    catch (IOException e)
    {
        PodEmuLog.debug("SIBT: AcceptThread listen() failed");
        PodEmuLog.printStackTrace(e);
    }
    mmServerSocket = tmp;
}
 

public AcceptThread(boolean isAndroid, boolean secure) {
    BluetoothServerSocket tmp = null;

    // Create a new listening server socket
    try {
        if (secure) {
            if(isAndroid)
                tmp = mAdapter.listenUsingRfcommWithServiceRecord(NAME_SECURE, UUID_ANDROID_DEVICE);
            else
                tmp = mAdapter.listenUsingRfcommWithServiceRecord(NAME_SECURE, UUID_OTHER_DEVICE);
        } else {
            if(isAndroid)
                tmp = mAdapter.listenUsingInsecureRfcommWithServiceRecord(NAME_SECURE, UUID_ANDROID_DEVICE);
            else
                tmp = mAdapter.listenUsingInsecureRfcommWithServiceRecord(NAME_SECURE, UUID_OTHER_DEVICE);
        }
    } catch (IOException e) { }
    mmServerSocket = tmp;
}
 

public AcceptThread() {
    // Use a temporary object that is later assigned to mmServerSocket,
    // because mmServerSocket is final
    BluetoothServerSocket tmp = null;
    try {
        // MY_UUID is the app's UUID string, also used by the client code
        tmp = bluetoothAdapter.listenUsingRfcommWithServiceRecord(SERVER_NAME, SERVER_UUID);
    } catch (IOException e) { }
    mmServerSocket = tmp;

    if(bluetoothHandler != null) {
        bluetoothHandler
                .obtainMessage(BluetoothHandler.MESSAGE_WAIT_FOR_CONNECTION)
                .sendToTarget();
    }
}
 

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;
    mState = STATE_LISTEN;
}
 

@SuppressLint("NewApi")
 @RequiresPermission(Manifest.permission.BLUETOOTH)
 public AcceptThread(boolean secure) {
 	synchronized(THREAD_LOCK){
     	//Log.d(TAG, "Creating an Accept Thread");
     	BluetoothServerSocket tmp = null;
     	mSocketType = secure ? "Secure":"Insecure";
     	// Create a new listening server socket
     	try {
         	if (secure) {
         		tmp = mAdapter.listenUsingRfcommWithServiceRecord(NAME_SECURE, SERVER_UUID);
         	}
     	} catch (IOException e) {
         	//Log.e(TAG, "Socket Type: " + mSocketType + "listen() failed", e);
         	 //Let's try to shut down this thead
     	}catch(SecurityException e2){
     		//Log.e(TAG, "<LIVIO> Security Exception in Accept Thread - "+e2.toString());
     		interrupt();
     	}
     	mmServerSocket = tmp;
//Should only log on debug
     	//BluetoothSocket mySock = getBTSocket(mmServerSocket);
     	//Log.d(TAG, "Accepting Connections on SDP Server Port Number: " + getChannel(mySock) + "\r\n");
     }
 }
 

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 AcceptThread() 
{
    // Use a temporary object that is later assigned to mmServerSocket,
    // because mmServerSocket is final
    BluetoothServerSocket tmp = null;
    try 
    {
        // MY_UUID is the app's UUID string, also used by the client code
        tmp = bluetoothAdapter.listenUsingRfcommWithServiceRecord(SERVERNAME, UUID.fromString(DEFAULT_UUID));
    } 
    catch (IOException e) 
    { 
    	postError(e.getMessage());
    }
    
    mmServerSocket = tmp;
}
 

public AcceptThread() 
{
    // Use a temporary object that is later assigned to mmServerSocket,
    // because mmServerSocket is final
    BluetoothServerSocket tmp = null;
    try 
    {
        // MY_UUID is the app's UUID string, also used by the client code
        tmp = bluetoothAdapter.listenUsingRfcommWithServiceRecord(SERVERNAME, UUID.fromString(DEFAULT_UUID));
    } 
    catch (IOException e) 
    { 
    	postError(e.getMessage());
    }
    
    mmServerSocket = tmp;
}
 

public AcceptThread(int index) {
    mIndex = index;
    BluetoothServerSocket tmp = null;

    // Create a new listening server socket
    try {
        tmp = mBluetoothAdapter.listenUsingRfcommWithServiceRecord(
                NAME,
                UUID.fromString(mUUIDs[mIndex]));
    } catch (IOException e) {
        Log.e(TAG, "::AcceptThread Socket listen() at "+ mIndex + " failed.", e);
    }
    mmServerSocket = tmp;
}
 

public BluetoothServer(BluetoothAdapter bluetoothAdapter, String serviceName, UUID serviceUUID) {
    // Use a temporary object that is later assigned to mmServerSocket,
    // because mmServerSocket is final
    BluetoothServerSocket tmp = null;
    try {
        // MY_UUID is the app's UUID string, also used by the client code
        tmp = bluetoothAdapter.listenUsingRfcommWithServiceRecord(serviceName, serviceUUID);
    } catch (IOException ignored) {
    }
    serverSocket = tmp;
}
 

public AcceptThread(boolean isAndroid) {
    BluetoothServerSocket tmp = null;

    // Create a new listening server socket
    try {
        if(isAndroid)
            tmp = mAdapter.listenUsingRfcommWithServiceRecord(NAME_SECURE, UUID_ANDROID_DEVICE);
        else
            tmp = mAdapter.listenUsingRfcommWithServiceRecord(NAME_SECURE, UUID_OTHER_DEVICE);
    } catch (IOException e) { }
    mmServerSocket = tmp;
}
 

public ServerThread(BluetoothAdapter bluetoothAdapter, Handler handler) {
    this.bluetoothAdapter = bluetoothAdapter;
    this.uiHandler = handler;
    BluetoothServerSocket tmp = null;
    try {
        tmp = bluetoothAdapter.listenUsingRfcommWithServiceRecord(Params.NAME, UUID.fromString(Params.UUID));
    } catch (IOException e) {
        e.printStackTrace();
    }
    serverSocket = tmp;
    Log.e(TAG, "-------------- do new()");
}
 

public AcceptThread() {
    BluetoothServerSocket tmp = null;

    try {
        tmp = BluetoothService.this.mBtAdapter.listenUsingRfcommWithServiceRecord("BluetoothPlugin", BluetoothService.MY_UUID);
    } catch (IOException e) {
        Log.e(TAG, "listen() failed", e);
    }

    this.mmServerSocket = tmp;
}
 

public AcceptThread(BluetoothAdapter bluetoothAdapter, Handler handler) {
    mBluetoothAdapter=bluetoothAdapter;
    BluetoothServerSocket tmp = null;
    mHandler=handler;
    try {
        //监听RFCOMM
        tmp = mBluetoothAdapter.listenUsingRfcommWithServiceRecord(
                "Bluetooth_Chat_Room", UUID.fromString(UUID_STR));
    } catch (IOException e) {

    }
    mServerSocket = tmp;
}
 

private AcceptThread() {
    BluetoothServerSocket tmp = null;
    try {
        tmp = mBtAdapter.listenUsingRfcommWithServiceRecord("_", UUID.fromString(CHARACTERISTIC_UUID));
    } catch (IOException e) {
        Log.e(TAG, e.getMessage());
    }
    mmServerSocket = tmp;
}
 

public AcceptThread(boolean isAndroid) {
    BluetoothServerSocket tmp = null;

    // Create a new listening server socket
    try {
        if(isAndroid)
            tmp = mAdapter.listenUsingRfcommWithServiceRecord(NAME_SECURE, UUID_ANDROID_DEVICE);
        else
            tmp = mAdapter.listenUsingRfcommWithServiceRecord(NAME_SECURE, UUID_OTHER_DEVICE);
    } catch (IOException e) { }
    mmServerSocket = tmp;
}
 

public AcceptThread()
{
	BluetoothServerSocket tmp = null;

	try
	{
		tmp = mAdapter.listenUsingRfcommWithServiceRecord(NAME, MY_UUID);
	}
	catch (IOException e)
	{
		Log.e(TAG, "listen() failed", e);
	}
	mmServerSocket = tmp;
}
 

public AcceptThread() {
    BluetoothServerSocket tmp = null;

    // Create a new listening server socket
    try {
        tmp = mAdapter.listenUsingRfcommWithServiceRecord(NAME, MY_UUID);
    } catch (IOException e) {
        Log.e(TAG, "listen() failed", e);
    }
    mmServerSocket = tmp;
}
 

public AcceptThread() {
	BluetoothServerSocket tmp = null;

	// Create a new listening server socket
	try {
		tmp = mAdapter
				.listenUsingRfcommWithServiceRecord(NAME, MY_UUID);
	} catch (IOException e) {
		Log.e(TAG, "Socket Type: " + mSocketType + "listen() failed", e);
	}
	mmServerSocket = tmp;
}
 

public MainThread() {
  Log.d(TAG, "Main thread created");
  BluetoothServerSocket tmp = null;

  try {
    tmp = adapter.listenUsingRfcommWithServiceRecord(BT_NAME, BT_UUID);
  } catch (IOException ignored) {
  }

  serverSocket = tmp;
}
 

public SerialInterface_BT ()
{
    btAdapter = BluetoothAdapter.getDefaultAdapter();
    if (btAdapter == null)
    {
        // Device does not support Bluetooth
        PodEmuLog.debug("SIBT: device does not support Bluetooth.");
        btServerSocket = null;
        return;
    }
    if (!btAdapter.isEnabled())
    {
        // Bluetooth is still disabled :(
        PodEmuLog.debug("SIBT: Bluetooth is disabled. Not trying to turn it on though...");
        btServerSocket = null;
        return;
    }

    // Use a temporary object that is later assigned to mmServerSocket
    // because mmServerSocket is final.
    BluetoothServerSocket tmp = null;
    try
    {
        PodEmuLog.debug("SIBT: SerialInterface_BT connecting with btdev_uuid_idx=0");
        tmp = btAdapter.listenUsingRfcommWithServiceRecord(getName(), BTDEV_UUID[0]);
    }
    catch (IOException e)
    {
        PodEmuLog.debug("SIBT: Socket's listen() method failed");
        PodEmuLog.printStackTrace(e);

    }
    btServerSocket = tmp;
    btState = STATE_NONE;
}
 

public AcceptThread() {
    BluetoothServerSocket tmp = null;

    // Create a new listening server socket
    try {
        tmp = mAdapter.listenUsingRfcommWithServiceRecord(NAME, MY_UUID);
    } catch (IOException e) {
        Log.e(TAG, "listen() failed" + e.toString());
    }
    mmServerSocket = tmp;
}
 

public AcceptThread() {
    BluetoothServerSocket tmp = null;

    // Create a new listening server socket.
    try {
        tmp = mBluetoothAdapter.listenUsingInsecureRfcommWithServiceRecord("Sync Streaming Profile", LISTEN_UUID);
    } catch (IOException e) {
        Log.e(TAG, "listen() failed", e);
    }
    mServerSocket = tmp;
}