gecko-dev/mobile/android/gradle.configure

# -*- 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/.

# If --with-gradle is specified, build mobile/android with Gradle.  If no
# Gradle binary is specified use the in tree Gradle wrapper.  The wrapper
# downloads and installs Gradle, which is good for local developers but not
# good in automation.
option('--without-gradle', nargs='?',
       help='Disable building mobile/android with Gradle '
            '(argument: location of binary or wrapper (gradle/gradlew))')

@depends('--with-gradle')
def with_gradle(value):
    if not value:
        die('Building --without-gradle is no longer supported: '
            'see https://bugzilla.mozilla.org/show_bug.cgi?id=1414415.')

    if value:
        return True


@depends('--with-gradle', check_build_environment)
@imports(_from='os.path', _import='isfile')
def gradle(value, build_env):
    gradle = value[0] if len(value) else \
        os.path.join(build_env.topsrcdir, 'gradlew')

    # TODO: verify that $GRADLE is executable.
    if not isfile(gradle):
        die('GRADLE must be executable: %s', gradle)

    return gradle

set_config('GRADLE', gradle)


@dependable
@imports(_from='itertools', _import='chain')
def gradle_android_build_config():
    def capitalize(s):
        # str.capitalize lower cases trailing letters.
        if s:
            return s[0].upper() + s[1:]
        else:
            return s

    def variant(productFlavors, buildType):
        return namespace(
            productFlavors=productFlavors,
            buildType=buildType,
            # Like 'WithoutGeckoBinariesDebug'
            name = ''.join(capitalize(t) for t in chain(productFlavors, (buildType, )))
        )

    return namespace(
        app=namespace(
            variant=variant(('withoutGeckoBinaries',), 'debug'),
        ),
        geckoview=namespace(
            variant=variant(('withGeckoBinaries',), 'debug'),
        ),
        geckoview_example=namespace(
            variant=variant(('withGeckoBinaries',), 'debug'),
        ),
    )


@depends(gradle_android_build_config)
@imports(_from='itertools', _import='imap')
def gradle_android_intermediates_folder(build_config):
    '''Path to intermediates classes folder.'''
    def uncapitalize(s):
        if s:
            return s[0].lower() + s[1:]
        else:
            return s

    def capitalize(s):
        # str.capitalize lower cases trailing letters.
        if s:
            return s[0].upper() + s[1:]
        else:
            return s

    productFlavor = uncapitalize(''.join(imap(capitalize, build_config.geckoview.variant.productFlavors)))
    buildType = uncapitalize(build_config.geckoview.variant.buildType)

    return "gradle/build/mobile/android/geckoview/intermediates/classes/{}/{}".format(
            productFlavor,
            buildType)

set_config('GRADLE_ANDROID_GECKOVIEW_APILINT_FOLDER', gradle_android_intermediates_folder)

@depends(gradle_android_build_config)
def gradle_android_variant_name(build_config):
    '''Like "withoutGeckoBinariesDebug".'''
    def uncapitalize(s):
        if s:
            return s[0].lower() + s[1:]
        else:
            return s

    return namespace(
        app=uncapitalize(build_config.app.variant.name),
        geckoview=uncapitalize(build_config.geckoview.variant.name),
    )

set_config('GRADLE_ANDROID_APP_VARIANT_NAME', gradle_android_variant_name.app)

set_config('GRADLE_ANDROID_GECKOVIEW_VARIANT_NAME', gradle_android_variant_name.geckoview)


@depends(gradle_android_build_config)
def gradle_android_app_tasks(build_config):
    '''Gradle tasks run by |mach android assemble-app|.'''
    return [
        'geckoview:generateJNIWrappersForGenerated{geckoview.variant.name}'.format(geckoview=build_config.geckoview),
        'app:generateJNIWrappersForFennec{app.variant.name}'.format(app=build_config.app),
        'app:assemble{app.variant.name}'.format(app=build_config.app),
        'app:assemble{app.variant.name}AndroidTest'.format(app=build_config.app),
    ]

set_config('GRADLE_ANDROID_APP_TASKS', gradle_android_app_tasks)


@dependable
def gradle_android_generate_sdk_bindings_tasks():
    '''Gradle tasks run by |mach android generate-sdk-bindings|.'''
    return [
        'geckoview:generateSDKBindings',
    ]

set_config('GRADLE_ANDROID_GENERATE_SDK_BINDINGS_TASKS', gradle_android_generate_sdk_bindings_tasks)


@depends(gradle_android_build_config)
def gradle_android_generate_generated_jni_wrappers_tasks(build_config):
    '''Gradle tasks run by |mach android generate-generated-jni-wrappers|.'''
    return [
        'geckoview:generateJNIWrappersForGenerated{geckoview.variant.name}'.format(geckoview=build_config.geckoview),
    ]

set_config('GRADLE_ANDROID_GENERATE_GENERATED_JNI_WRAPPERS_TASKS', gradle_android_generate_generated_jni_wrappers_tasks)


@depends(gradle_android_build_config)
def gradle_android_generate_fennec_jni_wrappers_tasks(build_config):
    '''Gradle tasks run by |mach android generate-fennec-jni-wrappers|.'''
    return [
        'app:generateJNIWrappersForFennec{app.variant.name}'.format(app=build_config.app),
    ]

set_config('GRADLE_ANDROID_GENERATE_FENNEC_JNI_WRAPPERS_TASKS', gradle_android_generate_fennec_jni_wrappers_tasks)


@depends(gradle_android_build_config, check_build_environment)
@imports(_from='itertools', _import='imap')
def gradle_android_app_apks(build_config, build_env):
    '''Paths to APK files produced by |mach android assemble-app|.'''
    def capitalize(s):
        # str.capitalize lower cases trailing letters.
        if s:
            return s[0].upper() + s[1:]
        else:
            return s

    def uncapitalize(s):
        if s:
            return s[0].lower() + s[1:]
        else:
            return s

    # Like 'productFlavor'.
    productFlavor = uncapitalize(''.join(imap(capitalize, build_config.app.variant.productFlavors)))
    # Like 'product-flavor'.
    product_flavor = '-'.join(build_config.app.variant.productFlavors)

    substs = {
        'topobjdir': build_env.topobjdir,
        'productFlavor': productFlavor,
        'product_flavor': product_flavor,
        'buildType': build_config.app.variant.buildType,
    }

    f = '{topobjdir}/gradle/build/mobile/android/app/outputs/apk/{productFlavor}/{buildType}/app-{product_flavor}-{buildType}.apk'
    g = '{topobjdir}/gradle/build/mobile/android/app/outputs/apk/androidTest/{productFlavor}/{buildType}/app-{product_flavor}-{buildType}-androidTest.apk'

    return namespace(app_apk=f.format(**substs),
                     app_androidTest_apk=g.format(**substs))

set_config('GRADLE_ANDROID_APP_APK', gradle_android_app_apks.app_apk)
set_config('GRADLE_ANDROID_APP_ANDROIDTEST_APK', gradle_android_app_apks.app_androidTest_apk)


@depends(gradle_android_build_config)
def gradle_android_test_tasks(build_config):
    '''Gradle tasks run by |mach android test|.'''
    return [
        'app:test{app.variant.name}UnitTest'.format(app=build_config.app),
        'geckoview:test{geckoview.variant.name}UnitTest'.format(
            geckoview=build_config.geckoview),
    ]


@dependable
def gradle_android_test_ccov_report_tasks():
    '''Additional gradle tasks run by |mach android test-ccov|.'''
    return [
        'app:jacocoTestReport',
        'geckoview:jacocoTestReport',
    ]

set_config('GRADLE_ANDROID_TEST_TASKS', gradle_android_test_tasks)
set_config('GRADLE_ANDROID_TEST_CCOV_REPORT_TASKS', gradle_android_test_ccov_report_tasks)


@depends(gradle_android_build_config)
def gradle_android_lint_tasks(build_config):
    '''Gradle tasks run by |mach android lint|.'''
    return [
        'app:lint{app.variant.name}'.format(app=build_config.app),
    ]

set_config('GRADLE_ANDROID_LINT_TASKS', gradle_android_lint_tasks)

@depends(gradle_android_build_config)
def gradle_android_api_lint_tasks(build_config):
    '''Gradle tasks run by |mach android api-lint|.'''
    return [
        'geckoview:apiLint{geckoview.variant.name}'.format(geckoview=build_config.geckoview),
    ]

set_config('GRADLE_ANDROID_API_LINT_TASKS', gradle_android_api_lint_tasks)


@dependable
def gradle_android_checkstyle_tasks():
    '''Gradle tasks run by |mach android checkstyle|.'''
    return [
        'app:checkstyle',
    ]

set_config('GRADLE_ANDROID_CHECKSTYLE_TASKS', gradle_android_checkstyle_tasks)


@depends(gradle_android_build_config)
def gradle_android_findbugs_tasks(build_config):
    '''Gradle tasks run by |mach android findbugs|.'''
    return [
        'app:findbugsXml{app.variant.name}'.format(app=build_config.app),
        'app:findbugsHtml{app.variant.name}'.format(app=build_config.app),
    ]

set_config('GRADLE_ANDROID_FINDBUGS_TASKS', gradle_android_findbugs_tasks)


@depends(gradle_android_build_config)
def gradle_android_archive_geckoview_tasks(build_config):
    '''Gradle tasks run by |mach android archive-geckoview|.'''
    return [
        'geckoview:assemble{geckoview.variant.name}'.format(geckoview=build_config.geckoview),
        'geckoview:assemble{geckoview.variant.name}AndroidTest'.format(geckoview=build_config.geckoview),
        'geckoview_example:assemble{geckoview_example.variant.name}'.format(geckoview_example=build_config.geckoview_example),
        'geckoview_example:assemble{geckoview_example.variant.name}AndroidTest'.format(geckoview_example=build_config.geckoview_example),
        'geckoview:publish{geckoview.variant.name}PublicationToMavenRepository'.format(geckoview=build_config.geckoview),
    ]

set_config('GRADLE_ANDROID_ARCHIVE_GECKOVIEW_TASKS', gradle_android_archive_geckoview_tasks)


@depends(gradle_android_build_config)
def gradle_android_archive_coverage_artifacts_tasks(build_config):
    '''Gradle tasks run by |mach android archive-coverage-artifacts|.'''
    return [
        'geckoview:archiveClassfiles{geckoview.variant.name}'.format(geckoview=build_config.geckoview),
        'geckoview:copyCoverageDependencies',
        'app:archiveClassfiles{app.variant.name}'.format(app=build_config.app),
    ]

set_config('GRADLE_ANDROID_ARCHIVE_COVERAGE_ARTIFACTS_TASKS',
           gradle_android_archive_coverage_artifacts_tasks)


@depends(gradle_android_build_config)
def gradle_android_build_geckoview_example_tasks(build_config):
    '''Gradle tasks run by |mach android build-geckoview_example|.'''
    return [
        'geckoview_example:assemble{geckoview_example.variant.name}'.format(geckoview_example=build_config.geckoview_example),
        'geckoview_example:assemble{geckoview_example.variant.name}AndroidTest'.format(geckoview_example=build_config.geckoview_example),
    ]

set_config('GRADLE_ANDROID_BUILD_GECKOVIEW_EXAMPLE_TASKS', gradle_android_build_geckoview_example_tasks)


@depends(gradle_android_build_config)
def gradle_android_install_geckoview_example_tasks(build_config):
    '''Gradle tasks run by |mach android install-geckoview_example|.'''
    return [
        'geckoview_example:install{geckoview_example.variant.name}'.format(geckoview_example=build_config.geckoview_example),
        'geckoview_example:install{geckoview_example.variant.name}AndroidTest'.format(geckoview_example=build_config.geckoview_example),
    ]

set_config('GRADLE_ANDROID_INSTALL_GECKOVIEW_EXAMPLE_TASKS', gradle_android_install_geckoview_example_tasks)


@depends(
    gradle_android_app_tasks,
    gradle_android_api_lint_tasks,
    gradle_android_test_tasks,
    gradle_android_lint_tasks,
    gradle_android_checkstyle_tasks,
    gradle_android_findbugs_tasks,
    gradle_android_archive_geckoview_tasks,
    gradle_android_generate_sdk_bindings_tasks,
    gradle_android_generate_generated_jni_wrappers_tasks,
    gradle_android_generate_fennec_jni_wrappers_tasks,
    gradle_android_archive_coverage_artifacts_tasks,
)
@imports(_from='itertools', _import='imap')
@imports(_from='itertools', _import='chain')
@imports(_from='itertools', _import='ifilterfalse')
def gradle_android_dependencies_tasks(*tasks):
    '''Gradle tasks run by |mach android dependencies|.'''
    # The union, plus a bit more, of all of the Gradle tasks
    # invoked by the android-* automation jobs.
    def withoutGeckoBinaries(task):
        return task.replace('withGeckoBinaries', 'withoutGeckoBinaries')

    return list(imap(withoutGeckoBinaries, chain(*tasks)))

set_config('GRADLE_ANDROID_DEPENDENCIES_TASKS', gradle_android_dependencies_tasks)


# Automation uses this to change log levels, not use the daemon, and use
# offline mode.
option(env='GRADLE_FLAGS', default='', help='Flags to pass to Gradle.')

@depends('GRADLE_FLAGS')
def gradle_flags(value):
    return value[0] if value else ''

set_config('GRADLE_FLAGS', gradle_flags)

# Automation will set this to (file:///path/to/local, ...) via the mozconfig.
# Local developer default is (jcenter, maven.google.com).
option(env='GRADLE_MAVEN_REPOSITORIES',
       nargs='+',
       default=('https://maven.google.com/',
                'https://jcenter.bintray.com/',
                'https://plugins.gradle.org/m2/',
       ),
       help='Comma-separated URLs of Maven repositories containing Gradle dependencies.')

@depends('GRADLE_MAVEN_REPOSITORIES')
@imports(_from='os.path', _import='isdir')
def gradle_maven_repositories(values):
    if not values:
        die('GRADLE_MAVEN_REPOSITORIES must not be empty')
    if not all(values):
        die('GRADLE_MAVEN_REPOSITORIES entries must not be empty')
    return values

set_config('GRADLE_MAVEN_REPOSITORIES', gradle_maven_repositories)