#!/usr/bin/python # build_native.py # Build native codes import sys import os, os.path import shutil from optparse import OptionParser import cocos from MultiLanguage import MultiLanguage import cocos_project import json import re from xml.dom import minidom if(sys.version_info.major < 3): import project_compile BUILD_CFIG_FILE="build-cfg.json" class AndroidBuilder(object): CFG_KEY_COPY_TO_ASSETS = "copy_to_assets" CFG_KEY_MUST_COPY_TO_ASSERTS = "must_copy_to_assets" CFG_KEY_STORE = "key_store" CFG_KEY_STORE_PASS = "key_store_pass" CFG_KEY_ALIAS = "alias" CFG_KEY_ALIAS_PASS = "alias_pass" GRADLE_KEY_STORE = "RELEASE_STORE_FILE" GRADLE_KEY_ALIAS = "RELEASE_KEY_ALIAS" GRADLE_KEY_STORE_PASS = "RELEASE_STORE_PASSWORD" GRADLE_KEY_ALIAS_PASS = "RELEASE_KEY_PASSWORD" GRADLE_PROP_TARGET_VERSION = 'PROP_TARGET_SDK_VERSION' GRADLE_PROP_BUILD_TYPE = 'PROP_BUILD_TYPE' GRADLE_PROP_APP_ABI = 'PROP_APP_ABI' GRADLE_PROP_COMPILE_SCRIPT = 'PROP_COMPILE_SCRIPT' GRADLE_PROP_LUA_ENCRYPT = 'PROP_LUA_ENCRYPT' GRADLE_PROP_LUA_ENCRYPT_KEY = 'PROP_LUA_ENCRYPT_KEY' GRADLE_PROP_LUA_ENCRYPT_SIGN = 'PROP_LUA_ENCRYPT_SIGN' 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') 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() def _run_cmd(self, command, cwd=None): cocos.CMDRunner.run_cmd(command, self._verbose, cwd=cwd) def _parse_cfg(self): # get the properties for sign release apk self.key_store_str = AndroidBuilder.GRADLE_KEY_STORE self.key_alias_str = AndroidBuilder.GRADLE_KEY_ALIAS self.key_store_pass_str = AndroidBuilder.GRADLE_KEY_STORE_PASS self.key_alias_pass_str = AndroidBuilder.GRADLE_KEY_ALIAS_PASS if self.gradle_support_ndk: return self.cfg_path = os.path.join(self.app_android_root, BUILD_CFIG_FILE) try: f = open(self.cfg_path) cfg = json.load(f, encoding='utf8') f.close() except Exception: raise cocos.CCPluginError(MultiLanguage.get_string('COMPILE_ERROR_PARSE_CFG_FAILED_FMT', self.cfg_path), cocos.CCPluginError.ERROR_PARSE_FILE) if cocos.dict_contains(cfg, project_compile.CCPluginCompile.CFG_KEY_MUST_COPY_RESOURCES): if self._no_res: self.res_files = cfg[project_compile.CCPluginCompile.CFG_KEY_MUST_COPY_RESOURCES] else: self.res_files = cfg[project_compile.CCPluginCompile.CFG_KEY_MUST_COPY_RESOURCES] + cfg[project_compile.CCPluginCompile.CFG_KEY_COPY_RESOURCES] else: self.res_files = cfg[project_compile.CCPluginCompile.CFG_KEY_COPY_RESOURCES] move_cfg = {} self.key_store = None if cocos.dict_contains(cfg, AndroidBuilder.CFG_KEY_STORE): self.key_store = cfg[AndroidBuilder.CFG_KEY_STORE] move_cfg[self.key_store_str] = self.key_store del cfg[AndroidBuilder.CFG_KEY_STORE] self.key_store_pass = None if cocos.dict_contains(cfg, AndroidBuilder.CFG_KEY_STORE_PASS): self.key_store_pass = cfg[AndroidBuilder.CFG_KEY_STORE_PASS] move_cfg[self.key_store_pass_str] = self.key_store_pass del cfg[AndroidBuilder.CFG_KEY_STORE_PASS] self.alias = None if cocos.dict_contains(cfg, AndroidBuilder.CFG_KEY_ALIAS): self.alias = cfg[AndroidBuilder.CFG_KEY_ALIAS] move_cfg[self.key_alias_str] = self.alias del cfg[AndroidBuilder.CFG_KEY_ALIAS] self.alias_pass = None if cocos.dict_contains(cfg, AndroidBuilder.CFG_KEY_ALIAS_PASS): self.alias_pass = cfg[AndroidBuilder.CFG_KEY_ALIAS_PASS] move_cfg[self.key_alias_pass_str] = self.alias_pass del cfg[AndroidBuilder.CFG_KEY_ALIAS_PASS] if len(move_cfg) > 0: # move the config into ant.properties self._move_cfg(move_cfg) with open(self.cfg_path, 'w') as outfile: json.dump(cfg, outfile, sort_keys = True, indent = 4) outfile.close() def has_keystore_in_signprops(self): keystore = None pattern = re.compile(r"^RELEASE_STORE_FILE=(.+)") try: file_obj = open(self.sign_prop_file) for line in file_obj: str1 = line.replace(' ', '') str2 = str1.replace('\t', '') match = pattern.match(str2) if match is not None: keystore = match.group(1) break file_obj.close() except: pass if keystore is None: return False else: return True def _write_sign_properties(self, cfg): file_obj = open(self.sign_prop_file, "a+") for key in cfg.keys(): str_cfg = "%s=%s\n" % (key, cfg[key]) file_obj.write(str_cfg) file_obj.close() def _move_cfg(self, cfg): if not self.has_keystore_in_signprops(): self._write_sign_properties(cfg) def remove_c_libs(self, libs_dir): for file_name in os.listdir(libs_dir): lib_file = os.path.join(libs_dir, file_name) if os.path.isfile(lib_file): ext = os.path.splitext(lib_file)[1] if ext == ".a" or ext == ".so": os.remove(lib_file) def _get_android_sdk_tools_ver(self, sdk_tools_path): cfg_file = os.path.join(sdk_tools_path, 'source.properties') if os.path.isfile(cfg_file): f = open(cfg_file) lines = f.readlines() pattern = r'^Pkg\.Revision=(\d+)\.(\d+)' for l in lines: match = re.match(pattern, l.strip()) if match: return ((int)(match.group(1)), (int)(match.group(2))) raise cocos.CCPluginError(MultiLanguage.get_string('COMPILE_ERROR_UNKNOWN_ANDROID_SDK_TOOLS_VERSION'), cocos.CCPluginError.ERROR_PATH_NOT_FOUND) def _update_project_properties(self, folder_path, target_str): props_path = os.path.join(folder_path, 'project.properties') f = open(props_path) lines = f.readlines() f.close() pattern = r'^target=(.*)$' matched = False new_line = 'target=%s\n' % target_str for i in range(0, len(lines)): l = lines[i] match = re.match(pattern, l.strip()) if match: lines[i] = new_line matched = True if not matched: lines.append('\n') lines.append(new_line) f = open(props_path, 'w') f.writelines(lines) f.close() 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('ANDROID_NDK') 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() def update_project(self, android_platform): if self.gradle_support_ndk: # If gradle supports ndk build, should write local.properties manually self._write_local_properties(self.app_android_root) return manifest_path = os.path.join(self.app_android_root, 'app') # check the android platform target_str = self.check_android_platform(self.sdk_root, android_platform, manifest_path) # should manually update the project self._write_local_properties(manifest_path) self._update_project_properties(manifest_path, target_str) # copy the local.properties to the app_android_root file_name = 'local.properties' src_path = os.path.normpath(os.path.join(manifest_path, file_name)) dst_path = os.path.normpath(os.path.join(self.app_android_root, file_name)) if src_path != dst_path: if os.path.isfile(dst_path): os.remove(dst_path) shutil.copy(src_path, dst_path) def get_toolchain_version(self, ndk_root, compile_obj): # it should be possible to override the toolchain if 'NDK_TOOLCHAIN_VERSION' in os.environ: return os.environ['NDK_TOOLCHAIN_VERSION'] return '4.9' 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('ANDROID_NDK') 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) def _xml_attr(self, dir, file_name, node_name, attr): doc = minidom.parse(os.path.join(dir, file_name)) return doc.getElementsByTagName(node_name)[0].getAttribute(attr) def update_lib_projects(self, sdk_root, sdk_tool_path, android_platform, property_path): property_file = os.path.join(property_path, "project.properties") if not os.path.isfile(property_file): return patten = re.compile(r'^android\.library\.reference\.[\d]+=(.+)') for line in open(property_file): str1 = line.replace(' ', '') str2 = str1.replace('\t', '') match = patten.match(str2) if match is not None: # a lib project is found lib_path = match.group(1) abs_lib_path = os.path.join(property_path, lib_path) abs_lib_path = os.path.normpath(abs_lib_path) if os.path.isdir(abs_lib_path): target_str = self.check_android_platform(sdk_root, android_platform, abs_lib_path) command = "%s update lib-project -p %s -t %s" % (cocos.CMDRunner.convert_path_to_cmd(sdk_tool_path), abs_lib_path, target_str) self._run_cmd(command) self.update_lib_projects(sdk_root, sdk_tool_path, android_platform, abs_lib_path) def get_api_level(self, target_str, raise_error=True): match = re.match(r'android-(\d+)', target_str) if match is not None: ret = int(match.group(1)) else: if raise_error: raise cocos.CCPluginError(MultiLanguage.get_string('COMPILE_ERROR_NOT_VALID_AP_FMT', target_str), cocos.CCPluginError.ERROR_PARSE_FILE) else: ret = -1 return ret def get_target_config(self, proj_path): property_file = os.path.join(proj_path, "project.properties") if not os.path.isfile(property_file): raise cocos.CCPluginError(MultiLanguage.get_string('COMPILE_ERROR_FILE_NOT_FOUND_FMT', property_file), cocos.CCPluginError.ERROR_PATH_NOT_FOUND) patten = re.compile(r'^target=(.+)') for line in open(property_file): str1 = line.replace(' ', '') str2 = str1.replace('\t', '') match = patten.match(str2) if match is not None: target = match.group(1) target_num = self.get_api_level(target) if target_num > 0: return target_num raise cocos.CCPluginError(MultiLanguage.get_string('COMPILE_ERROR_TARGET_NOT_FOUND_FMT', property_file), cocos.CCPluginError.ERROR_PARSE_FILE) # check the selected android platform def check_android_platform(self, sdk_root, android_platform, proj_path): ret = android_platform if android_platform is None: min_platform = self.get_target_config(proj_path) # not specified platform, use the one in project.properties ret = 'android-%d' % min_platform ret_path = os.path.join(cocos.CMDRunner.convert_path_to_python(sdk_root), "platforms", ret) if not os.path.isdir(ret_path): raise cocos.CCPluginError(MultiLanguage.get_string('COMPILE_ERROR_NO_AP_IN_SDK_FMT', ret), cocos.CCPluginError.ERROR_PATH_NOT_FOUND) return ret def gradle_build_apk(self, mode, android_platform, compile_obj): # check the compileSdkVersion & buildToolsVersion check_file = os.path.join(self.app_android_root, 'app', 'build.gradle') f = open(check_file) lines = f.readlines() f.close() compile_sdk_ver = None build_tools_ver = None compile_sdk_pattern = r'compileSdkVersion[ \t]+([\d]+)' build_tools_pattern = r'buildToolsVersion[ \t]+"(.+)"' for line in lines: line_str = line.strip() match1 = re.match(compile_sdk_pattern, line_str) if match1: compile_sdk_ver = match1.group(1) match2 = re.match(build_tools_pattern, line_str) if match2: build_tools_ver = match2.group(1) if compile_sdk_ver is not None: # check the compileSdkVersion check_folder_name = 'android-%s' % compile_sdk_ver check_path = os.path.join(self.sdk_root, 'platforms', check_folder_name) if not os.path.isdir(check_path): cocos.Logging.warning(MultiLanguage.get_string('COMPILE_WARNING_COMPILE_SDK_FMT', (compile_sdk_ver, check_path))) if build_tools_ver is not None: # check the buildToolsVersion check_path = os.path.join(self.sdk_root, 'build-tools', build_tools_ver) if not os.path.isdir(check_path): cocos.Logging.warning(MultiLanguage.get_string('COMPILE_WARNING_BUILD_TOOLS_FMT', (build_tools_ver, check_path))) # invoke gradlew for gradle building if cocos.os_is_win32(): gradle_path = os.path.join(self.app_android_root, 'gradlew.bat') else: gradle_path = os.path.join(self.app_android_root, 'gradlew') if not os.path.isfile(gradle_path): raise cocos.CCPluginError(MultiLanguage.get_string('COMPILE_ERROR_GRALEW_NOT_EXIST_FMT', gradle_path), cocos.CCPluginError.ERROR_PATH_NOT_FOUND) mode_str = 'Debug' if mode == 'debug' else 'Release' cmd = '"%s" --parallel --info assemble%s' % (gradle_path, mode_str) if self.gradle_support_ndk: add_props = { AndroidBuilder.GRADLE_PROP_BUILD_TYPE: self.build_type } if android_platform: ret = self.check_android_platform(self.sdk_root, android_platform, None) pattern = r'android-(\d+)' match = re.match(pattern, ret) if match: add_props[AndroidBuilder.GRADLE_PROP_TARGET_VERSION] = (int)(match.group(1)) if self.app_abi: add_props[AndroidBuilder.GRADLE_PROP_APP_ABI] = ':'.join(self.app_abi.split(' ')) if self._project._is_script_project(): if compile_obj._compile_script: add_props[AndroidBuilder.GRADLE_PROP_COMPILE_SCRIPT] = 1 else: add_props[AndroidBuilder.GRADLE_PROP_COMPILE_SCRIPT] = 0 if self._project._is_lua_project(): if compile_obj._lua_encrypt: add_props[AndroidBuilder.GRADLE_PROP_LUA_ENCRYPT] = 1 add_props[AndroidBuilder.GRADLE_PROP_LUA_ENCRYPT_KEY] = compile_obj._lua_encrypt_key add_props[AndroidBuilder.GRADLE_PROP_LUA_ENCRYPT_SIGN] = compile_obj._lua_encrypt_sign for key in add_props.keys(): cmd += ' -P%s=%s' % (key, add_props[key]) self._run_cmd(cmd, cwd=self.app_android_root) class LuaBuildArch: UNKNOWN = -1 ONLY_BUILD_64BIT = 1 ONLY_BUILD_32BIT = 2 BUILD_32BIT_AND_64BIT = 3 def _do_get_build_arch(self, str): # remove the '#' and the contents after it str = str.split('#')[0] build_64bit = str.find('arm64-v8a') != -1 # check if need to build other architecture build_other_arch = False other_archs = ('armeabi-v7a', 'x86') # other arches are not supported for arch in other_archs: if str.find(arch) != -1: build_other_arch = True break if build_64bit or build_other_arch: if build_64bit: if build_other_arch: print('build 64bit and 32bit') return self.LuaBuildArch.BUILD_32BIT_AND_64BIT else: print('only build 64bit') return self.LuaBuildArch.ONLY_BUILD_64BIT else: print('only build 32bit') return self.LuaBuildArch.ONLY_BUILD_32BIT return self.LuaBuildArch.UNKNOWN # check if arm64-v8a is set in Application.mk def _get_build_arch(self, param_of_appabi): # get build type from parameter if param_of_appabi: return self._do_get_build_arch(param_of_appabi) # get build type from Application.mk applicationmk_path = os.path.join(self.app_android_root, "app/jni/Application.mk") with open(applicationmk_path) as f: for line in f: if line.find('APP_ABI') == -1: continue build_arch = self._do_get_build_arch(line) if build_arch != self.LuaBuildArch.UNKNOWN: return build_arch return self.LuaBuildArch.UNKNOWN def do_build_apk(self, mode, no_apk, no_sign, output_dir, custom_step_args, android_platform, compile_obj): assets_dir = os.path.join(self.app_android_root, "app", "assets") project_name = None setting_file = os.path.join(self.app_android_root, 'settings.gradle') if os.path.isfile(setting_file): # get project name from settings.gradle f = open(setting_file) lines = f.readlines() f.close() pattern = r"project\(':(.*)'\)\.projectDir[ \t]*=[ \t]*new[ \t]*File\(settingsDir, 'app'\)" for line in lines: line_str = line.strip() match = re.match(pattern, line_str) if match: project_name = match.group(1) break if project_name is None: # use default project name project_name = 'app' gen_apk_folder = os.path.join(self.app_android_root, 'app/build/outputs/apk', mode) # gradle supports copy assets & compile scripts from engine 3.15 if not self.gradle_support_ndk: # copy resources self._copy_resources(custom_step_args, assets_dir) # check the project config & compile the script files if self._project._is_lua_project(): src_dir = os.path.join(assets_dir, 'src') build_arch = self._get_build_arch(compile_obj.app_abi) # only build 64bit if build_arch == self.LuaBuildArch.ONLY_BUILD_64BIT: dst_dir = os.path.join(assets_dir, 'src/64bit') is_compiled = compile_obj.compile_lua_scripts(src_dir, dst_dir, True) if is_compiled: # remove unneeded lua files compile_obj._remove_file_with_ext(src_dir, '.lua') shutil.rmtree(os.path.join(src_dir, 'cocos')) # only build 32bit if build_arch == self.LuaBuildArch.ONLY_BUILD_32BIT: # build 32-bit bytecode compile_obj.compile_lua_scripts(src_dir, src_dir, False) # build 32bit and 64bit if build_arch == self.LuaBuildArch.BUILD_32BIT_AND_64BIT: # build 64-bit bytecode dst_dir = os.path.join(assets_dir, 'src/64bit') compile_obj.compile_lua_scripts(src_dir, dst_dir, True) # build 32-bit bytecode compile_obj.compile_lua_scripts(src_dir, src_dir, False) if build_arch == self.LuaBuildArch.UNKNOWN: # haven't set APP_ABI in parameter and Application.mk, default build 32bit compile_obj.compile_lua_scripts(src_dir, src_dir, False) if self._project._is_js_project(): compile_obj.compile_js_scripts(assets_dir, assets_dir) if not no_apk: # gather the sign info if necessary if not no_sign: if mode == "release" and not self.has_keystore_in_signprops(): self._gather_sign_info() # build apk self.gradle_build_apk(mode, android_platform, compile_obj) # copy the apk to output dir if output_dir: # support generate unsigned apk if mode == "release" and no_sign: apk_name = '%s-%s-unsigned.apk' % (project_name, mode) else: apk_name = '%s-%s.apk' % (project_name, mode) gen_apk_path = os.path.join(gen_apk_folder, apk_name) if not os.path.exists(output_dir): os.makedirs(output_dir) shutil.copy(gen_apk_path, output_dir) cocos.Logging.info(MultiLanguage.get_string('COMPILE_INFO_MOVE_APK_FMT', output_dir)) if mode == "release" and not no_sign: signed_name = "%s-%s-signed.apk" % (project_name, mode) apk_path = os.path.join(output_dir, signed_name) if os.path.exists(apk_path): os.remove(apk_path) os.rename(os.path.join(output_dir, apk_name), apk_path) else: apk_path = os.path.join(output_dir, apk_name) return apk_path else: raise cocos.CCPluginError(MultiLanguage.get_string('COMPILE_ERROR_NOT_SPECIFY_OUTPUT'), cocos.CCPluginError.ERROR_WRONG_ARGS) def _gather_sign_info(self): user_cfg = {} # get the path of keystore file while True: inputed = self._get_user_input(MultiLanguage.get_string('COMPILE_TIP_INPUT_KEYSTORE')) inputed = inputed.strip() if not os.path.isabs(inputed): start_path = os.path.join(self.app_android_root, 'app') abs_path = os.path.join(start_path, inputed) else: abs_path = inputed if os.path.isfile(abs_path): user_cfg[self.key_store_str] = inputed.replace('\\', '/') break else: cocos.Logging.warning(MultiLanguage.get_string('COMPILE_INFO_NOT_A_FILE')) # get the alias of keystore file user_cfg[self.key_alias_str] = self._get_user_input(MultiLanguage.get_string('COMPILE_TIP_INPUT_ALIAS')) # get the keystore password user_cfg[self.key_store_pass_str] = self._get_user_input(MultiLanguage.get_string('COMPILE_TIP_INPUT_KEY_PASS')) # get the alias password user_cfg[self.key_alias_pass_str] = self._get_user_input(MultiLanguage.get_string('COMPILE_TIP_INPUT_ALIAS_PASS')) # write the config into ant.properties self._write_sign_properties(user_cfg) def _get_user_input(self, tip_msg): cocos.Logging.warning(tip_msg) ret = None while True: ret = cocos.get_input() break return ret def _copy_resources(self, custom_step_args, assets_dir): app_android_root = self.app_android_root res_files = self.res_files # remove app_android_root/assets if it exists if os.path.isdir(assets_dir): shutil.rmtree(assets_dir) # generate parameters for custom steps target_platform = cocos_project.Platforms.ANDROID cur_custom_step_args = custom_step_args.copy() cur_custom_step_args["assets-dir"] = assets_dir # make dir os.mkdir(assets_dir) # invoke custom step : pre copy assets self._project.invoke_custom_step_script(cocos_project.Project.CUSTOM_STEP_PRE_COPY_ASSETS, target_platform, cur_custom_step_args) # copy resources for cfg in res_files: cocos.copy_files_with_config(cfg, app_android_root, assets_dir) # invoke custom step : post copy assets self._project.invoke_custom_step_script(cocos_project.Project.CUSTOM_STEP_POST_COPY_ASSETS, target_platform, cur_custom_step_args) def get_apk_info(self): manifest_path = os.path.join(self.app_android_root, 'app') gradle_cfg_path = os.path.join(manifest_path, 'build.gradle') package = None if os.path.isfile(gradle_cfg_path): # get package name from build.gradle f = open(gradle_cfg_path) for line in f.readlines(): line_str = line.strip() pattern = r'applicationId[ \t]+"(.*)"' match = re.match(pattern, line_str) if match: package = match.group(1) break if package is None: # get package name from AndroidManifest.xml package = self._xml_attr(manifest_path, 'AndroidManifest.xml', 'manifest', 'package') activity_name = self._xml_attr(manifest_path, 'AndroidManifest.xml', 'activity', 'android:name') if activity_name.startswith('.'): activity = package + activity_name else: activity = activity_name ret = (package, activity) return ret