@Override public void run() { timestamp = System.currentTimeMillis(); BluetoothSocket btSocket = null; try { btSocket = device.createInsecureRfcommSocketToServiceRecord(BluetoothUuid_ObexMns.getUuid()); btSocket.connect(); } catch (IOException e) { Log.e(TAG, "BtSocket Connect error " + e.getMessage(), e); markConnectionFailed(btSocket); return; } if (V) Log.v( TAG, "Rfcomm socket connection attempt took " + (System.currentTimeMillis() - timestamp) + " ms"); ObexTransport transport; transport = new BluetoothMnsRfcommTransport(btSocket); if (V) Log.v(TAG, "Send transport message " + transport.toString()); mSessionHandler.obtainMessage(RFCOMM_CONNECTED, transport).sendToTarget(); }
public static BluetoothSocket createSocket(final BluetoothDevice device) throws IOException { if (Build.VERSION.SDK_INT >= 10) { // We're trying to create an insecure socket, which is only // supported in API 10 and up. Otherwise, we try a secure socket // which is in API 7 and up. return device.createInsecureRfcommSocketToServiceRecord( UUID.fromString("00001101-0000-1000-8000-00805F9B34FB")); } else { return device.createRfcommSocketToServiceRecord( UUID.fromString("00001101-0000-1000-8000-00805F9B34FB")); } }
private static BluetoothSocket createBluetoothSocket(BluetoothDevice device) throws IOException { if (Build.VERSION.SDK_INT >= 10) { try { final Method m = device .getClass() .getMethod("createInsecureRfcommSocketToServiceRecord", new Class[] {UUID.class}); return (BluetoothSocket) m.invoke(device, MY_UUID); } catch (Exception e) { } } return device.createInsecureRfcommSocketToServiceRecord(MY_UUID); }
void connectDevice(BluetoothDevice device) { try { UUID uuid = UUID.fromString("00001101-0000-1000-8000-00805F9B34FB"); BluetoothSocket bluetoothSocket = device.createInsecureRfcommSocketToServiceRecord(uuid); bluetoothSocket.connect(); transferSocket = bluetoothSocket; // listenForMessages(bluetoothSocket); } catch (IOException e) { e.printStackTrace(); } catch (Exception e) { e.printStackTrace(); } }
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); } catch (IOException e) { Log.e(TAG, "Socket Type: " + mSocketType + "create() failed", e); } mmSocket = tmp; }
@TargetApi(Build.VERSION_CODES.GINGERBREAD_MR1) @Override protected Void doInBackground( Void... devices) // while the progress dialog is shown, the connection is done in background { try { if (btSocket == null || !isBtConnected) { myBluetooth = BluetoothAdapter.getDefaultAdapter(); // get the mobile bluetooth device BluetoothDevice dispositivo = myBluetooth.getRemoteDevice( address); // connects to the device's address and checks if it's available btSocket = dispositivo.createInsecureRfcommSocketToServiceRecord( myUUID); // create a RFCOMM (SPP) connection BluetoothAdapter.getDefaultAdapter().cancelDiscovery(); btSocket.connect(); // start connection } } catch (IOException e) { ConnectSuccess = false; // if the try failed, you can check the exception here } return null; }
public ConnectThread(BluetoothDevice device, boolean secure) { if (DEBUG) { Log.d(TAG, "ConnectThread constructor"); } 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) { if (DEBUG) { Log.e(TAG, "Socket Type: " + mSocketType + "create() failed", e); } } mmSocket = tmp; }
@Override public void run() { timestamp = System.currentTimeMillis(); if (Constants.USE_TCP_DEBUG) { /* Use TCP socket to connect */ Socket s = new Socket(); // Try to connect for 50 seconds int result = 0; for (int i = 0; i < CONNECT_RETRY_TIME && result == 0; i++) { try { s.connect(new InetSocketAddress(host, channel), CONNECT_WAIT_TIMEOUT); } catch (UnknownHostException e) { Log.e(TAG, "TCP socket connect unknown host "); } catch (IOException e) { Log.e(TAG, "TCP socket connect failed "); } if (s.isConnected()) { if (D) Log.d(TAG, "TCP socket connected "); isConnected = true; break; } if (isInterrupted()) { Log.e(TAG, "TCP socket connect interrupted "); markConnectionFailed(s); return; } } if (!isConnected) { Log.e(TAG, "TCP socket connect failed after 20 seconds"); markConnectionFailed(s); return; } if (V) Log.v( TAG, "TCP Socket connection attempt took " + (System.currentTimeMillis() - timestamp) + " ms"); TestTcpTransport transport; transport = new TestTcpTransport(s); if (isInterrupted()) { isConnected = false; markConnectionFailed(s); transport = null; return; } if (!isConnected) { transport = null; Log.e(TAG, "TCP connect session error: "); markConnectionFailed(s); return; } else { if (D) Log.d(TAG, "Send transport message " + transport.toString()); mSessionHandler.obtainMessage(RFCOMM_CONNECTED, transport).sendToTarget(); } } else { /* Use BluetoothSocket to connect */ try { btSocket = device.createInsecureRfcommSocketToServiceRecord( BluetoothUuid.ObexObjectPush.getUuid()); } catch (IOException e1) { Log.e(TAG, "Rfcomm socket create error", e1); markConnectionFailed(btSocket); return; } try { btSocket.connect(); if (V) Log.v( TAG, "Rfcomm socket connection attempt took " + (System.currentTimeMillis() - timestamp) + " ms"); BluetoothOppRfcommTransport transport; transport = new BluetoothOppRfcommTransport(btSocket); BluetoothOppPreference.getInstance(mContext).setName(device, device.getName()); if (V) Log.v(TAG, "Send transport message " + transport.toString()); mSessionHandler.obtainMessage(RFCOMM_CONNECTED, transport).sendToTarget(); } catch (IOException e) { Log.e(TAG, "Rfcomm socket connect exception", e); // If the devices were paired before, but unpaired on the // remote end, it will return an error for the auth request // for the socket connection. Link keys will get exchanged // again, but we need to retry. There is no good way to // inform this socket asking it to retry apart from a blind // delayed retry. if (!mRetry && e.getMessage().equals(SOCKET_LINK_KEY_ERROR)) { Message msg = mSessionHandler.obtainMessage(SOCKET_ERROR_RETRY, -1, -1, device); mSessionHandler.sendMessageDelayed(msg, 1500); } else { markConnectionFailed(btSocket); } } } }
@TargetApi(10) void connect(Context context) { try { MetaWatchService.fakeWatch = false; if (Preferences.watchMacAddress.equals("DIGITAL")) { MetaWatchService.fakeWatch = true; MetaWatchService.watchType = MetaWatchService.WatchType.DIGITAL; } if (Preferences.watchMacAddress.equals("ANALOG")) { MetaWatchService.fakeWatch = true; MetaWatchService.watchType = MetaWatchService.WatchType.ANALOG; } if (Preferences.logging) Log.d(MetaWatch.TAG, "Remote device address: " + Preferences.watchMacAddress); if (!Preferences.loaded) loadPreferences(context); if (!MetaWatchService.fakeWatch) { if (bluetoothAdapter == null) { sendToast(getResources().getString(R.string.error_bluetooth_not_supported)); return; } else if (!bluetoothAdapter.isEnabled()) { sendToast(getResources().getString(R.string.error_bluetooth_not_enabled)); return; } wakeLock.acquire(5000); BluetoothDevice bluetoothDevice = bluetoothAdapter.getRemoteDevice(Preferences.watchMacAddress); if (Preferences.skipSDP) { Method method = bluetoothDevice.getClass().getMethod("createRfcommSocket", new Class[] {int.class}); bluetoothSocket = (BluetoothSocket) method.invoke(bluetoothDevice, 1); } else { UUID uuid = UUID.fromString("00001101-0000-1000-8000-00805F9B34FB"); int currentapiVersion = android.os.Build.VERSION.SDK_INT; if (Preferences.insecureBtSocket && currentapiVersion >= android.os.Build.VERSION_CODES.GINGERBREAD_MR1) { bluetoothSocket = bluetoothDevice.createInsecureRfcommSocketToServiceRecord(uuid); } else { bluetoothSocket = bluetoothDevice.createRfcommSocketToServiceRecord(uuid); } } bluetoothAdapter.cancelDiscovery(); bluetoothSocket.connect(); inputStream = bluetoothSocket.getInputStream(); outputStream = bluetoothSocket.getOutputStream(); } connectionState = ConnectionState.CONNECTED; updateNotification(); Protocol.startProtocolSender(); // RM: This is disabled for now, as it seems to confuse the watch fw (3.1.0S tested) // and get it into a state where it won't accept any date/time format updates :-S // if( Preferences.autoClockFormat ) // Protocol.setTimeDateFormat(this); Protocol.getRealTimeClock(); Protocol.getDeviceType(); Notification.startNotificationSender(this); Idle.updateIdle(this, true); } catch (IOException ioexception) { if (Preferences.logging) Log.d(MetaWatch.TAG, ioexception.toString()); } catch (SecurityException e) { if (Preferences.logging) Log.d(MetaWatch.TAG, e.toString()); } catch (NoSuchMethodException e) { if (Preferences.logging) Log.d(MetaWatch.TAG, e.toString()); } catch (IllegalArgumentException e) { if (Preferences.logging) Log.d(MetaWatch.TAG, e.toString()); } catch (IllegalAccessException e) { if (Preferences.logging) Log.d(MetaWatch.TAG, e.toString()); } catch (InvocationTargetException e) { if (Preferences.logging) Log.d(MetaWatch.TAG, e.toString()); } catch (NullPointerException e) { if (Preferences.logging) Log.d(MetaWatch.TAG, e.toString()); } finally { if (wakeLock != null && wakeLock.isHeld()) { wakeLock.release(); } } return; }
@Override public byte[] getByteArray(String locator, String hash) { byte[] data = new byte[3000000]; int connectAttemptsCounter = 0; if (locator.contains(NIMACBT)) { if (D) Log.d(TAG, " Connection process - Starting connection process!"); String mac = getMacAddressFromLocator(locator); BluetoothDevice device = mBluetoothAdapter.getRemoteDevice(mac); BluetoothSocket mmSocket = null; BluetoothSocket tmp = null; try { tmp = device.createInsecureRfcommSocketToServiceRecord(BO_TRANSFER_UUID); } catch (IOException e) { if (D) Log.e(TAG, "create() failed - (createInsecureRfcommSocketToServiceRecord) ", e); } mmSocket = tmp; // Always cancel discovery because it will slow down a connection mBluetoothAdapter.cancelDiscovery(); while (connectAttemptsCounter < retryAttempts) { connectAttemptsCounter++; // Make a connection to the BluetoothSocket try { // This is a blocking call and will only return on a // successful connection or an exception mmSocket.connect(); if (D) Log.d(TAG, " Connection process - Connection established - Socket connected"); if (D) Log.d(TAG, " Transferring Process - Starting file transfer"); data = getByteArrayFromRemotePeer(mmSocket, hash); if (data != null) { if (D) Log.d(TAG, " Transferring Process - File transferring done!"); return data; } } catch (IOException e) { if (D) Log.e( TAG, "failure while connecting to the socket - (createInsecureRfcommSocketToServiceRecord) ", e); } finally { try { if (mmSocket.isConnected()) { mmSocket.close(); } } catch (IOException e2) { Log.e(TAG, "unable to close() socket during connection failure", e2); } } } return null; } return null; }
@Override public void run() { handler.obtainMessage(MESSAGE_DEVICE_NAME_CHANGE, 0, 0, getDeviceName()); Throwable error = null; try { socket = device.createInsecureRfcommSocketToServiceRecord(uuid); setState(State.CONNECTING, null); socket.connect(); setState(State.CONNECTED, null); InputStream in = socket.getInputStream(); StringBuilder message = new StringBuilder(); byte[] buffer = new byte[512]; while (running.get()) { int bytesRead = in.read(buffer); // ISO-8859-1 contains all 256 bytes message.append(new String(buffer, 0, bytesRead, "ISO-8859-1")); int end; while ((end = message.indexOf("\n")) != -1) { handler.obtainMessage(MESSAGE_READ, bytesRead, 0, message.toString()).sendToTarget(); message.delete(0, end + 1); } } setState(State.CLOSING, null); } catch (IOException e) { error = e; } finally { try { // Synchronized prevents "ABORTING: INVALID HEAP ADDRESS IN dlfree" in android 4.0.4 synchronized (this) { socket.close(); } if (closedExplicitly.get()) setState(State.CLOSED, null); else setState(State.ERROR, error); } catch (IOException e) { setState(State.ERROR, error == null ? e : error); } } }