Ejemplo n.º 1
0
    def __init__(self,
                 verbose,
                 app_android_root,
                 no_res,
                 proj_obj,
                 use_studio=False):
        self._verbose = verbose

        self.app_android_root = app_android_root
        self._no_res = no_res
        self._project = proj_obj
        self.use_studio = use_studio

        # check environment variable
        if self.use_studio:
            self.ant_root = None
            self.sign_prop_file = os.path.join(self.app_android_root, 'app',
                                               "gradle.properties")
        else:
            self.ant_root = cocos.check_environment_variable('ANT_ROOT')
            self.sign_prop_file = os.path.join(self.app_android_root,
                                               "ant.properties")
        self.sdk_root = cocos.check_environment_variable('ANDROID_SDK_ROOT')

        self._parse_cfg()
Ejemplo n.º 2
0
    def do_ndk_build(self, ndk_build_param, build_mode, compile_obj):
        cocos.Logging.info(
            cocos.MultiLanguage.get_string('COMPILE_INFO_NDK_MODE') %
            build_mode)
        ndk_root = cocos.check_environment_variable('NDK_ROOT')

        toolchain_version = self.get_toolchain_version(ndk_root, compile_obj)

        app_android_root = self.app_android_root
        reload(sys)
        sys.setdefaultencoding('utf8')
        ndk_path = cocos.CMDRunner.convert_path_to_cmd(
            os.path.join(ndk_root, "ndk-build"))

        module_paths = []
        for cfg_path in self.ndk_module_paths:
            if cfg_path.find("${ENGINE_ROOT}") >= 0:
                cocos_root = cocos.check_environment_variable("COCOS_X_ROOT")
                module_paths.append(
                    cfg_path.replace("${ENGINE_ROOT}", cocos_root))
            elif cfg_path.find("${COCOS_FRAMEWORKS}") >= 0:
                cocos_frameworks = cocos.check_environment_variable(
                    "COCOS_FRAMEWORKS")
                module_paths.append(
                    cfg_path.replace("${COCOS_FRAMEWORKS}", cocos_frameworks))
            else:
                module_paths.append(os.path.join(app_android_root, cfg_path))

        # delete template static and dynamic files
        obj_local_dir = os.path.join(self.app_android_root, "obj", "local")
        if os.path.isdir(obj_local_dir):
            for abi_dir in os.listdir(obj_local_dir):
                static_file_path = os.path.join(self.app_android_root, "obj",
                                                "local", abi_dir)
                if os.path.isdir(static_file_path):
                    self.remove_c_libs(static_file_path)

        # windows should use ";" to seperate module paths
        if cocos.os_is_win32():
            ndk_module_path = ';'.join(module_paths)
        else:
            ndk_module_path = ':'.join(module_paths)

        ndk_module_path = 'NDK_MODULE_PATH=' + ndk_module_path

        if ndk_build_param is None:
            ndk_build_cmd = '%s -C %s %s' % (ndk_path, app_android_root,
                                             ndk_module_path)
        else:
            ndk_build_cmd = '%s -C %s %s %s' % (ndk_path, app_android_root,
                                                ' '.join(ndk_build_param),
                                                ndk_module_path)

        ndk_build_cmd = '%s NDK_TOOLCHAIN_VERSION=%s' % (ndk_build_cmd,
                                                         toolchain_version)

        if build_mode == 'debug':
            ndk_build_cmd = '%s NDK_DEBUG=1' % ndk_build_cmd

        self._run_cmd(ndk_build_cmd)
Ejemplo n.º 3
0
    def do_ndk_build(self, ndk_build_param, build_mode, compile_obj):
        cocos.Logging.info(MultiLanguage.get_string('COMPILE_INFO_NDK_MODE', build_mode))
        ndk_root = cocos.check_environment_variable('NDK_ROOT')

        toolchain_version = self.get_toolchain_version(ndk_root, compile_obj)

        if self.use_studio:
            ndk_work_dir = os.path.join(self.app_android_root, 'app')
        else:
            ndk_work_dir = self.app_android_root
        reload(sys)
        sys.setdefaultencoding('utf8')
        ndk_path = cocos.CMDRunner.convert_path_to_cmd(os.path.join(ndk_root, "ndk-build"))

        module_paths = []
        for cfg_path in self.ndk_module_paths:
            if cfg_path.find("${ENGINE_ROOT}") >= 0:
                cocos_root = cocos.check_environment_variable("COCOS_X_ROOT")
                module_paths.append(cfg_path.replace("${ENGINE_ROOT}", cocos_root))
            elif cfg_path.find("${COCOS_FRAMEWORKS}") >= 0:
                cocos_frameworks = cocos.check_environment_variable("COCOS_FRAMEWORKS")
                module_paths.append(cfg_path.replace("${COCOS_FRAMEWORKS}", cocos_frameworks))
            else:
                module_paths.append(os.path.join(self.app_android_root, cfg_path))

        # delete template static and dynamic files
        obj_local_dir = os.path.join(ndk_work_dir, "obj", "local")
        if os.path.isdir(obj_local_dir):
            for abi_dir in os.listdir(obj_local_dir):
                static_file_path = os.path.join(ndk_work_dir, "obj", "local", abi_dir)
                if os.path.isdir(static_file_path):
                    self.remove_c_libs(static_file_path)
           	    
        # windows should use ";" to seperate module paths
        if cocos.os_is_win32():
            ndk_module_path = ';'.join(module_paths)
        else:
            ndk_module_path = ':'.join(module_paths)
        
        #ndk_module_path= 'NDK_MODULE_PATH=' + ndk_module_path
        ndk_module_path = ''

        if ndk_build_param is None:
            ndk_build_cmd = '%s -C %s %s' % (ndk_path, ndk_work_dir, ndk_module_path)
        else:
            ndk_build_cmd = '%s -C %s %s %s' % (ndk_path, ndk_work_dir, ' '.join(ndk_build_param), ndk_module_path)

        #ndk_build_cmd = '%s NDK_TOOLCHAIN_VERSION=%s' % (ndk_build_cmd, toolchain_version)
        #ndk_build_cmd = "ndk-build -j8 -C . NDK_DEBUG=0"

        print ndk_build_cmd
        print 'xujian'
        print ndk_build_param
        print ndk_work_dir
        print 'xujian'
        if build_mode == 'debug':
            ndk_build_cmd = '%s NDK_DEBUG=1' % ndk_build_cmd

        self._run_cmd(ndk_build_cmd)
Ejemplo n.º 4
0
    def build_android(self):
        if not self._platforms.is_android_active():
            return

        project_dir = self._project.get_project_dir()
        build_mode = self._mode
        output_dir = self._output_dir
        if self._project._is_script_project():
            if self._project._is_lua_project():
                cocos_root = os.path.join(project_dir, 'frameworks',
                                          'cocos2d-x')
            else:
                cocos_root = os.path.join(
                    project_dir, 'frameworks',
                    '%s-bindings' % self._project.get_language(), 'cocos2d-x')
        else:
            cocos_root = os.path.join(project_dir, 'cocos2d')

        # check environment variable
        ant_root = cocos.check_environment_variable('ANT_ROOT')
        sdk_root = cocos.check_environment_variable('ANDROID_SDK_ROOT')
        project_android_dir = self._platforms.project_path()

        from build_android import AndroidBuilder
        builder = AndroidBuilder(self._verbose, cocos_root,
                                 project_android_dir, self._no_res,
                                 self._project)

        args_ndk_copy = self._custom_step_args.copy()
        target_platform = self._platforms.get_current_platform()

        if not self._project._is_script_project(
        ) or self._project._is_native_support():
            if self._ndk_mode != "none":
                # build native code
                cocos.Logging.info("building native")
                ndk_build_param = "-j%s" % self._jobs
                self._project.invoke_custom_step_script(
                    cocos_project.Project.CUSTOM_STEP_PRE_NDK_BUILD,
                    target_platform, args_ndk_copy)
                builder.do_ndk_build(ndk_build_param, self._ndk_mode)
                self._project.invoke_custom_step_script(
                    cocos_project.Project.CUSTOM_STEP_POST_NDK_BUILD,
                    target_platform, args_ndk_copy)

        # build apk
        cocos.Logging.info("building apk")
        self.apk_path = builder.do_build_apk(sdk_root, ant_root, self._ap,
                                             build_mode, output_dir,
                                             self._custom_step_args)

        cocos.Logging.info("build succeeded.")
    def build_android(self):
        if not self._platforms.is_android_active():
            return

        project_dir = self._project.get_project_dir()
        build_mode = self._mode
        if self._project._is_script_project():
            if build_mode == 'debug':
                output_dir = os.path.join(
                    project_dir, CCPluginCompile.OUTPUT_DIR_SCRIPT_DEBUG,
                    'android')
            else:
                output_dir = os.path.join(
                    project_dir, CCPluginCompile.OUTPUT_DIR_SCRIPT_RELEASE,
                    'android')

            if self._project._is_lua_project():
                cocos_root = os.path.join(project_dir, 'frameworks',
                                          'cocos2d-x')
            else:
                cocos_root = os.path.join(
                    project_dir, 'frameworks',
                    '%s-bindings' % self._project.get_language(), 'cocos2d-x')

        else:
            cocos_root = os.path.join(project_dir, 'cocos2d')
            output_dir = os.path.join(project_dir,
                                      CCPluginCompile.OUTPUT_DIR_NATIVE,
                                      build_mode, 'android')

        # check environment variable
        ant_root = cocos.check_environment_variable('ANT_ROOT')
        ndk_root = cocos.check_environment_variable('NDK_ROOT')
        sdk_root = cocos.check_environment_variable('ANDROID_SDK_ROOT')
        project_android_dir = self._platforms.project_path()

        from build_android import AndroidBuilder
        builder = AndroidBuilder(self._verbose, cocos_root,
                                 project_android_dir, self._no_res)

        # build native code
        cocos.Logging.info("building native")
        ndk_build_param = "-j%s" % self._jobs
        builder.do_ndk_build(ndk_root, ndk_build_param, build_mode)

        # build apk
        cocos.Logging.info("building apk")
        self.apk_path = builder.do_build_apk(sdk_root, ant_root, self._ap,
                                             build_mode, output_dir)

        cocos.Logging.info("build succeeded.")
Ejemplo n.º 6
0
    def do_ndk_build(self, ndk_build_param, build_mode):
        cocos.Logging.info('NDK build mode: %s' % build_mode)
        ndk_root = cocos.check_environment_variable('NDK_ROOT')
        select_toolchain_version(ndk_root)

        app_android_root = self.app_android_root
        cocos_root = self.cocos_root
        ndk_path = os.path.join(ndk_root, "ndk-build")
        module_paths = [
            os.path.join(app_android_root, path)
            for path in self.ndk_module_paths
        ]

        # windows should use ";" to seperate module paths
        if cocos.os_is_win32():
            ndk_module_path = ';'.join(module_paths)
        else:
            ndk_module_path = ':'.join(module_paths)

        ndk_module_path = 'NDK_MODULE_PATH=' + ndk_module_path

        if ndk_build_param == None:
            ndk_build_cmd = '%s -C %s %s' % (ndk_path, app_android_root,
                                             ndk_module_path)
        else:
            ndk_build_cmd = '%s -C %s %s %s' % (
                ndk_path, app_android_root, ''.join(
                    str(e) for e in ndk_build_param), ndk_module_path)

        if build_mode == 'debug':
            ndk_build_cmd = '%s NDK_DEBUG=1' % ndk_build_cmd

        self._run_cmd(ndk_build_cmd)
Ejemplo n.º 7
0
    def deploy_android(self, dependencies):
        if not self._platforms.is_android_active():
            return

        cocos.Logging.info(
            MultiLanguage.get_string('DEPLOY_INFO_INSTALLING_APK'))

        compile_dep = dependencies['compile']
        if compile_dep._bundle:
            return
        self.package = compile_dep.android_package
        self.activity = compile_dep.android_activity
        apk_path = compile_dep.apk_path
        sdk_root = cocos.check_environment_variable('ANDROID_SDK_ROOT')
        adb_path = cocos.CMDRunner.convert_path_to_cmd(
            os.path.join(sdk_root, 'platform-tools', 'adb'))

        if not self._no_uninstall:
            # do uninstall only when that app is installed
            if cocos.app_is_installed(adb_path, self.package):
                adb_uninstall = "%s uninstall %s" % (adb_path, self.package)
                self._run_cmd(adb_uninstall)

        adb_install = "%s install -r \"%s\"" % (adb_path, apk_path)
        self._run_cmd(adb_install)
Ejemplo n.º 8
0
    def deploy_tizen(self, dependencies):
        if not self._platforms.is_tizen_active():
            return

        tizen_proj_path = self._platforms.project_path()
        from xml.dom import minidom
        doc = minidom.parse(os.path.join(tizen_proj_path, "tizen-manifest.xml"))
        self.tizen_packageid = doc.getElementsByTagName("manifest")[0].getAttribute("package")

        # uninstall old app
        tizen_studio_path = cocos.check_environment_variable("TIZEN_STUDIO_HOME")
        tizen_cmd_path = cocos.CMDRunner.convert_path_to_cmd(os.path.join(tizen_studio_path, "tools", "ide", "bin", "tizen"))

        if not self._no_uninstall:
            try:
                uninstall_cmd = "%s uninstall -p %s" % (tizen_cmd_path, self.tizen_packageid)
                self._run_cmd(uninstall_cmd)
            except Exception:
                pass

        # install app
        compile_dep = dependencies["compile"]
        pkg_path = compile_dep.tizen_pkg_path
        pkg_dir, pkg_file_name = os.path.split(pkg_path)
        install_cmd = "%s install -- \"%s\" -n \"%s\"" % (tizen_cmd_path, pkg_dir, pkg_file_name)
        self._run_cmd(install_cmd)
Ejemplo n.º 9
0
    def deploy_android(self, dependencies):
        if not self._platforms.is_android_active():
            return

        cocos.Logging.info(
            MultiLanguage.get_string('DEPLOY_INFO_INSTALLING_APK'))

        compile_dep = dependencies['compile']
        self.package = compile_dep.android_package
        self.activity = compile_dep.android_activity
        apk_path = compile_dep.apk_path
        sdk_root = cocos.check_environment_variable('ANDROID_SDK_ROOT')

        if self._instant_game:
            ia_path = cocos.CMDRunner.convert_path_to_cmd(
                os.path.join(sdk_root, 'extras', 'google', 'instantapps',
                             'tools', 'ia.jar'))
            if self._launch_url:
                adb_install = "java -jar %s run -u %s %s" % (
                    ia_path, self._launch_url, apk_path)
            else:
                adb_install = "java -jar %s run %s" % (ia_path, apk_path)
        else:
            adb_path = cocos.CMDRunner.convert_path_to_cmd(
                os.path.join(sdk_root, 'platform-tools', 'adb'))
            # do uninstall only when that app is installed
            if cocos.app_is_installed(adb_path, self.package):
                adb_uninstall = "%s uninstall %s" % (adb_path, self.package)
                self._run_cmd(adb_uninstall)
            adb_install = "%s install -r \"%s\"" % (adb_path, apk_path)
        self._run_cmd(adb_install)
Ejemplo n.º 10
0
    def deploy_tizen(self, dependencies):
        if not self._platforms.is_tizen_active():
            return

        tizen_proj_path = self._platforms.project_path()
        from xml.dom import minidom
        doc = minidom.parse(os.path.join(tizen_proj_path,
                                         "tizen-manifest.xml"))
        self.tizen_packageid = doc.getElementsByTagName(
            "manifest")[0].getAttribute("package")

        # uninstall old app
        tizen_studio_path = cocos.check_environment_variable(
            "TIZEN_STUDIO_HOME")
        tizen_cmd_path = cocos.CMDRunner.convert_path_to_cmd(
            os.path.join(tizen_studio_path, "tools", "ide", "bin", "tizen"))

        if not self._no_uninstall:
            try:
                uninstall_cmd = "%s uninstall -p %s" % (tizen_cmd_path,
                                                        self.tizen_packageid)
                self._run_cmd(uninstall_cmd)
            except Exception:
                pass

        # install app
        compile_dep = dependencies["compile"]
        pkg_path = compile_dep.tizen_pkg_path
        pkg_dir, pkg_file_name = os.path.split(pkg_path)
        install_cmd = "%s install -- \"%s\" -n \"%s\"" % (
            tizen_cmd_path, pkg_dir, pkg_file_name)
        self._run_cmd(install_cmd)
Ejemplo n.º 11
0
    def deploy_android(self, dependencies):
        if not self._platforms.is_android_active():
            return

        project_dir = self._project.get_project_dir()
        android_project_dir = self._platforms.project_path()

        cocos.Logging.info("installing on device")
        self.package = self._xml_attr(android_project_dir, "AndroidManifest.xml", "manifest", "package")
        activity_name = self._xml_attr(android_project_dir, "AndroidManifest.xml", "activity", "android:name")
        if activity_name.startswith("."):
            self.activity = self.package + activity_name
        else:
            self.activity = activity_name

        compile_dep = dependencies["compile"]
        apk_path = compile_dep.apk_path
        sdk_root = cocos.check_environment_variable("ANDROID_SDK_ROOT")
        adb_path = cocos.CMDRunner.convert_path_to_cmd(os.path.join(sdk_root, "platform-tools", "adb"))

        # TODO detect if the application is installed before running this
        adb_uninstall = "%s uninstall %s" % (adb_path, self.package)
        self._run_cmd(adb_uninstall)
        adb_install = '%s install "%s"' % (adb_path, apk_path)
        self._run_cmd(adb_install)
Ejemplo n.º 12
0
    def do_ndk_build(self, ndk_build_param, mode, build_type, compile_obj):
        cocos.Logging.info(MultiLanguage.get_string('COMPILE_INFO_NDK_BUILD_TYPE', build_type))
        ndk_root = cocos.check_environment_variable('NDK_ROOT')

        toolchain_version = self.get_toolchain_version(ndk_root, compile_obj)

        ndk_work_dir = os.path.join(self.app_android_root, 'app')
        reload(sys)
        sys.setdefaultencoding('utf8')
        ndk_path = cocos.CMDRunner.convert_path_to_cmd(os.path.join(ndk_root, "ndk-build"))

        # delete template static and dynamic files
        obj_local_dir = os.path.join(ndk_work_dir, "obj", "local")
        if os.path.isdir(obj_local_dir):
            for abi_dir in os.listdir(obj_local_dir):
                static_file_path = os.path.join(ndk_work_dir, "obj", "local", abi_dir)
                if os.path.isdir(static_file_path):
                    self.remove_c_libs(static_file_path)

        if ndk_build_param is None:
            ndk_build_cmd = '%s -C %s' % (ndk_path, ndk_work_dir)
        else:
            ndk_build_cmd = '%s -C %s %s' % (ndk_path, ndk_work_dir, ' '.join(ndk_build_param))

        ndk_build_cmd = '%s NDK_TOOLCHAIN_VERSION=%s' % (ndk_build_cmd, toolchain_version)

        if mode == 'debug':
            ndk_build_cmd = '%s NDK_DEBUG=1' % ndk_build_cmd

        self._run_cmd(ndk_build_cmd)
Ejemplo n.º 13
0
    def deploy_android(self, dependencies):
        if not self._platforms.is_android_active():
            return

        project_dir = self._project.get_project_dir()
        android_project_dir = self._platforms.project_path()

        cocos.Logging.info(
            cocos.MultiLanguage.get_string('DEPLOY_INFO_INSTALLING_APK'))
        self.package = self._xml_attr(android_project_dir,
                                      'AndroidManifest.xml', 'manifest',
                                      'package')
        activity_name = self._xml_attr(android_project_dir,
                                       'AndroidManifest.xml', 'activity',
                                       'android:name')
        if activity_name.startswith('.'):
            self.activity = self.package + activity_name
        else:
            self.activity = activity_name

        compile_dep = dependencies['compile']
        apk_path = compile_dep.apk_path
        sdk_root = cocos.check_environment_variable('ANDROID_SDK_ROOT')
        adb_path = cocos.CMDRunner.convert_path_to_cmd(
            os.path.join(sdk_root, 'platform-tools', 'adb'))

        #TODO detect if the application is installed before running this
        adb_uninstall = "%s uninstall %s" % (adb_path, self.package)
        self._run_cmd(adb_uninstall)
        adb_install = "%s install \"%s\"" % (adb_path, apk_path)
        self._run_cmd(adb_install)
Ejemplo n.º 14
0
    def __init__(self,
                 verbose,
                 app_android_root,
                 no_res,
                 proj_obj,
                 mode,
                 build_type,
                 app_abi,
                 gradle_support_ndk=False):
        self._verbose = verbose

        self.app_android_root = app_android_root
        self._no_res = no_res
        self._project = proj_obj
        self.gradle_support_ndk = gradle_support_ndk
        self.app_abi = app_abi
        self.mode = mode
        self.build_type = build_type

        # check environment variable
        self.sdk_root = cocos.check_environment_variable('ANDROID_SDK_ROOT')
        self.ant_root = None
        self.sign_prop_file = os.path.join(self.app_android_root, 'app',
                                           "gradle.properties")

        self._parse_cfg()
Ejemplo n.º 15
0
    def deploy_android(self, dependencies):
        if not self._platforms.is_android_active():
            return

        project_dir = self._project.get_project_dir()
        android_project_dir = self._platforms.project_path()

        cocos.Logging.info(cocos.MultiLanguage.get_string('DEPLOY_INFO_INSTALLING_APK'))
        self.package = self._xml_attr(android_project_dir, 'AndroidManifest.xml', 'manifest', 'package')
        activity_name = self._xml_attr(android_project_dir, 'AndroidManifest.xml', 'activity', 'android:name')
        if activity_name.startswith('.'):
            self.activity = self.package + activity_name
        else:
            self.activity = activity_name

        compile_dep = dependencies['compile']
        apk_path = compile_dep.apk_path
        sdk_root = cocos.check_environment_variable('ANDROID_SDK_ROOT')
        adb_path = cocos.CMDRunner.convert_path_to_cmd(os.path.join(sdk_root, 'platform-tools', 'adb'))

        #TODO detect if the application is installed before running this
        adb_uninstall = "%s uninstall %s" % (adb_path, self.package)
        self._run_cmd(adb_uninstall)
        adb_install = "%s install \"%s\"" % (adb_path, apk_path)
        self._run_cmd(adb_install)
Ejemplo n.º 16
0
    def do_ndk_build(self, ndk_build_param, build_mode):
        cocos.Logging.info('NDK build mode: %s' % build_mode)
        ndk_root = cocos.check_environment_variable('NDK_ROOT')
        select_toolchain_version(ndk_root)

        app_android_root = self.app_android_root
        cocos_root = self.cocos_root
        ndk_path = os.path.join(ndk_root, "ndk-build")
        module_paths = [os.path.join(app_android_root, path) for path in self.ndk_module_paths]

        # windows should use ";" to seperate module paths
        if cocos.os_is_win32():
            ndk_module_path = ';'.join(module_paths)
        else:
            ndk_module_path = ':'.join(module_paths)
        
        ndk_module_path= 'NDK_MODULE_PATH=' + ndk_module_path

        if ndk_build_param == None:
            ndk_build_cmd = '%s -C %s %s' % (ndk_path, app_android_root, ndk_module_path)
        else:
            ndk_build_cmd = '%s -C %s %s %s' % (ndk_path, app_android_root, ''.join(str(e) for e in ndk_build_param), ndk_module_path)

        if build_mode == 'debug':
            ndk_build_cmd = '%s NDK_DEBUG=1' % ndk_build_cmd

        self._run_cmd(ndk_build_cmd)
Ejemplo n.º 17
0
    def __init__(self, verbose, app_android_root, no_res, proj_obj, use_studio=False):
        self._verbose = verbose

        self.app_android_root = app_android_root
        self._no_res = no_res
        self._project = proj_obj
        self.use_studio = use_studio

        # check environment variable
        if self.use_studio:
            self.ant_root = None
            self.sign_prop_file = os.path.join(self.app_android_root, 'app', "gradle.properties")
        else:
            self.ant_root = cocos.check_environment_variable('ANT_ROOT')
            self.sign_prop_file = os.path.join(self.app_android_root, "ant.properties")
        self.sdk_root = cocos.check_environment_variable('ANDROID_SDK_ROOT')

        self._parse_cfg()
Ejemplo n.º 18
0
    def do_ndk_build(self, ndk_build_param, build_mode, compile_obj):
        cocos.Logging.info(
            MultiLanguage.get_string('COMPILE_INFO_NDK_MODE', build_mode))
        ndk_root = cocos.check_environment_variable('NDK_ROOT')

        toolchain_version = self.get_toolchain_version(ndk_root, compile_obj)

        if self.use_studio:
            ndk_work_dir = os.path.join(self.app_android_root, 'app')
        else:
            ndk_work_dir = self.app_android_root
        reload(sys)
        sys.setdefaultencoding('utf8')
        ndk_path = cocos.CMDRunner.convert_path_to_cmd(
            os.path.join(ndk_root, "ndk-build"))

        module_paths = []
        for cfg_path in self.ndk_module_paths:
            the_path = cocos.replace_env_variable(cfg_path)
            if not os.path.isabs(the_path):
                the_path = os.path.normpath(
                    os.path.join(self.app_android_root, the_path))

            module_paths.append(the_path)

        # delete template static and dynamic files
        obj_local_dir = os.path.join(ndk_work_dir, "obj", "local")
        if os.path.isdir(obj_local_dir):
            for abi_dir in os.listdir(obj_local_dir):
                static_file_path = os.path.join(ndk_work_dir, "obj", "local",
                                                abi_dir)
                if os.path.isdir(static_file_path):
                    self.remove_c_libs(static_file_path)

        # windows should use ";" to seperate module paths
        if cocos.os_is_win32():
            ndk_module_path = ';'.join(module_paths)
        else:
            ndk_module_path = ':'.join(module_paths)

        ndk_module_path = 'NDK_MODULE_PATH=' + ndk_module_path

        if ndk_build_param is None:
            ndk_build_cmd = '%s -C %s %s' % (ndk_path, ndk_work_dir,
                                             ndk_module_path)
        else:
            ndk_build_cmd = '%s -C %s %s %s' % (ndk_path, ndk_work_dir,
                                                ' '.join(ndk_build_param),
                                                ndk_module_path)

        ndk_build_cmd = '%s NDK_TOOLCHAIN_VERSION=%s' % (ndk_build_cmd,
                                                         toolchain_version)

        if build_mode == 'debug':
            ndk_build_cmd = '%s NDK_DEBUG=1' % ndk_build_cmd

        self._run_cmd(ndk_build_cmd)
Ejemplo n.º 19
0
    def run_android_device(self, dependencies):
        if not self._platforms.is_android_active():
            return

        sdk_root = cocos.check_environment_variable('ANDROID_SDK_ROOT')
        adb_path = os.path.join(sdk_root, 'platform-tools', 'adb')
        deploy_dep = dependencies['deploy']
        startapp = "%s shell am start -n \"%s/%s\"" % (adb_path, deploy_dep.package, deploy_dep.activity)
        self._run_cmd(startapp)
        pass
Ejemplo n.º 20
0
    def run_android_device(self, dependencies):
        if not self._platforms.is_android_active():
            return

        sdk_root = cocos.check_environment_variable("ANDROID_SDK_ROOT")
        adb_path = cocos.CMDRunner.convert_path_to_cmd(os.path.join(sdk_root, "platform-tools", "adb"))
        deploy_dep = dependencies["deploy"]
        startapp = '%s shell am start -n "%s/%s"' % (adb_path, deploy_dep.package, deploy_dep.activity)
        self._run_cmd(startapp)
        pass
Ejemplo n.º 21
0
    def run_tizen(self, dependencies):
        if not self._platforms.is_tizen_active():
            return

        deploy_dep = dependencies['deploy']
        tizen_packageid = deploy_dep.tizen_packageid
        tizen_studio_path = cocos.check_environment_variable("TIZEN_STUDIO_HOME")
        tizen_cmd_path = cocos.CMDRunner.convert_path_to_cmd(os.path.join(tizen_studio_path, "tools", "ide", "bin", "tizen"))

        startapp = "%s run -p %s" % (tizen_cmd_path, tizen_packageid)
        self._run_cmd(startapp)
Ejemplo n.º 22
0
    def run_tizen(self, dependencies):
        if not self._platforms.is_tizen_active():
            return

        deploy_dep = dependencies['deploy']
        tizen_packageid = deploy_dep.tizen_packageid
        tizen_studio_path = cocos.check_environment_variable("TIZEN_STUDIO_HOME")
        tizen_cmd_path = cocos.CMDRunner.convert_path_to_cmd(os.path.join(tizen_studio_path, "tools", "ide", "bin", "tizen"))

        startapp = "%s run -p %s" % (tizen_cmd_path, tizen_packageid)
        self._run_cmd(startapp)
Ejemplo n.º 23
0
    def build_android(self):
        if not self._platforms.is_android_active():
            return

        project_dir = self._project.get_project_dir()
        build_mode = self._mode
        output_dir = self._output_dir
        if self._project._is_script_project():
            if self._project._is_lua_project():
                cocos_root = os.path.join(project_dir, 'frameworks' ,'cocos2d-x')
            else:
                cocos_root = os.path.join(project_dir, 'frameworks' ,'%s-bindings' % self._project.get_language(), 'cocos2d-x')
        else:
            cocos_root = os.path.join(project_dir, 'cocos2d')

        # check environment variable
        ant_root = cocos.check_environment_variable('ANT_ROOT')
        sdk_root = cocos.check_environment_variable('ANDROID_SDK_ROOT')
        project_android_dir = self._platforms.project_path()

        from build_android import AndroidBuilder
        builder = AndroidBuilder(self._verbose, cocos_root, project_android_dir, self._no_res, self._project)

        args_ndk_copy = self._custom_step_args.copy()
        target_platform = self._platforms.get_current_platform()

        if not self._project._is_script_project() or self._project._is_native_support():
            if self._ndk_mode != "none":
                # build native code
                cocos.Logging.info("building native")
                ndk_build_param = "-j%s" % self._jobs
                self._project.invoke_custom_step_script(cocos_project.Project.CUSTOM_STEP_PRE_NDK_BUILD, target_platform, args_ndk_copy)
                builder.do_ndk_build(ndk_build_param, self._ndk_mode)
                self._project.invoke_custom_step_script(cocos_project.Project.CUSTOM_STEP_POST_NDK_BUILD, target_platform, args_ndk_copy)

        # build apk
        cocos.Logging.info("building apk")
        self.apk_path = builder.do_build_apk(sdk_root, ant_root, self._ap, build_mode, output_dir, self._custom_step_args, self)

        cocos.Logging.info("build succeeded.")
Ejemplo n.º 24
0
    def build_android(self):
        if not self._platforms.is_android_active():
            return

        project_dir = self._project.get_project_dir()
        build_mode = self._mode
        if self._project._is_script_project():
            if build_mode == 'debug':
                output_dir = os.path.join(project_dir, CCPluginCompile.OUTPUT_DIR_SCRIPT_DEBUG, 'android')
            else:
                output_dir = os.path.join(project_dir, CCPluginCompile.OUTPUT_DIR_SCRIPT_RELEASE, 'android')

            if self._project._is_lua_project():
                cocos_root = os.path.join(project_dir, 'frameworks' ,'cocos2d-x')
            else:
                cocos_root = os.path.join(project_dir, 'frameworks' ,'%s-bindings' % self._project.get_language(), 'cocos2d-x')

        else:
            cocos_root = os.path.join(project_dir, 'cocos2d')
            output_dir = os.path.join(project_dir, CCPluginCompile.OUTPUT_DIR_NATIVE, build_mode, 'android')

        # check environment variable
        ant_root = cocos.check_environment_variable('ANT_ROOT')
        ndk_root = cocos.check_environment_variable('NDK_ROOT')
        sdk_root = cocos.check_environment_variable('ANDROID_SDK_ROOT')
        project_android_dir = self._platforms.project_path()

        from build_android import AndroidBuilder
        builder = AndroidBuilder(self._verbose, cocos_root, project_android_dir, self._no_res)

        # build native code
        cocos.Logging.info("building native")
        ndk_build_param = "-j%s" % self._jobs
        builder.do_ndk_build(ndk_root, ndk_build_param, build_mode)

        # build apk
        cocos.Logging.info("building apk")
        self.apk_path = builder.do_build_apk(sdk_root, ant_root, self._ap, build_mode, output_dir) 

        cocos.Logging.info("build succeeded.")
Ejemplo n.º 25
0
 def _write_local_properties(self, folder_path):
     local_porps_path = os.path.join(folder_path, 'local.properties')
     sdk_dir = self.sdk_root
     ndk_dir = cocos.check_environment_variable('NDK_ROOT')
     if cocos.os_is_win32():
         # On Windows, the path should be like:
         # sdk.dir = C:\\path\\android-sdk
         sdk_dir = sdk_dir.replace('\\', '\\\\')
         ndk_dir = ndk_dir.replace('\\', '\\\\')
     lines = ['sdk.dir=%s\n' % sdk_dir, 'ndk.dir=%s\n' % ndk_dir]
     f = open(local_porps_path, 'w')
     f.writelines(lines)
     f.close()
Ejemplo n.º 26
0
    def __init__(self, verbose, app_android_root, no_res, proj_obj):
        self._verbose = verbose

        self.app_android_root = app_android_root
        self._no_res = no_res
        self._project = proj_obj

        # check environment variable
        self.sdk_root = cocos.check_environment_variable('ANDROID_SDK_ROOT')
        self.sign_prop_file = os.path.join(self.app_android_root,
                                           "gradle.properties")

        self._parse_cfg()
Ejemplo n.º 27
0
    def run_android_device(self, dependencies):
        deploy_dep = dependencies['deploy']
        if not self._platforms.is_android_active() or not hasattr(
                deploy_dep, 'package'):
            return

        sdk_root = cocos.check_environment_variable('ANDROID_SDK_ROOT')
        adb_path = cocos.CMDRunner.convert_path_to_cmd(
            os.path.join(sdk_root, 'platform-tools', 'adb'))
        startapp = "%s shell am start -n \"%s/%s\"" % (
            adb_path, deploy_dep.package, deploy_dep.activity)
        self._run_cmd(startapp)
        pass
 def _write_local_properties(self, folder_path):
     local_porps_path = os.path.join(folder_path, 'local.properties')
     sdk_dir = self.sdk_root
     ndk_dir = cocos.check_environment_variable('NDK_ROOT')
     if cocos.os_is_win32():
         # On Windows, the path should be like:
         # sdk.dir = C:\\path\\android-sdk
         sdk_dir = sdk_dir.replace('\\', '\\\\')
         ndk_dir = ndk_dir.replace('\\', '\\\\')
     lines = [
         'sdk.dir=%s\n' % sdk_dir,
         'ndk.dir=%s\n' % ndk_dir
     ]
     f = open(local_porps_path, 'w')
     f.writelines(lines)
     f.close()
Ejemplo n.º 29
0
    def deploy_android(self, dependencies):
        if not self._platforms.is_android_active():
            return

        cocos.Logging.info(MultiLanguage.get_string('DEPLOY_INFO_INSTALLING_APK'))

        compile_dep = dependencies['compile']
        self.package = compile_dep.android_package
        self.activity = compile_dep.android_activity
        apk_path = compile_dep.apk_path
        sdk_root = cocos.check_environment_variable('ANDROID_SDK_ROOT')
        adb_path = cocos.CMDRunner.convert_path_to_cmd(os.path.join(sdk_root, 'platform-tools', 'adb'))

        #TODO detect if the application is installed before running this
        adb_uninstall = "%s uninstall %s" % (adb_path, self.package)
        self._run_cmd(adb_uninstall)
        adb_install = "%s install \"%s\"" % (adb_path, apk_path)
        self._run_cmd(adb_install)
Ejemplo n.º 30
0
    def do_ndk_build(self, ndk_build_param, build_mode):
        cocos.Logging.info('NDK build mode: %s' % build_mode)
        ndk_root = cocos.check_environment_variable('NDK_ROOT')

        app_android_root = self.app_android_root
        cocos_root = self.cocos_root
        reload(sys)
        sys.setdefaultencoding('utf8')
        ndk_path = os.path.join(ndk_root, "ndk-build")
        module_paths = [
            os.path.join(app_android_root, path)
            for path in self.ndk_module_paths
        ]

        # delete template static and dynamic files
        obj_local_dir = os.path.join(self.app_android_root, "obj", "local")
        if os.path.isdir(obj_local_dir):
            for abi_dir in os.listdir(obj_local_dir):
                static_file_path = os.path.join(self.app_android_root, "obj",
                                                "local", abi_dir)
                if os.path.isdir(static_file_path):
                    self.remove_c_libs(static_file_path)

        # windows should use ";" to seperate module paths
        if cocos.os_is_win32():
            ndk_module_path = ';'.join(module_paths)
        else:
            ndk_module_path = ':'.join(module_paths)

        ndk_module_path = 'NDK_MODULE_PATH=' + ndk_module_path

        if ndk_build_param is None:
            ndk_build_cmd = '%s -C %s %s' % (ndk_path, app_android_root,
                                             ndk_module_path)
        else:
            ndk_build_cmd = '%s -C %s %s %s' % (ndk_path, app_android_root,
                                                ' '.join(ndk_build_param),
                                                ndk_module_path)

        if build_mode == 'debug':
            ndk_build_cmd = '%s NDK_DEBUG=1' % ndk_build_cmd

        self._run_cmd(ndk_build_cmd)
Ejemplo n.º 31
0
    def do_ndk_build(self, ndk_build_param, build_mode):
        cocos.Logging.info("NDK build mode: %s" % build_mode)
        ndk_root = cocos.check_environment_variable("NDK_ROOT")
        select_toolchain_version(ndk_root)

        app_android_root = self.app_android_root
        cocos_root = self.cocos_root
        reload(sys)
        sys.setdefaultencoding("utf8")
        ndk_path = os.path.join(ndk_root, "ndk-build")
        module_paths = [os.path.join(app_android_root, path) for path in self.ndk_module_paths]

        # delete template static and dynamic files
        obj_local_dir = os.path.join(self.app_android_root, "obj", "local")
        if os.path.isdir(obj_local_dir):
            for abi_dir in os.listdir(obj_local_dir):
                static_file_path = os.path.join(self.app_android_root, "obj", "local", abi_dir)
                if os.path.isdir(static_file_path):
                    self.remove_c_libs(static_file_path)

        # windows should use ";" to seperate module paths
        if cocos.os_is_win32():
            ndk_module_path = ";".join(module_paths)
        else:
            ndk_module_path = ":".join(module_paths)

        ndk_module_path = "NDK_MODULE_PATH=" + ndk_module_path

        if ndk_build_param == None:
            ndk_build_cmd = "%s -C %s %s" % (ndk_path, app_android_root, ndk_module_path)
        else:
            ndk_build_cmd = "%s -C %s %s %s" % (
                ndk_path,
                app_android_root,
                "".join(str(e) for e in ndk_build_param),
                ndk_module_path,
            )

        if build_mode == "debug":
            ndk_build_cmd = "%s NDK_DEBUG=1" % ndk_build_cmd

        self._run_cmd(ndk_build_cmd)
Ejemplo n.º 32
0
    def select_default_android_platform(self, min_api_level):
        ''' select a default android platform in SDK_ROOT
        '''

        sdk_root = cocos.check_environment_variable('ANDROID_SDK_ROOT')
        platforms_dir = os.path.join(sdk_root, "platforms")
        ret_num = -1
        ret_platform = ""
        if os.path.isdir(platforms_dir):
            for dir_name in os.listdir(platforms_dir):
                if not os.path.isdir(os.path.join(platforms_dir, dir_name)):
                    continue

                num = self.get_api_level(dir_name, raise_error=False)
                if num >= min_api_level:
                    if ret_num == -1 or ret_num > num:
                        ret_num = num
                        ret_platform = dir_name

        if ret_num != -1:
            return ret_platform
        else:
            return None
Ejemplo n.º 33
0
    def select_default_android_platform(self, min_api_level):
        ''' select a default android platform in SDK_ROOT
        '''

        sdk_root = cocos.check_environment_variable('ANDROID_SDK_ROOT')
        platforms_dir = os.path.join(sdk_root, "platforms")
        ret_num = -1
        ret_platform = ""
        if os.path.isdir(platforms_dir):
            for dir_name in os.listdir(platforms_dir):
                if not os.path.isdir(os.path.join(platforms_dir, dir_name)):
                    continue

                num = self.get_api_level(dir_name, raise_error=False)
                if num >= min_api_level:
                    if ret_num == -1 or ret_num > num:
                        ret_num = num
                        ret_platform = dir_name

        if ret_num != -1:
            return ret_platform
        else:
            return None
    def __init__(self,
                 verbose,
                 app_android_root,
                 no_res,
                 proj_obj,
                 mode,
                 build_type,
                 app_abi,
                 gradle_support_ndk=False):
        self._verbose = verbose

        self.app_android_root = app_android_root
        self._no_res = no_res
        self._project = proj_obj
        self.gradle_support_ndk = gradle_support_ndk
        self.app_abi = app_abi
        self.mode = mode
        self.build_type = build_type

        # check environment variable
        self.sdk_root = cocos.check_environment_variable('ANDROID_SDK_ROOT')
        self.ant_root = None
        if os.path.exists(
                os.path.join(self.app_android_root, "gradle.properties")):
            self.sign_prop_file = os.path.join(self.app_android_root,
                                               "gradle.properties")
        elif os.path.exists(
                os.path.join(self.app_android_root, 'app',
                             "gradle.properties")):
            self.sign_prop_file = os.path.join(self.app_android_root, 'app',
                                               "gradle.properties")
        else:
            raise cocos.CCPluginError(
                MultiLanguage.get_string(
                    'COMPILE_GRADLE_PROPERTIES_NOT_FOUND'),
                cocos.CCPluginError.ERROR_PATH_NOT_FOUND)
        self._parse_cfg()
Ejemplo n.º 35
0
    def do_ndk_build(self, ndk_build_param, build_mode):
        cocos.Logging.info('NDK build mode: %s' % build_mode)
        ndk_root = cocos.check_environment_variable('NDK_ROOT')

        app_android_root = self.app_android_root
        cocos_root = self.cocos_root
        reload(sys)
        sys.setdefaultencoding('utf8')
        ndk_path = os.path.join(ndk_root, "ndk-build")
        module_paths = [os.path.join(app_android_root, path) for path in self.ndk_module_paths]

        # delete template static and dynamic files
        obj_local_dir = os.path.join(self.app_android_root, "obj", "local")
        if os.path.isdir(obj_local_dir):
            for abi_dir in os.listdir(obj_local_dir):
                static_file_path = os.path.join(self.app_android_root, "obj", "local", abi_dir)
                if os.path.isdir(static_file_path):
                    self.remove_c_libs(static_file_path)
           	    
        # windows should use ";" to seperate module paths
        if cocos.os_is_win32():
            ndk_module_path = ';'.join(module_paths)
        else:
            ndk_module_path = ':'.join(module_paths)
        
        ndk_module_path= 'NDK_MODULE_PATH=' + ndk_module_path

        if ndk_build_param is None:
            ndk_build_cmd = '%s -C %s %s' % (ndk_path, app_android_root, ndk_module_path)
        else:
            ndk_build_cmd = '%s -C %s %s %s' % (ndk_path, app_android_root, ' '.join(ndk_build_param), ndk_module_path)

        if build_mode == 'debug':
            ndk_build_cmd = '%s NDK_DEBUG=1' % ndk_build_cmd

        self._run_cmd(ndk_build_cmd)
Ejemplo n.º 36
0
    def compile_android(self):
        # build .so for android
        CONSOLE_PATH = "tools/cocos2d-console/bin"
        ANDROID_A_PATH = "frameworks/runtime-src/proj.android/obj/local"
        if self.use_studio is not None:
            ANDROID_A_PATH = "frameworks/runtime-src/proj.android-studio/app/build/intermediates/ndkBuild/" + self.mode + "/obj/local"

        android_out_dir = os.path.join(self.lib_dir, "android")
        engine_dir = self.repo_x
        console_dir = os.path.join(engine_dir, CONSOLE_PATH)
        cocos_py_path = os.path.join(console_dir, 'cocos.py')

        # build the simulator project
        proj_path = os.path.join(engine_dir, 'tools/simulator')
        python_path = cocos.check_environment_variable('COCOS_PYTHON_HOME',
                                                       raise_error=False)
        if python_path is None:
            python_path = 'python'
        else:
            python_path = os.path.join(python_path, 'python')
        build_cmd = "\"%s\" \"%s\" compile -s %s -p android --ndk-mode %s --app-abi %s -m %s" % (
            python_path, cocos_py_path, proj_path, self.mode, self.app_abi,
            self.mode)
        if self.android_platform is not None:
            build_cmd += ' --ap %s' % self.android_platform
        if self.use_studio is not None:
            build_cmd += ' --android-studio'

        env_param = ExtendEnv.get_extend_env_str()
        if env_param and len(env_param) > 0:
            build_cmd += (' --env "%s"' % env_param)
        self._run_cmd(build_cmd)

        # copy .a to prebuilt dir
        obj_dir = os.path.join(proj_path, ANDROID_A_PATH)
        copy_cfg = {
            "from": obj_dir,
            "to": android_out_dir,
            "include": ["*.a$"]
        }
        cocos.copy_files_with_config(copy_cfg, obj_dir, android_out_dir)

        if not self.disable_strip:
            # strip the android libs
            ndk_root = cocos.check_environment_variable("NDK_ROOT")
            if cocos.os_is_win32():
                if cocos.os_is_32bit_windows():
                    check_bits = ["", "-x86_64"]
                else:
                    check_bits = ["-x86_64", ""]

                sys_folder_name = "windows"
                for bit_str in check_bits:
                    check_folder_name = "windows%s" % bit_str
                    check_path = os.path.join(
                        ndk_root,
                        "toolchains/arm-linux-androideabi-4.9/prebuilt/%s" %
                        check_folder_name)
                    if os.path.isdir(check_path):
                        sys_folder_name = check_folder_name
                        break
            elif cocos.os_is_mac():
                sys_folder_name = "darwin-x86_64"
            else:
                sys_folder_name = "linux-x86_64"

            # set strip execute file name
            if cocos.os_is_win32():
                strip_execute_name = "strip.exe"
            else:
                strip_execute_name = "strip"

            # strip arm libs
            strip_cmd_path = os.path.join(
                ndk_root,
                "toolchains/arm-linux-androideabi-4.9/prebuilt/%s/arm-linux-androideabi/bin/%s"
                % (sys_folder_name, strip_execute_name))
            if os.path.exists(strip_cmd_path):
                armlibs = ["armeabi", "armeabi-v7a"]
                for fold in armlibs:
                    self.trip_libs(strip_cmd_path,
                                   os.path.join(android_out_dir, fold))
            else:
                raise Exception("(%s) wasn't found." % strip_cmd_path)

            # strip arm64-v8a libs
            strip_cmd_path = os.path.join(
                ndk_root,
                "toolchains/aarch64-linux-android-4.9/prebuilt/%s/aarch64-linux-android/bin/%s"
                % (sys_folder_name, strip_execute_name))
            if os.path.exists(strip_cmd_path):
                if os.path.exists(os.path.join(android_out_dir, "arm64-v8a")):
                    self.trip_libs(strip_cmd_path,
                                   os.path.join(android_out_dir, 'arm64-v8a'))
            else:
                raise Exception("(%s) wasn't found." % strip_cmd_path)

            # strip x86 libs
            strip_cmd_path = os.path.join(
                ndk_root,
                "toolchains/x86-4.9/prebuilt/%s/i686-linux-android/bin/%s" %
                (sys_folder_name, strip_execute_name))
            if os.path.exists(strip_cmd_path):
                if os.path.exists(os.path.join(android_out_dir, "x86")):
                    self.trip_libs(strip_cmd_path,
                                   os.path.join(android_out_dir, 'x86'))
            else:
                raise Exception("(%s) wasn't found." % strip_cmd_path)
Ejemplo n.º 37
0
    def build_android(self):
        if not self._platforms.is_android_active():
            return

        project_dir = self._project.get_project_dir()
        build_mode = self._mode
        output_dir = self._output_dir
        if self._project._is_script_project():
            if self._project._is_lua_project():
                cocos_root = os.path.join(project_dir, 'frameworks',
                                          'cocos2d-x')
            else:
                cocos_root = os.path.join(
                    project_dir, 'frameworks',
                    '%s-bindings' % self._project.get_language(), 'cocos2d-x')
        else:
            cocos_root = os.path.join(project_dir, 'cocos2d')

        # check environment variable
        ant_root = cocos.check_environment_variable('ANT_ROOT')
        sdk_root = cocos.check_environment_variable('ANDROID_SDK_ROOT')
        project_android_dir = self._platforms.project_path()

        from build_android import AndroidBuilder
        builder = AndroidBuilder(self._verbose, cocos_root,
                                 project_android_dir, self._no_res,
                                 self._project)

        args_ndk_copy = self._custom_step_args.copy()
        target_platform = self._platforms.get_current_platform()

        # update the project with the android platform
        builder.update_project(sdk_root, self._ap)

        if not self._project._is_script_project(
        ) or self._project._is_native_support():
            if self._ndk_mode != "none":
                # build native code
                cocos.Logging.info("building native")
                ndk_build_param = ["-j%s" % self._jobs]

                if self.app_abi:
                    abi_param = "APP_ABI=\"%s\"" % self.app_abi
                    ndk_build_param.append(abi_param)

                if self.ndk_toolchain:
                    toolchain_param = "NDK_TOOLCHAIN=%s" % self.ndk_toolchain
                    ndk_build_param.append(toolchain_param)

                self._project.invoke_custom_step_script(
                    cocos_project.Project.CUSTOM_STEP_PRE_NDK_BUILD,
                    target_platform, args_ndk_copy)

                modify_mk = False
                app_mk = os.path.join(project_android_dir,
                                      "jni/Application.mk")
                mk_content = None
                if self.cppflags and os.path.exists(app_mk):
                    # record the content of Application.mk
                    f = open(app_mk)
                    mk_content = f.read()
                    f.close()

                    # Add cpp flags
                    f = open(app_mk, "a")
                    f.write("\nAPP_CPPFLAGS += %s" % self.cppflags)
                    f.close()
                    modify_mk = True

                try:
                    builder.do_ndk_build(ndk_build_param, self._ndk_mode)
                except:
                    raise cocos.CCPluginError("Ndk build failed!")
                finally:
                    # roll-back the Application.mk
                    if modify_mk:
                        f = open(app_mk, "w")
                        f.write(mk_content)
                        f.close()

                self._project.invoke_custom_step_script(
                    cocos_project.Project.CUSTOM_STEP_POST_NDK_BUILD,
                    target_platform, args_ndk_copy)

        # build apk
        cocos.Logging.info("building apk")
        self.apk_path = builder.do_build_apk(sdk_root, ant_root, build_mode,
                                             output_dir,
                                             self._custom_step_args, self)

        cocos.Logging.info("build succeeded.")
Ejemplo n.º 38
0
    def build_web(self):
        if not self._platforms.is_web_active():
            return

        project_dir = self._platforms.project_path()

        # store env for run
        cfg_obj = self._platforms.get_current_config()
        if cfg_obj.run_root_dir is not None:
            self.run_root = cfg_obj.run_root_dir
        else:
            self.run_root = project_dir

        if cfg_obj.sub_url is not None:
            self.sub_url = cfg_obj.sub_url
        else:
            self.sub_url = '/'

        output_dir = "publish"
        if self._is_debug_mode():
            output_dir = "runtime"
            if not self._web_advanced:
                return

        self.sub_url = '%s%s/html5/' % (self.sub_url, output_dir)

        f = open(os.path.join(project_dir, "project.json"))
        project_json = json.load(f)
        f.close()
        engine_dir = os.path.join(project_json["engineDir"])
        realEngineDir = os.path.normpath(os.path.join(project_dir, engine_dir))
        publish_dir = os.path.normpath(
            os.path.join(project_dir, output_dir, "html5"))

        # need to config in options of command
        buildOpt = {
            "outputFileName": "game.min.js",
            "debug": "true" if self._is_debug_mode() else "false",
            "compilationLevel": "advanced" if self._web_advanced else "simple",
            "sourceMapOpened": True if self._has_sourcemap else False
        }

        if os.path.exists(publish_dir) == False:
            os.makedirs(publish_dir)

        # generate build.xml
        build_web.gen_buildxml(project_dir, project_json, publish_dir,
                               buildOpt)

        outputJsPath = os.path.join(publish_dir, buildOpt["outputFileName"])
        if os.path.exists(outputJsPath) == True:
            os.remove(outputJsPath)

        # call closure compiler
        ant_root = cocos.check_environment_variable('ANT_ROOT')
        ant_path = os.path.join(ant_root, 'ant')
        self._run_cmd("%s -f %s" %
                      (ant_path, os.path.join(publish_dir, 'build.xml')))

        # handle sourceMap
        sourceMapPath = os.path.join(publish_dir, "sourcemap")
        if os.path.exists(sourceMapPath):
            smFile = open(sourceMapPath)
            try:
                smContent = smFile.read()
            finally:
                smFile.close()

            dir_to_replace = project_dir
            if cocos.os_is_win32():
                dir_to_replace = project_dir.replace('\\', '\\\\')
            smContent = smContent.replace(
                dir_to_replace, os.path.relpath(project_dir, publish_dir))
            smContent = smContent.replace(
                realEngineDir, os.path.relpath(realEngineDir, publish_dir))
            smContent = smContent.replace('\\\\', '/')
            smContent = smContent.replace('\\', '/')
            smFile = open(sourceMapPath, "w")
            smFile.write(smContent)
            smFile.close()

        # handle project.json
        del project_json["engineDir"]
        del project_json["modules"]
        del project_json["jsList"]
        project_json_output_file = open(
            os.path.join(publish_dir, "project.json"), "w")
        project_json_output_file.write(json.dumps(project_json))
        project_json_output_file.close()

        # handle index.html
        indexHtmlFile = open(os.path.join(project_dir, "index.html"))
        try:
            indexContent = indexHtmlFile.read()
        finally:
            indexHtmlFile.close()
        reg1 = re.compile(
            r'<script\s+src\s*=\s*("|\')[^"\']*CCBoot\.js("|\')\s*><\/script>')
        indexContent = reg1.sub("", indexContent)
        mainJs = project_json.get("main") or "main.js"
        indexContent = indexContent.replace(mainJs, buildOpt["outputFileName"])
        indexHtmlOutputFile = open(os.path.join(publish_dir, "index.html"),
                                   "w")
        indexHtmlOutputFile.write(indexContent)
        indexHtmlOutputFile.close()

        # copy res dir
        dst_dir = os.path.join(publish_dir, 'res')
        src_dir = os.path.join(project_dir, 'res')
        if os.path.exists(dst_dir):
            shutil.rmtree(dst_dir)
        shutil.copytree(src_dir, dst_dir)
Ejemplo n.º 39
0
    def build_web(self):
        if not self._platforms.is_web_active():
            return

        project_dir = self._platforms.project_path()

        # store env for run
        cfg_obj = self._platforms.get_current_config()
        if cfg_obj.run_root_dir is not None:
            self.run_root = cfg_obj.run_root_dir
        else:
            self.run_root = project_dir

        if cfg_obj.sub_url is not None:
            self.sub_url = cfg_obj.sub_url
        else:
            self.sub_url = '/'

        if self._is_debug_mode():
            return
        else:
            self.sub_url = '%spublish/html5/' % self.sub_url

        f = open(os.path.join(project_dir, "project.json"))
        project_json = json.load(f)
        f.close()
        engine_dir = os.path.join(project_json["engineDir"])
        realEngineDir = os.path.normpath(os.path.join(project_dir, engine_dir))
        publish_dir = os.path.normpath(os.path.join(project_dir, "publish", "html5"))

        # need to config in options of command
        buildOpt = {
                "outputFileName" : "game.min.js",
                #"compilationLevel" : "simple",
                "compilationLevel" : "advanced",
                "sourceMapOpened" : True if self._has_sourcemap else False
                }

        if os.path.exists(publish_dir) == False:
            os.makedirs(publish_dir)

        # generate build.xml
        build_web.gen_buildxml(project_dir, project_json, publish_dir, buildOpt)

        outputJsPath = os.path.join(publish_dir, buildOpt["outputFileName"])
        if os.path.exists(outputJsPath) == True:
            os.remove(outputJsPath)


        # call closure compiler
        ant_root = cocos.check_environment_variable('ANT_ROOT')
        ant_path = os.path.join(ant_root, 'ant')
        self._run_cmd("%s -f %s" % (ant_path, os.path.join(publish_dir, 'build.xml')))

        # handle sourceMap
        sourceMapPath = os.path.join(publish_dir, "sourcemap")
        if os.path.exists(sourceMapPath):
            smFile = open(sourceMapPath)
            try:
                smContent = smFile.read()
            finally:
                smFile.close()

            dir_to_replace = project_dir
            if cocos.os_is_win32():
                dir_to_replace = project_dir.replace('\\', '\\\\')
            smContent = smContent.replace(dir_to_replace, os.path.relpath(project_dir, publish_dir))
            smContent = smContent.replace(realEngineDir, os.path.relpath(realEngineDir, publish_dir))
            smContent = smContent.replace('\\\\', '/')
            smContent = smContent.replace('\\', '/')
            smFile = open(sourceMapPath, "w")
            smFile.write(smContent)
            smFile.close()

        # handle project.json
        del project_json["engineDir"]
        del project_json["modules"]
        del project_json["jsList"]
        project_json_output_file = open(os.path.join(publish_dir, "project.json"), "w")
        project_json_output_file.write(json.dumps(project_json))
        project_json_output_file.close()

        # handle index.html
        indexHtmlFile = open(os.path.join(project_dir, "index.html"))
        try:
            indexContent = indexHtmlFile.read()
        finally:
            indexHtmlFile.close()
        reg1 = re.compile(r'<script\s+src\s*=\s*("|\')[^"\']*CCBoot\.js("|\')\s*><\/script>')
        indexContent = reg1.sub("", indexContent)
        mainJs = project_json.get("main") or "main.js"
        indexContent = indexContent.replace(mainJs, buildOpt["outputFileName"])
        indexHtmlOutputFile = open(os.path.join(publish_dir, "index.html"), "w")
        indexHtmlOutputFile.write(indexContent)
        indexHtmlOutputFile.close()
        
        # copy res dir
        dst_dir = os.path.join(publish_dir, 'res')
        src_dir = os.path.join(project_dir, 'res')
        if os.path.exists(dst_dir):
            shutil.rmtree(dst_dir)
        shutil.copytree(src_dir, dst_dir)
Ejemplo n.º 40
0
    def init(self, args):
        if getattr(sys, 'frozen', None):
            self.cur_dir = os.path.realpath(os.path.dirname(sys.executable))
            self.default_engine_path = os.path.join(self.cur_dir, os.pardir,
                                                    os.pardir, os.pardir)
        else:
            self.cur_dir = os.path.realpath(os.path.dirname(__file__))
            self.default_engine_path = os.path.join(self.cur_dir, os.pardir,
                                                    os.pardir, os.pardir,
                                                    os.pardir)
        self.default_engine_path = os.path.normpath(self.default_engine_path)

        if args.engine_path is None:
            self.engine_root = self.default_engine_path
        else:
            engine_path = os.path.expanduser(args.engine_path)
            if os.path.isabs(engine_path):
                self.engine_root = os.path.normpath(engine_path)
            else:
                self.engine_root = os.path.normpath(
                    os.path.abspath(engine_path))

        if not os.path.isdir(self.engine_root):
            raise CCPluginError(
                MultiLanguage.get_string('GEN_SIM_ERROR_WRONG_PATH_FMT',
                                         self.engine_root),
                CCPluginError.ERROR_WRONG_ARGS)

        self.simulator_abs_path = os.path.join(
            self.engine_root, SimulatorCompiler.SIMULATOR_PROJ_PATH)
        python_path = cocos.check_environment_variable('COCOS_PYTHON_HOME',
                                                       raise_error=False)
        if python_path is None:
            python_path = 'python'
        else:
            python_path = os.path.join(python_path, 'python')
        cocos_py_path = os.path.join(self.engine_root,
                                     SimulatorCompiler.COCOS_PY_PATH)
        self.cocos_bin = '\"%s\" \"%s\"' % (python_path, cocos_py_path)
        engine_version = utils.get_engine_version(self.engine_root)
        # get the short version after "cocos2d-x-"
        self.engine_version = engine_version[10:]

        # get the full path of output dir.
        if args.out_dir is None:
            self.simulator_output_dir = os.path.join(
                self.engine_root, SimulatorCompiler.DEFAULT_OUTPUT_FOLDER_NAME)
        else:
            out_dir = os.path.expanduser(args.out_dir)
            if os.path.isabs(out_dir):
                self.simulator_output_dir = os.path.normpath(out_dir)
            else:
                self.simulator_output_dir = os.path.normpath(
                    os.path.abspath(out_dir))

        # get arguments
        self.is_clean_before_build = args.do_clean
        if args.compile_mode is None:
            self.mode = 'debug'
        else:
            self.mode = args.compile_mode

        if args.platform is None:
            self.build_ios = True
            self.build_mac = True
            self.build_win = True
            self.build_android = True
        else:
            self.build_ios = False
            self.build_mac = False
            self.build_win = False
            self.build_android = False
            if 'win32' in args.platform:
                self.build_win = True
            if 'ios' in args.platform:
                self.build_ios = True
            if 'mac' in args.platform:
                self.build_mac = True
            if 'android' in args.platform:
                self.build_android = True

        self.build_log = ""
        self.vs_version = args.vs_version
        self._verbose = True
Ejemplo n.º 41
0
    def compile_android(self):
        # build .so for android
        CONSOLE_PATH = "tools/cocos2d-console/bin"
        ANDROID_A_PATH = "frameworks/runtime-src/proj.android/obj/local"

        android_out_dir = os.path.join(self.lib_dir, "android")
        engine_dir = self.repo_x
        console_dir = os.path.join(engine_dir, CONSOLE_PATH)
        if cocos.os_is_win32():
            cmd_path = os.path.join(console_dir, "cocos.bat")
        else:
            cmd_path = os.path.join(console_dir, "cocos")

        # build the simulator project
        proj_path = os.path.join(engine_dir, 'tools/simulator')
        build_cmd = "%s compile -s %s -p android --ndk-mode %s --app-abi %s" % (
            cmd_path, proj_path, self.mode, self.app_abi)

        env_param = ExtendEnv.get_extend_env_str()
        if env_param and len(env_param) > 0:
            build_cmd += (' --env "%s"' % env_param)
        self._run_cmd(build_cmd)

        # copy .a to prebuilt dir
        obj_dir = os.path.join(proj_path, ANDROID_A_PATH)
        copy_cfg = {
            "from": obj_dir,
            "to": android_out_dir,
            "include": ["*.a$"]
        }
        cocos.copy_files_with_config(copy_cfg, obj_dir, android_out_dir)

        if not self.disable_strip:
            # strip the android libs
            ndk_root = cocos.check_environment_variable("NDK_ROOT")
            if cocos.os_is_win32():
                if cocos.os_is_32bit_windows():
                    check_bits = ["", "-x86_64"]
                else:
                    check_bits = ["-x86_64", ""]

                sys_folder_name = "windows"
                for bit_str in check_bits:
                    check_folder_name = "windows%s" % bit_str
                    check_path = os.path.join(
                        ndk_root,
                        "toolchains/arm-linux-androideabi-4.8/prebuilt/%s" %
                        check_folder_name)
                    if os.path.isdir(check_path):
                        sys_folder_name = check_folder_name
                        break
            elif cocos.os_is_mac():
                sys_folder_name = "darwin-x86_64"
            else:
                sys_folder_name = "linux-x86_64"

            # set strip execute file name
            if cocos.os_is_win32():
                strip_execute_name = "strip.exe"
            else:
                strip_execute_name = "strip"

            # strip arm libs
            strip_cmd_path = os.path.join(
                ndk_root,
                "toolchains/arm-linux-androideabi-4.8/prebuilt/%s/arm-linux-androideabi/bin/%s"
                % (sys_folder_name, strip_execute_name))
            if os.path.exists(strip_cmd_path):
                armlibs = ["armeabi", "armeabi-v7a"]
                for fold in armlibs:
                    self.trip_libs(strip_cmd_path,
                                   os.path.join(android_out_dir, fold))

            # strip x86 libs
            strip_cmd_path = os.path.join(
                ndk_root,
                "toolchains/x86-4.8/prebuilt/%s/i686-linux-android/bin/%s" %
                (sys_folder_name, strip_execute_name))
            if os.path.exists(strip_cmd_path) and os.path.exists(
                    os.path.join(android_out_dir, "x86")):
                self.trip_libs(strip_cmd_path,
                               os.path.join(android_out_dir, 'x86'))
 def get_frameworks_path(self):
     return cocos.check_environment_variable(CCPluginUpgrade.FRAMEWORKS_VAR_KEY)
Ejemplo n.º 43
0
    def build_android(self):
        if not self._platforms.is_android_active():
            return

        project_dir = self._project.get_project_dir()
        build_mode = self._mode
        output_dir = self._output_dir
        if self._project._is_script_project():
            if self._project._is_lua_project():
                cocos_root = os.path.join(project_dir, 'frameworks' ,'cocos2d-x')
            else:
                cocos_root = os.path.join(project_dir, 'frameworks' ,'%s-bindings' % self._project.get_language(), 'cocos2d-x')
        else:
            cocos_root = os.path.join(project_dir, 'cocos2d')

        # check environment variable
        ant_root = cocos.check_environment_variable('ANT_ROOT')
        sdk_root = cocos.check_environment_variable('ANDROID_SDK_ROOT')
        project_android_dir = self._platforms.project_path()

        from build_android import AndroidBuilder
        builder = AndroidBuilder(self._verbose, cocos_root, project_android_dir, self._no_res, self._project)

        args_ndk_copy = self._custom_step_args.copy()
        target_platform = self._platforms.get_current_platform()

        # update the project with the android platform
        builder.update_project(sdk_root, self._ap)

        if not self._project._is_script_project() or self._project._is_native_support():
            if self._ndk_mode != "none":
                # build native code
                cocos.Logging.info("building native")
                ndk_build_param = [
                    "-j%s" % self._jobs
                ]

                if self.app_abi:
                    abi_param = "APP_ABI=\"%s\"" % self.app_abi
                    ndk_build_param.append(abi_param)

                if self.ndk_toolchain:
                    toolchain_param = "NDK_TOOLCHAIN=%s" % self.ndk_toolchain
                    ndk_build_param.append(toolchain_param)

                self._project.invoke_custom_step_script(cocos_project.Project.CUSTOM_STEP_PRE_NDK_BUILD, target_platform, args_ndk_copy)

                modify_mk = False
                app_mk = os.path.join(project_android_dir, "jni/Application.mk")
                mk_content = None
                if self.cppflags and os.path.exists(app_mk):
                    # record the content of Application.mk
                    f = open(app_mk)
                    mk_content = f.read()
                    f.close()

                    # Add cpp flags
                    f = open(app_mk, "a")
                    f.write("\nAPP_CPPFLAGS += %s" % self.cppflags)
                    f.close()
                    modify_mk = True

                try:
                    builder.do_ndk_build(ndk_build_param, self._ndk_mode)
                except:
                    raise cocos.CCPluginError("Ndk build failed!")
                finally:
                    # roll-back the Application.mk
                    if modify_mk:
                        f = open(app_mk, "w")
                        f.write(mk_content)
                        f.close()

                self._project.invoke_custom_step_script(cocos_project.Project.CUSTOM_STEP_POST_NDK_BUILD, target_platform, args_ndk_copy)

        # build apk
        cocos.Logging.info("building apk")
        self.apk_path = builder.do_build_apk(sdk_root, ant_root, build_mode, output_dir, self._custom_step_args, self)

        cocos.Logging.info("build succeeded.")