In Android development, managing application state is crucial for creating robust, responsive, and user-friendly applications. Application state refers to the data that an application maintains while it is running, including user inputs, preferences, and session information. Using Object-Oriented Programming (OOP) principles to manage state can help you build scalable and maintainable applications. This blog explores techniques for managing application state in Android using OOP principles, providing best practices and practical examples.

Understanding Application State in Android

Application state in Android can be categorized into several types:

• UI State: Information about the current state of the user interface, such as selected items, form inputs, and navigation history.

• Session State: Data that persists during a user's session, such as login status and temporary user settings.

• Persistent State: Data that remains even after the application is closed, such as user preferences and database entries.

Managing state effectively is essential for ensuring that your application behaves consistently, maintains user context, and provides a smooth user experience across different scenarios, such as screen rotations, backgrounding, and application restarts.

OOP Principles for State Management

Using OOP principles to manage application state involves designing your application’s architecture in a way that encapsulates state, promotes reusability, and facilitates maintenance. Key OOP principles to consider include:

• Encapsulation: Encapsulate state management logic within classes to hide the internal details and expose only the necessary interfaces.

• Abstraction: Abstract state management into reusable components to simplify the overall design and promote code reuse.

• Inheritance: Use inheritance to extend or modify state management behavior without altering the existing code.

• Polymorphism: Implement polymorphism to handle different state scenarios flexibly, allowing the same interface to manage various states.

Techniques for Managing State in Android Using OOP

1. Using ViewModel for UI State Management

The ViewModel class, part of the Android Architecture Components, is designed to store and manage UI-related data in a lifecycle-conscious way. It helps preserve UI state across configuration changes, such as screen rotations.

Example: Using ViewModel to Manage UI State

ViewModel Class:

import androidx.lifecycle.LiveData;
import androidx.lifecycle.MutableLiveData;
import androidx.lifecycle.ViewModel;

public class MainViewModel extends ViewModel {
    private final MutableLiveData<String> userInput = new MutableLiveData<>();

    public LiveData<String> getUserInput() {
        return userInput;
    }

    public void setUserInput(String input) {
        userInput.setValue(input);
    }
}

Activity Implementation:

import androidx.appcompat.app.AppCompatActivity;
import androidx.lifecycle.ViewModelProvider;
import android.os.Bundle;
import android.widget.EditText;
import android.widget.TextView;

public class MainActivity extends AppCompatActivity {
    private MainViewModel viewModel;
    private EditText editText;
    private TextView textView;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        editText = findViewById(R.id.editText);
        textView = findViewById(R.id.textView);

        viewModel = new ViewModelProvider(this).get(MainViewModel.class);
        viewModel.getUserInput().observe(this, input -> textView.setText(input));

        editText.addTextChangedListener(new SimpleTextWatcher() {
            @Override
            public void onTextChanged(CharSequence s, int start, int before, int count) {
                viewModel.setUserInput(s.toString());
            }
        });
    }
}

In this example:

• The MainViewModel class manages the UI state by holding user input.

• The MainActivity observes the LiveData from the ViewModel to update the UI when the data changes, preserving the state across configuration changes.

2. Using Singleton for Global State Management

A singleton class ensures that only one instance of the class exists throughout the application’s lifecycle, making it ideal for managing global state, such as user session data or application settings.

Example: Singleton Pattern for Global State

Singleton Class:

public class SessionManager {
    private static SessionManager instance;
    private String authToken;

    private SessionManager() {
        // Private constructor to prevent instantiation
    }

    public static synchronized SessionManager getInstance() {
        if (instance == null) {
            instance = new SessionManager();
        }
        return instance;
    }

    public void setAuthToken(String token) {
        this.authToken = token;
    }

    public String getAuthToken() {
        return authToken;
    }
}

Usage in Activity:

import androidx.appcompat.app.AppCompatActivity;
import android.os.Bundle;

public class MainActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        SessionManager sessionManager = SessionManager.getInstance();
        sessionManager.setAuthToken("exampleToken");

        String token = sessionManager.getAuthToken();
        // Use the token as needed
    }
}

In this example:

• The SessionManager class follows the Singleton pattern to manage the user session state across the application.

• The MainActivity accesses the global state via the SessionManager instance.

3. Using Repository Pattern for Persistent State Management

The Repository pattern provides a clean API for data access, abstracting the details of data storage and retrieval. It separates the data layer from the rest of the application, making it easier to manage persistent state.

Example: Repository Pattern for Data Management

UserRepository Class:

public class UserRepository {
    private static UserRepository instance;
    private final UserDao userDao;

    private UserRepository(Context context) {
        UserDatabase db = UserDatabase.getInstance(context);
        userDao = db.userDao();
    }

    public static synchronized UserRepository getInstance(Context context) {
        if (instance == null) {
            instance = new UserRepository(context);
        }
        return instance;
    }

    public LiveData<User> getUser(int userId) {
        return userDao.getUserById(userId);
    }

    public void insertUser(User user) {
        userDao.insert(user);
    }
}

Usage in ViewModel:

public class UserViewModel extends ViewModel {
    private final UserRepository userRepository;
    private LiveData<User> user;

    public UserViewModel(Application application) {
        userRepository = UserRepository.getInstance(application);
    }

    public LiveData<User> getUser(int userId) {
        if (user == null) {
            user = userRepository.getUser(userId);
        }
        return user;
    }

    public void insertUser(User user) {
        userRepository.insertUser(user);
    }
}

In this example:

• The UserRepository provides a clean interface for accessing user data, managing the persistent state in the database.

• The UserViewModel interacts with the UserRepository to fetch and manage user data.

4. Using EventBus for Event-Driven State Management

EventBus allows decoupled components to communicate by subscribing and publishing events, making it useful for managing state changes across different parts of the application.

Example: Using EventBus for State Management

Event Class:

public class UserEvent {
    public final String message;

    public UserEvent(String message) {
        this.message = message;
    }
}

Publisher Activity:

import androidx.appcompat.app.AppCompatActivity;
import android.os.Bundle;
import org.greenrobot.eventbus.EventBus;

public class MainActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        // Publish an event
        EventBus.getDefault().post(new UserEvent("User logged in"));
    }
}

Subscriber Activity:

import androidx.appcompat.app.AppCompatActivity;
import android.os.Bundle;
import android.widget.TextView;
import org.greenrobot.eventbus.EventBus;
import org.greenrobot.eventbus.Subscribe;
import org.greenrobot.eventbus.ThreadMode;

public class AnotherActivity extends AppCompatActivity {
    private TextView messageTextView;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_another);
        messageTextView = findViewById(R.id.messageTextView);
    }

    @Override
    public void onStart() {
        super.onStart();
        EventBus.getDefault().register(this);
    }

    @Override
    public void onStop() {
        super.onStop();
        EventBus.getDefault().unregister(this);
    }

    @Subscribe(threadMode = ThreadMode.MAIN)
    public void onUserEvent(UserEvent event) {
        messageTextView.setText(event.message);
    }
}

In this example:

• The UserEvent class represents an event that carries a message.

• MainActivity publishes an event using EventBus.

• AnotherActivity subscribes to the event and updates the UI when the event is received.

5. Using SharedPreferences for Simple Persistent State

SharedPreferences is a lightweight way to store key-value pairs, suitable for managing simple persistent state like user settings and preferences.

Example: Using SharedPreferences for User Settings

SharedPreferences Helper Class:

public class PreferenceManager {
    private static final String PREFERENCES_FILE = "com.example.myapp.PREFERENCES";
    private static final String KEY_USER_NAME = "username";

    private SharedPreferences sharedPreferences;

    public PreferenceManager(Context context) {
        sharedPreferences = context.getSharedPreferences(PREFERENCES_FILE, Context.MODE_PRIVATE);
    }

    public void saveUserName(String userName) {
        SharedPreferences.Editor editor = sharedPreferences.edit();
        editor.putString(KEY_USER_NAME, userName);
        editor.apply();
    }

    public String getUserName() {
        return sharedPreferences.getString(KEY_USER_NAME, "default_name");
    }
}

Usage in Activity:

import androidx.appcompat.app.AppCompatActivity;
import android.os.Bundle;

public class MainActivity extends AppCompatActivity {
    private PreferenceManager preferenceManager;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        preferenceManager = new PreferenceManager(this);
        preferenceManager.saveUserName("Alice");

        String userName = preferenceManager.getUserName();
        // Use the user name as needed
    }
}

In this example:

• The PreferenceManager class provides methods to save and retrieve user settings using SharedPreferences.

• The MainActivity saves and retrieves the user name using the PreferenceManager.

Best Practices for Managing State with OOP in Android

1. Encapsulate State Management: Encapsulate state management logic within classes to promote reusability and maintainability. Use access modifiers to control access to state data.

2. Separate Concerns: Follow the Single Responsibility Principle by separating state management logic from UI logic and business logic.

3. Use Lifecycle-Aware Components: Utilize lifecycle-aware components, such as ViewModel and LiveData, to manage state in a way that respects the lifecycle of Android components.

4. Persist Critical State: Ensure critical state data is persisted appropriately using databases, SharedPreferences, or other storage mechanisms to survive application restarts and configuration changes.

5. Avoid Memory Leaks: Be mindful of object lifecycles and avoid keeping references to contexts or views that may lead to memory leaks.

6. Handle Configuration Changes: Implement proper handling for configuration changes, such as screen rotations, to preserve and restore state seamlessly.

7. Use Dependency Injection: Use dependency injection frameworks to manage dependencies and state, promoting loose coupling and easier testing.

Conclusion

Managing state in Android applications using Object-Oriented Programming principles helps create robust, maintainable, and scalable applications. By leveraging techniques such as using ViewModel for UI state, implementing the Singleton pattern for global state, adopting the Repository pattern for persistent state, and employing SharedPreferences for simple state management, you can ensure that your application handles state efficiently and provides a seamless user experience. Embrace these OOP principles and best practices to build better, more reliable Android applications.