Transform Android Game SDKs: Custom Resource IDs & Annotation Injection

Background

In normal Android app development, developers frequently use findViewById with manual casting, which is repetitive and error‑prone. Annotation libraries such as ButterKnife solve this for ordinary apps, but they cannot be used directly in game distribution SDKs.

Industry workflow

The typical game publishing pipeline involves receiving an APK (the “mother package”), decompiling it, adding channel‑specific resources and the publisher’s SDK, and finally releasing the new channel APK.

The publisher’s SDK may contain calls like findViewById(R.id.sqBtn) with a fixed resource ID (e.g., 0x7f070001) compiled into class R1.

During re‑packaging, the public.xml generated from resource.arsc locks that ID value.

When the channel build regenerates its own R class (e.g., R2), the ID value changes (e.g., 0x7f070002).

The merged APK now contains R2 but the runtime still looks up the old ID in resource.arsc, causing a crash.

Common industry solution

Because findViewById cannot be used reliably, most publishers resort to Resources.getIdentifier("sqBtn", "id", pkgName). This avoids ID mismatches but sacrifices compile‑time checking and IDE auto‑completion, increasing the risk of misspelled resource names.

Two key challenges

1) Replace dynamic getIdentifier calls with compile‑time‑checked IDs. We need a way to generate a custom resource class that maps resource names to constant strings, enabling IDE assistance.

2) Provide an annotation‑based injection framework similar to ButterKnife that works with the custom resource class.

Key point 1: Custom “SqR” resource generation

Using a Gradle plugin we create a class SqR where each resource ID is defined as a public static final String whose value equals the resource name. This allows developers to write SqR.sqBtn and still retrieve the ID via getIdentifier at runtime.

Implementation steps:

Add new resources (images, strings, etc.) to the project.

Run the Gradle plugin to transform the generated R.java (for app modules) or R.txt (for library modules) into SqR.

Use the generated SqR in code, gaining compile‑time validation and IDE auto‑completion.

Usage effects

Compile‑time validation – resource names are checked during build, preventing misspellings.

IDE code completion – developers get suggestions for available resources.

Implementation process

1) Create a Gradle project (details omitted; see linked tutorial).

2) The plugin reads the original R.java (or R.txt) and replaces each int field with a String field, then renames the class to SqR.

Core code snippet

// Obtain package name for resource path
def rPackage = this.getPackageName(variant)
println(rPackage)
rPackage = rPackage.replace(".", "/")

// Get the Android Resources processing task
def variantOutput = variant.outputs.first()
def processResources = variantOutput.processResourcesProvider.get()
def rFiles = project.files(processResources.textSymbolOutputFile).builtBy(processResources)

// Path to R.txt
def RFilePath = rFiles.singleFile.absolutePath

// Output directory for generated sources
def outputDir = processResources.getSourceOutputDir()

// Transform R.java: replace int with String and rename class
def tempFile = new File(outputDir.absolutePath + File.separator + rPackage + File.separator + "R.java")
println("R file path: " + tempFile.absolutePath)
def rFileContent = tempFile.text

def pattern = Pattern.compile("public static(.*?) int (.*?)=(.*?);")
Matcher matcher = pattern.matcher(rFileContent)
while (matcher.find()) {
    String replace = "public static final String " + matcher.group(2) + " = \"" + matcher.group(2) + "\";"
    rFileContent = rFileContent.replaceAll(matcher.group(), replace)
}
rFileContent = rFileContent.replaceAll("class R", "class SqR")

Summary

The article explains the first key point of building a custom resource injection framework for game distribution SDKs: generating a “SqR” class via a Gradle plugin to replace findViewById with safe, IDE‑friendly identifiers. The next article will cover the annotation‑based injection (key point 2) that completes a ButterKnife‑like solution, named “SqInject”.