[QUESTION] Is there a way to provide a custom SDK jar to access hidden APIs?

[IndiTheo]

I'm new to rules_android, and I wonder if there's a neat way to replace a framework jar with a custom jar, for example to include hidden symbols, to avoid manually replacing the jar in the SDK folder. After some trial I couldn't come up with anything.

Thank you!

[ahumesky]

Depending on what custom jar you want to use, the correct way to do this is to define your own android_sdk toolchain and register that toolchain instead of the default one from android_sdk_repository:

rules_android/rules/android_sdk_repository/helper.bzl

Lines 206 to 256 in 88fea8e

	android_sdk(
	name = "sdk-%s" % api_level,
	aapt = select({
	":windows": "build-tools/%s/aapt.exe" % build_tools_directory,
	"//conditions:default": ":aapt_binary",
	}),
	aapt2 = select({
	":windows": "build-tools/%s/aapt2.exe" % build_tools_directory,
	"//conditions:default": ":aapt2_binary",
	}),
	adb = select({
	":windows": "platform-tools/adb.exe",
	"//conditions:default": "platform-tools/adb",
	}),
	aidl = select({
	":windows": "build-tools/%s/aidl.exe" % build_tools_directory,
	"//conditions:default": ":aidl_binary",
	}),
	android_jar = "platforms/android-%s/android.jar" % api_level,
	apksigner = ":apksigner",
	build_tools_version = build_tools_version,
	dx = select({
	"d8_standalone_dexer": ":d8_compat_dx",
	"dx_standalone_dexer": ":dx_binary",
	"//conditions:default": ":d8_compat_dx",
	}),
	framework_aidl = "platforms/android-%s/framework.aidl" % api_level,
	legacy_main_dex_list_generator = ":generate_main_dex_list",
	main_dex_classes = "build-tools/%s/mainDexClasses.rules" % build_tools_directory,
	main_dex_list_creator = ":main_dex_list_creator",
	proguard = select({
	":disallow_proguard": ":fail",
	"//conditions:default": "@remote_java_tools//:proguard",
	}),
	# See https://github.com/bazelbuild/bazel/issues/8757
	tags = ["__ANDROID_RULES_MIGRATION__"],
	zipalign = select({
	":windows": "build-tools/%s/zipalign.exe" % build_tools_directory,
	"//conditions:default": ":zipalign_binary",
	}),
	)
	native.toolchain(
	name = "sdk-%s-toolchain" % api_level,
	exec_compatible_with = HOST_CONSTRAINTS,
	toolchain = ":sdk-%s" % api_level,
	toolchain_type = ":sdk_toolchain_type",
	target_settings = [
	":api_%s_enabled" % api_level,
	],
	)

rules_android/README.md

Line 96 in 88fea8e

register_toolchains("@androidsdk//:sdk-toolchain", "@androidsdk//:all")

This is somewhat fiddly though because you'd have to give values for every attribute

[IndiTheo]

Yes, I see. How hard will it be to make it configurable in android_sdk_repository as a customization feature? Looks like adding android_jar to attrs of android_sdk_repository, and passing it through to initialize the android_sdk rule.

So this line will select the custom jar if provided, and fall back to default if not:

rules_android/rules/android_sdk_repository/helper.bzl

Line 224 in 88fea8e

android_jar = "platforms/android-%s/android.jar" % api_level,

As it's more of a power-feature, maybe there's a concise way to just inject my own jar so it appears first on the classpath?

[IndiTheo]

I actually could achieve some results by overriding AndroidSdkInfo fields and creating a custom toolchain like this:

libs/sdk_proxy.bzl:

load("@rules_android//providers:providers.bzl", "AndroidSdkInfo")

def _sdk_proxy_impl(ctx):
    # Retrieve the official auto-discovered SDK info
    base = ctx.attr.base_sdk[AndroidSdkInfo]
    
    # Return a new provider using a custom jar
    android_sdk_info = AndroidSdkInfo(
            android_jar = ctx.file.custom_jar,
            aapt = base.aapt,
            aapt2 = base.aapt2,
            adb = base.adb,
            aidl = base.aidl,
            aidl_lib = base.aidl_lib,
            apk_builder = base.apk_builder,
            apk_signer = base.apk_signer,
            dx = base.dx,
            framework_aidl = base.framework_aidl,
            legacy_main_dex_list_generator = base.legacy_main_dex_list_generator,
            main_dex_classes = base.main_dex_classes,
            main_dex_list_creator = base.main_dex_list_creator,
            proguard = base.proguard,
            shrinked_android_jar = base.shrinked_android_jar,
            source_properties = base.source_properties,
            system = None,
            zip_align = base.zip_align,
            build_tools_version = base.build_tools_version,
    )

    return [
        android_sdk_info,
        platform_common.ToolchainInfo(android_sdk_info = android_sdk_info),
    ]
    
sdk_proxy = rule(
    implementation = _sdk_proxy_impl,
    attrs = {
        "base_sdk": attr.label(mandatory = True, providers = [AndroidSdkInfo]),
        "custom_jar": attr.label(allow_single_file = True, mandatory = True),
    },
)

libs/BUILD.bzl:

load(":sdk_proxy.bzl", "sdk_proxy")

package(default_visibility = ["//visibility:public"])

sdk_proxy(
    name = "patched_sdk",
    base_sdk = "@androidsdk//:sdk", # Inherit official auto-discovery
    custom_jar = "android.jar",
)

toolchain(
    name = "patched_sdk_toolchain",
    toolchain = ":patched_sdk",
    toolchain_type = "@rules_android//toolchains/android_sdk:toolchain_type",
)

MODULE.bzl:

.....

register_toolchains("//libs:patched_sdk_toolchain")

Not sure if it suffices yet, but the build succeeds.

[IndiTheo]

I extensively tested the solution from my previous post, and it seems to work as expected. It'd be great to add support for custom JARs in the generic toolchain though.