envsetup.sh

   1 function hmm() {
   2 cat <<EOF
   3 Invoke ". build/envsetup.sh" from your shell to add the following functions to your environment:
   4 - lunch:   lunch <product_name>-<build_variant>
   5 - tapas:   tapas [<App1> <App2> ...] [arm|x86|mips|armv5] [eng|userdebug|user]
   6 - croot:   Changes directory to the top of the tree.
   7 - m:       Makes from the top of the tree.
   8 - mm:      Builds all of the modules in the current directory, but not their dependencies.
   9 - mmm:     Builds all of the modules in the supplied directories, but not their dependencies.
  10            To limit the modules being built use the syntax: mmm dir/:target1,target2.
  11 - mma:     Builds all of the modules in the current directory, and their dependencies.
  12 - mmma:    Builds all of the modules in the supplied directories, and their dependencies.
  13 - cgrep:   Greps on all local C/C++ files.
  14 - jgrep:   Greps on all local Java files.
  15 - resgrep: Greps on all local res/*.xml files.
  16 - godir:   Go to the directory containing a file.
  17
  18 Look at the source to view more functions. The complete list is:
  19 EOF
  20     T=$(gettop)
  21     local A
  22     A=""
  23     for i in `cat $T/build/envsetup.sh | sed -n "/^function /s/function \([a-z_]*\).*/\1/p" | sort`; do
  24       A="$A $i"
  25     done
  26     echo $A
  27 }
  28
  29 # Get the value of a build variable as an absolute path.
  30 function get_abs_build_var()
  31 {
  32     T=$(gettop)
  33     if [ ! "$T" ]; then
  34         echo "Couldn't locate the top of the tree.  Try setting TOP." >&2
  35         return
  36     fi
  37     (\cd $T; CALLED_FROM_SETUP=true BUILD_SYSTEM=build/core \
  38       make --no-print-directory -f build/core/config.mk dumpvar-abs-$1)
  39 }
  40
  41 # Get the exact value of a build variable.
  42 function get_build_var()
  43 {
  44     T=$(gettop)
  45     if [ ! "$T" ]; then
  46         echo "Couldn't locate the top of the tree.  Try setting TOP." >&2
  47         return
  48     fi
  49     (\cd $T; CALLED_FROM_SETUP=true BUILD_SYSTEM=build/core \
  50       make --no-print-directory -f build/core/config.mk dumpvar-$1)
  51 }
  52
  53 # check to see if the supplied product is one we can build
  54 function check_product()
  55 {
  56     T=$(gettop)
  57     if [ ! "$T" ]; then
  58         echo "Couldn't locate the top of the tree.  Try setting TOP." >&2
  59         return
  60     fi
  61         TARGET_PRODUCT=$1 \
  62         TARGET_BUILD_VARIANT= \
  63         TARGET_BUILD_TYPE= \
  64         TARGET_BUILD_APPS= \
  65         get_build_var TARGET_DEVICE > /dev/null
  66     # hide successful answers, but allow the errors to show
  67 }
  68
  69 VARIANT_CHOICES=(user userdebug eng)
  70
  71 # check to see if the supplied variant is valid
  72 function check_variant()
  73 {
  74     for v in ${VARIANT_CHOICES[@]}
  75     do
  76         if [ "$v" = "$1" ]
  77         then
  78             return 0
  79         fi
  80     done
  81     return 1
  82 }
  83
  84 function setpaths()
  85 {
  86     T=$(gettop)
  87     if [ ! "$T" ]; then
  88         echo "Couldn't locate the top of the tree.  Try setting TOP."
  89         return
  90     fi
  91
  92     ##################################################################
  93     #                                                                #
  94     #              Read me before you modify this code               #
  95     #                                                                #
  96     #   This function sets ANDROID_BUILD_PATHS to what it is adding  #
  97     #   to PATH, and the next time it is run, it removes that from   #
  98     #   PATH.  This is required so lunch can be run more than once   #
  99     #   and still have working paths.                                #
 100     #                                                                #
 101     ##################################################################
 102
 103     # Note: on windows/cygwin, ANDROID_BUILD_PATHS will contain spaces
 104     # due to "C:\Program Files" being in the path.
 105
 106     # out with the old
 107     if [ -n "$ANDROID_BUILD_PATHS" ] ; then
 108         export PATH=${PATH/$ANDROID_BUILD_PATHS/}
 109     fi
 110     if [ -n "$ANDROID_PRE_BUILD_PATHS" ] ; then
 111         export PATH=${PATH/$ANDROID_PRE_BUILD_PATHS/}
 112         # strip leading ':', if any
 113         export PATH=${PATH/:%/}
 114     fi
 115
 116     # and in with the new
 117     prebuiltdir=$(getprebuilt)
 118     gccprebuiltdir=$(get_abs_build_var ANDROID_GCC_PREBUILTS)
 119
 120     # defined in core/config.mk
 121     targetgccversion=$(get_build_var TARGET_GCC_VERSION)
 122     targetgccversion2=$(get_build_var 2ND_TARGET_GCC_VERSION)
 123     export TARGET_GCC_VERSION=$targetgccversion
 124
 125     # The gcc toolchain does not exists for windows/cygwin. In this case, do not reference it.
 126     export ANDROID_TOOLCHAIN=
 127     export ANDROID_TOOLCHAIN_2ND_ARCH=
 128     local ARCH=$(get_build_var TARGET_ARCH)
 129     case $ARCH in
 130         x86) toolchaindir=x86/x86_64-linux-android-$targetgccversion/bin
 131             ;;
 132         x86_64) toolchaindir=x86/x86_64-linux-android-$targetgccversion/bin
 133             ;;
 134         arm) toolchaindir=arm/arm-linux-androideabi-$targetgccversion/bin
 135             ;;
 136         arm64) toolchaindir=aarch64/aarch64-linux-android-$targetgccversion/bin;
 137                toolchaindir2=arm/arm-linux-androideabi-$targetgccversion2/bin
 138             ;;
 139         mips) toolchaindir=mips/mipsel-linux-android-$targetgccversion/bin
 140             ;;
 141         mips64) toolchaindir=mips/mips64el-linux-android-$targetgccversion/bin
 142             ;;
 143         *)
 144             echo "Can't find toolchain for unknown architecture: $ARCH"
 145             toolchaindir=xxxxxxxxx
 146             ;;
 147     esac
 148     if [ -d "$gccprebuiltdir/$toolchaindir" ]; then
 149         export ANDROID_TOOLCHAIN=$gccprebuiltdir/$toolchaindir
 150     fi
 151
 152     if [ -d "$gccprebuiltdir/$toolchaindir2" ]; then
 153         export ANDROID_TOOLCHAIN_2ND_ARCH=$gccprebuiltdir/$toolchaindir2
 154     fi
 155
 156     unset ANDROID_KERNEL_TOOLCHAIN_PATH
 157     case $ARCH in
 158         arm)
 159             # Legacy toolchain configuration used for ARM kernel compilation
 160             toolchaindir=arm/arm-eabi-$targetgccversion/bin
 161             if [ -d "$gccprebuiltdir/$toolchaindir" ]; then
 162                  export ARM_EABI_TOOLCHAIN="$gccprebuiltdir/$toolchaindir"
 163                  ANDROID_KERNEL_TOOLCHAIN_PATH="$ARM_EABI_TOOLCHAIN":
 164             fi
 165             ;;
 166         *)
 167             # No need to set ARM_EABI_TOOLCHAIN for other ARCHs
 168             ;;
 169     esac
 170
 171     export ANDROID_DEV_SCRIPTS=$T/development/scripts:$T/prebuilts/devtools/tools
 172     export ANDROID_BUILD_PATHS=$(get_build_var ANDROID_BUILD_PATHS):$ANDROID_TOOLCHAIN:$ANDROID_TOOLCHAIN_2ND_ARCH:$ANDROID_KERNEL_TOOLCHAIN_PATH$ANDROID_DEV_SCRIPTS:
 173
 174     # If prebuilts/android-emulator/<system>/ exists, prepend it to our PATH
 175     # to ensure that the corresponding 'emulator' binaries are used.
 176     case $(uname -s) in
 177         Darwin)
 178             ANDROID_EMULATOR_PREBUILTS=$T/prebuilts/android-emulator/darwin-x86_64
 179             ;;
 180         Linux)
 181             ANDROID_EMULATOR_PREBUILTS=$T/prebuilts/android-emulator/linux-x86_64
 182             ;;
 183         *)
 184             ANDROID_EMULATOR_PREBUILTS=
 185             ;;
 186     esac
 187     if [ -n "$ANDROID_EMULATOR_PREBUILTS" -a -d "$ANDROID_EMULATOR_PREBUILTS" ]; then
 188         ANDROID_BUILD_PATHS=$ANDROID_BUILD_PATHS$ANDROID_EMULATOR_PREBUILTS:
 189         export ANDROID_EMULATOR_PREBUILTS
 190     fi
 191
 192     export PATH=$ANDROID_BUILD_PATHS$PATH
 193
 194     unset ANDROID_JAVA_TOOLCHAIN
 195     unset ANDROID_PRE_BUILD_PATHS
 196     if [ -n "$JAVA_HOME" ]; then
 197         export ANDROID_JAVA_TOOLCHAIN=$JAVA_HOME/bin
 198         export ANDROID_PRE_BUILD_PATHS=$ANDROID_JAVA_TOOLCHAIN:
 199         export PATH=$ANDROID_PRE_BUILD_PATHS$PATH
 200     fi
 201
 202     unset ANDROID_PRODUCT_OUT
 203     export ANDROID_PRODUCT_OUT=$(get_abs_build_var PRODUCT_OUT)
 204     export OUT=$ANDROID_PRODUCT_OUT
 205
 206     unset ANDROID_HOST_OUT
 207     export ANDROID_HOST_OUT=$(get_abs_build_var HOST_OUT)
 208
 209     # needed for building linux on MacOS
 210     # TODO: fix the path
 211     #export HOST_EXTRACFLAGS="-I "$T/system/kernel_headers/host_include
 212 }
 213
 214 function printconfig()
 215 {
 216     T=$(gettop)
 217     if [ ! "$T" ]; then
 218         echo "Couldn't locate the top of the tree.  Try setting TOP." >&2
 219         return
 220     fi
 221     get_build_var report_config
 222 }
 223
 224 function set_stuff_for_environment()
 225 {
 226     settitle
 227     set_java_home
 228     setpaths
 229     set_sequence_number
 230
 231     export ANDROID_BUILD_TOP=$(gettop)
 232     # With this environment variable new GCC can apply colors to warnings/errors
 233     export GCC_COLORS='error=01;31:warning=01;35:note=01;36:caret=01;32:locus=01:quote=01'
 234 }
 235
 236 function set_sequence_number()
 237 {
 238     export BUILD_ENV_SEQUENCE_NUMBER=10
 239 }
 240
 241 function settitle()
 242 {
 243     if [ "$STAY_OFF_MY_LAWN" = "" ]; then
 244         local arch=$(gettargetarch)
 245         local product=$TARGET_PRODUCT
 246         local variant=$TARGET_BUILD_VARIANT
 247         local apps=$TARGET_BUILD_APPS
 248         if [ -z "$apps" ]; then
 249             export PROMPT_COMMAND="echo -ne \"\033]0;[${arch}-${product}-${variant}] ${USER}@${HOSTNAME}: ${PWD}\007\""
 250         else
 251             export PROMPT_COMMAND="echo -ne \"\033]0;[$arch $apps $variant] ${USER}@${HOSTNAME}: ${PWD}\007\""
 252         fi
 253     fi
 254 }
 255
 256 function addcompletions()
 257 {
 258     local T dir f
 259
 260     # Keep us from trying to run in something that isn't bash.
 261     if [ -z "${BASH_VERSION}" ]; then
 262         return
 263     fi
 264
 265     # Keep us from trying to run in bash that's too old.
 266     if [ ${BASH_VERSINFO[0]} -lt 3 ]; then
 267         return
 268     fi
 269
 270     dir="sdk/bash_completion"
 271     if [ -d ${dir} ]; then
 272         for f in `/bin/ls ${dir}/[a-z]*.bash 2> /dev/null`; do
 273             echo "including $f"
 274             . $f
 275         done
 276     fi
 277 }
 278
 279 function choosetype()
 280 {
 281     echo "Build type choices are:"
 282     echo "     1. release"
 283     echo "     2. debug"
 284     echo
 285
 286     local DEFAULT_NUM DEFAULT_VALUE
 287     DEFAULT_NUM=1
 288     DEFAULT_VALUE=release
 289
 290     export TARGET_BUILD_TYPE=
 291     local ANSWER
 292     while [ -z $TARGET_BUILD_TYPE ]
 293     do
 294         echo -n "Which would you like? ["$DEFAULT_NUM"] "
 295         if [ -z "$1" ] ; then
 296             read ANSWER
 297         else
 298             echo $1
 299             ANSWER=$1
 300         fi
 301         case $ANSWER in
 302         "")
 303             export TARGET_BUILD_TYPE=$DEFAULT_VALUE
 304             ;;
 305         1)
 306             export TARGET_BUILD_TYPE=release
 307             ;;
 308         release)
 309             export TARGET_BUILD_TYPE=release
 310             ;;
 311         2)
 312             export TARGET_BUILD_TYPE=debug
 313             ;;
 314         debug)
 315             export TARGET_BUILD_TYPE=debug
 316             ;;
 317         *)
 318             echo
 319             echo "I didn't understand your response.  Please try again."
 320             echo
 321             ;;
 322         esac
 323         if [ -n "$1" ] ; then
 324             break
 325         fi
 326     done
 327
 328     set_stuff_for_environment
 329 }
 330
 331 #
 332 # This function isn't really right:  It chooses a TARGET_PRODUCT
 333 # based on the list of boards.  Usually, that gets you something
 334 # that kinda works with a generic product, but really, you should
 335 # pick a product by name.
 336 #
 337 function chooseproduct()
 338 {
 339     if [ "x$TARGET_PRODUCT" != x ] ; then
 340         default_value=$TARGET_PRODUCT
 341     else
 342         default_value=full
 343     fi
 344
 345     export TARGET_PRODUCT=
 346     local ANSWER
 347     while [ -z "$TARGET_PRODUCT" ]
 348     do
 349         echo -n "Which product would you like? [$default_value] "
 350         if [ -z "$1" ] ; then
 351             read ANSWER
 352         else
 353             echo $1
 354             ANSWER=$1
 355         fi
 356
 357         if [ -z "$ANSWER" ] ; then
 358             export TARGET_PRODUCT=$default_value
 359         else
 360             if check_product $ANSWER
 361             then
 362                 export TARGET_PRODUCT=$ANSWER
 363             else
 364                 echo "** Not a valid product: $ANSWER"
 365             fi
 366         fi
 367         if [ -n "$1" ] ; then
 368             break
 369         fi
 370     done
 371
 372     set_stuff_for_environment
 373 }
 374
 375 function choosevariant()
 376 {
 377     echo "Variant choices are:"
 378     local index=1
 379     local v
 380     for v in ${VARIANT_CHOICES[@]}
 381     do
 382         # The product name is the name of the directory containing
 383         # the makefile we found, above.
 384         echo "     $index. $v"
 385         index=$(($index+1))
 386     done
 387
 388     local default_value=eng
 389     local ANSWER
 390
 391     export TARGET_BUILD_VARIANT=
 392     while [ -z "$TARGET_BUILD_VARIANT" ]
 393     do
 394         echo -n "Which would you like? [$default_value] "
 395         if [ -z "$1" ] ; then
 396             read ANSWER
 397         else
 398             echo $1
 399             ANSWER=$1
 400         fi
 401
 402         if [ -z "$ANSWER" ] ; then
 403             export TARGET_BUILD_VARIANT=$default_value
 404         elif (echo -n $ANSWER | grep -q -e "^[0-9][0-9]*$") ; then
 405             if [ "$ANSWER" -le "${#VARIANT_CHOICES[@]}" ] ; then
 406                 export TARGET_BUILD_VARIANT=${VARIANT_CHOICES[$(($ANSWER-1))]}
 407             fi
 408         else
 409             if check_variant $ANSWER
 410             then
 411                 export TARGET_BUILD_VARIANT=$ANSWER
 412             else
 413                 echo "** Not a valid variant: $ANSWER"
 414             fi
 415         fi
 416         if [ -n "$1" ] ; then
 417             break
 418         fi
 419     done
 420 }
 421
 422 function choosecombo()
 423 {
 424     choosetype $1
 425
 426     echo
 427     echo
 428     chooseproduct $2
 429
 430     echo
 431     echo
 432     choosevariant $3
 433
 434     echo
 435     set_stuff_for_environment
 436     printconfig
 437 }
 438
 439 # Clear this variable.  It will be built up again when the vendorsetup.sh
 440 # files are included at the end of this file.
 441 unset LUNCH_MENU_CHOICES
 442 function add_lunch_combo()
 443 {
 444     local new_combo=$1
 445     local c
 446     for c in ${LUNCH_MENU_CHOICES[@]} ; do
 447         if [ "$new_combo" = "$c" ] ; then
 448             return
 449         fi
 450     done
 451     LUNCH_MENU_CHOICES=(${LUNCH_MENU_CHOICES[@]} $new_combo)
 452 }
 453
 454 # add the default one here
 455 add_lunch_combo aosp_arm-eng
 456 add_lunch_combo aosp_arm64-eng
 457 add_lunch_combo aosp_mips-eng
 458 add_lunch_combo aosp_mips64-eng
 459 add_lunch_combo aosp_x86-eng
 460 add_lunch_combo aosp_x86_64-eng
 461 add_lunch_combo vbox_x86-eng
 462
 463 function print_lunch_menu()
 464 {
 465     local uname=$(uname)
 466     echo
 467     echo "You're building on" $uname
 468     echo
 469     echo "Lunch menu... pick a combo:"
 470
 471     local i=1
 472     local choice
 473     for choice in ${LUNCH_MENU_CHOICES[@]}
 474     do
 475         echo "     $i. $choice"
 476         i=$(($i+1))
 477     done
 478
 479     echo
 480 }
 481
 482 function lunch()
 483 {
 484     local answer
 485
 486     if [ "$1" ] ; then
 487         answer=$1
 488     else
 489         print_lunch_menu
 490         echo -n "Which would you like? [aosp_arm-eng] "
 491         read answer
 492     fi
 493
 494     local selection=
 495
 496     if [ -z "$answer" ]
 497     then
 498         selection=aosp_arm-eng
 499     elif (echo -n $answer | grep -q -e "^[0-9][0-9]*$")
 500     then
 501         if [ $answer -le ${#LUNCH_MENU_CHOICES[@]} ]
 502         then
 503             selection=${LUNCH_MENU_CHOICES[$(($answer-1))]}
 504         fi
 505     elif (echo -n $answer | grep -q -e "^[^\-][^\-]*-[^\-][^\-]*$")
 506     then
 507         selection=$answer
 508     fi
 509
 510     if [ -z "$selection" ]
 511     then
 512         echo
 513         echo "Invalid lunch combo: $answer"
 514         return 1
 515     fi
 516
 517     export TARGET_BUILD_APPS=
 518
 519     local product=$(echo -n $selection | sed -e "s/-.*$//")
 520     check_product $product
 521     if [ $? -ne 0 ]
 522     then
 523         echo
 524         echo "** Don't have a product spec for: '$product'"
 525         echo "** Do you have the right repo manifest?"
 526         product=
 527     fi
 528
 529     local variant=$(echo -n $selection | sed -e "s/^[^\-]*-//")
 530     check_variant $variant
 531     if [ $? -ne 0 ]
 532     then
 533         echo
 534         echo "** Invalid variant: '$variant'"
 535         echo "** Must be one of ${VARIANT_CHOICES[@]}"
 536         variant=
 537     fi
 538
 539     if [ -z "$product" -o -z "$variant" ]
 540     then
 541         echo
 542         return 1
 543     fi
 544
 545     export TARGET_PRODUCT=$product
 546     export TARGET_BUILD_VARIANT=$variant
 547     export TARGET_BUILD_TYPE=release
 548
 549     echo
 550
 551     set_stuff_for_environment
 552     printconfig
 553 }
 554
 555 # Tab completion for lunch.
 556 function _lunch()
 557 {
 558     local cur prev opts
 559     COMPREPLY=()
 560     cur="${COMP_WORDS[COMP_CWORD]}"
 561     prev="${COMP_WORDS[COMP_CWORD-1]}"
 562
 563     COMPREPLY=( $(compgen -W "${LUNCH_MENU_CHOICES[*]}" -- ${cur}) )
 564     return 0
 565 }
 566 complete -F _lunch lunch
 567
 568 # Configures the build to build unbundled apps.
 569 # Run tapas with one ore more app names (from LOCAL_PACKAGE_NAME)
 570 function tapas()
 571 {
 572     local arch=$(echo -n $(echo $* | xargs -n 1 echo | \grep -E '^(arm|x86|mips|armv5)$'))
 573     local variant=$(echo -n $(echo $* | xargs -n 1 echo | \grep -E '^(user|userdebug|eng)$'))
 574     local apps=$(echo -n $(echo $* | xargs -n 1 echo | \grep -E -v '^(user|userdebug|eng|arm|x86|mips|armv5)$'))
 575
 576     if [ $(echo $arch | wc -w) -gt 1 ]; then
 577         echo "tapas: Error: Multiple build archs supplied: $arch"
 578         return
 579     fi
 580     if [ $(echo $variant | wc -w) -gt 1 ]; then
 581         echo "tapas: Error: Multiple build variants supplied: $variant"
 582         return
 583     fi
 584
 585     local product=full
 586     case $arch in
 587       x86)   product=full_x86;;
 588       mips)  product=full_mips;;
 589       armv5) product=generic_armv5;;
 590     esac
 591     if [ -z "$variant" ]; then
 592         variant=eng
 593     fi
 594     if [ -z "$apps" ]; then
 595         apps=all
 596     fi
 597
 598     export TARGET_PRODUCT=$product
 599     export TARGET_BUILD_VARIANT=$variant
 600     export TARGET_BUILD_TYPE=release
 601     export TARGET_BUILD_APPS=$apps
 602
 603     set_stuff_for_environment
 604     printconfig
 605 }
 606
 607 function gettop
 608 {
 609     local TOPFILE=build/core/envsetup.mk
 610     if [ -n "$TOP" -a -f "$TOP/$TOPFILE" ] ; then
 611         echo $TOP
 612     else
 613         if [ -f $TOPFILE ] ; then
 614             # The following circumlocution (repeated below as well) ensures
 615             # that we record the true directory name and not one that is
 616             # faked up with symlink names.
 617             PWD= /bin/pwd
 618         else
 619             local HERE=$PWD
 620             T=
 621             while [ \( ! \( -f $TOPFILE \) \) -a \( $PWD != "/" \) ]; do
 622                 \cd ..
 623                 T=`PWD= /bin/pwd -P`
 624             done
 625             \cd $HERE
 626             if [ -f "$T/$TOPFILE" ]; then
 627                 echo $T
 628             fi
 629         fi
 630     fi
 631 }
 632
 633 # Return driver for "make", if any (eg. static analyzer)
 634 function getdriver()
 635 {
 636     local T="$1"
 637     test "$WITH_STATIC_ANALYZER" = "0" && unset WITH_STATIC_ANALYZER
 638     if [ -n "$WITH_STATIC_ANALYZER" ]; then
 639         echo "\
 640 $T/prebuilts/misc/linux-x86/analyzer/tools/scan-build/scan-build \
 641 --use-analyzer $T/prebuilts/misc/linux-x86/analyzer/bin/analyzer \
 642 --status-bugs \
 643 --top=$T"
 644     fi
 645 }
 646
 647 function m()
 648 {
 649     local T=$(gettop)
 650     local DRV=$(getdriver $T)
 651     if [ "$T" ]; then
 652         $DRV make -C $T -f build/core/main.mk $@
 653     else
 654         echo "Couldn't locate the top of the tree.  Try setting TOP."
 655     fi
 656 }
 657
 658 function findmakefile()
 659 {
 660     TOPFILE=build/core/envsetup.mk
 661     local HERE=$PWD
 662     T=
 663     while [ \( ! \( -f $TOPFILE \) \) -a \( $PWD != "/" \) ]; do
 664         T=`PWD= /bin/pwd`
 665         if [ -f "$T/Android.mk" ]; then
 666             echo $T/Android.mk
 667             \cd $HERE
 668             return
 669         fi
 670         \cd ..
 671     done
 672     \cd $HERE
 673 }
 674
 675 function mm()
 676 {
 677     local T=$(gettop)
 678     local DRV=$(getdriver $T)
 679     # If we're sitting in the root of the build tree, just do a
 680     # normal make.
 681     if [ -f build/core/envsetup.mk -a -f Makefile ]; then
 682         $DRV make $@
 683     else
 684         # Find the closest Android.mk file.
 685         local M=$(findmakefile)
 686         local MODULES=
 687         local GET_INSTALL_PATH=
 688         local ARGS=
 689         # Remove the path to top as the makefilepath needs to be relative
 690         local M=`echo $M|sed 's:'$T'/::'`
 691         if [ ! "$T" ]; then
 692             echo "Couldn't locate the top of the tree.  Try setting TOP."
 693         elif [ ! "$M" ]; then
 694             echo "Couldn't locate a makefile from the current directory."
 695         else
 696             for ARG in $@; do
 697                 case $ARG in
 698                   GET-INSTALL-PATH) GET_INSTALL_PATH=$ARG;;
 699                 esac
 700             done
 701             if [ -n "$GET_INSTALL_PATH" ]; then
 702               MODULES=
 703               ARGS=GET-INSTALL-PATH
 704             else
 705               MODULES=all_modules
 706               ARGS=$@
 707             fi
 708             ONE_SHOT_MAKEFILE=$M $DRV make -C $T -f build/core/main.mk $MODULES $ARGS
 709         fi
 710     fi
 711 }
 712
 713 function mmm()
 714 {
 715     local T=$(gettop)
 716     local DRV=$(getdriver $T)
 717     if [ "$T" ]; then
 718         local MAKEFILE=
 719         local MODULES=
 720         local ARGS=
 721         local DIR TO_CHOP
 722         local GET_INSTALL_PATH=
 723         local DASH_ARGS=$(echo "$@" | awk -v RS=" " -v ORS=" " '/^-.*$/')
 724         local DIRS=$(echo "$@" | awk -v RS=" " -v ORS=" " '/^[^-].*$/')
 725         for DIR in $DIRS ; do
 726             MODULES=`echo $DIR | sed -n -e 's/.*:\(.*$\)/\1/p' | sed 's/,/ /'`
 727             if [ "$MODULES" = "" ]; then
 728                 MODULES=all_modules
 729             fi
 730             DIR=`echo $DIR | sed -e 's/:.*//' -e 's:/$::'`
 731             if [ -f $DIR/Android.mk ]; then
 732                 local TO_CHOP=`(\cd -P -- $T && pwd -P) | wc -c | tr -d ' '`
 733                 local TO_CHOP=`expr $TO_CHOP + 1`
 734                 local START=`PWD= /bin/pwd`
 735                 local MFILE=`echo $START | cut -c${TO_CHOP}-`
 736                 if [ "$MFILE" = "" ] ; then
 737                     MFILE=$DIR/Android.mk
 738                 else
 739                     MFILE=$MFILE/$DIR/Android.mk
 740                 fi
 741                 MAKEFILE="$MAKEFILE $MFILE"
 742             else
 743                 case $DIR in
 744                   showcommands | snod | dist | incrementaljavac) ARGS="$ARGS $DIR";;
 745                   GET-INSTALL-PATH) GET_INSTALL_PATH=$DIR;;
 746                   *) echo "No Android.mk in $DIR."; return 1;;
 747                 esac
 748             fi
 749         done
 750         if [ -n "$GET_INSTALL_PATH" ]; then
 751           ARGS=$GET_INSTALL_PATH
 752           MODULES=
 753         fi
 754         ONE_SHOT_MAKEFILE="$MAKEFILE" $DRV make -C $T -f build/core/main.mk $DASH_ARGS $MODULES $ARGS
 755     else
 756         echo "Couldn't locate the top of the tree.  Try setting TOP."
 757     fi
 758 }
 759
 760 function mma()
 761 {
 762   local T=$(gettop)
 763   local DRV=$(getdriver $T)
 764   if [ -f build/core/envsetup.mk -a -f Makefile ]; then
 765     $DRV make $@
 766   else
 767     if [ ! "$T" ]; then
 768       echo "Couldn't locate the top of the tree.  Try setting TOP."
 769     fi
 770     local MY_PWD=`PWD= /bin/pwd|sed 's:'$T'/::'`
 771     $DRV make -C $T -f build/core/main.mk $@ all_modules BUILD_MODULES_IN_PATHS="$MY_PWD"
 772   fi
 773 }
 774
 775 function mmma()
 776 {
 777   local T=$(gettop)
 778   local DRV=$(getdriver $T)
 779   if [ "$T" ]; then
 780     local DASH_ARGS=$(echo "$@" | awk -v RS=" " -v ORS=" " '/^-.*$/')
 781     local DIRS=$(echo "$@" | awk -v RS=" " -v ORS=" " '/^[^-].*$/')
 782     local MY_PWD=`PWD= /bin/pwd`
 783     if [ "$MY_PWD" = "$T" ]; then
 784       MY_PWD=
 785     else
 786       MY_PWD=`echo $MY_PWD|sed 's:'$T'/::'`
 787     fi
 788     local DIR=
 789     local MODULE_PATHS=
 790     local ARGS=
 791     for DIR in $DIRS ; do
 792       if [ -d $DIR ]; then
 793         if [ "$MY_PWD" = "" ]; then
 794           MODULE_PATHS="$MODULE_PATHS $DIR"
 795         else
 796           MODULE_PATHS="$MODULE_PATHS $MY_PWD/$DIR"
 797         fi
 798       else
 799         case $DIR in
 800           showcommands | snod | dist | incrementaljavac) ARGS="$ARGS $DIR";;
 801           *) echo "Couldn't find directory $DIR"; return 1;;
 802         esac
 803       fi
 804     done
 805     $DRV make -C $T -f build/core/main.mk $DASH_ARGS $ARGS all_modules BUILD_MODULES_IN_PATHS="$MODULE_PATHS"
 806   else
 807     echo "Couldn't locate the top of the tree.  Try setting TOP."
 808   fi
 809 }
 810
 811 function croot()
 812 {
 813     T=$(gettop)
 814     if [ "$T" ]; then
 815         \cd $(gettop)
 816     else
 817         echo "Couldn't locate the top of the tree.  Try setting TOP."
 818     fi
 819 }
 820
 821 function cproj()
 822 {
 823     TOPFILE=build/core/envsetup.mk
 824     local HERE=$PWD
 825     T=
 826     while [ \( ! \( -f $TOPFILE \) \) -a \( $PWD != "/" \) ]; do
 827         T=$PWD
 828         if [ -f "$T/Android.mk" ]; then
 829             \cd $T
 830             return
 831         fi
 832         \cd ..
 833     done
 834     \cd $HERE
 835     echo "can't find Android.mk"
 836 }
 837
 838 # simplified version of ps; output in the form
 839 # <pid> <procname>
 840 function qpid() {
 841     local prepend=''
 842     local append=''
 843     if [ "$1" = "--exact" ]; then
 844         prepend=' '
 845         append='$'
 846         shift
 847     elif [ "$1" = "--help" -o "$1" = "-h" ]; then
 848                 echo "usage: qpid [[--exact] <process name|pid>"
 849                 return 255
 850         fi
 851
 852     local EXE="$1"
 853     if [ "$EXE" ] ; then
 854                 qpid | \grep "$prepend$EXE$append"
 855         else
 856                 adb shell ps \
 857                         | tr -d '\r' \
 858                         | sed -e 1d -e 's/^[^ ]* *\([0-9]*\).* \([^ ]*\)$/\1 \2/'
 859         fi
 860 }
 861
 862 function pid()
 863 {
 864     local prepend=''
 865     local append=''
 866     if [ "$1" = "--exact" ]; then
 867         prepend=' '
 868         append='$'
 869         shift
 870     fi
 871     local EXE="$1"
 872     if [ "$EXE" ] ; then
 873         local PID=`adb shell ps \
 874             | tr -d '\r' \
 875             | \grep "$prepend$EXE$append" \
 876             | sed -e 's/^[^ ]* *\([0-9]*\).*$/\1/'`
 877         echo "$PID"
 878     else
 879         echo "usage: pid [--exact] <process name>"
 880                 return 255
 881     fi
 882 }
 883
 884 # systemstack - dump the current stack trace of all threads in the system process
 885 # to the usual ANR traces file
 886 function systemstack()
 887 {
 888     stacks system_server
 889 }
 890
 891 function stacks()
 892 {
 893     if [[ $1 =~ ^[0-9]+$ ]] ; then
 894         local PID="$1"
 895     elif [ "$1" ] ; then
 896         local PIDLIST="$(pid $1)"
 897         if [[ $PIDLIST =~ ^[0-9]+$ ]] ; then
 898             local PID="$PIDLIST"
 899         elif [ "$PIDLIST" ] ; then
 900             echo "more than one process: $1"
 901         else
 902             echo "no such process: $1"
 903         fi
 904     else
 905         echo "usage: stacks [pid|process name]"
 906     fi
 907
 908     if [ "$PID" ] ; then
 909         # Determine whether the process is native
 910         if adb shell ls -l /proc/$PID/exe | grep -q /system/bin/app_process ; then
 911             # Dump stacks of Dalvik process
 912             local TRACES=/data/anr/traces.txt
 913             local ORIG=/data/anr/traces.orig
 914             local TMP=/data/anr/traces.tmp
 915
 916             # Keep original traces to avoid clobbering
 917             adb shell mv $TRACES $ORIG
 918
 919             # Make sure we have a usable file
 920             adb shell touch $TRACES
 921             adb shell chmod 666 $TRACES
 922
 923             # Dump stacks and wait for dump to finish
 924             adb shell kill -3 $PID
 925             adb shell notify $TRACES >/dev/null
 926
 927             # Restore original stacks, and show current output
 928             adb shell mv $TRACES $TMP
 929             adb shell mv $ORIG $TRACES
 930             adb shell cat $TMP
 931         else
 932             # Dump stacks of native process
 933             local USE64BIT="$(is64bit $PID)"
 934             adb shell debuggerd$USE64BIT -b $PID
 935         fi
 936     fi
 937 }
 938
 939 function gdbwrapper()
 940 {
 941     local GDB_CMD="$1"
 942     shift 1
 943     $GDB_CMD -x "$@"
 944 }
 945
 946 function get_symbols_directory()
 947 {
 948     echo $(get_abs_build_var TARGET_OUT_UNSTRIPPED)
 949 }
 950
 951 # Read the ELF header from /proc/$PID/exe to determine if the process is
 952 # 64-bit.
 953 function is64bit()
 954 {
 955     local PID="$1"
 956     if [ "$PID" ] ; then
 957         if [[ "$(adb shell cat /proc/$PID/exe | xxd -l 1 -s 4 -ps)" -eq "02" ]] ; then
 958             echo "64"
 959         else
 960             echo ""
 961         fi
 962     else
 963         echo ""
 964     fi
 965 }
 966
 967 # gdbclient now determines whether the user wants to debug a 32-bit or 64-bit
 968 # executable, set up the approriate gdbserver, then invokes the proper host
 969 # gdb.
 970 function gdbclient()
 971 {
 972    local OUT_ROOT=$(get_abs_build_var PRODUCT_OUT)
 973    local OUT_SYMBOLS=$(get_abs_build_var TARGET_OUT_UNSTRIPPED)
 974    local OUT_SO_SYMBOLS=$(get_abs_build_var TARGET_OUT_SHARED_LIBRARIES_UNSTRIPPED)
 975    local OUT_VENDOR_SO_SYMBOLS=$(get_abs_build_var TARGET_OUT_VENDOR_SHARED_LIBRARIES_UNSTRIPPED)
 976    local OUT_EXE_SYMBOLS=$(get_symbols_directory)
 977    local PREBUILTS=$(get_abs_build_var ANDROID_PREBUILTS)
 978    local ARCH=$(get_build_var TARGET_ARCH)
 979    local GDB
 980    case "$ARCH" in
 981        arm) GDB=arm-linux-androideabi-gdb;;
 982        arm64) GDB=arm-linux-androideabi-gdb; GDB64=aarch64-linux-android-gdb;;
 983        mips) GDB=mipsel-linux-android-gdb;;
 984        mips64) GDB=mipsel-linux-android-gdb;;
 985        x86) GDB=x86_64-linux-android-gdb;;
 986        x86_64) GDB=x86_64-linux-android-gdb;;
 987        *) echo "Unknown arch $ARCH"; return 1;;
 988    esac
 989
 990    if [ "$OUT_ROOT" -a "$PREBUILTS" ]; then
 991        local EXE="$1"
 992        if [ "$EXE" ] ; then
 993            EXE=$1
 994            if [[ $EXE =~ ^[^/].* ]] ; then
 995                EXE="system/bin/"$EXE
 996            fi
 997        else
 998            EXE="app_process"
 999        fi
1000
1001        local PORT="$2"
1002        if [ "$PORT" ] ; then
1003            PORT=$2
1004        else
1005            PORT=":5039"
1006        fi
1007
1008        local PID="$3"
1009        if [ "$PID" ] ; then
1010            if [[ ! "$PID" =~ ^[0-9]+$ ]] ; then
1011                PID=`pid $3`
1012                if [[ ! "$PID" =~ ^[0-9]+$ ]] ; then
1013                    # that likely didn't work because of returning multiple processes
1014                    # try again, filtering by root processes (don't contain colon)
1015                    PID=`adb shell ps | \grep $3 | \grep -v ":" | awk '{print $2}'`
1016                    if [[ ! "$PID" =~ ^[0-9]+$ ]]
1017                    then
1018                        echo "Couldn't resolve '$3' to single PID"
1019                        return 1
1020                    else
1021                        echo ""
1022                        echo "WARNING: multiple processes matching '$3' observed, using root process"
1023                        echo ""
1024                    fi
1025                fi
1026            fi
1027            adb forward "tcp$PORT" "tcp$PORT"
1028            local USE64BIT="$(is64bit $PID)"
1029            adb shell gdbserver$USE64BIT $PORT --attach $PID &
1030            sleep 2
1031        else
1032                echo ""
1033                echo "If you haven't done so already, do this first on the device:"
1034                echo "    gdbserver $PORT /system/bin/$EXE"
1035                    echo " or"
1036                echo "    gdbserver $PORT --attach <PID>"
1037                echo ""
1038        fi
1039
1040        OUT_SO_SYMBOLS=$OUT_SO_SYMBOLS$USE64BIT
1041
1042        echo >|"$OUT_ROOT/gdbclient.cmds" "set solib-absolute-prefix $OUT_SYMBOLS"
1043        echo >>"$OUT_ROOT/gdbclient.cmds" "set solib-search-path $OUT_SO_SYMBOLS:$OUT_SO_SYMBOLS/hw:$OUT_SO_SYMBOLS/ssl/engines:$OUT_SO_SYMBOLS/drm:$OUT_SO_SYMBOLS/egl:$OUT_SO_SYMBOLS/soundfx:$OUT_VENDOR_SO_SYMBOLS:$OUT_VENDOR_SO_SYMBOLS/hw:$OUT_VENDOR_SO_SYMBOLS/egl"
1044        echo >>"$OUT_ROOT/gdbclient.cmds" "source $ANDROID_BUILD_TOP/development/scripts/gdb/dalvik.gdb"
1045        echo >>"$OUT_ROOT/gdbclient.cmds" "target remote $PORT"
1046        echo >>"$OUT_ROOT/gdbclient.cmds" ""
1047
1048        local WHICH_GDB=
1049        # 64-bit exe found
1050        if [ "$USE64BIT" != "" ] ; then
1051            WHICH_GDB=$ANDROID_TOOLCHAIN/$GDB64
1052        # 32-bit exe / 32-bit platform
1053        elif [ "$(get_build_var TARGET_2ND_ARCH)" = "" ]; then
1054            WHICH_GDB=$ANDROID_TOOLCHAIN/$GDB
1055        # 32-bit exe / 64-bit platform
1056        else
1057            WHICH_GDB=$ANDROID_TOOLCHAIN_2ND_ARCH/$GDB
1058        fi
1059
1060        gdbwrapper $WHICH_GDB "$OUT_ROOT/gdbclient.cmds" "$OUT_EXE_SYMBOLS/$EXE"
1061   else
1062        echo "Unable to determine build system output dir."
1063    fi
1064
1065 }
1066
1067 case `uname -s` in
1068     Darwin)
1069         function sgrep()
1070         {
1071             find -E . -name .repo -prune -o -name .git -prune -o  -type f -iregex '.*\.(c|h|cpp|S|java|xml|sh|mk)' -print0 | xargs -0 grep --color -n "$@"
1072         }
1073
1074         ;;
1075     *)
1076         function sgrep()
1077         {
1078             find . -name .repo -prune -o -name .git -prune -o  -type f -iregex '.*\.\(c\|h\|cpp\|S\|java\|xml\|sh\|mk\)' -print0 | xargs -0 grep --color -n "$@"
1079         }
1080         ;;
1081 esac
1082
1083 function gettargetarch
1084 {
1085     get_build_var TARGET_ARCH
1086 }
1087
1088 function jgrep()
1089 {
1090     find . -name .repo -prune -o -name .git -prune -o -name out -prune -o -type f -name "*\.java" -print0 | xargs -0 grep --color -n "$@"
1091 }
1092
1093 function cgrep()
1094 {
1095     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' \) -print0 | xargs -0 grep --color -n "$@"
1096 }
1097
1098 function resgrep()
1099 {
1100     for dir in `find . -name .repo -prune -o -name .git -prune -o -name out -prune -o -name res -type d`; do find $dir -type f -name '*\.xml' -print0 | xargs -0 grep --color -n "$@"; done;
1101 }
1102
1103 function mangrep()
1104 {
1105     find . -name .repo -prune -o -name .git -prune -o -path ./out -prune -o -type f -name 'AndroidManifest.xml' -print0 | xargs -0 grep --color -n "$@"
1106 }
1107
1108 function sepgrep()
1109 {
1110     find . -name .repo -prune -o -name .git -prune -o -path ./out -prune -o -name sepolicy -type d -print0 | xargs -0 grep --color -n -r --exclude-dir=\.git "$@"
1111 }
1112
1113 case `uname -s` in
1114     Darwin)
1115         function mgrep()
1116         {
1117             find -E . -name .repo -prune -o -name .git -prune -o -path ./out -prune -o -type f -iregex '.*/(Makefile|Makefile\..*|.*\.make|.*\.mak|.*\.mk)' -print0 | xargs -0 grep --color -n "$@"
1118         }
1119
1120         function treegrep()
1121         {
1122             find -E . -name .repo -prune -o -name .git -prune -o -type f -iregex '.*\.(c|h|cpp|S|java|xml)' -print0 | xargs -0 grep --color -n -i "$@"
1123         }
1124
1125         ;;
1126     *)
1127         function mgrep()
1128         {
1129             find . -name .repo -prune -o -name .git -prune -o -path ./out -prune -o -regextype posix-egrep -iregex '(.*\/Makefile|.*\/Makefile\..*|.*\.make|.*\.mak|.*\.mk)' -type f -print0 | xargs -0 grep --color -n "$@"
1130         }
1131
1132         function treegrep()
1133         {
1134             find . -name .repo -prune -o -name .git -prune -o -regextype posix-egrep -iregex '.*\.(c|h|cpp|S|java|xml)' -type f -print0 | xargs -0 grep --color -n -i "$@"
1135         }
1136
1137         ;;
1138 esac
1139
1140 function getprebuilt
1141 {
1142     get_abs_build_var ANDROID_PREBUILTS
1143 }
1144
1145 function tracedmdump()
1146 {
1147     T=$(gettop)
1148     if [ ! "$T" ]; then
1149         echo "Couldn't locate the top of the tree.  Try setting TOP."
1150         return
1151     fi
1152     local prebuiltdir=$(getprebuilt)
1153     local arch=$(gettargetarch)
1154     local KERNEL=$T/prebuilts/qemu-kernel/$arch/vmlinux-qemu
1155
1156     local TRACE=$1
1157     if [ ! "$TRACE" ] ; then
1158         echo "usage:  tracedmdump  tracename"
1159         return
1160     fi
1161
1162     if [ ! -r "$KERNEL" ] ; then
1163         echo "Error: cannot find kernel: '$KERNEL'"
1164         return
1165     fi
1166
1167     local BASETRACE=$(basename $TRACE)
1168     if [ "$BASETRACE" = "$TRACE" ] ; then
1169         TRACE=$ANDROID_PRODUCT_OUT/traces/$TRACE
1170     fi
1171
1172     echo "post-processing traces..."
1173     rm -f $TRACE/qtrace.dexlist
1174     post_trace $TRACE
1175     if [ $? -ne 0 ]; then
1176         echo "***"
1177         echo "*** Error: malformed trace.  Did you remember to exit the emulator?"
1178         echo "***"
1179         return
1180     fi
1181     echo "generating dexlist output..."
1182     /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
1183     echo "generating dmtrace data..."
1184     q2dm -r $ANDROID_PRODUCT_OUT/symbols $TRACE $KERNEL $TRACE/dmtrace || return
1185     echo "generating html file..."
1186     dmtracedump -h $TRACE/dmtrace >| $TRACE/dmtrace.html || return
1187     echo "done, see $TRACE/dmtrace.html for details"
1188     echo "or run:"
1189     echo "    traceview $TRACE/dmtrace"
1190 }
1191
1192 # communicate with a running device or emulator, set up necessary state,
1193 # and run the hat command.
1194 function runhat()
1195 {
1196     # process standard adb options
1197     local adbTarget=""
1198     if [ "$1" = "-d" -o "$1" = "-e" ]; then
1199         adbTarget=$1
1200         shift 1
1201     elif [ "$1" = "-s" ]; then
1202         adbTarget="$1 $2"
1203         shift 2
1204     fi
1205     local adbOptions=${adbTarget}
1206     #echo adbOptions = ${adbOptions}
1207
1208     # runhat options
1209     local targetPid=$1
1210
1211     if [ "$targetPid" = "" ]; then
1212         echo "Usage: runhat [ -d | -e | -s serial ] target-pid"
1213         return
1214     fi
1215
1216     # confirm hat is available
1217     if [ -z $(which hat) ]; then
1218         echo "hat is not available in this configuration."
1219         return
1220     fi
1221
1222     # issue "am" command to cause the hprof dump
1223     local sdcard=$(adb ${adbOptions} shell echo -n '$EXTERNAL_STORAGE')
1224     local devFile=$sdcard/hprof-$targetPid
1225     #local devFile=/data/local/hprof-$targetPid
1226     echo "Poking $targetPid and waiting for data..."
1227     echo "Storing data at $devFile"
1228     adb ${adbOptions} shell am dumpheap $targetPid $devFile
1229     echo "Press enter when logcat shows \"hprof: heap dump completed\""
1230     echo -n "> "
1231     read
1232
1233     local localFile=/tmp/$$-hprof
1234
1235     echo "Retrieving file $devFile..."
1236     adb ${adbOptions} pull $devFile $localFile
1237
1238     adb ${adbOptions} shell rm $devFile
1239
1240     echo "Running hat on $localFile"
1241     echo "View the output by pointing your browser at http://localhost:7000/"
1242     echo ""
1243     hat -JXmx512m $localFile
1244 }
1245
1246 function getbugreports()
1247 {
1248     local reports=(`adb shell ls /sdcard/bugreports | tr -d '\r'`)
1249
1250     if [ ! "$reports" ]; then
1251         echo "Could not locate any bugreports."
1252         return
1253     fi
1254
1255     local report
1256     for report in ${reports[@]}
1257     do
1258         echo "/sdcard/bugreports/${report}"
1259         adb pull /sdcard/bugreports/${report} ${report}
1260         gunzip ${report}
1261     done
1262 }
1263
1264 function getsdcardpath()
1265 {
1266     adb ${adbOptions} shell echo -n \$\{EXTERNAL_STORAGE\}
1267 }
1268
1269 function getscreenshotpath()
1270 {
1271     echo "$(getsdcardpath)/Pictures/Screenshots"
1272 }
1273
1274 function getlastscreenshot()
1275 {
1276     local screenshot_path=$(getscreenshotpath)
1277     local screenshot=`adb ${adbOptions} ls ${screenshot_path} | grep Screenshot_[0-9-]*.*\.png | sort -rk 3 | cut -d " " -f 4 | head -n 1`
1278     if [ "$screenshot" = "" ]; then
1279         echo "No screenshots found."
1280         return
1281     fi
1282     echo "${screenshot}"
1283     adb ${adbOptions} pull ${screenshot_path}/${screenshot}
1284 }
1285
1286 function startviewserver()
1287 {
1288     local port=4939
1289     if [ $# -gt 0 ]; then
1290             port=$1
1291     fi
1292     adb shell service call window 1 i32 $port
1293 }
1294
1295 function stopviewserver()
1296 {
1297     adb shell service call window 2
1298 }
1299
1300 function isviewserverstarted()
1301 {
1302     adb shell service call window 3
1303 }
1304
1305 function key_home()
1306 {
1307     adb shell input keyevent 3
1308 }
1309
1310 function key_back()
1311 {
1312     adb shell input keyevent 4
1313 }
1314
1315 function key_menu()
1316 {
1317     adb shell input keyevent 82
1318 }
1319
1320 function smoketest()
1321 {
1322     if [ ! "$ANDROID_PRODUCT_OUT" ]; then
1323         echo "Couldn't locate output files.  Try running 'lunch' first." >&2
1324         return
1325     fi
1326     T=$(gettop)
1327     if [ ! "$T" ]; then
1328         echo "Couldn't locate the top of the tree.  Try setting TOP." >&2
1329         return
1330     fi
1331
1332     (\cd "$T" && mmm tests/SmokeTest) &&
1333       adb uninstall com.android.smoketest > /dev/null &&
1334       adb uninstall com.android.smoketest.tests > /dev/null &&
1335       adb install $ANDROID_PRODUCT_OUT/data/app/SmokeTestApp.apk &&
1336       adb install $ANDROID_PRODUCT_OUT/data/app/SmokeTest.apk &&
1337       adb shell am instrument -w com.android.smoketest.tests/android.test.InstrumentationTestRunner
1338 }
1339
1340 # simple shortcut to the runtest command
1341 function runtest()
1342 {
1343     T=$(gettop)
1344     if [ ! "$T" ]; then
1345         echo "Couldn't locate the top of the tree.  Try setting TOP." >&2
1346         return
1347     fi
1348     ("$T"/development/testrunner/runtest.py $@)
1349 }
1350
1351 function godir () {
1352     if [[ -z "$1" ]]; then
1353         echo "Usage: godir <regex>"
1354         return
1355     fi
1356     T=$(gettop)
1357     if [[ ! -f $T/filelist ]]; then
1358         echo -n "Creating index..."
1359         (\cd $T; find . -wholename ./out -prune -o -wholename ./.repo -prune -o -type f > filelist)
1360         echo " Done"
1361         echo ""
1362     fi
1363     local lines
1364     lines=($(\grep "$1" $T/filelist | sed -e 's/\/[^/]*$//' | sort | uniq))
1365     if [[ ${#lines[@]} = 0 ]]; then
1366         echo "Not found"
1367         return
1368     fi
1369     local pathname
1370     local choice
1371     if [[ ${#lines[@]} > 1 ]]; then
1372         while [[ -z "$pathname" ]]; do
1373             local index=1
1374             local line
1375             for line in ${lines[@]}; do
1376                 printf "%6s %s\n" "[$index]" $line
1377                 index=$(($index + 1))
1378             done
1379             echo
1380             echo -n "Select one: "
1381             unset choice
1382             read choice
1383             if [[ $choice -gt ${#lines[@]} || $choice -lt 1 ]]; then
1384                 echo "Invalid choice"
1385                 continue
1386             fi
1387             pathname=${lines[$(($choice-1))]}
1388         done
1389     else
1390         pathname=${lines[0]}
1391     fi
1392     \cd $T/$pathname
1393 }
1394
1395 # Force JAVA_HOME to point to java 1.7 or java 1.6  if it isn't already set.
1396 #
1397 # Note that the MacOS path for java 1.7 includes a minor revision number (sigh).
1398 # For some reason, installing the JDK doesn't make it show up in the
1399 # JavaVM.framework/Versions/1.7/ folder.
1400 function set_java_home() {
1401     # Clear the existing JAVA_HOME value if we set it ourselves, so that
1402     # we can reset it later, depending on the version of java the build
1403     # system needs.
1404     #
1405     # If we don't do this, the JAVA_HOME value set by the first call to
1406     # build/envsetup.sh will persist forever.
1407     if [ -n "$ANDROID_SET_JAVA_HOME" ]; then
1408       export JAVA_HOME=""
1409     fi
1410
1411     if [ ! "$JAVA_HOME" ]; then
1412       if [ -n "$LEGACY_USE_JAVA6" ]; then
1413         case `uname -s` in
1414             Darwin)
1415                 export JAVA_HOME=/System/Library/Frameworks/JavaVM.framework/Versions/1.6/Home
1416                 ;;
1417             *)
1418                 export JAVA_HOME=/usr/lib/jvm/java-6-sun
1419                 ;;
1420         esac
1421       else
1422         case `uname -s` in
1423             Darwin)
1424                 export JAVA_HOME=$(/usr/libexec/java_home -v 1.7)
1425                 ;;
1426             *)
1427                 export JAVA_HOME=/usr/lib/jvm/java-7-openjdk-amd64
1428                 ;;
1429         esac
1430       fi
1431
1432       # Keep track of the fact that we set JAVA_HOME ourselves, so that
1433       # we can change it on the next envsetup.sh, if required.
1434       export ANDROID_SET_JAVA_HOME=true
1435     fi
1436 }
1437
1438 # Print colored exit condition
1439 function pez {
1440     "$@"
1441     local retval=$?
1442     if [ $retval -ne 0 ]
1443     then
1444         echo -e "\e[0;31mFAILURE\e[00m"
1445     else
1446         echo -e "\e[0;32mSUCCESS\e[00m"
1447     fi
1448     return $retval
1449 }
1450
1451 if [ "x$SHELL" != "x/bin/bash" ]; then
1452     case `ps -o command -p $$` in
1453         *bash*)
1454             ;;
1455         *)
1456             echo "WARNING: Only bash is supported, use of other shell would lead to erroneous results"
1457             ;;
1458     esac
1459 fi
1460
1461 # Execute the contents of any vendorsetup.sh files we can find.
1462 for f in `test -d device && find device -maxdepth 4 -name 'vendorsetup.sh' 2> /dev/null` \
1463          `test -d vendor && find vendor -maxdepth 4 -name 'vendorsetup.sh' 2> /dev/null`
1464 do
1465     echo "including $f"
1466     . $f
1467 done
1468 unset f
1469
1470 addcompletions