public BluetoothPreferenceManager(Context context) { super(context); IntentFilter filter = new IntentFilter(BluetoothDevice.ACTION_FOUND); context.registerReceiver(mDiscoveryReceiver, filter); try { mBluetoothDeviceManager = new DeviceManager(context); fillBluetoothDeviceList(); } catch(BluetoothException e) { Log.w(TAG, "This device most likely does not have " + "a Bluetooth adapter"); } }
public boolean writeCharacteristicToBLE(byte[] bytes) { try { for (int i = 0; i < bytes.length; i++) { writeArray[queueEnd++] = bytes[i]; } } catch (BufferOverflowException e) { Log.d(TAG, "Buffer overflowing!!!!"); return false; } BLESendData(); return true; }
/** * Connect to the target device and open a socket. This method will block * while waiting for the device. * <p> * Returns a socket connected to the device. */ public BluetoothSocket connect(String targetAddress) throws BluetoothException { return connect(getDefaultAdapter().getRemoteDevice(targetAddress)); }
public BluetoothSocket connect(BluetoothDevice device) throws BluetoothException { if (device == null) { throw new BluetoothException("Not connecting to null Bluetooth device"); } mSocket = setupSocket(device); connectToSocket(mSocket); storeLastConnectedDevice(device); return mSocket; }
public BluetoothGatt connectBLE(String address) throws BluetoothException { return connectBLE(getDefaultAdapter().getRemoteDevice(address)); }
mDeviceManager.getLastConnectedDevice(); Log.i(TAG, "Connecting to Bluetooth device " + address + " device is BLE : " + mDeviceManager.isBLEDevice(address)); try { if (!isConnected()) { if (!mDeviceManager.isBLEDevice(address)) { connectingToBLE = false; newSocket = mDeviceManager.connect(address); } else if (!mDeviceManager.isBLEConnected()) { connectingToBLE = true; bluetoothGatt = mDeviceManager.connectBLE(address); mDeviceManager.getCandidateDevices()); Log.i(TAG, "Attempting connection to auto-detected " + "VI " + device); if (!mDeviceManager.isBLEDevice(device)) { connectingToBLE = false; newSocket = mDeviceManager.connect(device); } else { connectingToBLE = true; bluetoothGatt = mDeviceManager.connectBLE(device); candidateDevices.get(0).getAddress() + " as the next one to try"); mDeviceManager.storeLastConnectedDevice( candidateDevices.get(0));
private void fillBluetoothDeviceList() { for(BluetoothDevice device : mBluetoothDeviceManager.getPairedDevices()) { mDiscoveredDevices.put(device.getAddress(), device.getName() + " (" + device.getAddress() + ")"); } persistCandidateDiscoveredDevices(); mBluetoothDeviceManager.startDiscovery(); }
public Set<BluetoothDevice> getCandidateDevices() { Set<BluetoothDevice> candidates = new HashSet<>(); for (BluetoothDevice device : getPairedDevices()) { if (device.getName().startsWith( BluetoothVehicleInterface.DEVICE_NAME_PREFIX)) { candidates.add(device); } } SharedPreferences preferences = mContext.getSharedPreferences(KNOWN_BLUETOOTH_DEVICE_PREFERENCES, Context.MODE_MULTI_PROCESS); Set<String> detectedDevices = SupportSettingsUtils.getStringSet( preferences, KNOWN_BLUETOOTH_DEVICE_PREF_KEY, new HashSet<String>()); for (String address : detectedDevices) { if (BluetoothAdapter.checkBluetoothAddress(address)) { candidates.add(getDefaultAdapter().getRemoteDevice(address)); } } for (BluetoothDevice candidate : candidates) { Log.d(TAG, "Found previously discovered or paired OpenXC BT VI " + candidate.getAddress()); } return candidates; }
DeviceManager deviceManager = new DeviceManager(getActivity()); deviceManager.startDiscovery();
public Set<BluetoothDevice> getPairedDevices() { Set<BluetoothDevice> devices = new HashSet<>(); if (getDefaultAdapter() != null && getDefaultAdapter().isEnabled()) { devices = getDefaultAdapter().getBondedDevices(); } return devices; }
@Override public void close() { super.close(); getContext().unregisterReceiver(mDiscoveryReceiver); mBluetoothDeviceManager.stop(); }
public void startDiscovery() { if (getDefaultAdapter() != null) { if (getDefaultAdapter().isDiscovering()) { getDefaultAdapter().cancelDiscovery(); } Log.i(TAG, "Starting Bluetooth discovery"); getDefaultAdapter().startDiscovery(); } }
@Override public synchronized void stop() { if (isRunning()) { try { getContext().unregisterReceiver(mBroadcastReceiver); } catch (IllegalArgumentException e) { Log.w(TAG, "Broadcast receiver not registered but we expected it to be"); } mDeviceManager.stop(); closeSocket(); super.stop(); } }
public BluetoothServerSocket listen() { BluetoothServerSocket tmp = null; try { // TODO use an OpenXC-specific UUID tmp = getDefaultAdapter().listenUsingRfcommWithServiceRecord( "TODO", DeviceManager.RFCOMM_UUID); } catch (IOException e) { } return tmp; }
public BluetoothVehicleInterface(SourceCallback callback, Context context, String address) throws DataSourceException { super(callback, context); try { mDeviceManager = new DeviceManager(getContext()); } catch (BluetoothException e) { throw new DataSourceException( "Unable to open Bluetooth device manager", e); } IntentFilter filter = new IntentFilter( BluetoothAdapter.ACTION_DISCOVERY_FINISHED); getContext().registerReceiver(mBroadcastReceiver, filter); filter = new IntentFilter(BluetoothDevice.ACTION_ACL_CONNECTED); getContext().registerReceiver(mBroadcastReceiver, filter); filter = new IntentFilter(BluetoothAdapter.ACTION_STATE_CHANGED); getContext().registerReceiver(mBroadcastReceiver, filter); SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(context); mUsePolling = preferences.getBoolean( context.getString(R.string.bluetooth_polling_key), true); Log.d(TAG, "Bluetooth device polling is " + (mUsePolling ? "enabled" : "disabled")); setAddress(address); start(); mAcceptThread = new Thread(new SocketAccepter()); mAcceptThread.start(); }
public BluetoothDevice getLastConnectedDevice() { SharedPreferences preferences = mContext.getSharedPreferences(KNOWN_BLUETOOTH_DEVICE_PREFERENCES, Context.MODE_MULTI_PROCESS); String lastConnectedDeviceAddress = preferences.getString( LAST_CONNECTED_BLUETOOTH_DEVICE_PREF_KEY, null); BluetoothDevice lastConnectedDevice = null; if (lastConnectedDeviceAddress != null) { lastConnectedDevice = getDefaultAdapter().getRemoteDevice(lastConnectedDeviceAddress); } return lastConnectedDevice; }
/** * The DeviceManager requires an Android Context in order to send the intent * to enable Bluetooth if it isn't already on. */ public DeviceManager(Context context) throws BluetoothException { mContext = context; if (getDefaultAdapter() == null) { String message = "This device most likely does not have " + "a Bluetooth adapter"; Log.w(TAG, message); throw new BluetoothException(message); } else { Log.d(TAG, "Initializing Bluetooth device manager"); } }
public boolean isBLEDevice(String address) { return getDefaultAdapter(). getRemoteDevice(address). getType() == BluetoothDevice.DEVICE_TYPE_LE; }
/** * Immediately cancel any pending Bluetooth operations. * <p> * The BluetoothSocket.connect() function blocks while waiting for a * connection, but it's thread safe and we can cancel that by calling * close() on it at any time. * <p> * Importantly we don't want to close the socket any other time, because we * want to leave that up to the user of the socket - if you call close() * twice, or close Input/Output streams associated with the socket * simultaneously, it can cause a segfault due to a bug in some Android * Bluetooth stacks. Awesome! */ public void stop() { if (mSocketConnecting.get() && mSocket != null) { try { mSocket.close(); } catch (IOException e) { } } if (mSocketConnecting.get() && mBluetoothGatt != null) { mBluetoothGatt.close(); } if (getDefaultAdapter() != null) { getDefaultAdapter().cancelDiscovery(); } }
private void connectToSocket(BluetoothSocket socket) throws BluetoothException { mSocketConnecting.set(true); try { socket.connect(); if (getDefaultAdapter().isDiscovering()) { getDefaultAdapter().cancelDiscovery(); } } catch (IOException e) { String error = "Could not connect to SPP service on " + socket; Log.e(TAG, error); try { socket.close(); } catch (IOException e2) { } throw new BluetoothException(error, e); } finally { mSocketConnecting.set(false); } }