MVVMHabitComponent

Use a global flag in gradle.properties to switch between running a component as a standalone application (for debugging) or as a library (for integration into the Host).

1. Define the flag in gradle.properties: isBuildModule=false (false = integrated, true = standalone).

2. Dynamic Plugin Switching: In the component's build.gradle, use the flag to apply either com.android.application or com.android.library.

3. Manifest Management:

   • For integrated mode, use the standard src/main/AndroidManifest.xml.
   • For standalone mode, use a specialized manifest located at src/main/alone/AndroidManifest.xml that defines the entry point (Activity) and intent filters.
   • Use sourceSets in build.gradle to swap the manifest file based on the isBuildModule flag.

// gradle.properties
isBuildModule=false

// component build.gradle
android {
    sourceSets {
        main {
            if (isBuildModule.toBoolean()) {
                // Standalone mode: use the debug manifest
                manifest.srcFile 'src/main/alone/AndroidManifest.xml'
            } else {
                // Integrated mode: use standard manifest and exclude debug files
                manifest.srcFile 'src/main/AndroidManifest.xml'
                resources {
                    exclude 'src/main/alone/*'
                }
            }
        }
    }
}

The project requires MVVMHabit and ARouter. You can use remote dependencies by configuring your repositories and dependency blocks.

MVVMHabit Setup: Add jitpack.io to your allprojects repositories and implement the dependency.

ARouter Setup: Configure the AROUTER_MODULE_NAME argument in annotationProcessorOptions so the compiler knows which module is being processed, then add the API and compiler dependencies.

// MVVMHabit Repository
allprojects {
    repositories {
        google()
        jcenter()
        maven { url 'https://jitpack.io' }
    }
}

// MVVMHabit Dependency
dependencies {
    implementation 'com.github.goldze:MVVMHabit:?'
}

// ARouter Configuration
defaultConfig {
    javaCompileOptions {
        annotationProcessorOptions {
            arguments = [AROUTER_MODULE_NAME: project.getName()]
        }
    }
}

dependencies {
    api 'com.alibaba:arouter-api:?'
    annotationProcessor 'com.alibaba:arouter-compiler:?'
}

For cross-component event communication (where data needs to be sent back or broadcasted), use RxBus. Note that RxBus is not effective across different processes.

Posting an Event

To send data (e.g., from Component B back to Component A):

_Login _login = new _Login();
RxBus.getDefault().post(_login);

Subscribing to an Event

To receive an event in Component A, subscribe to the specific class type. Ensure you unregister the subscription to prevent memory leaks:

subscribe = RxBus.getDefault().toObservable(_Login.class)
    .subscribe(new Consumer<_Login>() {
        @Override
        public void accept(_Login l) throws Exception {
            // Handle the event (e.g., refresh data)
            initData();
            // Unregister
            RxSubscriptions.remove(subscribe);
        }
    });
RxSubscriptions.add(subscribe);

// Posting
RxBus.getDefault().post(new MyEvent("data"));

// Subscribing
Disposable subscribe = RxBus.getDefault().toObservable(MyEvent.class)
    .subscribe(event -> {
        // Handle event
    });
RxSubscriptions.add(subscribe);

To build a componentized project, start by creating a Host (the main shell project) and several Components (modules).

1. Host Project: Create a standard Android project via File -> New -> New Project.... The Host's responsibility is to aggregate all components into a single APK. It primarily contains the AndroidManifest.xml for application configuration and build.gradle for managing dependencies.
2. Components: Create modules via File -> New -> New Module -> Android Library.... These modules are special: they act as com.android.library when being merged into the Host, but can be configured to act as com.android.application for independent testing.
3. Base Libraries: Create two essential foundation libraries:
   • library-base: Stores common methods, constants, and communication contracts. It acts as the core dependency for all components.
   • library-res: A dedicated resource library for images, styles, animations, and colors to reduce the load on library-base.

// Component build.gradle dynamic plugin switching
if (isBuildModule.toBoolean()) {
    apply plugin: 'com.android.application'
} else {
    apply plugin: 'com.android.library'
}

Establish a clear dependency chain to ensure modularity:

1. Host $\rightarrow$ Business Components: The Host project should implement all business modules (e.g., module-home, module-user).
2. Business Components $\rightarrow$ library-base: All business modules should use api project(':library-base') to access common logic.
3. library-base $\rightarrow$ Common Libraries & library-res: The base library should depend on library-res, the MVVMHabit framework, ARouter API, and other common utilities (like image pickers or push services).

// Host dependencies
dependencies {
    implementation project(':module-main')
    implementation project(':module-sign')
    implementation project(':module-home')
    // ... other modules
}

// Business component dependencies
dependencies {
    api project(':library-base')
}

// library-base dependencies
dependencies {
    api project(':library-res')
    api rootProject.ext.dependencies.MVVMHabit
    api rootProject.ext.dependencies["arouter-api"]
}

In a componentized architecture, the host App's Application class is the only one that can run. To initialize individual components, implement the IModuleInit interface in your component and use reflection to trigger it from the host App.

Implementation Steps:

1. Implement IModuleInit in your component: Create an initialization class that implements IModuleInit. This allows you to control the order of initialization.

   • onInitAhead(Application application): For high-priority libraries (e.g., ARouter) that need to be initialized as early as possible.
   • onInitLow(Application application): For lower-priority components.

2. Register the component: Register the full class path of your initialization class in ModuleLifecycleReflexs to allow dynamic invocation via reflection.

3. Trigger initialization in the Host Application: Call the ModuleLifecycleConfig singleton methods within the host's onCreate() method.

Note: Ensure that the Module classes used for initialization are not obfuscated during the build process, otherwise reflection will fail.

// 1. Implement the interface in your component
public class MyComponentInit implements IModuleInit {
    @Override
    public boolean onInitAhead(Application application) {
        // High priority initialization (e.g., ARouter)
        ARouter.init(application);
        return false;
    }

    @Override
    public boolean onInitLow(Application application) {
        // Lower priority initialization
        return false;
    }
}

// 2. In the Host Application's onCreate
@Override
public void onCreate() {
    super.onCreate();
    // Initialize high-priority components
    ModuleLifecycleConfig.getInstance().initModuleAhead(this);
    
    // ... other logic ...

    // Initialize low-priority components
    ModuleLifecycleConfig.getInstance().initModuleLow(this);
}