Android BaseActivity Tutorial — Reusable Activity Architecture in Android

In large Android applications, developers often repeat the same code across multiple activities.

Examples:

• Progress dialogs
• Keyboard handling
• Activity transitions
• Internet connection checks
• Permission handling
• Font configuration

To avoid duplicate code and improve maintainability, Android applications commonly use:

BaseActivity

---

What Is BaseActivity?

BaseActivity is a parent activity class that contains:

• Common reusable functionality
• Shared UI behavior
• Global helper methods
• Application-wide configurations

Other activities extend BaseActivity to inherit common features.

---

Why Use BaseActivity?

Without BaseActivity:

• Code duplication increases
• Maintenance becomes difficult
• Bug fixing becomes repetitive
• Project structure becomes messy

BaseActivity centralizes shared functionality.

---

Common Features Inside BaseActivity

• Loading dialogs
• Network state detection
• Keyboard hiding
• Permission helpers
• Activity animations
• Analytics logging
• Crash handling
• Theme handling

---

Modern Android Recommendation

Older Android tutorials use:

android.support.*

which is deprecated.

Modern Android applications should use:

androidx.*

---

Modern BaseActivity Example

package com.example.baseapp;

import android.content.Context;
import android.content.Intent;
import android.os.Bundle;
import android.view.MotionEvent;
import android.view.View;
import android.view.inputmethod.InputMethodManager;
import android.widget.EditText;

import androidx.annotation.Nullable;
import androidx.appcompat.app.AppCompatActivity;

public abstract class BaseActivity
        extends AppCompatActivity {

    @Override
    protected void onCreate(
            @Nullable Bundle savedInstanceState
    ) {

        super.onCreate(savedInstanceState);
    }

    @Override
    public void startActivity(
            Intent intent
    ) {

        super.startActivity(intent);

        overridePendingTransition(
                android.R.anim.fade_in,
                android.R.anim.fade_out
        );
    }

    @Override
    public void onBackPressed() {

        super.onBackPressed();

        overridePendingTransition(
                android.R.anim.fade_in,
                android.R.anim.fade_out
        );
    }

    @Override
    public boolean dispatchTouchEvent(
            MotionEvent event
    ) {

        View view = getCurrentFocus();

        if (view instanceof EditText) {

            int[] coordinates =
                    new int[2];

            view.getLocationOnScreen(
                    coordinates
            );

            float x = event.getRawX()
                    + view.getLeft()
                    - coordinates[0];

            float y = event.getRawY()
                    + view.getTop()
                    - coordinates[1];

            if (
                event.getAction()
                == MotionEvent.ACTION_UP
            ) {

                if (
                    x < view.getLeft()
                    || x > view.getRight()
                    || y < view.getTop()
                    || y > view.getBottom()
                ) {

                    hideKeyboard(view);
                }
            }
        }

        return super.dispatchTouchEvent(
                event
        );
    }

    private void hideKeyboard(
            View view
    ) {

        InputMethodManager manager =
                (InputMethodManager)
                getSystemService(
                        Context.INPUT_METHOD_SERVICE
                );

        if (manager != null) {

            manager.hideSoftInputFromWindow(
                    view.getWindowToken(),
                    0
            );
        }
    }
}

---

Understanding BaseActivity Features

• Common transition animation
• Keyboard auto hide
• Centralized lifecycle behavior
• Shared utility methods

---

How to Use BaseActivity?

Instead of:

extends AppCompatActivity

activities should use:

extends BaseActivity

---

Example Usage

public class MainActivity
        extends BaseActivity {

}

---

What Is AppController?

AppController is commonly an:

Application

class used for:

• Global initialization
• SDK setup
• Analytics setup
• Crash reporting
• Dependency initialization

---

Create AppController.java

package com.example.baseapp;

import android.app.Application;

public class AppController
        extends Application {

    private static AppController
            instance;

    @Override
    public void onCreate() {

        super.onCreate();

        instance = this;
    }

    public static AppController
    getInstance() {

        return instance;
    }
}

---

Add Application Class in Manifest

<application

    android:name=".AppController"

    android:allowBackup="true"

    android:theme="@style/Theme.App">

</application>

---

Why Use Application Class?

Application class initializes components before activities start.

Useful for:

• Firebase
• Crashlytics
• Retrofit
• Dependency Injection
• Logging systems

---

Modern Android Replacements

Older tutorials commonly use:

• Fabric Crashlytics
• Calligraphy fonts
• Manual permission handlers

Modern Android now recommends:

• Firebase Crashlytics
• Material Typography
• Activity Result APIs
• Jetpack libraries

---

Modern Firebase Crashlytics

Instead of:

Fabric.with(this, new Crashlytics());

Modern apps use:

FirebaseCrashlytics

---

Modern Font Recommendation

Instead of Calligraphy library:

• Use XML fonts
• Use Material Typography
• Use Google Fonts

---

Modern Permission Handling

Instead of manual permission managers:

Use:

ActivityResultLauncher

---

Keyboard Handling Explanation

The:

dispatchTouchEvent()

method hides keyboard when user taps outside EditText.

This improves:

• User experience
• Form interaction
• Screen usability

---

Modern Architecture Recommendation

Modern Android apps usually combine:

• BaseActivity
• MVVM Architecture
• ViewBinding
• Dependency Injection
• Navigation Component
• Jetpack Compose

---

BaseActivity vs BaseFragment

BaseActivity	BaseFragment
Activity-level logic	Fragment-level logic
Global UI behavior	Reusable fragment behavior
Transitions/navigation	Fragment-specific logic

---

Modern Jetpack Compose Alternative

Jetpack Compose reduces the need for large BaseActivity classes by:

• Using composables
• Using state hoisting
• Using lifecycle-aware components

---

Common Beginner Mistakes

1. Putting Too Much Logic Inside BaseActivity

Keep BaseActivity lightweight and reusable.

---

2. Memory Leaks

Avoid storing Activity references globally.

---

3. Tight Coupling

Do not place feature-specific code inside BaseActivity.

---

Best Practices

• Keep BaseActivity generic
• Use helper methods carefully
• Avoid unnecessary inheritance
• Use lifecycle-aware components
• Combine with MVVM architecture

---

FAQ

Why use BaseActivity?

BaseActivity reduces duplicate code across multiple activities.

---

Is BaseActivity mandatory?

No. It is an architectural choice.

---

Should all activities extend BaseActivity?

Only if they share common reusable functionality.

---

Conclusion

BaseActivity is a powerful architectural pattern for organizing reusable Android application behavior.

It helps improve maintainability, reduce duplicate code, and centralize common functionality across activities.

Modern Android applications should combine BaseActivity, AndroidX, MVVM architecture, lifecycle-aware components, and scalable project structure for production-grade development.

---

About the Author

Salil Jha is a Full Stack and Mobile Developer specializing in Android, React Native, fintech systems, scalable SaaS platforms, and developer tooling products.

CodeChain Dev — Build Modern Products. Solve Real Problems.