### Configuring HiddenApiRefinePlugin in Gradle Build Files

Source: https://context7.com/rikkaapps/hiddenapirefineplugin/llms.txt

Provides instructions on how to apply the `dev.rikka.tools.refine` Gradle plugin in your project. This includes setup in `settings.gradle`, root `build.gradle`, and module-level `build.gradle` files, along with necessary dependency configurations.

```groovy
// settings.gradle
pluginManagement {
    repositories {
        mavenCentral()
        google()
        gradlePluginPortal()
    }
}

// root build.gradle
plugins {
    id 'dev.rikka.tools.refine' version '4.4.0' apply false
}

// Apply plugin to all Android modules automatically
subprojects {
    plugins.withId("com.android.base") {
        plugins.apply('dev.rikka.tools.refine')
    }
}

// app/build.gradle
plugins {
    id 'com.android.application'
    id 'dev.rikka.tools.refine'
}

dependencies {
    // Import your hidden-api module as compileOnly
    compileOnly project(':hidden-api')

    // Runtime utility for unsafeCast (optional)
    implementation 'dev.rikka.tools.refine:runtime:4.4.0'
}
```

--------------------------------

### Apply HiddenApiRefinePlugin (Gradle)

Source: https://github.com/rikkaapps/hiddenapirefineplugin/blob/main/README.md

This Gradle snippet shows how to apply the HiddenApiRefinePlugin to an Android application module. It's essential for modules that will utilize the refined hidden APIs. The example also includes a way to apply it to all subprojects that use the Android Gradle Plugin.

```gradle
plugins {
    id('dev.rikka.tools.refine') version '<version>'
}

```

```gradle
subprojects {
    plugins.withId("com.android.base") {
        plugins.apply('dev.rikka.tools.refine')
    }
}
```

--------------------------------

### Integrate and Use Hidden APIs in Application (Java)

Source: https://context7.com/rikkaapps/hiddenapirefineplugin/llms.txt

Demonstrates how an Android application can use hidden APIs defined in stub modules. It utilizes `Refine.unsafeCast()` to access hidden methods of `UserHandle` and `ActivityManager`, showcasing runtime access to non-public system functionality.

```java
// app/src/main/java/com/example/app/SystemToolActivity.java
package com.example.app;

import android.app.Activity;
import android.app.ActivityManager;
import android.app.ActivityManagerHidden;
import android.os.Bundle;
import android.os.UserHandle;
import android.os.UserHandleHidden;
import dev.rikka.tools.refine.Refine;

public class SystemToolActivity extends Activity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        // Access hidden UserHandle methods
        int uid = android.os.Process.myUid();
        int appId = Refine.<UserHandleHidden>unsafeCast(UserHandle.class)
            .getAppId(uid);
        int userId = Refine.<UserHandleHidden>unsafeCast(UserHandle.class)
            .getUserId(uid);

        Log.d("SystemTool", "App ID: " + appId + ", User ID: " + userId);

        // Access hidden ActivityManager methods
        ActivityManager am = (ActivityManager) getSystemService(ACTIVITY_SERVICE);
        ActivityManagerHidden amHidden = Refine.unsafeCast(am);

        // Get running services using hidden API
        List<ActivityManager.RunningServiceInfo> services =
            amHidden.getRunningServices(100);

        for (ActivityManager.RunningServiceInfo info : services) {
            Log.d("SystemTool", "Running service: " + info.service.getClassName());
        }
    }
}
```

--------------------------------

### Configure Hidden API Module (Gradle)

Source: https://context7.com/rikkaapps/hiddenapirefineplugin/llms.txt

Sets up an Android library module to define stub classes for hidden APIs. It includes the annotation processor and annotation library required for the refinement process. The annotation processor generates metadata during compilation.

```groovy
plugins {
    id 'com.android.library'
}

android {
    namespace 'com.example.hiddenapi'
    compileSdk 34

    defaultConfig {
        minSdk 21
    }
}

dependencies {
    // Annotation processor generates refine metadata
    annotationProcessor 'dev.rikka.tools.refine:annotation-processor:4.4.0'

    // Annotation library (compileOnly since it's source retention)
    compileOnly 'dev.rikka.tools.refine:annotation:4.4.0'
}
```

--------------------------------

### Import Hidden API Module (Gradle)

Source: https://github.com/rikkaapps/hiddenapirefineplugin/blob/main/README.md

This Gradle configuration snippet illustrates how to import a module containing hidden API stubs using the `compileOnly` configuration. This ensures that the stub classes are available at compile time without being included in the final application package.

```gradle
dependencies {
    compileOnly project(':hidden-api')
}
```

--------------------------------

### Using @RefineAs Annotation for Hidden API Stubs (Java)

Source: https://context7.com/rikkaapps/hiddenapirefineplugin/llms.txt

Demonstrates how to use the @RefineAs annotation to mark a stub class that will be renamed to its target Android framework class during compilation. This approach allows developers to define and interact with hidden APIs as if they were part of the public SDK.

```java
package android.content.pm;

import dev.rikka.tools.refine.RefineAs;

// This class will be renamed to android.content.pm.PackageManager at compile time
@RefineAs(PackageManager.class)
public class PackageManagerHidden {

    // Define hidden interfaces that exist in the real PackageManager
    public interface OnPermissionsChangedListener {
        void onPermissionsChanged(int uid);
    }

    // Stub methods matching hidden API signatures
    public void addOnPermissionsChangeListener(OnPermissionsChangedListener listener) {
        throw new RuntimeException("Stub!");
    }

    public void removeOnPermissionsChangeListener(OnPermissionsChangedListener listener) {
        throw new RuntimeException("Stub!");
    }
}
```

--------------------------------

### Use Hidden API with Refine (Java)

Source: https://github.com/rikkaapps/hiddenapirefineplugin/blob/main/README.md

This Java code snippet demonstrates how to use a refined hidden API. It utilizes `Refine.unsafeCast` to cast a PackageManager instance to the `PackageManagerHidden` stub class, allowing access to methods like `addOnPermissionsChangeListener`.

```java
Refine.<PackageManagerHidden>unsafeCast(context.getPackageManager())
        .addOnPermissionsChangeListener(new PackageManagerHidden.OnPermissionsChangedListener() {
            @Override
            public void onPermissionsChanged(int uid) {
                // do staff
            }
        });
```

--------------------------------

### Using Refine.unsafeCast() for Type-Safe Hidden API Access (Java)

Source: https://context7.com/rikkaapps/hiddenapirefineplugin/llms.txt

Illustrates the use of the Refine.unsafeCast() utility method to safely cast objects between their public types and 'Hidden' stub types. This method is optimized away by R8, ensuring no runtime overhead. It's useful when an instance of a public class needs to access its hidden methods via a stub class.

```java
import dev.rikka.tools.refine.Refine;
import android.content.pm.PackageManager;
import android.content.pm.PackageManagerHidden;

public class PermissionMonitor {

    private final PackageManager packageManager;
    private PackageManagerHidden.OnPermissionsChangedListener listener;

    public PermissionMonitor(Context context) {
        this.packageManager = context.getPackageManager();
    }

    public void startMonitoring() {
        listener = new PackageManagerHidden.OnPermissionsChangedListener() {
            @Override
            public void onPermissionsChanged(int uid) {
                Log.d("PermissionMonitor", "Permissions changed for UID: " + uid);
                // Handle permission change event
            }
        };

        // Cast PackageManager to PackageManagerHidden to access hidden API
        Refine.<PackageManagerHidden>unsafeCast(packageManager)
            .addOnPermissionsChangeListener(listener);
    }

    public void stopMonitoring() {
        if (listener != null) {
            Refine.<PackageManagerHidden>unsafeCast(packageManager)
                .removeOnPermissionsChangeListener(listener);
            listener = null;
        }
    }
}
```

--------------------------------

### Define Hidden ActivityManager API Stub (Java)

Source: https://context7.com/rikkaapps/hiddenapirefineplugin/llms.txt

Provides a Java stub for hidden ActivityManager methods, including getRunningServices and forceStopPackage. It also defines a nested stub class, ProcessErrorStateInfoHidden, mirroring ActivityManager.ProcessErrorStateInfo.

```java
// hidden-api/src/main/java/android/app/ActivityManagerHidden.java
package android.app;

import dev.rikka.tools.refine.RefineAs;
import java.util.List;

@RefineAs(ActivityManager.class)
public class ActivityManagerHidden {

    // Hidden method to get running services (deprecated in public API but still works)
    public List<ActivityManager.RunningServiceInfo> getRunningServices(int maxNum) {
        throw new RuntimeException("Stub!");
    }

    // Hidden method to force stop a package
    public void forceStopPackage(String packageName) {
        throw new RuntimeException("Stub!");
    }

    // Hidden nested class for process error state
    @RefineAs(ActivityManager.ProcessErrorStateInfo.class)
    public static class ProcessErrorStateInfoHidden {
        public static final int NO_ERROR = 0;
        public static final int CRASHED = 1;
        public static final int NOT_RESPONDING = 2;
    }
}
```

--------------------------------

### Define Hidden UserHandle API Stub (Java)

Source: https://context7.com/rikkaapps/hiddenapirefineplugin/llms.txt

Creates a Java stub class for hidden UserHandle methods. The @RefineAs annotation targets the original UserHandle class, and the stub provides access to methods like getAppId, getUserId, and getUid, along with constants like PER_USER_RANGE.

```java
package android.os;

import dev.rikka.tools.refine.RefineAs;

@RefineAs(UserHandle.class)
public class UserHandleHidden {

    // Hidden static method to get app user ID
    public static int getAppId(int uid) {
        throw new RuntimeException("Stub!");
    }

    // Hidden static method to get user ID from UID
    public static int getUserId(int uid) {
        throw new RuntimeException("Stub!");
    }

    // Hidden static method to create UID from user and app IDs
    public static int getUid(int userId, int appId) {
        throw new RuntimeException("Stub!");
    }

    // Hidden constant
    public static final int PER_USER_RANGE = 100000;
}
```

--------------------------------

### Add Runtime Dependency (Gradle)

Source: https://github.com/rikkaapps/hiddenapirefineplugin/blob/main/README.md

This Gradle dependency declaration adds the `runtime` library for the HiddenApiRefinePlugin. This is optional and is only needed if you intend to use the `Refine.unsafeCast` method for type casting.

```gradle
dependencies {
    implementation("dev.rikka.tools.refine:runtime:<version>")
}
```

--------------------------------

### Define Hidden API Stub Class (Java)

Source: https://github.com/rikkaapps/hiddenapirefineplugin/blob/main/README.md

This Java code demonstrates how to define a stub class for a hidden Android API using the @RefineAs annotation. The annotation specifies the original target class, and the plugin will rename the stub class to match the target, simplifying its usage.

```java
package android.content.pm;

import dev.rikka.tools.refine.RefineAs;

@RefineAs(PackageManager.class)
public class PackageManagerHidden {
    public interface OnPermissionsChangedListener {
        void onPermissionsChanged(int uid);
    }

    public void addOnPermissionsChangeListener(OnPermissionsChangedListener listener) {
        throw new RuntimeException("Stub!");
    }
    public void removeOnPermissionsChangeListener(OnPermissionsChangedListener listener) {
        throw new RuntimeException("Stub!");
    }
}
```

--------------------------------

### Add Annotation Dependency (Gradle)

Source: https://github.com/rikkaapps/hiddenapirefineplugin/blob/main/README.md

This snippet shows how to add the necessary annotation processor and annotation dependencies to a Gradle module. These are required for the HiddenApiRefinePlugin to function correctly when defining hidden API stubs.

```gradle
dependencies {
    annotationProcessor 'dev.rikka.tools.refine:annotation-processor:<version>'
    compileOnly 'dev.rikka.tools.refine:annotation:<version>'
}
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.