Write an Exercise Tracker Program in Kotlin for Android

In this comprehensive guide, we will walk you through the process of crafting a basic exercise tracker app using the robust Kotlin programming language for Android. Our app will empower you to seamlessly input your exercise routines, providing an effective solution to staying organized and motivated on your fitness journey. We will ensure that each code block is meticulously explained, enabling you to gain a profound understanding of the entire development process.

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.

Step 1: Setting Up Our Project

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

Step 2: Designing the User Interface

1. 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.
2. 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
3. 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.

1. MainActivity (`MainActivity.kt`): Open the Kotlin file for our main activity.
2. Import Statements: Import the required classes and packages.
```kotlin importandroid.os.Bundle importandroidx.appcompat.app.AppCompatActivity import kotlinx.android.synthetic.main.activity_main.* ```
3. Main Activity Class: Set up the main activity class.
```kotlin classMainActivity : AppCompatActivity() { // Our main activity code goes here } ```

Step 4: Adding Exercise Logic

1. Exercise Data Class: Create a data class to represent an exercise.
```kotlin data class Exercise(val name: String, val sets: Int, val reps: Int) ```
2. Initializing Exercise List: Inside the `MainActivity` class, let's initialize an empty list to store exercise objects.
```kotlin privatevalexerciseList = mutableListOf () ```
3. 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() } } ```
4. 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() } ```
5. 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

1. Run the App: Connect an Android device or emulator to our development environment. Build and run the app.
2. Add Exercises: Input exercise details and click the "Add Exercise" button.
3. 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.