NikGapps 3.94__tar.gz → 3.96__tar.gz

{nikgapps-3.94 → nikgapps-3.96}/NikGapps/build/Build.py

@@ -22,6 +22,31 @@ class Build:
         if cached:
             return app_set_build_list
         building = T()
+        if Config.PACKAGE_SOURCE == "registry":
+            print("[Registry] Package source mode is enabled; skipping the legacy APK repository")
+            from nikgapps_package_pipeline.consumer import (
+                CatalogPackageSource,
+                channel_overrides_from_env,
+            )
+            registry_source = CatalogPackageSource(
+                Config.PACKAGE_CATALOG_URL,
+                Config.PACKAGE_APPSETS_URL,
+                Path(Config.PACKAGE_CACHE),
+                channel=Config.PACKAGE_CHANNEL,
+                channel_overrides=channel_overrides_from_env(Config.PACKAGE_CHANNEL_OVERRIDES),
+                token=os.environ.get("GITLAB_TOKEN"),
+            )
+            Config.APK_SOURCE = str(registry_source.prepare(
+                app_set_build_list,
+                android_version,
+                getattr(Config, "PACKAGE_ARCH", "arm64"),
+            ))
+            print(f"[Registry] Handing prepared source to the existing builder: {Config.APK_SOURCE}")
+            print("[Registry] Final NikGapps ZIP assembly remains unchanged")
+            if Config.OVERLAY_SOURCE is None:
+                overlay_path = Path(Config.APK_SOURCE) / ".overlays"
+                overlay_path.mkdir(parents=True, exist_ok=True)
+                Config.OVERLAY_SOURCE = str(overlay_path)
         source_directory = Config.APK_SOURCE
         print(f"Building from {source_directory}")
         cmd = Cmd()

{nikgapps-3.94 → nikgapps-3.96}/NikGapps/build_config.py

@@ -26,6 +26,11 @@ def build_config():
     if len(args.get_android_versions()) > 0:
         android_versions = args.get_android_versions()
     Config.UPLOAD_FILES = args.upload
+    if args.package_source:
+        Config.PACKAGE_SOURCE = args.package_source
+    if args.package_channel:
+        Config.PACKAGE_CHANNEL = args.package_channel
+    Config.PACKAGE_ARCH = args.arch
     print("---------------------------------------")
     print("Android Versions to build: " + str(android_versions))
     print("---------------------------------------")
@@ -48,10 +53,12 @@ def build_config():
             path = config_name
             F.write_string_in_lf_file(str_data=config_string, file_path=path)
     for android_version in android_versions:
-        apk_repo = GitOp.clone_apk_source(android_version, args.arch, release_type=Config.RELEASE_TYPE)
-        Config.APK_SOURCE = apk_repo.working_tree_dir
+        if Config.PACKAGE_SOURCE != "registry":
+            apk_repo = GitOp.clone_apk_source(android_version, args.arch, release_type=Config.RELEASE_TYPE)
+            Config.APK_SOURCE = apk_repo.working_tree_dir
         overlay_repo = GitOp.clone_overlay_repo(android_version)
-        Config.OVERLAY_SOURCE = overlay_repo.working_tree_dir
+        if overlay_repo is not None:
+            Config.OVERLAY_SOURCE = overlay_repo.working_tree_dir
         config_obj = NikGappsConfig(android_version=android_version, config_path=path)
         print(f"Setting up package list from {config_name}...")
         config_obj.config_package_list = Build.build_from_directory(app_set_build_list=config_obj.config_package_list,

{nikgapps-3.94 → nikgapps-3.96}/NikGapps/helper/Args.py

@@ -39,6 +39,14 @@ class Args:
             '-r', '--releaseType', help="It is the release type for which we need to build the gapps",
             default="stable", type=str)
         self.parser.add_argument('-P', '--packageList', help="List of packages to build", type=str)
+        self.parser.add_argument(
+            '--packageSource', choices=['git', 'registry'],
+            help="Use the legacy Git source or the package registry catalog"
+        )
+        self.parser.add_argument(
+            '--packageChannel', choices=['stable', 'beta', 'canary'],
+            help="Default registry channel for selected packages"
+        )
 
         args = self.parser.parse_args()
 
@@ -60,6 +68,8 @@ class Args:
         self.release_type = args.releaseType
         self.ssh_clone = args.sshClone
         self.send_zip_device = args.sendToDevice
+        self.package_source = args.packageSource
+        self.package_channel = args.packageChannel
         # self.oems = args.oems
 
     def get_package_list(self):

{nikgapps-3.94 → nikgapps-3.96}/NikGapps/helper/Config.py

@@ -53,6 +53,24 @@ CACHED_SOURCE = None
 APK_SOURCE = None
 OVERLAY_SOURCE = None
 
+# Package source. "git" preserves the existing clone behavior; "registry"
+# resolves AppSets through the published package catalog and verified cache.
+PACKAGE_SOURCE = os.environ.get("PACKAGE_SOURCE", "git").lower()
+PACKAGE_CHANNEL = os.environ.get("PACKAGE_CHANNEL", RELEASE_TYPE).lower()
+PACKAGE_CATALOG_URL = os.environ.get(
+    "PACKAGE_CATALOG_URL",
+    "https://gitlab.com/nikgapps/nikgapps-package-catalog/-/raw/main/catalog.json"
+)
+PACKAGE_APPSETS_URL = os.environ.get(
+    "PACKAGE_APPSETS_URL",
+    "https://gitlab.com/nikgapps/nikgapps-package-catalog/-/raw/main/appsets.json"
+)
+PACKAGE_CACHE = os.environ.get(
+    "PACKAGE_CACHE",
+    os.path.abspath(os.path.join(os.getcwd(), ".nikgapps-package-cache"))
+)
+PACKAGE_CHANNEL_OVERRIDES = os.environ.get("PACKAGE_CHANNEL_OVERRIDES", "{}")
+
 # Enabling this will enable the feature of building NikGapps using config file
 BUILD_CONFIG = True
 BUILD_EXCLUSIVE = (RELEASE_TYPE.lower().__eq__("stable"))

{nikgapps-3.94 → nikgapps-3.96}/NikGapps/helper/assets/config_versions.json

@@ -6,5 +6,6 @@
   "13": "37",
   "14": "37",
   "15": "37",
-  "16": "38"
-}
+  "16": "38",
+  "17": "39"
+}

{nikgapps-3.94 → nikgapps-3.96}/NikGapps/main.py

@@ -21,6 +21,11 @@ def main():
     package_list = Config.BUILD_PACKAGE_LIST
     Config.UPLOAD_FILES = args.upload
     Config.USE_CACHED_APKS = args.use_cached_apks
+    if args.package_source:
+        Config.PACKAGE_SOURCE = args.package_source
+    if args.package_channel:
+        Config.PACKAGE_CHANNEL = args.package_channel
+    Config.PACKAGE_ARCH = args.arch
     if Config.USE_CACHED_APKS:
         print("Using Cached Apks")
     Modes.DEFAULT = Modes.TAR_XZ if args.tar else Modes.ZIP
@@ -39,13 +44,17 @@ def main():
         Config.TARGET_ANDROID_VERSION = android_version
         # clone the apk repo if it doesn't exist
         if args.enable_git_clone:
-            if Config.USE_CACHED_APKS:
-                cached_repo = GitOp.clone_apk_source(android_version, release_type=Config.RELEASE_TYPE,
-                                                             cached=True)
-                Config.CACHED_SOURCE = cached_repo.working_tree_dir
-            else:
-                apk_repo = GitOp.clone_apk_source(android_version, args.arch, release_type=Config.RELEASE_TYPE)
-                Config.APK_SOURCE = apk_repo.working_tree_dir
+            if Config.PACKAGE_SOURCE != "registry":
+                if Config.USE_CACHED_APKS:
+                    cached_repo = GitOp.clone_apk_source(android_version, release_type=Config.RELEASE_TYPE,
+                                                                 cached=True)
+                    Config.CACHED_SOURCE = cached_repo.working_tree_dir
+                else:
+                    apk_repo = GitOp.clone_apk_source(android_version, args.arch, release_type=Config.RELEASE_TYPE)
+                    Config.APK_SOURCE = apk_repo.working_tree_dir
+            # Overlays are not catalog artifacts yet. Keep the established
+            # overlay source so registry-backed builds retain output parity.
+            if not Config.USE_CACHED_APKS:
                 overlay_repo = GitOp.clone_overlay_repo(android_version)
                 if overlay_repo is not None:
                     Config.OVERLAY_SOURCE = overlay_repo.working_tree_dir
@@ -53,6 +62,31 @@ def main():
             Release.zip(package_list, android_version, args.arch, args.sign)
         if Config.RELEASE_TYPE and Config.ENVIRONMENT_TYPE == "production":
             GitOp.mark_a_release(android_version, Config.RELEASE_TYPE)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
     if args.release:
         if args.update_website:
             website_repo = TestGit(GitStatics.website_repo_dir)

{nikgapps-3.94 → nikgapps-3.96}/NikGapps/overlay_control.py

@@ -1,3 +1,4 @@
+import argparse
 import os
 from pathlib import Path
 
@@ -11,11 +12,49 @@ from niklibrary.git.Git import Git
 from NikGapps.helper.overlay.Overlay import Overlay
 
 
+ANDROID_PLATFORM_VERSIONS = {
+    # niklibrary 0.28 predates Android 17. Keep the compatibility entry here
+    # until the same mapping is available in the shared library.
+    "17": {"sdk": "37", "code": "CinnamonBun"},
+}
+
+
+def register_android_platform(android_version):
+    version = str(android_version)
+    if version not in Statics.android_versions and version in ANDROID_PLATFORM_VERSIONS:
+        Statics.android_versions[version] = ANDROID_PLATFORM_VERSIONS[version]
+
+
+def build_local_overlays(android_version, source_dir, output_dir):
+    """Generate and compile overlays locally without cloning or pushing repos."""
+    register_android_platform(android_version)
+    source_dir = os.path.abspath(source_dir)
+    output_dir = os.path.abspath(output_dir)
+    os.makedirs(source_dir, exist_ok=True)
+    os.makedirs(output_dir, exist_ok=True)
+    for overlay in NikGappsOverlays.get_overlay(android_version=android_version):
+        overlay.build_apk_source(source_dir)
+    built = []
+    for folder in sorted(Path(source_dir).iterdir()):
+        if not folder.is_dir() or not F.file_exists(os.path.join(str(folder), "apktool.yml")):
+            continue
+        overlay_path = Cmd().build_overlay(folder_name=str(folder))
+        if not overlay_path:
+            raise RuntimeError(f"Failed to build Android {android_version} overlay: {folder.name}")
+        destination = os.path.join(output_dir, folder.name, f"{folder.name}.apk")
+        F.copy_file(overlay_path, destination)
+        F.remove_dir(os.path.join(str(folder), "dist"))
+        F.remove_dir(os.path.join(str(folder), "build"))
+        built.append(destination)
+    return built
+
+
 def overlay_control():
     args = Args()
     android_versions = args.get_android_versions()
 
     for android_version in android_versions:
+        register_android_platform(android_version)
         repo_name = Statics.get_overlay_source_repo(android_version)
         repo_dir = Statics.get_overlay_source_directory(android_version)
         branch = "main"
@@ -64,4 +103,17 @@ def overlay_control():
 
 
 if __name__ == "__main__":
-    overlay_control()
+    parser = argparse.ArgumentParser(description="Build NikGapps resource overlays")
+    parser.add_argument("--android-version")
+    parser.add_argument("--source-dir")
+    parser.add_argument("--output-dir")
+    options = parser.parse_args()
+    if options.android_version:
+        if not options.source_dir or not options.output_dir:
+            parser.error("--source-dir and --output-dir are required in local mode")
+        paths = build_local_overlays(
+            options.android_version, options.source_dir, options.output_dir
+        )
+        print(f"Built {len(paths)} overlays for Android {options.android_version}")
+    else:
+        overlay_control()

{nikgapps-3.94 → nikgapps-3.96/NikGapps.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: NikGapps
-Version: 3.94
+Version: 3.96
 Summary: A short description of your project
 Home-page: https://github.com/nikgapps/project
 Author: Nikhil Menghani

{nikgapps-3.94 → nikgapps-3.96}/NikGapps.egg-info/SOURCES.txt

@@ -63,4 +63,30 @@ NikGapps/helper/overlay/Overlay.py
 NikGapps/helper/overlay/Resources.py
 NikGapps/helper/overlay/String.py
 NikGapps/helper/overlay/StringArray.py
-NikGapps/helper/overlay/__init__.py
+NikGapps/helper/overlay/__init__.py
+nikgapps_package_pipeline/__init__.py
+nikgapps_package_pipeline/__main__.py
+nikgapps_package_pipeline/apk.py
+nikgapps_package_pipeline/archive.py
+nikgapps_package_pipeline/cli.py
+nikgapps_package_pipeline/compat.py
+nikgapps_package_pipeline/config.py
+nikgapps_package_pipeline/consumer.py
+nikgapps_package_pipeline/errors.py
+nikgapps_package_pipeline/gitlab.py
+nikgapps_package_pipeline/models.py
+nikgapps_package_pipeline/pipeline.py
+nikgapps_package_pipeline/scanner.py
+nikgapps_package_pipeline/upgrade.py
+nikgapps_package_pipeline/util.py
+nikgapps_registry/__init__.py
+nikgapps_registry/__main__.py
+nikgapps_registry/cli.py
+nikgapps_registry/service.py
+tests_package_pipeline/__init__.py
+tests_package_pipeline/test_consumer.py
+tests_package_pipeline/test_overlay_control.py
+tests_package_pipeline/test_pipeline.py
+tests_package_pipeline/test_upgrade.py
+tests_registry/__init__.py
+tests_registry/test_registry.py

{nikgapps-3.94 → nikgapps-3.96}/NikGapps.egg-info/entry_points.txt

@@ -3,5 +3,6 @@ build = NikGapps.build_config:build_config
 cache = NikGapps.cache:cache
 copy_repos = NikGapps.copy_repos:copy_repos
 nikgapps = NikGapps.main:main
+nikgapps-registry = nikgapps_registry.cli:main
 nikgapps_config_upload = NikGapps.config_upload:config_upload
 nikgapps_overlay = NikGapps.overlay_control:overlay_control

nikgapps-3.96/NikGapps.egg-info/top_level.txt

@@ -0,0 +1,5 @@
+NikGapps
+nikgapps_package_pipeline
+nikgapps_registry
+tests_package_pipeline
+tests_registry

{nikgapps-3.94/NikGapps.egg-info → nikgapps-3.96}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: NikGapps
-Version: 3.94
+Version: 3.96
 Summary: A short description of your project
 Home-page: https://github.com/nikgapps/project
 Author: Nikhil Menghani

nikgapps-3.96/nikgapps_package_pipeline/__init__.py

@@ -0,0 +1,3 @@
+"""Independent NikGapps package migration and publishing pipeline."""
+
+__version__ = "1.0.0"

nikgapps-3.96/nikgapps_package_pipeline/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+raise SystemExit(main())

nikgapps-3.96/nikgapps_package_pipeline/apk.py

@@ -0,0 +1,136 @@
+from __future__ import annotations
+
+import re
+import subprocess
+import os
+from pathlib import Path
+
+from .errors import PipelineError
+from .models import ApkMetadata
+
+
+class ApkInspector:
+    """APK metadata boundary; injectable for tests and alternate tooling."""
+
+    def inspect(self, apk: Path) -> ApkMetadata:
+        raise NotImplementedError
+
+    def privileged_permissions(self, apk: Path) -> list[str]:
+        """Return permissions requested/declared by a privileged APK."""
+        return []
+
+
+class Aapt2Inspector(ApkInspector):
+    def __init__(self, executable: str = "aapt2") -> None:
+        self.executable = executable
+
+    def inspect(self, apk: Path) -> ApkMetadata:
+        badging = self._dump(["dump", "badging", str(apk)], apk)
+        if not re.search(r"^sdkVersion:'\d+'", badging, re.MULTILINE):
+            manifest = self._dump(
+                ["dump", "xmltree", str(apk), "--file", "AndroidManifest.xml"],
+                apk,
+            )
+            uses_sdk = re.search(
+                r"E: uses-sdk\b(?P<body>.*?)(?=\n\s*E: |\Z)",
+                manifest,
+                re.DOTALL,
+            )
+            minimum = re.search(
+                r"minSdkVersion[^=]*=(?:\(type [^)]+\))?(\d+)",
+                uses_sdk.group("body") if uses_sdk else "",
+            )
+            if not minimum:
+                raise PipelineError(
+                    f"Missing minimum SDK in both badging and manifest output for {apk}"
+                )
+            badging += f"\nsdkVersion:'{minimum.group(1)}'\n"
+        return self.parse(badging, apk)
+
+    def privileged_permissions(self, apk: Path) -> list[str]:
+        output = self._dump(["dump", "permissions", str(apk)], apk)
+        permissions: set[str] = set()
+        for line in output.splitlines():
+            stripped = line.strip()
+            requested = re.match(r"uses-permission(?:-sdk-\d+)?:\s+name='([^']+)'", stripped)
+            declared = re.match(r"permission:\s+(?:name=)?'?([^'\s]+)'?", stripped)
+            match = requested or declared
+            if match:
+                permissions.add(match.group(1))
+        return sorted(permissions)
+
+    def _dump(self, arguments: list[str], apk: Path) -> str:
+        try:
+            result = subprocess.run(
+                [self.executable, *arguments],
+                check=True,
+                capture_output=True,
+            )
+        except FileNotFoundError as exc:
+            raise PipelineError(
+                f"{self.executable!r} was not found. Install Android build-tools "
+                "or pass --aapt2 with its full path."
+            ) from exc
+        except subprocess.CalledProcessError as exc:
+            raw_detail = exc.stderr or exc.stdout or b""
+            detail = raw_detail.decode("utf-8", errors="replace").strip()
+            raise PipelineError(f"aapt2 failed for {apk}: {detail}") from exc
+        return result.stdout.decode("utf-8", errors="replace")
+
+    @staticmethod
+    def parse(text: str, apk: Path | None = None) -> ApkMetadata:
+        def required(pattern: str, name: str) -> str:
+            match = re.search(pattern, text, re.MULTILINE)
+            if not match:
+                raise PipelineError(f"Missing {name} in aapt2 output for {apk or 'APK'}")
+            return match.group(1)
+
+        return ApkMetadata(
+            package_name=required(r"^package: name='([^']+)'", "package name"),
+            version_name=required(r"^package:.*versionName='([^']+)'", "version name"),
+            version_code=int(required(r"^package:.*versionCode='(\d+)'", "version code")),
+            min_api=int(required(r"^sdkVersion:'(\d+)'", "minimum SDK")),
+            target_api=int(required(r"^targetSdkVersion:'(\d+)'", "target SDK")),
+        )
+
+
+def find_aapt2() -> str:
+    """Find aapt2 in PATH or a conventional local Android SDK."""
+    import shutil
+
+    on_path = shutil.which("aapt2")
+    if on_path:
+        return on_path
+    project_root = Path(__file__).resolve().parent.parent
+    bundled = (
+        project_root.parent / "nikassets" / "nikassets" / "helper" / "assets"
+        / "bin" / ("Windows" if os.name == "nt" else "Linux")
+        / ("aapt2.exe" if os.name == "nt" else "aapt2")
+    )
+    if bundled.is_file():
+        return str(bundled)
+    sdk_roots = [
+        os.environ.get("ANDROID_SDK_ROOT"),
+        os.environ.get("ANDROID_HOME"),
+        str(Path.home() / "AppData" / "Local" / "Android" / "Sdk"),
+    ]
+    for raw_root in sdk_roots:
+        if not raw_root:
+            continue
+        build_tools = Path(raw_root) / "build-tools"
+        try:
+            exists = build_tools.is_dir()
+        except OSError:
+            continue
+        if not exists:
+            continue
+        try:
+            candidates = sorted(
+                build_tools.glob("*/aapt2.exe" if os.name == "nt" else "*/aapt2"),
+                reverse=True,
+            )
+        except OSError:
+            continue
+        if candidates:
+            return str(candidates[0])
+    return "aapt2"

nikgapps-3.96/nikgapps_package_pipeline/archive.py

@@ -0,0 +1,176 @@
+from __future__ import annotations
+
+import zipfile
+from pathlib import Path
+from typing import Any
+
+from .errors import PipelineError
+from .models import PayloadFile
+from .util import json_data, safe_path
+
+ZIP_TIME = (1980, 1, 1, 0, 0, 0)
+ALREADY_COMPRESSED = {
+    ".apk", ".zip", ".jar", ".gz", ".png", ".jpg", ".jpeg", ".webp",
+    ".mp3", ".mp4", ".so", ".tflite",
+}
+
+
+def _write_entry(archive: zipfile.ZipFile, name: str, data: bytes, compress: int) -> None:
+    safe_path(name)
+    info = zipfile.ZipInfo(name, ZIP_TIME)
+    info.create_system = 3
+    info.external_attr = 0o100644 << 16
+    info.compress_type = compress
+    archive.writestr(info, data, compress_type=compress, compresslevel=9)
+
+
+def write_package_zip(
+    destination: Path,
+    files: list[PayloadFile],
+    manifest: dict[str, Any],
+    *,
+    pretty: bool = True,
+) -> None:
+    if any(item.path in {"package.json", "installer.sh", "uninstaller.sh"} for item in files):
+        raise PipelineError("Payload collides with reserved package.json")
+    destination.parent.mkdir(parents=True, exist_ok=True)
+    with zipfile.ZipFile(destination, "w") as archive:
+        for item in sorted(files, key=lambda value: value.path):
+            compression = (
+                zipfile.ZIP_STORED
+                if item.source.suffix.casefold() in ALREADY_COMPRESSED
+                else zipfile.ZIP_DEFLATED
+            )
+            _write_entry(archive, encode_builder_path(item.path), item.source.read_bytes(), compression)
+        for generated in sorted(manifest.get("generatedFiles", []), key=lambda value: value["path"]):
+            _write_entry(
+                archive,
+                encode_builder_path(generated["path"]),
+                generated["content"].encode("utf-8"),
+                zipfile.ZIP_DEFLATED,
+            )
+        _write_entry(archive, "installer.sh", package_installer(manifest).encode(), zipfile.ZIP_DEFLATED)
+        _write_entry(archive, "uninstaller.sh", package_uninstaller(manifest).encode(), zipfile.ZIP_DEFLATED)
+        _write_entry(archive, "package.json", json_data(manifest, pretty), zipfile.ZIP_DEFLATED)
+
+
+def encode_builder_path(path: str) -> str:
+    """Encode an install path using the nested-package format used by NikGapps."""
+    safe_path(path)
+    parts = path.split("/")
+    return "___" + "___".join(parts[:-1]) + "/" + parts[-1]
+
+
+def _lines(values: list[str]) -> str:
+    return "\n".join(values)
+
+
+def _legacy_asset(name: str) -> str:
+    path = Path(__file__).resolve().parent.parent / "NikGapps" / "helper" / "assets" / name
+    try:
+        return path.read_text(encoding="utf-8")
+    except OSError as exc:
+        raise PipelineError(f"Cannot read legacy package template {path}: {exc}") from exc
+
+
+def package_installer(manifest: dict[str, Any]) -> str:
+    install = manifest["install"]
+    apk = manifest.get("apk") or {}
+    file_list = [item["archivePath"] for item in manifest["files"]]
+    extra = install.get("additionalInstallerScript") or ""
+    extra_block = f"{extra}\n" if extra else ""
+    validation = install.get("validationScript") or "find_install_mode"
+    remove_files = [value for value in install["removeFiles"] if value.strip()]
+    remove_overlays = [value for value in install["removeOverlays"] if value.strip()]
+    remove_files_block = "".join(f"{value}\n" for value in remove_files)
+    remove_overlays_block = "".join(f"{value}\n" for value in remove_overlays)
+    file_list_block = "".join(f"{value}\n" for value in file_list)
+    folders: list[str] = []
+    for row in manifest["files"]:
+        parts = row["path"].split("/")[:-1]
+        for index in range(1, len(parts) + 1):
+            folder = "/".join(parts[:index])
+            if parts and parts[0] not in {"system", "vendor", "product", "system_ext", "overlay"} and folder not in folders:
+                folders.append(folder)
+    make_dirs = "".join(f'   make_dir "{folder}"\n' for folder in folders)
+    return _legacy_asset("installer.sh") + f'''# Initialize the variables
+default_partition="{manifest["defaultPartition"]}"
+clean_flash_only="{str(install["cleanFlashOnly"]).lower()}"
+product_prefix=$(find_product_prefix "$install_partition")
+title="{install["title"]}"
+package_title="{install["packageTitle"]}"
+pkg_size="{install["payloadSize"]}"
+package_name="{manifest.get("packageName") or ""}"
+packagePath=install{install["packageTitle"]}Files
+deleteFilesPath=delete{install["packageTitle"]}Files
+propFilePath=$(get_prop_file_path $package_title)
+
+remove_aosp_apps_from_rom="
+{remove_files_block}"
+
+delete_overlays="
+{remove_overlays_block}"
+
+file_list="
+{file_list_block}"
+
+remove_overlays() {{
+   for i in $delete_overlays; do
+       delete_overlays "$i" "$propFilePath" "$package_title" 
+   done
+}}
+
+remove_existing_package() {{
+   # remove the existing folder for clean install of {install["packageTitle"]}
+   delete_package "{install["title"]}" "$package_title" 
+}}
+
+remove_aosp_apps() {{
+   # Delete the folders that we want to remove with installing {install["packageTitle"]}
+   for i in $remove_aosp_apps_from_rom; do
+       RemoveAospAppsFromRom "$i" "$propFilePath" "$package_title" 
+   done
+}}
+
+install_package() {{
+   remove_existing_package
+   remove_aosp_apps
+   remove_overlays
+   # Create folders and set the permissions
+{make_dirs}
+   delete_prop_lines "$propFilePath"
+
+   # Copy the files and set the permissions
+   for i in $file_list; do
+       install_file "$i"
+   done
+
+{extra_block}   chmod 755 "$COMMONDIR/addon.sh";
+   update_prop "$propFilePath" "install" "$propFilePath" "{install["packageTitle"]}" 
+   . $COMMONDIR/addon.sh "{install["packageTitle"]}" "$propFilePath" "{install["addonIndex"]}"
+   copy_file "$propFilePath" "$logDir/addonfiles/$package_title.prop"
+}}
+
+{validation}
+
+'''
+
+
+def package_uninstaller(manifest: dict[str, Any]) -> str:
+    install = manifest["install"]
+    file_list = [item["archivePath"] for item in manifest["files"]]
+    return _legacy_asset("uninstaller.sh") + f'''
+
+# Initialize the variables
+uninstall_addon=$1
+clean_flash_only="{str(install["cleanFlashOnly"]).lower()}"
+title="{install["title"]}"
+package_title="{install["packageTitle"]}"
+package_name="{manifest.get("packageName") or ""}"
+
+file_list="
+{_lines(file_list)}
+"
+
+uninstall_package
+'''