Meituan-Dianping/Robust
Robust
Robust is an Android hotfix framework and runtime application updater designed for patching bugs in production environments. It functions as a bytecode patcher and dynamic code injection tool, allowing for the modification of application logic without requiring a full app update or device reboot.
The project enables the remediation of Android defects by injecting new classes and methods into existing builds and modifying the implementations of existing methods. It utilizes a toolchain to generate binary patch files that update application behavior and introduce workarounds on the fly.
The system achieves these updates through bytecode redirection, class loader isolation, and runtime method table patching. It also incorporates reflection-based hooking and dynamic bytecode injection to redirect execution flow within the running virtual machine.
Features
- Application Component Hotfixes - Delivers rapid binary hotfixes to specific application components to resolve bugs without requiring full app updates.
- Application Bundle Patching - Implements mechanisms for applying binary patches to application bundles at runtime to resolve defects.
- Dynamic Application Updates - Enables deploying dynamic updates to running Android applications to fix errors without interrupting the user experience.
- Android Application Modifiers - Provides a framework for modifying Android application binaries to resolve production defects via bytecode injection.
- Hotfix Runtime Updates - Allows modifying the behavior of installed Android apps using patch files to implement workarounds instantly.
- Runtime Method Implementation Overrides - Allows changing the implementation of existing methods in a running application to resolve functional bugs.
- Bytecode Injection - Provides the capability to inject new classes and methods directly into Android executable DEX files at runtime.
- Runtime Code Injection - Provides mechanisms for injecting new classes and methods to update the live execution state of a running app.
- Bytecode-Level Interceptors - Implements bytecode-level interceptors to replace original method implementations with patched versions at runtime.
- Runtime Method Patching - Implements runtime method table patching to swap buggy code with corrected logic without restarting the application.
- Reflection-Based Hooking - Utilizes Java reflection to modify internal class structures and redirect execution flow to fixed implementations.
- Binary Patch Toolchains - Ships a toolchain that processes source code changes into optimized binary patch files for remote deployment.
- Patch Generators - Includes utilities for automating the generation of patch files to streamline bug fix deployment.
- Custom ClassLoader Isolation - Uses custom class loaders to isolate patch files, preventing naming collisions while maintaining access to original classes.
- Android Utility Tools - High-compatibility hot-fix solution for Android bug patching.
- Mobile Development Tools - Android hot-fix system for patching bugs without re-releasing.
