Android library monitoring hardware sensors with RxJava.
| Current Branch | Branch | Artifact Id | Maven Central |
|---|---|---|---|
RxJava1.x |
reactivesensors |
 |
|
RxJava2.x |
reactivesensors-rx2 |
 |
|
| ☑️ | RxJava3.x |
reactivesensors-rx3 |
 |
- Usage
- Example
- Good practices
- Download
- Tests
- Code style
- Static code analysis
- Releasing
- References
- License
Code sample below demonstrates how to observe Gyroscope sensor.
Please note that we are filtering events occurring when sensor readings change with ReactiveSensorEvent::sensorChanged method. There's also event describing change of sensor's accuracy, which can be filtered with ReactiveSensorEvent::accuracyChanged method. When we don't apply any filter, we will be notified both about sensor readings and accuracy changes.
new ReactiveSensors(context).observeSensor(Sensor.TYPE_GYROSCOPE)
.subscribeOn(Schedulers.computation())
.filter(ReactiveSensorEvent::sensorChanged)
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Consumer<ReactiveSensorEvent>() {
@Override public void call(ReactiveSensorEvent event) {
float x = event.sensorValues()[0];
float y = event.sensorValues()[1];
float z = event.sensorValues()[2];
String message = String.format("x = %f, y = %f, z = %f", x, y, z);
Log.d("gyroscope readings", message);
}
});
}We can observe any hardware sensor in the same way. You can check list of all sensors in official Android documentation. To get list of all sensors available on the current device, you can use getSensors() method available in ReactiveSensors class.
Default sampling period for Flowable below is set to SensorManager.SENSOR_DELAY_NORMAL.
Flowable<ReactiveSensorEvent> observeSensor(int sensorType)We can configure sampling period according to our needs with the following flowable:
Flowable<ReactiveSensorEvent> observeSensor(final int sensorType, final int samplingPeriodInUs)We can use predefined values available in SensorManager class from Android SDK:
int SENSOR_DELAY_FASTEST- get sensor data as fast as possibleint SENSOR_DELAY_GAME- rate suitable for gamesint SENSOR_DELAY_NORMAL- rate (default) suitable for screen orientation changesint SENSOR_DELAY_UI- rate suitable for the user interface
We can also define our own integer value in microseconds, but it's recommended to use predefined values.
We can customize RxJava Backpressure Strategy for our flowable with method:
Flowable<ReactiveSensorEvent> observeSensor(final int sensorType, final int samplingPeriodInUs,
final BackpressureStrategy strategy)Default Backpressure Strategy is BUFFER.
Exemplary application, which gets readings of various sensors is located in app directory of this repository. You can easily change SENSOR_TYPE variable to read values from a different sensor in a given samples.
We should check whether device has concrete sensor before we start observing it.
We can do it in the following way:
if (reactiveSensors.hasSensor(SENSOR_TYPE)) {
// observe sensor
} else {
// show error message
}We can let our subscription crash and handle situation when device does not have given sensor e.g. in the Consumer<Throwable>() implementation (if we want to return Disposable) or in the onError(throwable) method implementation of the Subscriber. Other types of errors can be handled there as well.
new ReactiveSensors(context).observeSensor(Sensor.TYPE_GYROSCOPE)
.subscribeOn(Schedulers.computation())
.filter(ReactiveSensorEvent::sensorChanged)
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Consumer<ReactiveSensorEvent>() {
@Override public void accept(ReactiveSensorEvent reactiveSensorEvent) throws Exception {
// handle reactiveSensorEvent
}
}, new Consumer<Throwable>() {
@Override public void accept(Throwable throwable) throws Exception {
if (throwable instanceof SensorNotFoundException) {
textViewForMessage.setText("Sorry, your device doesn't have required sensor.");
}
}
});When we are using Disposables in Activity, we should subscribe them in onResume() method and dispose them in onPause() method.
When we want to receive only sensor updates, we should use ReactiveSensorEvent::sensorChanged method in filter(...) method from RxJava.
When we want to receive only accuracy updates, we should use ReactiveSensorEvent::accuracyChanged method in filter(...) method from RxJava.
If we don't apply any filter, we will receive both accuracy and sensor readings updates.
ReactiveSensors class implements SensorsProxy interface. It allows you to create stubs or mocks for testing behavior of the sensors in your application without need of mocking SensorManager class from Android SDK accessing hardware components. Once you instantiate SensorsProxy, then you'll be allowed to mock or stub it pretty easily. Moreover, you can mock ReactiveSensorEvent, which wraps code from Android API, expose appropriate methods and does not force you to use native code accessing hardware sensors in tests, so you can foucus just on the application logic.
See also Best Practices for Accessing and Using Sensors.
latest version:
replace x.y.z with the latest version
You can depend on the library through Maven:
<dependency>
<groupId>com.github.pwittchen</groupId>
<artifactId>reactivesensors-rx3</artifactId>
<version>x.y.z</version>
</dependency>or through Gradle:
dependencies {
compile 'com.github.pwittchen:reactivesensors-rx3:x.y.z'
}Tests are available in library/src/androidTest/java/ directory and can be executed on emulator or Android device from Android Studio or CLI with the following command:
./gradlew connectedCheck
Code style used in the project is called SquareAndroid from Java Code Styles repository by Square available at: https://github.com/square/java-code-styles. Currently, library doesn't have checkstyle verification attached. It can be done in the future.
Static code analysis runs Checkstyle, FindBugs, PMD and Lint. It can be executed with command:
./gradlew check
Reports from analysis are generated in library/build/reports/ directory.
See RELEASING.md file.
Copyright 2015 Piotr Wittchen
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
![dependabot-preview[bot] avatar](https://avatars.githubusercontent.com/in/2141?v=4 "dependabot-preview[bot]")
React
Typescript
Django
Laravel
Facebook
Microsoft
Google
Alibaba
D3
Tencent