Tinker Android Hot-Fix Library

Tinker requires a specific application structure. You must separate your application lifecycle logic from the Application class itself.

1. Create a LifeCycle class: Subclass DefaultApplicationLike (instead of Application) to hold your application's initialization logic.
2. Create the Application class: Subclass TinkerApplication. Since TinkerApplication is abstract and has no default constructor, you must provide a no-arg constructor that calls super() with the appropriate tinkerFlags and the full class name of your LifeCycle class.

Tinker Flags: Use ShareConstants.TINKER_ENABLE_ALL to support dex, library, and resource updates. Other options include dex-only or library-only.

Alternatively, you can use the @DefaultLifeCycle annotation from tinker-android-anno to automate the generation of the TinkerApplication class.

// Manual implementation
public class SampleApplication extends TinkerApplication {
    public SampleApplication() {
      super(
        ShareConstants.TINKER_ENABLE_ALL,
        "tinker.sample.android.app.SampleApplicationLike");
    }
}

// Recommended: Using @DefaultLifeCycle annotation
@DefaultLifeCycle(
    application = "tinker.sample.android.app.SampleApplication",
    flags = ShareConstants.TINKER_ENABLE_ALL
)
public class SampleApplicationLike extends DefaultApplicationLike {
    // ... implementation
}

The TinkerClassLoader is a specialized PathClassLoader used to facilitate hot-patching in Android applications. It allows the application to load patched .dex files at runtime by prioritizing them over the original application classes.

When searching for a class or resource, TinkerClassLoader follows this lookup order:

1. The system class loader.
2. The patched dex files (via injectDexPath).
3. The mOriginAppClassLoader (the original application's class loader).

Note: The constructor is package-private (TinkerClassLoader(...)), implying that it is intended to be instantiated by the Tinker framework's internal loader components rather than directly by end-users in typical application code.

// Note: The constructor is package-private in the source.
// It is used by the framework to initialize the patched environment.
TinkerClassLoader loader = new TinkerClassLoader(
    dexPath,           // Path to the patched dex files
    optimizedDir,       // Directory for optimized dex files
    libraryPath,        // Path to native libraries
    originAppClassLoader // The original application ClassLoader
);

Use monkeyPatchExistingResources(Context context, String externalResourceFile, boolean isReInject) to inject updated resources into the running application.

• context: The application context.
• externalResourceFile: The absolute path to the patched APK file containing the new resources.
• isReInject: If true, the method will skip the heavy logic of creating new AssetManager instances and instead re-applies the existing patch (useful for handling lifecycle events like screen rotation on certain Android versions).

This method performs several critical tasks:

1. Updates LoadedApk to point to the new resource directory.
2. Creates a new AssetManager pointing to the externalResourceFile.
3. Iterates through all existing Resources objects in the system and replaces their AssetManager with the new one.
4. Handles manufacturer-specific issues (like MIUI) by clearing mTypedArrayPool caches.
5. Installs a ResourceInsuranceHandlerCallback to ensure patches persist through activity lifecycle changes.

// 1. Prepare the patcher
TinkerResourcePatcher.isResourceCanPatch(context);

// 2. Apply the patch
String patchPath = "/data/user/0/com.example/files/patch.apk";
TinkerResourcePatcher.monkeyPatchExistingResources(context, patchPath, false);