How to make a pedometer on Android: from applications to your own code

A pedometer on a smartphone is not only a fashionable fitness gadget, but also a useful tool for tracking activity, monitoring health and motivating movement. Modern Android devices equipped with built-in sensors (accelerometer, gyroscope, low-power pedometer), which allow you to count steps with high accuracy. However, not all manufacturers enable this feature by default, and standard applications are often limited in capabilities.

In this article we will look all ways to create a pedometer on Android from using ready-made applications to writing your own code from scratch. You will learn how to configure the built-in step counter, which apps offer advanced analytics, and how to develop a unique solution using Android SDK i Google Fit API. We will pay special attention to the issues of accuracy, power consumption and compatibility with different versions Android (from 8.0 Oreo to 15).

1. Built-in pedometer in Android: how to enable and configure

Many users do not suspect that their smartphone can already count steps without additional applications. Starting from Android 4.4 KitKat, the system integrates Hardware Step Counter a hardware step counter that operates at the hardware level and consumes minimal energy. However, access to it depends on the manufacturer and model of the device.

To check for a built-in pedometer:

• 📱 Open Settings → Google → Google services → Fit (the path may differ by Samsung, Xiaomi or Huawei).
• 🔍 Check the "Fitness" or "Activity" section - if there is step data there, the sensor is working.
• 📊 On some devices (for example, Pixel or OnePlus) steps are displayed in Google Fit automatically.

⚠️ Attention: On budget smartphones (for example, Redmi 9A or Samsung Galaxy A03) there may be no hardware pedometer. In this case, the system uses accelerometer data, which is less accurate and consumes more battery.

If the built-in counter is inactive, try:

1. Update Google Play Services i Google Fit in Play Market.
2. Give permission to access physical activity sensors in Settings → Applications → Google Fit → Permissions.
3. Reboot the device - sometimes this resets sensor errors.

2. TOP 5 applications for pedometer: comparison of capabilities

If the built-in tools are not satisfactory, install one of the specialized applications. We tested 15 apps and selected the best ones in terms of accuracy, functionality and energy efficiency. They are all free (with a premium subscription option) and support the Russian language.

For maximum accuracy, we recommend combining data from Google Fit i Pedometer. The first synchronizes with other fitness services, and the second allows you to fine-tune the sensitivity of the sensor. For example, if you are working at a computer and the phone is on the table, Accupedo automatically ignores vibrations, while a standard counter can count them as steps.

3. How to create a pedometer without programming: application designers

If you want own pedometer application, but do not have coding skills, use online constructors. They allow you to assemble a working prototype in 10–15 minutes using ready-made blocks. The best platforms for this task:

• 🛠️ Appy Pie —drag-and-drop editor with templates for fitness applications. Supports integration with Google Fit API.
• 📱 Thunkable —a visual environment based on MIT App Inventor, where you can add blocks for working with sensors.
• 🌐 Glide —suitable for creating a simple activity tracker based on Google Sheets (data is entered manually).

Example of step-by-step assembly in Thunkable:

1. Create a new project and select a template Blank App.
2. Add a component Pedometer Sensor from the "Sensors" section.
3. Customize the interface: add a label (Label) to display the number of steps and a reset button.
4. In the block When Pedometer.Step → Do specify the action: update the label with the current value of steps.
5. Export the APK and install it on your phone.

⚠️ Warning: Applications built in constructors may have limitations in accuracy. For example, Glide cannot automatically read data from sensors - manual input will be required. For a full-fledged pedometer, it is better to use Google Fit API (more on this below).

4. Developing a pedometer from scratch: a guide for programmers

To create a professional pedometer with high accuracy and minimal battery consumption, you will need to write code in Java or Kotlin. We will consider two approaches: using Step Counter API (for hardware sensors) and Accelerometer API (for software counting).

Before you start, make sure that the file AndroidManifest.xml has the necessary permissions:

<uses-permission android:name="android.permission.ACTIVITY_RECOGNITION" />
<uses-feature android:name="android.hardware.sensor.stepcounter" />
<uses-feature android:name="android.hardware.sensor.accelerometer" />

Method 1: Step Counter API (recommended)

This method uses the built-in hardware step counter, which ensures high accuracy and minimal battery consumption. Code for Kotlin:

class StepCounterService : Service() {
private lateinit var sensorManager: SensorManager
private var stepSensor: Sensor? = null
private var stepCount = 0

override fun onCreate() {
super.onCreate()
sensorManager = getSystemService(SENSOR_SERVICE) as SensorManager
stepSensor = sensorManager.getDefaultSensor(Sensor.TYPE_STEP_COUNTER)

stepSensor?.also { sensor ->
sensorManager.registerListener(
stepDetectorListener,
sensor,
SensorManager.SENSOR_DELAY_UI
)
}
}

private val stepDetectorListener = object : SensorEventListener {
override fun onSensorChanged(event: SensorEvent) {
if (event.sensor.type == Sensor.TYPE_STEP_COUNTER) {
stepCount = event.values[0].toInt()
// Send data to the main thread to update the UI
sendBroadcast(Intent("STEP_COUNT_UPDATE").putExtra("count", stepCount))
}
}
override fun onAccuracyChanged(sensor: Sensor, accuracy: Int) {}
}

override fun onBind(intent: Intent?): IBinder? = null
}

Method 2: Accelerometer API (for devices without a hardware sensor)

If your phone does not have TYPE_STEP_COUNTER, you can use an accelerometer. However, this method is less accurate and requires additional data processing to filter out false positives:

class AccelerometerStepCounter : Service() {
private lateinit var sensorManager: SensorManager
private var accelerometer: Sensor? = null
private var lastStepTime: Long = 0
private var stepCount = 0
private val threshold = 12.0f // Threshold value for step registration

override fun onCreate() {
super.onCreate()
sensorManager = getSystemService(SENSOR_SERVICE) as SensorManager
accelerometer = sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER)

accelerometer?.also { sensor ->
sensorManager.registerListener(
accelerometerListener,
sensor,
SensorManager.SENSOR_DELAY_FASTEST
)
}
}

private val accelerometerListener = object : SensorEventListener {
override fun onSensorChanged(event: SensorEvent) {
val x = event.values[0]
val y = event.values[1]
val z = event.values[2]
val acceleration = sqrt(x  x + y  y + z * z)

if (acceleration > threshold) {
val currentTime = System.currentTimeMillis()
if (currentTime - lastStepTime > 300) { // Protection against double positives
stepCount++
lastStepTime = currentTime
}
}
}
override fun onAccuracyChanged(sensor: Sensor, accuracy: Int) {}
}
}

Critical feature: When using the accelerometer, the pedometer will only work when the screen is active or in the background with high priority, which significantly increases battery consumption. For optimization, add Foreground Service with a notification and use WorkManager to periodically record data.

Added permissions to AndroidManifest.xml|Tested on devices without a hardware sensor|Optimized battery consumption|Implemented background work via Foreground Service|Checked compatibility with Android 12+-->

5. Optimizing accuracy and power consumption

Even the most advanced pedometer app can show inaccurate data or quickly drain the battery. We have collected 7 proven ways to improve the performance of your step counter:

• 📉 Sensor calibration: Walk 50-100 steps manually and compare with phone readings. If the difference is more than 10%, adjust the coefficient in the code (for Accelerometer API).
• 🔋 Management background processes: Use JobScheduler or WorkManager to record data in batches rather than in real time.
• 📱 Phone positioning: Carry the device in your pants pocket or on your belt - this increases accuracy by 20-30% compared to a bag or hand.
• 🛠️ Noise filtering: To Accelerometer API add a low-pass filter (for example, LowPassFilter) to smooth the data.

To test accuracy, use professional fitness trackers (for example, Garmin or Fitbit) as a reference. Compare readings over a distance of 1–2 km at different walking speeds. Typical mistakes:

• 🚶 False steps: Registered while driving a vehicle or working at a computer. The solution is to add a check for the amplitude and frequency of vibrations.
• 🏃 Skipped steps: Occur when walking slowly or if the phone is lying motionless. The solution is to reduce the sensitivity threshold.

6. Integration with Google Fit and other services

To allow your pedometer to synchronize data with Google Fit, Apple Health (via export) or Strava, use Google Fit API. This will allow users to analyze activity in one place and compare data with other devices.

Example code for recording steps in Google Fit:

val fitnessOptions = FitnessOptions.builder()
.addDataType(DataType.TYPE_STEP_COUNT_DELTA, FitnessOptions.ACCESS_WRITE)
.build()

if (!GoogleSignIn.hasPermissions(GoogleSignIn.getLastSignedInAccount(this), fitnessOptions)) {
GoogleSignIn.requestPermissions(
this,
REQUEST_OAUTH_REQUEST_CODE,
GoogleSignIn.getLastSignedInAccount(this),
fitnessOptions
)
} else {
recordSteps()
}

private fun recordSteps() {
val dataSource = DataSource.Builder()
.setDataType(DataType.TYPE_STEP_COUNT_DELTA)
.setType(DataSource.TYPE_RAW)
.setAppPackageName("com.example.stepcounter")
.build()

val dataSet = DataSet.create(dataSource)
val dataPoint = dataSet.createDataPoint()
.setTimeInterval(startTime, endTime, TimeUnit.NANOSECONDS)
dataPoint.getValue(Field.FIELD_STEPS).setInt(steps)
dataSet.add(dataPoint)

Fitness.getHistoryClient(this, GoogleSignIn.getLastSignedInAccount(this)!!)
.insertData(dataSet)
.addOnSuccessListener { Log.d("StepCounter", "Steps recorded in Google Fit") }
}

To work with the API you will need:

1. Create a project in Google Cloud Console and enable Fitness API.
2. Generate OAuth 2.0 Client ID for Android.
3. Add dependency to build.gradle:

   implementation 'com.google.android.gms:play-services-fitness:21.1.0'

⚠️ Attention: From 2023 Google Fit API requires verification for applications that request access to physical activity data. If your application has not been moderated, users will see a warning about “unverified source.”

7. Problems and solutions: why the pedometer does not work

If your step counter shows incorrect data or does not function at all, check the following points:

If the problem persists, check logs via Logcat (filter by tag "StepCounter"). Typical errors:

• Sensor not found — the sensor is missing on the device.
• Permission denied — there are not enough permissions (check AndroidManifest.xml).
• GoogleApiException — authorization error in Google Fit API.

adb shell am startservice -a com.example.stepcounter.START

This will allow you to test background work without a physical device.-->

8. Alternative ways to track steps

If developing your own pedometer seems complicated, consider alternative options:

• 📱 Fitness bracelets: Xiaomi Mi Band, Huawei Band or Amazfit synchronizes with Google Fit and is 15-20% more accurate than a smartphone.
• 👟 Smart sneakers: Models with built-in sensors (for example, Nike Adapt) transmit data directly to the application.
• 💻 Web services: Strava or Endomondo allow you to manually enter the number of steps and build graphs activity.
• 🔧 Automation via Tasker: Set up a task that will read steps from Google Fit and send notifications when the goal is achieved.

For those who like experiments: you can assemble hardware pedometer on the base Arduino or Raspberry Pi with sensor MPU-6050. The cost of the components is about 500–1000 rubles, and the accuracy is comparable to fitness bracelets. Example diagram:

Arduino Nano → MPU-6050 (accelerometer/gyroscope) → Bluetooth module HC-05 → Android application

FAQ: Frequently asked questions about pedometers on Android

adb backup -f steps.ab com.example.pedometer

class WearStepCounterService : WearableListenerService() {
override fun onDataChanged(dataEvents: DataEventBuffer) {
for (event in dataEvents) {
if (event.type == DataEvent.TYPE_CHANGED &&
event.dataItem.uri.path == "/steps") {
val dataMap = DataMapItem.fromDataItem(event.dataItem).dataMap
val steps = dataMap.getInt("count")
// Updating the UI on the watch
}
}
}
}