Esempio n. 1
0
def generate(params):
    # prepare data
    proj_path = params["proj_path"]
    target_name = params["target_name"]

    target_config = config.run(proj_path, target_name, params)
    build_types = target_config["build_types"]

    version = util.get_version(params, config)
    source_files = []

    dist_folder = os.path.join(proj_path, const.DIR_NAME_DIST, target_name)

    # add folders
    for build_type in build_types:
        source_files.append(
            {
                "path": os.path.join(dist_folder, build_type),
                "arcname": build_type,
            }
        )

    # generate
    pack.generate(
        proj_path=proj_path,
        target_name=target_name,
        version=version,
        source_files=source_files,
    )
Esempio n. 2
0
def run(params):
    proj_path = params["proj_path"]
    target_name = params["target_name"]
    target_config = config.run(proj_path, target_name, params)

    archs = target_config["archs"]
    build_types = target_config["build_types"]

    if archs and len(archs) > 0:
        for arch in archs:
            for build_type in build_types:
                log.info(
                    "Building for: {0}/{1}...".format(arch["conan_arch"], build_type)
                )

                # conan install
                build_dir = os.path.join(
                    proj_path,
                    const.DIR_NAME_BUILD,
                    target_name,
                    build_type,
                    arch["conan_arch"],
                    const.DIR_NAME_BUILD_CONAN,
                )

                file.remove_dir(build_dir)
                file.create_dir(build_dir)

                run_args = [
                    "conan",
                    "install",
                    os.path.join(
                        proj_path,
                        const.DIR_NAME_FILES,
                        const.DIR_NAME_FILES_TARGETS,
                        target_name,
                        const.DIR_NAME_FILES_TARGET_CONAN,
                        const.DIR_NAME_FILES_TARGET_CONAN_RECIPE,
                        const.FILE_NAME_FILES_TARGET_CONAN_RECIPE_CONANFILE_PY,
                    ),
                    "--profile",
                    arch["conan_profile"],
                    "-s",
                    "arch={0}".format(arch["conan_arch"]),
                    "-s",
                    "os.api_level={0}".format(arch["api_level"]),
                    "-s",
                    "build_type={0}".format(build_type),
                    "--build=missing",
                    "--update",
                ]

                runner.run(run_args, build_dir)
    else:
        log.error('Arch list for "{0}" is invalid or empty'.format(target_name))
Esempio n. 3
0
def run(params):
    proj_path = params["proj_path"]
    target_name = params["target_name"]
    target_config = config.run(proj_path, target_name, params)

    archs = target_config["archs"]
    build_types = target_config["build_types"]
    param_dry_run = util.list_has_key(params["args"], "--dry-run")

    if param_dry_run:
        log.info("Running in dry mode...")

    if archs and len(archs) > 0:
        for arch in archs:
            for build_type in build_types:
                log.info("Building for: {0}/{1}...".format(
                    arch["conan_arch"], build_type))

                # conan build
                build_dir = os.path.join(
                    proj_path,
                    const.DIR_NAME_BUILD,
                    target_name,
                    build_type,
                    arch["conan_arch"],
                    const.DIR_NAME_BUILD_TARGET,
                )

                clean_build_dir = True

                if param_dry_run and os.path.isdir(build_dir):
                    clean_build_dir = False

                if clean_build_dir:
                    file.remove_dir(build_dir)
                    file.create_dir(build_dir)

                run_args = [
                    "conan",
                    "build",
                    os.path.join(
                        proj_path,
                        const.DIR_NAME_FILES,
                        const.DIR_NAME_FILES_TARGETS,
                        target_name,
                        const.DIR_NAME_FILES_TARGET_CONAN,
                        const.DIR_NAME_FILES_TARGET_CONAN_RECIPE,
                        const.FILE_NAME_FILES_TARGET_CONAN_RECIPE_CONANFILE_PY,
                    ),
                    "--source-folder",
                    os.path.join(
                        proj_path,
                        const.DIR_NAME_FILES,
                        const.DIR_NAME_FILES_TARGETS,
                        target_name,
                        const.DIR_NAME_FILES_TARGET_CMAKE,
                    ),
                    "--build-folder",
                    os.path.join(
                        proj_path,
                        const.DIR_NAME_BUILD,
                        target_name,
                        build_type,
                        arch["conan_arch"],
                        const.DIR_NAME_BUILD_TARGET,
                    ),
                    "--install-folder",
                    os.path.join(
                        proj_path,
                        const.DIR_NAME_BUILD,
                        target_name,
                        build_type,
                        arch["conan_arch"],
                        const.DIR_NAME_BUILD_CONAN,
                    ),
                ]

                runner.run(run_args, build_dir)
    else:
        log.error(
            'Arch list for "{0}" is invalid or empty'.format(target_name))
Esempio n. 4
0
def run(params):
    proj_path = params["proj_path"]
    target_name = params["target_name"]
    target_config = config.run(proj_path, target_name, params)

    archs = target_config["archs"]
    build_types = target_config["build_types"]
    module_name = "library"

    log.info("Creating AAR library...")

    if archs and len(archs) > 0:
        if build_types and len(build_types) > 0:
            for build_type in build_types:
                log.info("Creating AAR library for: {0}...".format(build_type))

                build_dir = os.path.join(proj_path, const.DIR_NAME_BUILD,
                                         target_name, build_type)

                android_library_build_dir = os.path.join(build_dir, "aar")

                file.remove_dir(android_library_build_dir)
                file.create_dir(android_library_build_dir)

                android_project_dir = os.path.join(
                    proj_path,
                    const.DIR_NAME_FILES,
                    const.DIR_NAME_FILES_TARGETS,
                    target_name,
                    const.DIR_NAME_FILES_TARGET_SUPPORT,
                    "android-aar-project",
                )

                file.copy_dir(android_project_dir,
                              android_library_build_dir,
                              symlinks=True)

                # copy djinni support lib files
                djinni_support_lib_dir = os.path.join(proj_path,
                                                      const.DIR_NAME_FILES,
                                                      "djinni", "support-lib")

                file.copy_all_inside(
                    os.path.join(djinni_support_lib_dir, "java"),
                    os.path.join(android_library_build_dir, module_name, "src",
                                 "main", "java"),
                )

                # copy all modules djinni files
                modules_dir = os.path.join(proj_path, const.DIR_NAME_FILES,
                                           "djinni")

                modules = file.find_dirs_simple(modules_dir, "*")

                for module in modules:
                    module_dir_name = os.path.basename(module)

                    if module_dir_name == "support-lib":
                        continue

                    module_dir = os.path.join(modules_dir, module_dir_name,
                                              "generated-src", "java")

                    if file.dir_exists(module_dir):
                        file.copy_all_inside(
                            module_dir,
                            os.path.join(
                                android_library_build_dir,
                                module_name,
                                "src",
                                "main",
                                "java",
                            ),
                        )

                # copy all modules implementation files
                modules_dir = os.path.join(proj_path, const.DIR_NAME_FILES,
                                           const.DIR_NAME_FILES_SRC)

                modules = file.find_dirs_simple(modules_dir, "*")

                for module in modules:
                    module_dir_name = os.path.basename(module)

                    module_dir = os.path.join(modules_dir, module_dir_name,
                                              "java")

                    if file.dir_exists(module_dir):
                        file.copy_all_inside(
                            module_dir,
                            os.path.join(
                                android_library_build_dir,
                                module_name,
                                "src",
                                "main",
                                "java",
                            ),
                        )

                # copy all native libraries
                for arch in archs:
                    compiled_arch_dir = os.path.join(
                        build_dir,
                        arch["conan_arch"],
                        const.DIR_NAME_BUILD_TARGET,
                        "lib",
                    )

                    target_arch_dir = os.path.join(
                        android_library_build_dir,
                        "library",
                        "src",
                        "main",
                        "jniLibs",
                        arch["arch"],
                    )

                    file.copy_all_inside(compiled_arch_dir, target_arch_dir)

                # build aar
                android_module_dir = os.path.join(android_library_build_dir,
                                                  module_name)

                run_args = ["../gradlew", "bundle{0}Aar".format(build_type)]

                runner.run(run_args, android_module_dir)

                # copy files
                arr_dir = os.path.join(android_library_build_dir, module_name,
                                       "build", "outputs", "aar")

                dist_dir = os.path.join(proj_path, const.DIR_NAME_DIST,
                                        target_name, build_type)

                file.remove_dir(dist_dir)

                file.copy_all_inside(arr_dir, dist_dir)
        else:
            log.info('Build type list for "{0}" is invalid or empty'.format(
                target_name))
    else:
        log.info('Arch list for "{0}" is invalid or empty'.format(target_name))