LifeCycleActivity.java

Overview

`LifeCycleActivity.java` defines a custom Android Activity class named `LifeCycleActivity` that extends `AppCompatActivity` and implements the `LifecycleOwner` interface. Its primary purpose is to integrate Android Architecture Components' lifecycle-aware capabilities by explicitly managing and exposing its lifecycle state through a `LifecycleRegistry`.

This class tracks the activity’s lifecycle states (CREATED, STARTED, RESUMED, etc.) and propagates these states via a `LifecycleRegistry` instance, enabling other components or observers to respond appropriately to lifecycle changes. This approach facilitates better separation of concerns, improves resource management, and enables reactive programming paradigms within the app.

Classes and Interfaces

LifeCycleActivity

public class LifeCycleActivity extends AppCompatActivity implements LifecycleOwner

• Superclass: AppCompatActivity

• Implements: LifecycleOwner

Description

`LifeCycleActivity` is an Android `Activity` that provides lifecycle state management by maintaining a `LifecycleRegistry`. This allows components observing this lifecycle to be notified of state changes in a precise and lifecycle-aware manner.

Properties

Methods

Lifecycle Callbacks

These methods override the standard Android activity lifecycle callbacks to update the `LifecycleRegistry` state accordingly.

protected void onCreate(@Nullable Bundle savedInstanceState)

• Description: Initializes the LifecycleRegistry and marks the lifecycle state as CREATED.

• Parameters:

  • savedInstanceState – Optional Bundle containing saved state.

• Usage: Called when the activity is first created.

@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    mLifecycleRegistry = new LifecycleRegistry(this);
    mLifecycleRegistry.markState(Lifecycle.State.CREATED);
}

public void onStart()

• Description: Marks the lifecycle state as STARTED.

• Usage: Called when the activity becomes visible to the user.

@Override
public void onStart() {
    super.onStart();
    mLifecycleRegistry.markState(Lifecycle.State.STARTED);
}

protected void onResume()

• Description: Marks the lifecycle state as RESUMED.

• Usage: Called when the activity starts interacting with the user.

@Override
protected void onResume() {
    super.onResume();
    mLifecycleRegistry.markState(Lifecycle.State.RESUMED);
}

protected void onPause()

• Description: Marks the lifecycle state back to STARTED.

• Usage: Called when the system is about to start resuming another activity.

@Override
protected void onPause() {
    super.onPause();
    mLifecycleRegistry.markState(Lifecycle.State.STARTED);
}

protected void onStop()

• Description: Marks the lifecycle state back to CREATED.

• Usage: Called when the activity is no longer visible to the user.

@Override
protected void onStop() {
    super.onStop();
    mLifecycleRegistry.markState(Lifecycle.State.CREATED);
}

protected void onDestroy()

• Description: Marks the lifecycle state as DESTROYED.

• Usage: Called before the activity is destroyed.

@Override
protected void onDestroy() {
    super.onDestroy();
    mLifecycleRegistry.markState(Lifecycle.State.DESTROYED);
}

LifecycleOwner Interface Method

@NonNull public Lifecycle getLifecycle()

• Description: Returns the Lifecycle associated with this activity.

• Returns: Lifecycle — The current lifecycle registry instance.

• Usage: Used by lifecycle-aware components and observers to subscribe to lifecycle events.

@NonNull
@Override
public Lifecycle getLifecycle() {
    return mLifecycleRegistry;
}

Implementation Details

• LifecycleRegistry:
  The core of this class is the LifecycleRegistry object, which tracks the current lifecycle state and notifies observers about state changes. This is a concrete implementation of the Lifecycle interface designed for lifecycle owners that want to manually handle lifecycle state changes.

• State Management:
  The activity updates its lifecycle state explicitly in each overridden lifecycle method to reflect its current state accurately. For example, when onPause() is called, the state moves from RESUMED back to STARTED.

• LifecycleOwner Interface:
  By implementing LifecycleOwner, this activity can be used with Android Architecture Components like LiveData, ViewModel, and lifecycle-aware observers, enabling automatic lifecycle handling and reducing boilerplate code in components observing this activity.

Interaction with Other System Components

• Android Framework:
  The class overrides Android's native Activity lifecycle callbacks to synchronize the LifecycleRegistry state with the system lifecycle events.

• Architecture Components:
  Other components like ViewModels, LiveData observers, or custom lifecycle-aware components can query this activity’s lifecycle via getLifecycle() and register observers that react to state changes (e.g., starting/stopping animations, releasing resources).

• UI Layer:
  Since it extends AppCompatActivity, this class serves as a base activity that could be used in the UI layer of the app, providing lifecycle awareness throughout.

• Potential Usage:
  This activity could be subclassed or used directly by other activities in the app to leverage lifecycle-aware functionality without rewriting lifecycle management logic.

Usage Example

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

        // Example: Observe lifecycle changes
        getLifecycle().addObserver(new LifecycleObserver() {
            @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
            public void onResumeEvent() {
                // Start animation or refresh UI
            }

            @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
            public void onPauseEvent() {
                // Pause animation or save state
            }
        });
    }
}

Mermaid Class Diagram

classDiagram
    LifeCycleActivity ..|> AppCompatActivity
    LifeCycleActivity ..|> LifecycleOwner

    class LifeCycleActivity {
        - LifecycleRegistry mLifecycleRegistry
        + void onCreate(Bundle savedInstanceState)
        + void onStart()
        + void onResume()
        + void onPause()
        + void onStop()
        + void onDestroy()
        + Lifecycle getLifecycle()
    }

    class AppCompatActivity {
        <<Android Framework>>
    }

    class LifecycleOwner {
        <<Interface>>
        + Lifecycle getLifecycle()
    }

    class LifecycleRegistry {
        + void markState(Lifecycle.State state)
    }

Summary

`LifeCycleActivity.java` is a foundational class that enhances a typical Android `AppCompatActivity` by explicitly managing and exposing its lifecycle state using Android Architecture Components. This enables better lifecycle-aware programming, allowing components to respond efficiently to lifecycle changes, improving app stability, resource management, and maintainability. It fits into the project’s modular architecture by acting as a lifecycle-aware UI component base class that can be extended or used throughout the app’s user interface layer.