Android Tutorial for Beginners

Introduction

Frustrated with outdated tutorials and the steep learning curve of core concepts such as the Activity Lifecycle and threading in Android? You are not alone! This Android Tutorial for Beginners, geared towards beginners, breaks down complex topics into clear, practical steps using modern best practices, Kotlin and Jetpack Compose. 

Stop guessing and start coding with confidence! Ready for the roadmap to becoming an Android Developer? Download the full Android developer course syllabus now!

Why Students or Freshers Learn Android?

Here are the reasons for students or freshers learn Android:

• Massive Market Share: Android is the leader of the mobile OS market worldwide, hence offering a very huge user base for your apps and skilled developers in high demand.
• Lucrative Career: Competitive salaries, good prospects for growth, and a wide range of roles from Junior Developer to Team Lead.
• Open-Source Advantage: Android is open-source, which translates to free tools and an enormous, supportive community for learning, troubleshooting, and continuous improvement.
• Easy to Start: Resources like Google’s official courses and modern tools, such as Kotlin and Jetpack Compose, make the learning curve a lot easier for starters.
• Real-World Impact: You turn creative ideas into real, user-friendly applications that billions of people use each day.

Ready to ace your job search? Download our essential Android Interview Questions and Answers!

Step-by-Step Android Developer Tutorial for Beginners

This Android developer tutorial will walk you through setting up your environment and building your first simple app using Kotlin and Jetpack Compose, the modern, recommended way to build UIs on Android.

Step 1. Installation and Setup: The Foundation

The first step and most importantly, is how to set up your IDE: Android Studio.

1.1. Install Android Studio

1. System Check: Make sure your computer meets the recommended system requirements.
   • Example: Minimum 8 GB of RAM; recommended 16 GB, 64-bit Operating System.
2. Download: Go onto the official download page of Android Studio and download the installer for your operating system (for Windows, macOS, or Linux).
3. Installation: Run the downloaded installer.
   • Follow the on-screen instructions:
   • Click Next to accept the default components to be installed, typically Android Studio itself and the necessary Android SDK.
   • Finish installing and open the application Android Studio.

1.2. Set up the Android SDK

When you open Android Studio for the first time, the Setup Wizard will pop up.

1. SDK Components: The wizard will lead you through downloading the necessary components such as the latest Android Platform SDK. Just accept the defaults and click Finish.
2. SDK Manager Check: (Recommended): Once the main screen has loaded, select Tools → SDK Manager.
   • In the SDK Platforms tab, make sure that the most updated stable Android version is selected.
   • Inside the SDK Tools tab, ensure the Android SDK Build → Tools, Android Emulator, and Android SDK Platform → Tools are checked and installed.

1.3. Create an Android Virtual Device (AVD)

You need a virtual device-emulator-to test your app without the phone itself.

1. Navigate to Tools → Device Manager.
2. Click the Create Device button or click the + icon.
3. Select Hardware: Select a recent phone profile, say Pixel 8, and click Next.
4. System Image: Under the Recommended tab, select a recent stable API Level, such as API 34/35. If the image is not already downloaded, you will see a Download link beside the image to download it.
5. Configuration: Click Next, give your AVD an easyto-remember name if you want, and click Finish.

Step 2. Creating Your First Project

Now, let’s create a simple “Hello World” app using Jetpack Compose.

1. From the Android Studio welcome screen, select New Project.
2. Choose a Template: In the Phone and Tablet tab, select the Empty Activity template. This is the modern template that uses Compose by default. Click Next.
3. Configure Your Project:
   • Name: MyFirstApp
   • Package name: com.example.myfirstapp (Conventionally, this uses your domain name in reverse, e.g., com.yourcompany.appname).
   • Save location: Choose a folder on your computer.
   • Language: Kotlin (The modern standard).
   • Minimum SDK: Use a recent API level-such as API 24 or 26-to be compatible with the majority of active devices.
4. Click Finish. Android Studio will take a moment to set up the project and download its dependencies (Gradle sync).

Step 3. Understanding the Project Structure

Get familiarized with yourself with the key files and folders in the Project view – select the Android view for the most relevant structure:

• app/java/com.example.myfirstapp: Contains your Kotlin source code files (for example, MainActivity.kt).
• app/res (Resources): Houses all non-code resources.
  • drawable: Images and icons.
  • layout: Traditional XML layout files. (Not used much with Compose)
  • mipmap: Launcher icons for your app.
  • values: XML files for common resources: colors.xml, strings.xml, and themes.xml.
• app/manifests/AndroidManifest.xml: The blueprint of your app; declares all its components – activities, services, needed permissions like Internet access, and a minimum required API level.
• Gradle Scripts: Here you will find configuration files for builds. The module-level build.gradle, such as app/build.gradle, is where you should declare the dependencies for your app, namely external libraries.

Step 4. Building the UI with Jetpack Compose

Jetpack Compose is the modern, declarative UI toolkit of Android. You describe your UI by calling functions that are referred to as Composables.

4.1. The Default Composable

Open your main code file: app/java/com.example.myfirstapp/MainActivity.kt

You will see the basic structure:

// MainActivity.kt (Simplified)

package com.example.myfirstapp

import android.os.Bundle

import androidx.activity.ComponentActivity

import androidx.activity.compose.setContent

import androidx.compose.material3.Text

import androidx.compose.runtime.Composable

import androidx.compose.ui.tooling.preview.Preview

class MainActivity : ComponentActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {

        super.onCreate(savedInstanceState)

        setContent {

            // MyFirstAppTheme is defined in ui.theme

            MyFirstAppTheme { 

                Greeting(“Android”) // Calls the main UI function

            }

        }

    }

}

@Composable

fun Greeting(name: String) {

    Text(text = “Hello $name!”)

}

@Preview(showBackground = true)

@Composable

fun GreetingPreview() {

    MyFirstAppTheme {

        Greeting(“Android”)

    }

}

• MainActivity: This is the main Activity for your app, the entry point. The onCreate function is called when the screen is first created.
• setContent {…}: This is the key line for Compose. It defines the root of your Composable UI tree.
• @Composable: This annotation marks a function as a Composable—a UI element that describes part of your screen.
• Text(): This is a built-in Composable that shows text.

4.2. Modifying the UI: A Clickable Button

Now, change the simple text to a slightly more complicated layout that includes a button and updates a counter when clicked.

In MainActivity.kt change the code to the following. We are going to add a Column for vertical arrangement and remember/mutableStateOf to handle state.

// In MainActivity.kt

import androidx.compose.foundation.layout.Column

import androidx.compose.foundation.layout.padding

import androidx.compose.material3.Button

import androidx.compose.material3.Surface

import androidx.compose.runtime.getValue

import androidx.compose.runtime.mutableIntStateOf // Use mutableIntStateOf for cleaner integer state

import androidx.compose.runtime.remember

import androidx.compose.runtime.setValue

import androidx.compose.ui.Modifier

import androidx.compose.ui.unit.dp

// … (Keep the imports, MainActivity class, and onCreate function the same)

// The new main Composable function for our app

@Composable

fun CounterApp() {

    // 1. State Management: The ‘count’ variable will trigger a UI update when its value changes.

    var count by remember { mutableIntStateOf(0) }

    Surface(modifier = Modifier.padding(16.dp)) { // Surface provides a background and padding

        Column { // Arranges items vertically

            // 2. Display the current count

            Text(text = “The button has been clicked $count times!”,

                 modifier = Modifier.padding(bottom = 16.dp))

            // 3. Button with an action

            Button(onClick = { 

                // When clicked, update the state, which automatically redraws the UI

                count++ 

            }) {

                Text(“Click Me!”)

            }

        }

    }

}

// 4. Update the GreetingPreview and onCreate to use CounterApp

@Preview(showBackground = true)

@Composable

fun CounterAppPreview() {

    MyFirstAppTheme {

        CounterApp()

    }

}

Now, modify the call in onCreate of MainActivity.kt:

Step 5. Running Your Application

You have three main ways to run your app:

5.1. Running on the Emulator (AVD)

1. Check the toolbar for the Device Selector dropdown menu- it may display “No Device” or the name of a previously created device.
2. If you already have an AVD then select it, otherwise click on Device Manager to create one as early mentioned in Step 1.3.
3. Click the Run App (green triangle) button in the toolbar.
4. Android Studio will now compile your app (Gradle does the work) and start the emulator. You should see your simple counter app!

5.2. Running on a Physical Device (USB Debugging)

This is often faster and more realistic for testing.

1. Enable Developer Options on your Android phone:
   • Go to Settings → About Phone.
   • Tap the Build number seven times until you see a message that says “You are now a developer!
2. Enable USB Debugging:
   • Go to Settings → System → Developer options.
   • Enable USB debugging.
3. Connect: Use a USB cable to connect your phone to your computer.
4. A popup may appear on your phone asking to “Allow USB debugging.” Just tap OK.
5. At this point, your device should be listed in Android Studio’s Device Selector. Select it, then click the Run App button.

5.3. Using the Preview Pane

For a quick UI check in Compose, you don’t even need to run the app.

• Make sure you’re looking at the MainActivity.kt file.
• On the right-hand side of the editor, there are options to toggle between Split or Design view.
• The @Preview function below, CounterAppPreview, will render automatically in the Design/Preview pane so you can immediately see UI changes as you type.

6. Key Concepts Explained

As a beginner, understanding these terms is important:

• Activity: A single, focused thing that the user can do. In our app, MainActivity is the primary screen. An app is a collection of activities.
• Manifest: The main configuration file, which declares all the components of your app, any permissions that the app requires, such as CAMERA and INTERNET, and also the activity that should launch when the app starts.
• Resources/ res folder: This is all the static content your app uses which isn’t code. This includes:
  • Strings: The resource file containing all visible text is res/values/strings.xml. Best Practice Never hardcode text directly in the Kotlin code; use string resources for easier localization and maintenance.
  • Drawables: Images and icons.
• Kotlin: This is a modern language for Android app development. It’s more compact, null-safe, and interoperable with Java.
• Jetpack Compose: The new, modern Android toolkit for native UI. It is declarative, which allows you to describe how the UI should appear for any given state, and Compose takes care of the rest.
• State: Anything that can change over time and affects the UI. For example, in our JetNews app, the count variable is our state. If the state changes, Compose automatically recomposes (redraws) the composables that read it – in other words, Compose makes your UI reactive.

You now have your environment set up and your first reactive Android application built. The road to being a great developer involves continued practice. Now, it’s time you start challenging yourself with hands-on coding exercises.

Ready to move from tutorials to true app development skills? Download our set of 10 Beginner Android Developer Challenges and Solutions and put your new knowledge to practice developing a simple To-Do List, Calculator, and more! Start coding and speed your learning!

Real Time Examples for Android Tutorial for Learners

The best way to learn Android is by building real-world applications. Following are some practical project ideas to help solidify core concepts and modern practices-Kotlin & Compose:

Simple Calculator Application

• Concepts Learned: User input handling, state management (remember/mutableStateOf), basic arithmetic logic, using Compose layouts (Row, Column)
• Objective: Create a functional app with number buttons and operation buttons.

To-Do List Manager

• Concepts Learned: Handling dynamic lists using Compose’s LazyColumn builtin equivalent of Recycler View, handling item addition and deletion, and persisting them using Shared Preferences or a local Room Database.
• Goal: A basic task list application with check and uncheck functionality.

Basic Weather Application – API Integration

• Concepts Learned: How to make network requests with libraries like Ktor or Retrofit, how to parse the JSON data, handle background tasks and threading, use of Coroutines, and show dynamic data in the UI.
• Goal: Get the current weather from a public API, such as OpenWeatherMap and display it.

Get our list of comprehensive Android Project Ideas for Beginners, complete with feature requirements! 

FAQs About Android Tutorial for Beginners

Conclusion

You have successfully set up Android Studio, created a functional app using Kotlin and Jetpack Compose, and understood the core components. Well, this is your foundation, and now you need to go from simple tutorials to creating production-ready apps featuring complex database management, network calls (APIs), and advanced architecture patterns like MVVM. Don’t let your progress stop here! Complete our full Android Developer Course in Chennai to take your skills to the next level and build your portfolio of commercial-grade applications!