# Copyright (c) 2021 Project CHIP Authors
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

import logging
import os
import shlex
from enum import Enum, auto

from runner.runner import Runner

from .builder import Builder, BuilderOutput, BuildProfile, OutDirLock, lock_output_dir

log = logging.getLogger(__name__)


class AndroidBoard(Enum):
    ARM = auto()
    ARM64 = auto()
    X64 = auto()
    X86 = auto()
    AndroidStudio_ARM = auto()
    AndroidStudio_ARM64 = auto()
    AndroidStudio_X64 = auto()
    AndroidStudio_X86 = auto()

    def TargetCpuName(self):
        if self == AndroidBoard.ARM or self == AndroidBoard.AndroidStudio_ARM:
            return "arm"
        if self == AndroidBoard.ARM64 or self == AndroidBoard.AndroidStudio_ARM64:
            return "arm64"
        if self == AndroidBoard.X64 or self == AndroidBoard.AndroidStudio_X64:
            return "x64"
        if self == AndroidBoard.X86 or self == AndroidBoard.AndroidStudio_X86:
            return "x86"
        raise Exception(f"Unknown board type: {self!r}")

    def AbiName(self):
        if self.TargetCpuName() == "arm":
            return "armeabi-v7a"
        if self.TargetCpuName() == "arm64":
            return "arm64-v8a"
        if self.TargetCpuName() == "x64":
            return "x86_64"
        if self.TargetCpuName() == "x86":
            return "x86"
        raise Exception(f"Unknown board type: {self!r}")

    def IsIde(self):
        return (self == AndroidBoard.AndroidStudio_ARM
                or self == AndroidBoard.AndroidStudio_ARM64
                or self == AndroidBoard.AndroidStudio_X64
                or self == AndroidBoard.AndroidStudio_X86)


class AndroidApp(Enum):
    CHIP_TOOL = auto()
    CHIP_TEST = auto()
    TV_SERVER = auto()
    TV_CASTING_APP = auto()
    VIRTUAL_DEVICE_APP = auto()

    def AppName(self):
        if self == AndroidApp.CHIP_TOOL:
            return "CHIPTool"
        if self == AndroidApp.CHIP_TEST:
            return "CHIPTest"
        if self == AndroidApp.TV_SERVER:
            return "tv-server"
        if self == AndroidApp.TV_CASTING_APP:
            return "tv-casting"
        if self == AndroidApp.VIRTUAL_DEVICE_APP:
            return "virtual-device-app"
        raise Exception(f"Unknown app type: {self!r}")

    def AppGnArgs(self):
        gn_args = {}

        if self == AndroidApp.TV_SERVER:
            gn_args["chip_config_network_layer_ble"] = False
        elif self == AndroidApp.TV_CASTING_APP:
            gn_args["chip_config_network_layer_ble"] = False
        elif self == AndroidApp.VIRTUAL_DEVICE_APP:
            gn_args["chip_config_network_layer_ble"] = True
        elif self == AndroidApp.CHIP_TOOL:
            gn_args["chip_enable_nfc_based_commissioning"] = True
            gn_args["chip_build_controller_dynamic_server"] = True
        return gn_args

    def ExampleName(self):
        if self == AndroidApp.TV_SERVER:
            return "tv-app"
        if self == AndroidApp.TV_CASTING_APP:
            return "tv-casting-app"
        if self == AndroidApp.VIRTUAL_DEVICE_APP:
            return "virtual-device-app"
        if self == AndroidApp.CHIP_TEST:
            return "chip-test"
        return None

    def Modules(self):
        if self == AndroidApp.TV_SERVER:
            return ["platform-app", "content-app"]
        return None

    def BuildRoot(self, root):
        if self == AndroidApp.CHIP_TEST:
            return os.path.join(root, 'examples/android/CHIPTest')
        return None


class AndroidBuilder(Builder):
    def __init__(self,
                 root: str,
                 runner: Runner,
                 output_dir_lock: OutDirLock, board: AndroidBoard, app: AndroidApp,
                 optimize_size: bool = False):
        super().__init__(root, runner, output_dir_lock)
        self.board = board
        self.app = app
        self.optimize_size = optimize_size

    def _get_sdk_manager_paths(self):
        """Get list of possible SDK manager paths for Android SDK compatibility."""
        paths = []

        # Allow environment variable override for testing purposes - check this first
        test_sdk_manager = os.environ.get("TEST_ANDROID_SDK_MANAGER_PATH")
        if test_sdk_manager:
            paths.append(test_sdk_manager)

        # Standard paths using ANDROID_HOME
        android_home = os.environ.get("ANDROID_HOME", "")
        if android_home:
            paths.extend([
                os.path.join(android_home, "cmdline-tools", "latest", "bin", "sdkmanager"),  # modern Android SDK
                os.path.join(android_home, "cmdline-tools", "10.0", "bin", "sdkmanager"),    # specific version
                os.path.join(android_home, "tools", "bin", "sdkmanager")                     # legacy Android SDK
            ])

        return paths

    def _find_sdk_manager(self, for_purpose="validation"):
        """Find a valid SDK manager executable from possible paths."""
        sdk_manager_paths = self._get_sdk_manager_paths()

        sdk_manager = None
        checked_details = []
        for path in sdk_manager_paths:
            # In test environment, treat TEST_ANDROID_SDK_MANAGER_PATH as valid even if file doesn't exist
            is_test_path = path == os.environ.get("TEST_ANDROID_SDK_MANAGER_PATH")

            if is_test_path:
                # Test environment - assume the path is valid
                sdk_manager = path
                checked_details.append(f"{path} (test environment - assumed valid)")
                log.info("Using SDK manager for %s from test environment: %s", for_purpose, sdk_manager)
                break
            # Real environment - check actual file existence
            exists = os.path.isfile(path)
            executable = os.access(path, os.X_OK)
            checked_details.append(f"{path} (exists: {exists}, executable: {executable})")
            log.debug("Checking SDK manager path for %s: %s - exists: %s, executable: %s", for_purpose, path, exists, executable)

            if exists and executable:
                sdk_manager = path
                log.info("Found SDK manager for %s at: %s", for_purpose, sdk_manager)
                break

        return sdk_manager, checked_details

    def _handle_sdk_license_acceptance(self):
        """Handle SDK manager license acceptance with consistent behavior between dry-run and real execution."""

        # Use the same logic for both dry-run and real execution
        sdk_manager_for_licenses, checked_details = self._find_sdk_manager("license acceptance")

        if sdk_manager_for_licenses:
            self._Execute(
                ["bash", "-c", f"yes | {sdk_manager_for_licenses} --licenses >/dev/null"],
                title=f"Accepting NDK licenses using: {sdk_manager_for_licenses}",
            )
        else:
            log.warning("No SDK manager found for license acceptance - licenses may need to be accepted manually")

    def validate_build_environment(self):
        # Log Android environment paths for debugging
        android_ndk_home = os.environ.get("ANDROID_NDK_HOME", "")
        android_home = os.environ.get("ANDROID_HOME", "")

        log.info("Android environment paths:")
        log.info("  ANDROID_NDK_HOME: %s", android_ndk_home)
        log.info("  ANDROID_HOME: %s", android_home)

        for k in ["ANDROID_NDK_HOME", "ANDROID_HOME"]:
            if k not in os.environ:
                raise Exception(
                    f"Environment {k} missing, cannot build android libraries"
                )

        # SDK manager must be runnable to 'accept licenses'
        # Check multiple possible SDK manager locations for Android SDK compatibility
        sdk_manager, checked_details = self._find_sdk_manager("validation")

        if not sdk_manager:
            log.error("SDK manager not found in any expected location")
            for detail in checked_details:
                log.error("  %s", detail)

            android_home = os.environ["ANDROID_HOME"]
            possible_fixes = [
                f"1. Install Android SDK Command Line Tools in {android_home}",
                f"2. Fix permissions: chmod +x {android_home}/cmdline-tools/*/bin/sdkmanager",
                "3. Verify ANDROID_HOME points to correct SDK directory"
            ]

            raise Exception(
                f"No working SDK manager found. Tried: {len(checked_details)} locations.\n"
                f"Possible fixes:\n" + "\n".join(possible_fixes)
            )

        # In order to accept a license, the licenses folder is updated with the hash of the
        # accepted license
        android_home = os.environ["ANDROID_HOME"]
        licenses = os.path.join(android_home, "licenses")
        if not os.path.exists(licenses):
            # Initial install may not have licenses at all
            if not os.access(android_home, os.W_OK):
                raise Exception(
                    f"'{android_home}' is NOT writable by the current user (needed to create licenses folder for accept)"
                )

        elif not os.access(licenses, os.W_OK):
            raise Exception(f"'{licenses}' is NOT writable by the current user (needed to accept licenses)")

    def copyToSrcAndroid(self):
        # JNILibs will be copied as long as they reside in src/main/jniLibs/ABI:
        #    https://developer.android.com/studio/projects/gradle-external-native-builds#jniLibs
        # to avoid redefined in IDE mode, copy to another place and add that path in build.gradle

        # We do NOT use python builtins for copy, so that the 'execution commands' are available
        # when using dry run.
        jnilibs_dir = os.path.join(
            self.root,
            "examples/android/",
            self.app.AppName(),
            "app/libs/jniLibs",
            self.board.AbiName(),
        )
        libs_dir = os.path.join(
            self.root, "examples/android/", self.app.AppName(), "app/libs"
        )
        self._Execute(
            ["mkdir", "-p", jnilibs_dir], title="Prepare Native libs " + self.identifier
        )

        # TODO: Runtime dependencies should be computed by the build system rather than hardcoded
        # GN supports getting these dependencies like:
        #   gn desc out/android-x64-chip_tool/ //src/controller/java runtime_deps
        #   gn desc out/android-x64-chip_tool/ //src/setup_payload/java runtime_deps
        # However  this assumes that the output folder has been populated, which will not be
        # the case for `dry-run` executions. Hence this harcoding here.
        #
        #   If we unify the JNI libraries, libc++_shared.so may not be needed anymore, which could
        # be another path of resolving this inconsistency.
        for libName in [
            "libCHIPController.so",
            "libc++_shared.so",
        ]:
            self._Execute(
                [
                    "cp",
                    os.path.join(
                        self.output_dir, "lib", "jni", self.board.AbiName(), libName
                    ),
                    os.path.join(jnilibs_dir, libName),
                ]
            )

        jars = {
            "CHIPController.jar": "src/controller/java/CHIPController.jar",
            "CHIPInteractionModel.jar": "src/controller/java/CHIPInteractionModel.jar",
            "OnboardingPayload.jar": "src/controller/java/OnboardingPayload.jar",
            "AndroidPlatform.jar": "src/platform/android/AndroidPlatform.jar",
            "libMatterJson.jar": "src/controller/java/libMatterJson.jar",
            "libMatterTlv.jar": "src/controller/java/libMatterTlv.jar",
            "CHIPClusters.jar": "src/controller/java/CHIPClusters.jar",
            "CHIPClusterID.jar": "src/controller/java/CHIPClusterID.jar",
        }

        for jarName in jars:
            self._Execute(
                [
                    "cp",
                    os.path.join(self.output_dir, "lib", jars[jarName]),
                    os.path.join(libs_dir, jarName),
                ]
            )

    def copyToExampleApp(self, jnilibs_dir, libs_dir, libs, jars):
        self._Execute(
            ["mkdir", "-p", jnilibs_dir], title="Prepare Native libs " + self.identifier
        )

        for libName in libs:
            self._Execute(
                [
                    "cp",
                    os.path.join(
                        self.output_dir, "lib", "jni", self.board.AbiName(), libName
                    ),
                    os.path.join(jnilibs_dir, libName),
                ]
            )

        for jarName in jars:
            self._Execute(
                [
                    "cp",
                    os.path.join(self.output_dir, "lib", jars[jarName]),
                    os.path.join(libs_dir, jarName),
                ]
            )

    def gradlewBuildSrcAndroid(self):
        # App compilation
        self._Execute(
            [
                f"{self.root}/examples/android/{self.app.AppName()}/gradlew",
                "-p",
                f"{self.root}/examples/android/{self.app.AppName()}",
                f"-PmatterBuildSrcDir={self.output_dir}",
                "-PmatterSdkSourceBuild=false",
                f"-PbuildDir={self.output_dir}",
                "assembleDebug",
            ],
            title="Building APP " + self.identifier,
        )

    def gradlewBuildExampleAndroid(self):

        # Example compilation
        optimize_flag = "-PoptimizeApkSize=true" if self.optimize_size else "-PoptimizeApkSize=false"

        if self.app.Modules():
            for module in self.app.Modules():
                self._Execute(
                    [
                        f"{self.root}/examples/{self.app.ExampleName()}/android/App/gradlew",
                        "-p",
                        f"{self.root}/examples/{self.app.ExampleName()}/android/App/",
                        f"-PmatterBuildSrcDir={self.output_dir}",
                        "-PmatterSdkSourceBuild=false",
                        f"-PbuildDir={self.output_dir}/{module}",
                        optimize_flag,
                        f":{module}:assembleDebug",
                    ],
                    title=f"Building Example {self.identifier}, module {module}",
                )
        else:
            self._Execute(
                [
                    f"{self.root}/examples/{self.app.ExampleName()}/android/App/gradlew",
                    "-p",
                    f"{self.root}/examples/{self.app.ExampleName()}/android/App/",
                    f"-PmatterBuildSrcDir={self.output_dir}",
                    "-PmatterSdkSourceBuild=false",
                    f"-PbuildDir={self.output_dir}",
                    optimize_flag,
                    "assembleDebug",
                ],
                title="Building Example " + self.identifier,
            )

    @lock_output_dir
    def generate(self):
        self._Execute(
            ["python3", "third_party/android_deps/set_up_android_deps.py"],
            title="Setting up Android deps through Gradle",
        )

        self._Execute(
            ["third_party/java_deps/set_up_java_deps.sh"],
            title="Setting up Java deps",
        )

        if not os.path.exists(self.output_dir):
            # NRF does a in-place update  of SDK tools
            if not self._runner.dry_run:
                self.validate_build_environment()

            exampleName = self.app.ExampleName()
            gn_args = {}
            gn_args["target_os"] = "android"
            gn_args["target_cpu"] = self.board.TargetCpuName()
            gn_args["android_ndk_root"] = os.environ["ANDROID_NDK_HOME"]
            gn_args["android_sdk_root"] = os.environ["ANDROID_HOME"]
            if exampleName == "chip-test":
                gn_args["chip_build_test_static_libraries"] = False

            match self.options.build_profile:
                # Explicitly treat DEFAULT as DEBUG when building examples.
                case BuildProfile.DEFAULT | BuildProfile.DEBUG:
                    gn_args.update({"is_debug": True, "optimize_debug": False})
                case BuildProfile.DEBUG_OPTIMIZED:
                    gn_args.update({"is_debug": True, "optimize_debug": True})
                case BuildProfile.RELEASE:
                    gn_args.update({"is_debug": False, "optimize_for_size": False})
                case BuildProfile.RELEASE_SIZE:
                    gn_args.update({"is_debug": False, "optimize_for_size": True})

            if self.options.pw_command_launcher:
                gn_args["pw_command_launcher"] = self.options.pw_command_launcher

            if self.options.enable_link_map_file:
                gn_args["chip_generate_link_map_file"] = True

            if exampleName == "chip-test":
                gn_args["chip_build_tests"] = True
            if self.optimize_size:
                gn_args["optimize_apk_size"] = True
                gn_args["is_debug"] = False
                gn_args["matter_enable_tracing_support"] = False
                gn_args["use_static_libcxx"] = True

                # TV Casting App size optimizations: point the build at
                # the override directory containing slim source files
                # (cluster-objects, TLV decoders, accessors, cluster
                # servers) covering only the ~36 casting-relevant
                # clusters.  The build system resolves well-known
                # filenames inside this directory automatically.
                # This must be passed as an explicit GN build arg
                # because args.gni is evaluated inside default_args
                # (before args.gn is applied), so the
                # if (optimize_apk_size) conditional there cannot see
                # the args.gn value.
                if self.app == AndroidApp.TV_CASTING_APP:
                    gn_args["chip_data_model_overrides_dir"] = (
                        "//third_party/connectedhomeip/examples/"
                        "tv-casting-app/tv-casting-common"
                    )
                    gn_args["chip_data_model_extra_logging"] = False
                    gn_args["enable_rtti"] = False
            gn_args.update(self.app.AppGnArgs())

            args_str = ""
            for key, value in gn_args.items():
                if type(value) is bool:
                    if value:
                        args_str += f"{key}=true "
                    else:
                        args_str += f"{key}=false "
                else:
                    args_str += f'{key}="{shlex.quote(value)}" '
            args = f"--args={args_str}"

            gn_gen = [
                "gn",
                "gen",
                "--check",
                "--fail-on-unused-args",
                self.output_dir,
                args,
            ]

            rootName = self.app.BuildRoot(self.root)
            if rootName is not None:
                gn_gen += [f"--root={rootName}"]
            elif exampleName is not None:
                gn_gen += [f"--root={self.root}/examples/{exampleName}/android/"]

            if self.board.IsIde():
                gn_gen += [
                    "--ide=json",
                    "--json-ide-script=//scripts/examples/gn_to_cmakelists.py",
                ]

            self._Execute(gn_gen, title="Generating " + self.identifier)

            # Handle SDK manager license acceptance
            self._handle_sdk_license_acceptance()

    @lock_output_dir
    def stripSymbols(self):
        output_libs_dir = os.path.join(
            self.output_dir,
            "lib",
            "jni",
            self.board.AbiName())
        for lib in os.listdir(output_libs_dir):
            if (lib.endswith(".so")):
                self._Execute(
                    ["llvm-strip",
                     "-s",
                     os.path.join(output_libs_dir, lib)
                     ],
                    "Stripping symbols from " + lib
                )

    @lock_output_dir
    def _build(self):
        if self.board.IsIde():
            # App compilation IDE
            # TODO: Android Gradle with module and -PbuildDir= will caused issue, remove -PbuildDir=
            self._Execute(
                [
                    f"{self.root}/examples/android/{self.app.AppName()}/gradlew",
                    "-p",
                    f"{self.root}/examples/android/{self.app.AppName()}",
                    f"-PmatterBuildSrcDir={self.output_dir}",
                    "-PmatterSdkSourceBuild=true",
                    f"-PmatterSourceBuildAbiFilters={self.board.AbiName()}",
                    "assembleDebug",
                ],
                title="Building APP " + self.identifier,
            )
        else:
            cmd = ["ninja", "-C", self.output_dir]

            if self.ninja_jobs is not None:
                cmd.append('-j' + str(self.ninja_jobs))

            self._Execute(
                cmd,
                title="Building JNI " + self.identifier,
            )

            if self.options.build_profile in [BuildProfile.RELEASE, BuildProfile.RELEASE_SIZE] or self.optimize_size:
                self.stripSymbols()

            exampleName = self.app.ExampleName()
            if exampleName is None:
                self.copyToSrcAndroid()
                self.gradlewBuildSrcAndroid()
            elif exampleName == "tv-casting-app":
                jnilibs_dir = os.path.join(
                    self.root,
                    "examples/",
                    self.app.ExampleName(),
                    "android/App/app/libs/jniLibs",
                    self.board.AbiName(),
                )

                libs_dir = os.path.join(
                    self.root, "examples/", self.app.ExampleName(), "android/App/app/libs"
                )

                # When size-optimized with static libc++, libc++_shared.so is
                # folded into libTvCastingApp.so and doesn't need to be shipped.
                if self.optimize_size:
                    libs = ["libTvCastingApp.so"]
                else:
                    libs = ["libc++_shared.so", "libTvCastingApp.so"]

                jars = {
                    "AndroidPlatform.jar": "third_party/connectedhomeip/src/platform/android/AndroidPlatform.jar",
                    "CHIPAppServer.jar": "third_party/connectedhomeip/src/app/server/java/CHIPAppServer.jar",
                    "CHIPInteractionModel.jar": "third_party/connectedhomeip/src/controller/java/CHIPInteractionModel.jar",
                    "TvCastingApp.jar": "TvCastingApp.jar",
                }

                self.copyToExampleApp(jnilibs_dir, libs_dir, libs, jars)
                self.gradlewBuildExampleAndroid()
            elif exampleName == "tv-app":
                jnilibs_dir = os.path.join(
                    self.root,
                    "examples/",
                    self.app.ExampleName(),
                    "android/App/app/libs/jniLibs",
                    self.board.AbiName(),
                )

                libs_dir = os.path.join(
                    self.root, "examples/", self.app.ExampleName(), "android/App/app/libs"
                )

                libs = ["libc++_shared.so", "libTvApp.so"]

                jars = {
                    "OnboardingPayload.jar": "third_party/connectedhomeip/src/controller/java/OnboardingPayload.jar",
                    "AndroidPlatform.jar": "third_party/connectedhomeip/src/platform/android/AndroidPlatform.jar",
                    "CHIPAppServer.jar": "third_party/connectedhomeip/src/app/server/java/CHIPAppServer.jar",
                    "TvApp.jar": "TvApp.jar",
                }

                self.copyToExampleApp(jnilibs_dir, libs_dir, libs, jars)
                self.gradlewBuildExampleAndroid()
            elif exampleName == "chip-test":
                jnilibs_dir = os.path.join(
                    self.root,
                    "examples/android/CHIPTest/app/libs/jniLibs",
                    self.board.AbiName(),
                )

                libs_dir = os.path.join(
                    self.root, "examples/android/CHIPTest/app/libs"
                )

                libs = ["libc++_shared.so", "libCHIPTest.so"]

                jars = {
                    "AndroidPlatform.jar": "third_party/connectedhomeip/src/platform/android/AndroidPlatform.jar",
                    "CHIPTest.jar": "CHIPTest.jar",
                }
                self.copyToExampleApp(jnilibs_dir, libs_dir, libs, jars)
                self.gradlewBuildSrcAndroid()
            elif exampleName == "virtual-device-app":
                jnilibs_dir = os.path.join(
                    self.root,
                    "examples/",
                    self.app.ExampleName(),
                    "android/App/app/libs/jniLibs",
                    self.board.AbiName(),
                )

                libs_dir = os.path.join(
                    self.root, "examples/", self.app.ExampleName(), "android/App/app/libs"
                )

                libs = ["libc++_shared.so", "libDeviceApp.so"]

                jars = {
                    "OnboardingPayload.jar": "third_party/connectedhomeip/src/controller/java/OnboardingPayload.jar",
                    "AndroidPlatform.jar": "third_party/connectedhomeip/src/platform/android/AndroidPlatform.jar",
                    "CHIPAppServer.jar": "third_party/connectedhomeip/src/app/server/java/CHIPAppServer.jar",
                    "DeviceApp.jar": "DeviceApp.jar",
                }

                self.copyToExampleApp(jnilibs_dir, libs_dir, libs, jars)
                self.gradlewBuildExampleAndroid()

    @lock_output_dir
    def build_outputs(self):
        if self.board.IsIde():
            yield BuilderOutput(
                os.path.join(
                    self.root,
                    "examples/android",
                    self.app.AppName(),
                    "app/build/outputs/apk/debug/app-debug.apk"),
                self.app.AppName() + "-debug.apk")
        elif self.app.ExampleName() is not None:
            if self.app == AndroidApp.TV_SERVER:
                yield BuilderOutput(
                    os.path.join(self.output_dir, "platform-app",
                                 "outputs", "apk", "debug", "platform-app-debug.apk"),
                    "tv-sever-platform-app-debug.apk")
                yield BuilderOutput(
                    os.path.join(self.output_dir, "content-app",
                                 "outputs", "apk", "debug", "content-app-debug.apk"),
                    "tv-sever-content-app-debug.apk")
            elif self.app == AndroidApp.VIRTUAL_DEVICE_APP:
                yield BuilderOutput(
                    os.path.join(self.output_dir, "VirtualDeviceApp", "app",
                                 "outputs", "apk", "debug", "app-debug.apk"),
                    self.app.AppName() + "app-debug.apk")
            else:
                yield BuilderOutput(
                    os.path.join(self.output_dir,
                                 "outputs", "apk", "debug", "app-debug.apk"),
                    self.app.AppName() + "app-debug.apk")
        else:
            yield BuilderOutput(
                os.path.join(self.output_dir, "outputs", "apk", "debug", "app-debug.apk"),
                self.app.AppName() + "app-debug.apk")
            yield BuilderOutput(
                os.path.join(self.output_dir, "lib", "src", "controller", "java", "CHIPController.jar"),
                "CHIPController.jar")
            yield BuilderOutput(
                os.path.join(self.output_dir, "lib", "src", "controller", "java", "CHIPInteractionModel.jar"),
                "CHIPInteractionModel.jar")
            yield BuilderOutput(
                os.path.join(self.output_dir, "lib", "src", "controller", "java", "libMatterTlv.jar"),
                "libMatterTlv.jar")
            yield BuilderOutput(
                os.path.join(self.output_dir, "lib", "src", "platform", "android", "AndroidPlatform.jar"),
                "AndroidPlatform.jar")
            yield BuilderOutput(
                os.path.join(self.output_dir, "lib", "src", "controller", "java", "OnboardingPayload.jar"),
                "OnboardingPayload.jar")
            yield BuilderOutput(
                os.path.join(self.output_dir, "lib", "src", "controller", "java", "CHIPClusters.jar"),
                "CHIPClusters.jar")
            yield BuilderOutput(
                os.path.join(self.output_dir, "lib", "src", "controller", "java", "CHIPClusterID.jar"),
                "CHIPClusterID.jar")
            yield BuilderOutput(
                os.path.join(self.output_dir, "lib", "jni", self.board.AbiName(), "libCHIPController.so"),
                f"jni/{self.board.AbiName()}/libCHIPController.so")
            yield BuilderOutput(
                os.path.join(self.output_dir, "lib", "jni", self.board.AbiName(), "libc++_shared.so"),
                f"jni/{self.board.AbiName()}/libc++_shared.so")