Master Android Sensors with Jetpack Compose

Chapter 1: The Android Sensor Ecosystem Chapter Project: PhoneCheckup — Device Health Diagnostic By the end of this chapter, you will build PhoneCheckup — an app that discovers all available sensors on any Android device, runs interactive diagnostic tests, and generates a health report card. People use this app when buying or selling used phones, or when troubleshooting device issues. 1.1 Why Sensors Matter in Modern Android Apps Pick up your phone and tilt it. The screen rotates. Walk down the street and your fitness app counts every step. Open your banking app and your fingerprint unlocks it. Point your camera at a QR code on a restaurant table and the menu appears. Every single one of these interactions is powered by sensors. Sensors are the bridge between the physical world and the digital experience on your phone. Without them, a smartphone is just a small computer with a touchscreen. With them, it becomes a context-aware device that understands where it is, how it's moving, what it's seeing, and who is holding it. Yet most Android developers never go beyond basic sensor usage. They might use the camera or check location, but the full spectrum of sensors — accelerometers, gyroscopes, magnetometers, barometers, proximity detectors, light meters, step counters, and biometric readers — remains largely untapped in most applications. Read More https://leanpub.com/master_android_sensors This book changes that. Across 15 chapters, you will master every category of sensor available on Android, and you will do it by building real apps that solve real problems. Not toy demos. Not academic exercises. Apps that people download and use every day. The Shift to Context-Aware Applications Traditional mobile apps are reactive — they wait for the user to tap, type, or swipe. Sensor-driven apps are proactive. They understand context and respond to the physical world: Fitness apps count steps, detect activity type, and measure heart rate without the user pressing a single button. Navigation apps know which direction you're facing and adjust the map accordingly. Smart home apps detect when you leave your house (geofencing) and turn off the lights. Accessibility apps use proximity sensors to let visually impaired users interact through gestures. Gaming apps turn the phone into a steering wheel, a sword, or a magic wand using motion sensors. The opportunity for developers who understand sensors is enormous. Most apps in the Play Store still treat the phone as a flat rectangle. The apps that stand out — the ones users love and recommend — are the ones that feel alive, aware, and intelligent. That intelligence comes from sensors. What You Will Build in This Book Every chapter in this book pairs sensor knowledge with a practical, daily-life project: Chapter Sensor Focus Project Real Problem Solved 1 Sensor Framework PhoneCheckup Test a used phone's sensors 2 Accelerometer & Gyroscope DriveSafe Monitor driving behavior 3 Magnetometer & Orientation ProCompass Qibla direction + compass 4 Light, Pressure, Temperature SleepComfort Bedroom sleep monitor 5 Proximity Sensor SmartEtiquette Auto-silence phone 6 Step Counter WalkMate Daily walking companion 7 GPS & Geofencing ParkPin Find your parked car 8 Camera (CameraX) DocPocket Document & QR scanner 9 Microphone BabySentry Baby cry monitor 10 Biometric Sensors AppLock Lock apps with fingerprint 11 Health Sensors MorningVitals Daily health dashboard 12 Sensor Fusion FallGuard Fall detection for elderly 13 Data Visualization MyDay Auto daily activity journal 14 XR & Foldable Sensors FlexMode Smart foldable layouts 15 Testing & Benchmarking SensorBench Developer testing toolkit Let's start by understanding how the Android sensor system works under the hood. 1.2 Android Sensor Framework Architecture The Android Sensor Framework is the system-level infrastructure that lets your app communicate with hardware sensors. Understanding its architecture is essential before writing a single line of sensor code — it explains why certain things work the way they do, and helps you avoid common pitfalls. The Big Picture: From Hardware to Your App When a sensor detects a change in the physical world, the data travels through several layers before reaching your Kotlin code: Physical World (motion, light, magnetic field, etc.) ↓ Hardware Sensor (MEMS chip on the phone's circuit board) ↓ Sensor HAL (Hardware Abstraction Layer — vendor-specific driver) ↓ SensorService (Native C++ system service in Android OS) ↓ SensorManager (Java/Kotlin system service your app talks to) ↓ SensorEventListener (Your callback — where you receive data) ↓ Compose State (StateFlow / mutableStateOf — drives your UI) Let's examine each layer. Hardware Sensors Modern Android phones contain a variety of MEMS (Micro-Electro-Mechanical Systems) chips. These are tiny mechanical structures etched onto silicon that physically respond to forces like acceleration, rotation, magnetic fields, and pressure. A typical flagship phone in 2025 includes: An accelerometer + gyroscope combo chip (e.g., Bosch BMI260) A magnetometer (e.g., AKM AK09918) A barometric pressure sensor (e.g., Bosch BMP380) A proximity sensor (typically infrared) An ambient light sensor A fingerprint sensor (under-display ultrasonic or optical) Budget phones may have fewer sensors. Some phones lack a gyroscope, barometer, or magnetometer entirely. This is why sensor availability checking is critical — and exactly what our PhoneCheckup project will do. Sensor HAL (Hardware Abstraction Layer) The HAL is a vendor-specific layer that translates raw hardware signals into standardized data formats. Samsung, Google, Xiaomi, and other manufacturers each implement their own HAL for their specific sensor chips. This is why the same sensor type might behave slightly differently across devices — different noise characteristics, different sampling rates, different accuracy. As app developers, we never interact with the HAL directly. But understanding that it exists explains why you might see different sensor behavior on a Pixel vs. a Samsung Galaxy. SensorManager: Your Gateway to Sensors SensorManager is the system service that your app uses to interact with sensors. You obtain it through the standard Android system service mechanism: val sensorManager = context.getSystemService(Context.SENSOR_SERVICE) as SensorManager SensorManager provides three essential capabilities: Discovery — Find out which sensors are available on the device Registration — Subscribe to sensor data updates Utility — Helper functions for orientation computation, altitude calculation, etc. The SensorEvent Lifecycle Working with sensors follows a consistent lifecycle pattern: // 1. Get the SensorManager val sensorManager = context.getSystemService(Context.SENSOR_SERVICE) as SensorManager // 2. Get a specific sensor (returns null if not available) val accelerometer = sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER) // 3. Create a listener val listener = object : SensorEventListener { override fun onSensorChanged(event: SensorEvent) { // 4. Receive data — this is called at high frequency val x = event.values[0] val y = event.values[1] val z = event.values[2] } override fun onAccuracyChanged(sensor: Sensor, accuracy: Int) { // Called when sensor accuracy changes } } // 5. Register the listener (start receiving data) sensorManager.registerListener(listener, accelerometer, SensorManager.SENSOR_DELAY_UI) // 6. Unregister when done (CRITICAL — prevents battery drain and memory leaks) sensorManager.unregisterListener(listener) The registerListener call takes a delay parameter that suggests how frequently you want updates: Constant Approximate Delay Use Case SENSOR_DELAY_FASTEST 0 ms (as fast as possible) Scientific data collection SENSOR_DELAY_GAME 20 ms (~50 Hz) Games, AR SENSOR_DELAY_UI 60 ms (~16 Hz) UI animations SENSOR_DELAY_NORMAL 200 ms (~5 Hz) Screen rotation, casual monitoring Important: These are suggestions, not guarantees. The actual delivery rate depends on the hardware, HAL implementation, and system load. In Chapter 15, we'll build SensorBench to measure actual vs. requested rates on your device. The SensorEvent Object Every sensor callback delivers a SensorEvent object containing: event.sensor // The Sensor object that generated this event event.values // FloatArray of sensor readings (size depends on sensor type) event.accuracy // Accuracy level (UNRELIABLE, LOW, MEDIUM, HIGH) event.timestamp // Nanoseconds since boot (NOT wall clock time) The values array is the most important field. Its size and meaning depend on the sensor type: Sensor Type values[0] values[1] values[2] Unit Accelerometer x-axis y-axis z-axis m/s² Gyroscope x rotation y rotation z rotation rad/s Magnetometer x-axis y-axis z-axis μT Light lux level — — lux Proximity distance — — cm Pressure atmospheric — — hPa Step Counter cumulative steps — — steps 1.3 Sensor Categories Overview Android organizes sensors into three broad categories. Understanding these categories helps you choose the right sensor for your app and understand the characteristics of each. Motion Sensors Motion sensors measure acceleration forces and rotational forces along three axes. They are the most commonly used sensor family. TYPE_ACCELEROMETER — Measures acceleration force in m/s² applied to the device on all three physical axes (x, y, z), including the force of gravity. When the phone lies flat on a table, values read approximately (0, 0, 9.81) because gravity pulls along the z-axis. TYPE_LINEAR_ACCELERATION — Same as accelerometer but with gravity removed. This is a software sensor (also called a virtual or composite sensor) that the platform computes by subtracting gravity from the accelerometer reading. Useful when you want to detect user-initiated movement without the constant gravity component. TYPE_GRAVITY — Reports just the gravity vector. Combined with LINEAR_ACCELERATION, it equals the raw ACCELEROMETER reading. This is also a software sensor. TYPE_GYROSCOPE — Measures the rate of rotation in rad/s around each axis. Essential for detecting twists, turns, and rotational movements. Used heavily in gaming, AR, and motion tracking. TYPE_GYROSCOPE_UNCALIBRATED — Raw gyroscope data without bias compensation. Includes estimated drift values. Useful when you need to apply your own calibration or fusion algorithm. TYPE_STEP_COUNTER — Counts the total number of steps taken since the last device reboot. This is a hardware sensor on most modern phones, meaning it continues counting even when your app is not running. The count resets on reboot. TYPE_STEP_DETECTOR — Fires an event each time the user takes a step. Unlike STEP_COUNTER, this gives you individual step events with timestamps. TYPE_SIGNIFICANT_MOTION — A trigger sensor that fires once when the device detects significant motion (like the user starting to walk). This is a special one-shot sensor designed for power-efficient wake-up scenarios. Environmental Sensors Environmental sensors measure properties of the physical environment around the device. TYPE_LIGHT — Measures ambient light level in lux. The system uses this for auto-brightness. Your app can use it for adaptive UI themes or, as we'll do in Chapter 4, monitoring bedroom darkness for sleep quality. TYPE_PRESSURE — Measures atmospheric pressure in hPa (hectopascals). Used for altitude estimation, weather prediction, and detecting floor changes in buildings. Not available on all devices. TYPE_AMBIENT_TEMPERATURE — Measures room temperature in degrees Celsius. Rare on phones — mostly found on specialized devices. TYPE_RELATIVE_HUMIDITY — Measures ambient relative humidity as a percentage. Even rarer than the temperature sensor. Position Sensors Position sensors determine the device's physical position in the world. TYPE_MAGNETIC_FIELD — Measures the geomagnetic field strength in μT (microteslas) along three axes. Essential for compass applications. Combined with the accelerometer, it provides full device orientation. TYPE_MAGNETIC_FIELD_UNCALIBRATED — Raw magnetic field data without hard iron calibration. Includes estimated calibration values. TYPE_PROXIMITY — Measures the distance of an object from the device screen, typically in centimeters. Most implementations are binary — they report only "near" (0 cm) or "far" (maximum range, usually 5 cm). Used by the system to turn off the screen during calls. TYPE_ROTATION_VECTOR — A software sensor that provides the device's orientation as a quaternion. This is the platform's built-in sensor fusion, combining accelerometer, gyroscope, and magnetometer data for stable, drift-free orientation. We'll explore this deeply in Chapter 12. TYPE_GAME_ROTATION_VECTOR — Like ROTATION_VECTOR but without the magnetometer. Faster and more responsive, but subject to yaw drift over time. Ideal for games where relative rotation matters more than absolute compass bearing. Deprecated and Removed Sensors Be aware of sensors that should no longer be used: TYPE_ORIENTATION (deprecated API 8) — Use SensorManager.getOrientation() with rotation matrix instead. TYPE_TEMPERATURE (deprecated API 14) — Measured device temperature, not ambient. Replaced by TYPE_AMBIENT_TEMPERATURE. Always check the minimum API level for each sensor type you use, and always handle the case where a sensor is not available on the device. 1.4 Setting Up a Compose-First Sensor Project Let's set up the foundation project that we'll use throughout this chapter and build into PhoneCheckup. Project Structure Create a new Android project in Android Studio with the Empty Compose Activity template. Here's the dependency setup: build.gradle.kts (app level): plugins { alias(libs.plugins.android.application) alias(libs.plugins.kotlin.android) alias(libs.plugins.kotlin.compose) alias(libs.plugins.hilt.android) alias(libs.plugins.ksp) } android { namespace = "com.example.phonecheckup" compileSdk = 35 defaultConfig { applicationId = "com.example.phonecheckup" minSdk = 26 targetSdk = 35 versionCode = 1 versionName = "1.0" } buildFeatures { compose = true } composeOptions { kotlinCompilerExtensionVersion = "1.5.14" } kotlinOptions { jvmTarget = "17" } } dependencies { // Compose BOM val composeBom = platform(libs.compose.bom) implementation(composeBom) implementation(libs.compose.material3) implementation(libs.compose.ui) implementation(libs.compose.ui.tooling.preview) implementation(libs.compose.activity) implementation(libs.lifecycle.viewmodel.compose) implementation(libs.lifecycle.runtime.compose) // Hilt implementation(libs.hilt.android) ksp(libs.hilt.compiler) implementation(libs.hilt.navigation.compose) // Testing testImplementation(libs.junit) androidTestImplementation(composeBom) androidTestImplementation(libs.compose.ui.test) debugImplementation(libs.compose.ui.tooling) } The SensorManager Wrapper The raw SensorManager API is callback-based and lifecycle-unaware. We need a clean abstraction that works well with Compose's reactive model. Let's create a wrapper that exposes sensor data as Kotlin Flows: package com.example.phonecheckup.sensor import android.content.Context import android.hardware.Sensor import android.hardware.SensorEvent import android.hardware.SensorEventListener import android.hardware.SensorManager import dagger.hilt.android.qualifiers.ApplicationContext import kotlinx.coroutines.channels.awaitClose import kotlinx.coroutines.flow.Flow import kotlinx.coroutines.flow.callbackFlow import javax.inject.Inject import javax.inject.Singleton data class SensorData( val values: FloatArray, val accuracy: Int, val timestamp: Long ) { override fun equals(other: Any?): Boolean { if (this === other) return true if (other !is SensorData) return false return values.contentEquals(other.values) && accuracy == other.accuracy && timestamp == other.timestamp } override fun hashCode(): Int { var result = values.contentHashCode() result = 31 * result + accuracy result = 31 * result + timestamp.hashCode() return result } } @singleton class SensorManagerWrapper @Inject constructor( @ApplicationContext private val context: Context ) { private val sensorManager: SensorManager = context.getSystemService(Context.SENSOR_SERVICE) as SensorManager /** * Returns a list of all available sensors on this device. */ fun getAllSensors(): List { return sensorManager.getSensorList(Sensor.TYPE_ALL) } /** * Returns the default sensor for the given type, or null if not available. */ fun getSensor(type: Int): Sensor? { return sensorManager.getDefaultSensor(type) } /** * Returns true if the device has a sensor of the given type. */ fun isSensorAvailable(type: Int): Boolean { return sensorManager.getDefaultSensor(type) != null } /** * Observes sensor data as a Flow. Automatically registers when collected * and unregisters when the collector is cancelled. */ fun observeSensor( type: Int, samplingPeriod: Int = SensorManager.SENSOR_DELAY_UI ): Flow = callbackFlow { val sensor = sensorManager.getDefaultSensor(type) if (sensor == null) { close(IllegalStateException("Sensor type $type is not available")) return@callbackFlow } val listener = object : SensorEventListener { override fun onSensorChanged(event: SensorEvent) { trySend( SensorData( values = event.values.copyOf(), accuracy = event.accuracy, timestamp = event.timestamp ) ) } override fun onAccuracyChanged(sensor: Sensor, accuracy: Int) { // Accuracy changes are handled through SensorData.accuracy } } sensorManager.registerListener(listener, sensor, samplingPeriod) awaitClose { sensorManager.unregisterListener(listener) } } } There are several important design decisions in this wrapper worth understanding. First, we use callbackFlow to bridge the callback-based SensorEventListener to Kotlin's Flow API. When a composable starts collecting this Flow, the sensor is registered. When the composable leaves the composition or the coroutine is cancelled, awaitClose fires and unregisters the listener. This prevents the most common sensor bug — forgetting to unregister. Second, we call event.values.copyOf() instead of storing the reference directly. This is critical because Android reuses the same SensorEvent object across callbacks. If you store the reference, all your historical data will point to the same array with only the latest values. Third, we use trySend instead of send because trySend is non-suspending. Sensor callbacks come from a system thread and should return quickly. If the collector is slow, trySend simply drops the event rather than blocking the sensor thread. Permissions Model Most physical sensors (accelerometer, gyroscope, magnetometer, light, pressure, proximity) require no runtime permissions. The system grants access by default. However, some sensor categories require explicit permissions: Feature Declarations for Play Store Filtering If your app requires a specific sensor to function, declare it as a hardware feature. The Play Store uses this to filter your app from devices that lack the sensor: For PhoneCheckup, all sensor features should be required="false" since the whole point is to detect what's available on any device. 1.5 Integrating Sensors with Jetpack Compose Now let's build the bridge between our SensorManagerWrapper and Jetpack Compose's reactive UI model. Building rememberSensorState() The cleanest way to consume sensor data in Compose is through a custom remember function that returns a State object: package com.example.phonecheckup.sensor import android.hardware.SensorManager import androidx.compose.runtime.Composable import androidx.compose.runtime.State import androidx.compose.runtime.collectAsState import androidx.compose.runtime.remember import androidx.compose.ui.platform.LocalContext /** Remembers and observes sensor data as Compose State. * Usage: val accelData by rememberSensorState(Sensor.TYPE_ACCELEROMETER) accelData?.let { data -> Text("X: ${data.values[0]}") } */ @Composable fun rememberSensorState( sensorType: Int, samplingPeriod: Int = SensorManager.SENSOR_DELAY_UI, sensorManagerWrapper: SensorManagerWrapper ): State { val flow = remember(sensorType, samplingPeriod) { sensorManagerWrapper.observeSensor(sensorType, samplingPeriod) } return flow.collectAsState(initial = null) } Using this in a composable is as simple as: @Composable fun AccelerometerDisplay(sensorManagerWrapper: SensorManagerWrapper) { val sensorData by rememberSensorState( sensorType = Sensor.TYPE_ACCELEROMETER, sensorManagerWrapper = sensorManagerWrapper ) sensorData?.let { data -> Column { Text("X: ${"%.2f".format(data.values[0])} m/s²") Text("Y: ${"%.2f".format(data.values[1])} m/s²") Text("Z: ${"%.2f".format(data.values[2])} m/s²") } } ?: Text("Accelerometer not available") } Lifecycle-Aware Sensor Registration with DisposableEffect Sometimes you need more control over sensor registration — for example, when you want to register in onResume and unregister in onPause. Here's a pattern using DisposableEffect and LifecycleEventObserver: @Composable fun LifecycleAwareSensor( sensorType: Int, sensorManagerWrapper: SensorManagerWrapper, onSensorData: (SensorData) -> Unit ) { val lifecycleOwner = LocalLifecycleOwner.current DisposableEffect(lifecycleOwner, sensorType) { val sensorManager = /* get from context */ val sensor = sensorManager.getDefaultSensor(sensorType) val listener = object : SensorEventListener { override fun onSensorChanged(event: SensorEvent) { onSensorData( SensorData( values = event.values.copyOf(), accuracy = event.accuracy, timestamp = event.timestamp ) ) } override fun onAccuracyChanged(s: Sensor, accuracy: Int) {} } val observer = LifecycleEventObserver { _, event -> when (event) { Lifecycle.Event.ON_RESUME -> { sensor?.let { sensorManager.registerListener( listener, it, SensorManager.SENSOR_DELAY_UI ) } } Lifecycle.Event.ON_PAUSE -> { sensorManager.unregisterListener(listener) } else -> {} } } lifecycleOwner.lifecycle.addObserver(observer) onDispose { sensorManager.unregisterListener(listener) lifecycleOwner.lifecycle.removeObserver(observer) } } } This pattern ensures sensors are only active when the UI is visible, which is exactly what you want for most user-facing sensor displays. Handling Sensor Availability Gracefully Not every device has every sensor. A well-designed sensor app handles missing sensors gracefully instead of crashing: @Composable fun SensorCard( sensorType: Int, sensorName: String, sensorManagerWrapper: SensorManagerWrapper, content: @Composable (SensorData) -> Unit ) { val isAvailable = remember { sensorManagerWrapper.isSensorAvailable(sensorType) } Card( modifier = Modifier .fillMaxWidth() .padding(8.dp), colors = CardDefaults.cardColors( containerColor = if (isAvailable) MaterialTheme.colorScheme.surface else MaterialTheme.colorScheme.surfaceVariant ) ) { Column(modifier = Modifier.padding(16.dp)) { Row( verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.SpaceBetween, modifier = Modifier.fillMaxWidth() ) { Text( text = sensorName, style = MaterialTheme.typography.titleMedium ) if (isAvailable) { Icon( imageVector = Icons.Default.CheckCircle, contentDescription = "Available", tint = Color(0xFF34A853) ) } else { Icon( imageVector = Icons.Default.Cancel, contentDescription = "Not Available", tint = Color(0xFFEA4335) ) } } if (isAvailable) { Spacer(modifier = Modifier.height(8.dp)) val sensorData by rememberSensorState( sensorType = sensorType, sensorManagerWrapper = sensorManagerWrapper ) sensorData?.let { content(it) } } else { Text( text = "This sensor is not available on your device", style = MaterialTheme.typography.bodySmall, color = MaterialTheme.colorScheme.onSurfaceVariant ) } } } } 1.6 Project: Building PhoneCheckup Now let's bring everything together into a complete, polished app. PhoneCheckup discovers all sensors, runs diagnostic tests, and generates a health report card. App Architecture We'll follow MVVM with Clean Architecture, using Hilt for dependency injection: com.example.phonecheckup/ ├── di/ │ └── SensorModule.kt // Hilt module providing SensorManagerWrapper ├── sensor/ │ ├── SensorManagerWrapper.kt // Our sensor abstraction (already built) │ ├── SensorData.kt // Data classes │ └── SensorDiagnostics.kt // Diagnostic test logic ├── ui/ │ ├── theme/ │ │ └── Theme.kt │ ├── screens/ │ │ ├── SensorListScreen.kt // Main sensor discovery screen │ │ ├── DiagnosticScreen.kt // Interactive diagnostic tests │ │ └── ReportScreen.kt // Health report card │ ├── components/ │ │ ├── SensorCard.kt // Expandable sensor card │ │ ├── DiagnosticTestCard.kt // Interactive test UI │ │ └── StatusIndicator.kt // Pass/Fail/Degraded indicator │ └── viewmodel/ │ └── PhoneCheckupViewModel.kt // Main ViewModel ├── model/ │ ├── SensorInfo.kt // Sensor metadata model │ ├── DiagnosticResult.kt // Test result model │ └── SensorCategory.kt // Category grouping └── MainActivity.kt Data Models First, let's define the data structures that drive the app: package com.example.phonecheckup.model import android.hardware.Sensor enum class SensorCategory(val displayName: String) { MOTION("Motion Sensors"), ENVIRONMENT("Environmental Sensors"), POSITION("Position Sensors"), BIOMETRIC("Biometric Sensors"), OTHER("Other Sensors") } enum class SensorStatus { AVAILABLE, // Sensor exists and working DEGRADED, // Sensor exists but accuracy is low NOT_AVAILABLE, // Sensor not present on device NOT_TESTED // Haven't run diagnostic yet } enum class DiagnosticStatus { PENDING, RUNNING, PASSED, FAILED, SKIPPED } data class SensorInfo( val type: Int, val name: String, val vendor: String, val version: Int, val maxRange: Float, val resolution: Float, val power: Float, // mA consumption val minDelay: Int, // minimum delay between events in microseconds val maxDelay: Int, // maximum delay between events in microseconds val isWakeUp: Boolean, val category: SensorCategory, val status: SensorStatus = SensorStatus.NOT_TESTED, val currentValues: FloatArray? = null ) { val maxSamplingRateHz: Double get() = if (minDelay > 0) 1_000_000.0 / minDelay else 0.0 val powerDescription: String get() = when { power < 0.5f -> "Ultra-low (${power} mA)" power < 1.0f -> "Low (${power} mA)" power < 3.0f -> "Moderate (${power} mA)" else -> "High (${power} mA)" } override fun equals(other: Any?): Boolean { if (this === other) return true if (other !is SensorInfo) return false return type == other.type && name == other.name } override fun hashCode(): Int = 31 * type + name.hashCode() } data class DiagnosticTest( val sensorType: Int, val testName: String, val instruction: String, // "Rotate your phone 360°" val durationMs: Long = 5000, // How long the test runs val status: DiagnosticStatus = DiagnosticStatus.PENDING, val result: String = "" // "Passed — all axes responsive" ) data class HealthReport( val deviceName: String, val androidVersion: String, val totalSensors: Int, val availableSensors: Int, val passedTests: Int, val failedTests: Int, val overallScore: Int, // 0-100 val sensorResults: List, val diagnosticResults: List, val timestamp: Long = System.currentTimeMillis() ) Sensor Discovery and Categorization The core logic for discovering and categorizing sensors: package com.example.phonecheckup.sensor import android.hardware.Sensor import com.example.phonecheckup.model.SensorCategory import com.example.phonecheckup.model.SensorInfo import com.example.phonecheckup.model.SensorStatus import javax.inject.Inject import javax.inject.Singleton @singleton class SensorDiscovery @Inject constructor( private val sensorManagerWrapper: SensorManagerWrapper ) { /** * Maps sensor types to human-friendly names. */ private val sensorTypeNames = mapOf( Sensor.TYPE_ACCELEROMETER to "Accelerometer", Sensor.TYPE_MAGNETIC_FIELD to "Magnetometer", Sensor.TYPE_GYROSCOPE to "Gyroscope", Sensor.TYPE_LIGHT to "Light Sensor", Sensor.TYPE_PRESSURE to "Barometer", Sensor.TYPE_PROXIMITY to "Proximity Sensor", Sensor.TYPE_GRAVITY to "Gravity Sensor", Sensor.TYPE_LINEAR_ACCELERATION to "Linear Acceleration", Sensor.TYPE_ROTATION_VECTOR to "Rotation Vector", Sensor.TYPE_RELATIVE_HUMIDITY to "Humidity Sensor", Sensor.TYPE_AMBIENT_TEMPERATURE to "Temperature Sensor", Sensor.TYPE_MAGNETIC_FIELD_UNCALIBRATED to "Magnetometer (Uncalibrated)", Sensor.TYPE_GAME_ROTATION_VECTOR to "Game Rotation Vector", Sensor.TYPE_GYROSCOPE_UNCALIBRATED to "Gyroscope (Uncalibrated)", Sensor.TYPE_SIGNIFICANT_MOTION to "Significant Motion", Sensor.TYPE_STEP_DETECTOR to "Step Detector", Sensor.TYPE_STEP_COUNTER to "Step Counter", Sensor.TYPE_GEOMAGNETIC_ROTATION_VECTOR to "Geomagnetic Rotation", Sensor.TYPE_HEART_RATE to "Heart Rate", Sensor.TYPE_STATIONARY_DETECT to "Stationary Detect", Sensor.TYPE_MOTION_DETECT to "Motion Detect", Sensor.TYPE_HEART_BEAT to "Heart Beat", Sensor.TYPE_LOW_LATENCY_OFFBODY_DETECT to "Off-Body Detect", Sensor.TYPE_ACCELEROMETER_UNCALIBRATED to "Accelerometer (Uncalibrated)", Sensor.TYPE_HINGE_ANGLE to "Hinge Angle" ) /** * Maps sensor types to categories. */ private fun categorize(type: Int): SensorCategory = when (type) { Sensor.TYPE_ACCELEROMETER, Sensor.TYPE_LINEAR_ACCELERATION, Sensor.TYPE_GRAVITY, Sensor.TYPE_GYROSCOPE, Sensor.TYPE_GYROSCOPE_UNCALIBRATED, Sensor.TYPE_ACCELEROMETER_UNCALIBRATED, Sensor.TYPE_SIGNIFICANT_MOTION, Sensor.TYPE_STEP_COUNTER, Sensor.TYPE_STEP_DETECTOR, Sensor.TYPE_MOTION_DETECT, Sensor.TYPE_STATIONARY_DETECT -> SensorCategory.MOTION Sensor.TYPE_LIGHT, Sensor.TYPE_PRESSURE, Sensor.TYPE_AMBIENT_TEMPERATURE, Sensor.TYPE_RELATIVE_HUMIDITY -> SensorCategory.ENVIRONMENT Sensor.TYPE_MAGNETIC_FIELD, Sensor.TYPE_MAGNETIC_FIELD_UNCALIBRATED, Sensor.TYPE_PROXIMITY, Sensor.TYPE_ROTATION_VECTOR, Sensor.TYPE_GAME_ROTATION_VECTOR, Sensor.TYPE_GEOMAGNETIC_ROTATION_VECTOR, Sensor.TYPE_HINGE_ANGLE -> SensorCategory.POSITION Sensor.TYPE_HEART_RATE, Sensor.TYPE_HEART_BEAT, Sensor.TYPE_LOW_LATENCY_OFFBODY_DETECT -> SensorCategory.BIOMETRIC else -> SensorCategory.OTHER } /** * Discovers all sensors on the device and returns them as SensorInfo objects, * grouped by category. */ fun discoverAll(): Map { val allSensors = sensorManagerWrapper.getAllSensors() return allSensors.map { sensor -> SensorInfo( type = sensor.type, name = sensorTypeNames[sensor.type] ?: sensor.name, vendor = sensor.vendor, version = sensor.version, maxRange = sensor.maximumRange, resolution = sensor.resolution, power = sensor.power, minDelay = sensor.minDelay, maxDelay = sensor.maxDelay, isWakeUp = sensor.isWakeUpSensor, category = categorize(sensor.type), status = SensorStatus.AVAILABLE ) } .distinctBy { it.type } .groupBy { it.category } .toSortedMap(compareBy { it.ordinal }) } /** * Checks which important sensors are missing from this device. */ fun findMissingSensors(): List { val importantTypes = listOf( Sensor.TYPE_ACCELEROMETER, Sensor.TYPE_GYROSCOPE, Sensor.TYPE_MAGNETIC_FIELD, Sensor.TYPE_LIGHT, Sensor.TYPE_PROXIMITY, Sensor.TYPE_PRESSURE, Sensor.TYPE_STEP_COUNTER, Sensor.TYPE_ROTATION_VECTOR ) return importantTypes .filter { !sensorManagerWrapper.isSensorAvailable(it) } .map { type -> SensorInfo( type = type, name = sensorTypeNames[type] ?: "Unknown", vendor = "N/A", version = 0, maxRange = 0f, resolution = 0f, power = 0f, minDelay = 0, maxDelay = 0, isWakeUp = false, category = categorize(type), status = SensorStatus.NOT_AVAILABLE ) } } } Diagnostic Tests Engine The diagnostic engine runs interactive tests that verify sensors are actually working correctly — not just present: package com.example.phonecheckup.sensor import android.hardware.Sensor import com.example.phonecheckup.model.DiagnosticStatus import com.example.phonecheckup.model.DiagnosticTest import kotlinx.coroutines.delay import kotlinx.coroutines.flow.first import kotlinx.coroutines.withTimeoutOrNull import javax.inject.Inject import javax.inject.Singleton import kotlin.math.abs import kotlin.math.sqrt @singleton class SensorDiagnostics @Inject constructor( private val sensorManagerWrapper: SensorManagerWrapper ) { fun getAvailableTests(): List { val tests = mutableListOf() if (sensorManagerWrapper.isSensorAvailable(Sensor.TYPE_ACCELEROMETER)) { tests.add( DiagnosticTest( sensorType = Sensor.TYPE_ACCELEROMETER, testName = "Accelerometer Test", instruction = "Place your phone flat on a table, then pick it up and tilt it in all directions.", durationMs = 6000 ) ) } if (sensorManagerWrapper.isSensorAvailable(Sensor.TYPE_GYROSCOPE)) { tests.add( DiagnosticTest( sensorType = Sensor.TYPE_GYROSCOPE, testName = "Gyroscope Test", instruction = "Slowly rotate your phone 360° like turning a steering wheel.", durationMs = 8000 ) ) } if (sensorManagerWrapper.isSensorAvailable(Sensor.TYPE_MAGNETIC_FIELD)) { tests.add( DiagnosticTest( sensorType = Sensor.TYPE_MAGNETIC_FIELD, testName = "Magnetometer Test", instruction = "Move your phone in a figure-8 pattern, then point it north.", durationMs = 8000 ) ) } if (sensorManagerWrapper.isSensorAvailable(Sensor.TYPE_PROXIMITY)) { tests.add( DiagnosticTest( sensorType = Sensor.TYPE_PROXIMITY, testName = "Proximity Sensor Test", instruction = "Cover the top of your phone with your hand, then remove it.", durationMs = 6000 ) ) } if (sensorManagerWrapper.isSensorAvailable(Sensor.TYPE_LIGHT)) { tests.add( DiagnosticTest( sensorType = Sensor.TYPE_LIGHT, testName = "Light Sensor Test", instruction = "Cover your phone screen completely, then uncover it to expose to light.", durationMs = 6000 ) ) } if (sensorManagerWrapper.isSensorAvailable(Sensor.TYPE_PRESSURE)) { tests.add( DiagnosticTest( sensorType = Sensor.TYPE_PRESSURE, testName = "Barometer Test", instruction = "Hold your phone still. The barometer will check for stable pressure readings.", durationMs = 5000 ) ) } return tests } /** * Runs the accelerometer diagnostic test. * Checks that all 3 axes respond to movement and that gravity is detected. */ suspend fun runAccelerometerTest(): DiagnosticTest { val test = DiagnosticTest( sensorType = Sensor.TYPE_ACCELEROMETER, testName = "Accelerometer Test", instruction = "Tilt your phone in all directions", status = DiagnosticStatus.RUNNING ) var minX = Float.MAX_VALUE; var maxX = Float.MIN_VALUE var minY = Float.MAX_VALUE; var maxY = Float.MIN_VALUE var minZ = Float.MAX_VALUE; var maxZ = Float.MIN_VALUE val sensorFlow = sensorManagerWrapper.observeSensor( Sensor.TYPE_ACCELEROMETER ) val result = withTimeoutOrNull(6000L) { var sampleCount = 0 sensorFlow.collect { data -> val x = data.values[0] val y = data.values[1] val z = data.values[2] minX = minOf(minX, x); maxX = maxOf(maxX, x) minY = minOf(minY, y); maxY = maxOf(maxY, y) minZ = minOf(minZ, z); maxZ = maxOf(maxZ, z) sampleCount++ if (sampleCount > 300) return@collect } } val xRange = maxX - minX val yRange = maxY - minY val zRange = maxZ - minZ val allAxesResponsive = xRange > 2f && yRange > 2f && zRange > 2f // Check if gravity magnitude is approximately 9.81 m/s² val gravityMagnitude = sqrt( (maxX * maxX + maxY * maxY + maxZ * maxZ).toDouble() ).toFloat() val gravityDetected = gravityMagnitude > 8f && gravityMagnitude < 12f val passed = allAxesResponsive && gravityDetected return test.copy( status = if (passed) DiagnosticStatus.PASSED else DiagnosticStatus.FAILED, result = if (passed) { "All 3 axes responsive. Gravity detected at ${"%.1f".format(gravityMagnitude)} m/s²." } else { buildString { if (!allAxesResponsive) append("Some axes not responding (X: ${"%.1f".format(xRange)}, Y: ${"%.1f".format(yRange)}, Z: ${"%.1f".format(zRange)}). ") if (!gravityDetected) append("Gravity reading abnormal (${"%.1f".format(gravityMagnitude)} m/s²). ") } } ) } /** * Runs the proximity sensor diagnostic test. * Checks that the sensor can detect near and far states. */ suspend fun runProximityTest(): DiagnosticTest { val test = DiagnosticTest( sensorType = Sensor.TYPE_PROXIMITY, testName = "Proximity Sensor Test", instruction = "Cover and uncover the top of your phone", status = DiagnosticStatus.RUNNING ) var sawNear = false var sawFar = false val sensorFlow = sensorManagerWrapper.observeSensor( Sensor.TYPE_PROXIMITY ) withTimeoutOrNull(6000L) { sensorFlow.collect { data -> val distance = data.values[0] if (distance < 1f) sawNear = true if (distance > 3f) sawFar = true if (sawNear && sawFar) return@collect } } val passed = sawNear && sawFar return test.copy( status = if (passed) DiagnosticStatus.PASSED else DiagnosticStatus.FAILED, result = if (passed) { "Near and far states detected successfully." } else { buildString { if (!sawNear) append("Near state not detected — try covering the top sensor area. ") if (!sawFar) append("Far state not detected. ") } } ) } /** * Runs the light sensor diagnostic test. * Checks that the sensor responds to light level changes. */ suspend fun runLightTest(): DiagnosticTest { val test = DiagnosticTest( sensorType = Sensor.TYPE_LIGHT, testName = "Light Sensor Test", instruction = "Cover then uncover your phone", status = DiagnosticStatus.RUNNING ) var minLux = Float.MAX_VALUE var maxLux = Float.MIN_VALUE val sensorFlow = sensorManagerWrapper.observeSensor( Sensor.TYPE_LIGHT ) withTimeoutOrNull(6000L) { var sampleCount = 0 sensorFlow.collect { data -> val lux = data.values[0] minLux = minOf(minLux, lux) maxLux = maxOf(maxLux, lux) sampleCount++ if (sampleCount > 200) return@collect } } val luxRange = maxLux - minLux val passed = luxRange > 50f // Should see significant change when covering/uncovering return test.copy( status = if (passed) DiagnosticStatus.PASSED else DiagnosticStatus.FAILED, result = if (passed) { "Light range detected: ${"%.0f".format(minLux)} – ${"%.0f".format(maxLux)} lux." } else { "Insufficient light variation detected (${"%.0f".format(luxRange)} lux). Try covering and uncovering the sensor." } ) } } The ViewModel The ViewModel orchestrates the sensor discovery and diagnostic testing: package com.example.phonecheckup.ui.viewmodel import android.os.Build import androidx.lifecycle.ViewModel import androidx.lifecycle.viewModelScope import com.example.phonecheckup.model.* import com.example.phonecheckup.sensor.SensorDiagnostics import com.example.phonecheckup.sensor.SensorDiscovery import dagger.hilt.android.lifecycle.HiltViewModel import kotlinx.coroutines.flow.MutableStateFlow import kotlinx.coroutines.flow.StateFlow import kotlinx.coroutines.flow.asStateFlow import kotlinx.coroutines.flow.update import kotlinx.coroutines.launch import javax.inject.Inject data class PhoneCheckupUiState( val sensorsByCategory: Map> = emptyMap(), val missingSensors: List = emptyList(), val totalSensorCount: Int = 0, val diagnosticTests: List = emptyList(), val isRunningDiagnostics: Boolean = false, val currentTestIndex: Int = -1, val healthReport: HealthReport? = null, val selectedTab: Int = 0 ) @HiltViewModel class PhoneCheckupViewModel @Inject constructor( private val sensorDiscovery: SensorDiscovery, private val sensorDiagnostics: SensorDiagnostics ) : ViewModel() { private val _uiState = MutableStateFlow(PhoneCheckupUiState()) val uiState: StateFlow = _uiState.asStateFlow() init { discoverSensors() } private fun discoverSensors() { val sensorsByCategory = sensorDiscovery.discoverAll() val missingSensors = sensorDiscovery.findMissingSensors() val totalCount = sensorsByCategory.values.sumOf { it.size } _uiState.update { it.copy( sensorsByCategory = sensorsByCategory, missingSensors = missingSensors, totalSensorCount = totalCount, diagnosticTests = sensorDiagnostics.getAvailableTests() )} } fun runAllDiagnostics() { viewModelScope.launch { _uiState.update { it.copy(isRunningDiagnostics = true, currentTestIndex = 0) } val results = mutableListOf() val tests = _uiState.value.diagnosticTests tests.forEachIndexed { index, test -> _uiState.update { it.copy(currentTestIndex = index) } val result = when (test.sensorType) { android.hardware.Sensor.TYPE_ACCELEROMETER -> sensorDiagnostics.runAccelerometerTest() android.hardware.Sensor.TYPE_PROXIMITY -> sensorDiagnostics.runProximityTest() android.hardware.Sensor.TYPE_LIGHT -> sensorDiagnostics.runLightTest() else -> test.copy(status = DiagnosticStatus.SKIPPED) } results.add(result) _uiState.update { it.copy(diagnosticTests = results.toList()) } } _uiState.update { it.copy( isRunningDiagnostics = false, currentTestIndex = -1, diagnosticTests = results )} generateReport(results) } } private fun generateReport(diagnosticResults: List) { val state = _uiState.value val passedTests = diagnosticResults.count { it.status == DiagnosticStatus.PASSED } val failedTests = diagnosticResults.count { it.status == DiagnosticStatus.FAILED } val totalTests = diagnosticResults.size // Score: base 50 for having sensors, up to 50 more for passing tests val sensorScore = ((state.totalSensorCount.toFloat() / 20f) * 50).toInt().coerceAtMost(50) val testScore = if (totalTests > 0) { ((passedTests.toFloat() / totalTests) * 50).toInt() } else 0 val overallScore = (sensorScore + testScore).coerceIn(0, 100) val report = HealthReport( deviceName = "${Build.MANUFACTURER} ${Build.MODEL}", androidVersion = "Android ${Build.VERSION.RELEASE} (API ${Build.VERSION.SDK_INT})", totalSensors = state.totalSensorCount, availableSensors = state.totalSensorCount, passedTests = passedTests, failedTests = failedTests, overallScore = overallScore, sensorResults = state.sensorsByCategory.values.flatten(), diagnosticResults = diagnosticResults ) _uiState.update { it.copy(healthReport = report) } } fun selectTab(index: Int) { _uiState.update { it.copy(selectedTab = index) } } } Main UI: Sensor List Screen The main screen shows all discovered sensors in expandable cards grouped by category: package com.example.phonecheckup.ui.screens import android.hardware.Sensor import androidx.compose.animation.AnimatedVisibility import androidx.compose.animation.expandVertically import androidx.compose.animation.shrinkVertically import androidx.compose.foundation.background import androidx.compose.foundation.clickable import androidx.compose.foundation.layout.* import androidx.compose.foundation.lazy.LazyColumn import androidx.compose.foundation.lazy.items import androidx.compose.foundation.shape.RoundedCornerShape import androidx.compose.material.icons.Icons import androidx.compose.material.icons.filled.* import androidx.compose.material3.* import androidx.compose.runtime.* import androidx.compose.ui.Alignment import androidx.compose.ui.Modifier import androidx.compose.ui.draw.clip import androidx.compose.ui.graphics.Color import androidx.compose.ui.text.font.FontWeight import androidx.compose.ui.unit.dp import com.example.phonecheckup.model.SensorCategory import com.example.phonecheckup.model.SensorInfo @Composable fun SensorListScreen( sensorsByCategory: Map>, missingSensors: List, totalCount: Int ) { LazyColumn( modifier = Modifier.fillMaxSize(), contentPadding = PaddingValues(16.dp), verticalArrangement = Arrangement.spacedBy(12.dp) ) { // Summary card item { SensorSummaryCard( totalSensors = totalCount, missingSensors = missingSensors.size ) } // Sensor categories sensorsByCategory.forEach { (category, sensors) -> item { Text( text = category.displayName, style = MaterialTheme.typography.titleMedium, fontWeight = FontWeight.Bold, modifier = Modifier.padding(top = 8.dp, bottom = 4.dp), color = MaterialTheme.colorScheme.primary ) } items(sensors, key = { it.type }) { sensor -> ExpandableSensorCard(sensorInfo = sensor) } } // Missing sensors section if (missingSensors.isNotEmpty()) { item { Text( text = "Missing Sensors", style = MaterialTheme.typography.titleMedium, fontWeight = FontWeight.Bold, modifier = Modifier.padding(top = 8.dp, bottom = 4.dp), color = MaterialTheme.colorScheme.error ) } items(missingSensors, key = { "missing_${it.type}" }) { sensor -> MissingSensorCard(sensorInfo = sensor) } } } } @Composable fun SensorSummaryCard(totalSensors: Int, missingSensors: Int) { Card( modifier = Modifier.fillMaxWidth(), colors = CardDefaults.cardColors( containerColor = MaterialTheme.colorScheme.primaryContainer ) ) { Row( modifier = Modifier .fillMaxWidth() .padding(20.dp), horizontalArrangement = Arrangement.SpaceEvenly, verticalAlignment = Alignment.CenterVertically ) { SummaryItem( count = totalSensors.toString(), label = "Sensors Found", color = MaterialTheme.colorScheme.primary ) SummaryItem( count = missingSensors.toString(), label = "Missing", color = if (missingSensors > 0) MaterialTheme.colorScheme.error else Color(0xFF34A853) ) } } } @Composable fun SummaryItem(count: String, label: String, color: Color) { Column(horizontalAlignment = Alignment.CenterHorizontally) { Text( text = count, style = MaterialTheme.typography.headlineLarge, fontWeight = FontWeight.Bold, color = color ) Text( text = label, style = MaterialTheme.typography.bodySmall, color = MaterialTheme.colorScheme.onSurfaceVariant ) } } @Composable fun ExpandableSensorCard(sensorInfo: SensorInfo) { var expanded by remember { mutableStateOf(false) } Card( modifier = Modifier .fillMaxWidth() .clickable { expanded = !expanded } ) { Column(modifier = Modifier.padding(16.dp)) { Row( modifier = Modifier.fillMaxWidth(), horizontalArrangement = Arrangement.SpaceBetween, verticalAlignment = Alignment.CenterVertically ) { Column(modifier = Modifier.weight(1f)) { Text( text = sensorInfo.name, style = MaterialTheme.typography.titleSmall, fontWeight = FontWeight.SemiBold ) Text( text = sensorInfo.vendor, style = MaterialTheme.typography.bodySmall, color = MaterialTheme.colorScheme.onSurfaceVariant ) } Row(verticalAlignment = Alignment.CenterVertically) { Icon( imageVector = Icons.Default.CheckCircle, contentDescription = "Available", tint = Color(0xFF34A853), modifier = Modifier.size(20.dp) ) Spacer(modifier = Modifier.width(4.dp)) Icon( imageVector = if (expanded) Icons.Default.ExpandLess else Icons.Default.ExpandMore, contentDescription = "Expand" ) } } AnimatedVisibility( visible = expanded, enter = expandVertically(), exit = shrinkVertically() ) { Column(modifier = Modifier.padding(top = 12.dp)) { HorizontalDivider(modifier = Modifier.padding(bottom = 12.dp)) DetailRow("Max Range", "${sensorInfo.maxRange}") DetailRow("Resolution", "${sensorInfo.resolution}") DetailRow("Power", sensorInfo.powerDescription) DetailRow("Max Sampling Rate", "${"%.1f".format(sensorInfo.maxSamplingRateHz)} Hz") DetailRow("Wake-up Sensor", if (sensorInfo.isWakeUp) "Yes" else "No") DetailRow("Version", "${sensorInfo.version}") } } } } } @Composable fun DetailRow(label: String, value: String) { Row( modifier = Modifier .fillMaxWidth() .padding(vertical = 2.dp), horizontalArrangement = Arrangement.SpaceBetween ) { Text( text = label, style = MaterialTheme.typography.bodySmall, color = MaterialTheme.colorScheme.onSurfaceVariant ) Text( text = value, style = MaterialTheme.typography.bodySmall, fontWeight = FontWeight.Medium ) } } @Composable fun MissingSensorCard(sensorInfo: SensorInfo) { Card( modifier = Modifier.fillMaxWidth(), colors = CardDefaults.cardColors( containerColor = MaterialTheme.colorScheme.errorContainer.copy(alpha = 0.3f) ) ) { Row( modifier = Modifier .fillMaxWidth() .padding(16.dp), horizontalArrangement = Arrangement.SpaceBetween, verticalAlignment = Alignment.CenterVertically ) { Text( text = sensorInfo.name, style = MaterialTheme.typography.titleSmall, color = MaterialTheme.colorScheme.error ) Icon( imageVector = Icons.Default.Cancel, contentDescription = "Not Available", tint = MaterialTheme.colorScheme.error, modifier = Modifier.size(20.dp) ) } } } Hilt Module package com.example.phonecheckup.di import android.content.Context import com.example.phonecheckup.sensor.SensorManagerWrapper import dagger.Module import dagger.Provides import dagger.hilt.InstallIn import dagger.hilt.android.qualifiers.ApplicationContext import dagger.hilt.components.SingletonComponent import javax.inject.Singleton @Module @InstallIn(SingletonComponent::class) object SensorModule { @Provides @Singleton fun provideSensorManagerWrapper( @ApplicationContext context: Context ): SensorManagerWrapper { return SensorManagerWrapper(context) } } Chapter Summary In this chapter, you've built a solid foundation for everything that follows: Sensor Framework Architecture — You understand how sensor data flows from hardware through the HAL to your Kotlin code via SensorManager and SensorEventListener. Sensor Categories — You know the three families of sensors (motion, environmental, position), what each sensor type measures, and which ones are common vs. rare across devices. Compose Integration — You built a reusable SensorManagerWrapper that exposes sensor data as Kotlin Flows, a rememberSensorState() composable for reactive sensor consumption, and lifecycle-aware registration patterns. PhoneCheckup App — You built a practical app that discovers sensors, runs diagnostic tests, and generates health reports — the kind of app real people use when buying used phones. In Chapter 2, we'll dive into the accelerometer and gyroscope in depth and build DriveSafe — an app that monitors driving behavior and scores trip safety. Read More https://leanpub.com/master_android_sensors