Welcome to Android Development: What Android Is and How This Course Works

Welcome to the Google Android Studio course at Techbase Academy! Over the next 72 lessons you will go from "I have never written code" to "I can design, build, test and publish a real Android app". This first lesson has no installation and no typing marathon. Its job is to give you a map: what Android actually is, how an app travels from your keyboard to somebody's phone, and how this course is organised so you always know where you are.

Think of it like arriving in a new city. Before you rent a flat and learn the bus routes, you look at a map and learn the names of the main districts. Once you know where the market, the motor park and the school are, every later street makes sense.

By the end of this lesson you will be able to:

• Explain in plain language what Android is and who makes it.
• Describe the layers of the Android software stack, from the Linux kernel up to your app.
• Explain what an APK and an AAB are and why Google Play prefers bundles.
• Explain what ART is and why your Kotlin code needs a "translator" on the phone.
• Name the languages and tools Android developers use today, and why this course uses Kotlin and Jetpack Compose.
• Read a tiny Android app (manifest, activity and Compose function) without being afraid of it.
• Describe the three levels and the six official programmes this course follows.
• Prepare your computer, your account and your mindset for lesson 02.

How this fits the bigger picture: This lesson matches the opening items of Unit 1 in Google's official Android Basics with Compose course: Welcome to Android Basics with Compose, Before you begin and Introduction to Android Studio. It also gives you an overview of everything in this course, which follows every programme on the official Android courses page. Official pages are linked at the end.

Why learn Android at all?

Android runs on billions of active devices worldwide, and in Nigeria and much of Africa it is by far the most common kind of smartphone. That means an app you build can reach real people: a school register for your community, a market price tracker, a booking tool for a salon, a fee reminder for a school. You do not need a company, a licence or a big laptop to start. You need patience, a computer that can run Android Studio, and a plan. This course is the plan.

You need very little. These are the only ideas we assume, and each is explained in a paragraph.

1. You can use a smartphone

You have used apps. You know that tapping an icon opens an app, that apps have screens, and that they sometimes ask permission to use your camera or location. That experience is your best starting point, because a developer is just someone who builds the things you already tap.

2. What is software?

Software is a set of instructions stored as files. The phone's processor follows those instructions. An app is software that a person can install and launch from the home screen. The operating system is also software; it is the program that runs all the other programs and shares the screen, battery, memory and network between them.

3. What is an operating system?

An operating system (OS) is the manager of the device. When two apps both want the screen, the camera or the battery, the OS decides who gets what. Windows, macOS, Linux, iOS and Android are all operating systems. Android is the OS in most phones, tablets, smart TVs, watches and car dashboards you will meet.

4. What is a programming language?

A programming language is a strict way of writing instructions so a machine can follow them. You will meet Kotlin properly in lessons 06 to 14. Today we only look at a few lines so that nothing feels mysterious later.

Android is an open-source mobile operating system led by Google. "Open source" means the core code, the Android Open Source Project (AOSP), is published so manufacturers can build on it. Samsung, Tecno, Infinix, Xiaomi, Nokia and many others take that base, add their own look and features, and ship phones. Google then adds its own apps and services (Google Play, Maps, Gmail and more) on top for devices that meet its compatibility requirements. This is why two Android phones can look different and yet run the same apps.

The layers of Android

Android is built like a tall building. Each floor depends on the floors below it and offers services to the floors above it.

+--------------------------------------------------+
|  YOUR APP and other apps (Kotlin + Compose)      |  <- you work here
+--------------------------------------------------+
|  Android Framework (APIs: Activity, Intent,      |
|  notifications, location, camera, storage)       |
+--------------------------------------------------+
|  Android Runtime (ART)    |  Native libraries    |
|  runs your app's code     |  (graphics, media,   |
|                           |   SQLite, WebView)   |
+--------------------------------------------------+
|  Hardware Abstraction Layer (HAL)                |
|  a common way to talk to camera, audio, sensors  |
+--------------------------------------------------+
|  Linux kernel (drivers, memory, processes,       |
|  security, power management)                     |
+--------------------------------------------------+
|  HARDWARE: CPU, screen, battery, radio, sensors  |
+--------------------------------------------------+

As an app developer you almost always work on the top two floors. You rarely touch the kernel. But knowing the lower floors exist explains many things later, for example why your app is not allowed to read another app's private files (the kernel gives each app its own sandbox).

What is ART?

You write Kotlin, but a phone's processor does not understand Kotlin. The journey looks like this:

Kotlin source (.kt)
      |  Kotlin compiler
      v
Java bytecode (.class)
      |  D8 / R8 tools (dexing and shrinking)
      v
DEX bytecode (classes.dex) packed into the APK / AAB
      |  installed on the phone
      v
ART (Android Runtime): compiles and runs it on the device

ART, the Android Runtime, is the part of Android that runs your compiled app on the device. It uses a mix of strategies, including compiling code ahead of time and compiling frequently used code while the app runs, so apps start quickly and run smoothly. You do not need to manage that. What matters to you: your Kotlin code is turned into a compact format called DEX, and ART is what runs it on every phone.

APK and AAB: the two packages you will meet

When you build an app, Android Studio packages everything into a file.

An APK is really a ZIP archive. It contains your compiled code, your images and layouts, and the manifest that describes the app. An AAB holds the same ingredients, but it lets Google Play generate a smaller download tailored to the user's phone, for example only the screen density and CPU type that phone needs. That matters a great deal for people on limited mobile data. You will build and publish a bundle in lessons 49 to 53.

Google Play and other ways to distribute

Google Play is the main store. Developers register, upload a bundle, fill in a store listing and publish. Apps can also be shared as APK files, through company-internal distribution or through other stores, but Play is where most users look. A whole programme of this course (Google Play Store Listing Certificate) covers it.

Languages and tools

Google announced in 2019 that Android development would be Kotlin-first. Jetpack Compose lets you describe a screen as Kotlin functions instead of writing separate XML files, so there is less to learn and less to keep in sync.

Think about it: Why might a phone maker want an operating system it does not have to write from scratch? (It saves years of work and lets thousands of developers build apps for its phones.)

You will not understand every line yet, and that is perfectly fine. The goal is to see that Android code is made of ordinary, readable pieces.

Piece 1: the manifest

Every app has a file called AndroidManifest.xml. It is the app's identity card, listing screens and permissions.

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android">
 <application
 android:label="Hello Ibadan"
 android:icon="@mipmap/ic_launcher">
 <activity
 android:name=".MainActivity"
 android:exported="true">
 <intent-filter>
 <action android:name="android.intent.action.MAIN" />
 <category android:name="android.intent.category.LAUNCHER" />
 </intent-filter>
 </activity>
 </application>
</manifest>

Reading it aloud: "This app is labelled Hello Ibadan. It has one screen, MainActivity. That screen is the one to open when the user taps the launcher icon." The intent-filter with MAIN and LAUNCHER is what marks the starting screen. Lesson 03 explains every attribute.

Piece 2: an Activity

An Activity is one entry point into your app's UI, roughly "a window of the app".

package com.example.helloibadan
import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.compose.material3.Text
class MainActivity : ComponentActivity() {
 override fun onCreate(savedInstanceState: Bundle?) {
 super.onCreate(savedInstanceState)
 setContent {
 Text("Hello, Ibadan!")
 }
 }
}

When Android starts the screen it calls onCreate. Inside, setContent { ... } says "this is what the screen should show". Here it shows one line of text. You will study this in lesson 15 and the activity lifecycle in lesson 23.

Piece 3: a composable function

In Jetpack Compose the UI is built from small functions marked @Composable.

import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
@Composable
fun Greeting(name: String) {
 Text(text = "Hello, $name!")
}

Call Greeting("Tunde") and the screen shows Hello, Tunde!. Compare that with the older way of writing a layout in XML, an Activity and a lot of glue code. Compose is far shorter.

Piece 4: the build file

Gradle build files tell the tools how to assemble the app. This tiny extract names the app and the Android versions it supports:

android {
 namespace = "com.example.helloibadan"
 defaultConfig {
 applicationId = "com.example.helloibadan"
 minSdk = 24
 }
}

applicationId is the app's unique name on a device and on Google Play. minSdk is the oldest Android version the app supports. Exact numbers change between Android Studio releases, and you will choose them in lesson 03.

Piece 5: what the toolchain does with those files

# A typical command-line build, run in the project folder
# (macOS and Linux)
./gradlew assembleDebug

# (Windows)
gradlew.bat assembleDebug

This asks Gradle to compile everything and produce a debug APK. You will almost never type it, because Android Studio's Run button does it for you, but it is useful to know the button is not magic.

Android has marketing names and numbers (Android 14, Android 15 and so on), but developers care about API levels: a whole number that identifies a version of the Android framework. Each new Android release adds an API level with new features. Three numbers appear in every project:

Jetpack: libraries that smooth out the differences

Phones in the real world run many Android versions. Jetpack is a family of libraries (called androidx) that gives you the same modern tools on old and new phones: Compose, ViewModel, Navigation, Room, WorkManager and many more. You will meet them one by one. When you see an import that starts with androidx., you are using Jetpack.

The three levels

The six programmes this course follows

The official site developer.android.com/courses hosts several programmes. Together they are the official route to becoming an Android developer, and this course walks through all of them in depth.

A map of the course

BEGINNER
  01-05  Android Studio: install, first project, emulator, real phone, Logcat
  06-14  Kotlin: variables, functions, conditions, null safety, classes,
         lambdas, generics, collections
  15-22  First Compose apps: text, images, buttons, debugging, state,
         tests, lists, theming and animation
INTERMEDIATE
  23-27  Lifecycle, ViewModel, UI state, navigation, adaptive layouts
  28-36  Coroutines, HTTP and Retrofit, repositories, Coil, SQL, Flow,
         Room, DataStore, WorkManager
  37-44  Compose in depth, Views, interoperability, Studio power tools
  45-48  Compose testing and accessibility
  49-53  Release and Google Play
ADVANCED
  54-59  Advanced Compose: state, navigation, custom layouts,
         performance, adaptive apps, Wear OS and widgets
  60-65  Architecture: layers, UI, data, domain, offline-first, Hilt
  66-70  Kotlin Multiplatform
  71-72  Capstone project and quick reference

How every lesson is built

Each lesson follows the same rhythm, so you always know what comes next:

1. Lesson Introduction: what you will achieve.
2. Prerequisite Concepts: a refresher so you are never lost.
3. Conceptual Understanding: the ideas, with analogies and diagrams.
4. Worked examples or a step-by-step build: real code and click paths.
5. Guided Practice Exercises: challenges you try before revealing the answer.
6. Common Beginner Mistakes: the errors everyone makes, and the fixes.
7. Knowledge Check: five questions that mirror the official quizzes.
8. Mini project: a small build you can finish in one sitting and add to your GitHub portfolio.

The golden rule: type the code yourself. Copy and paste teaches your fingers nothing. When you hit an error, read it slowly; the first error is usually the real one. Look for the first red message, not the last.

This section matches the official Before you begin item. It is about being ready, not about downloading anything yet.

Your computer

Android Studio is a large program. Google publishes official system requirements, and they change between releases, so always read the current version on the Android Studio install page. As a rough guide, which lesson 02 explains in detail:

If your laptop is modest, do not give up. Lesson 04 covers low-RAM alternatives and lesson 05 shows how to run apps on a real phone, which uses far less of your computer than an emulator.

Your internet connection

The first installation downloads several gigabytes (Android Studio itself is over a gigabyte, plus the SDK and Gradle libraries). Plan to do the first setup on a good connection, perhaps at a hub or a friend's Wi-Fi, and keep the downloaded installer. After that, daily work uses much less data, although every new library you add is downloaded once.

Accounts and habits

• A Google account helps for Android Studio sign-in, Gemini features, and later the Play Console.
• A GitHub account (free) lets you publish each mini project as a portfolio piece.
• Keep one folder for the course, for example techbase-android, and one sub-folder per lesson.
• Study in short regular blocks. Thirty focused minutes a day beats one exhausting Saturday.

A tiny self-check you can do on any computer

Open a terminal (Command Prompt, PowerShell, Terminal or a Linux shell) and run:

# Shows how many CPU cores and what OS you have (Linux)
nproc
uname -a

# Shows free disk space in a readable form (macOS and Linux)
df -h

# Windows (PowerShell): free space on drive C
Get-PSDrive C

You are not looking for a pass mark. You are just learning how much room you have. Write down your RAM and free disk space; you will compare them with the official requirements in the next lesson.

The official course includes an Introduction to Android Studio video. Here is what that video's idea boils down to, in words, so you have it even if you are offline.

Android Studio is Google's official IDE for Android. It combines a code editor, a visual Layout Preview for Compose, a build system, an emulator launcher, a debugger and a Logcat viewer. Everything you need to write, run and fix an app lives in one window.

+---------------------------------------------------------------+
| Menu bar   |  Toolbar: [Run] [Debug] [device list]            |
+------------+--------------------------------------------------+
| Project    |  Code editor                                     |
| tool       |  (your .kt files)                                |
| window     |                                                  |
| (files)    |                                                  |
+------------+--------------------------------------------------+
| Bottom tool windows: Logcat | Build | Run | Terminal          |
+---------------------------------------------------------------+

You will take a full guided tour in lesson 02, and use these windows in every lesson after it. For now, keep this picture in mind: files on the left, code in the middle, messages at the bottom.

These are not code errors yet, but they are the mistakes that stop beginners in their first week.

Mistake #1: Trying to learn everything before starting. The problem: reading about Android for weeks and never installing anything. The fix: follow the lessons in order and type each example. Understanding grows from doing.

Mistake #2: Confusing Android with Android Studio. The problem: Android is the operating system on the phone; Android Studio is the program you use on your computer to build apps. The fix: remember "Studio is the workshop, Android is the road the finished vehicle drives on."

Mistake #3: Confusing Kotlin with Java and thinking you must learn Java first. The problem: old tutorials insist on Java. The fix: you do not need Java first. Kotlin is Google's preferred language and this course teaches it from zero. Kotlin can use Java libraries, so nothing is wasted if you read Java later.

Mistake #4: Copying code you do not understand. The problem: it works until the day it breaks, and then you cannot fix it. The fix: after each snippet, say in your own words what each line does. If you cannot, re-read the explanation before moving on.

Mistake #5: Using a very old tutorial. The problem: Android changes quickly. Screens built with XML layouts, findViewById and the old kapt tool still exist in many blog posts, but modern projects use Compose, version catalogs and KSP. The fix: check the date. If it is more than a couple of years old, prefer the official documentation or this course.

Mistake #6: Downloading Android Studio from a random website. The problem: unofficial copies can contain malware or be badly out of date. The fix: download only from developer.android.com/studio, and compare the checksum if you want to be extra careful (lesson 02 shows how).

Mistake #7: Expecting the emulator to be fast on any machine. The problem: with low RAM or no virtualisation support, the emulator can crawl. The fix: use a real phone (lesson 05) or lighter emulator settings (lesson 04).

Answer each question in your head or on paper, then reveal the answer.

Question 1. Who leads the development of Android, and what is AOSP?

Question 2. What is the difference between an APK and an AAB?

Question 3. What does ART do?

Question 4. Which two things in AndroidManifest.xml make an activity the one that opens when the user taps the app icon?

Question 5. Name the six official programmes this course follows.

Go deeper: official resources

• Android courses: the home of all six official programmes.
• Android Basics with Compose: the full course outline.
• Unit 1, pathway 1: the first official pathway.
• Android Studio and Introduction to Android Studio: download page and tool overview.
• Kotlin documentation: the language reference.