Introduction to Android Native Development with Kotlin or Java

Course: React Native Training

Topic: Introduction to Android Native Development with Kotlin or Java

Course Link: React Native Training at JustAcademy

Demo Link: Register for a Course Demo

Additional Resource: JustAcademy Official Website

1. Introduction to Android Native Development

Android native development is the process of creating applications specifically for devices that run the Android operating system. Developers use Android APIs, platform tools, programming languages, and development frameworks to build applications that interact directly with Android features.

Kotlin and Java are two major programming languages used for Android development. Kotlin is the recommended starting point for most new Android projects, while Java remains important for maintaining existing applications and working with established libraries. Official Kotlin and Android documentation provides guidance on using Kotlin for Android development.

1.1 What Is Native Development?

Native development means building software for a particular operating system using its supported tools and APIs. Android native applications can use system services, device hardware, application lifecycle APIs, notifications, storage, and platform-specific user interface components.

• Native applications can interact with Android platform APIs.
• They can use device capabilities such as the camera, GPS, sensors, and Bluetooth when supported and permitted.
• They can use Android-specific UI components and navigation patterns.
• They can be packaged and distributed through supported Android distribution channels.
• They can integrate with Android libraries and third-party SDKs.

1.2 Why Is Native Android Knowledge Important for React Native Developers?

React Native enables developers to create mobile applications using JavaScript or TypeScript and React. However, a React Native application still has a native Android project that manages Android-specific configuration and integration.

• Understand how React Native applications are built for Android.
• Identify the source of Android-specific build and runtime errors.
• Configure permissions and application metadata.
• Integrate native Android libraries and SDKs.
• Develop custom native modules when existing JavaScript libraries are insufficient.
• Understand the relationship between JavaScript code and native Android code.

2. Learning Objectives

After completing this topic, learners should be able to:

• Explain Android native development and its major components.
• Compare Kotlin and Java for Android programming.
• Understand the roles of Android Studio, Android SDK, Gradle, and the emulator.
• Recognize the main folders and files in an Android project.
• Understand basic Kotlin and Java syntax.
• Explain activities, intents, lifecycle callbacks, and resources.
• Understand Android permissions and device APIs.
• Recognize how Kotlin and Java can support React Native projects.
• Build, run, and troubleshoot a basic Android application.

3. Understanding the Android Platform

Android is an operating system that provides an environment for mobile applications and other supported device types. It includes system services, runtime components, application APIs, security mechanisms, and tools that developers use to build software.

3.1 Major Android Development Components

3.2 Android Application Formats

• APK: An Android application package that can be installed on compatible devices.
• AAB: Android App Bundle, a publishing format used by Google Play to generate optimized APKs for supported devices.

During development, developers commonly build debug versions of an application. Release versions require appropriate signing and configuration before distribution.

4. Introduction to Kotlin

Kotlin is a statically typed programming language developed by JetBrains. It works with Java and is widely used for modern Android development. Kotlin offers concise syntax, null-safety features, extension functions, data classes, and coroutine support.

4.1 Important Kotlin Features

• Concise syntax: Reduces boilerplate code for many common programming tasks.
• Null safety: Distinguishes nullable and non-nullable types in the type system.
• Type inference: Allows the compiler to infer many variable types.
• Data classes: Simplify classes used mainly to hold data.
• Extension functions: Add callable functionality to existing types without modifying their original definitions.
• Coroutines: Support structured asynchronous programming.
• Java interoperability: Allows Kotlin to work with Java classes and libraries.

4.2 Kotlin Variables

fun main() {
    val appName = "My Android App"
    var launchCount = 1
    launchCount += 1
    println(appName)
    println(launchCount)
}

The val keyword declares a read-only reference, while var declares a reassignable variable. Kotlin can infer the type when it is clear from the assigned value.

4.3 Kotlin Functions

fun greetUser(name: String): String {
    return "Welcome, $name!"
}

fun main() {
    println(greetUser("Alex"))
}

The function accepts a string parameter and returns a greeting. Functions help developers organize code into reusable units.

4.4 Kotlin Classes and Objects

class User(val name: String, val age: Int) {
    fun getMessage(): String {
        return "Hello, $name"
    }
}

fun main() {
    val user = User("Alex", 25)
    println(user.getMessage())
}

A class defines properties and behavior. An object is an instance of a class. Classes can represent users, products, settings, and other application entities.

4.5 Kotlin Null Safety

fun main() {
    var username: String? = null
    username = "Alex"
    println(username?.uppercase())
}

The question mark in String? indicates that the variable can hold a null value. The safe-call operator ?. accesses a property or method only when the reference is not null. Null safety reduces common errors but does not eliminate every possible runtime problem.

5. Introduction to Java

Java is a widely used object-oriented programming language with a mature ecosystem of libraries and development tools. It has been used extensively in Android development and remains valuable when working with existing applications or Java-based dependencies.

5.1 Important Java Concepts

• Classes and objects: Organize application logic into reusable structures.
• Data types: Define the kinds of values that variables can store.
• Methods: Define operations that can be performed by classes or objects.
• Encapsulation: Controls access to an object's internal state.
• Inheritance: Allows one class to derive behavior from another class.
• Interfaces: Define contracts that classes can implement.
• Exception handling: Provides mechanisms for responding to exceptional conditions.

5.2 Java Variables

public class Main {
    public static void main(String[] args) {
        String appName = "My Android App";
        int launchCount = 1;
        launchCount++;
        System.out.println(appName);
        System.out.println(launchCount);
    }
}

5.3 Java Methods

public class Greeting {
    public static String greetUser(String name) {
        return "Welcome, " + name + "!";
    }

    public static void main(String[] args) {
        System.out.println(greetUser("Alex"));
    }
}

5.4 Java Classes and Objects

public class User {
    private final String name;
    private final int age;

    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getMessage() {
        return "Hello, " + name;
    }
}

This example demonstrates encapsulation through private fields and a constructor that initializes the object.

6. Kotlin vs. Java

Recommendation: Learn Kotlin first if you are beginning modern Android development. Learn to read Java as well because many existing Android projects contain Java code.

7. Setting Up the Android Development Environment

Android Studio provides an integrated environment for writing code, managing dependencies, building applications, testing interfaces, and debugging problems. The official Android Studio introduction explains its core features and project structure.

7.1 Essential Tools

7.2 Installation Steps

1. Download Android Studio from the official Android developer website.
2. Install the application and follow the setup wizard.
3. Install a suitable Android SDK platform and the required build tools.
4. Create an Android Virtual Device or prepare a compatible physical Android device.
5. Create a new Android project and choose an appropriate template.
6. Select Kotlin or Java where the template supports that choice.
7. Allow Gradle to synchronize the project.
8. Run the application and confirm that it launches successfully.

Check compatibility between the Android Studio version, Android Gradle Plugin, Gradle, and JDK before changing versions in an existing project.

8. Creating Your First Android Project

8.1 Project Creation Workflow

1. Open Android Studio and select the option to create a new project.
2. Choose a suitable starter template, such as an Empty Activity.
3. Enter the application name and package name.
4. Choose the programming language if the template offers a choice.
5. Set the minimum supported Android API level based on application requirements.
6. Finish creating the project and wait for synchronization.
7. Run the starter application on an emulator or physical device.

8.2 Understanding the Project Structure

MyAndroidApp/
├── app/
│   ├── src/
│   │   ├── main/
│   │   │   ├── java/ or kotlin/
│   │   │   ├── res/
│   │   │   └── AndroidManifest.xml
│   │   ├── test/
│   │   └── androidTest/
│   └── build.gradle.kts
├── gradle/
├── build.gradle.kts
├── settings.gradle.kts
└── gradle.properties

This is a simplified example. The actual file structure depends on the project template and configuration.

9. Android Application Components

Android applications use system-managed components to provide screens, handle actions, respond to events, and expose data. Understanding the component model helps developers build applications that behave correctly across lifecycle changes.

Not every application requires all these components. Their configuration and use should follow Android's security and lifecycle requirements.

10. Understanding Activities and the Lifecycle

An Activity is an Android component commonly used to represent a screen or user-interaction entry point. Android manages activity lifecycle callbacks as the user navigates through the application or as system conditions change.

10.1 Common Lifecycle Methods

• onCreate() initializes the activity and its initial state.
• onStart() is called when the activity becomes visible.
• onResume() is called when the activity enters the foreground interaction state.
• onPause() indicates that the activity is losing the foreground interaction state.
• onStop() is called when the activity is no longer visible.
• onDestroy() is called when the activity is being destroyed, but applications must not rely on it for every process termination.

10.2 Basic Activity in Kotlin

package com.example.myandroidapp

import android.os.Bundle
import androidx.activity.ComponentActivity

class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        // Initialize the activity here.
    }
}

10.3 Basic Activity in Java

package com.example.myandroidapp;

import android.os.Bundle;
import androidx.activity.ComponentActivity;

public class MainActivity extends ComponentActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        // Initialize the activity here.
    }
}

These examples demonstrate the basic lifecycle entry point. A complete application must also configure or render its user interface using the approach supported by the project.

10.4 Why the Lifecycle Matters

• It helps applications manage resources correctly.
• It helps preserve user interface state when screens are recreated.
• It reduces the risk of memory leaks and unnecessary background operations.
• It helps developers respond to navigation and system interruptions.

11. Android User Interface Development

Android interfaces can be built with traditional XML layouts and View-based components or with Jetpack Compose, a declarative user interface toolkit designed for Kotlin.

11.1 XML Layouts and Views

Traditional Android applications often define layouts in XML and use View components such as TextView, Button, EditText, and layout containers.

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    android:padding="16dp">

    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Welcome to Android" />

</LinearLayout>

This example displays a text label in a vertical layout. XML layout resources are commonly stored in the res/layout directory.

11.2 Jetpack Compose

Jetpack Compose allows developers to describe user interfaces using Kotlin functions annotated with @Composable. UI content responds to state changes through recomposition.

@Composable
fun WelcomeMessage() {
    Text(text = "Welcome to Android")
}

This example requires the relevant Compose dependencies and imports. Compose is especially relevant for modern Kotlin-based Android projects.

11.3 XML vs. Jetpack Compose

12. Intents and Android Navigation

An Intent describes an action to perform, such as starting an activity or asking another eligible component to handle an operation. Explicit intents identify a particular component, while implicit intents describe an action that another component may handle.

12.1 Explicit Intent in Kotlin

val intent = Intent(this, DetailsActivity::class.java)
startActivity(intent)

12.2 Explicit Intent in Java

Intent intent = new Intent(MainActivity.this, DetailsActivity.class);
startActivity(intent);

12.3 Common Uses of Intents

• Navigating between activities.
• Opening supported external applications.
• Sharing content with compatible applications.
• Launching supported system interfaces.
• Passing small amounts of data between components.

Always validate incoming intent data. Avoid placing passwords, authentication tokens, or sensitive information in unprotected intent extras.

13. Android Resources and the Manifest

Android resources keep reusable content separate from application logic. The manifest provides essential information about application components and configuration.

13.1 Common Resource Types

13.2 Example String Resources

<resources>
    <string name="app_name">My Android App</string>
    <string name="welcome_message">Welcome to Android</string>
</resources>

Centralizing strings makes it easier to maintain content and support multiple languages.

13.3 Understanding AndroidManifest.xml

<manifest xmlns:android="http://schemas.android.com/apk/res/android">
    <application
        android:label="@string/app_name"
        android:allowBackup="true">
        <!-- Declare application components here. -->
    </application>
</manifest>

This is an illustrative fragment. A complete application may need additional attributes, component declarations, and configuration based on its functionality.

14. Android Permissions and Device Features

Applications must follow Android permission rules when accessing protected features or user data. Some permissions must be declared in the manifest and also requested from the user at runtime.

14.1 Examples of Permissions

• android.permission.CAMERA for camera access.
• android.permission.ACCESS_FINE_LOCATION for precise location access when required.
• android.permission.RECORD_AUDIO for microphone access.
• android.permission.POST_NOTIFICATIONS for runtime notification permission on Android versions where it applies.

14.2 Permission Best Practices

• Request only the permissions needed by the application.
• Explain why a permission is needed when appropriate.
• Handle permission denial gracefully.
• Check the current permission status before performing a protected operation.
• Follow platform requirements for the application's target SDK and Android version.
• Protect sensitive information and avoid unnecessary data collection.

15. Background Work and Asynchronous Operations

Lengthy operations should not block the Android main thread. Network requests, database operations, and time-consuming file operations should use appropriate asynchronous or background execution mechanisms.

15.1 Kotlin Coroutines

Kotlin coroutines support structured concurrency and are widely used for asynchronous operations in modern Android applications.

// Illustrative pattern inside an appropriate
// lifecycle-aware Android component.
lifecycleScope.launch {
    val result = withContext(Dispatchers.IO) {
        // Perform suitable background work here.
        "Operation completed"
    }
    // Handle the result on the main thread.
    println(result)
}

This pattern requires suitable coroutine and lifecycle dependencies. Production code should handle exceptions, cancellation, and UI state updates explicitly.

15.2 Background Work in Java

Java applications can use executors, threads, callbacks, and Android-supported scheduling APIs. The appropriate option depends on whether the work is short-lived, associated with a visible screen, or must be scheduled reliably after the application moves to the background.

16. Gradle and Android Build Configuration

Gradle automates compilation, dependency resolution, testing, resource processing, and packaging. Android projects commonly use the Android Gradle Plugin to add Android-specific build capabilities.

16.1 Important Build Concepts

• Project-level configuration: Defines shared build configuration and plugin versions.
• Module-level configuration: Defines application or library settings and dependencies.
• Compile SDK: Specifies the Android API level used to compile the application.
• Minimum SDK: Specifies the lowest Android API level supported by the application.
• Target SDK: Indicates the API level the application targets for platform behavior and compatibility requirements.
• Dependencies: External libraries and modules required by the project.
• Build variants: Allow different build configurations, such as debug and release.

16.2 Common Gradle Commands

# Windows
gradlew.bat assembleDebug
gradlew.bat testDebugUnitTest

# macOS or Linux
./gradlew assembleDebug
./gradlew testDebugUnitTest

Run commands from the project directory containing the Gradle wrapper. Available tasks depend on the project's configuration.

17. Android Debugging and Testing

Testing helps verify that an application behaves correctly, while debugging helps identify the cause of unexpected behavior. Android Studio includes logging, breakpoints, device emulation, and diagnostic tools.

17.1 Common Debugging Tools

• Logcat: Displays application and system log messages.
• Debugger: Supports breakpoints, step-by-step execution, and variable inspection.
• Android Emulator: Tests applications on virtual devices.
• Layout Inspector: Helps inspect supported UI hierarchies.
• Profiler: Helps analyze CPU, memory, and network activity.
• ADB: Supports device communication and diagnostic tasks.

17.2 Types of Android Tests

18. Relationship Between Android Native Development and React Native

React Native lets developers create mobile applications using JavaScript or TypeScript while integrating with native platform functionality. The Android portion of a React Native application contains native configuration, build scripts, and code used to produce the Android application.

18.1 How Native Android Code Supports React Native

• Gradle builds the Android application and integrates dependencies.
• The Android manifest declares relevant permissions and application components.
• Native code can integrate Android SDKs and platform services.
• Native modules can expose selected Android functionality to JavaScript or TypeScript.
• Native debugging tools help diagnose problems that cannot be resolved solely in JavaScript.

18.2 When React Native Developers Need Kotlin or Java

• Integrating an Android SDK without a suitable React Native library.
• Creating a custom native module.
• Modifying Android-specific configuration.
• Investigating Android build errors.
• Handling platform-specific permissions and functionality.
• Maintaining existing native Android code.

18.3 Simplified React Native Project Structure

MyReactNativeApp/
├── android/
│   ├── app/
│   │   ├── src/
│   │   │   └── main/
│   │   │       ├── AndroidManifest.xml
│   │   │       └── java/ or kotlin/
│   │   └── build.gradle
│   ├── build.gradle
│   └── settings.gradle
├── src/
├── package.json
└── App.tsx

This is a simplified illustration. Actual folder names and files vary by React Native version and project configuration.

19. Introduction to Native Modules

A native module allows React Native applications to access functionality implemented in platform-specific code. On Android, that code may be written in Kotlin or Java. The implementation approach depends on the React Native version and architecture.

19.1 Common Use Cases

• Integrating a specialized Android SDK.
• Accessing platform functionality that is not covered by an existing package.
• Exposing a native service to JavaScript or TypeScript.
• Wrapping functionality from an existing Android library.
• Supporting device capabilities required by a particular application.

19.2 Before Creating a Native Module

• Check whether an existing React Native package already solves the problem.
• Confirm that the package supports the project's React Native version.
• Review Android permission and security requirements.
• Plan how errors and asynchronous results will be communicated to JavaScript.
• Test the integration on emulators and physical devices.
• Document the setup and maintenance requirements.

20. Common Errors and Troubleshooting

20.1 Systematic Troubleshooting Process

1. Reproduce the issue and record the exact steps.
2. Read the complete error message and stack trace.
3. Identify whether the problem belongs to application code, Android configuration, Gradle, or a third-party library.
4. Review recent code and configuration changes.
5. Check SDK, JDK, Gradle, plugin, and dependency compatibility.
6. Make one targeted change at a time.
7. Rebuild and rerun the affected workflow.
8. Document the root cause and the verified solution.

21. Development and Security Best Practices

• Use Kotlin for most new native Android code unless project requirements suggest otherwise.
• Learn to read Java code when working with existing applications and libraries.
• Keep passwords, tokens, and private keys out of source code.
• Request only the permissions needed by the application.
• Validate data received from intents, external applications, and network services.
• Avoid blocking the main thread with lengthy operations.
• Handle exceptions and permission denial gracefully.
• Use lifecycle-aware approaches to manage resources and background tasks.
• Keep dependencies and build tools compatible and maintained.
• Test across relevant Android API levels, screen sizes, and device configurations.
• Use version control to track native project changes.
• Consult official Android documentation when platform behavior differs by version.

22. Practical Project: Build a Simple Welcome Application

The objective is to create a basic Android application that displays a welcome message and updates it when the user taps a button.

22.1 Requirements

• Create an Android Studio project.
• Use Kotlin or Java.
• Display a welcome message.
• Add a button that responds to a tap.
• Run the application on an emulator or physical device.
• Use Logcat to inspect any errors.

22.2 Kotlin Button Interaction

button.setOnClickListener {
    textView.text = "Welcome! Your app is running."
}

22.3 Java Button Interaction

button.setOnClickListener(view -> {
    textView.setText("Welcome! Your app is running.");
});

Both snippets assume that the button and text view have already been initialized correctly using the UI approach chosen for the project.

22.4 Testing Checklist

• Does the application build without errors?
• Does the welcome message appear on launch?
• Does tapping the button update the message?
• Does the application respond correctly to supported lifecycle changes?
• Are runtime errors visible in Logcat?
• Does the application work on another emulator configuration or device?

23. Interview Questions and Answers

Q1. What is Android native development?

Answer: It is the process of building Android applications using Android development tools, platform APIs, and supported programming languages such as Kotlin and Java.

Q2. Which language should a beginner learn for new Android development?

Answer: Kotlin is the recommended starting point for most new Android development. Java remains important for existing applications and libraries.

Q3. Can Kotlin and Java be used in the same project?

Answer: Yes. Kotlin and Java can interoperate, allowing developers to combine Kotlin code with Java classes and libraries.

Q4. What is Android Studio?

Answer: Android Studio is the official integrated development environment for writing, building, testing, and debugging Android applications.

Q5. What is the Android SDK?

Answer: The Android SDK provides platform APIs and development tools used to build and test Android applications.

Q6. What is Gradle?

Answer: Gradle is a build automation system used to compile code, manage dependencies, run tasks, and package applications.

Q7. What is an Activity?

Answer: An Activity is an Android component commonly used as a screen or user-interaction entry point.

Q8. What is AndroidManifest.xml?

Answer: It declares essential application information, components, permissions, and configuration.

Q9. What is Kotlin null safety?

Answer: Kotlin's type system distinguishes nullable and non-nullable references, helping developers identify and handle null values more safely.

Q10. What is Jetpack Compose?

Answer: Jetpack Compose is a declarative UI toolkit for building native Android interfaces using Kotlin.

Q11. What is an Intent?

Answer: An Intent describes an action to perform, such as starting an activity or requesting an operation from another eligible component.

Q12. Why is the Android lifecycle important?

Answer: Lifecycle knowledge helps developers manage resources, preserve state, and respond correctly when screens become visible, move to the background, or are recreated.

Q13. Why should long operations not block the main thread?

Answer: Blocking the main thread can make the interface unresponsive. Suitable asynchronous and background approaches help maintain responsiveness.

Q14. Why might a React Native developer need Kotlin or Java?

Answer: Native code may be required to integrate Android SDKs, create native modules, modify Android configuration, or troubleshoot native build and runtime issues.

Q15. How do you investigate an Android crash?

Answer: Reproduce the crash, inspect Logcat and the stack trace, identify the relevant exception, examine recent changes, and test a targeted fix.

24. Practice Exercises

1. Install Android Studio and create a basic Android project.
2. Write a Kotlin function that accepts a name and returns a greeting.
3. Write the same function in Java and compare the syntax.
4. Create a welcome screen using XML layouts or Jetpack Compose.
5. Add a button that updates a text label when tapped.
6. Identify the manifest, source files, resources, and Gradle files in the project.
7. Use Logcat to inspect application messages.
8. Research how to request a runtime permission for a device feature.
9. Open a React Native project's Android folder and identify its main configuration files.
10. Write a short explanation of when a React Native project might require native Android code.

25. Quick Revision Checklist

• Understand native Android development and its purpose.
• Know the differences between Kotlin and Java.
• Recognize the roles of Android Studio, SDK, emulator, and Gradle.
• Understand the basic Android project structure.
• Know basic Kotlin and Java syntax.
• Understand activities and lifecycle callbacks.
• Know the purpose of layouts, resources, and the manifest.
• Understand intents, permissions, and device APIs.
• Know how to use Logcat and the debugger.
• Understand why React Native projects contain native Android configuration.
• Recognize when a native module may be needed.
• Practice building, running, testing, and troubleshooting an Android application.

26. Conclusion

Android native development provides the foundation for creating applications that use Android APIs, system services, and device capabilities. Kotlin is a strong starting point for new Android projects because it offers concise syntax, null-safety features, and modern tooling support. Java remains useful for understanding existing codebases and maintaining applications that use Java-based libraries.

For React Native developers, understanding native Android development helps with build troubleshooting, platform-specific configuration, permission handling, and custom native integration. Begin with programming fundamentals, learn the Android project structure, create a simple application, and then explore lifecycle management, asynchronous operations, testing, and native modules.

Course Resource: Visit React Native Training at JustAcademy, register through the Course Demo Registration page, or explore the JustAcademy official website.