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