Building Your Android Exercise App with Kotlin

Crafting an Effective Android App

Explore the world of Android app development through our in-depth guide on building a foundational exercise tracker app using Kotlin. This comprehensive guide equips you with the knowledge to craft a user-friendly exercise routine management tool. As you delve into this process, you'll not only enhance your coding skills but also gain valuable insights that can greatly help your Android app assignment and pave the way for more intricate project undertakings.

Prerequisites

Before we begin, let's ensure we have:

A basic familiarity with the Kotlin programming language.
Android Studio installed on our computer.

Step 1: Setting Up Our Project

Open Android Studio: Let's start by launching Android Studio to create our project.
Create a New Project: Choose "Start a new Android Studio project" and follow the prompts to set up our project's details.
Select Activity Template: Opt for an "Empty Activity" template for our project.

Step 2: Designing the User Interface

Layout XML (`activity_main.xml`): Open the layout XML file for our main activity. This is where we'll define our app's user interface.

Design UI Elements: Let's design the UI by adding the following elements:

`EditText` for exercise name
`EditText` for sets
`EditText` for reps
`Button` to add exercises
`TextView` to display the list of exercises

Example Layout:


```xml
< RelativeLayoutxmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
tools:context=".MainActivity" >
< EditText
android:id="@+id/exerciseNameEditText"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:hint="Exercise Name" / >
< EditText
android:id="@+id/setsEditText"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:layout_below="@id/exerciseNameEditText"
android:hint="Sets"
android:inputType="number" / >
< EditText
android:id="@+id/repsEditText"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:layout_below="@id/setsEditText"
android:hint="Reps"
android:inputType="number" / >
< Button
android:id="@+id/addExerciseButton"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_below="@id/repsEditText"
android:text="Add Exercise" / >
< TextView
android:id="@+id/exerciseListTextView"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:layout_below="@id/addExerciseButton"
android:layout_marginTop="16dp"
android:text=""
android:textSize="16sp" / >
< /RelativeLayout >
```

Step 3: Writing the Kotlin Code

Let's delve into the Kotlin code that powers our exercise tracker app.

MainActivity (`MainActivity.kt`): Open the Kotlin file for our main activity.

Import Statements: Import the required classes and packages.


```kotlin
importandroid.os.Bundle
importandroidx.appcompat.app.AppCompatActivity
import kotlinx.android.synthetic.main.activity_main.*
```

Main Activity Class: Set up the main activity class.


```kotlin
classMainActivity : AppCompatActivity() {
// Our main activity code goes here
}
```

Step 4: Adding Exercise Logic

Exercise Data Class: Create a data class to represent an exercise.


```kotlin
data class Exercise(val name: String, val sets: Int, val reps: Int)
```

Initializing Exercise List: Inside the `MainActivity` class, let's initialize an empty list to store exercise objects.


```kotlin
privatevalexerciseList = mutableListOf
()
```

Button Click Listener: Add a click listener to the "Add Exercise" button to handle exercise addition.


```kotlin
addExerciseButton.setOnClickListener {
val name = exerciseNameEditText.text.toString()
val sets = setsEditText.text.toString().toInt()
val reps = repsEditText.text.toString().toInt()
if (name.isNotEmpty() && sets > 0 && reps > 0) {
val exercise = Exercise(name, sets, reps)
exerciseList.add(exercise)
updateExerciseList()
clearInputs()
}
}
```

Updating Exercise List: Create a function to update the displayed exercise list.


```kotlin
private fun updateExerciseList() {
valexerciseText = StringBuilder()
for (exercise in exerciseList) {
exerciseText.append("${exercise.name}: ${exercise.sets} sets of ${exercise.reps} reps\n")
}
exerciseListTextView.text = exerciseText.toString()
}
```

Clearing Input Fields: Implement a function to clear input fields after adding an exercise.


```kotlin
private fun clearInputs() {
exerciseNameEditText.text.clear()
setsEditText.text.clear()
repsEditText.text.clear()
}
```

Step 5: Testing Our App

Run the App: Connect an Android device or emulator to our development environment. Build and run the app.
Add Exercises: Input exercise details and click the "Add Exercise" button.
View Exercise List: The added exercises will be displayed in the text view below the button.

Conclusion

Our exercise tracker app is now ready and functional using Kotlin for Android! This guide has expertly navigated us through crucial phases such as project setup, user interface design, Kotlin code implementation, and app testing. As we continue our programming journey, feel empowered to tailor and enrich the app's features according to our aspirations, thereby elevating its functionality to new heights.

Write an Exercise Tracker Program in Kotlin for Android