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