Merge pull request #389 from natural-law/tizen-cli

Support compile & run project on Tizen.

Author: minggo

bin/cocos_project.py

@@ -199,6 +199,7 @@ class Platforms(object):
     WP8 = "wp8"
     WP8_1 = "wp8_1"
     METRO = "metro"
+    TIZEN = "tizen"
 
     CFG_CLASS_MAP = {
         ANDROID : "cocos_project.AndroidConfig",
@@ -209,7 +210,8 @@ class Platforms(object):
         LINUX : "cocos_project.LinuxConfig",
         WP8 : "cocos_project.Wp8Config",
         WP8_1 : "cocos_project.Wp8_1Config",
-        METRO : "cocos_project.MetroConfig"
+        METRO : "cocos_project.MetroConfig",
+        TIZEN : "cocos_project.TizenConfig"
     }
 
     @staticmethod
@@ -239,10 +241,10 @@ def __init__(self, project, current, proj_dir = None):
     def _filter_platforms(self, platforms):
         ret = []
         platforms_for_os = {
-            "linux" : [ Platforms.WEB, Platforms.LINUX, Platforms.ANDROID ],
-            "mac" : [ Platforms.WEB, Platforms.IOS, Platforms.MAC, Platforms.ANDROID ],
+            "linux" : [ Platforms.WEB, Platforms.LINUX, Platforms.ANDROID, Platforms.TIZEN ],
+            "mac" : [ Platforms.WEB, Platforms.IOS, Platforms.MAC, Platforms.ANDROID, Platforms.TIZEN ],
             "win32" : [ Platforms.WEB, Platforms.WIN32, Platforms.ANDROID, Platforms.WP8,
-                        Platforms.WP8_1, Platforms.METRO]
+                        Platforms.WP8_1, Platforms.METRO, Platforms.TIZEN ]
         }
         for p in platforms:
             if cocos.os_is_linux():
@@ -261,22 +263,22 @@ def _gen_available_platforms(self, proj_info, proj_dir):
         # generate the platform list for different projects
         if self._project._is_lua_project():
             if self._project._is_native_support():
-                platform_list = [ Platforms.ANDROID, Platforms.WIN32, Platforms.IOS, Platforms.MAC, Platforms.LINUX ]
+                platform_list = [ Platforms.ANDROID, Platforms.WIN32, Platforms.IOS, Platforms.MAC, Platforms.LINUX, Platforms.TIZEN ]
             else:
                 if self._project.has_android_libs():
                     platform_list = [ Platforms.ANDROID ]
                 else:
                     platform_list = []
         elif self._project._is_js_project():
             if self._project._is_native_support():
-                platform_list = [ Platforms.ANDROID, Platforms.WIN32, Platforms.IOS, Platforms.MAC, Platforms.WEB, Platforms.LINUX, Platforms.WP8, Platforms.WP8_1, Platforms.METRO ]
+                platform_list = [ Platforms.ANDROID, Platforms.WIN32, Platforms.IOS, Platforms.MAC, Platforms.WEB, Platforms.LINUX, Platforms.WP8, Platforms.WP8_1, Platforms.METRO, Platforms.TIZEN ]
             else:
                 if self._project.has_android_libs():
                     platform_list = [ Platforms.ANDROID, Platforms.WEB ]
                 else:
                     platform_list = [ Platforms.WEB ]
         elif self._project._is_cpp_project():
-            platform_list = [ Platforms.ANDROID, Platforms.WIN32, Platforms.IOS, Platforms.MAC, Platforms.LINUX, Platforms.WP8, Platforms.WP8_1, Platforms.METRO ]
+            platform_list = [ Platforms.ANDROID, Platforms.WIN32, Platforms.IOS, Platforms.MAC, Platforms.LINUX, Platforms.WP8, Platforms.WP8_1, Platforms.METRO, Platforms.TIZEN ]
 
         # filter the available platform list
         platform_list = self._filter_platforms(platform_list)
@@ -342,6 +344,9 @@ def is_wp8_1_active(self):
     def is_metro_active(self):
         return self._current == Platforms.METRO
 
+    def is_tizen_active(self):
+        return self._current == Platforms.TIZEN
+
     def get_current_config(self):
         if self.none_active():
             return None
@@ -706,3 +711,18 @@ def _is_available(self):
         ret = super(MetroConfig, self)._is_available()
 
         return ret
+
+class TizenConfig(PlatformConfig):
+    def _use_default(self):
+        if self._is_script:
+            self.proj_path = os.path.join(self._proj_root_path, "frameworks", "runtime-src", "proj.tizen")
+        else:
+            self.proj_path = os.path.join(self._proj_root_path, "proj.tizen")
+
+    def _parse_info(self, cfg_info):
+        super(TizenConfig, self)._parse_info(cfg_info)
+
+    def _is_available(self):
+        ret = super(TizenConfig, self)._is_available()
+
+        return ret

bin/strings.json

@@ -156,6 +156,17 @@
         "COMPILE_ARG_LUA_ENCRYPT" : "Enable the encrypting of lua scripts.",
         "COMPILE_ARG_LUA_ENCRYPT_KEY" : "Specify the encrypt key for the encrypting of lua scripts.",
         "COMPILE_ARG_LUA_ENCRYPT_SIGN" : "Specify the encrypt sign for the encrypting of lua scripts.",
+        "COMPILE_ARG_GROUP_TIZEN" : "Tizen Options",
+        "COMPILE_ARG_TIZEN_ARCH" : "Determines the architecture type for the rootstrap.",
+        "COMPILE_ARG_TIZEN_COMPILER" : "Set the compiler to the native project.",
+        "COMPILE_ARG_TIZEN_PKGTYPE" : "Set the package type.",
+        "COMPILE_ARG_TIZEN_PROFILE" : "Set the profile path for signing.",
+        "COMPILE_ARG_TIZEN_SIGN" : "Set the profile name to use for signing.",
+        "COMPILE_ARG_TIZEN_STRIP" : "Determines whether to strip the native binary.",
+        "COMPILE_ERROR_TIZEN_PROFILE" : "Please specify the profile path by --tizen-profile.",
+        "COMPILE_ERROR_TIZEN_NO_FILE_FMT" : "%s is not generated by 'tizen build-native'",
+        "COMPILE_ERROR_TIZEN_NO_TYPE" : "Please specify the package type by --tizen-pkgtype.",
+        "COMPILE_ERROR_TIZEN_BUILD_FAILED" : "Build tizen package failed!",
         "COMPILE_DETECT_CPU_FAILED" : "Failed to detect number of cpus, assume 1 cpu.",
         "COMPILE_INFO_BUILD_NATIVE" : "Building native...",
         "COMPILE_INFO_BUILD_APK" : "Building apk...",
@@ -485,6 +496,17 @@
         "COMPILE_ARG_LUA_ENCRYPT" : "开启 XXTEA 加密功能。",
         "COMPILE_ARG_LUA_ENCRYPT_KEY" : "指定 XXTEA 加密功能的 key 字段。",
         "COMPILE_ARG_LUA_ENCRYPT_SIGN" : "指定 XXTEA 加密功能的 sign 字段。",
+        "COMPILE_ARG_GROUP_TIZEN" : "Tizen 相关参数",
+        "COMPILE_ARG_TIZEN_ARCH" : "指定需要编译的 CPU 架构。",
+        "COMPILE_ARG_TIZEN_COMPILER" : "指定 native 工程所需使用的编译器。",
+        "COMPILE_ARG_TIZEN_PKGTYPE" : "指定最终生成安装包的类型。",
+        "COMPILE_ARG_TIZEN_PROFILE" : "指定用于签名的 profile 文件路径。",
+        "COMPILE_ARG_TIZEN_SIGN" : "指定用于签名的 profile 名称。",
+        "COMPILE_ARG_TIZEN_STRIP" : "指定是否开启 native 库的 strip 功能。",
+        "COMPILE_ERROR_TIZEN_PROFILE" : "请使用参数 --tizen-profile 指定用于签名的 profile 文件路径。",
+        "COMPILE_ERROR_TIZEN_NO_FILE_FMT" : "'tizen build-native' 命令未生成路径 %s",
+        "COMPILE_ERROR_TIZEN_NO_TYPE" : "请使用参数 --tizen-pkgtype 指定生成的安装包类型。",
+        "COMPILE_ERROR_TIZEN_BUILD_FAILED" : "生成 tizen 安装包失败。",
         "COMPILE_DETECT_CPU_FAILED" : "检测机器 cpu 数量失败，使用 1 个 cpu 进行编译。",
         "COMPILE_INFO_BUILD_NATIVE" : "正在执行 ndk-build...",
         "COMPILE_INFO_BUILD_APK" : "正在生成 apk 文件...",
@@ -813,6 +835,17 @@
         "COMPILE_ARG_LUA_ENCRYPT" : "開啟 XXTEA 加密功能。",
         "COMPILE_ARG_LUA_ENCRYPT_KEY" : "指定 XXTEA 加密功能的 key 字段。",
         "COMPILE_ARG_LUA_ENCRYPT_SIGN" : "指定 XXTEA 加密功能的 sign 字段。",
+        "COMPILE_ARG_GROUP_TIZEN" : "Tizen 相關參數",
+        "COMPILE_ARG_TIZEN_ARCH" : "指定需要編譯的 CPU 架構。",
+        "COMPILE_ARG_TIZEN_COMPILER" : "指定 native 工程所需使用的編譯器。",
+        "COMPILE_ARG_TIZEN_PKGTYPE" : "指定最終生成安裝包的類型。",
+        "COMPILE_ARG_TIZEN_PROFILE" : "指定用於簽名的 profile 檔路徑。",
+        "COMPILE_ARG_TIZEN_SIGN" : "指定用於簽名的 profile 名稱。",
+        "COMPILE_ARG_TIZEN_STRIP" : "指定是否開啟 native 庫的 strip 功能。",
+        "COMPILE_ERROR_TIZEN_PROFILE" : "請使用參數 --tizen-profile 指定用於簽名的 profile 檔路徑。",
+        "COMPILE_ERROR_TIZEN_NO_FILE_FMT" : "'tizen build-native' 命令未生成路徑 %s",
+        "COMPILE_ERROR_TIZEN_NO_TYPE" : "請使用參數 --tizen-pkgtype 指定生成的安裝包類型。",
+        "COMPILE_ERROR_TIZEN_BUILD_FAILED" : "生成 tizen 安裝包失敗。",
         "COMPILE_DETECT_CPU_FAILED" : "檢測機器 cpu 數量失敗，使用 1 個 cpu 進行編譯。",
         "COMPILE_INFO_BUILD_NATIVE" : "正在執行 ndk-build...",
         "COMPILE_INFO_BUILD_APK" : "正在生成 apk 檔案...",

plugins/plugin_compile/project_compile.py

@@ -115,6 +115,14 @@ def _add_custom_options(self, parser):
         group.add_argument("--lua-encrypt-sign", dest="lua_encrypt_sign",
                            help=MultiLanguage.get_string('COMPILE_ARG_LUA_ENCRYPT_SIGN'))
 
+        group = parser.add_argument_group(MultiLanguage.get_string('COMPILE_ARG_GROUP_TIZEN'))
+        group.add_argument("--tizen-arch", dest="tizen_arch", default="x86", choices=[ "x86", "arm" ], help=MultiLanguage.get_string('COMPILE_ARG_TIZEN_ARCH'))
+        # group.add_argument("--tizen-compiler", dest="tizen_compiler", choices=[ "llvm", "gcc" ], help=MultiLanguage.get_string('COMPILE_ARG_TIZEN_COMPILER'))
+        # group.add_argument("--tizen-pkgtype", dest="tizen_pkgtype", default="tpk", choices=[ "tpk", "wgt" ], help=MultiLanguage.get_string('COMPILE_ARG_TIZEN_PKGTYPE'))
+        group.add_argument("--tizen-profile", dest="tizen_profile", help=MultiLanguage.get_string('COMPILE_ARG_TIZEN_PROFILE'))
+        group.add_argument("--tizen-sign", dest="tizen_sign", help=MultiLanguage.get_string('COMPILE_ARG_TIZEN_SIGN'))
+        group.add_argument("--tizen-strip", dest="tizen_strip", action="store_true", help=MultiLanguage.get_string('COMPILE_ARG_TIZEN_STRIP'))
+
         category = self.plugin_category()
         name = self.plugin_name()
         usage = "\n\t%%prog %s %s -p <platform> [-s src_dir][-m <debug|release>]" \
@@ -157,6 +165,15 @@ def _check_custom_options(self, args):
         if args.target_name is not None:
             self.xcode_target_name = args.target_name
 
+        # Tizen arguments
+        self.tizen_arch = args.tizen_arch
+        # self.tizen_compiler = args.tizen_compiler
+        # self.tizen_pkgtype = args.tizen_pkgtype
+        self.tizen_pkgtype = 'tpk'
+        self.tizen_sign = args.tizen_sign
+        self.tizen_strip = args.tizen_strip
+        self.tizen_profile = args.tizen_profile
+
         if args.compile_script is not None:
             self._compile_script = bool(args.compile_script)
         else:
@@ -1160,24 +1177,7 @@ def build_win32(self):
                 shutil.copy(file_path, output_dir)
 
         # copy lua files & res
-        build_cfg_path = self._build_cfg_path()
-        build_cfg = os.path.join(build_cfg_path, CCPluginCompile.BUILD_CONFIG_FILE)
-        if not os.path.exists(build_cfg):
-            message = MultiLanguage.get_string('COMPILE_ERROR_FILE_NOT_FOUND_FMT', build_cfg)
-            raise cocos.CCPluginError(message, cocos.CCPluginError.ERROR_PATH_NOT_FOUND)
-        f = open(build_cfg)
-        data = json.load(f)
-
-        if data.has_key(CCPluginCompile.CFG_KEY_MUST_COPY_RESOURCES):
-            if self._no_res:
-                fileList = data[CCPluginCompile.CFG_KEY_MUST_COPY_RESOURCES]
-            else:
-                fileList = data[CCPluginCompile.CFG_KEY_COPY_RESOURCES] + data[CCPluginCompile.CFG_KEY_MUST_COPY_RESOURCES]
-        else:
-            fileList = data[CCPluginCompile.CFG_KEY_COPY_RESOURCES]
-
-        for cfg in fileList:
-            cocos.copy_files_with_config(cfg, build_cfg_path, output_dir)
+        self._copy_resources(output_dir)
 
         # check the project config & compile the script files
         if self._project._is_js_project():
@@ -1524,6 +1524,113 @@ def build_metro(self):
         build_mode = 'Debug' if self._is_debug_mode() else 'Release'
         self.build_vs_project(projectPath, self.project_name, build_mode, self.vs_version)
 
+    def _build_tizen_proj(self, tizen_cmd_path, build_mode, proj_path):
+        build_native_cmd = "%s build-native -- \"%s\"" % (tizen_cmd_path, proj_path)
+        build_native_cmd += " -C %s" % build_mode
+        build_native_cmd += " -a %s" % self.tizen_arch
+
+        # if self.tizen_compiler is not None:
+        #     build_native_cmd += " -c %s" % self.tizen_compiler
+        # TODO now only support gcc
+        build_native_cmd += " -c gcc"
+
+        self._run_cmd(build_native_cmd)
+
+    def build_tizen(self):
+        if not self._platforms.is_tizen_active():
+            return
+
+        tizen_studio_path = cocos.check_environment_variable("TIZEN_STUDIO_HOME")
+        tizen_proj_path = self._platforms.project_path()
+        tizen_cmd_path = cocos.CMDRunner.convert_path_to_cmd(os.path.join(tizen_studio_path, "tools", "ide", "bin", "tizen"))
+        build_mode = 'Debug' if self._is_debug_mode() else 'Release'
+
+        # build library projects
+        build_cfg_data = self._get_build_cfg()
+        if build_cfg_data.has_key('depend_projs'):
+            lib_projs = build_cfg_data['depend_projs']
+            for proj in lib_projs:
+                proj_path = os.path.normpath(os.path.join(self._build_cfg_path(), proj))
+                self._build_tizen_proj(tizen_cmd_path, build_mode, proj_path)
+
+        # build the game project
+        self._build_tizen_proj(tizen_cmd_path, build_mode, tizen_proj_path)
+
+        # copy resources files
+        res_path = os.path.join(tizen_proj_path, 'res')
+        self._copy_resources(res_path)
+
+        # check the project config & compile the script files
+        if self._project._is_js_project():
+            self.compile_js_scripts(res_path, res_path)
+
+        if self._project._is_lua_project():
+            self.compile_lua_scripts(res_path, res_path, False)
+
+        # config the profile path
+        if self.tizen_profile is not None:
+            config_cmd = "%s cli-config -g \"default.profiles.path=%s\"" % (tizen_cmd_path, self.tizen_profile)
+            self._run_cmd(config_cmd)
+
+        # invoke tizen package
+        build_cfg_path = os.path.join(tizen_proj_path, build_mode)
+        if not os.path.isdir(build_cfg_path):
+            raise cocos.CCPluginError(MultiLanguage.get_string('COMPILE_ERROR_TIZEN_NO_FILE_FMT', build_cfg_path))
+
+        package_cmd = "%s package -- \"%s\" -t %s" % (tizen_cmd_path, build_cfg_path, self.tizen_pkgtype)
+        if self.tizen_sign is not None:
+            package_cmd += " -s \"%s\"" % self.tizen_sign
+
+        if self.tizen_strip:
+            package_cmd += " -S"
+
+        self._run_cmd(package_cmd)
+
+        # get the package path
+        from xml.dom import minidom
+        doc = minidom.parse(os.path.join(tizen_proj_path, "tizen-manifest.xml"))
+        pkgid = doc.getElementsByTagName("manifest")[0].getAttribute("package")
+        version = doc.getElementsByTagName("manifest")[0].getAttribute("version")
+
+        if self.tizen_arch == "arm":
+            arch_str = "arm"
+        else:
+            arch_str = "i386"
+
+        pkg_file_name = "%s-%s-%s.%s" % (pkgid, version, arch_str, self.tizen_pkgtype)
+        tizen_pkg_path = os.path.join(tizen_proj_path, build_mode, pkg_file_name)
+        if not os.path.isfile(tizen_pkg_path):
+            raise cocos.CCPluginError(MultiLanguage.get_string('COMPILE_ERROR_TIZEN_BUILD_FAILED'))
+
+        # copy the package into output dir
+        if not os.path.exists(self._output_dir):
+            os.makedirs(self._output_dir)
+        shutil.copy(tizen_pkg_path, self._output_dir)
+        self.tizen_pkg_path = os.path.join(self._output_dir, pkg_file_name)
+
+    def _get_build_cfg(self):
+        build_cfg_dir = self._build_cfg_path()
+        build_cfg = os.path.join(build_cfg_dir, CCPluginCompile.BUILD_CONFIG_FILE)
+        if not os.path.exists(build_cfg):
+            message = MultiLanguage.get_string('COMPILE_ERROR_FILE_NOT_FOUND_FMT', build_cfg)
+            raise cocos.CCPluginError(message, cocos.CCPluginError.ERROR_PATH_NOT_FOUND)
+        f = open(build_cfg)
+        return json.load(f)
+
+    def _copy_resources(self, dst_path):
+        data = self._get_build_cfg()
+
+        if data.has_key(CCPluginCompile.CFG_KEY_MUST_COPY_RESOURCES):
+            if self._no_res:
+                fileList = data[CCPluginCompile.CFG_KEY_MUST_COPY_RESOURCES]
+            else:
+                fileList = data[CCPluginCompile.CFG_KEY_COPY_RESOURCES] + data[CCPluginCompile.CFG_KEY_MUST_COPY_RESOURCES]
+        else:
+            fileList = data[CCPluginCompile.CFG_KEY_COPY_RESOURCES]
+
+        for cfg in fileList:
+            cocos.copy_files_with_config(cfg, self._build_cfg_path(), dst_path)
+
     def checkFileByExtention(self, ext, path):
         filelist = os.listdir(path)
         for fullname in filelist:
@@ -1557,6 +1664,7 @@ def run(self, argv, dependencies):
         self.build_wp8()
         self.build_wp8_1()
         self.build_metro()
+        self.build_tizen()
 
         # invoke the custom step: post-build
         self._project.invoke_custom_step_script(cocos_project.Project.CUSTOM_STEP_POST_BUILD, target_platform, args_build_copy)

plugins/plugin_deploy.py

@@ -185,6 +185,31 @@ def deploy_android(self, dependencies):
         adb_install = "%s install \"%s\"" % (adb_path, apk_path)
         self._run_cmd(adb_install)
 
+    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"))
+        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)
+
     def get_filename_by_extention(self, ext, path):
         filelist = os.listdir(path)
 
@@ -204,3 +229,4 @@ def run(self, argv, dependencies):
         self.deploy_win32(dependencies)
         self.deploy_linux(dependencies)
         self.deploy_wp8(dependencies)
+        self.deploy_tizen(dependencies)

plugins/plugin_run/project_run.py

@@ -324,6 +324,17 @@ def run_linux(self, dependencies):
         with cocos.pushd(run_root):
             self._run_with_desktop_options(os.path.join(run_root, exe))
 
+    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)
 
 
     def run(self, argv, dependencies):
@@ -336,4 +347,5 @@ def run(self, argv, dependencies):
         self.run_win32(dependencies)
         self.run_linux(dependencies)
         self.run_wp8(dependencies)
+        self.run_tizen(dependencies)