s24 MADS 4001 Intro to Android Development

Day 01: Introduction to Android

Introduction to Android architecture and app lifecycle

Fundamentals of the development environment and tools

Course Software Setup (Android Studio)

UI Components:

Working with Views (TextView, EditText, Button)

Handling event listeners for various UI Components

Day 02 : JULY 9

UI Components, continued

Displaying an image using an ImageView and a file in the drawables folder

Programmatically updating the picture shown in an ImageView

Learning outcomes:

The elements of Android KOTLIN Applications and their architecture.

The elements of Android Kotlin applications are typically structured within a recommended architecture that ensures the development of robust, scalable, and maintainable apps.

The main elements and architecture of Android Kotlin applications include the key elements and architecture of Android Kotlin applications:

The 6 Key Elements of Android Application Architecture:

1. Activities and Fragments - The core UI components that represent screens and portions of the UI.

2. Layouts and Views - Define the structure and individual UI elements.

3. Intents - Messaging objects used to request actions from other app components.

4. Services - Background components for long-running operations.

5. Broadcast Receivers - Components that respond to system-wide broadcast messages.

6. Content Providers - Manage and share app data.

Architecture:

Android Kotlin apps typically follow an MVVM (Model-View-ViewModel) or Clean Architecture pattern.

This is similar to Model View Controller for Web Applications:

View : HTML, Android Screen: Point of Interaction with the User.

Controller: the set of classes which run the application: Deliver the Business Rules and Algorithms

Model: Data Store or data persistence layer. This is NOT the database itself. The Model is the wrapper or mediator that brokers connections to the database.

In the Android OS, there is a build in SQLite database. Accessible via the “Shared Preferences” Android Framework.

We also have the ROOMS Library.

With the following layers:

1. UI Layer - Activities/Fragments are used to build ViewModels

2. Domain Layer: The “controller” - the system partition in which code business rules and algorithms: == Simplest Example here is the MainActivity.kt file : the file in which we code what happens - Use Cases are boxes, descriptions of business processes, and how they Interact

3. Data Layer: The Persistence Layer - Repositories - Data Sources (local and remote)

This could be “on device” memory or remote API accessed memory.

Room Framework : built in SQLite db, good for storing preferences

MVVM Pattern: This architecture promotes:

Comparing MVC to MVVM: The big difference is:

In MVC: We do NOT allow Business Logic in the View Layer.

In MVVM, we put business logic in the view layer to simplify the design of the program.

- Separation of concerns - Testability - Maintainability - Scalability

The ViewModel acts as a bridge between the UI and business logic.

The “Persistence Layer” (the connection to your database) manage data operations across multiple sources.

This layered approach allows for a clean separation between the UI, business logic, and data management.

This architecture enables building robust, maintainable Android applications in Kotlin by organizing code into logical layers with clear responsibilities.

Citations: [1] https://developer.android.com/guide/components/fundamentals [2] https://www.scaler.com/topics/basic-android-elements-in-kotlin/ [3] https://reintech.io/blog/implementing-mvvm-architecture-kotlin [4] https://www.youtube.com/watch?v=4agk_yVY5z8 [5] https://github.com/emedinaa/kotlin-mvvm [6] https://github.com/android10/Android-CleanArchitecture-Kotlin [7] https://developer.android.com/topic/architecture [8] https://developer.android.com/topic/libraries/architecture/viewmodel [9] https://www.geeksforgeeks.org/components-android-application/ [10] https://kotlinlang.org/docs/android-overview.html [11] https://www.toptal.com/android/android-apps-mvvm-with-clean-architecture [12] https://dev.to/whatminjacodes/simple-example-of-mvvm-architecture-in-kotlin-4j5b [13] https://www.geeksforgeeks.org/android-architecture/ [14] https://www.geeksforgeeks.org/mvvm-model-view-viewmodel-architecture-pattern-in-android/

Lab Part 1: "Intro to Android App Architecture".

Here is a comprehensive lesson plan focusing on Activities and the activity lifecycle.

We'll use viewBindings and avoid findViewById as prescribed by current best practice.

Here's a detailed outline for the lesson:

This lesson plan covers the key aspects of Android app architecture, focusing on Activities and their lifecycle.

The coding demo and hands-on exercise will give students practical experience with implementing and observing the Activity lifecycle in action, using viewBinding in keeping with current Android Kotlin Application Development best practices.

Day 2 Class: Intro to Android App Architecture

1. Introduction (10 minutes) - Brief recap of previous class - Overview of today's topics:

Activities and Activity Lifecycle

2. What is an Activity? (15 minutes) - Definition: A single, focused thing that the user can do. - Relation to app screens - Role in the Android app architecture

3. Activity Lifecycle (20 minutes) - Explanation of the Activity Lifecycle concept - Visual representation: [Activity Lifecycle Diagram](https://static.javatpoint.com/images/androidimages/Android-Activity-Lifecycle.png) - Detailed explanation of each lifecycle state

⁠

⁠

⁠

4. Lifecycle Methods (30 minutes) - Overview of main lifecycle methods: - onCreate() - onStart() - onResume() - onPause() - onStop() - onRestart() - onDestroy() - When and why each method is called

5. Coding Demo:

Overriding Lifecycle Methods (45 minutes) - Setup a new Android project in Android Studio - Implement viewBinding - Override lifecycle methods and add logging statements - Run the app and demonstrate when each method is called (debugger and logcat)

​Here's a basic code structure for the lifecycle demo:

```kotlin class MainActivity : AppCompatActivity() {

private lateinit var binding: ActivityMainBinding private val TAG = "MainActivity"

override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) binding = ActivityMainBinding.inflate(layoutInflater) setContentView(binding.root) Log.d(TAG, "onCreate called")

binding.buttonNext.setOnClickListener { startActivity(Intent(this, SecondActivity::class.java)) } }

override fun onStart() { super.onStart() Log.d(TAG, "onStart called") }

override fun onResume() { super.onResume() Log.d(TAG, "onResume called") }

override fun onPause() { super.onPause() Log.d(TAG, "onPause called") }

override fun onStop() { super.onStop() Log.d(TAG, "onStop called") }

override fun onRestart() { super.onRestart() Log.d(TAG, "onRestart called") }

override fun onDestroy() { super.onDestroy() Log.d(TAG, "onDestroy called") } } ```

6. Hands-on Exercise (30 minutes) - Students create a simple two-activity app - Implement viewBinding in both activities - Override lifecycle methods in both activities - Add logging statements to track lifecycle method calls - Test the app and observe the lifecycle method execution order

Code Lab 1

build.gradle.kts (Project level): 1 for the entire application