devbox
笔触狂放9
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Android 编译脚本 envsetup.sh_warning: cannot display lunch menu.

作者：笔触狂放9 | 2024-03-27 22:09:18

赞

踩

warning: cannot display lunch menu.

版本： android-12.0.0_r3

目录： build/envsetup.sh

  1. function hmm() {
  2. cat <<EOF
  4. Run "m help" for help with the build system itself.
  5. 运行“m help”以获取有关构建系统本身的帮助
  7. Invoke ". build/envsetup.sh" from your shell to add the following functions to your environment:
  8. 从您的 shell 中调用“.build/envsetup.sh”以将以下函数添加到您的环境中：
  9. - lunch:      lunch <product_name>-<build_variant>
  10.                选择编译的目标
  11.               Selects <product_name> as the product to build, and <build_variant> as the     
  12.               variant to build, and stores those selections in the environment to be read 
  13.               by subsequent invocations of 'm' etc.
  14.               选择 <product_name> 作为要构建的产品，选择 <build_variant> 作为要构建的变体构 
  15.               建，并将这些选择存储在环境中以供后续读取调用 'm' 等。
  17. - tapas:      tapas [<App1> <App2> ...] [arm|x86|arm64|x86_64] [eng|userdebug|user]
  18.               Sets up the build environment for building unbundled apps (APKs).
  19.               设置用于构建非捆绑应用 (APK) 的构建环境
  21. - banchan:    banchan <module1> [<module2> ...] [arm|x86|arm64|x86_64]                  
  22.               [eng|userdebug|user]
  23.               Sets up the build environment for building unbundled modules (APEXes).
  24.               设置用于构建非捆绑模块 (APEX) 的构建环境。
  26. - croot:      Changes directory to the top of the tree, or a subdirectory thereof.
  27.               将目录更改为树的顶部或其子目录。
  28.               改变当前路径到Android源码的根目录
  30. - m:          Makes from the top of the tree.
  31.               编译整个Android项目
  33. - mm:         Builds and installs all of the modules in the current directory, and their
  34.               dependencies.
  35.               生成并安装当前目录中的所有模块及其依赖项。
  36.               编译当前目录下所有的模块
  38. - mmm:        Builds and installs all of the modules in the supplied directories, and 
  39.               their dependencies.
  40.               在提供的目录中构建并安装所有模块，以及他们的依赖关系
  41.               
  42.               编译通过参数指定的模块，例如mmm dalvik/dexdump
  44.               To limit the modules being built use the syntax: mmm dir/:target1,target2.
  45.               要限制正在构建的模块，请使用以下语法：mmm dir/：target1、target2
  47. - mma:        Same as 'mm'   跟 mm 一样
  48. - mmma:       Same as 'mmm'  跟  mmm 一样
  49. - provision:  Flash device with all required partitions. Options will be passed on to         
  50.               fastboot.
  51.               具有所有必需分区的闪存设备。选项将传递给 fastboot。
  52. - cgrep:      Greps on all local C/C++ files.
  53.               对所有本地 C/C++ 文件进行 Greps
  54.               查询当前目录及子目录下所有符合查询条件的C文件（*.c, *.cc, *.cpp, *.h）
  56. - ggrep:      Greps on all local Gradle files.
  57.               对所有本地 Gradle 文件进行 Greps。
  58. - gogrep:     Greps on all local Go files.
  59.               对所有本地 Go 文件进行 Greps。
  60. - jgrep:      Greps on all local Java files.
  61.               对所有本地 Java 文件进行 Greps。
  62.               查询当前目录及子目录下所有符合查询条件的JAVA文件（*.java）
  64. - ktgrep:     Greps on all local Kotlin files.
  65.               对所有本地 kotlin 文件进行 Greps。
  66. - resgrep:    Greps on all local res/*.xml files.
  67.               对所有本地 res/*.xml 文件进行 Greps。
  68.               查询当前目录及子目录下所有资源相关的文件（*.xml）
  70. - mangrep:    Greps on all local AndroidManifest.xml files.
  71.               对所有本地AndroidManifest.xml 文件进行 Greps。
  72. - mgrep:      Greps on all local Makefiles and *.bp files.
  73.               对所有本地 Makefile 和 *.bp 文件进行 Greps。
  74. - owngrep:    Greps on all local OWNERS files.
  75.               对所有本地 OWNERS 文件进行 Greps。
  76. - rsgrep:     Greps on all local Rust files.
  77.               对所有本地 Rust 文件进行 Greps。
  78. - sepgrep:    Greps on all local sepolicy files.
  79.               对所有本地 sepolicy 文件进行 Greps。
  80. - sgrep:      Greps on all local source files.
  81.               对所有本地源文件进行 Greps。
  82. - godir:      Go to the directory containing a file.
  83.               转到包含文件的目录。
  84. - allmod:     List all modules.
  85.               列出所有模块
  86. - gomod:      Go to the directory containing a module.
  87.               转到包含模块的目录。
  88. - pathmod:    Get the directory containing a module.
  89.               获取包含模块的目录。
  90. - outmod:     Gets the location of a module's installed outputs with a certain extension.
  91.               获取具有特定扩展名的模块已安装输出的位置。
  92. - dirmods:    Gets the modules defined in a given directory.
  93.               获取给定目录中定义的模块。
  94. - installmod: Adb installs a module's built APK.
  95.               Adb 安装模块的构建 APK。
  96. - refreshmod: Refresh list of modules for allmod/gomod/pathmod/outmod/installmod.
  97.               刷新 allmod/gomod/pathmod/outmod/installmod 的模块列表。
  98. - syswrite:   Remount partitions (e.g. system.img) as writable, rebooting if necessary.
  99.               将分区（例如 system.img）重新挂载为可写，必要时重新启动。
  101. Environment options:
  102. 环境选项
  103. - SANITIZE_HOST: Set to 'address' to use ASAN for all host modules.
  104.   SANITIZE_HOST：设置为“地址”以对所有主机模块使用 ASAN。
  105. - ANDROID_QUIET_BUILD: set to 'true' to display only the essential messages.
  106.   ANDROID_QUIET_BUILD：设置为“true”以仅显示基本消息。
  108. Look at the source to view more functions. The complete list is:
  109. 查看源代码以查看更多功能。完整列表是
  110. EOF
  111.     local T=$(gettop)
  112.     local A=""
  113.     local i
  114.     for i in `cat $T/build/envsetup.sh | sed -n "/^[[:blank:]]*function /s/function \([a-z_]*\).*/\1/p" | sort | uniq`; do
  115.       A="$A $i"
  116.     done
  117.     echo $A
  118. }
  119.  
  120. # Get all the build variables needed by this script in a single call to the build system.
  121. # 在对构建系统的一次调用中获取此脚本所需的所有构建变量。
  122. function build_build_var_cache()
  123. {
  124.     local T=$(gettop)
  125.     # Grep out the variable names from the script.
  126.     # 从脚本中找出变量名
  127.     cached_vars=(`cat $T/build/envsetup.sh | tr '()' '  ' | awk '{for(i=1;i<=NF;i++) if($i~/get_build_var/) print $(i+1)}' | sort -u | tr '\n' ' '`)
  128.     cached_abs_vars=(`cat $T/build/envsetup.sh | tr '()' '  ' | awk '{for(i=1;i<=NF;i++) if($i~/get_abs_build_var/) print $(i+1)}' | sort -u | tr '\n' ' '`)
  129.     # Call the build system to dump the "<val>=<value>" pairs as a shell script.
  130.     # 调用构建系统将“<val>=<value>”对转储为 shell 脚本。
  131.     build_dicts_script=`\builtin cd $T; build/soong/soong_ui.bash --dumpvars-mode \
  132.                         --vars="${cached_vars[*]}" \
  133.                         --abs-vars="${cached_abs_vars[*]}" \
  134.                         --var-prefix=var_cache_ \
  135.                         --abs-var-prefix=abs_var_cache_`
  136.     local ret=$?
  137.     if [ $ret -ne 0 ]
  138.     then
  139.         unset build_dicts_script
  140.         return $ret
  141.     fi
  142.     # Execute the script to store the "<val>=<value>" pairs as shell variables.
  143.     # 执行脚本以将“<val>=<value>”对存储为 shell 变量。
  144.     eval "$build_dicts_script"
  145.     ret=$?
  146.     unset build_dicts_script
  147.     if [ $ret -ne 0 ]
  148.     then
  149.         return $ret
  150.     fi
  151.     BUILD_VAR_CACHE_READY="true"
  152. }
  153.  
  154. # Delete the build var cache, so that we can still call into the build system
  155. # to get build variables not listed in this script.
  156. # 删除build var缓存，这样我们仍然可以调用build系统来获取这个脚本中没有列出的构建变量。
  157. function destroy_build_var_cache()
  158. {
  159.     unset BUILD_VAR_CACHE_READY
  160.     local v
  161.     for v in $cached_vars; do
  162.       unset var_cache_$v
  163.     done
  164.     unset cached_vars
  165.     for v in $cached_abs_vars; do
  166.       unset abs_var_cache_$v
  167.     done
  168.     unset cached_abs_vars
  169. }
  170.  
  171. # Get the value of a build variable as an absolute path.
  172. # 获取构建变量的值作为绝对路径。
  173. function get_abs_build_var()
  174. {
  175.     if [ "$BUILD_VAR_CACHE_READY" = "true" ]
  176.     then
  177.         eval "echo \"\${abs_var_cache_$1}\""
  178.         return
  179.     fi
  180.  
  181.     local T=$(gettop)
  182.     if [ ! "$T" ]; then
  183.         echo "Couldn't locate the top of the tree.  Try setting TOP." >&2
  184.         return
  185.     fi
  186.     (\cd $T; build/soong/soong_ui.bash --dumpvar-mode --abs $1)
  187. }
  188.  
  189. # Get the exact value of a build variable.
  190. # 获取构建变量的确切值。
  191. function get_build_var()
  192. {
  193.     if [ "$BUILD_VAR_CACHE_READY" = "true" ]
  194.     then
  195.         eval "echo \"\${var_cache_$1}\""
  196.         return 0
  197.     fi
  198.  
  199.     local T=$(gettop)
  200.     if [ ! "$T" ]; then
  201.         echo "Couldn't locate the top of the tree.  Try setting TOP." >&2
  202.         return 1
  203.     fi
  204.     (\cd $T; build/soong/soong_ui.bash --dumpvar-mode $1)
  205. }
  206.  
  207. # check to see if the supplied product is one we can build
  208. # 检查提供的产品是否是我们可以build
  209. function check_product()
  210. {
  211.     local T=$(gettop)
  212.     if [ ! "$T" ]; then
  213.         echo "Couldn't locate the top of the tree.  Try setting TOP." >&2
  214.         return
  215.     fi
  216.         TARGET_PRODUCT=$1 \
  217.         TARGET_BUILD_VARIANT= \
  218.         TARGET_BUILD_TYPE= \
  219.         TARGET_BUILD_APPS= \
  220.         get_build_var TARGET_DEVICE > /dev/null
  221.     # hide successful answers, but allow the errors to show
  222. }
  223.  
  224. VARIANT_CHOICES=(user userdebug eng)
  225.  
  226. # check to see if the supplied variant is valid
  227. # 检查提供的变体是否有效
  228. function check_variant()
  229. {
  230.     local v
  231.     for v in ${VARIANT_CHOICES[@]}
  232.     do
  233.         if [ "$v" = "$1" ]
  234.         then
  235.             return 0
  236.         fi
  237.     done
  238.     return 1
  239. }
  240.  
  241. function setpaths()
  242. {
  243.     local T=$(gettop)
  244.     if [ ! "$T" ]; then
  245.         echo "Couldn't locate the top of the tree.  Try setting TOP."
  246.         return
  247.     fi
  248.  
  249.     ##################################################################
  250.     #                                                                #
  251.     #              Read me before you modify this code               #
  252.     #                                                                #
  253.     #   This function sets ANDROID_BUILD_PATHS to what it is adding  #
  254.     #   to PATH, and the next time it is run, it removes that from   #
  255.     #   PATH.  This is required so lunch can be run more than once   #
  256.     #   and still have working paths.                                #
  257.     #                                                                #
  258.     ##################################################################
  259.  
  260.     # Note: on windows/cygwin, ANDROID_BUILD_PATHS will contain spaces
  261.     # due to "C:\Program Files" being in the path.
  262.  
  263.     # out with the old
  264.     if [ -n "$ANDROID_BUILD_PATHS" ] ; then
  265.         export PATH=${PATH/$ANDROID_BUILD_PATHS/}
  266.     fi
  267.     if [ -n "$ANDROID_PRE_BUILD_PATHS" ] ; then
  268.         export PATH=${PATH/$ANDROID_PRE_BUILD_PATHS/}
  269.         # strip leading ':', if any
  270.         export PATH=${PATH/:%/}
  271.     fi
  272.  
  273.     # and in with the new
  274.     local prebuiltdir=$(getprebuilt)
  275.     local gccprebuiltdir=$(get_abs_build_var ANDROID_GCC_PREBUILTS)
  276.  
  277.     # defined in core/config.mk
  278.     local targetgccversion=$(get_build_var TARGET_GCC_VERSION)
  279.     local targetgccversion2=$(get_build_var 2ND_TARGET_GCC_VERSION)
  280.     export TARGET_GCC_VERSION=$targetgccversion
  281.  
  282.     # The gcc toolchain does not exists for windows/cygwin. In this case, do not reference it.
  283.     export ANDROID_TOOLCHAIN=
  284.     export ANDROID_TOOLCHAIN_2ND_ARCH=
  285.     local ARCH=$(get_build_var TARGET_ARCH)
  286.     local toolchaindir toolchaindir2=
  287.     case $ARCH in
  288.         x86) toolchaindir=x86/x86_64-linux-android-$targetgccversion/bin
  289.             ;;
  290.         x86_64) toolchaindir=x86/x86_64-linux-android-$targetgccversion/bin
  291.             ;;
  292.         arm) toolchaindir=arm/arm-linux-androideabi-$targetgccversion/bin
  293.             ;;
  294.         arm64) toolchaindir=aarch64/aarch64-linux-android-$targetgccversion/bin;
  295.                toolchaindir2=arm/arm-linux-androideabi-$targetgccversion2/bin
  296.             ;;
  297.         *)
  298.             echo "Can't find toolchain for unknown architecture: $ARCH"
  299.             toolchaindir=xxxxxxxxx
  300.             ;;
  301.     esac
  302.     if [ -d "$gccprebuiltdir/$toolchaindir" ]; then
  303.         export ANDROID_TOOLCHAIN=$gccprebuiltdir/$toolchaindir
  304.     fi
  305.  
  306.     if [ "$toolchaindir2" -a -d "$gccprebuiltdir/$toolchaindir2" ]; then
  307.         export ANDROID_TOOLCHAIN_2ND_ARCH=$gccprebuiltdir/$toolchaindir2
  308.     fi
  309.  
  310.     export ANDROID_DEV_SCRIPTS=$T/development/scripts:$T/prebuilts/devtools/tools:$T/external/selinux/prebuilts/bin
  311.  
  312.     # add kernel specific binaries
  313.     case $(uname -s) in
  314.         Linux)
  315.             export ANDROID_DEV_SCRIPTS=$ANDROID_DEV_SCRIPTS:$T/prebuilts/misc/linux-x86/dtc:$T/prebuilts/misc/linux-x86/libufdt
  316.             ;;
  317.         *)
  318.             ;;
  319.     esac
  320.  
  321.     ANDROID_BUILD_PATHS=$(get_build_var ANDROID_BUILD_PATHS):$ANDROID_TOOLCHAIN
  322.     if [ -n "$ANDROID_TOOLCHAIN_2ND_ARCH" ]; then
  323.         ANDROID_BUILD_PATHS=$ANDROID_BUILD_PATHS:$ANDROID_TOOLCHAIN_2ND_ARCH
  324.     fi
  325.     ANDROID_BUILD_PATHS=$ANDROID_BUILD_PATHS:$ANDROID_DEV_SCRIPTS
  326.  
  327.     # Append llvm binutils prebuilts path to ANDROID_BUILD_PATHS.
  328.     local ANDROID_LLVM_BINUTILS=$(get_abs_build_var ANDROID_CLANG_PREBUILTS)/llvm-binutils-stable
  329.     ANDROID_BUILD_PATHS=$ANDROID_BUILD_PATHS:$ANDROID_LLVM_BINUTILS
  330.  
  331.     # Set up ASAN_SYMBOLIZER_PATH for SANITIZE_HOST=address builds.
  332.     export ASAN_SYMBOLIZER_PATH=$ANDROID_LLVM_BINUTILS/llvm-symbolizer
  333.  
  334.     # If prebuilts/android-emulator/<system>/ exists, prepend it to our PATH
  335.     # to ensure that the corresponding 'emulator' binaries are used.
  336.     case $(uname -s) in
  337.         Darwin)
  338.             ANDROID_EMULATOR_PREBUILTS=$T/prebuilts/android-emulator/darwin-x86_64
  339.             ;;
  340.         Linux)
  341.             ANDROID_EMULATOR_PREBUILTS=$T/prebuilts/android-emulator/linux-x86_64
  342.             ;;
  343.         *)
  344.             ANDROID_EMULATOR_PREBUILTS=
  345.             ;;
  346.     esac
  347.     if [ -n "$ANDROID_EMULATOR_PREBUILTS" -a -d "$ANDROID_EMULATOR_PREBUILTS" ]; then
  348.         ANDROID_BUILD_PATHS=$ANDROID_BUILD_PATHS:$ANDROID_EMULATOR_PREBUILTS
  349.         export ANDROID_EMULATOR_PREBUILTS
  350.     fi
  351.  
  352.     # Append asuite prebuilts path to ANDROID_BUILD_PATHS.
  353.     local os_arch=$(get_build_var HOST_PREBUILT_TAG)
  354.     local ACLOUD_PATH="$T/prebuilts/asuite/acloud/$os_arch"
  355.     local AIDEGEN_PATH="$T/prebuilts/asuite/aidegen/$os_arch"
  356.     local ATEST_PATH="$T/prebuilts/asuite/atest/$os_arch"
  357.     export ANDROID_BUILD_PATHS=$ANDROID_BUILD_PATHS:$ACLOUD_PATH:$AIDEGEN_PATH:$ATEST_PATH:
  358.  
  359.     export PATH=$ANDROID_BUILD_PATHS$PATH
  360.  
  361.     # out with the duplicate old
  362.     if [ -n $ANDROID_PYTHONPATH ]; then
  363.         export PYTHONPATH=${PYTHONPATH//$ANDROID_PYTHONPATH/}
  364.     fi
  365.     # and in with the new
  366.     export ANDROID_PYTHONPATH=$T/development/python-packages:
  367.     if [ -n $VENDOR_PYTHONPATH  ]; then
  368.         ANDROID_PYTHONPATH=$ANDROID_PYTHONPATH$VENDOR_PYTHONPATH
  369.     fi
  370.     export PYTHONPATH=$ANDROID_PYTHONPATH$PYTHONPATH
  371.  
  372.     export ANDROID_JAVA_HOME=$(get_abs_build_var ANDROID_JAVA_HOME)
  373.     export JAVA_HOME=$ANDROID_JAVA_HOME
  374.     export ANDROID_JAVA_TOOLCHAIN=$(get_abs_build_var ANDROID_JAVA_TOOLCHAIN)
  375.     export ANDROID_PRE_BUILD_PATHS=$ANDROID_JAVA_TOOLCHAIN:
  376.     export PATH=$ANDROID_PRE_BUILD_PATHS$PATH
  377.  
  378.     unset ANDROID_PRODUCT_OUT
  379.     export ANDROID_PRODUCT_OUT=$(get_abs_build_var PRODUCT_OUT)
  380.     export OUT=$ANDROID_PRODUCT_OUT
  381.  
  382.     unset ANDROID_HOST_OUT
  383.     export ANDROID_HOST_OUT=$(get_abs_build_var HOST_OUT)
  384.  
  385.     unset ANDROID_SOONG_HOST_OUT
  386.     export ANDROID_SOONG_HOST_OUT=$(get_abs_build_var SOONG_HOST_OUT)
  387.  
  388.     unset ANDROID_HOST_OUT_TESTCASES
  389.     export ANDROID_HOST_OUT_TESTCASES=$(get_abs_build_var HOST_OUT_TESTCASES)
  390.  
  391.     unset ANDROID_TARGET_OUT_TESTCASES
  392.     export ANDROID_TARGET_OUT_TESTCASES=$(get_abs_build_var TARGET_OUT_TESTCASES)
  393.  
  394.     # needed for building linux on MacOS
  395.     # TODO: fix the path
  396.     #export HOST_EXTRACFLAGS="-I "$T/system/kernel_headers/host_include
  397. }
  398.  
  399. function bazel()
  400. {
  401.     local T="$(gettop)"
  402.     if [ ! "$T" ]; then
  403.         echo "Couldn't locate the top of the tree.  Try setting TOP."
  404.         return
  405.     fi
  406.  
  407.     if which bazel &>/dev/null; then
  408.         >&2 echo "NOTE: bazel() function sourced from envsetup.sh is being used instead of $(which bazel)"
  409.         >&2 echo
  410.     fi
  411.  
  412.     "$T/tools/bazel" "$@"
  413. }
  414.  
  415. function printconfig()
  416. {
  417.     local T=$(gettop)
  418.     if [ ! "$T" ]; then
  419.         echo "Couldn't locate the top of the tree.  Try setting TOP." >&2
  420.         return
  421.     fi
  422.     get_build_var report_config
  423. }
  424.  
  425. function set_stuff_for_environment()
  426. {
  427.     setpaths
  428.     set_sequence_number
  429.  
  430.     export ANDROID_BUILD_TOP=$(gettop)
  431.     # With this environment variable new GCC can apply colors to warnings/errors
  432.     export GCC_COLORS='error=01;31:warning=01;35:note=01;36:caret=01;32:locus=01:quote=01'
  433. }
  434.  
  435. function set_sequence_number()
  436. {
  437.     export BUILD_ENV_SEQUENCE_NUMBER=13
  438. }
  439.  
  440. # Takes a command name, and check if it's in ENVSETUP_NO_COMPLETION or not.
  441. function should_add_completion() {
  442.     local cmd="$(basename $1| sed 's/_completion//' |sed 's/\.\(.*\)*sh$//')"
  443.     case :"$ENVSETUP_NO_COMPLETION": in
  444.         *:"$cmd":*)
  445.             return 1
  446.             ;;
  447.     esac
  448.     return 0
  449. }
  450.  
  451. function addcompletions()
  452. {
  453.     local f=
  454.  
  455.     # Keep us from trying to run in something that's neither bash nor zsh.
  456.     if [ -z "$BASH_VERSION" -a -z "$ZSH_VERSION" ]; then
  457.         return
  458.     fi
  459.  
  460.     # Keep us from trying to run in bash that's too old.
  461.     if [ -n "$BASH_VERSION" -a ${BASH_VERSINFO[0]} -lt 3 ]; then
  462.         return
  463.     fi
  464.  
  465.     local completion_files=(
  466.       system/core/adb/adb.bash
  467.       system/core/fastboot/fastboot.bash
  468.       tools/asuite/asuite.sh
  469.     )
  470.     # Completion can be disabled selectively to allow users to use non-standard completion.
  471.     # e.g.
  472.     # ENVSETUP_NO_COMPLETION=adb # -> disable adb completion
  473.     # ENVSETUP_NO_COMPLETION=adb:bit # -> disable adb and bit completion
  474.     for f in ${completion_files[*]}; do
  475.         if [ -f "$f" ] && should_add_completion "$f"; then
  476.             . $f
  477.         fi
  478.     done
  479.  
  480.     if should_add_completion bit ; then
  481.         complete -C "bit --tab" bit
  482.     fi
  483.     if [ -z "$ZSH_VERSION" ]; then
  484.         # Doesn't work in zsh.
  485.         complete -o nospace -F _croot croot
  486.     fi
  487.     complete -F _lunch lunch
  488.  
  489.     complete -F _complete_android_module_names pathmod
  490.     complete -F _complete_android_module_names gomod
  491.     complete -F _complete_android_module_names outmod
  492.     complete -F _complete_android_module_names installmod
  493.     complete -F _complete_android_module_names m
  494. }
  495.  
  496. function choosetype()
  497. {
  498.     echo "Build type choices are:"
  499.     echo "     1. release"
  500.     echo "     2. debug"
  501.     echo
  502.  
  503.     local DEFAULT_NUM DEFAULT_VALUE
  504.     DEFAULT_NUM=1
  505.     DEFAULT_VALUE=release
  506.  
  507.     export TARGET_BUILD_TYPE=
  508.     local ANSWER
  509.     while [ -z $TARGET_BUILD_TYPE ]
  510.     do
  511.         echo -n "Which would you like? ["$DEFAULT_NUM"] "
  512.         if [ -z "$1" ] ; then
  513.             read ANSWER
  514.         else
  515.             echo $1
  516.             ANSWER=$1
  517.         fi
  518.         case $ANSWER in
  519.         "")
  520.             export TARGET_BUILD_TYPE=$DEFAULT_VALUE
  521.             ;;
  522.         1)
  523.             export TARGET_BUILD_TYPE=release
  524.             ;;
  525.         release)
  526.             export TARGET_BUILD_TYPE=release
  527.             ;;
  528.         2)
  529.             export TARGET_BUILD_TYPE=debug
  530.             ;;
  531.         debug)
  532.             export TARGET_BUILD_TYPE=debug
  533.             ;;
  534.         *)
  535.             echo
  536.             echo "I didn't understand your response.  Please try again."
  537.             echo
  538.             ;;
  539.         esac
  540.         if [ -n "$1" ] ; then
  541.             break
  542.         fi
  543.     done
  544.  
  545.     build_build_var_cache
  546.     set_stuff_for_environment
  547.     destroy_build_var_cache
  548. }
  549.  
  550. #
  551. # This function isn't really right:  It chooses a TARGET_PRODUCT
  552. # based on the list of boards.  Usually, that gets you something
  553. # that kinda works with a generic product, but really, you should
  554. # pick a product by name.
  555. #
  556. function chooseproduct()
  557. {
  558.     local default_value
  559.     if [ "x$TARGET_PRODUCT" != x ] ; then
  560.         default_value=$TARGET_PRODUCT
  561.     else
  562.         default_value=aosp_arm
  563.     fi
  564.  
  565.     export TARGET_BUILD_APPS=
  566.     export TARGET_PRODUCT=
  567.     local ANSWER
  568.     while [ -z "$TARGET_PRODUCT" ]
  569.     do
  570.         echo -n "Which product would you like? [$default_value] "
  571.         if [ -z "$1" ] ; then
  572.             read ANSWER
  573.         else
  574.             echo $1
  575.             ANSWER=$1
  576.         fi
  577.  
  578.         if [ -z "$ANSWER" ] ; then
  579.             export TARGET_PRODUCT=$default_value
  580.         else
  581.             if check_product $ANSWER
  582.             then
  583.                 export TARGET_PRODUCT=$ANSWER
  584.             else
  585.                 echo "** Not a valid product: $ANSWER"
  586.             fi
  587.         fi
  588.         if [ -n "$1" ] ; then
  589.             break
  590.         fi
  591.     done
  592.  
  593.     build_build_var_cache
  594.     set_stuff_for_environment
  595.     destroy_build_var_cache
  596. }
  597.  
  598. function choosevariant()
  599. {
  600.     echo "Variant choices are:"
  601.     local index=1
  602.     local v
  603.     for v in ${VARIANT_CHOICES[@]}
  604.     do
  605.         # The product name is the name of the directory containing
  606.         # the makefile we found, above.
  607.         echo "     $index. $v"
  608.         index=$(($index+1))
  609.     done
  610.  
  611.     local default_value=eng
  612.     local ANSWER
  613.  
  614.     export TARGET_BUILD_VARIANT=
  615.     while [ -z "$TARGET_BUILD_VARIANT" ]
  616.     do
  617.         echo -n "Which would you like? [$default_value] "
  618.         if [ -z "$1" ] ; then
  619.             read ANSWER
  620.         else
  621.             echo $1
  622.             ANSWER=$1
  623.         fi
  624.  
  625.         if [ -z "$ANSWER" ] ; then
  626.             export TARGET_BUILD_VARIANT=$default_value
  627.         elif (echo -n $ANSWER | grep -q -e "^[0-9][0-9]*$") ; then
  628.             if [ "$ANSWER" -le "${#VARIANT_CHOICES[@]}" ] ; then
  629.                 export TARGET_BUILD_VARIANT=${VARIANT_CHOICES[@]:$(($ANSWER-1)):1}
  630.             fi
  631.         else
  632.             if check_variant $ANSWER
  633.             then
  634.                 export TARGET_BUILD_VARIANT=$ANSWER
  635.             else
  636.                 echo "** Not a valid variant: $ANSWER"
  637.             fi
  638.         fi
  639.         if [ -n "$1" ] ; then
  640.             break
  641.         fi
  642.     done
  643. }
  644.  
  645. function choosecombo()
  646. {
  647.     choosetype $1
  648.  
  649.     echo
  650.     echo
  651.     chooseproduct $2
  652.  
  653.     echo
  654.     echo
  655.     choosevariant $3
  656.  
  657.     echo
  658.     build_build_var_cache
  659.     set_stuff_for_environment
  660.     printconfig
  661.     destroy_build_var_cache
  662. }
  663.  
  664. function add_lunch_combo()
  665. {
  666.     if [ -n "$ZSH_VERSION" ]; then
  667.         echo -n "${funcfiletrace[1]}: "
  668.     else
  669.         echo -n "${BASH_SOURCE[1]}:${BASH_LINENO[0]}: "
  670.     fi
  671.     echo "add_lunch_combo is obsolete. Use COMMON_LUNCH_CHOICES in your AndroidProducts.mk instead."
  672. }
  673.  
  674. function print_lunch_menu()
  675. {
  676.     local uname=$(uname)
  677.     local choices
  678.     choices=$(TARGET_BUILD_APPS= TARGET_PRODUCT= TARGET_BUILD_VARIANT= get_build_var COMMON_LUNCH_CHOICES 2>/dev/null)
  679.     local ret=$?
  680.  
  681.     echo
  682.     echo "You're building on" $uname
  683.     echo
  684.  
  685.     if [ $ret -ne 0 ]
  686.     then
  687.         echo "Warning: Cannot display lunch menu."
  688.         echo
  689.         echo "Note: You can invoke lunch with an explicit target:"
  690.         echo
  691.         echo "  usage: lunch [target]" >&2
  692.         echo
  693.         return
  694.     fi
  695.  
  696.     echo "Lunch menu... pick a combo:"
  697.  
  698.     local i=1
  699.     local choice
  700.     for choice in $(echo $choices)
  701.     do
  702.         echo "     $i. $choice"
  703.         i=$(($i+1))
  704.     done
  705.  
  706.     echo
  707. }
  708.  
  709. function lunch()
  710. {
  711.     local answer
  712.  
  713.     if [[ $# -gt 1 ]]; then
  714.         echo "usage: lunch [target]" >&2
  715.         return 1
  716.     fi
  717.  
  718.     if [ "$1" ]; then
  719.         answer=$1
  720.     else
  721.         print_lunch_menu
  722.         echo -n "Which would you like? [aosp_arm-eng] "
  723.         read answer
  724.     fi
  725.  
  726.     local selection=
  727.  
  728.     if [ -z "$answer" ]
  729.     then
  730.         selection=aosp_arm-eng
  731.     elif (echo -n $answer | grep -q -e "^[0-9][0-9]*$")
  732.     then
  733.         local choices=($(TARGET_BUILD_APPS= get_build_var COMMON_LUNCH_CHOICES))
  734.         if [ $answer -le ${#choices[@]} ]
  735.         then
  736.             # array in zsh starts from 1 instead of 0.
  737.             if [ -n "$ZSH_VERSION" ]
  738.             then
  739.                 selection=${choices[$(($answer))]}
  740.             else
  741.                 selection=${choices[$(($answer-1))]}
  742.             fi
  743.         fi
  744.     else
  745.         selection=$answer
  746.     fi
  747.  
  748.     export TARGET_BUILD_APPS=
  749.  
  750.     local product variant_and_version variant version
  751.     product=${selection%%-*} # Trim everything after first dash
  752.     variant_and_version=${selection#*-} # Trim everything up to first dash
  753.     if [ "$variant_and_version" != "$selection" ]; then
  754.         variant=${variant_and_version%%-*}
  755.         if [ "$variant" != "$variant_and_version" ]; then
  756.             version=${variant_and_version#*-}
  757.         fi
  758.     fi
  759.  
  760.     if [ -z "$product" ]
  761.     then
  762.         echo
  763.         echo "Invalid lunch combo: $selection"
  764.         return 1
  765.     fi
  766.  
  767.     TARGET_PRODUCT=$product \
  768.     TARGET_BUILD_VARIANT=$variant \
  769.     TARGET_PLATFORM_VERSION=$version \
  770.     build_build_var_cache
  771.     if [ $? -ne 0 ]
  772.     then
  773.         return 1
  774.     fi
  775.     export TARGET_PRODUCT=$(get_build_var TARGET_PRODUCT)
  776.     export TARGET_BUILD_VARIANT=$(get_build_var TARGET_BUILD_VARIANT)
  777.     if [ -n "$version" ]; then
  778.       export TARGET_PLATFORM_VERSION=$(get_build_var TARGET_PLATFORM_VERSION)
  779.     else
  780.       unset TARGET_PLATFORM_VERSION
  781.     fi
  782.     export TARGET_BUILD_TYPE=release
  783.  
  784.     [[ -n "${ANDROID_QUIET_BUILD:-}" ]] || echo
  785.  
  786.     set_stuff_for_environment
  787.     [[ -n "${ANDROID_QUIET_BUILD:-}" ]] || printconfig
  788.     destroy_build_var_cache
  789. }
  790.  
  791. unset COMMON_LUNCH_CHOICES_CACHE
  792. # Tab completion for lunch.
  793. function _lunch()
  794. {
  795.     local cur prev opts
  796.     COMPREPLY=()
  797.     cur="${COMP_WORDS[COMP_CWORD]}"
  798.     prev="${COMP_WORDS[COMP_CWORD-1]}"
  799.  
  800.     if [ -z "$COMMON_LUNCH_CHOICES_CACHE" ]; then
  801.         COMMON_LUNCH_CHOICES_CACHE=$(TARGET_BUILD_APPS= get_build_var COMMON_LUNCH_CHOICES)
  802.     fi
  803.  
  804.     COMPREPLY=( $(compgen -W "${COMMON_LUNCH_CHOICES_CACHE}" -- ${cur}) )
  805.     return 0
  806. }
  807.  
  808. # Configures the build to build unbundled apps.
  809. # Run tapas with one or more app names (from LOCAL_PACKAGE_NAME)
  810. function tapas()
  811. {
  812.     local showHelp="$(echo $* | xargs -n 1 echo | \grep -E '^(help)$' | xargs)"
  813.     local arch="$(echo $* | xargs -n 1 echo | \grep -E '^(arm|x86|arm64|x86_64)$' | xargs)"
  814.     local variant="$(echo $* | xargs -n 1 echo | \grep -E '^(user|userdebug|eng)$' | xargs)"
  815.     local density="$(echo $* | xargs -n 1 echo | \grep -E '^(ldpi|mdpi|tvdpi|hdpi|xhdpi|xxhdpi|xxxhdpi|alldpi)$' | xargs)"
  816.     local apps="$(echo $* | xargs -n 1 echo | \grep -E -v '^(user|userdebug|eng|arm|x86|arm64|x86_64|ldpi|mdpi|tvdpi|hdpi|xhdpi|xxhdpi|xxxhdpi|alldpi)$' | xargs)"
  817.  
  818.     if [ "$showHelp" != "" ]; then
  819.       $(gettop)/build/make/tapasHelp.sh
  820.       return
  821.     fi
  822.  
  823.     if [ $(echo $arch | wc -w) -gt 1 ]; then
  824.         echo "tapas: Error: Multiple build archs supplied: $arch"
  825.         return
  826.     fi
  827.     if [ $(echo $variant | wc -w) -gt 1 ]; then
  828.         echo "tapas: Error: Multiple build variants supplied: $variant"
  829.         return
  830.     fi
  831.     if [ $(echo $density | wc -w) -gt 1 ]; then
  832.         echo "tapas: Error: Multiple densities supplied: $density"
  833.         return
  834.     fi
  835.  
  836.     local product=aosp_arm
  837.     case $arch in
  838.       x86)    product=aosp_x86;;
  839.       arm64)  product=aosp_arm64;;
  840.       x86_64) product=aosp_x86_64;;
  841.     esac
  842.     if [ -z "$variant" ]; then
  843.         variant=eng
  844.     fi
  845.     if [ -z "$apps" ]; then
  846.         apps=all
  847.     fi
  848.     if [ -z "$density" ]; then
  849.         density=alldpi
  850.     fi
  851.  
  852.     export TARGET_PRODUCT=$product
  853.     export TARGET_BUILD_VARIANT=$variant
  854.     export TARGET_BUILD_DENSITY=$density
  855.     export TARGET_BUILD_TYPE=release
  856.     export TARGET_BUILD_APPS=$apps
  857.  
  858.     build_build_var_cache
  859.     set_stuff_for_environment
  860.     printconfig
  861.     destroy_build_var_cache
  862. }
  863.  
  864. # Configures the build to build unbundled Android modules (APEXes).
  865. # Run banchan with one or more module names (from apex{} modules).
  866. function banchan()
  867. {
  868.     local showHelp="$(echo $* | xargs -n 1 echo | \grep -E '^(help)$' | xargs)"
  869.     local product="$(echo $* | xargs -n 1 echo | \grep -E '^(.*_)?(arm|x86|arm64|x86_64)$' | xargs)"
  870.     local variant="$(echo $* | xargs -n 1 echo | \grep -E '^(user|userdebug|eng)$' | xargs)"
  871.     local apps="$(echo $* | xargs -n 1 echo | \grep -E -v '^(user|userdebug|eng|(.*_)?(arm|x86|arm64|x86_64))$' | xargs)"
  872.  
  873.     if [ "$showHelp" != "" ]; then
  874.       $(gettop)/build/make/banchanHelp.sh
  875.       return
  876.     fi
  877.  
  878.     if [ -z "$product" ]; then
  879.         product=arm
  880.     elif [ $(echo $product | wc -w) -gt 1 ]; then
  881.         echo "banchan: Error: Multiple build archs or products supplied: $products"
  882.         return
  883.     fi
  884.     if [ $(echo $variant | wc -w) -gt 1 ]; then
  885.         echo "banchan: Error: Multiple build variants supplied: $variant"
  886.         return
  887.     fi
  888.     if [ -z "$apps" ]; then
  889.         echo "banchan: Error: No modules supplied"
  890.         return
  891.     fi
  892.  
  893.     case $product in
  894.       arm)    product=module_arm;;
  895.       x86)    product=module_x86;;
  896.       arm64)  product=module_arm64;;
  897.       x86_64) product=module_x86_64;;
  898.     esac
  899.     if [ -z "$variant" ]; then
  900.         variant=eng
  901.     fi
  902.  
  903.     export TARGET_PRODUCT=$product
  904.     export TARGET_BUILD_VARIANT=$variant
  905.     export TARGET_BUILD_DENSITY=alldpi
  906.     export TARGET_BUILD_TYPE=release
  907.  
  908.     # This setup currently uses TARGET_BUILD_APPS just like tapas, but the use
  909.     # case is different and it may diverge in the future.
  910.     export TARGET_BUILD_APPS=$apps
  911.  
  912.     build_build_var_cache
  913.     set_stuff_for_environment
  914.     printconfig
  915.     destroy_build_var_cache
  916. }
  917.  
  918. function gettop
  919. {
  920.     local TOPFILE=build/make/core/envsetup.mk
  921.     if [ -n "$TOP" -a -f "$TOP/$TOPFILE" ] ; then
  922.         # The following circumlocution ensures we remove symlinks from TOP.
  923.         (cd "$TOP"; PWD= /bin/pwd)
  924.     else
  925.         if [ -f $TOPFILE ] ; then
  926.             # The following circumlocution (repeated below as well) ensures
  927.             # that we record the true directory name and not one that is
  928.             # faked up with symlink names.
  929.             PWD= /bin/pwd
  930.         else
  931.             local HERE=$PWD
  932.             local T=
  933.             while [ \( ! \( -f $TOPFILE \) \) -a \( "$PWD" != "/" \) ]; do
  934.                 \cd ..
  935.                 T=`PWD= /bin/pwd -P`
  936.             done
  937.             \cd "$HERE"
  938.             if [ -f "$T/$TOPFILE" ]; then
  939.                 echo "$T"
  940.             fi
  941.         fi
  942.     fi
  943. }
  944.  
  945. function croot()
  946. {
  947.     local T=$(gettop)
  948.     if [ "$T" ]; then
  949.         if [ "$1" ]; then
  950.             \cd $(gettop)/$1
  951.         else
  952.             \cd $(gettop)
  953.         fi
  954.     else
  955.         echo "Couldn't locate the top of the tree.  Try setting TOP."
  956.     fi
  957. }
  958.  
  959. function _croot()
  960. {
  961.     local T=$(gettop)
  962.     if [ "$T" ]; then
  963.         local cur="${COMP_WORDS[COMP_CWORD]}"
  964.         k=0
  965.         for c in $(compgen -d ${T}/${cur}); do
  966.             COMPREPLY[k++]=${c#${T}/}/
  967.         done
  968.     fi
  969. }
  970.  
  971. function cproj()
  972. {
  973.     local TOPFILE=build/make/core/envsetup.mk
  974.     local HERE=$PWD
  975.     local T=
  976.     while [ \( ! \( -f $TOPFILE \) \) -a \( $PWD != "/" \) ]; do
  977.         T=$PWD
  978.         if [ -f "$T/Android.mk" ]; then
  979.             \cd $T
  980.             return
  981.         fi
  982.         \cd ..
  983.     done
  984.     \cd $HERE
  985.     echo "can't find Android.mk"
  986. }
  987.  
  988. # simplified version of ps; output in the form
  989. # <pid> <procname>
  990. function qpid() {
  991.     local prepend=''
  992.     local append=''
  993.     if [ "$1" = "--exact" ]; then
  994.         prepend=' '
  995.         append='$'
  996.         shift
  997.     elif [ "$1" = "--help" -o "$1" = "-h" ]; then
  998.         echo "usage: qpid [[--exact] <process name|pid>"
  999.         return 255
  1000.     fi
  1001.  
  1002.     local EXE="$1"
  1003.     if [ "$EXE" ] ; then
  1004.         qpid | \grep "$prepend$EXE$append"
  1005.     else
  1006.         adb shell ps \
  1007.             | tr -d '\r' \
  1008.             | sed -e 1d -e 's/^[^ ]* *\([0-9]*\).* \([^ ]*\)$/\1 \2/'
  1009.     fi
  1010. }
  1011.  
  1012. # syswrite - disable verity, reboot if needed, and remount image
  1013. #
  1014. # Easy way to make system.img/etc writable
  1015. function syswrite() {
  1016.   adb wait-for-device && adb root || return 1
  1017.   if [[ $(adb disable-verity | grep "reboot") ]]; then
  1018.       echo "rebooting"
  1019.       adb reboot && adb wait-for-device && adb root || return 1
  1020.   fi
  1021.   adb wait-for-device && adb remount || return 1
  1022. }
  1023.  
  1024. # coredump_setup - enable core dumps globally for any process
  1025. #                  that has the core-file-size limit set correctly
  1026. #
  1027. # NOTE: You must call also coredump_enable for a specific process
  1028. #       if its core-file-size limit is not set already.
  1029. # NOTE: Core dumps are written to ramdisk; they will not survive a reboot!
  1030.  
  1031. function coredump_setup()
  1032. {
  1033.     echo "Getting root...";
  1034.     adb root;
  1035.     adb wait-for-device;
  1036.  
  1037.     echo "Remounting root partition read-write...";
  1038.     adb shell mount -w -o remount -t rootfs rootfs;
  1039.     sleep 1;
  1040.     adb wait-for-device;
  1041.     adb shell mkdir -p /cores;
  1042.     adb shell mount -t tmpfs tmpfs /cores;
  1043.     adb shell chmod 0777 /cores;
  1044.  
  1045.     echo "Granting SELinux permission to dump in /cores...";
  1046.     adb shell restorecon -R /cores;
  1047.  
  1048.     echo "Set core pattern.";
  1049.     adb shell 'echo /cores/core.%p > /proc/sys/kernel/core_pattern';
  1050.  
  1051.     echo "Done."
  1052. }
  1053.  
  1054. # coredump_enable - enable core dumps for the specified process
  1055. # $1 = PID of process (e.g., $(pid mediaserver))
  1056. #
  1057. # NOTE: coredump_setup must have been called as well for a core
  1058. #       dump to actually be generated.
  1059.  
  1060. function coredump_enable()
  1061. {
  1062.     local PID=$1;
  1063.     if [ -z "$PID" ]; then
  1064.         printf "Expecting a PID!\n";
  1065.         return;
  1066.     fi;
  1067.     echo "Setting core limit for $PID to infinite...";
  1068.     adb shell /system/bin/ulimit -p $PID -c unlimited
  1069. }
  1070.  
  1071. # core - send SIGV and pull the core for process
  1072. # $1 = PID of process (e.g., $(pid mediaserver))
  1073. #
  1074. # NOTE: coredump_setup must be called once per boot for core dumps to be
  1075. #       enabled globally.
  1076.  
  1077. function core()
  1078. {
  1079.     local PID=$1;
  1080.  
  1081.     if [ -z "$PID" ]; then
  1082.         printf "Expecting a PID!\n";
  1083.         return;
  1084.     fi;
  1085.  
  1086.     local CORENAME=core.$PID;
  1087.     local COREPATH=/cores/$CORENAME;
  1088.     local SIG=SEGV;
  1089.  
  1090.     coredump_enable $1;
  1091.  
  1092.     local done=0;
  1093.     while [ $(adb shell "[ -d /proc/$PID ] && echo -n yes") ]; do
  1094.         printf "\tSending SIG%s to %d...\n" $SIG $PID;
  1095.         adb shell kill -$SIG $PID;
  1096.         sleep 1;
  1097.     done;
  1098.  
  1099.     adb shell "while [ ! -f $COREPATH ] ; do echo waiting for $COREPATH to be generated; sleep 1; done"
  1100.     echo "Done: core is under $COREPATH on device.";
  1101. }
  1102.  
  1103. # systemstack - dump the current stack trace of all threads in the system process
  1104. # to the usual ANR traces file
  1105. function systemstack()
  1106. {
  1107.     stacks system_server
  1108. }
  1109.  
  1110. # Read the ELF header from /proc/$PID/exe to determine if the process is
  1111. # 64-bit.
  1112. function is64bit()
  1113. {
  1114.     local PID="$1"
  1115.     if [ "$PID" ] ; then
  1116.         if [[ "$(adb shell cat /proc/$PID/exe | xxd -l 1 -s 4 -p)" -eq "02" ]] ; then
  1117.             echo "64"
  1118.         else
  1119.             echo ""
  1120.         fi
  1121.     else
  1122.         echo ""
  1123.     fi
  1124. }
  1125.  
  1126. case `uname -s` in
  1127.     Darwin)
  1128.         function sgrep()
  1129.         {
  1130.             find -E . -name .repo -prune -o -name .git -prune -o  -type f -iregex '.*\.(c|h|cc|cpp|hpp|S|java|kt|xml|sh|mk|aidl|vts|proto)' \
  1131.                 -exec grep --color -n "$@" {} +
  1132.         }
  1133.  
  1134.         ;;
  1135.     *)
  1136.         function sgrep()
  1137.         {
  1138.             find . -name .repo -prune -o -name .git -prune -o  -type f -iregex '.*\.\(c\|h\|cc\|cpp\|hpp\|S\|java\|kt\|xml\|sh\|mk\|aidl\|vts\|proto\)' \
  1139.                 -exec grep --color -n "$@" {} +
  1140.         }
  1141.         ;;
  1142. esac
  1143.  
  1144. function gettargetarch
  1145. {
  1146.     get_build_var TARGET_ARCH
  1147. }
  1148.  
  1149. function ggrep()
  1150. {
  1151.     find . -name .repo -prune -o -name .git -prune -o -name out -prune -o -type f -name "*\.gradle" \
  1152.         -exec grep --color -n "$@" {} +
  1153. }
  1154.  
  1155. function gogrep()
  1156. {
  1157.     find . -name .repo -prune -o -name .git -prune -o -name out -prune -o -type f -name "*\.go" \
  1158.         -exec grep --color -n "$@" {} +
  1159. }
  1160.  
  1161. function jgrep()
  1162. {
  1163.     find . -name .repo -prune -o -name .git -prune -o -name out -prune -o -type f -name "*\.java" \
  1164.         -exec grep --color -n "$@" {} +
  1165. }
  1166.  
  1167. function rsgrep()
  1168. {
  1169.     find . -name .repo -prune -o -name .git -prune -o -name out -prune -o -type f -name "*\.rs" \
  1170.         -exec grep --color -n "$@" {} +
  1171. }
  1172.  
  1173. function ktgrep()
  1174. {
  1175.     find . -name .repo -prune -o -name .git -prune -o -name out -prune -o -type f -name "*\.kt" \
  1176.         -exec grep --color -n "$@" {} +
  1177. }
  1178.  
  1179. function cgrep()
  1180. {
  1181.     find . -name .repo -prune -o -name .git -prune -o -name out -prune -o -type f \( -name '*.c' -o -name '*.cc' -o -name '*.cpp' -o -name '*.h' -o -name '*.hpp' \) \
  1182.         -exec grep --color -n "$@" {} +
  1183. }
  1184.  
  1185. function resgrep()
  1186. {
  1187.     local dir
  1188.     for dir in `find . -name .repo -prune -o -name .git -prune -o -name out -prune -o -name res -type d`; do
  1189.         find $dir -type f -name '*\.xml' -exec grep --color -n "$@" {} +
  1190.     done
  1191. }
  1192.  
  1193. function mangrep()
  1194. {
  1195.     find . -name .repo -prune -o -name .git -prune -o -path ./out -prune -o -type f -name 'AndroidManifest.xml' \
  1196.         -exec grep --color -n "$@" {} +
  1197. }
  1198.  
  1199. function owngrep()
  1200. {
  1201.     find . -name .repo -prune -o -name .git -prune -o -path ./out -prune -o -type f -name 'OWNERS' \
  1202.         -exec grep --color -n "$@" {} +
  1203. }
  1204.  
  1205. function sepgrep()
  1206. {
  1207.     find . -name .repo -prune -o -name .git -prune -o -path ./out -prune -o -name sepolicy -type d \
  1208.         -exec grep --color -n -r --exclude-dir=\.git "$@" {} +
  1209. }
  1210.  
  1211. function rcgrep()
  1212. {
  1213.     find . -name .repo -prune -o -name .git -prune -o -name out -prune -o -type f -name "*\.rc*" \
  1214.         -exec grep --color -n "$@" {} +
  1215. }
  1216.  
  1217. case `uname -s` in
  1218.     Darwin)
  1219.         function mgrep()
  1220.         {
  1221.             find -E . -name .repo -prune -o -name .git -prune -o -path ./out -prune -o \( -iregex '.*/(Makefile|Makefile\..*|.*\.make|.*\.mak|.*\.mk|.*\.bp)' -o -regex '(.*/)?(build|soong)/.*[^/]*\.go' \) -type f \
  1222.                 -exec grep --color -n "$@" {} +
  1223.         }
  1224.  
  1225.         function treegrep()
  1226.         {
  1227.             find -E . -name .repo -prune -o -name .git -prune -o -type f -iregex '.*\.(c|h|cpp|hpp|S|java|kt|xml)' \
  1228.                 -exec grep --color -n -i "$@" {} +
  1229.         }
  1230.  
  1231.         ;;
  1232.     *)
  1233.         function mgrep()
  1234.         {
  1235.             find . -name .repo -prune -o -name .git -prune -o -path ./out -prune -o \( -regextype posix-egrep -iregex '(.*\/Makefile|.*\/Makefile\..*|.*\.make|.*\.mak|.*\.mk|.*\.bp)' -o -regextype posix-extended -regex '(.*/)?(build|soong)/.*[^/]*\.go' \) -type f \
  1236.                 -exec grep --color -n "$@" {} +
  1237.         }
  1238.  
  1239.         function treegrep()
  1240.         {
  1241.             find . -name .repo -prune -o -name .git -prune -o -regextype posix-egrep -iregex '.*\.(c|h|cpp|hpp|S|java|kt|xml)' -type f \
  1242.                 -exec grep --color -n -i "$@" {} +
  1243.         }
  1244.  
  1245.         ;;
  1246. esac
  1247.  
  1248. function getprebuilt
  1249. {
  1250.     get_abs_build_var ANDROID_PREBUILTS
  1251. }
  1252.  
  1253. function tracedmdump()
  1254. {
  1255.     local T=$(gettop)
  1256.     if [ ! "$T" ]; then
  1257.         echo "Couldn't locate the top of the tree.  Try setting TOP."
  1258.         return
  1259.     fi
  1260.     local prebuiltdir=$(getprebuilt)
  1261.     local arch=$(gettargetarch)
  1262.     local KERNEL=$T/prebuilts/qemu-kernel/$arch/vmlinux-qemu
  1263.  
  1264.     local TRACE=$1
  1265.     if [ ! "$TRACE" ] ; then
  1266.         echo "usage:  tracedmdump  tracename"
  1267.         return
  1268.     fi
  1269.  
  1270.     if [ ! -r "$KERNEL" ] ; then
  1271.         echo "Error: cannot find kernel: '$KERNEL'"
  1272.         return
  1273.     fi
  1274.  
  1275.     local BASETRACE=$(basename $TRACE)
  1276.     if [ "$BASETRACE" = "$TRACE" ] ; then
  1277.         TRACE=$ANDROID_PRODUCT_OUT/traces/$TRACE
  1278.     fi
  1279.  
  1280.     echo "post-processing traces..."
  1281.     rm -f $TRACE/qtrace.dexlist
  1282.     post_trace $TRACE
  1283.     if [ $? -ne 0 ]; then
  1284.         echo "***"
  1285.         echo "*** Error: malformed trace.  Did you remember to exit the emulator?"
  1286.         echo "***"
  1287.         return
  1288.     fi
  1289.     echo "generating dexlist output..."
  1290.     /bin/ls $ANDROID_PRODUCT_OUT/system/framework/*.jar $ANDROID_PRODUCT_OUT/system/app/*.apk $ANDROID_PRODUCT_OUT/data/app/*.apk 2>/dev/null | xargs dexlist > $TRACE/qtrace.dexlist
  1291.     echo "generating dmtrace data..."
  1292.     q2dm -r $ANDROID_PRODUCT_OUT/symbols $TRACE $KERNEL $TRACE/dmtrace || return
  1293.     echo "generating html file..."
  1294.     dmtracedump -h $TRACE/dmtrace >| $TRACE/dmtrace.html || return
  1295.     echo "done, see $TRACE/dmtrace.html for details"
  1296.     echo "or run:"
  1297.     echo "    traceview $TRACE/dmtrace"
  1298. }
  1299.  
  1300. # communicate with a running device or emulator, set up necessary state,
  1301. # and run the hat command.
  1302. function runhat()
  1303. {
  1304.     # process standard adb options
  1305.     local adbTarget=""
  1306.     if [ "$1" = "-d" -o "$1" = "-e" ]; then
  1307.         adbTarget=$1
  1308.         shift 1
  1309.     elif [ "$1" = "-s" ]; then
  1310.         adbTarget="$1 $2"
  1311.         shift 2
  1312.     fi
  1313.     local adbOptions=${adbTarget}
  1314.     #echo adbOptions = ${adbOptions}
  1315.  
  1316.     # runhat options
  1317.     local targetPid=$1
  1318.  
  1319.     if [ "$targetPid" = "" ]; then
  1320.         echo "Usage: runhat [ -d | -e | -s serial ] target-pid"
  1321.         return
  1322.     fi
  1323.  
  1324.     # confirm hat is available
  1325.     if [ -z $(which hat) ]; then
  1326.         echo "hat is not available in this configuration."
  1327.         return
  1328.     fi
  1329.  
  1330.     # issue "am" command to cause the hprof dump
  1331.     local devFile=/data/local/tmp/hprof-$targetPid
  1332.     echo "Poking $targetPid and waiting for data..."
  1333.     echo "Storing data at $devFile"
  1334.     adb ${adbOptions} shell am dumpheap $targetPid $devFile
  1335.     echo "Press enter when logcat shows \"hprof: heap dump completed\""
  1336.     echo -n "> "
  1337.     read
  1338.  
  1339.     local localFile=/tmp/$$-hprof
  1340.  
  1341.     echo "Retrieving file $devFile..."
  1342.     adb ${adbOptions} pull $devFile $localFile
  1343.  
  1344.     adb ${adbOptions} shell rm $devFile
  1345.  
  1346.     echo "Running hat on $localFile"
  1347.     echo "View the output by pointing your browser at http://localhost:7000/"
  1348.     echo ""
  1349.     hat -JXmx512m $localFile
  1350. }
  1351.  
  1352. function getbugreports()
  1353. {
  1354.     local reports=(`adb shell ls /sdcard/bugreports | tr -d '\r'`)
  1355.  
  1356.     if [ ! "$reports" ]; then
  1357.         echo "Could not locate any bugreports."
  1358.         return
  1359.     fi
  1360.  
  1361.     local report
  1362.     for report in ${reports[@]}
  1363.     do
  1364.         echo "/sdcard/bugreports/${report}"
  1365.         adb pull /sdcard/bugreports/${report} ${report}
  1366.         gunzip ${report}
  1367.     done
  1368. }
  1369.  
  1370. function getsdcardpath()
  1371. {
  1372.     adb ${adbOptions} shell echo -n \$\{EXTERNAL_STORAGE\}
  1373. }
  1374.  
  1375. function getscreenshotpath()
  1376. {
  1377.     echo "$(getsdcardpath)/Pictures/Screenshots"
  1378. }
  1379.  
  1380. function getlastscreenshot()
  1381. {
  1382.     local screenshot_path=$(getscreenshotpath)
  1383.     local screenshot=`adb ${adbOptions} ls ${screenshot_path} | grep Screenshot_[0-9-]*.*\.png | sort -rk 3 | cut -d " " -f 4 | head -n 1`
  1384.     if [ "$screenshot" = "" ]; then
  1385.         echo "No screenshots found."
  1386.         return
  1387.     fi
  1388.     echo "${screenshot}"
  1389.     adb ${adbOptions} pull ${screenshot_path}/${screenshot}
  1390. }
  1391.  
  1392. function startviewserver()
  1393. {
  1394.     local port=4939
  1395.     if [ $# -gt 0 ]; then
  1396.             port=$1
  1397.     fi
  1398.     adb shell service call window 1 i32 $port
  1399. }
  1400.  
  1401. function stopviewserver()
  1402. {
  1403.     adb shell service call window 2
  1404. }
  1405.  
  1406. function isviewserverstarted()
  1407. {
  1408.     adb shell service call window 3
  1409. }
  1410.  
  1411. function key_home()
  1412. {
  1413.     adb shell input keyevent 3
  1414. }
  1415.  
  1416. function key_back()
  1417. {
  1418.     adb shell input keyevent 4
  1419. }
  1420.  
  1421. function key_menu()
  1422. {
  1423.     adb shell input keyevent 82
  1424. }
  1425.  
  1426. function smoketest()
  1427. {
  1428.     if [ ! "$ANDROID_PRODUCT_OUT" ]; then
  1429.         echo "Couldn't locate output files.  Try running 'lunch' first." >&2
  1430.         return
  1431.     fi
  1432.     local T=$(gettop)
  1433.     if [ ! "$T" ]; then
  1434.         echo "Couldn't locate the top of the tree.  Try setting TOP." >&2
  1435.         return
  1436.     fi
  1437.  
  1438.     (\cd "$T" && mmm tests/SmokeTest) &&
  1439.       adb uninstall com.android.smoketest > /dev/null &&
  1440.       adb uninstall com.android.smoketest.tests > /dev/null &&
  1441.       adb install $ANDROID_PRODUCT_OUT/data/app/SmokeTestApp.apk &&
  1442.       adb install $ANDROID_PRODUCT_OUT/data/app/SmokeTest.apk &&
  1443.       adb shell am instrument -w com.android.smoketest.tests/android.test.InstrumentationTestRunner
  1444. }
  1445.  
  1446. # simple shortcut to the runtest command
  1447. function runtest()
  1448. {
  1449.     local T=$(gettop)
  1450.     if [ ! "$T" ]; then
  1451.         echo "Couldn't locate the top of the tree.  Try setting TOP." >&2
  1452.         return
  1453.     fi
  1454.     ("$T"/development/testrunner/runtest.py $@)
  1455. }
  1456.  
  1457. function godir () {
  1458.     if [[ -z "$1" ]]; then
  1459.         echo "Usage: godir <regex>"
  1460.         return
  1461.     fi
  1462.     local T=$(gettop)
  1463.     local FILELIST
  1464.     if [ ! "$OUT_DIR" = "" ]; then
  1465.         mkdir -p $OUT_DIR
  1466.         FILELIST=$OUT_DIR/filelist
  1467.     else
  1468.         FILELIST=$T/filelist
  1469.     fi
  1470.     if [[ ! -f $FILELIST ]]; then
  1471.         echo -n "Creating index..."
  1472.         (\cd $T; find . -wholename ./out -prune -o -wholename ./.repo -prune -o -type f > $FILELIST)
  1473.         echo " Done"
  1474.         echo ""
  1475.     fi
  1476.     local lines
  1477.     lines=($(\grep "$1" $FILELIST | sed -e 's/\/[^/]*$//' | sort | uniq))
  1478.     if [[ ${#lines[@]} = 0 ]]; then
  1479.         echo "Not found"
  1480.         return
  1481.     fi
  1482.     local pathname
  1483.     local choice
  1484.     if [[ ${#lines[@]} > 1 ]]; then
  1485.         while [[ -z "$pathname" ]]; do
  1486.             local index=1
  1487.             local line
  1488.             for line in ${lines[@]}; do
  1489.                 printf "%6s %s\n" "[$index]" $line
  1490.                 index=$(($index + 1))
  1491.             done
  1492.             echo
  1493.             echo -n "Select one: "
  1494.             unset choice
  1495.             read choice
  1496.             if [[ $choice -gt ${#lines[@]} || $choice -lt 1 ]]; then
  1497.                 echo "Invalid choice"
  1498.                 continue
  1499.             fi
  1500.             pathname=${lines[@]:$(($choice-1)):1}
  1501.         done
  1502.     else
  1503.         pathname=${lines[@]:0:1}
  1504.     fi
  1505.     \cd $T/$pathname
  1506. }
  1507.  
  1508. # Update module-info.json in out.
  1509. function refreshmod() {
  1510.     if [ ! "$ANDROID_PRODUCT_OUT" ]; then
  1511.         echo "No ANDROID_PRODUCT_OUT. Try running 'lunch' first." >&2
  1512.         return 1
  1513.     fi
  1514.  
  1515.     echo "Refreshing modules (building module-info.json). Log at $ANDROID_PRODUCT_OUT/module-info.json.build.log." >&2
  1516.  
  1517.     # for the output of the next command
  1518.     mkdir -p $ANDROID_PRODUCT_OUT || return 1
  1519.  
  1520.     # Note, can't use absolute path because of the way make works.
  1521.     m $(get_build_var PRODUCT_OUT)/module-info.json \
  1522.         > $ANDROID_PRODUCT_OUT/module-info.json.build.log 2>&1
  1523. }
  1524.  
  1525. # Verifies that module-info.txt exists, creating it if it doesn't.
  1526. function verifymodinfo() {
  1527.     if [ ! "$ANDROID_PRODUCT_OUT" ]; then
  1528.         if [ "$QUIET_VERIFYMODINFO" != "true" ] ; then
  1529.             echo "No ANDROID_PRODUCT_OUT. Try running 'lunch' first." >&2
  1530.         fi
  1531.         return 1
  1532.     fi
  1533.  
  1534.     if [ ! -f "$ANDROID_PRODUCT_OUT/module-info.json" ]; then
  1535.         if [ "$QUIET_VERIFYMODINFO" != "true" ] ; then
  1536.             echo "Could not find module-info.json. It will only be built once, and it can be updated with 'refreshmod'" >&2
  1537.         fi
  1538.         return 1
  1539.     fi
  1540. }
  1541.  
  1542. # List all modules for the current device, as cached in module-info.json. If any build change is
  1543. # made and it should be reflected in the output, you should run 'refreshmod' first.
  1544. function allmod() {
  1545.     verifymodinfo || return 1
  1546.  
  1547.     python3 -c "import json; print('\n'.join(sorted(json.load(open('$ANDROID_PRODUCT_OUT/module-info.json')).keys())))"
  1548. }
  1549.  
  1550. # Get the path of a specific module in the android tree, as cached in module-info.json.
  1551. # If any build change is made, and it should be reflected in the output, you should run
  1552. # 'refreshmod' first.  Note: This is the inverse of dirmods.
  1553. function pathmod() {
  1554.     if [[ $# -ne 1 ]]; then
  1555.         echo "usage: pathmod <module>" >&2
  1556.         return 1
  1557.     fi
  1558.  
  1559.     verifymodinfo || return 1
  1560.  
  1561.     local relpath=$(python3 -c "import json, os
  1562. module = '$1'
  1563. module_info = json.load(open('$ANDROID_PRODUCT_OUT/module-info.json'))
  1564. if module not in module_info:
  1565.     exit(1)
  1566. print(module_info[module]['path'][0])" 2>/dev/null)
  1567.  
  1568.     if [ -z "$relpath" ]; then
  1569.         echo "Could not find module '$1' (try 'refreshmod' if there have been build changes?)." >&2
  1570.         return 1
  1571.     else
  1572.         echo "$ANDROID_BUILD_TOP/$relpath"
  1573.     fi
  1574. }
  1575.  
  1576. # Get the path of a specific module in the android tree, as cached in module-info.json.
  1577. # If any build change is made, and it should be reflected in the output, you should run
  1578. # 'refreshmod' first.  Note: This is the inverse of pathmod.
  1579. function dirmods() {
  1580.     if [[ $# -ne 1 ]]; then
  1581.         echo "usage: dirmods <path>" >&2
  1582.         return 1
  1583.     fi
  1584.  
  1585.     verifymodinfo || return 1
  1586.  
  1587.     python3 -c "import json, os
  1588. dir = '$1'
  1589. while dir.endswith('/'):
  1590.     dir = dir[:-1]
  1591. prefix = dir + '/'
  1592. module_info = json.load(open('$ANDROID_PRODUCT_OUT/module-info.json'))
  1593. results = set()
  1594. for m in module_info.values():
  1595.     for path in m.get(u'path', []):
  1596.         if path == dir or path.startswith(prefix):
  1597.             name = m.get(u'module_name')
  1598.             if name:
  1599.                 results.add(name)
  1600. for name in sorted(results):
  1601.     print(name)
  1602. "
  1603. }
  1604.  
  1605.  
  1606. # Go to a specific module in the android tree, as cached in module-info.json. If any build change
  1607. # is made, and it should be reflected in the output, you should run 'refreshmod' first.
  1608. function gomod() {
  1609.     if [[ $# -ne 1 ]]; then
  1610.         echo "usage: gomod <module>" >&2
  1611.         return 1
  1612.     fi
  1613.  
  1614.     local path="$(pathmod $@)"
  1615.     if [ -z "$path" ]; then
  1616.         return 1
  1617.     fi
  1618.     cd $path
  1619. }
  1620.  
  1621. # Gets the list of a module's installed outputs, as cached in module-info.json.
  1622. # If any build change is made, and it should be reflected in the output, you should run 'refreshmod' first.
  1623. function outmod() {
  1624.     if [[ $# -ne 1 ]]; then
  1625.         echo "usage: outmod <module>" >&2
  1626.         return 1
  1627.     fi
  1628.  
  1629.     verifymodinfo || return 1
  1630.  
  1631.     local relpath
  1632.     relpath=$(python3 -c "import json, os
  1633. module = '$1'
  1634. module_info = json.load(open('$ANDROID_PRODUCT_OUT/module-info.json'))
  1635. if module not in module_info:
  1636.     exit(1)
  1637. for output in module_info[module]['installed']:
  1638.     print(os.path.join('$ANDROID_BUILD_TOP', output))" 2>/dev/null)
  1639.  
  1640.     if [ $? -ne 0 ]; then
  1641.         echo "Could not find module '$1' (try 'refreshmod' if there have been build changes?)" >&2
  1642.         return 1
  1643.     elif [ ! -z "$relpath" ]; then
  1644.         echo "$relpath"
  1645.     fi
  1646. }
  1647.  
  1648. # adb install a module's apk, as cached in module-info.json. If any build change
  1649. # is made, and it should be reflected in the output, you should run 'refreshmod' first.
  1650. # Usage: installmod [adb install arguments] <module>
  1651. # For example: installmod -r Dialer -> adb install -r /path/to/Dialer.apk
  1652. function installmod() {
  1653.     if [[ $# -eq 0 ]]; then
  1654.         echo "usage: installmod [adb install arguments] <module>" >&2
  1655.         return 1
  1656.     fi
  1657.  
  1658.     local _path
  1659.     _path=$(outmod ${@:$#:1})
  1660.     if [ $? -ne 0 ]; then
  1661.         return 1
  1662.     fi
  1663.  
  1664.     _path=$(echo "$_path" | grep -E \\.apk$ | head -n 1)
  1665.     if [ -z "$_path" ]; then
  1666.         echo "Module '$1' does not produce a file ending with .apk (try 'refreshmod' if there have been build changes?)" >&2
  1667.         return 1
  1668.     fi
  1669.     local length=$(( $# - 1 ))
  1670.     echo adb install ${@:1:$length} $_path
  1671.     adb install ${@:1:$length} $_path
  1672. }
  1673.  
  1674. function _complete_android_module_names() {
  1675.     local word=${COMP_WORDS[COMP_CWORD]}
  1676.     COMPREPLY=( $(QUIET_VERIFYMODINFO=true allmod | grep -E "^$word") )
  1677. }
  1678.  
  1679. # Print colored exit condition
  1680. function pez {
  1681.     "$@"
  1682.     local retval=$?
  1683.     if [ $retval -ne 0 ]
  1684.     then
  1685.         echo $'\E'"[0;31mFAILURE\e[00m"
  1686.     else
  1687.         echo $'\E'"[0;32mSUCCESS\e[00m"
  1688.     fi
  1689.     return $retval
  1690. }
  1691.  
  1692. function get_make_command()
  1693. {
  1694.     # If we're in the top of an Android tree, use soong_ui.bash instead of make
  1695.     if [ -f build/soong/soong_ui.bash ]; then
  1696.         # Always use the real make if -C is passed in
  1697.         for arg in "$@"; do
  1698.             if [[ $arg == -C* ]]; then
  1699.                 echo command make
  1700.                 return
  1701.             fi
  1702.         done
  1703.         echo build/soong/soong_ui.bash --make-mode
  1704.     else
  1705.         echo command make
  1706.     fi
  1707. }
  1708.  
  1709. function _wrap_build()
  1710. {
  1711.     if [[ "${ANDROID_QUIET_BUILD:-}" == true ]]; then
  1712.       "$@"
  1713.       return $?
  1714.     fi
  1715.     local start_time=$(date +"%s")
  1716.     "$@"
  1717.     local ret=$?
  1718.     local end_time=$(date +"%s")
  1719.     local tdiff=$(($end_time-$start_time))
  1720.     local hours=$(($tdiff / 3600 ))
  1721.     local mins=$((($tdiff % 3600) / 60))
  1722.     local secs=$(($tdiff % 60))
  1723.     local ncolors=$(tput colors 2>/dev/null)
  1724.     if [ -n "$ncolors" ] && [ $ncolors -ge 8 ]; then
  1725.         color_failed=$'\E'"[0;31m"
  1726.         color_success=$'\E'"[0;32m"
  1727.         color_reset=$'\E'"[00m"
  1728.     else
  1729.         color_failed=""
  1730.         color_success=""
  1731.         color_reset=""
  1732.     fi
  1733.     echo
  1734.     if [ $ret -eq 0 ] ; then
  1735.         echo -n "${color_success}#### build completed successfully "
  1736.     else
  1737.         echo -n "${color_failed}#### failed to build some targets "
  1738.     fi
  1739.     if [ $hours -gt 0 ] ; then
  1740.         printf "(%02g:%02g:%02g (hh:mm:ss))" $hours $mins $secs
  1741.     elif [ $mins -gt 0 ] ; then
  1742.         printf "(%02g:%02g (mm:ss))" $mins $secs
  1743.     elif [ $secs -gt 0 ] ; then
  1744.         printf "(%s seconds)" $secs
  1745.     fi
  1746.     echo " ####${color_reset}"
  1747.     echo
  1748.     return $ret
  1749. }
  1750.  
  1751. function _trigger_build()
  1752. (
  1753.     local -r bc="$1"; shift
  1754.     if T="$(gettop)"; then
  1755.       _wrap_build "$T/build/soong/soong_ui.bash" --build-mode --${bc} --dir="$(pwd)" "$@"
  1756.     else
  1757.       echo "Couldn't locate the top of the tree. Try setting TOP."
  1758.     fi
  1759. )
  1760.  
  1761. function m()
  1762. (
  1763.     _trigger_build "all-modules" "$@"
  1764. )
  1765.  
  1766. function mm()
  1767. (
  1768.     _trigger_build "modules-in-a-dir-no-deps" "$@"
  1769. )
  1770.  
  1771. function mmm()
  1772. (
  1773.     _trigger_build "modules-in-dirs-no-deps" "$@"
  1774. )
  1775.  
  1776. function mma()
  1777. (
  1778.     _trigger_build "modules-in-a-dir" "$@"
  1779. )
  1780.  
  1781. function mmma()
  1782. (
  1783.     _trigger_build "modules-in-dirs" "$@"
  1784. )
  1785.  
  1786. function make()
  1787. {
  1788.     _wrap_build $(get_make_command "$@") "$@"
  1789. }
  1790.  
  1791. function provision()
  1792. {
  1793.     if [ ! "$ANDROID_PRODUCT_OUT" ]; then
  1794.         echo "Couldn't locate output files.  Try running 'lunch' first." >&2
  1795.         return 1
  1796.     fi
  1797.     if [ ! -e "$ANDROID_PRODUCT_OUT/provision-device" ]; then
  1798.         echo "There is no provisioning script for the device." >&2
  1799.         return 1
  1800.     fi
  1801.  
  1802.     # Check if user really wants to do this.
  1803.     if [ "$1" = "--no-confirmation" ]; then
  1804.         shift 1
  1805.     else
  1806.         echo "This action will reflash your device."
  1807.         echo ""
  1808.         echo "ALL DATA ON THE DEVICE WILL BE IRREVOCABLY ERASED."
  1809.         echo ""
  1810.         echo -n "Are you sure you want to do this (yes/no)? "
  1811.         read
  1812.         if [[ "${REPLY}" != "yes" ]] ; then
  1813.             echo "Not taking any action. Exiting." >&2
  1814.             return 1
  1815.         fi
  1816.     fi
  1817.     "$ANDROID_PRODUCT_OUT/provision-device" "$@"
  1818. }
  1819.  
  1820. # Zsh needs bashcompinit called to support bash-style completion.
  1821. function enable_zsh_completion() {
  1822.     # Don't override user's options if bash-style completion is already enabled.
  1823.     if ! declare -f complete >/dev/null; then
  1824.         autoload -U compinit && compinit
  1825.         autoload -U bashcompinit && bashcompinit
  1826.     fi
  1827. }
  1828.  
  1829. function validate_current_shell() {
  1830.     local current_sh="$(ps -o command -p $$)"
  1831.     case "$current_sh" in
  1832.         *bash*)
  1833.             function check_type() { type -t "$1"; }
  1834.             ;;
  1835.         *zsh*)
  1836.             function check_type() { type "$1"; }
  1837.             enable_zsh_completion ;;
  1838.         *)
  1839.             echo -e "WARNING: Only bash and zsh are supported.\nUse of other shell would lead to erroneous results."
  1840.             ;;
  1841.     esac
  1842. }
  1843.  
  1844. # Execute the contents of any vendorsetup.sh files we can find.
  1845. # Unless we find an allowed-vendorsetup_sh-files file, in which case we'll only
  1846. # load those.
  1847. #
  1848. # This allows loading only approved vendorsetup.sh files
  1849. function source_vendorsetup() {
  1850.     unset VENDOR_PYTHONPATH
  1851.     local T="$(gettop)"
  1852.     allowed=
  1853.     for f in $(cd "$T" && find -L device vendor product -maxdepth 4 -name 'allowed-vendorsetup_sh-files' 2>/dev/null | sort); do
  1854.         if [ -n "$allowed" ]; then
  1855.             echo "More than one 'allowed_vendorsetup_sh-files' file found, not including any vendorsetup.sh files:"
  1856.             echo "  $allowed"
  1857.             echo "  $f"
  1858.             return
  1859.         fi
  1860.         allowed="$T/$f"
  1861.     done
  1862.  
  1863.     allowed_files=
  1864.     [ -n "$allowed" ] && allowed_files=$(cat "$allowed")
  1865.     for dir in device vendor product; do
  1866.         for f in $(cd "$T" && test -d $dir && \
  1867.             find -L $dir -maxdepth 4 -name 'vendorsetup.sh' 2>/dev/null | sort); do
  1868.  
  1869.             if [[ -z "$allowed" || "$allowed_files" =~ $f ]]; then
  1870.                 echo "including $f"; . "$T/$f"
  1871.             else
  1872.                 echo "ignoring $f, not in $allowed"
  1873.             fi
  1874.         done
  1875.     done
  1876. }
  1877.  
  1878. function showcommands() {
  1879.     local T=$(gettop)
  1880.     if [[ -z "$TARGET_PRODUCT" ]]; then
  1881.         >&2 echo "TARGET_PRODUCT not set. Run lunch."
  1882.         return
  1883.     fi
  1884.     case $(uname -s) in
  1885.         Darwin)
  1886.             PREBUILT_NAME=darwin-x86
  1887.             ;;
  1888.         Linux)
  1889.             PREBUILT_NAME=linux-x86
  1890.             ;;
  1891.         *)
  1892.             >&2 echo Unknown host $(uname -s)
  1893.             return
  1894.             ;;
  1895.     esac
  1896.     if [[ -z "$OUT_DIR" ]]; then
  1897.       if [[ -z "$OUT_DIR_COMMON_BASE" ]]; then
  1898.         OUT_DIR=out
  1899.       else
  1900.         OUT_DIR=${OUT_DIR_COMMON_BASE}/${PWD##*/}
  1901.       fi
  1902.     fi
  1903.     if [[ "$1" == "--regenerate" ]]; then
  1904.       shift 1
  1905.       NINJA_ARGS="-t commands $@" m
  1906.     else
  1907.       (cd $T && prebuilts/build-tools/$PREBUILT_NAME/bin/ninja \
  1908.           -f $OUT_DIR/combined-${TARGET_PRODUCT}.ninja \
  1909.           -t commands "$@")
  1910.     fi
  1911. }
  1912.  
  1913. # 执行方法
  1914. validate_current_shell
  1915. source_vendorsetup
  1916. addcompletions

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/笔触狂放9/article/detail/327286
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号