1. Introduction
Fitness apps have become an integral part of our lives, helping individuals monitor their physical activity, set goals, and track progress. In this article, we'll guide you through the process of building a fitness tracker app in Android. This app will allow users to track various fitness metrics such as steps taken, distance covered, and calories burned.
2. Setting Up the
Project
Before diving into the code, we need to set up our Android project. Follow these steps to get started:
2.1. Create a New Android Project
Open Android Studio and create a new project. Choose a name for your project, select the appropriate SDK, and set up the basic configurations. For this tutorial, we'll name the project FitnessTrackerApp.
2.2. Adding Dependencies
To build a fitness tracker app, you'll need to add certain dependencies to your build.gradle file. Some of the key libraries you might need include:
dependencies {
implementation 'com.google.android.gms:play-services-fitness:21.0.1'
implementation 'com.google.android.gms:play-services-location:21.0.1'
implementation 'androidx.lifecycle:lifecycle-extensions:2.2.0'
implementation 'androidx.room:room-runtime:2.3.0'
annotationProcessor 'androidx.room:room-compiler:2.3.0'
}
3. Designing the User
Interface (UI)
Next, let's design the UI of our fitness tracker app. The UI should be simple, intuitive, and provide users with easy access to their fitness data. Here are some key components:
3.1. Main Activity Layout
The main activity will serve as the central hub of the app, displaying the user's fitness metrics. Here's a basic layout structure:
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:padding="16dp">
<TextView
android:id="@+id/step_count"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Steps: 0"
android:textSize="24sp"
android:textColor="#000"/>
<TextView
android:id="@+id/distance_covered"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_below="@id/step_count"
android:text="Distance: 0.0 km"
android:textSize="24sp"
android:textColor="#000"/>
<TextView
android:id="@+id/calories_burned"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_below="@id/distance_covered"
android:text="Calories: 0 kcal"
android:textSize="24sp"
android:textColor="#000"/>
</RelativeLayout>
4. Integrating Google
Fit API
To track fitness metrics, we'll integrate the Google Fit API into our app. Google Fit provides access to a variety of fitness data, such as step count, distance, and calories burned. Follow these steps to set up Google Fit:
4.1. Configure Google Fit API
First, add the necessary permissions to your AndroidManifest.xml file:
<uses-permission android:name="android.permission.ACTIVITY_RECOGNITION"/>
<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION"/>
Then, in your MainActivity, initialize the Google Fit API client:
class MainActivity : AppCompatActivity() {
private lateinit var fitnessOptions: FitnessOptions
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
fitnessOptions = FitnessOptions.builder()
.addDataType(DataType.TYPE_STEP_COUNT_CUMULATIVE, FitnessOptions.ACCESS_READ)
.addDataType(DataType.TYPE_DISTANCE_DELTA, FitnessOptions.ACCESS_READ)
.addDataType(DataType.TYPE_CALORIES_EXPENDED, FitnessOptions.ACCESS_READ)
.build()
val account = GoogleSignIn.getAccountForExtension(this, fitnessOptions)
if (!GoogleSignIn.hasPermissions(account, fitnessOptions)) {
GoogleSignIn.requestPermissions(
this,
REQUEST_OAUTH_REQUEST_CODE,
account,
fitnessOptions)
} else {
accessGoogleFitData()
}
}
private fun accessGoogleFitData() {
Fitness.getHistoryClient(this, GoogleSignIn.getAccountForExtension(this, fitnessOptions))
.readDailyTotal(DataType.TYPE_STEP_COUNT_CUMULATIVE)
.addOnSuccessListener { result ->
val totalSteps = result.dataPoints.firstOrNull()?.getValue(Field.FIELD_STEPS)?.asInt() ?: 0
findViewById(R.id.step_count).text = "Steps: $totalSteps"
}
.addOnFailureListener { e ->
Log.w(TAG, "There was a problem getting the step count.", e)
}
}
companion object {
const val REQUEST_OAUTH_REQUEST_CODE = 1
}
}
5. Storing Fitness Data
with Room Database
To keep track of historical fitness data, we'll use Room, Google's persistence library for Android. Room provides an abstraction layer over SQLite, making it easier to work with databases in Android apps.
5.1. Setting Up Room
Start by creating an Entity class that represents a table in your database:
@Entity(tableName = "fitness_data")
data class FitnessData(
@PrimaryKey(autoGenerate = true) val id: Int,
val steps: Int,
val distance: Float,
val calories: Int,
val date: Long
)
Next, create a DAO (Data Access Object) interface to define the methods for interacting with the database:
@Dao
interface FitnessDataDao {
@Insert(onConflict = OnConflictStrategy.REPLACE)
suspend fun insertFitnessData(fitnessData: FitnessData)
@Query("SELECT * FROM fitness_data ORDER BY date DESC")
fun getAllFitnessData(): LiveData>
@Query("DELETE FROM fitness_data")
suspend fun deleteAllFitnessData()
}
5.2. Building the Database
With the entity and DAO in place, it's time to set up the database. Create an abstract class that extends RoomDatabase:
@Database(entities = [FitnessData::class], version = 1, exportSchema = false)
abstract class FitnessDatabase : RoomDatabase() {
abstract fun fitnessDataDao(): FitnessDataDao
companion object {
@Volatile
private var INSTANCE: FitnessDatabase? = null
fun getDatabase(context: Context): FitnessDatabase {
return INSTANCE ?: synchronized(this) {
val instance = Room.databaseBuilder(
context.applicationContext,
FitnessDatabase::class.java,
"fitness_database"
).build()
INSTANCE = instance
instance
}
}
}
}
6. Displaying Fitness
Data
Now that we've integrated the Google Fit API and set up the Room database, it's time to display the fitness data in our app's UI.
6.1. Fetching Data from the Database
In your ViewModel, fetch the fitness data from the Room database:
class FitnessViewModel(application: Application) : AndroidViewModel(application) {
private val fitnessDataDao = FitnessDatabase.getDatabase(application).fitnessDataDao()
val allFitnessData: LiveData> = fitnessDataDao.getAllFitnessData()
fun insertFitnessData(fitnessData: FitnessData) = viewModelScope.launch {
fitnessDataDao.insertFitnessData(fitnessData)
}
fun deleteAllFitnessData() = viewModelScope.launch {
fitnessDataDao.deleteAllFitnessData()
}
}
6.2. Observing Data in the UI
In your activity or fragment, observe the LiveData and update the UI accordingly:
class MainActivity : AppCompatActivity() {
private lateinit var fitnessViewModel: FitnessViewModel
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
fitnessViewModel = ViewModelProvider(this).get(FitnessViewModel::class.java)
fitnessViewModel.allFitnessData.observe(this, Observer { fitnessData ->
// Update UI with the latest fitness data
})
}
}
7. Conclusion
Building a fitness tracker app in Android involves integrating various components, from the Google Fit API for real-time fitness data to Room for storing and retrieving historical data. By following the steps outlined in this article, you can create a fully functional fitness tracker app that helps users monitor their fitness progress effectively.
Remember, this is just a starting point. You can expand the app by adding features like goal setting, reminders, or even integrating with wearables for more accurate tracking.
Post a Comment