Sensors API — ay ang interface ng Android platform para sa pag-access sa mga hardware sensor ng device. Ang API ay nagbibigay ng pinag-isang paraan ng pagkuha ng data mula sa accelerometer, gyroscope, magnetometer, light sensor, at iba pang sensor. Ayon sa datos ng Google, 2026, mahigit 95% ng mga modernong Android device ay nilagyan ng hindi bababa sa tatlong uri ng sensor, na nagbubukas ng malawak na posibilidad para sa pag-develop ng mga context-aware na application.
Mga Pangunahing Punto
Sensors API — ay ang programming interface ng Android Framework, na nagbibigay sa mga developer ng access sa mga hardware sensor ng mobile device. Ang API ay bahagi ng Android SDK mula noong bersyon 1.0 at naa-access sa pamamagitan ng package na android.hardware. Ang interface ay nag-aabstrak ng mga pagkakaiba sa pagitan ng mga implementasyon ng sensor mula sa iba't ibang manufacturer — Qualcomm, MediaTek, Samsung Exynos — at nagbibigay ng pinag-isang modelo ng pagtatrabaho sa mga sensor.
Ang API ay nagbibigay-daan sa tatlong pangunahing operasyon: pagkuha ng listahan ng mga available na sensor, pagrehistro ng mga listener para sa pagtanggap ng data, at pamamahala sa dalas ng pag-update ng mga pagbasa. SensorManager ang sentral na punto ng access sa lahat ng operasyon. Ang system ay nag-aabiso sa application sa pamamagitan ng callback na onSensorChanged, na nagpapadala ng object na SensorEvent na may array ng mga float value.
Sa panahon ng pag-iral ng Android, ang API ay dumaan sa ilang yugto ng pag-develop. Sa bersyon 2.3 (Gingerbread) lumitaw ang suporta para sa Batch Processing — pagpapangkat ng mga sensor event para mabawasan ang konsumo ng kuryente. Android 4.0 (Ice Cream Sandwich) ay nagdagdag ng mga virtual na sensor na Gravity at Linear Acceleration. Simula sa Android 8.0, nilimitahan ng system ang background access sa mga sensor para sa mas mataas na privacy.
val sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
val sensorList: List<Sensor> = sensorManager.getSensorList(Sensor.TYPE_ALL)
sensorList.forEach { sensor ->
Log.d("Sensor", "${sensor.name} — ${sensor.type}")
}
Hindi lahat ng device ay may parehong set ng mga sensor. Dapat suriin ng application ang pagkakaroon ng isang partikular na sensor bago magrehistro ng listener. Ang Android emulator ay sumusuporta lamang sa limitadong set ng mga sensor — accelerometer at magnetometer. Para sa pagsubok ng iba pang mga sensor, kinakailangan ang isang pisikal na device. Simula sa Android 12, dapat ideklara ng mga application ang paggamit ng mga sensor sa manifest.
Inuuri ng Android ang lahat ng sensor sa tatlong kategorya: Motion (galaw), Position (posisyon), at Environment (kapaligiran). Ang mga Motion sensor ay kinabibilangan ng accelerometer, gyroscope, at pedometer. Ang mga Position sensor ay naglalaman ng magnetometer at Orientation. Environment — light sensor, pressure, temperatura at humidity.
| Kategorya | Mga Sensor | Uri (constant) | Pisikal/Virtual |
|---|---|---|---|
| Motion | Accelerometer | TYPE_ACCELEROMETER | Pisikal |
| Motion | Gyroscope | TYPE_GYROSCOPE | Pisikal |
| Motion | Pedometer | TYPE_STEP_COUNTER | Pisikal |
| Motion | Gravity | TYPE_GRAVITY | Virtual |
| Position | Magnetometer | TYPE_MAGNETIC_FIELD | Pisikal |
| Position | Rotation Vector | TYPE_ROTATION_VECTOR | Virtual |
| Environment | Liwanag | TYPE_LIGHT | Pisikal |
| Environment | Presyon | TYPE_PRESSURE | Pisikal |
Ang accelerometer ay sumusukat ng acceleration sa m/s² sa tatlong axis — X, Y at Z. Kasama sa mga value ang gravity (9.8 m/s² sa Z axis sa pahinga). Ang gyroscope ay sumusukat ng angular velocity sa rad/s — ang bilis ng pag-ikot ng device sa bawat axis. Ang kombinasyon ng dalawang sensor na ito ay ginagamit sa nabigasyon, laro, at AR application.
class SensorActivity : Activity(), SensorEventListener {
override fun onSensorChanged(event: SensorEvent) {
if (event.sensor.type == Sensor.TYPE_ACCELEROMETER) {
val x = event.values[0]
val y = event.values[1]
val z = event.values[2]
textView.text = "X: $x, Y: $y, Z: $z"
}
}
override fun onAccuracyChanged(sensor: Sensor, accuracy: Int) {}
}
Ang magnetometer (TYPE_MAGNETIC_FIELD) ay sumusukat ng magnetic field sa microtesla (µT) sa tatlong axis. Ginagamit bilang digital compass — kasama ng accelerometer ay nagbibigay-daan upang matukoy ang azimuth ng device. Rotation Vector — isang virtual na sensor na pinagsasama ang data mula sa gyroscope, accelerometer, at magnetometer para sa tumpak na pagtukoy ng oryentasyon.
Ang light sensor (TYPE_LIGHT) ay sumusukat ng antas ng panlabas na ilaw sa lux (lx). Ginagamit para sa awtomatikong pagsasaayos ng liwanag ng screen. Ang pressure sensor (TYPE_PRESSURE) ay sumusukat ng atmospheric pressure sa hectopascal (hPa) — ginagamit sa mga navigation application para sa pagtukoy ng altitude sa ibabaw ng dagat.
Sensors API ay binuo sa isang client-server na arkitektura. Ang application ay kumikilos bilang client, SensorManager — bilang serbisyo ng Android system. Kapag nagrehistro ang application ng isang listener sa pamamagitan ng registerListener, kumokonekta ang SensorManager sa HAL (Hardware Abstraction Layer) — ang low-level driver ng sensor na gumagana sa antas ng Linux kernel.
Ang HAL driver ay tumatanggap ng raw data mula sa hardware chip, nag-filter ng ingay, at ipinapadala ang mga ito pataas sa stack — sa pamamagitan ng SensorService (system process) papunta sa application. Ang data ay ipinapadala bilang isang SensorEvent object, na naglalaman ng array ng float value na values at timestamp sa nanosecond. Ang dalas ng mga event ay depende sa napiling delivery mode.
Sa pagrehistro ng listener, tinutukoy ng developer ang nais na pagkaantala sa pagitan ng mga event sa pamamagitan ng mga constant na SENSOR_DELAY_NORMAL (200 ms), SENSOR_DELAY_UI (60 ms), SENSOR_DELAY_GAME (20 ms) at SENSOR_DELAY_FASTEST (0 ms — maximum frequency). Ang aktwal na dalas ay maaaring mag-iba — ino-optimize ng system ang konsumo ng kuryente.
val sensor = sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER)
sensorManager.registerListener(
this,
sensor,
SensorManager.SENSOR_DELAY_GAME
)
Simula sa Android 2.3, sinusuportahan ng mga sensor ang batch mode — ang mga event ay naiipon sa FIFO buffer at inihahatid sa isang package. Ito ay nagpapahintulot sa processor na manatili sa sleep mode nang mas matagal, na binabawasan ang konsumo ng kuryente ng hanggang 60%. Ang laki ng buffer ay depende sa sensor chip at nakasaad sa field na Sensor.fifoMaxEventCount.
SensorManager — serbisyo ng system na naa-access sa pamamagitan ng getSystemService(Context.SENSOR_SERVICE). Nagbibigay ng mga pamamaraan para sa pagkuha ng listahan ng mga sensor, pagkuha ng isang partikular na default sensor, at pagrehistro/pagkansela ng mga listener. SensorManager — singleton, isang instance para sa buong application.
Bago gamitin ang isang sensor, kinakailangang suriin ang presensya nito. Ang pamamaraang getDefaultSensor(type) ay nagbabalik ng null kung ang sensor ay hindi available sa device. Ang pagkuha ng null nang walang pagsusuri ay magdudulot ng NullPointerException sa pagrehistro ng listener. Ang listahan ng lahat ng sensor ay ibinabalik ng pamamaraang getSensorList(type).
fun checkSensorAvailability(type: Int): Boolean {
val sensorManager =
getSystemService(Context.SENSOR_SERVICE) as SensorManager
return sensorManager.getDefaultSensor(type) != null
}
// Paggamit:
if (checkSensorAvailability(Sensor.TYPE_GYROSCOPE)) {
Log.d("Sensor", "Available ang gyroscope")
}
Ang listener ay nirerehistro sa pamamagitan ng registerListener(listener, sensor, delay). Mahalaga: ang pagkansela ng listener ay dapat gawin sa paraang onPause() sa pamamagitan ng unregisterListener(listener). Kung hindi ito gagawin, ang application ay patuloy na makakatanggap ng mga sensor event, na nagpapababa ng baterya kahit sa background. Android 8+ ay nagpapakita ng babala sa logcat tungkol sa hindi narehistrong mga listener.
Ang pamamaraang onAccuracyChanged(sensor, accuracy) ay tinatawag kapag nagbago ang katumpakan ng sensor. Mga value: SENSOR_STATUS_ACCURACY_HIGH, MEDIUM, LOW at UNRELIABLE. Kapag natanggap ang UNRELIABLE, ang data ng sensor ay dapat balewalain hanggang sa maibalik ang katumpakan. Halimbawa, ang magnetometer ay nangangailangan ng kalibrasyon — pag-alog ng device sa hugis ng figure eight.
Tingnan natin ang mga praktikal na halimbawa ng paggamit ng Sensors API sa mga Android application sa Kotlin. Unang halimbawa — pagtukoy ng oryentasyon ng screen gamit ang accelerometer. Pangalawa — pagbabasa ng magnetometer readings na may kalibrasyon. Pangatlo — step detector gamit ang pedometer.
Para sa pagtukoy ng oryentasyon, ginagamit ang kombinasyon ng accelerometer at magnetometer. Ang pamamaraang SensorManager.getRotationMatrix() ay kinakalkula ang rotation matrix, at getOrientation() ay kumukuha ng mga anggulong pitch, roll at azimuth. Azimuth — ang anggulo na may kaugnayan sa magnetic north sa radians.
val gravity = FloatArray(3)
val geomagnetic = FloatArray(3)
val rotationMatrix = FloatArray(9)
val orientation = FloatArray(3)
SensorManager.getRotationMatrix(
rotationMatrix, null, gravity, geomagnetic
)
SensorManager.getOrientation(rotationMatrix, orientation)
// orientation[0] — azimuth, [1] — pitch, [2] — roll
val azimuthDeg = Math.toDegrees(orientation[0].toDouble())
Pedometer (TYPE_STEP_COUNTER) ay nagbabalik ng kabuuang bilang ng mga hakbang na ginawa ng user mula noong huling pag-restart ng device. Ang sensor ay gumagana sa antas ng hardware — aktibo kahit hindi tumatakbo ang application. Para makuha ang bilang ng mga hakbang bawat session, kailangang i-save ang paunang halaga at kalkulahin ang pagkakaiba.
var initialSteps = 0
var isInitialized = false
override fun onSensorChanged(event: SensorEvent) {
if (event.sensor.type == Sensor.TYPE_STEP_COUNTER) {
if (!isInitialized) {
initialSteps = event.values[0].toInt()
isInitialized = true
}
val currentSteps = event.values[0].toInt()
val sessionSteps = currentSteps - initialSteps
Log.d("Hakbang", "Hakbang bawat session: $sessionSteps")
}
}
Ang light sensor ay nagbibigay-daan upang i-adapt ang interface sa mga kondisyon ng kapaligiran. Sa mababang ilaw (mas mababa sa 10 lx) maaaring lumipat sa dark theme. Sa maliwanag na sikat ng araw (higit sa 10000 lx) — dagdagan ang contrast. Para sa pag-filter ng ingay, ginagamit ang moving average ng huling 5 value.
Ang Android ay nagbibigay ng ilang virtual na sensor na walang direktang hardware na katumbas. Ang virtual na sensor ay kinakalkula ang mga pagbasa nito batay sa kombinasyon ng mga pisikal na sensor. Ito ay nagbabawas ng load sa developer — ang system mismo ang nag-iimplementa ng mga algorithm ng data fusion.
Ang sensor na Gravity (TYPE_GRAVITY) ay kumukuha ng gravity component mula sa accelerometer readings gamit ang low-pass filter. Linear Acceleration (TYPE_LINEAR_ACCELERATION) — kabaligtaran, tinatanggal ang gravity at nag-iiwan lamang ng linear acceleration ng device. Ang kabuuan ng Gravity at Linear Acceleration ay nagbibigay ng raw accelerometer readings.
Rotation Vector — ang pinaka-komplikadong virtual na sensor. Pinagsasama nito ang data mula sa gyroscope (high-frequency changes), accelerometer (gravity vector), at magnetometer (orientation relative sa north). Ang resulta — isang quaternion na naglalarawan ng absolute orientation ng device sa space. Ginagamit sa AR application at VR headset.
Game Rotation Vector — isang pinasimpleng bersyon ng Rotation Vector nang walang paggamit ng magnetometer. Ito ay nagbibigay ng mas mababang katumpakan ng pagtukoy ng azimuth, ngunit mas mataas na dalas ng pag-update at katatagan. Inirerekomenda para sa mga laro kung saan mahalaga ang mababang latency, hindi ang absolute orientation na may kaugnayan sa north.
Mga sensor — isa sa mga pinaka-enerhiya na komponent ng device. Ang accelerometer at gyroscope sa maximum polling frequency ay maaaring mag-discharge ng baterya sa loob ng 3–4 na oras ng tuloy-tuloy na paggamit. Ang pag-optimize ng pagtatrabaho sa mga sensor ay isang kritikal na gawain para sa anumang application na gumagamit ng Sensors API.
Huwag gamitin ang SENSOR_DELAY_FASTEST nang hindi kinakailangan. Para sa UI animations, sapat na ang SENSOR_DELAY_UI (60 ms). Para sa pagtukoy ng oryentasyon ng screen — SENSOR_DELAY_NORMAL (200 ms). Kung mas mataas ang dalas, mas maraming oras ang ginugugol ng processor sa aktibong estado. Ang pagkakaiba sa pagitan ng NORMAL at FASTEST ay hanggang 10x sa konsumo ng kuryente.
Simula sa Android 8.0 (API 26), ang mga background application ay tumatanggap ng sensor events na may pinababang dalas. Sa Android 12+, ang background access sa Motion at Position sensor ay nangangailangan ng pahintulot na BODY_SENSORS_BACKGROUND. Kanselahin ang pagrehistro ng listener kapag pumunta ang application sa background mode — ito ay nagpapahaba ng buhay ng baterya ng device.
Gamitin ang batch processing sa pamamagitan ng pamamaraang registerListener(listener, sensor, delay, maxReportLatencyUs). Ang parameter na maxReportLatencyUs ay tumutukoy sa maximum na pagkaantala ng paghahatid ng mga event sa microseconds. Sa halagang 1000000 (1 segundo), ang mga event ay naiipon sa FIFO buffer ng sensor at inihahatid isang beses bawat segundo — ang processor ay mas madalang lumabas sa sleep mode.
Mga Madalas Itanong
Minimum na set — accelerometer at magnetometer. Ang dalawang sensor na ito ay naroroon sa higit sa 95% ng mga device. Gyroscope, light sensor at proximity sensor — sa 70–80% ng mga modernong modelo. Ang iba pang sensor (presyon, temperatura, halumigmig, pedometer) ay mas madalang at depende sa kategorya ng presyo ng device.
TYPE_ACCELEROMETER ay nagbabalik ng buong acceleration kasama ang gravity (9.8 m/s²). TYPE_LINEAR_ACCELERATION ay nagbabalik ng acceleration na walang gravity — tanging acceleration mula sa paggalaw ng device. Kung ang device ay nakahiga nang hindi gumagalaw, ang accelerometer ay magpapakita ng 9.8 m/s² sa Z axis, habang ang Linear Acceleration ay 0 sa lahat ng axis.
Gamitin ang getPackageManager().hasSystemFeature() na may mga katumbas na constant: FEATURE_SENSOR_ACCELEROMETER, FEATURE_SENSOR_GYROSCOPE, FEATURE_SENSOR_PROXIMITY at iba pa. Ang alternatibong paraan — tawagan ang getDefaultSensor(type) at suriin ang resulta kung null. Ang unang paraan ay mas mainam para sa pagsusuri sa yugto ng inisyalisasyon.
Ang raw data mula sa mga sensor ay naglalaman ng ingay. Para sa pagpapakinis, gumamit ng low-pass filter: newValue = alpha * rawValue + (1 — alpha) * previousValue. Ang coefficient alpha = 0.1–0.3 ay nagbibigay ng magandang balanse sa pagitan ng responsiveness at smoothness. Para sa gyroscope, ginagamit din ang high-pass filter para alisin ang zero drift.
Oo, ngunit may mga limitasyon. Simula sa Android 8.0, ang dalas ng sensor events ay binabawasan para sa mga background application. Simula sa Android 12, kinakailangan ang pahintulot na BODY_SENSORS_BACKGROUND para sa pag-access ng mga sensor sa background. Para sa background work, inirerekomenda ang paggamit ng Foreground Service na may notification.
Buod
Gagawa kami ng mobile application na turnkey
Gumagawa ang IT Sectr ng mga iOS at Android application para sa mga startup at negosyo mula noong 2017. Magpapayo kami sa iyo at magmumungkahi ng pinakamahusay na solusyon.
Basahin din