# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
# vim: set filetype=python:
# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this
# file, You can obtain one at http://mozilla.org/MPL/2.0/.

project_flag(
    "MOZ_ANDROID_EXCLUDE_FONTS",
    help="Whether to exclude font files from the build",
    default=True,
)

project_flag(
    "MOZ_ANDROID_HLS_SUPPORT",
    help="Enable HLS (HTTP Live Streaming) support (currently using the ExoPlayer library)",
    default=True,
)

option(
    "--num-content-services",
    default="40",
    help="The number of content process services to generate in the GeckoView manifest",
)


@depends("--num-content-services")
def num_content_services(value):
    strValue = value[0]
    intValue = int(strValue)
    acceptableRange = range(1, 41)
    if intValue not in acceptableRange:
        die(
            "Unacceptable value, must be within range [%d,%d)"
            % (acceptableRange.start, acceptableRange.stop)
        )
    return strValue


set_config("MOZ_ANDROID_CONTENT_SERVICE_COUNT", num_content_services)
set_define("MOZ_ANDROID_CONTENT_SERVICE_COUNT", num_content_services)

option(
    "--enable-isolated-zygote-process",
    env="MOZ_ANDROID_CONTENT_SERVICE_ISOLATED_WITH_ZYGOTE",
    help="Enable generating content process services with app Zygote preloading and isolated processes",
    default=False,
)

isIsolatedAppZygoteProcessEnabled = depends_if(
    "MOZ_ANDROID_CONTENT_SERVICE_ISOLATED_WITH_ZYGOTE"
)(lambda _: True)
set_config(
    "MOZ_ANDROID_CONTENT_SERVICE_ISOLATED_WITH_ZYGOTE",
    isIsolatedAppZygoteProcessEnabled,
)
set_define(
    "MOZ_ANDROID_CONTENT_SERVICE_ISOLATED_WITH_ZYGOTE",
    isIsolatedAppZygoteProcessEnabled,
)

option(
    "--enable-isolated-process",
    env="MOZ_ANDROID_CONTENT_SERVICE_ISOLATED_PROCESS",
    help="Enable generating content process services with isolatedProcess=true",
    default=False,
)

isIsolatedProcessEnabled = depends_if("MOZ_ANDROID_CONTENT_SERVICE_ISOLATED_PROCESS")(
    lambda _: True
)
set_config(
    "MOZ_ANDROID_CONTENT_SERVICE_ISOLATED_PROCESS",
    isIsolatedProcessEnabled,
)
set_define(
    "MOZ_ANDROID_CONTENT_SERVICE_ISOLATED_PROCESS",
    isIsolatedProcessEnabled,
)

option(
    "--enable-geckoview-lite",
    help="Build GeckoView in Lite mode. Lite mode removes all unnecessary dependencies like Glean",
)

set_config("MOZ_ANDROID_GECKOVIEW_LITE", True, when="--enable-geckoview-lite")

option(
    "--enable-android-subproject",
    choices=(
        "fenix",
        "focus",
        "geckoview_example",
    ),
    nargs="?",
    help="Build a subproject of android. Possible options: fenix/focus/geckoview_example",
)


@depends("--enable-android-subproject")
def android_subproject(value):
    if value:
        return value[0]


set_config("MOZ_ANDROID_SUBPROJECT", android_subproject)


# The android:debuggable flag controls if a debugger can be attached on to the
# running app. Default this setting to follow `--enable-debug`. Use this flag to
# allow attaching debugging to app compiled in an optimized / release
# configuration.
#
# NOTE: There are numerous performance implications for a package marked as
#       android:debuggable versus a similar one that isn't. Particularly around
#       AOT compilation heuristics and caches.

option(
    "--enable-android-debuggable",
    default=moz_debug,
    help="{Enable|Disable} the android:debuggable flag in AndroidManifest.xml",
)


@depends("--enable-android-debuggable")
def android_debuggable(value):
    if value:
        return True


set_config("MOZ_ANDROID_DEBUGGABLE", android_debuggable)


imply_option("MOZ_NORMANDY", False)
imply_option("MOZ_SERVICES_HEALTHREPORT", True)
imply_option("MOZ_GECKOVIEW_HISTORY", True)

imply_option("MOZ_APP_UA_NAME", "Firefox")
imply_option("MOZ_APP_VENDOR", "Mozilla")
imply_option("MOZ_APP_ID", "{aa3c5121-dab2-40e2-81ca-7ea25febc110}")
imply_option("BROWSER_CHROME_URL", "chrome://geckoview/content/geckoview.xhtml")

option(
    "--enable-appservices-in-tree",
    help="Enables building from an in-tree app-services",
)


@depends("--enable-appservices-in-tree")
def enable_appservices_in_tree(value):
    if value:
        return True


set_config("MOZ_APPSERVICES_IN_TREE", enable_appservices_in_tree)


@depends(target)
def check_target(target):
    if target.os != "Android":
        log.error(
            "You must specify --target=arm-linux-androideabi (or some "
            "other valid Android target) when building mobile/android."
        )
        die(
            "See https://developer.mozilla.org/docs/Mozilla/Developer_guide/"
            "Build_Instructions/Simple_Firefox_for_Android_build "
            "for more information about the necessary options."
        )


include("../shared/moz.configure")
include("../../toolkit/moz.configure")
include("../../build/moz.configure/android-sdk.configure")
include("../../build/moz.configure/java.configure")
include("gradle.configure")

# Automation will set this via the TC environment.
option(
    env="MOZ_ANDROID_FAT_AAR_ARCHITECTURES",
    nargs="*",
    choices=("armeabi-v7a", "arm64-v8a", "x86_64"),
    help='Comma-separated list of Android CPU architectures like "armeabi-v7a,arm64-v8a,x86_64"',
)

set_config(
    "MOZ_ANDROID_FAT_AAR_ARCHITECTURES",
    depends("MOZ_ANDROID_FAT_AAR_ARCHITECTURES")(lambda x: x),
)


# Template to check for a build-time host/bin program that is either produced as
# part of the build or is fetched from a toolchain artifact.  Also allows
# `--without-{prog}` to disable checking.
#
# Such compiled programs are "part of the build" but need special accommodations
# to distribute to artifact builds: they are distributed as toolchain builds
# rather than extracted from a package or a test package.  In addition, these
# compiled programs may not be needed for very unusual jobs, in particular
# `android-gradle-dependencies` jobs, so they can be disabled entirely.
#
# - `var` is the name of the variable that will be set with `set_config` when
#   the program is found, like "A_PROG".
# - `prog` is the name of the program, like "a-prog".
# - `toolchain` is the name of the toolchain (defaults to `prog`).
@template
def check_host_bin_prog(var, prog, toolchain=None):
    option(f"--without-{prog}", help="Disable building with {prog}")

    with only_when(f"--with-{prog}"):
        with only_when(compile_environment):
            # Produced at build-time.  Look in `$DIST/host/bin`.
            set_config(
                var,
                depends(build_environment.dist, bin_suffix(host))(
                    lambda dist, bin_suffix: f"{dist}/host/bin/{prog}{bin_suffix}"
                ),
            )

        with only_when(~compile_environment):
            # Fetched at configure-time.  Look in `~/.mozbuild` locally or
            # `$MOZ_FETCH_DIR` in automation.
            check_prog(
                var,
                [prog],
                what=prog,
                bootstrap=toolchain or prog,
            )


check_host_bin_prog("EMBEDDED_UNIFFI_BINDGEN", "embedded-uniffi-bindgen")
check_host_bin_prog("NIMBUS_FML", "nimbus-fml")