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     stacks system_server
 741 }
 742
 743 function stacks()
 744 {
 745     if [[ $1 =~ ^[0-9]+$ ]] ; then
 746         local PID="$1"
 747     elif [ "$1" ] ; then
 748         local PID=$(pid $1)
 749     else
 750         echo "usage: stacks [pid|process name]"
 751     fi
 752
 753     if [ "$PID" ] ; then
 754         local TRACES=/data/anr/traces.txt
 755         local ORIG=/data/anr/traces.orig
 756         local TMP=/data/anr/traces.tmp
 757
 758         # Keep original traces to avoid clobbering
 759         adb shell mv $TRACES $ORIG
 760
 761         # Make sure we have a usable file
 762         adb shell touch $TRACES
 763         adb shell chmod 666 $TRACES
 764
 765         # Dump stacks and wait for dump to finish
 766         adb shell kill -3 $PID
 767         adb shell notify $TRACES
 768
 769         # Restore original stacks, and show current output
 770         adb shell mv $TRACES $TMP
 771         adb shell mv $ORIG $TRACES
 772         adb shell cat $TMP | less -S
 773     fi
 774 }
 775
 776 function gdbwrapper()
 777 {
 778     $ANDROID_TOOLCHAIN/$GDB -x "$@"
 779 }
 780
 781 function gdbclient()
 782 {
 783    local OUT_ROOT=$(get_abs_build_var PRODUCT_OUT)
 784    local OUT_SYMBOLS=$(get_abs_build_var TARGET_OUT_UNSTRIPPED)
 785    local OUT_SO_SYMBOLS=$(get_abs_build_var TARGET_OUT_SHARED_LIBRARIES_UNSTRIPPED)
 786    local OUT_EXE_SYMBOLS=$(get_abs_build_var TARGET_OUT_EXECUTABLES_UNSTRIPPED)
 787    local PREBUILTS=$(get_abs_build_var ANDROID_PREBUILTS)
 788    local ARCH=$(get_build_var TARGET_ARCH)
 789    local GDB
 790    case "$ARCH" in
 791        x86) GDB=i686-linux-android-gdb;;
 792        arm) GDB=arm-linux-androideabi-gdb;;
 793        mips) GDB=mipsel-linux-android-gdb;;
 794        *) echo "Unknown arch $ARCH"; return 1;;
 795    esac
 796
 797    if [ "$OUT_ROOT" -a "$PREBUILTS" ]; then
 798        local EXE="$1"
 799        if [ "$EXE" ] ; then
 800            EXE=$1
 801        else
 802            EXE="app_process"
 803        fi
 804
 805        local PORT="$2"
 806        if [ "$PORT" ] ; then
 807            PORT=$2
 808        else
 809            PORT=":5039"
 810        fi
 811
 812        local PID
 813        local PROG="$3"
 814        if [ "$PROG" ] ; then
 815            if [[ "$PROG" =~ ^[0-9]+$ ]] ; then
 816                PID="$3"
 817            else
 818                PID=`pid $3`
 819            fi
 820            adb forward "tcp$PORT" "tcp$PORT"
 821            adb shell gdbserver $PORT --attach $PID &
 822            sleep 2
 823        else
 824                echo ""
 825                echo "If you haven't done so already, do this first on the device:"
 826                echo "    gdbserver $PORT /system/bin/$EXE"
 827                    echo " or"
 828                echo "    gdbserver $PORT --attach $PID"
 829                echo ""
 830        fi
 831
 832        echo >|"$OUT_ROOT/gdbclient.cmds" "set solib-absolute-prefix $OUT_SYMBOLS"
 833        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"
 834        echo >>"$OUT_ROOT/gdbclient.cmds" "target remote $PORT"
 835        echo >>"$OUT_ROOT/gdbclient.cmds" ""
 836
 837        gdbwrapper "$OUT_ROOT/gdbclient.cmds" "$OUT_EXE_SYMBOLS/$EXE"
 838   else
 839        echo "Unable to determine build system output dir."
 840    fi
 841
 842 }
 843
 844 case `uname -s` in
 845     Darwin)
 846         function sgrep()
 847         {
 848             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 "$@"
 849         }
 850
 851         ;;
 852     *)
 853         function sgrep()
 854         {
 855             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 "$@"
 856         }
 857         ;;
 858 esac
 859
 860 function gettargetarch
 861 {
 862     get_build_var TARGET_ARCH
 863 }
 864
 865 function jgrep()
 866 {
 867     find . -name .repo -prune -o -name .git -prune -o  -type f -name "*\.java" -print0 | xargs -0 grep --color -n "$@"
 868 }
 869
 870 function cgrep()
 871 {
 872     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 "$@"
 873 }
 874
 875 function resgrep()
 876 {
 877     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;
 878 }
 879
 880 function mangrep()
 881 {
 882     find . -name .repo -prune -o -name .git -prune -o -path ./out -prune -o -type f -name 'AndroidManifest.xml' -print0 | xargs -0 grep --color -n "$@"
 883 }
 884
 885 case `uname -s` in
 886     Darwin)
 887         function mgrep()
 888         {
 889             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 "$@"
 890         }
 891
 892         function treegrep()
 893         {
 894             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 "$@"
 895         }
 896
 897         ;;
 898     *)
 899         function mgrep()
 900         {
 901             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 "$@"
 902         }
 903
 904         function treegrep()
 905         {
 906             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 "$@"
 907         }
 908
 909         ;;
 910 esac
 911
 912 function getprebuilt
 913 {
 914     get_abs_build_var ANDROID_PREBUILTS
 915 }
 916
 917 function tracedmdump()
 918 {
 919     T=$(gettop)
 920     if [ ! "$T" ]; then
 921         echo "Couldn't locate the top of the tree.  Try setting TOP."
 922         return
 923     fi
 924     local prebuiltdir=$(getprebuilt)
 925     local arch=$(gettargetarch)
 926     local KERNEL=$T/prebuilts/qemu-kernel/$arch/vmlinux-qemu
 927
 928     local TRACE=$1
 929     if [ ! "$TRACE" ] ; then
 930         echo "usage:  tracedmdump  tracename"
 931         return
 932     fi
 933
 934     if [ ! -r "$KERNEL" ] ; then
 935         echo "Error: cannot find kernel: '$KERNEL'"
 936         return
 937     fi
 938
 939     local BASETRACE=$(basename $TRACE)
 940     if [ "$BASETRACE" = "$TRACE" ] ; then
 941         TRACE=$ANDROID_PRODUCT_OUT/traces/$TRACE
 942     fi
 943
 944     echo "post-processing traces..."
 945     rm -f $TRACE/qtrace.dexlist
 946     post_trace $TRACE
 947     if [ $? -ne 0 ]; then
 948         echo "***"
 949         echo "*** Error: malformed trace.  Did you remember to exit the emulator?"
 950         echo "***"
 951         return
 952     fi
 953     echo "generating dexlist output..."
 954     /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
 955     echo "generating dmtrace data..."
 956     q2dm -r $ANDROID_PRODUCT_OUT/symbols $TRACE $KERNEL $TRACE/dmtrace || return
 957     echo "generating html file..."
 958     dmtracedump -h $TRACE/dmtrace >| $TRACE/dmtrace.html || return
 959     echo "done, see $TRACE/dmtrace.html for details"
 960     echo "or run:"
 961     echo "    traceview $TRACE/dmtrace"
 962 }
 963
 964 # communicate with a running device or emulator, set up necessary state,
 965 # and run the hat command.
 966 function runhat()
 967 {
 968     # process standard adb options
 969     local adbTarget=""
 970     if [ "$1" = "-d" -o "$1" = "-e" ]; then
 971         adbTarget=$1
 972         shift 1
 973     elif [ "$1" = "-s" ]; then
 974         adbTarget="$1 $2"
 975         shift 2
 976     fi
 977     local adbOptions=${adbTarget}
 978     #echo adbOptions = ${adbOptions}
 979
 980     # runhat options
 981     local targetPid=$1
 982
 983     if [ "$targetPid" = "" ]; then
 984         echo "Usage: runhat [ -d | -e | -s serial ] target-pid"
 985         return
 986     fi
 987
 988     # confirm hat is available
 989     if [ -z $(which hat) ]; then
 990         echo "hat is not available in this configuration."
 991         return
 992     fi
 993
 994     # issue "am" command to cause the hprof dump
 995     local sdcard=$(adb shell echo -n '$EXTERNAL_STORAGE')
 996     local devFile=$sdcard/hprof-$targetPid
 997     #local devFile=/data/local/hprof-$targetPid
 998     echo "Poking $targetPid and waiting for data..."
 999     echo "Storing data at $devFile"
1000     adb ${adbOptions} shell am dumpheap $targetPid $devFile
1001     echo "Press enter when logcat shows \"hprof: heap dump completed\""
1002     echo -n "> "
1003     read
1004
1005     local localFile=/tmp/$$-hprof
1006
1007     echo "Retrieving file $devFile..."
1008     adb ${adbOptions} pull $devFile $localFile
1009
1010     adb ${adbOptions} shell rm $devFile
1011
1012     echo "Running hat on $localFile"
1013     echo "View the output by pointing your browser at http://localhost:7000/"
1014     echo ""
1015     hat -JXmx512m $localFile
1016 }
1017
1018 function getbugreports()
1019 {
1020     local reports=(`adb shell ls /sdcard/bugreports | tr -d '\r'`)
1021
1022     if [ ! "$reports" ]; then
1023         echo "Could not locate any bugreports."
1024         return
1025     fi
1026
1027     local report
1028     for report in ${reports[@]}
1029     do
1030         echo "/sdcard/bugreports/${report}"
1031         adb pull /sdcard/bugreports/${report} ${report}
1032         gunzip ${report}
1033     done
1034 }
1035
1036 function getsdcardpath()
1037 {
1038     adb ${adbOptions} shell echo -n \$\{EXTERNAL_STORAGE\}
1039 }
1040
1041 function getscreenshotpath()
1042 {
1043     echo "$(getsdcardpath)/Pictures/Screenshots"
1044 }
1045
1046 function getlastscreenshot()
1047 {
1048     local screenshot_path=$(getscreenshotpath)
1049     local screenshot=`adb ${adbOptions} ls ${screenshot_path} | grep Screenshot_[0-9-]*.*\.png | sort -rk 3 | cut -d " " -f 4 | head -n 1`
1050     if [ "$screenshot" = "" ]; then
1051         echo "No screenshots found."
1052         return
1053     fi
1054     echo "${screenshot}"
1055     adb ${adbOptions} pull ${screenshot_path}/${screenshot}
1056 }
1057
1058 function startviewserver()
1059 {
1060     local port=4939
1061     if [ $# -gt 0 ]; then
1062             port=$1
1063     fi
1064     adb shell service call window 1 i32 $port
1065 }
1066
1067 function stopviewserver()
1068 {
1069     adb shell service call window 2
1070 }
1071
1072 function isviewserverstarted()
1073 {
1074     adb shell service call window 3
1075 }
1076
1077 function key_home()
1078 {
1079     adb shell input keyevent 3
1080 }
1081
1082 function key_back()
1083 {
1084     adb shell input keyevent 4
1085 }
1086
1087 function key_menu()
1088 {
1089     adb shell input keyevent 82
1090 }
1091
1092 function smoketest()
1093 {
1094     if [ ! "$ANDROID_PRODUCT_OUT" ]; then
1095         echo "Couldn't locate output files.  Try running 'lunch' first." >&2
1096         return
1097     fi
1098     T=$(gettop)
1099     if [ ! "$T" ]; then
1100         echo "Couldn't locate the top of the tree.  Try setting TOP." >&2
1101         return
1102     fi
1103
1104     (\cd "$T" && mmm tests/SmokeTest) &&
1105       adb uninstall com.android.smoketest > /dev/null &&
1106       adb uninstall com.android.smoketest.tests > /dev/null &&
1107       adb install $ANDROID_PRODUCT_OUT/data/app/SmokeTestApp.apk &&
1108       adb install $ANDROID_PRODUCT_OUT/data/app/SmokeTest.apk &&
1109       adb shell am instrument -w com.android.smoketest.tests/android.test.InstrumentationTestRunner
1110 }
1111
1112 # simple shortcut to the runtest command
1113 function runtest()
1114 {
1115     T=$(gettop)
1116     if [ ! "$T" ]; then
1117         echo "Couldn't locate the top of the tree.  Try setting TOP." >&2
1118         return
1119     fi
1120     ("$T"/development/testrunner/runtest.py $@)
1121 }
1122
1123 function godir () {
1124     if [[ -z "$1" ]]; then
1125         echo "Usage: godir <regex>"
1126         return
1127     fi
1128     T=$(gettop)
1129     if [[ ! -f $T/filelist ]]; then
1130         echo -n "Creating index..."
1131         (\cd $T; find . -wholename ./out -prune -o -wholename ./.repo -prune -o -type f > filelist)
1132         echo " Done"
1133         echo ""
1134     fi
1135     local lines
1136     lines=($(\grep "$1" $T/filelist | sed -e 's/\/[^/]*$//' | sort | uniq))
1137     if [[ ${#lines[@]} = 0 ]]; then
1138         echo "Not found"
1139         return
1140     fi
1141     local pathname
1142     local choice
1143     if [[ ${#lines[@]} > 1 ]]; then
1144         while [[ -z "$pathname" ]]; do
1145             local index=1
1146             local line
1147             for line in ${lines[@]}; do
1148                 printf "%6s %s\n" "[$index]" $line
1149                 index=$(($index + 1))
1150             done
1151             echo
1152             echo -n "Select one: "
1153             unset choice
1154             read choice
1155             if [[ $choice -gt ${#lines[@]} || $choice -lt 1 ]]; then
1156                 echo "Invalid choice"
1157                 continue
1158             fi
1159             pathname=${lines[$(($choice-1))]}
1160         done
1161     else
1162         pathname=${lines[0]}
1163     fi
1164     \cd $T/$pathname
1165 }
1166
1167 # Force JAVA_HOME to point to java 1.6 if it isn't already set
1168 function set_java_home() {
1169     if [ ! "$JAVA_HOME" ]; then
1170         case `uname -s` in
1171             Darwin)
1172                 export JAVA_HOME=/System/Library/Frameworks/JavaVM.framework/Versions/1.6/Home
1173                 ;;
1174             *)
1175                 export JAVA_HOME=/usr/lib/jvm/java-6-sun
1176                 ;;
1177         esac
1178     fi
1179 }
1180
1181 if [ "x$SHELL" != "x/bin/bash" ]; then
1182     case `ps -o command -p $$` in
1183         *bash*)
1184             ;;
1185         *)
1186             echo "WARNING: Only bash is supported, use of other shell would lead to erroneous results"
1187             ;;
1188     esac
1189 fi
1190
1191 # Execute the contents of any vendorsetup.sh files we can find.
1192 for f in `/bin/ls vendor/*/vendorsetup.sh vendor/*/*/vendorsetup.sh device/*/*/vendorsetup.sh 2> /dev/null`
1193 do
1194     echo "including $f"
1195     . $f
1196 done
1197 unset f
1198
1199 addcompletions