First Android app in Android Kotlin - Deep Dive

Overview - First Android app

What is it?

A first Android app is a simple program you create to run on Android phones or tablets. It usually shows a screen with some text or buttons. This app introduces you to how Android apps work and how to build user interfaces. It is the starting point for making more complex apps.

Why it matters

Building a first Android app helps you understand how mobile apps are made and how they interact with users. Without this foundation, you can't create apps that people use daily for communication, games, or services. It solves the problem of turning ideas into interactive software on mobile devices.

Where it fits

Before this, you should know basic programming concepts like variables and functions. After learning this, you can explore more Android features like navigation, data storage, and network communication. This is the first step in your Android development journey.

Mental Model

Core Idea

An Android app is a set of screens and actions that run on a phone, starting with a main screen called an Activity.

Think of it like...

Making your first Android app is like setting up a simple shop window: you arrange what people see first and decide what happens when they tap on things.

┌───────────────────────────┐
│       Android App         │
│ ┌───────────────┐         │
│ │   Activity    │  <-- Main screen shown to user
│ │ (UI + logic)  │         │
│ └───────────────┘         │
│                           │
│ User taps buttons or views │
│ triggers app actions       │
└───────────────────────────┘

Build-Up - 6 Steps

1

Foundation

Set up Android Studio IDE

Concept: Learn to install and open the Android Studio software to start building apps.

Download Android Studio from the official website. Install it by following the setup steps. Open Android Studio and create a new project using the 'Empty Activity' template. This prepares your workspace for coding.

Result

You have a ready environment with a new Android project and a basic screen setup.

Understanding the development environment setup is crucial because it provides all the tools needed to build and test your app.

2

Foundation

Create a simple UI layout

Concept: Design the app's main screen using XML layout files.

Open the 'activity_main.xml' file. Use the visual editor or write XML to add a TextView that says 'Hello, Android!'. This defines what the user sees on the screen.

Result

The app's main screen shows the text 'Hello, Android!' when run.

Knowing how to create UI layouts lets you control what users see and interact with in your app.

3

Intermediate

Understand the MainActivity class

🤔Before reading on: do you think MainActivity controls the app's screen appearance or just stores data? Commit to your answer.

Concept: Learn how the MainActivity Kotlin class connects the UI layout to app behavior.

Open 'MainActivity.kt'. Notice it extends 'AppCompatActivity' and sets the content view to 'activity_main'. This class runs when the app starts and shows the UI you designed.

Result

The app launches showing the UI defined in the layout file, controlled by MainActivity.

Understanding that MainActivity links code and UI helps you control app behavior and respond to user actions.

4

Intermediate

Run the app on emulator or device

🤔Before reading on: do you think the app runs automatically after creation or needs manual start? Commit to your answer.

Concept: Learn how to build and launch your app on a virtual or real Android device.

Use the 'Run' button in Android Studio. Choose an emulator or connect a physical device. The app compiles and installs, then opens showing your UI.

Result

You see your app running on a phone screen, ready for interaction.

Knowing how to run your app is essential to test and see your work in action.

5

Advanced

Modify UI text programmatically

🤔Before reading on: do you think UI text can only be set in XML or also changed in code? Commit to your answer.

Concept: Learn to change UI elements like TextView text from Kotlin code.

In MainActivity.kt, find the TextView by its ID using 'findViewById'. Then set its text property to a new string like 'Welcome to my app!'. This changes the text when the app runs.

Result

The app shows the updated text from code instead of the XML default.

Knowing how to update UI from code allows dynamic and interactive apps that respond to user input or data.

6

Expert

Understand Activity lifecycle basics

🤔Before reading on: do you think an Activity runs once or can restart multiple times during app use? Commit to your answer.

Concept: Learn how Android manages the Activity's states like start, pause, and stop.

An Activity goes through lifecycle stages: created, started, resumed, paused, stopped, and destroyed. Override lifecycle methods like onCreate and onPause to handle these changes. This ensures your app behaves well when users switch apps or receive calls.

Result

Your app manages resources properly and maintains state during interruptions.

Understanding lifecycle prevents common bugs like crashes or lost data when the app is paused or resumed.

Under the Hood

When you launch an Android app, the system creates an Activity instance. This Activity loads the UI layout XML and displays it on the screen. The Activity listens for user actions like taps and runs your Kotlin code to respond. Android manages the Activity lifecycle to optimize memory and performance, pausing or destroying Activities as needed.

Why designed this way?

Android uses Activities to separate different screens and manage resources efficiently on limited mobile devices. This modular design allows apps to handle interruptions gracefully and conserve battery life. Early mobile systems lacked this, causing poor user experience.

┌───────────────┐
│ Android OS    │
│ manages app   │
│ lifecycle     │
└──────┬────────┘
       │
┌──────▼────────┐
│ Activity      │
│ (Main screen) │
│ loads UI XML  │
└──────┬────────┘
       │
┌──────▼────────┐
│ User Interface│
│ shown on screen│
└───────────────┘

Myth Busters - 3 Common Misconceptions

Quick: Do you think the UI layout XML runs code logic? Commit yes or no.

Common Belief: The XML layout file contains the app's logic and controls behavior.

Reality: XML only defines the visual structure; the Kotlin code controls behavior and logic.

Why it matters: Confusing layout with logic leads to trying to put code in XML, which is impossible and causes frustration.

Quick: Do you think the app runs automatically after creation without running it? Commit yes or no.

Common Belief: Once created, the app runs on the device without manual start.

Reality: You must build and run the app manually or set up automation; creation alone does not launch it.

Why it matters: Expecting automatic running causes confusion when the app doesn't appear on the device.

Quick: Do you think an Activity stays alive forever once started? Commit yes or no.

Common Belief: An Activity runs continuously until the app is closed.

Reality: Android can pause, stop, or destroy Activities to save resources; they do not run forever.

Why it matters: Ignoring lifecycle leads to bugs like lost data or crashes when the app is interrupted.

Expert Zone

1

The Activity lifecycle methods are called in a strict order, and missing one can cause subtle bugs in state management.

2

Using view binding or Kotlin synthetic properties simplifies UI code but requires understanding of generated code behind the scenes.

3

Emulators simulate different device configurations; testing on multiple emulators helps catch device-specific UI issues early.

When NOT to use

For very simple apps or quick prototypes, using Android Studio and Activities might be overkill; alternatives like Flutter or web apps can be faster. Also, for apps requiring complex background processing, consider using Services or Jetpack Compose for UI.

Production Patterns

In real apps, developers separate UI code from business logic using patterns like MVVM. They also handle configuration changes and save UI state to provide smooth user experience across device rotations and interruptions.

Connections

Event-driven programming

Builds-on

Understanding that Android apps respond to user events like taps helps grasp how the app reacts dynamically.

State machines

Same pattern

The Activity lifecycle behaves like a state machine with defined states and transitions, which helps in managing app behavior predictably.

Theatre stage management

Builds-on

Just like a stage manager controls scenes and actors on stage, Android manages Activities to show the right screen at the right time.

Common Pitfalls

#1 Trying to change UI text directly in XML after app runs.

Wrong approach:

// Then expecting it to change dynamically without code

Correct approach:

val textView = findViewById(R.id.textView)
textView.text = "New Text"

Root cause:

Misunderstanding that XML is static and UI changes must happen in code.

#2 Not running the app after creating it, expecting it to appear on device.

Wrong approach:

Create project and close Android Studio without clicking Run.

Correct approach:

Click the Run button and select device/emulator to launch the app.

Root cause:

Assuming creation equals execution without manual start.

#3 Ignoring Activity lifecycle and putting all code in onCreate.

Wrong approach:

override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
// All code here
}

Correct approach:

Override onStart, onResume, onPause as needed to manage resources and state.

Root cause:

Not understanding that Activities can pause and resume multiple times.

Key Takeaways

Your first Android app is a simple screen controlled by an Activity class that connects UI and code.

Android Studio is the tool that helps you create, build, and run your app on devices or emulators.

UI layouts are defined in XML files, but dynamic changes happen in Kotlin code.

Running the app manually is necessary to see it on a device or emulator.

Understanding the Activity lifecycle is key to building stable and responsive apps.