RxBleDevice

java.lang.Object
- com.idevicesinc.sweetblue.rx.RxBleDevice

public class RxBleDevice
extends java.lang.Object

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addHistoricalData(java.util.UUID uuid, byte[] data)` Same as `addHistoricalData(UUID, byte[], EpochTime)` but uses `System.currentTimeMillis()` for the timestamp.
`void`	`addHistoricalData(java.util.UUID uuid, byte[] data, EpochTime epochTime)` Manual way to add data to the historical data list managed by this device.
`void`	`addHistoricalData(java.util.UUID uuid, EpochTime epochTime, byte[] data)` Just an overload of `addHistoricalData(UUID, byte[], EpochTime)` with the data and epochTime parameters switched around.
`void`	`addHistoricalData(java.util.UUID uuid, ForEach_Returning<HistoricalData> historicalData)` Same as `addHistoricalData(UUID, byte[], EpochTime)` but for large datasets this is more efficient when writing to disk.
`void`	`addHistoricalData(java.util.UUID uuid, HistoricalData historicalData)` Same as `addHistoricalData(UUID, byte[], EpochTime)`.
`void`	`addHistoricalData(java.util.UUID uuid, java.util.Iterator<HistoricalData> historicalData)` Same as `addHistoricalData(UUID, byte[], EpochTime)` but for large datasets this is more efficient when writing to disk.
`void`	`addHistoricalData(java.util.UUID uuid, java.util.List<HistoricalData> historicalData)` Same as `addHistoricalData(UUID, byte[], EpochTime)` but for large datasets this is more efficient when writing to disk.
`<any>`	`bond()` Bonds this device.
`void`	`clearAllData()` One method to remove absolutely all "metadata" related to this device that is stored on disk and/or cached in memory in any way.
`void`	`clearHistoricalData_memoryOnly()` Clears all `HistoricalData` tracked by this device.
`void`	`clearHistoricalData_memoryOnly(EpochTimeRange range)` Clears all `HistoricalData` tracked by this device within the given range.
`void`	`clearHistoricalData_memoryOnly(EpochTimeRange range, long count)` Clears the first `count` number of `HistoricalData` tracked by this device within the given range.
`void`	`clearHistoricalData_memoryOnly(long count)` Clears the first `count` number of `HistoricalData` tracked by this device.
`void`	`clearHistoricalData_memoryOnly(java.util.UUID uuid)` Clears all `HistoricalData` tracked by this device for a particular characteristic `UUID`.
`void`	`clearHistoricalData_memoryOnly(java.util.UUID characteristicUuid, EpochTimeRange range)` Clears all `HistoricalData` tracked by this device for a particular characteristic `UUID` within the given range.
`void`	`clearHistoricalData_memoryOnly(java.util.UUID characteristicUuid, EpochTimeRange range, long count)` Clears the first `count` number of `HistoricalData` tracked by this device for a particular characteristic `UUID` within the given range.
`void`	`clearHistoricalData_memoryOnly(java.util.UUID uuid, long count)` Clears the first `count` number of `HistoricalData` tracked by this device for a particular characteristic `UUID`.
`void`	`clearHistoricalData()` Clears all `HistoricalData` tracked by this device.
`void`	`clearHistoricalData(EpochTimeRange range)` Clears all `HistoricalData` tracked by this device within the given range.
`void`	`clearHistoricalData(EpochTimeRange range, long count)` Clears the first `count` number of `HistoricalData` tracked by this device within the given range.
`void`	`clearHistoricalData(long count)` Clears the first `count` number of `HistoricalData` tracked by this device.
`void`	`clearHistoricalData(java.util.UUID... uuids)` Overload of `clearHistoricalData(UUID)` that just calls that method multiple times.
`void`	`clearHistoricalData(java.util.UUID uuid)` Clears all `HistoricalData` tracked by this device for a particular characteristic `UUID`.
`void`	`clearHistoricalData(java.util.UUID uuid, EpochTimeRange range)` Clears all `HistoricalData` tracked by this device for a particular characteristic `UUID` within the given range.
`void`	`clearHistoricalData(java.util.UUID uuid, EpochTimeRange range, long count)` Clears the first `count` number of `HistoricalData` tracked by this device for a particular characteristic `UUID` within the given range.
`void`	`clearHistoricalData(java.util.UUID uuid, long count)` Clears the first `count` number of `HistoricalData` tracked by this device for a particular characteristic `UUID`.
`void`	`clearName()` Clears any name previously provided through `setName(String)` or overloads.
`void`	`clearSharedPreferences()` Convenience forwarding of `RxBleManager.clearSharedPreferences(String)`.
`<any>`	`connect_withRetries()` Similar to `connect()`, only the `ObservableEmitter#onNext(Object)` method can get called multiple times depending on what logic is implemented in `BleDeviceConfig.reconnectFilter`.
`<any>`	`connect_withRetries(RxBleTransaction.RxAuth authTxn)` Overload of `connect_withRetries(RxBleTransaction.RxAuth, RxBleTransaction.RxInit)`.
`<any>`	`connect_withRetries(RxBleTransaction.RxAuth authTxn, RxBleTransaction.RxInit initTxn)` Similar to `connect_withRetries()`, only this method allows you to pass in `RxBleTransaction.RxAuth`, and `RxBleTransaction.RxInit` instances for this specific device -- instead of using `BleDeviceConfig.defaultAuthFactory`, or `BleDeviceConfig.defaultInitFactory`.
`<any>`	`connect_withRetries(RxBleTransaction.RxInit initTxn)` Overload of `connect_withRetries(RxBleTransaction.RxAuth, RxBleTransaction.RxInit)`.
`Completable`	`connect()` Connect to this BLE device.
`Completable`	`connect(RxBleTransaction.RxAuth authTxn)` Overload of `connect(RxBleTransaction.RxAuth, RxBleTransaction.RxInit)`.
`Completable`	`connect(RxBleTransaction.RxAuth authTxn, RxBleTransaction.RxInit initTxn)` Similar to `connect()`, only this method allows you to pass in `RxBleTransaction.RxAuth`, and `RxBleTransaction.RxInit` instances for this specific device -- instead of using `BleDeviceConfig.defaultAuthFactory`, or `BleDeviceConfig.defaultInitFactory`.
`Completable`	`connect(RxBleTransaction.RxInit initTxn)` Overload of `connect(RxBleTransaction.RxAuth, RxBleTransaction.RxInit)`.
`<any>`	`disableNotifies(java.util.List<BleNotify> notifies)`
`<any>`	`disableNotify(BleNotify notify)` Disable notifications for a characteristic on this BLE device.
`boolean`	`disconnect_remote()` Same as `disconnect()` but this call roughly simulates the disconnect as if it's because of the remote device going down, going out of range, etc.
`boolean`	`disconnect()` Disconnects from a connected device or does nothing if already `BleDeviceState.BLE_DISCONNECTED`.
`boolean`	`disconnectWhenReady()` Similar to `disconnect()` with the difference being the disconnect task is set to a low priority.
`<any>`	`enableNotifies(java.util.List<BleNotify> notifies)`
`<any>`	`enableNotify(BleNotify notify)` Enable notifications for a characteristic on this BLE device.
`boolean`	`equals(java.lang.Object object_nullable)` Returns `equals(RxBleDevice)` if object is an instance of `RxBleDevice`.
`boolean`	`equals(RxBleDevice device_nullable)` First checks referential equality and if `false` checks equality of `getMacAddress()`.
`int`	`getAdvertisingFlags()` Returns the advertising flags, if any, parsed from `getScanRecord()`.
`Interval`	`getAverageReadTime()` See similar explanation for `getAverageWriteTime()`.
`Interval`	`getAverageWriteTime()` Returns the average round trip time in seconds for all write operations started with `write(BleWrite)`.
`BleDevice`	`getBleDevice()`
`RxBleDeviceConfig`	`getConfig()` Return the `RxBleDeviceConfig` this device is set to use.
`BleConnectionPriority`	`getConnectionPriority()` Returns the connection priority value set by `setConnectionPriority(BleConnectionPriority)`, or `BleNodeConfig.DEFAULT_MTU_SIZE` if it was never set explicitly.
`int`	`getConnectionRetryCount()` Returns the connection failure retry count during a retry loop.
`Distance`	`getDistance()` Returns the approximate distance in meters based on `getRssi()` and `getTxPower()`.
`int`	`getEffectiveWriteMtuSize()` Returns the effective MTU size for a write.
`<any>`	`getHistoricalData_atOffset(java.util.UUID uuid, EpochTimeRange range, int offsetFromStart)`
`<any>`	`getHistoricalData_atOffset(java.util.UUID uuid, int offsetFromStart)`
`<any>`	`getHistoricalData_latest(java.util.UUID uuid)` Returns the cached data from the latest successful read or notify received for a given uuid.
`<any>`	`getHistoricalData(java.util.UUID uuid)` Overload of `getHistoricalData(UUID, EpochTimeRange)`, which uses a range of `EpochTimeRange.FROM_MIN_TO_MAX`.
`<any>`	`getHistoricalData(java.util.UUID uuid, EpochTimeRange range)` Returns an `Observable` which emits `HistoricalData` for each data item for the UUID given, and within the specified range.
`int`	`getHistoricalDataCount(java.util.UUID uuid)` Returns the number of historical data entries that have been logged for the device's given characteristic.
`int`	`getHistoricalDataCount(java.util.UUID uuid, EpochTimeRange range)` Returns the number of historical data entries that have been logged for the device's given characteristic within the range provided.
`State.ChangeIntent`	`getLastDisconnectIntent()` This enum gives you an indication of the last interaction with a device across app sessions or in-app BLE `BleManagerState.OFF`->`BleManagerState.ON` cycles or undiscovery->rediscovery, which basically means how it was last `BleDeviceState.BLE_DISCONNECTED`.
`EpochTime`	`getLastDiscoveryTime()` Returns the last time the device was `DiscoveryListener.LifeCycle.DISCOVERED` or `DiscoveryListener.LifeCycle.REDISCOVERED`.
`java.lang.String`	`getMacAddress()` Returns the MAC address of this device, as retrieved from the native stack or provided through `RxBleManager.newDevice(String)` (or overloads thereof).
`byte[]`	`getManufacturerData()` Returns the manufacturer data, if any, parsed from `getScanRecord()`.
`int`	`getManufacturerId()` Returns the manufacturer id, if any, parsed from `getScanRecord()` }.
`int`	`getMtu()` Returns the "maximum transmission unit" value set by `negotiateMtu(int)`, or `BleNodeConfig.DEFAULT_MTU_SIZE` if it was never set explicitly.
`java.lang.String`	`getName_debug()` Returns a name useful for logging and debugging.
`java.lang.String`	`getName_native()` Returns the raw, unmodified device name retrieved from the stack.
`java.lang.String`	`getName_normalized()` The name retrieved from `getName_native()` can change arbitrarily, like the last 4 of the MAC address can get appended sometimes, and spaces might get changed to underscores or vice-versa, caps to lowercase, etc.
`java.lang.String`	`getName_override()` By default returns the same value as `getName_native()`.
`android.bluetooth.BluetoothDevice`	`getNative()` Provides just-in-case lower-level access to the native device instance.
`android.bluetooth.BluetoothGatt`	`getNativeGatt()` See pertinent warning for `getNative()`.
`int`	`getNativeStateMask()` Returns the actual native state mask representation of the `BleDeviceState` for this device.
`BleDeviceOrigin`	`getOrigin()` How the device was originally created, either from scanning or explicit creation.
`int`	`getRssi()` Returns the raw RSSI retrieved from when the device was discovered, rediscovered, or when you call `readRssi()` or `startRssiPoll(Interval)`.
`Percent`	`getRssiPercent()` Raw RSSI from `getRssi()` is a little cryptic, so this gives you a friendly 0%-100% value for signal strength.
`BleScanRecord`	`getScanInfo()` Returns the `BleScanRecord` instance held by this `RxBleDevice`.
`byte[]`	`getScanRecord()` Returns the scan record from when we discovered the device.
`int`	`getStateMask()` Returns the bitwise state mask representation of `BleDeviceState` for this device.
`Interval`	`getTimeInState(BleDeviceState state)` If `is(BleDeviceState)` returns true for the given state (i.e.
`int`	`getTxPower()` Returns the calibrated transmission power of the device.
`int`	`hashCode()`
`boolean`	`hasHistoricalData()` Returns `true` if there is any historical data at all for this device.
`boolean`	`hasHistoricalData(EpochTimeRange range)` Returns `true` if there is any historical data at all for this device within the given range.
`boolean`	`hasHistoricalData(java.util.UUID uuid)` Returns `true` if there is any historical data for the given uuid.
`boolean`	`hasHistoricalData(java.util.UUID[] uuids)` Returns `true` if there is any historical data for any of the given uuids.
`boolean`	`hasHistoricalData(java.util.UUID uuid, EpochTimeRange range)` Returns `true` if there is any historical data for the given uuid within the given range.
`boolean`	`is(BleDeviceState state)` Returns whether the device is in the provided state.
`boolean`	`is(java.lang.Object... query)` Similar to `is(BleDeviceState)` and `isAny(BleDeviceState...)` but allows you to give a simple query made up of `BleDeviceState` and `Boolean` pairs.
`boolean`	`isAll(BleDeviceState... states)` Returns whether the device is in all of the provided states.
`boolean`	`isAll(int mask_BleDeviceState)` Returns `true` if there is complete bitwise overlap between the provided value and `getStateMask()`.
`boolean`	`isAny(BleDeviceState... states)` Returns whether the device is in any of the provided states.
`boolean`	`isAny(int mask_BleDeviceState)` Returns `true` if there is any bitwise overlap between the provided value and `getStateMask()`.
`boolean`	`isConnectable()` Convenience method to tell you whether a call to `connect()` (or overloads) has a chance of succeeding.
`boolean`	`isHistoricalDataLoaded()` Returns `true` if the historical data for all historical data for this device is loaded into memory.
`boolean`	`isHistoricalDataLoaded(java.util.UUID uuid)` Returns `true` if the historical data for a given uuid is loaded into memory.
`boolean`	`isHistoricalDataLoading()` Returns whether the device is currently loading any historical data to memory, either through `loadHistoricalData()` (or overloads) or `getHistoricalData(UUID)` (or overloads).
`boolean`	`isHistoricalDataLoading(java.util.UUID uuid)` Returns whether the device is currently loading any historical data to memory for the given uuid, either through `loadHistoricalData()` (or overloads) or `getHistoricalData(UUID)` (or overloads).
`boolean`	`isNotifyEnabled(java.util.UUID uuid)` Returns `true` if notifications are enabled for the given uuid.
`boolean`	`isNotifyEnabling(java.util.UUID uuid)` Returns `true` if SweetBlue is in the process of enabling notifications for the given uuid.
`boolean`	`isNull()` As you should never get an instance of this class which is `null`, use this method to see if the device is considered to be `null` or not.
`<any>`	`loadHistoricalData()` Loads all historical data to memory for this device.
`<any>`	`loadHistoricalData(java.util.UUID uuid)` Loads all historical data to memory for this device for the given `UUID`.
`<any>`	`negotiateMtu(int mtu)` Wrapper for `BluetoothGatt.requestMtu(int)` which attempts to change the "maximum transmission unit" for a given connection.
`<any>`	`negotiateMtuToDefault()` Overload of `negotiateMtu(int)` that returns the "maximum transmission unit" to the default.
`<any>`	`observeBondEvents()` Returns a `Flowable` which emits `RxBondEvent` when any bonding events happen for this device.
`<any>`	`observeHistoricalDataLoadEvents()` Returns a `Flowable` which emits `RxHistoricalDataLoadEvent` when any `HistoricalDataLoadListener.HistoricalDataLoadEvent` is posted for this device.
`<any>`	`observeNotifyEvents()` Returns a `Flowable` which emits `RxNotificationEvent` when any notifications are received for this `RxBleDevice`.
`<any>`	`observeReadWriteEvents()` Returns a `Flowable` which emits `RxReadWriteEvent` when any read, or write operation completes for this device.
`<any>`	`observeStateEvents()` Returns a `Flowable` which emits `RxDeviceStateEvent` when this `RxBleDevice` changes state.
`boolean`	`performOta(RxBleTransaction.RxOta txn)` Kicks off an "over the air" long-term transaction if it's not already taking place and the device is `BleDeviceState.INITIALIZED`.
`boolean`	`performTransaction(RxBleTransaction txn)` Allows you to perform an arbitrary transaction that is not associated with any `BleDeviceState` like `BleDeviceState.PERFORMING_OTA`, `BleDeviceState.AUTHENTICATING` or `BleDeviceState.INITIALIZING`.
`boolean`	`popListener_Reconnect()` Pops the current `DeviceReconnectFilter` off the stack of listeners.
`java.lang.String`	`printState()` Returns a string of all the states this `RxBleDevice` is currently in.
`void`	`pushListener_Reconnect(DeviceReconnectFilter listener)` Pushes the provided `DeviceReconnectFilter` on to the top of the stack of listeners.
`<any>`	`read(BleDescriptorRead read)`
`<any>`	`read(BleRead read)` Perform a BLE read on this device.
`<any>`	`readMany(BleRead[] bleReads)` Overload for `read(BleRead)` for many writes.
`<any>`	`readMany(java.lang.Iterable<BleRead> bleReads)` Overload for `read(BleRead)` for many writes.
`<any>`	`readPhyOptions()` Method to get the current "phy options" (physical layer), or current bluetooth 5 feature.
`<any>`	`readRssi()` Wrapper for `BluetoothGatt.readRemoteRssi()`.
`void`	`refreshGattDatabase()` Overload of `refreshGattDatabase(Interval)` which uses the default gatt refresh delay of `BleDeviceConfig.DEFAULT_GATT_REFRESH_DELAY`.
`void`	`refreshGattDatabase(Interval gattPause)` This only applies to a device which is `BleDeviceState.BLE_CONNECTED`.
`RxReadWriteEvent`	`reliableWrite_abort()` Wrapper for `BluetoothGatt.abortReliableWrite()` - will return an event such that `RxReadWriteEvent.isNull()` will return `false` if there are no problems.
`<any>`	`reliableWrite_begin()` Wrapper for `BluetoothGatt.beginReliableWrite()` - will return an `Observable` which emits `RxReadWriteEvent`s.
`RxReadWriteEvent`	`reliableWrite_execute()` Wrapper for `BluetoothGatt.abortReliableWrite()` - will return an event such that `RxReadWriteEvent.isNull()` will return `false` if there are no problems.
`void`	`setConfig(RxBleDeviceConfig config_nullable)` Optionally sets overrides for any custom options given to `RxBleManager.get(android.content.Context, RxBleManagerConfig)` for this individual device.
`<any>`	`setConnectionPriority(BleConnectionPriority priority)` Wrapper for `BluetoothGatt.requestConnectionPriority(int)` which attempts to change the connection priority for a given connection.
`void`	`setListener_Reconnect(DeviceReconnectFilter listener_nullable)` Set a listener here to be notified whenever a connection fails and to have control over retry behavior.
`<any>`	`setName(java.lang.String name)` Same as `setName(String, UUID)` but will not attempt to propagate the name change to the remote device.
`<any>`	`setName(java.lang.String name, java.util.UUID characteristicUuid)` Sets the local name of the device and also attempts a `write(BleWrite)` using the given `UUID`.
`<any>`	`setPhyOptions(Phy phyOption)` Use this method to manually set the bluetooth 5 physical layer to use a bluetooth 5 feature (high speed/long range).
`<any>`	`startChangeTrackingPoll(java.util.UUID characteristicUuid, Interval interval)`
`<any>`	`startChangeTrackingPoll(java.util.UUID serviceUuid, java.util.UUID characteristicUuid, DescriptorFilter descriptorFilter, Interval interval)` Similar to `startPoll(UUID, Interval)` but only invokes a callback when a change in the characteristic value is detected.
`<any>`	`startChangeTrackingPoll(java.util.UUID serviceUuid, java.util.UUID characteristicUuid, Interval interval)`
`<any>`	`startPoll(java.lang.Iterable<java.util.UUID> uuids, Interval interval)`
`<any>`	`startPoll(java.util.UUID[] uuids, Interval interval)`
`<any>`	`startPoll(java.util.UUID characteristicUuid, Interval interval)`
`<any>`	`startPoll(java.util.UUID serviceUuid, java.util.UUID characteristicUuid, DescriptorFilter descriptorFilter, Interval interval)` Starts a periodic read of a particular characteristic.
`<any>`	`startPoll(java.util.UUID serviceUuid, java.util.UUID characteristicUuid, Interval interval)`
`<any>`	`startRssiPoll(Interval interval)` Kicks off a poll that automatically calls `readRssi()` at the `Interval` frequency specified.
`java.lang.String`	`toString()`
`void`	`unbond()` Forwards `BleDevice.unbond()`.
`boolean`	`undiscover()` Convenience method that calls `RxBleManager.undiscover(RxBleDevice)`.
`<any>`	`write(BleDescriptorWrite write)`
`<any>`	`write(BleWrite write)` Performs a BLE write on this device.
`<any>`	`writeMany(BleWrite[] writes)` Overload for `write(BleWrite)` for many writes.
`<any>`	`writeMany(java.lang.Iterable<BleWrite> writes)` Overload for `write(BleWrite)` for many writes.

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

- Method Detail
  - observeStateEvents
```
public final <any> observeStateEvents()
```
    Returns a Flowable which emits RxDeviceStateEvent when this RxBleDevice changes state.
  - observeNotifyEvents
```
public final <any> observeNotifyEvents()
```
    Returns a Flowable which emits RxNotificationEvent when any notifications are received for this RxBleDevice.
  - observeBondEvents
```
public final <any> observeBondEvents()
```
    Returns a Flowable which emits RxBondEvent when any bonding events happen for this device.
  - observeReadWriteEvents
```
public final <any> observeReadWriteEvents()
```
    Returns a Flowable which emits RxReadWriteEvent when any read, or write operation completes for this device.
  - observeHistoricalDataLoadEvents
```
public final <any> observeHistoricalDataLoadEvents()
```
    Returns a Flowable which emits RxHistoricalDataLoadEvent when any HistoricalDataLoadListener.HistoricalDataLoadEvent is posted for this device.
  - setListener_Reconnect
```
public final void setListener_Reconnect(DeviceReconnectFilter listener_nullable)
```
    Set a listener here to be notified whenever a connection fails and to have control over retry behavior. NOTE: This will clear the stack of DeviceReconnectFilters, and set the one provided here to be the only one in the stack. If the provided listener is null, then the stack of listeners will be cleared.
  - pushListener_Reconnect
```
public final void pushListener_Reconnect(DeviceReconnectFilter listener)
```
    Pushes the provided DeviceReconnectFilter on to the top of the stack of listeners. This method will early-out if the provided listener is null
  - popListener_Reconnect
```
public final boolean popListener_Reconnect()
```
    Pops the current DeviceReconnectFilter off the stack of listeners. Returns true if a listener was actually removed from the stack (it will only be false if the stack is already empty).
  - reliableWrite_begin
```
public final <any> reliableWrite_begin()
```
    Wrapper for BluetoothGatt.beginReliableWrite() - will return an Observable which emits RxReadWriteEvents. After calling this you should do your write(BleWrite) calls then call reliableWrite_execute().
  - reliableWrite_abort
```
public final RxReadWriteEvent reliableWrite_abort()
```
    Wrapper for BluetoothGatt.abortReliableWrite() - will return an event such that RxReadWriteEvent.isNull() will return false if there are no problems. This call requires a previous call to reliableWrite_begin().
  - reliableWrite_execute
```
public final RxReadWriteEvent reliableWrite_execute()
```
    Wrapper for BluetoothGatt.abortReliableWrite() - will return an event such that RxReadWriteEvent.isNull() will return false if there are no problems. This call requires a previous call to reliableWrite_begin().
  - printState
```
public final java.lang.String printState()
```
    Returns a string of all the states this RxBleDevice is currently in.
  - setConfig
```
public final void setConfig(RxBleDeviceConfig config_nullable)
```
    Optionally sets overrides for any custom options given to RxBleManager.get(android.content.Context, RxBleManagerConfig) for this individual device.
  - getConfig
```
public final RxBleDeviceConfig getConfig()
```
    Return the RxBleDeviceConfig this device is set to use. If none has been set explicitly, then the instance of RxBleManagerConfig is returned.
  - getOrigin
```
public final BleDeviceOrigin getOrigin()
```
    How the device was originally created, either from scanning or explicit creation.
    
    NOTE: That devices for which this returns BleDeviceOrigin.EXPLICIT may still be DiscoveryListener.LifeCycle.REDISCOVERED through RxBleManager.scan(ScanOptions).
  - getLastDiscoveryTime
```
public final EpochTime getLastDiscoveryTime()
```
    Returns the last time the device was DiscoveryListener.LifeCycle.DISCOVERED or DiscoveryListener.LifeCycle.REDISCOVERED. If getOrigin() returns BleDeviceOrigin.EXPLICIT then this will return EpochTime.NULL unless or until the device is DiscoveryListener.LifeCycle.REDISCOVERED.
  - getLastDisconnectIntent
```
public final State.ChangeIntent getLastDisconnectIntent()
```
    This enum gives you an indication of the last interaction with a device across app sessions or in-app BLE BleManagerState.OFF->BleManagerState.ON cycles or undiscovery->rediscovery, which basically means how it was last BleDeviceState.BLE_DISCONNECTED.
    
    If State.ChangeIntent.NULL, then the last disconnect is unknown because (a) device has never been seen before, (b) reason for disconnect was app being killed and BleDeviceConfig.manageLastDisconnectOnDisk was false, (c) app user cleared app data between app sessions or reinstalled the app.
    
    If State.ChangeIntent.UNINTENTIONAL, then from a user experience perspective, the user may not have wanted the disconnect to happen, and thus *probably* would want to be automatically connected again as soon as the device is discovered.
    
    If State.ChangeIntent.INTENTIONAL, then the last reason the device was BleDeviceState.BLE_DISCONNECTED was because disconnect() was called, which most-likely means the user doesn't want to automatically connect to this device again.
    
    See further explanation at BleDeviceConfig.manageLastDisconnectOnDisk.
  - getConnectionRetryCount
```
public final int getConnectionRetryCount()
```
    Returns the connection failure retry count during a retry loop. Basic example use case is to provide a callback to setListener_Reconnect(DeviceReconnectFilter) and update your application's UI with this method's return value downstream of your ReconnectFilter.onConnectFailed(ReconnectFilter.ConnectFailEvent) override.
  - getStateMask
```
public final int getStateMask()
```
    Returns the bitwise state mask representation of BleDeviceState for this device.
    
    See Also:
    
    BleDeviceState
  - getNativeStateMask
```
public final int getNativeStateMask()
```
    Returns the actual native state mask representation of the BleDeviceState for this device. The main purpose of this is to reflect what's going on under the hood while is(BleDeviceState) with BleDeviceState.RECONNECTING_SHORT_TERM is true.
  - getAverageReadTime
```
public final Interval getAverageReadTime()
```
    See similar explanation for getAverageWriteTime().
    
    See Also:
    
    getAverageWriteTime(), BleDeviceConfig.nForAverageRunningReadTime
  - getAverageWriteTime
```
public final Interval getAverageWriteTime()
```
    Returns the average round trip time in seconds for all write operations started with write(BleWrite). This is a running average with N being defined by BleDeviceConfig.nForAverageRunningWriteTime. This may be useful for estimating how long a series of reads and/or writes will take. For example for displaying the estimated time remaining for a firmware update.
  - getRssi
```
public final int getRssi()
```
    Returns the raw RSSI retrieved from when the device was discovered, rediscovered, or when you call readRssi() or startRssiPoll(Interval).
    
    See Also:
    
    getDistance()
  - getRssiPercent
```
public final Percent getRssiPercent()
```
    Raw RSSI from getRssi() is a little cryptic, so this gives you a friendly 0%-100% value for signal strength.
  - getDistance
```
public final Distance getDistance()
```
    Returns the approximate distance in meters based on getRssi() and getTxPower(). NOTE: the higher the distance, the less the accuracy.
  - getTxPower
```
public final int getTxPower()
```
    Returns the calibrated transmission power of the device. If this can't be figured out from the device itself then it backs up to the value provided in BleDeviceConfig.defaultTxPower.
    
    See Also:
    
    BleDeviceConfig.defaultTxPower
  - getManufacturerData
```
public final byte[] getManufacturerData()
```
    Returns the manufacturer data, if any, parsed from getScanRecord(). May be empty but never null.
  - getManufacturerId
```
public final int getManufacturerId()
```
    Returns the manufacturer id, if any, parsed from getScanRecord() }. May be -1 if not set
  - getScanRecord
```
public final byte[] getScanRecord()
```
    Returns the scan record from when we discovered the device. May be empty but never null.
  - getScanInfo
```
public final BleScanRecord getScanInfo()
```
    Returns the BleScanRecord instance held by this RxBleDevice.
  - getAdvertisingFlags
```
public final int getAdvertisingFlags()
```
    Returns the advertising flags, if any, parsed from getScanRecord().
  - loadHistoricalData
```
public final <any> loadHistoricalData()
```
    Loads all historical data to memory for this device.
  - loadHistoricalData
```
public final <any> loadHistoricalData(java.util.UUID uuid)
```
    Loads all historical data to memory for this device for the given UUID.
  - isHistoricalDataLoading
```
public final boolean isHistoricalDataLoading()
```
    Returns whether the device is currently loading any historical data to memory, either through loadHistoricalData() (or overloads) or getHistoricalData(UUID) (or overloads).
  - isHistoricalDataLoading
```
public final boolean isHistoricalDataLoading(java.util.UUID uuid)
```
    Returns whether the device is currently loading any historical data to memory for the given uuid, either through loadHistoricalData() (or overloads) or getHistoricalData(UUID) (or overloads).
  - isHistoricalDataLoaded
```
public final boolean isHistoricalDataLoaded()
```
    Returns true if the historical data for all historical data for this device is loaded into memory. Use HistoricalDataLoadListener to listen for when the load actually completes. If hasHistoricalData(UUID) returns false then this will also always return false.
  - isHistoricalDataLoaded
```
public final boolean isHistoricalDataLoaded(java.util.UUID uuid)
```
    Returns true if the historical data for a given uuid is loaded into memory. Use HistoricalDataLoadListener to listen for when the load actually completes. If hasHistoricalData(UUID) returns false then this will also always return false.
  - getHistoricalData_latest
```
public final <any> getHistoricalData_latest(java.util.UUID uuid)
```
    Returns the cached data from the latest successful read or notify received for a given uuid. Basically if you receive a ReadWriteListener.ReadWriteEvent for which ReadWriteListener.ReadWriteEvent.isRead() and ReadWriteListener.ReadWriteEvent.wasSuccess() both return true then ReadWriteListener.ReadWriteEvent.data(), will be cached and is retrievable by this method.
    
    Returns:
    
    The cached value from a previous read or notify, or HistoricalData.NULL otherwise.
    
    See Also:
    
    BleNodeConfig.HistoricalDataLogFilter, BleNodeConfig.DefaultHistoricalDataLogFilter
  - getHistoricalData
```
public final <any> getHistoricalData(java.util.UUID uuid)
```
    Overload of getHistoricalData(UUID, EpochTimeRange), which uses a range of EpochTimeRange.FROM_MIN_TO_MAX.
  - getHistoricalData
```
public final <any> getHistoricalData(java.util.UUID uuid,
                                     EpochTimeRange range)
```
    Returns an Observable which emits HistoricalData for each data item for the UUID given, and within the specified range.
  - getHistoricalData_atOffset
```
public final <any> getHistoricalData_atOffset(java.util.UUID uuid,
                                              int offsetFromStart)
```
  - getHistoricalData_atOffset
```
public final <any> getHistoricalData_atOffset(java.util.UUID uuid,
                                              EpochTimeRange range,
                                              int offsetFromStart)
```
  - getHistoricalDataCount
```
public final int getHistoricalDataCount(java.util.UUID uuid)
```
    Returns the number of historical data entries that have been logged for the device's given characteristic.
    
    See Also:
    
    BleNodeConfig.HistoricalDataLogFilter, BleNodeConfig.DefaultHistoricalDataLogFilter
  - getHistoricalDataCount
```
public final int getHistoricalDataCount(java.util.UUID uuid,
                                        EpochTimeRange range)
```
    Returns the number of historical data entries that have been logged for the device's given characteristic within the range provided.
    
    See Also:
    
    BleNodeConfig.HistoricalDataLogFilter, BleNodeConfig.DefaultHistoricalDataLogFilter
  - hasHistoricalData
```
public final boolean hasHistoricalData()
```
    Returns true if there is any historical data at all for this device.
    
    See Also:
    
    BleNodeConfig.HistoricalDataLogFilter, BleNodeConfig.DefaultHistoricalDataLogFilter
  - hasHistoricalData
```
public final boolean hasHistoricalData(EpochTimeRange range)
```
    Returns true if there is any historical data at all for this device within the given range.
    
    See Also:
    
    BleNodeConfig.HistoricalDataLogFilter, BleNodeConfig.DefaultHistoricalDataLogFilter
  - hasHistoricalData
```
public final boolean hasHistoricalData(java.util.UUID uuid)
```
    Returns true if there is any historical data for the given uuid.
    
    See Also:
    
    BleNodeConfig.HistoricalDataLogFilter, BleNodeConfig.DefaultHistoricalDataLogFilter
  - hasHistoricalData
```
public final boolean hasHistoricalData(java.util.UUID[] uuids)
```
    Returns true if there is any historical data for any of the given uuids.
    
    See Also:
    
    BleNodeConfig.HistoricalDataLogFilter, BleNodeConfig.DefaultHistoricalDataLogFilter
  - hasHistoricalData
```
public final boolean hasHistoricalData(java.util.UUID uuid,
                                       EpochTimeRange range)
```
    Returns true if there is any historical data for the given uuid within the given range.
    
    See Also:
    
    BleNodeConfig.HistoricalDataLogFilter, BleNodeConfig.DefaultHistoricalDataLogFilter
  - addHistoricalData
```
public final void addHistoricalData(java.util.UUID uuid,
                                    byte[] data,
                                    EpochTime epochTime)
```
    Manual way to add data to the historical data list managed by this device. You may want to use this if, for example, your remote BLE device is capable of taking and caching independent readings while not connected. After you connect with this device and download the log you can add it manually here. Really you can use this for any arbitrary historical data though, even if it's not associated with a characteristic.
    
    See Also:
    
    BleNodeConfig.HistoricalDataLogFilter, BleNodeConfig.DefaultHistoricalDataLogFilter
  - addHistoricalData
```
public final void addHistoricalData(java.util.UUID uuid,
                                    EpochTime epochTime,
                                    byte[] data)
```
    Just an overload of addHistoricalData(UUID, byte[], EpochTime) with the data and epochTime parameters switched around.
  - addHistoricalData
```
public final void addHistoricalData(java.util.UUID uuid,
                                    byte[] data)
```
    Same as addHistoricalData(UUID, byte[], EpochTime) but uses System.currentTimeMillis() for the timestamp.
    
    See Also:
    
    BleNodeConfig.HistoricalDataLogFilter, BleNodeConfig.DefaultHistoricalDataLogFilter
  - addHistoricalData
```
public final void addHistoricalData(java.util.UUID uuid,
                                    HistoricalData historicalData)
```
    Same as addHistoricalData(UUID, byte[], EpochTime).
    
    See Also:
    
    BleNodeConfig.HistoricalDataLogFilter, BleNodeConfig.DefaultHistoricalDataLogFilter
  - addHistoricalData
```
public final void addHistoricalData(java.util.UUID uuid,
                                    java.util.Iterator<HistoricalData> historicalData)
```
    Same as addHistoricalData(UUID, byte[], EpochTime) but for large datasets this is more efficient when writing to disk.
    
    See Also:
    
    BleNodeConfig.HistoricalDataLogFilter, BleNodeConfig.DefaultHistoricalDataLogFilter
  - addHistoricalData
```
public final void addHistoricalData(java.util.UUID uuid,
                                    java.util.List<HistoricalData> historicalData)
```
    Same as addHistoricalData(UUID, byte[], EpochTime) but for large datasets this is more efficient when writing to disk.
    
    See Also:
    
    BleNodeConfig.HistoricalDataLogFilter, BleNodeConfig.DefaultHistoricalDataLogFilter
  - addHistoricalData
```
public final void addHistoricalData(java.util.UUID uuid,
                                    ForEach_Returning<HistoricalData> historicalData)
```
    Same as addHistoricalData(UUID, byte[], EpochTime) but for large datasets this is more efficient when writing to disk.
    
    See Also:
    
    BleNodeConfig.HistoricalDataLogFilter, BleNodeConfig.DefaultHistoricalDataLogFilter
  - isAny
```
public final boolean isAny(BleDeviceState... states)
```
    Returns whether the device is in any of the provided states.
    
    See Also:
    
    is(BleDeviceState)
  - isAll
```
public final boolean isAll(BleDeviceState... states)
```
    Returns whether the device is in all of the provided states.
    
    See Also:
    
    isAny(BleDeviceState...)
  - isConnectable
```
public final boolean isConnectable()
```
    Convenience method to tell you whether a call to connect() (or overloads) has a chance of succeeding. For example if the device is BleDeviceState.CONNECTING_OVERALL or BleDeviceState.INITIALIZED then this will return false.
  - is
```
public final boolean is(BleDeviceState state)
```
    Returns whether the device is in the provided state.
    
    See Also:
    
    isAny(BleDeviceState...)
  - isAny
```
public final boolean isAny(int mask_BleDeviceState)
```
    Returns true if there is any bitwise overlap between the provided value and getStateMask().
    
    See Also:
    
    isAll(int)
  - isAll
```
public final boolean isAll(int mask_BleDeviceState)
```
    Returns true if there is complete bitwise overlap between the provided value and getStateMask().
    
    See Also:
    
    isAny(int)
  - is
```
public final boolean is(java.lang.Object... query)
```
    Similar to is(BleDeviceState) and isAny(BleDeviceState...) but allows you to give a simple query made up of BleDeviceState and Boolean pairs. So an example would be myDevice.is(BleDeviceState.BLE_CONNECTING, true, BleDeviceState.RECONNECTING_LONG_TERM, false).
  - getTimeInState
```
public final Interval getTimeInState(BleDeviceState state)
```
    If is(BleDeviceState) returns true for the given state (i.e. if the device is in the given state) then this method will (a) return the amount of time that the device has been in the state. Otherwise, this will (b) return the amount of time that the device was *previously* in that state. Otherwise, if the device has never been in the state, it will (c) return 0.0 seconds. Case (b) might be useful for example for checking how long you were connected for after becoming BleDeviceState.BLE_DISCONNECTED, for analytics purposes or whatever.
  - refreshGattDatabase
```
public final void refreshGattDatabase()
```
    Overload of refreshGattDatabase(Interval) which uses the default gatt refresh delay of BleDeviceConfig.DEFAULT_GATT_REFRESH_DELAY.
  - refreshGattDatabase
```
public final void refreshGattDatabase(Interval gattPause)
```
    This only applies to a device which is BleDeviceState.BLE_CONNECTED. This is meant to be used mainly after performing a firmware update, and the Gatt database has changed. This will clear the device's gatt cache, and perform discover services again. The device will drop out of BleDeviceState.SERVICES_DISCOVERED, and enter BleDeviceState.DISCOVERING_SERVICES. So, you can listen in your device's DeviceStateListener for when it enters BleDeviceState.SERVICES_DISCOVERED to know when the operation is complete.
  - setName
```
public final <any> setName(java.lang.String name)
```
    Same as setName(String, UUID) but will not attempt to propagate the name change to the remote device. Only getName_override() will be affected by this.
  - setName
```
public final <any> setName(java.lang.String name,
                           java.util.UUID characteristicUuid)
```
    Sets the local name of the device and also attempts a write(BleWrite) using the given UUID. Further calls to getName_override() will immediately reflect the name given here. Further calls to getName_native(), getName_debug() and getName_normalized() will only reflect the name given here if the write is successful. It is somewhat assumed that doing this write will cause the remote device to use the new name given here for its device information service Uuids.DEVICE_NAME. If BleDeviceConfig.saveNameChangesToDisk is true then this name will always be returned for getName_override(), even if you kill/restart the app.
  - clearName
```
public final void clearName()
```
    Clears any name previously provided through setName(String) or overloads.
  - getName_override
```
public final java.lang.String getName_override()
```
    By default returns the same value as getName_native(). If you call setName(String) (or overloads) then calling this will return the same string provided in that setter.
  - getName_native
```
public final java.lang.String getName_native()
```
    Returns the raw, unmodified device name retrieved from the stack. Equivalent to BluetoothDevice.getName(). It's suggested to use getName_normalized() if you're using the name to match/filter against something, e.g. an entry in a config file or for advertising filtering.
  - getName_normalized
```
public final java.lang.String getName_normalized()
```
    The name retrieved from getName_native() can change arbitrarily, like the last 4 of the MAC address can get appended sometimes, and spaces might get changed to underscores or vice-versa, caps to lowercase, etc. This may somehow be standard, to-the-spec behavior but to the newcomer it's confusing and potentially time-bomb-bug-inducing, like if you're using device name as a filter for something and everything's working until one day your app is suddenly broken and you don't know why. This method is an attempt to normalize name behavior and always return the same name regardless of the underlying stack's whimsy. The target format is all lowercase and underscore-delimited with no trailing MAC address.
  - getName_debug
```
public final java.lang.String getName_debug()
```
    Returns a name useful for logging and debugging. As of this writing it is getName_normalized() plus the last four digits of the device's MAC address from getMacAddress(). BleDevice.toString() uses this.
  - getNative
```
public final android.bluetooth.BluetoothDevice getNative()
```
    Provides just-in-case lower-level access to the native device instance.
    
    WARNING: Be careful with this. It generally should not be needed. Only invoke "mutators" of this object in times of extreme need.
    
    NOTE: If you are forced to use this please contact library developers to discuss possible feature addition or report bugs.
  - getNativeGatt
```
public final android.bluetooth.BluetoothGatt getNativeGatt()
```
    See pertinent warning for getNative(). Generally speaking, this will return null if the BleDevice is BleDeviceState.BLE_DISCONNECTED.
    
    NOTE: If you are forced to use this please contact library developers to discuss possible feature addition or report bugs.
  - getMacAddress
```
public final java.lang.String getMacAddress()
```
    Returns the MAC address of this device, as retrieved from the native stack or provided through RxBleManager.newDevice(String) (or overloads thereof). You may treat this as the unique ID of the device, suitable as a key in a HashMap, SharedPreferences, etc.
  - disconnect
```
public final boolean disconnect()
```
    Disconnects from a connected device or does nothing if already BleDeviceState.BLE_DISCONNECTED. You can call this at any point during the connection process as a whole, during reads and writes, during transactions, whenever, and the device will cleanly cancel all ongoing operations. This method will also bring the device out of the BleDeviceState.RECONNECTING_LONG_TERM state.
    
    Returns:
    
    true if this call "had an effect", such as if the device was previously BleDeviceState.RECONNECTING_LONG_TERM, BleDeviceState.CONNECTING_OVERALL, or BleDeviceState.INITIALIZED
    
    See Also:
    
    DeviceReconnectFilter.Status.EXPLICIT_DISCONNECT
  - disconnectWhenReady
```
public final boolean disconnectWhenReady()
```
    Similar to disconnect() with the difference being the disconnect task is set to a low priority. This allows all current calls to finish executing before finally disconnecting. Note that this can cause issues if you keep executing reads/writes, as they have a higher priority.
    
    Returns:
    
    true if this call "had an effect", such as if the device was previously BleDeviceState.RECONNECTING_LONG_TERM, BleDeviceState.CONNECTING_OVERALL, or BleDeviceState.INITIALIZED
    
    See Also:
    
    DeviceReconnectFilter.Status.EXPLICIT_DISCONNECT
  - disconnect_remote
```
public final boolean disconnect_remote()
```
    Same as disconnect() but this call roughly simulates the disconnect as if it's because of the remote device going down, going out of range, etc. For example getLastDisconnectIntent() will be State.ChangeIntent.UNINTENTIONAL instead of State.ChangeIntent.INTENTIONAL.
    
    If the device is currently BleDeviceState.CONNECTING_OVERALL then your ReconnectFilter.onConnectFailed(ReconnectFilter.ConnectFailEvent) implementation will be called with DeviceReconnectFilter.Status.ROGUE_DISCONNECT.
    
    NOTE: One major difference between this and an actual remote disconnect is that this will not cause the device to enter BleDeviceState.RECONNECTING_SHORT_TERM or BleDeviceState.RECONNECTING_LONG_TERM.
  - undiscover
```
public final boolean undiscover()
```
    Convenience method that calls RxBleManager.undiscover(RxBleDevice).
    
    Returns:
    
    true if the device was successfully BleDeviceState.UNDISCOVERED, false if BleDevice isn't known to the BleManager.
    
    See Also:
    
    BleManager.undiscover(BleDevice)
  - clearSharedPreferences
```
public final void clearSharedPreferences()
```
    Convenience forwarding of RxBleManager.clearSharedPreferences(String).
    
    See Also:
    
    RxBleManager.clearSharedPreferences(RxBleDevice)
  - equals
```
public final boolean equals(RxBleDevice device_nullable)
```
    First checks referential equality and if false checks equality of getMacAddress(). Note that ideally this method isn't useful to you and never returns true (besides the identity case, which isn't useful to you). Otherwise it probably means your app is holding on to old references that have been undiscovered, and this may be a bug or bad design decision in your code. This library will (well, should) never hold references to two devices such that this method returns true for them.
  - equals
```
public final boolean equals(java.lang.Object object_nullable)
```
    Returns equals(RxBleDevice) if object is an instance of RxBleDevice. Otherwise calls super.
    
    Overrides:
    
    equals in class java.lang.Object
    
    See Also:
    
    equals(RxBleDevice)
  - startPoll
```
public final <any> startPoll(java.util.UUID characteristicUuid,
                             Interval interval)
```
  - startPoll
```
public final <any> startPoll(java.util.UUID serviceUuid,
                             java.util.UUID characteristicUuid,
                             Interval interval)
```
  - startPoll
```
public final <any> startPoll(java.util.UUID[] uuids,
                             Interval interval)
```
  - startPoll
```
public final <any> startPoll(java.lang.Iterable<java.util.UUID> uuids,
                             Interval interval)
```
  - startPoll
```
public final <any> startPoll(java.util.UUID serviceUuid,
                             java.util.UUID characteristicUuid,
                             DescriptorFilter descriptorFilter,
                             Interval interval)
```
    Starts a periodic read of a particular characteristic. Use this wherever you can in place of enableNotify(BleNotify). One use case would be to periodically read wind speed from a weather device. You *could* develop your device firmware to send notifications to the app only when the wind speed changes, but Android has observed stability issues with notifications, so use them only when needed.
    
    TIP: You can call this method when the device is in any BleDeviceState, even BleDeviceState.BLE_DISCONNECTED. However, you will not receive any events until the device is connected.
    
    See Also:
    
    startChangeTrackingPoll(UUID, Interval), enableNotify(BleNotify)
  - startChangeTrackingPoll
```
public final <any> startChangeTrackingPoll(java.util.UUID characteristicUuid,
                                           Interval interval)
```
  - startChangeTrackingPoll
```
public final <any> startChangeTrackingPoll(java.util.UUID serviceUuid,
                                           java.util.UUID characteristicUuid,
                                           Interval interval)
```
  - startChangeTrackingPoll
```
public final <any> startChangeTrackingPoll(java.util.UUID serviceUuid,
                                           java.util.UUID characteristicUuid,
                                           DescriptorFilter descriptorFilter,
                                           Interval interval)
```
    Similar to startPoll(UUID, Interval) but only invokes a callback when a change in the characteristic value is detected. Use this in preference to enableNotify(BleNotify) if possible, due to instability issues (rare, but still) with notifications on Android.
    
    TIP: You can call this method when the device is in any BleDeviceState, even BleDeviceState.BLE_DISCONNECTED. However, you will not receive any events until the device is connected.
  - connect
```
public Completable connect()
```
    Connect to this BLE device.
    Returns a Completable which holds nothing. CompletableEmitter#onComplete() will be called when connected, otherwise a ConnectException will be returned in CompletableEmitter#onError(Throwable), which contains the DeviceReconnectFilter.ConnectFailEvent. The onError method will only be called when SweetBlue has run through all retries -- set via DeviceReconnectFilter.
    
    See Also:
    
    connect(RxBleTransaction.RxAuth, RxBleTransaction.RxInit), connect_withRetries()
  - connect
```
public Completable connect(RxBleTransaction.RxAuth authTxn,
                           RxBleTransaction.RxInit initTxn)
```
    Similar to connect(), only this method allows you to pass in RxBleTransaction.RxAuth, and RxBleTransaction.RxInit instances for this specific device -- instead of using BleDeviceConfig.defaultAuthFactory, or BleDeviceConfig.defaultInitFactory.
    
    See Also:
    
    connect(), connect(RxBleTransaction.RxAuth), connect(RxBleTransaction.RxInit)
  - connect
```
public Completable connect(RxBleTransaction.RxAuth authTxn)
```
    Overload of connect(RxBleTransaction.RxAuth, RxBleTransaction.RxInit). This will use BleDeviceConfig.defaultInitFactory for the init transaction, if one has been set. If you don't want this behavior, then call connect(RxBleTransaction.RxAuth, RxBleTransaction.RxInit), and pass in null for the init transaction.
    
    See Also:
    
    connect(RxBleTransaction.RxAuth, RxBleTransaction.RxInit), connect()
  - connect
```
public Completable connect(RxBleTransaction.RxInit initTxn)
```
    Overload of connect(RxBleTransaction.RxAuth, RxBleTransaction.RxInit). This will use BleDeviceConfig.defaultAuthFactory for the auth transaction, if one has been set. If you don't want this behavior, then call connect(RxBleTransaction.RxAuth, RxBleTransaction.RxInit), and pass in null for the auth transaction.
    
    See Also:
    
    connect(RxBleTransaction.RxAuth, RxBleTransaction.RxInit), connect()
  - connect_withRetries
```
public <any> connect_withRetries()
```
    Similar to connect(), only the ObservableEmitter#onNext(Object) method can get called multiple times depending on what logic is implemented in BleDeviceConfig.reconnectFilter. ObservableEmitter#onError(Throwable) will be called on the last failed connection attempt (ie the library has tried all retries, and will no longer be attempting to connect). It's best not to use this method, and to use connect() instead.
    
    See Also:
    
    connect(), RxConnectEvent.wasSuccess(), RxConnectEvent.isRetrying()
  - connect_withRetries
```
public <any> connect_withRetries(RxBleTransaction.RxAuth authTxn,
                                 RxBleTransaction.RxInit initTxn)
```
    Similar to connect_withRetries(), only this method allows you to pass in RxBleTransaction.RxAuth, and RxBleTransaction.RxInit instances for this specific device -- instead of using BleDeviceConfig.defaultAuthFactory, or BleDeviceConfig.defaultInitFactory.
    
    See Also:
    
    connect_withRetries(), connect_withRetries(RxBleTransaction.RxAuth), connect_withRetries(RxBleTransaction.RxInit)
  - connect_withRetries
```
public <any> connect_withRetries(RxBleTransaction.RxAuth authTxn)
```
    Overload of connect_withRetries(RxBleTransaction.RxAuth, RxBleTransaction.RxInit). This will use BleDeviceConfig.defaultInitFactory for the init transaction, if one has been set. If you don't want this behavior, then call connect_withRetries(RxBleTransaction.RxAuth), and pass in null for the init transaction.
    
    See Also:
    
    connect_withRetries(RxBleTransaction.RxAuth, RxBleTransaction.RxInit), connect_withRetries()
  - connect_withRetries
```
public <any> connect_withRetries(RxBleTransaction.RxInit initTxn)
```
    Overload of connect_withRetries(RxBleTransaction.RxAuth, RxBleTransaction.RxInit). This will use BleDeviceConfig.defaultAuthFactory for the auth transaction, if one has been set. If you don't want this behavior, then call connect(RxBleTransaction.RxAuth, RxBleTransaction.RxInit), and pass in null for the auth transaction.
    
    See Also:
    
    connect_withRetries(RxBleTransaction.RxAuth, RxBleTransaction.RxInit), connect_withRetries(), connect_withRetries(RxBleTransaction.RxAuth)
  - bond
```
public <any> bond()
```
    Bonds this device.
    Returns a Single which holds an instance of BondListener.BondEvent. If the bond fails, SingleEmitter#onError(Throwable) will be called which holds an instance of BondException, which also holds an instance of BondListener.BondEvent, so you can get more information on what went wrong.
  - unbond
```
public void unbond()
```
    Forwards BleDevice.unbond().
  - read
```
public <any> read(BleRead read)
```
    Perform a BLE read on this device.
    Returns a Single which holds an instance of ReadWriteListener.ReadWriteEvent. If the bond fails, SingleEmitter#onError(Throwable) will be called which holds an instance of ReadWriteException, which also holds an instance of ReadWriteListener.ReadWriteEvent, so you can get more information on what went wrong.
  - readMany
```
public final <any> readMany(BleRead[] bleReads)
```
    Overload for read(BleRead) for many writes. This calls Observable#merge(Iterable) after calling Single#toObservable() to merge all Singles into one Observable.
  - readMany
```
public final <any> readMany(java.lang.Iterable<BleRead> bleReads)
```
    Overload for read(BleRead) for many writes. This calls Observable#mergeWith(ObservableSource) after calling Single#toObservable() to merge all Singles into one Observable.
  - read
```
public final <any> read(BleDescriptorRead read)
```
  - write
```
public <any> write(BleWrite write)
```
    Performs a BLE write on this device.
    Returns a Single which holds an instance of ReadWriteListener.ReadWriteEvent. If the bond fails, SingleEmitter#onError(Throwable) will be called which holds an instance of ReadWriteException, which also holds an instance of ReadWriteListener.ReadWriteEvent, so you can get more information on what went wrong.
  - writeMany
```
public final <any> writeMany(BleWrite[] writes)
```
    Overload for write(BleWrite) for many writes. This calls Observable#mergeWith(ObservableSource) after calling Single#toObservable() to merge all Singles into one Observable.
  - writeMany
```
public final <any> writeMany(java.lang.Iterable<BleWrite> writes)
```
    Overload for write(BleWrite) for many writes. This calls Observable#mergeWith(ObservableSource) after calling Single#toObservable() to merge all Singles into one Observable.
  - write
```
public final <any> write(BleDescriptorWrite write)
```
  - enableNotify
```
public <any> enableNotify(BleNotify notify)
```
    Enable notifications for a characteristic on this BLE device.
    Returns a Single which holds an instance of NotificationListener.NotificationEvent. If the bond fails, SingleEmitter#onError(Throwable) will be called which holds an instance of NotifyEnableException, which also holds an instance of NotificationListener.NotificationEvent, so you can get more information on what went wrong.
  - enableNotifies
```
public <any> enableNotifies(java.util.List<BleNotify> notifies)
```
  - disableNotify
```
public <any> disableNotify(BleNotify notify)
```
    Disable notifications for a characteristic on this BLE device.
    Returns a Single which holds an instance of NotificationListener.NotificationEvent. If the bond fails, SingleEmitter#onError(Throwable) will be called which holds an instance of NotifyEnableException, which also holds an instance of NotificationListener.NotificationEvent, so you can get more information on what went wrong.
  - disableNotifies
```
public <any> disableNotifies(java.util.List<BleNotify> notifies)
```
  - readRssi
```
public final <any> readRssi()
```
    Wrapper for BluetoothGatt.readRemoteRssi(). This will eventually update the value returned by getRssi() but it is not instantaneous. When a new RSSI is actually received the given listener will be called. The device must be BleDeviceState.BLE_CONNECTED for this call to succeed. When the device is not BleDeviceState.BLE_CONNECTED then the value returned by getRssi() will be automatically updated every time this device is discovered (or rediscovered) by a scan operation.
  - setConnectionPriority
```
public final <any> setConnectionPriority(BleConnectionPriority priority)
```
    Wrapper for BluetoothGatt.requestConnectionPriority(int) which attempts to change the connection priority for a given connection. This will eventually update the value returned by getConnectionPriority() but it is not instantaneous. When we receive confirmation from the native stack then this value will be updated. The device must be BleDeviceState.BLE_CONNECTED for this call to succeed.
    
    See Also:
    
    getConnectionPriority()
  - getConnectionPriority
```
public final BleConnectionPriority getConnectionPriority()
```
    Returns the connection priority value set by setConnectionPriority(BleConnectionPriority), or BleNodeConfig.DEFAULT_MTU_SIZE if it was never set explicitly.
  - getMtu
```
public final int getMtu()
```
    Returns the "maximum transmission unit" value set by negotiateMtu(int), or BleNodeConfig.DEFAULT_MTU_SIZE if it was never set explicitly.
  - negotiateMtuToDefault
```
public final <any> negotiateMtuToDefault()
```
    Overload of negotiateMtu(int) that returns the "maximum transmission unit" to the default. Unlike negotiateMtu(int), this can be called when the device is BleDeviceState.BLE_DISCONNECTED in the event that you don't want the MTU to be auto-set upon next reconnection.
  - negotiateMtu
```
public final <any> negotiateMtu(int mtu)
```
    Wrapper for BluetoothGatt.requestMtu(int) which attempts to change the "maximum transmission unit" for a given connection. This will eventually update the value returned by getMtu() but it is not instantaneous. When we receive confirmation from the native stack then this value will be updated. The device must be BleDeviceState.BLE_CONNECTED for this call to succeed.
    NOTE 1: This will only work on devices running Android Lollipop (5.0) or higher. Otherwise it will be ignored. NOTE 2: Some phones will request an MTU, and accept a higher number, but will fail (time out) when writing a characteristic with a large payload. Namely, we've found the Moto Pure X, and the OnePlus OnePlus2 to have this behavior. For those phones any MTU above 50 failed.
  - setPhyOptions
```
public final <any> setPhyOptions(Phy phyOption)
```
    Use this method to manually set the bluetooth 5 physical layer to use a bluetooth 5 feature (high speed/long range). NOTE: This only works on Android Oreo and above, and not all devices on this OS have bluetooth 5 hardware.
    
    See Also:
    
    RxBleManager.isBluetooth5Supported(), RxBleManager.isBluetooth5HighSpeedSupported(), RxBleManager.isBluetooth5LongRangeSupported()
  - readPhyOptions
```
public final <any> readPhyOptions()
```
    Method to get the current "phy options" (physical layer), or current bluetooth 5 feature. This shouldn't need to be called, as SweetBlue caches this info for you, but it's here for flexibility, and just-in-case scenarios.
  - startRssiPoll
```
public final <any> startRssiPoll(Interval interval)
```
    Kicks off a poll that automatically calls readRssi() at the Interval frequency specified. This can be called before the device is actually BleDeviceState.BLE_CONNECTED. If you call this more than once in a row then the most recent call's parameters will be respected.
    
    TIP: You can call this method when the device is in any BleDeviceState, even BleDeviceState.BLE_DISCONNECTED, however, a scan must be running in order to receive any updates (and of course, the device must be found in the scan).
  - clearAllData
```
public final void clearAllData()
```
    One method to remove absolutely all "metadata" related to this device that is stored on disk and/or cached in memory in any way. This method is useful if for example you have a "forget device" feature in your app.
  - clearHistoricalData
```
public final void clearHistoricalData()
```
    Clears all HistoricalData tracked by this device.
    
    See Also:
    
    BleNodeConfig.HistoricalDataLogFilter, BleNodeConfig.DefaultHistoricalDataLogFilter
  - clearHistoricalData
```
public final void clearHistoricalData(long count)
```
    Clears the first count number of HistoricalData tracked by this device.
    
    See Also:
    
    BleNodeConfig.HistoricalDataLogFilter, BleNodeConfig.DefaultHistoricalDataLogFilter
  - clearHistoricalData
```
public final void clearHistoricalData(EpochTimeRange range)
```
    Clears all HistoricalData tracked by this device within the given range.
    
    See Also:
    
    BleNodeConfig.HistoricalDataLogFilter, BleNodeConfig.DefaultHistoricalDataLogFilter
  - clearHistoricalData
```
public final void clearHistoricalData(EpochTimeRange range,
                                      long count)
```
    Clears the first count number of HistoricalData tracked by this device within the given range.
    
    See Also:
    
    BleNodeConfig.HistoricalDataLogFilter, BleNodeConfig.DefaultHistoricalDataLogFilter
  - clearHistoricalData
```
public final void clearHistoricalData(java.util.UUID uuid)
```
    Clears all HistoricalData tracked by this device for a particular characteristic UUID.
    
    See Also:
    
    BleNodeConfig.HistoricalDataLogFilter, BleNodeConfig.DefaultHistoricalDataLogFilter
  - clearHistoricalData
```
public final void clearHistoricalData(java.util.UUID... uuids)
```
    Overload of clearHistoricalData(UUID) that just calls that method multiple times.
  - clearHistoricalData
```
public final void clearHistoricalData(java.util.UUID uuid,
                                      long count)
```
    Clears the first count number of HistoricalData tracked by this device for a particular characteristic UUID.
    
    See Also:
    
    BleNodeConfig.HistoricalDataLogFilter, BleNodeConfig.DefaultHistoricalDataLogFilter
  - clearHistoricalData
```
public final void clearHistoricalData(java.util.UUID uuid,
                                      EpochTimeRange range)
```
    Clears all HistoricalData tracked by this device for a particular characteristic UUID within the given range.
    
    See Also:
    
    BleNodeConfig.HistoricalDataLogFilter, BleNodeConfig.DefaultHistoricalDataLogFilter
  - clearHistoricalData
```
public final void clearHistoricalData(java.util.UUID uuid,
                                      EpochTimeRange range,
                                      long count)
```
    Clears the first count number of HistoricalData tracked by this device for a particular characteristic UUID within the given range.
    
    See Also:
    
    BleNodeConfig.HistoricalDataLogFilter, BleNodeConfig.DefaultHistoricalDataLogFilter
  - clearHistoricalData_memoryOnly
```
public final void clearHistoricalData_memoryOnly()
```
    Clears all HistoricalData tracked by this device.
    
    See Also:
    
    BleNodeConfig.HistoricalDataLogFilter, BleNodeConfig.DefaultHistoricalDataLogFilter
  - clearHistoricalData_memoryOnly
```
public final void clearHistoricalData_memoryOnly(long count)
```
    Clears the first count number of HistoricalData tracked by this device.
    
    See Also:
    
    BleNodeConfig.HistoricalDataLogFilter, BleNodeConfig.DefaultHistoricalDataLogFilter
  - clearHistoricalData_memoryOnly
```
public final void clearHistoricalData_memoryOnly(EpochTimeRange range)
```
    Clears all HistoricalData tracked by this device within the given range.
    
    See Also:
    
    BleNodeConfig.HistoricalDataLogFilter, BleNodeConfig.DefaultHistoricalDataLogFilter
  - clearHistoricalData_memoryOnly
```
public final void clearHistoricalData_memoryOnly(EpochTimeRange range,
                                                 long count)
```
    Clears the first count number of HistoricalData tracked by this device within the given range.
    
    See Also:
    
    BleNodeConfig.HistoricalDataLogFilter, BleNodeConfig.DefaultHistoricalDataLogFilter
  - clearHistoricalData_memoryOnly
```
public final void clearHistoricalData_memoryOnly(java.util.UUID uuid)
```
    Clears all HistoricalData tracked by this device for a particular characteristic UUID.
    
    See Also:
    
    BleNodeConfig.HistoricalDataLogFilter, BleNodeConfig.DefaultHistoricalDataLogFilter
  - clearHistoricalData_memoryOnly
```
public final void clearHistoricalData_memoryOnly(java.util.UUID uuid,
                                                 long count)
```
    Clears the first count number of HistoricalData tracked by this device for a particular characteristic UUID.
    
    See Also:
    
    BleNodeConfig.HistoricalDataLogFilter, BleNodeConfig.DefaultHistoricalDataLogFilter
  - clearHistoricalData_memoryOnly
```
public final void clearHistoricalData_memoryOnly(java.util.UUID characteristicUuid,
                                                 EpochTimeRange range)
```
    Clears all HistoricalData tracked by this device for a particular characteristic UUID within the given range.
    
    See Also:
    
    BleNodeConfig.HistoricalDataLogFilter, BleNodeConfig.DefaultHistoricalDataLogFilter
  - clearHistoricalData_memoryOnly
```
public final void clearHistoricalData_memoryOnly(java.util.UUID characteristicUuid,
                                                 EpochTimeRange range,
                                                 long count)
```
    Clears the first count number of HistoricalData tracked by this device for a particular characteristic UUID within the given range.
    
    See Also:
    
    BleNodeConfig.HistoricalDataLogFilter, BleNodeConfig.DefaultHistoricalDataLogFilter
  - isNotifyEnabled
```
public final boolean isNotifyEnabled(java.util.UUID uuid)
```
    Returns true if notifications are enabled for the given uuid. NOTE: isNotifyEnabling(UUID) may return true even if this method returns false.
    
    See Also:
    
    isNotifyEnabling(UUID)
  - isNotifyEnabling
```
public final boolean isNotifyEnabling(java.util.UUID uuid)
```
    Returns true if SweetBlue is in the process of enabling notifications for the given uuid.
    
    See Also:
    
    isNotifyEnabled(UUID)
  - performOta
```
public final boolean performOta(RxBleTransaction.RxOta txn)
```
    Kicks off an "over the air" long-term transaction if it's not already taking place and the device is BleDeviceState.INITIALIZED. This will put the device into the BleDeviceState.PERFORMING_OTA state if true is returned. You can use this to do firmware updates, file transfers, etc.
    
    TIP: Use the TimeEstimator class to let your users know roughly how much time it will take for the ota to complete.
    
    TIP: For shorter-running transactions consider using performTransaction(RxBleTransaction).
    
    Returns:
    
    true if OTA has started, otherwise false if device is either already BleDeviceState.PERFORMING_OTA or is not BleDeviceState.INITIALIZED.
    
    See Also:
    
    BleDeviceConfig.includeOtaReadWriteTimesInAverage, BleManagerConfig.autoScanDuringOta, performTransaction(RxBleTransaction)
  - performTransaction
```
public final boolean performTransaction(RxBleTransaction txn)
```
    Allows you to perform an arbitrary transaction that is not associated with any BleDeviceState like BleDeviceState.PERFORMING_OTA, BleDeviceState.AUTHENTICATING or BleDeviceState.INITIALIZING. Generally this transaction should be short, several reads and writes. For longer-term transaction consider using performOta(RxBleTransaction.RxOta).
    
    The device must be BleDeviceState.INITIALIZED.
    
    TIP: For long-term transactions consider using performOta(RxBleTransaction.RxOta).
    
    Returns:
    
    true if the transaction successfully started, false otherwise if device is not BleDeviceState.INITIALIZED.
  - getEffectiveWriteMtuSize
```
public final int getEffectiveWriteMtuSize()
```
    Returns the effective MTU size for a write. BLE has an overhead when reading and writing, so that eats out of the MTU size. The write overhead is defined via BleNodeConfig.GATT_WRITE_MTU_OVERHEAD. The method simply returns the MTU size minus the overhead. This is just used internally, but is exposed in case it's needed for some other use app-side.
  - isNull
```
public boolean isNull()
```
    As you should never get an instance of this class which is null, use this method to see if the device is considered to be null or not.
  - getBleDevice
```
public BleDevice getBleDevice()
```
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class java.lang.Object
  - toString
```
public java.lang.String toString()
```
    Overrides:
    
    toString in class java.lang.Object

Class RxBleDevice

Method Summary

Methods inherited from class java.lang.Object

Method Detail

observeStateEvents

observeNotifyEvents

observeBondEvents

observeReadWriteEvents

observeHistoricalDataLoadEvents

setListener_Reconnect

pushListener_Reconnect

popListener_Reconnect

reliableWrite_begin

reliableWrite_abort

reliableWrite_execute

printState

setConfig

getConfig

getOrigin

getLastDiscoveryTime

getLastDisconnectIntent

getConnectionRetryCount

getStateMask

getNativeStateMask

getAverageReadTime

getAverageWriteTime

getRssi

getRssiPercent

getDistance

getTxPower

getManufacturerData

getManufacturerId

getScanRecord

getScanInfo

getAdvertisingFlags

loadHistoricalData

loadHistoricalData

isHistoricalDataLoading

isHistoricalDataLoading

isHistoricalDataLoaded

isHistoricalDataLoaded

getHistoricalData_latest

getHistoricalData

getHistoricalData

getHistoricalData_atOffset

getHistoricalData_atOffset

getHistoricalDataCount

getHistoricalDataCount

hasHistoricalData

hasHistoricalData

hasHistoricalData

hasHistoricalData

hasHistoricalData

addHistoricalData

addHistoricalData

addHistoricalData

addHistoricalData

addHistoricalData

addHistoricalData

addHistoricalData

isAny

isAll

isConnectable

is

isAny

isAll

is

getTimeInState

refreshGattDatabase

refreshGattDatabase

setName

setName

clearName

getName_override

getName_native

getName_normalized

getName_debug

getNative

getNativeGatt

getMacAddress