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] [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.
   9 - mmm:     Builds all of the modules in the supplied directories.
  10 - cgrep:   Greps on all local C/C++ files.
  11 - jgrep:   Greps on all local Java files.
  12 - resgrep: Greps on all local res/*.xml files.
  13 - godir:   Go to the directory containing a file.
  14
  15 Look at the source to view more functions. The complete list is:
  16 EOF
  17     T=$(gettop)
  18     local A
  19     A=""
  20     for i in `cat $T/build/envsetup.sh | sed -n "/^function /s/function \([a-z_]*\).*/\1/p" | sort`; do
  21       A="$A $i"
  22     done
  23     echo $A
  24 }
  25
  26 # Get the value of a build variable as an absolute path.
  27 function get_abs_build_var()
  28 {
  29     T=$(gettop)
  30     if [ ! "$T" ]; then
  31         echo "Couldn't locate the top of the tree.  Try setting TOP." >&2
  32         return
  33     fi
  34     (\cd $T; CALLED_FROM_SETUP=true BUILD_SYSTEM=build/core \
  35       make --no-print-directory -C "$T" -f build/core/config.mk dumpvar-abs-$1)
  36 }
  37
  38 # Get the exact value of a build variable.
  39 function get_build_var()
  40 {
  41     T=$(gettop)
  42     if [ ! "$T" ]; then
  43         echo "Couldn't locate the top of the tree.  Try setting TOP." >&2
  44         return
  45     fi
  46     CALLED_FROM_SETUP=true BUILD_SYSTEM=build/core \
  47       make --no-print-directory -C "$T" -f build/core/config.mk dumpvar-$1
  48 }
  49
  50 # check to see if the supplied product is one we can build
  51 function check_product()
  52 {
  53     T=$(gettop)
  54     if [ ! "$T" ]; then
  55         echo "Couldn't locate the top of the tree.  Try setting TOP." >&2
  56         return
  57     fi
  58     CALLED_FROM_SETUP=true BUILD_SYSTEM=build/core \
  59         TARGET_PRODUCT=$1 \
  60         TARGET_BUILD_VARIANT= \
  61         TARGET_BUILD_TYPE= \
  62         TARGET_BUILD_APPS= \
  63         get_build_var TARGET_DEVICE > /dev/null
  64     # hide successful answers, but allow the errors to show
  65 }
  66
  67 VARIANT_CHOICES=(user userdebug eng)
  68
  69 # check to see if the supplied variant is valid
  70 function check_variant()
  71 {
  72     for v in ${VARIANT_CHOICES[@]}
  73     do
  74         if [ "$v" = "$1" ]
  75         then
  76             return 0
  77         fi
  78     done
  79     return 1
  80 }
  81
  82 function setpaths()
  83 {
  84     T=$(gettop)
  85     if [ ! "$T" ]; then
  86         echo "Couldn't locate the top of the tree.  Try setting TOP."
  87         return
  88     fi
  89
  90     ##################################################################
  91     #                                                                #
  92     #              Read me before you modify this code               #
  93     #                                                                #
  94     #   This function sets ANDROID_BUILD_PATHS to what it is adding  #
  95     #   to PATH, and the next time it is run, it removes that from   #
  96     #   PATH.  This is required so lunch can be run more than once   #
  97     #   and still have working paths.                                #
  98     #                                                                #
  99     ##################################################################
 100
 101     # Note: on windows/cygwin, ANDROID_BUILD_PATHS will contain spaces
 102     # due to "C:\Program Files" being in the path.
 103
 104     # out with the old
 105     if [ -n "$ANDROID_BUILD_PATHS" ] ; then
 106         export PATH=${PATH/$ANDROID_BUILD_PATHS/}
 107     fi
 108     if [ -n "$ANDROID_PRE_BUILD_PATHS" ] ; then
 109         export PATH=${PATH/$ANDROID_PRE_BUILD_PATHS/}
 110         # strip leading ':', if any
 111         export PATH=${PATH/:%/}
 112     fi
 113
 114     # and in with the new
 115     CODE_REVIEWS=
 116     prebuiltdir=$(getprebuilt)
 117     gccprebuiltdir=$(get_abs_build_var ANDROID_GCC_PREBUILTS)
 118
 119     # defined in core/config.mk
 120     targetgccversion=$(get_build_var TARGET_GCC_VERSION)
 121     export TARGET_GCC_VERSION=$targetgccversion
 122
 123     # The gcc toolchain does not exists for windows/cygwin. In this case, do not reference it.
 124     export ANDROID_EABI_TOOLCHAIN=
 125     local ARCH=$(get_build_var TARGET_ARCH)
 126     case $ARCH in
 127         x86) toolchaindir=x86/i686-linux-android-$targetgccversion/bin
 128             ;;
 129         arm) toolchaindir=arm/arm-linux-androideabi-$targetgccversion/bin
 130             ;;
 131         mips) toolchaindir=mips/mipsel-linux-android-$targetgccversion/bin
 132             ;;
 133         *)
 134             echo "Can't find toolchain for unknown architecture: $ARCH"
 135             toolchaindir=xxxxxxxxx
 136             ;;
 137     esac
 138     if [ -d "$gccprebuiltdir/$toolchaindir" ]; then
 139         export ANDROID_EABI_TOOLCHAIN=$gccprebuiltdir/$toolchaindir
 140     fi
 141
 142     unset ARM_EABI_TOOLCHAIN ARM_EABI_TOOLCHAIN_PATH
 143     case $ARCH in
 144         arm)
 145             toolchaindir=arm/arm-eabi-$targetgccversion/bin
 146             if [ -d "$gccprebuiltdir/$toolchaindir" ]; then
 147                  export ARM_EABI_TOOLCHAIN="$gccprebuiltdir/$toolchaindir"
 148                  ARM_EABI_TOOLCHAIN_PATH=":$gccprebuiltdir/$toolchaindir"
 149             fi
 150             ;;
 151         mips) toolchaindir=mips/mips-eabi-4.4.3/bin
 152             ;;
 153         *)
 154             # No need to set ARM_EABI_TOOLCHAIN for other ARCHs
 155             ;;
 156     esac
 157
 158     export ANDROID_TOOLCHAIN=$ANDROID_EABI_TOOLCHAIN
 159     export ANDROID_QTOOLS=$T/development/emulator/qtools
 160     export ANDROID_DEV_SCRIPTS=$T/development/scripts
 161     export ANDROID_BUILD_PATHS=$(get_build_var ANDROID_BUILD_PATHS):$ANDROID_QTOOLS:$ANDROID_TOOLCHAIN$ARM_EABI_TOOLCHAIN_PATH$CODE_REVIEWS:$ANDROID_DEV_SCRIPTS:
 162     export PATH=$ANDROID_BUILD_PATHS$PATH
 163
 164     unset ANDROID_JAVA_TOOLCHAIN
 165     unset ANDROID_PRE_BUILD_PATHS
 166     if [ -n "$JAVA_HOME" ]; then
 167         export ANDROID_JAVA_TOOLCHAIN=$JAVA_HOME/bin
 168         export ANDROID_PRE_BUILD_PATHS=$ANDROID_JAVA_TOOLCHAIN:
 169         export PATH=$ANDROID_PRE_BUILD_PATHS$PATH
 170     fi
 171
 172     unset ANDROID_PRODUCT_OUT
 173     export ANDROID_PRODUCT_OUT=$(get_abs_build_var PRODUCT_OUT)
 174     export OUT=$ANDROID_PRODUCT_OUT
 175
 176     unset ANDROID_HOST_OUT
 177     export ANDROID_HOST_OUT=$(get_abs_build_var HOST_OUT)
 178
 179     # needed for processing samples collected by perf counters
 180     unset OPROFILE_EVENTS_DIR
 181     export OPROFILE_EVENTS_DIR=$T/external/oprofile/events
 182
 183     # needed for building linux on MacOS
 184     # TODO: fix the path
 185     #export HOST_EXTRACFLAGS="-I "$T/system/kernel_headers/host_include
 186 }
 187
 188 function printconfig()
 189 {
 190     T=$(gettop)
 191     if [ ! "$T" ]; then
 192         echo "Couldn't locate the top of the tree.  Try setting TOP." >&2
 193         return
 194     fi
 195     get_build_var report_config
 196 }
 197
 198 function set_stuff_for_environment()
 199 {
 200     settitle
 201     set_java_home
 202     setpaths
 203     set_sequence_number
 204
 205     export ANDROID_BUILD_TOP=$(gettop)
 206 }
 207
 208 function set_sequence_number()
 209 {
 210     export BUILD_ENV_SEQUENCE_NUMBER=10
 211 }
 212
 213 function settitle()
 214 {
 215     if [ "$STAY_OFF_MY_LAWN" = "" ]; then
 216         local arch=$(gettargetarch)
 217         local product=$TARGET_PRODUCT
 218         local variant=$TARGET_BUILD_VARIANT
 219         local apps=$TARGET_BUILD_APPS
 220         if [ -z "$apps" ]; then
 221             export PROMPT_COMMAND="echo -ne \"\033]0;[${arch}-${product}-${variant}] ${USER}@${HOSTNAME}: ${PWD}\007\""
 222         else
 223             export PROMPT_COMMAND="echo -ne \"\033]0;[$arch $apps $variant] ${USER}@${HOSTNAME}: ${PWD}\007\""
 224         fi
 225     fi
 226 }
 227
 228 function addcompletions()
 229 {
 230     local T dir f
 231
 232     # Keep us from trying to run in something that isn't bash.
 233     if [ -z "${BASH_VERSION}" ]; then
 234         return
 235     fi
 236
 237     # Keep us from trying to run in bash that's too old.
 238     if [ ${BASH_VERSINFO[0]} -lt 3 ]; then
 239         return
 240     fi
 241
 242     dir="sdk/bash_completion"
 243     if [ -d ${dir} ]; then
 244         for f in `/bin/ls ${dir}/[a-z]*.bash 2> /dev/null`; do
 245             echo "including $f"
 246             . $f
 247         done
 248     fi
 249 }
 250
 251 function choosetype()
 252 {
 253     echo "Build type choices are:"
 254     echo "     1. release"
 255     echo "     2. debug"
 256     echo
 257
 258     local DEFAULT_NUM DEFAULT_VALUE
 259     DEFAULT_NUM=1
 260     DEFAULT_VALUE=release
 261
 262     export TARGET_BUILD_TYPE=
 263     local ANSWER
 264     while [ -z $TARGET_BUILD_TYPE ]
 265     do
 266         echo -n "Which would you like? ["$DEFAULT_NUM"] "
 267         if [ -z "$1" ] ; then
 268             read ANSWER
 269         else
 270             echo $1
 271             ANSWER=$1
 272         fi
 273         case $ANSWER in
 274         "")
 275             export TARGET_BUILD_TYPE=$DEFAULT_VALUE
 276             ;;
 277         1)
 278             export TARGET_BUILD_TYPE=release
 279             ;;
 280         release)
 281             export TARGET_BUILD_TYPE=release
 282             ;;
 283         2)
 284             export TARGET_BUILD_TYPE=debug
 285             ;;
 286         debug)
 287             export TARGET_BUILD_TYPE=debug
 288             ;;
 289         *)
 290             echo
 291             echo "I didn't understand your response.  Please try again."
 292             echo
 293             ;;
 294         esac
 295         if [ -n "$1" ] ; then
 296             break
 297         fi
 298     done
 299
 300     set_stuff_for_environment
 301 }
 302
 303 #
 304 # This function isn't really right:  It chooses a TARGET_PRODUCT
 305 # based on the list of boards.  Usually, that gets you something
 306 # that kinda works with a generic product, but really, you should
 307 # pick a product by name.
 308 #
 309 function chooseproduct()
 310 {
 311     if [ "x$TARGET_PRODUCT" != x ] ; then
 312         default_value=$TARGET_PRODUCT
 313     else
 314         default_value=full
 315     fi
 316
 317     export TARGET_PRODUCT=
 318     local ANSWER
 319     while [ -z "$TARGET_PRODUCT" ]
 320     do
 321         echo -n "Which product would you like? [$default_value] "
 322         if [ -z "$1" ] ; then
 323             read ANSWER
 324         else
 325             echo $1
 326             ANSWER=$1
 327         fi
 328
 329         if [ -z "$ANSWER" ] ; then
 330             export TARGET_PRODUCT=$default_value
 331         else
 332             if check_product $ANSWER
 333             then
 334                 export TARGET_PRODUCT=$ANSWER
 335             else
 336                 echo "** Not a valid product: $ANSWER"
 337             fi
 338         fi
 339         if [ -n "$1" ] ; then
 340             break
 341         fi
 342     done
 343
 344     set_stuff_for_environment
 345 }
 346
 347 function choosevariant()
 348 {
 349     echo "Variant choices are:"
 350     local index=1
 351     local v
 352     for v in ${VARIANT_CHOICES[@]}
 353     do
 354         # The product name is the name of the directory containing
 355         # the makefile we found, above.
 356         echo "     $index. $v"
 357         index=$(($index+1))
 358     done
 359
 360     local default_value=eng
 361     local ANSWER
 362
 363     export TARGET_BUILD_VARIANT=
 364     while [ -z "$TARGET_BUILD_VARIANT" ]
 365     do
 366         echo -n "Which would you like? [$default_value] "
 367         if [ -z "$1" ] ; then
 368             read ANSWER
 369         else
 370             echo $1
 371             ANSWER=$1
 372         fi
 373
 374         if [ -z "$ANSWER" ] ; then
 375             export TARGET_BUILD_VARIANT=$default_value
 376         elif (echo -n $ANSWER | grep -q -e "^[0-9][0-9]*$") ; then
 377             if [ "$ANSWER" -le "${#VARIANT_CHOICES[@]}" ] ; then
 378                 export TARGET_BUILD_VARIANT=${VARIANT_CHOICES[$(($ANSWER-1))]}
 379             fi
 380         else
 381             if check_variant $ANSWER
 382             then
 383                 export TARGET_BUILD_VARIANT=$ANSWER
 384             else
 385                 echo "** Not a valid variant: $ANSWER"
 386             fi
 387         fi
 388         if [ -n "$1" ] ; then
 389             break
 390         fi
 391     done
 392 }
 393
 394 function choosecombo()
 395 {
 396     choosetype $1
 397
 398     echo
 399     echo
 400     chooseproduct $2
 401
 402     echo
 403     echo
 404     choosevariant $3
 405
 406     echo
 407     set_stuff_for_environment
 408     printconfig
 409 }
 410
 411 # Clear this variable.  It will be built up again when the vendorsetup.sh
 412 # files are included at the end of this file.
 413 unset LUNCH_MENU_CHOICES
 414 function add_lunch_combo()
 415 {
 416     local new_combo=$1
 417     local c
 418     for c in ${LUNCH_MENU_CHOICES[@]} ; do
 419         if [ "$new_combo" = "$c" ] ; then
 420             return
 421         fi
 422     done
 423     LUNCH_MENU_CHOICES=(${LUNCH_MENU_CHOICES[@]} $new_combo)
 424 }
 425
 426 # add the default one here
 427 add_lunch_combo full-eng
 428 add_lunch_combo full_x86-eng
 429 add_lunch_combo vbox_x86-eng
 430 add_lunch_combo full_mips-eng
 431
 432 function print_lunch_menu()
 433 {
 434     local uname=$(uname)
 435     echo
 436     echo "You're building on" $uname
 437     echo
 438     echo "Lunch menu... pick a combo:"
 439
 440     local i=1
 441     local choice
 442     for choice in ${LUNCH_MENU_CHOICES[@]}
 443     do
 444         echo "     $i. $choice"
 445         i=$(($i+1))
 446     done
 447
 448     echo
 449 }
 450
 451 function lunch()
 452 {
 453     local answer
 454
 455     if [ "$1" ] ; then
 456         answer=$1
 457     else
 458         print_lunch_menu
 459         echo -n "Which would you like? [full-eng] "
 460         read answer
 461     fi
 462
 463     local selection=
 464
 465     if [ -z "$answer" ]
 466     then
 467         selection=full-eng
 468     elif (echo -n $answer | grep -q -e "^[0-9][0-9]*$")
 469     then
 470         if [ $answer -le ${#LUNCH_MENU_CHOICES[@]} ]
 471         then
 472             selection=${LUNCH_MENU_CHOICES[$(($answer-1))]}
 473         fi
 474     elif (echo -n $answer | grep -q -e "^[^\-][^\-]*-[^\-][^\-]*$")
 475     then
 476         selection=$answer
 477     fi
 478
 479     if [ -z "$selection" ]
 480     then
 481         echo
 482         echo "Invalid lunch combo: $answer"
 483         return 1
 484     fi
 485
 486     export TARGET_BUILD_APPS=
 487
 488     local product=$(echo -n $selection | sed -e "s/-.*$//")
 489     check_product $product
 490     if [ $? -ne 0 ]
 491     then
 492         echo
 493         echo "** Don't have a product spec for: '$product'"
 494         echo "** Do you have the right repo manifest?"
 495         product=
 496     fi
 497
 498     local variant=$(echo -n $selection | sed -e "s/^[^\-]*-//")
 499     check_variant $variant
 500     if [ $? -ne 0 ]
 501     then
 502         echo
 503         echo "** Invalid variant: '$variant'"
 504         echo "** Must be one of ${VARIANT_CHOICES[@]}"
 505         variant=
 506     fi
 507
 508     if [ -z "$product" -o -z "$variant" ]
 509     then
 510         echo
 511         return 1
 512     fi
 513
 514     export TARGET_PRODUCT=$product
 515     export TARGET_BUILD_VARIANT=$variant
 516     export TARGET_BUILD_TYPE=release
 517
 518     echo
 519
 520     set_stuff_for_environment
 521     printconfig
 522 }
 523
 524 # Tab completion for lunch.
 525 function _lunch()
 526 {
 527     local cur prev opts
 528     COMPREPLY=()
 529     cur="${COMP_WORDS[COMP_CWORD]}"
 530     prev="${COMP_WORDS[COMP_CWORD-1]}"
 531
 532     COMPREPLY=( $(compgen -W "${LUNCH_MENU_CHOICES[*]}" -- ${cur}) )
 533     return 0
 534 }
 535 complete -F _lunch lunch
 536
 537 # Configures the build to build unbundled apps.
 538 # Run tapas with one ore more app names (from LOCAL_PACKAGE_NAME)
 539 function tapas()
 540 {
 541     local arch=$(echo -n $(echo $* | xargs -n 1 echo | \grep -E '^(arm|x86|mips)$'))
 542     local variant=$(echo -n $(echo $* | xargs -n 1 echo | \grep -E '^(user|userdebug|eng)$'))
 543     local apps=$(echo -n $(echo $* | xargs -n 1 echo | \grep -E -v '^(user|userdebug|eng|arm|x86|mips)$'))
 544
 545     if [ $(echo $arch | wc -w) -gt 1 ]; then
 546         echo "tapas: Error: Multiple build archs supplied: $arch"
 547         return
 548     fi
 549     if [ $(echo $variant | wc -w) -gt 1 ]; then
 550         echo "tapas: Error: Multiple build variants supplied: $variant"
 551         return
 552     fi
 553
 554     local product=full
 555     case $arch in
 556       x86)   product=full_x86;;
 557       mips)  product=full_mips;;
 558     esac
 559     if [ -z "$variant" ]; then
 560         variant=eng
 561     fi
 562     if [ -z "$apps" ]; then
 563         apps=all
 564     fi
 565
 566     export TARGET_PRODUCT=$product
 567     export TARGET_BUILD_VARIANT=$variant
 568     export TARGET_BUILD_TYPE=release
 569     export TARGET_BUILD_APPS=$apps
 570
 571     set_stuff_for_environment
 572     printconfig
 573 }
 574
 575 function gettop
 576 {
 577     local TOPFILE=build/core/envsetup.mk
 578     if [ -n "$TOP" -a -f "$TOP/$TOPFILE" ] ; then
 579         echo $TOP
 580     else
 581         if [ -f $TOPFILE ] ; then
 582             # The following circumlocution (repeated below as well) ensures
 583             # that we record the true directory name and not one that is
 584             # faked up with symlink names.
 585             PWD= /bin/pwd
 586         else
 587             local HERE=$PWD
 588             T=
 589             while [ \( ! \( -f $TOPFILE \) \) -a \( $PWD != "/" \) ]; do
 590                 \cd ..
 591                 T=`PWD= /bin/pwd`
 592             done
 593             \cd $HERE
 594             if [ -f "$T/$TOPFILE" ]; then
 595                 echo $T
 596             fi
 597         fi
 598     fi
 599 }
 600
 601 function m()
 602 {
 603     T=$(gettop)
 604     if [ "$T" ]; then
 605         make -C $T $@
 606     else
 607         echo "Couldn't locate the top of the tree.  Try setting TOP."
 608     fi
 609 }
 610
 611 function findmakefile()
 612 {
 613     TOPFILE=build/core/envsetup.mk
 614     local HERE=$PWD
 615     T=
 616     while [ \( ! \( -f $TOPFILE \) \) -a \( $PWD != "/" \) ]; do
 617         T=`PWD= /bin/pwd`
 618         if [ -f "$T/Android.mk" ]; then
 619             echo $T/Android.mk
 620             \cd $HERE
 621             return
 622         fi
 623         \cd ..
 624     done
 625     \cd $HERE
 626 }
 627
 628 function mm()
 629 {
 630     # If we're sitting in the root of the build tree, just do a
 631     # normal make.
 632     if [ -f build/core/envsetup.mk -a -f Makefile ]; then
 633         make $@
 634     else
 635         # Find the closest Android.mk file.
 636         T=$(gettop)
 637         local M=$(findmakefile)
 638         # Remove the path to top as the makefilepath needs to be relative
 639         local M=`echo $M|sed 's:'$T'/::'`
 640         if [ ! "$T" ]; then
 641             echo "Couldn't locate the top of the tree.  Try setting TOP."
 642         elif [ ! "$M" ]; then
 643             echo "Couldn't locate a makefile from the current directory."
 644         else
 645             ONE_SHOT_MAKEFILE=$M make -C $T all_modules $@
 646         fi
 647     fi
 648 }
 649
 650 function mmm()
 651 {
 652     T=$(gettop)
 653     if [ "$T" ]; then
 654         local MAKEFILE=
 655         local MODULES=
 656         local ARGS=
 657         local DIR TO_CHOP
 658         local DASH_ARGS=$(echo "$@" | awk -v RS=" " -v ORS=" " '/^-.*$/')
 659         local DIRS=$(echo "$@" | awk -v RS=" " -v ORS=" " '/^[^-].*$/')
 660         for DIR in $DIRS ; do
 661             MODULES=`echo $DIR | sed -n -e 's/.*:\(.*$\)/\1/p' | sed 's/,/ /'`
 662             if [ "$MODULES" = "" ]; then
 663                 MODULES=all_modules
 664             fi
 665             DIR=`echo $DIR | sed -e 's/:.*//' -e 's:/$::'`
 666             if [ -f $DIR/Android.mk ]; then
 667                 TO_CHOP=`(\cd -P -- $T && pwd -P) | wc -c | tr -d ' '`
 668                 TO_CHOP=`expr $TO_CHOP + 1`
 669                 START=`PWD= /bin/pwd`
 670                 MFILE=`echo $START | cut -c${TO_CHOP}-`
 671                 if [ "$MFILE" = "" ] ; then
 672                     MFILE=$DIR/Android.mk
 673                 else
 674                     MFILE=$MFILE/$DIR/Android.mk
 675                 fi
 676                 MAKEFILE="$MAKEFILE $MFILE"
 677             else
 678                 if [ "$DIR" = snod ]; then
 679                     ARGS="$ARGS snod"
 680                 elif [ "$DIR" = showcommands ]; then
 681                     ARGS="$ARGS showcommands"
 682                 elif [ "$DIR" = dist ]; then
 683                     ARGS="$ARGS dist"
 684                 elif [ "$DIR" = incrementaljavac ]; then
 685                     ARGS="$ARGS incrementaljavac"
 686                 else
 687                     echo "No Android.mk in $DIR."
 688                     return 1
 689                 fi
 690             fi
 691         done
 692         ONE_SHOT_MAKEFILE="$MAKEFILE" make -C $T $DASH_ARGS $MODULES $ARGS
 693     else
 694         echo "Couldn't locate the top of the tree.  Try setting TOP."
 695     fi
 696 }
 697
 698 function croot()
 699 {
 700     T=$(gettop)
 701     if [ "$T" ]; then
 702         \cd $(gettop)
 703     else
 704         echo "Couldn't locate the top of the tree.  Try setting TOP."
 705     fi
 706 }
 707
 708 function cproj()
 709 {
 710     TOPFILE=build/core/envsetup.mk
 711     local HERE=$PWD
 712     T=
 713     while [ \( ! \( -f $TOPFILE \) \) -a \( $PWD != "/" \) ]; do
 714         T=$PWD
 715         if [ -f "$T/Android.mk" ]; then
 716             \cd $T
 717             return
 718         fi
 719         \cd ..
 720     done
 721     \cd $HERE
 722     echo "can't find Android.mk"
 723 }
 724
 725 function pid()
 726 {
 727    local EXE="$1"
 728    if [ "$EXE" ] ; then
 729        local PID=`adb shell ps | fgrep $1 | sed -e 's/[^ ]* *\([0-9]*\).*/\1/'`
 730        echo "$PID"
 731    else
 732        echo "usage: pid name"
 733    fi
 734 }
 735
 736 # systemstack - dump the current stack trace of all threads in the system process
 737 # to the usual ANR traces file
 738 function systemstack()
 739 {
 740     adb shell echo '""' '>>' /data/anr/traces.txt && adb shell chmod 776 /data/anr/traces.txt && adb shell kill -3 $(pid system_server)
 741 }
 742
 743 function gdbclient()
 744 {
 745    local OUT_ROOT=$(get_abs_build_var PRODUCT_OUT)
 746    local OUT_SYMBOLS=$(get_abs_build_var TARGET_OUT_UNSTRIPPED)
 747    local OUT_SO_SYMBOLS=$(get_abs_build_var TARGET_OUT_SHARED_LIBRARIES_UNSTRIPPED)
 748    local OUT_EXE_SYMBOLS=$(get_abs_build_var TARGET_OUT_EXECUTABLES_UNSTRIPPED)
 749    local PREBUILTS=$(get_abs_build_var ANDROID_PREBUILTS)
 750    local ARCH=$(get_build_var TARGET_ARCH)
 751    local GDB
 752    case "$ARCH" in
 753        x86) GDB=i686-linux-android-gdb;;
 754        arm) GDB=arm-linux-androideabi-gdb;;
 755        mips) GDB=mipsel-linux-android-gdb;;
 756        *) echo "Unknown arch $ARCH"; return 1;;
 757    esac
 758
 759    if [ "$OUT_ROOT" -a "$PREBUILTS" ]; then
 760        local EXE="$1"
 761        if [ "$EXE" ] ; then
 762            EXE=$1
 763        else
 764            EXE="app_process"
 765        fi
 766
 767        local PORT="$2"
 768        if [ "$PORT" ] ; then
 769            PORT=$2
 770        else
 771            PORT=":5039"
 772        fi
 773
 774        local PID
 775        local PROG="$3"
 776        if [ "$PROG" ] ; then
 777            if [[ "$PROG" =~ ^[0-9]+$ ]] ; then
 778                PID="$3"
 779            else
 780                PID=`pid $3`
 781            fi
 782            adb forward "tcp$PORT" "tcp$PORT"
 783            adb shell gdbserver $PORT --attach $PID &
 784            sleep 2
 785        else
 786                echo ""
 787                echo "If you haven't done so already, do this first on the device:"
 788                echo "    gdbserver $PORT /system/bin/$EXE"
 789                    echo " or"
 790                echo "    gdbserver $PORT --attach $PID"
 791                echo ""
 792        fi
 793
 794        echo >|"$OUT_ROOT/gdbclient.cmds" "set solib-absolute-prefix $OUT_SYMBOLS"
 795        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"
 796        echo >>"$OUT_ROOT/gdbclient.cmds" "target remote $PORT"
 797        echo >>"$OUT_ROOT/gdbclient.cmds" ""
 798
 799        $ANDROID_TOOLCHAIN/$GDB -x "$OUT_ROOT/gdbclient.cmds" "$OUT_EXE_SYMBOLS/$EXE"
 800   else
 801        echo "Unable to determine build system output dir."
 802    fi
 803
 804 }
 805
 806 case `uname -s` in
 807     Darwin)
 808         function sgrep()
 809         {
 810             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 "$@"
 811         }
 812
 813         ;;
 814     *)
 815         function sgrep()
 816         {
 817             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 "$@"
 818         }
 819         ;;
 820 esac
 821
 822 function gettargetarch
 823 {
 824     get_build_var TARGET_ARCH
 825 }
 826
 827 function jgrep()
 828 {
 829     find . -name .repo -prune -o -name .git -prune -o  -type f -name "*\.java" -print0 | xargs -0 grep --color -n "$@"
 830 }
 831
 832 function cgrep()
 833 {
 834     find . -name .repo -prune -o -name .git -prune -o -type f \( -name '*.c' -o -name '*.cc' -o -name '*.cpp' -o -name '*.h' \) -print0 | xargs -0 grep --color -n "$@"
 835 }
 836
 837 function resgrep()
 838 {
 839     for dir in `find . -name .repo -prune -o -name .git -prune -o -name res -type d`; do find $dir -type f -name '*\.xml' -print0 | xargs -0 grep --color -n "$@"; done;
 840 }
 841
 842 case `uname -s` in
 843     Darwin)
 844         function mgrep()
 845         {
 846             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 "$@"
 847         }
 848
 849         function treegrep()
 850         {
 851             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 "$@"
 852         }
 853
 854         ;;
 855     *)
 856         function mgrep()
 857         {
 858             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 "$@"
 859         }
 860
 861         function treegrep()
 862         {
 863             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 "$@"
 864         }
 865
 866         ;;
 867 esac
 868
 869 function getprebuilt
 870 {
 871     get_abs_build_var ANDROID_PREBUILTS
 872 }
 873
 874 function tracedmdump()
 875 {
 876     T=$(gettop)
 877     if [ ! "$T" ]; then
 878         echo "Couldn't locate the top of the tree.  Try setting TOP."
 879         return
 880     fi
 881     local prebuiltdir=$(getprebuilt)
 882     local arch=$(gettargetarch)
 883     local KERNEL=$T/prebuilts/qemu-kernel/$arch/vmlinux-qemu
 884
 885     local TRACE=$1
 886     if [ ! "$TRACE" ] ; then
 887         echo "usage:  tracedmdump  tracename"
 888         return
 889     fi
 890
 891     if [ ! -r "$KERNEL" ] ; then
 892         echo "Error: cannot find kernel: '$KERNEL'"
 893         return
 894     fi
 895
 896     local BASETRACE=$(basename $TRACE)
 897     if [ "$BASETRACE" = "$TRACE" ] ; then
 898         TRACE=$ANDROID_PRODUCT_OUT/traces/$TRACE
 899     fi
 900
 901     echo "post-processing traces..."
 902     rm -f $TRACE/qtrace.dexlist
 903     post_trace $TRACE
 904     if [ $? -ne 0 ]; then
 905         echo "***"
 906         echo "*** Error: malformed trace.  Did you remember to exit the emulator?"
 907         echo "***"
 908         return
 909     fi
 910     echo "generating dexlist output..."
 911     /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
 912     echo "generating dmtrace data..."
 913     q2dm -r $ANDROID_PRODUCT_OUT/symbols $TRACE $KERNEL $TRACE/dmtrace || return
 914     echo "generating html file..."
 915     dmtracedump -h $TRACE/dmtrace >| $TRACE/dmtrace.html || return
 916     echo "done, see $TRACE/dmtrace.html for details"
 917     echo "or run:"
 918     echo "    traceview $TRACE/dmtrace"
 919 }
 920
 921 # communicate with a running device or emulator, set up necessary state,
 922 # and run the hat command.
 923 function runhat()
 924 {
 925     # process standard adb options
 926     local adbTarget=""
 927     if [ "$1" = "-d" -o "$1" = "-e" ]; then
 928         adbTarget=$1
 929         shift 1
 930     elif [ "$1" = "-s" ]; then
 931         adbTarget="$1 $2"
 932         shift 2
 933     fi
 934     local adbOptions=${adbTarget}
 935     #echo adbOptions = ${adbOptions}
 936
 937     # runhat options
 938     local targetPid=$1
 939
 940     if [ "$targetPid" = "" ]; then
 941         echo "Usage: runhat [ -d | -e | -s serial ] target-pid"
 942         return
 943     fi
 944
 945     # confirm hat is available
 946     if [ -z $(which hat) ]; then
 947         echo "hat is not available in this configuration."
 948         return
 949     fi
 950
 951     # issue "am" command to cause the hprof dump
 952     local sdcard=$(adb shell echo -n '$EXTERNAL_STORAGE')
 953     local devFile=$sdcard/hprof-$targetPid
 954     #local devFile=/data/local/hprof-$targetPid
 955     echo "Poking $targetPid and waiting for data..."
 956     echo "Storing data at $devFile"
 957     adb ${adbOptions} shell am dumpheap $targetPid $devFile
 958     echo "Press enter when logcat shows \"hprof: heap dump completed\""
 959     echo -n "> "
 960     read
 961
 962     local localFile=/tmp/$$-hprof
 963
 964     echo "Retrieving file $devFile..."
 965     adb ${adbOptions} pull $devFile $localFile
 966
 967     adb ${adbOptions} shell rm $devFile
 968
 969     echo "Running hat on $localFile"
 970     echo "View the output by pointing your browser at http://localhost:7000/"
 971     echo ""
 972     hat -JXmx512m $localFile
 973 }
 974
 975 function getbugreports()
 976 {
 977     local reports=(`adb shell ls /sdcard/bugreports | tr -d '\r'`)
 978
 979     if [ ! "$reports" ]; then
 980         echo "Could not locate any bugreports."
 981         return
 982     fi
 983
 984     local report
 985     for report in ${reports[@]}
 986     do
 987         echo "/sdcard/bugreports/${report}"
 988         adb pull /sdcard/bugreports/${report} ${report}
 989         gunzip ${report}
 990     done
 991 }
 992
 993 function getsdcardpath()
 994 {
 995     adb ${adbOptions} shell echo -n \$\{EXTERNAL_STORAGE\}
 996 }
 997
 998 function getscreenshotpath()
 999 {
1000     echo "$(getsdcardpath)/Pictures/Screenshots"
1001 }
1002
1003 function getlastscreenshot()
1004 {
1005     local screenshot_path=$(getscreenshotpath)
1006     local screenshot=`adb ${adbOptions} ls ${screenshot_path} | grep Screenshot_[0-9-]*.*\.png | sort -rk 3 | cut -d " " -f 4 | head -n 1`
1007     if [ "$screenshot" = "" ]; then
1008         echo "No screenshots found."
1009         return
1010     fi
1011     echo "${screenshot}"
1012     adb ${adbOptions} pull ${screenshot_path}/${screenshot}
1013 }
1014
1015 function startviewserver()
1016 {
1017     local port=4939
1018     if [ $# -gt 0 ]; then
1019             port=$1
1020     fi
1021     adb shell service call window 1 i32 $port
1022 }
1023
1024 function stopviewserver()
1025 {
1026     adb shell service call window 2
1027 }
1028
1029 function isviewserverstarted()
1030 {
1031     adb shell service call window 3
1032 }
1033
1034 function key_home()
1035 {
1036     adb shell input keyevent 3
1037 }
1038
1039 function key_back()
1040 {
1041     adb shell input keyevent 4
1042 }
1043
1044 function key_menu()
1045 {
1046     adb shell input keyevent 82
1047 }
1048
1049 function smoketest()
1050 {
1051     if [ ! "$ANDROID_PRODUCT_OUT" ]; then
1052         echo "Couldn't locate output files.  Try running 'lunch' first." >&2
1053         return
1054     fi
1055     T=$(gettop)
1056     if [ ! "$T" ]; then
1057         echo "Couldn't locate the top of the tree.  Try setting TOP." >&2
1058         return
1059     fi
1060
1061     (\cd "$T" && mmm tests/SmokeTest) &&
1062       adb uninstall com.android.smoketest > /dev/null &&
1063       adb uninstall com.android.smoketest.tests > /dev/null &&
1064       adb install $ANDROID_PRODUCT_OUT/data/app/SmokeTestApp.apk &&
1065       adb install $ANDROID_PRODUCT_OUT/data/app/SmokeTest.apk &&
1066       adb shell am instrument -w com.android.smoketest.tests/android.test.InstrumentationTestRunner
1067 }
1068
1069 # simple shortcut to the runtest command
1070 function runtest()
1071 {
1072     T=$(gettop)
1073     if [ ! "$T" ]; then
1074         echo "Couldn't locate the top of the tree.  Try setting TOP." >&2
1075         return
1076     fi
1077     ("$T"/development/testrunner/runtest.py $@)
1078 }
1079
1080 function godir () {
1081     if [[ -z "$1" ]]; then
1082         echo "Usage: godir <regex>"
1083         return
1084     fi
1085     T=$(gettop)
1086     if [[ ! -f $T/filelist ]]; then
1087         echo -n "Creating index..."
1088         (\cd $T; find . -wholename ./out -prune -o -wholename ./.repo -prune -o -type f > filelist)
1089         echo " Done"
1090         echo ""
1091     fi
1092     local lines
1093     lines=($(\grep "$1" $T/filelist | sed -e 's/\/[^/]*$//' | sort | uniq))
1094     if [[ ${#lines[@]} = 0 ]]; then
1095         echo "Not found"
1096         return
1097     fi
1098     local pathname
1099     local choice
1100     if [[ ${#lines[@]} > 1 ]]; then
1101         while [[ -z "$pathname" ]]; do
1102             local index=1
1103             local line
1104             for line in ${lines[@]}; do
1105                 printf "%6s %s\n" "[$index]" $line
1106                 index=$(($index + 1))
1107             done
1108             echo
1109             echo -n "Select one: "
1110             unset choice
1111             read choice
1112             if [[ $choice -gt ${#lines[@]} || $choice -lt 1 ]]; then
1113                 echo "Invalid choice"
1114                 continue
1115             fi
1116             pathname=${lines[$(($choice-1))]}
1117         done
1118     else
1119         pathname=${lines[0]}
1120     fi
1121     \cd $T/$pathname
1122 }
1123
1124 # Force JAVA_HOME to point to java 1.6 if it isn't already set
1125 function set_java_home() {
1126     if [ ! "$JAVA_HOME" ]; then
1127         case `uname -s` in
1128             Darwin)
1129                 export JAVA_HOME=/System/Library/Frameworks/JavaVM.framework/Versions/1.6/Home
1130                 ;;
1131             *)
1132                 export JAVA_HOME=/usr/lib/jvm/java-6-sun
1133                 ;;
1134         esac
1135     fi
1136 }
1137
1138 if [ "x$SHELL" != "x/bin/bash" ]; then
1139     case `ps -o command -p $$` in
1140         *bash*)
1141             ;;
1142         *)
1143             echo "WARNING: Only bash is supported, use of other shell would lead to erroneous results"
1144             ;;
1145     esac
1146 fi
1147
1148 # Execute the contents of any vendorsetup.sh files we can find.
1149 for f in `/bin/ls vendor/*/vendorsetup.sh vendor/*/*/vendorsetup.sh device/*/*/vendorsetup.sh 2> /dev/null`
1150 do
1151     echo "including $f"
1152     . $f
1153 done
1154 unset f
1155
1156 addcompletions