cc44d2e70e
Add a function to log the invocation of tools run from the Android build environment. This enables analyzing and optimizing developer flows. Note that there are no tools currently leveraging the logging facility. Logging is also disabled by default and not configured to use any particular logger. Test: atest run_tool_with_logging_test bug: 331638854 Change-Id: I001ba3c6c30b3ffc95d0fdb30ea7178a991c680f
2142 lines
63 KiB
Bash
2142 lines
63 KiB
Bash
# Copyright (C) 2022 The Android Open Source Project
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License");
|
|
# you may not use this file except in compliance with the License.
|
|
# You may obtain a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS,
|
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
# See the License for the specific language governing permissions and
|
|
# limitations under the License.
|
|
|
|
# gettop is duplicated here and in shell_utils.mk, because it's difficult
|
|
# to find shell_utils.make without it for all the novel ways this file can be
|
|
# sourced. Other common functions should only be in one place or the other.
|
|
function _gettop_once
|
|
{
|
|
local TOPFILE=build/make/core/envsetup.mk
|
|
if [ -n "$TOP" -a -f "$TOP/$TOPFILE" ] ; then
|
|
# The following circumlocution ensures we remove symlinks from TOP.
|
|
(cd "$TOP"; PWD= /bin/pwd)
|
|
else
|
|
if [ -f $TOPFILE ] ; then
|
|
# The following circumlocution (repeated below as well) ensures
|
|
# that we record the true directory name and not one that is
|
|
# faked up with symlink names.
|
|
PWD= /bin/pwd
|
|
else
|
|
local HERE=$PWD
|
|
local T=
|
|
while [ \( ! \( -f $TOPFILE \) \) -a \( "$PWD" != "/" \) ]; do
|
|
\cd ..
|
|
T=`PWD= /bin/pwd -P`
|
|
done
|
|
\cd "$HERE"
|
|
if [ -f "$T/$TOPFILE" ]; then
|
|
echo "$T"
|
|
fi
|
|
fi
|
|
fi
|
|
}
|
|
T=$(_gettop_once)
|
|
if [ ! "$T" ]; then
|
|
echo "Couldn't locate the top of the tree. Always source build/envsetup.sh from the root of the tree." >&2
|
|
return 1
|
|
fi
|
|
IMPORTING_ENVSETUP=true source $T/build/make/shell_utils.sh
|
|
|
|
|
|
# Help
|
|
function hmm() {
|
|
cat <<EOF
|
|
|
|
Run "m help" for help with the build system itself.
|
|
|
|
Invoke ". build/envsetup.sh" from your shell to add the following functions to your environment:
|
|
- lunch: lunch <product_name>-<release_type>-<build_variant>
|
|
Selects <product_name> as the product to build, and <build_variant> as the variant to
|
|
build, and stores those selections in the environment to be read by subsequent
|
|
invocations of 'm' etc.
|
|
- tapas: tapas [<App1> <App2> ...] [arm|x86|arm64|x86_64] [eng|userdebug|user]
|
|
Sets up the build environment for building unbundled apps (APKs).
|
|
- banchan: banchan <module1> [<module2> ...] \\
|
|
[arm|x86|arm64|riscv64|x86_64|arm64_only|x86_64only] [eng|userdebug|user]
|
|
Sets up the build environment for building unbundled modules (APEXes).
|
|
- croot: Changes directory to the top of the tree, or a subdirectory thereof.
|
|
- m: Makes from the top of the tree.
|
|
- mm: Builds and installs all of the modules in the current directory, and their
|
|
dependencies.
|
|
- mmm: Builds and installs all of the modules in the supplied directories, and their
|
|
dependencies.
|
|
To limit the modules being built use the syntax: mmm dir/:target1,target2.
|
|
- mma: Same as 'mm'
|
|
- mmma: Same as 'mmm'
|
|
- provision: Flash device with all required partitions. Options will be passed on to fastboot.
|
|
- cgrep: Greps on all local C/C++ files.
|
|
- ggrep: Greps on all local Gradle files.
|
|
- gogrep: Greps on all local Go files.
|
|
- jgrep: Greps on all local Java files.
|
|
- jsongrep: Greps on all local Json files.
|
|
- ktgrep: Greps on all local Kotlin files.
|
|
- resgrep: Greps on all local res/*.xml files.
|
|
- mangrep: Greps on all local AndroidManifest.xml files.
|
|
- mgrep: Greps on all local Makefiles and *.bp files.
|
|
- owngrep: Greps on all local OWNERS files.
|
|
- rsgrep: Greps on all local Rust files.
|
|
- sepgrep: Greps on all local sepolicy files.
|
|
- sgrep: Greps on all local source files.
|
|
- tomlgrep: Greps on all local Toml files.
|
|
- pygrep: Greps on all local Python files.
|
|
- godir: Go to the directory containing a file.
|
|
- allmod: List all modules.
|
|
- gomod: Go to the directory containing a module.
|
|
- bmod: Get the Bazel label of a Soong module if it is converted with bp2build.
|
|
- pathmod: Get the directory containing a module.
|
|
- outmod: Gets the location of a module's installed outputs with a certain extension.
|
|
- dirmods: Gets the modules defined in a given directory.
|
|
- installmod: Adb installs a module's built APK.
|
|
- refreshmod: Refresh list of modules for allmod/gomod/pathmod/outmod/installmod.
|
|
- syswrite: Remount partitions (e.g. system.img) as writable, rebooting if necessary.
|
|
|
|
Environment options:
|
|
- SANITIZE_HOST: Set to 'address' to use ASAN for all host modules.
|
|
- ANDROID_QUIET_BUILD: set to 'true' to display only the essential messages.
|
|
|
|
Look at the source to view more functions. The complete list is:
|
|
EOF
|
|
local T=$(gettop)
|
|
local A=""
|
|
local i
|
|
for i in `cat $T/build/envsetup.sh | sed -n "/^[[:blank:]]*function /s/function \([a-z_]*\).*/\1/p" | sort | uniq`; do
|
|
A="$A $i"
|
|
done
|
|
echo $A
|
|
}
|
|
|
|
# Get all the build variables needed by this script in a single call to the build system.
|
|
function build_build_var_cache()
|
|
{
|
|
local T=$(gettop)
|
|
# Grep out the variable names from the script.
|
|
cached_vars=(`cat $T/build/envsetup.sh | tr '()' ' ' | awk '{for(i=1;i<=NF;i++) if($i~/get_build_var/) print $(i+1)}' | sort -u | tr '\n' ' '`)
|
|
cached_abs_vars=(`cat $T/build/envsetup.sh | tr '()' ' ' | awk '{for(i=1;i<=NF;i++) if($i~/get_abs_build_var/) print $(i+1)}' | sort -u | tr '\n' ' '`)
|
|
# Call the build system to dump the "<val>=<value>" pairs as a shell script.
|
|
build_dicts_script=`\builtin cd $T; build/soong/soong_ui.bash --dumpvars-mode \
|
|
--vars="${cached_vars[*]}" \
|
|
--abs-vars="${cached_abs_vars[*]}" \
|
|
--var-prefix=var_cache_ \
|
|
--abs-var-prefix=abs_var_cache_`
|
|
local ret=$?
|
|
if [ $ret -ne 0 ]
|
|
then
|
|
unset build_dicts_script
|
|
return $ret
|
|
fi
|
|
# Execute the script to store the "<val>=<value>" pairs as shell variables.
|
|
eval "$build_dicts_script"
|
|
ret=$?
|
|
unset build_dicts_script
|
|
if [ $ret -ne 0 ]
|
|
then
|
|
return $ret
|
|
fi
|
|
BUILD_VAR_CACHE_READY="true"
|
|
}
|
|
|
|
# Delete the build var cache, so that we can still call into the build system
|
|
# to get build variables not listed in this script.
|
|
function destroy_build_var_cache()
|
|
{
|
|
unset BUILD_VAR_CACHE_READY
|
|
local v
|
|
for v in $cached_vars; do
|
|
unset var_cache_$v
|
|
done
|
|
unset cached_vars
|
|
for v in $cached_abs_vars; do
|
|
unset abs_var_cache_$v
|
|
done
|
|
unset cached_abs_vars
|
|
}
|
|
|
|
# Get the value of a build variable as an absolute path.
|
|
function get_abs_build_var()
|
|
{
|
|
if [ "$BUILD_VAR_CACHE_READY" = "true" ]
|
|
then
|
|
eval "echo \"\${abs_var_cache_$1}\""
|
|
return
|
|
fi
|
|
|
|
local T=$(gettop)
|
|
if [ ! "$T" ]; then
|
|
echo "Couldn't locate the top of the tree. Try setting TOP." >&2
|
|
return
|
|
fi
|
|
(\cd $T; build/soong/soong_ui.bash --dumpvar-mode --abs $1)
|
|
}
|
|
|
|
# Get the exact value of a build variable.
|
|
function get_build_var()
|
|
{
|
|
if [ "$BUILD_VAR_CACHE_READY" = "true" ]
|
|
then
|
|
eval "echo \"\${var_cache_$1}\""
|
|
return 0
|
|
fi
|
|
|
|
local T=$(gettop)
|
|
if [ ! "$T" ]; then
|
|
echo "Couldn't locate the top of the tree. Try setting TOP." >&2
|
|
return 1
|
|
fi
|
|
(\cd $T; build/soong/soong_ui.bash --dumpvar-mode $1)
|
|
}
|
|
|
|
# check to see if the supplied product is one we can build
|
|
function check_product()
|
|
{
|
|
local T=$(gettop)
|
|
if [ ! "$T" ]; then
|
|
echo "Couldn't locate the top of the tree. Try setting TOP." >&2
|
|
return
|
|
fi
|
|
TARGET_PRODUCT=$1 \
|
|
TARGET_RELEASE= \
|
|
TARGET_BUILD_VARIANT= \
|
|
TARGET_BUILD_TYPE= \
|
|
TARGET_BUILD_APPS= \
|
|
get_build_var TARGET_DEVICE > /dev/null
|
|
# hide successful answers, but allow the errors to show
|
|
}
|
|
|
|
VARIANT_CHOICES=(user userdebug eng)
|
|
|
|
# check to see if the supplied variant is valid
|
|
function check_variant()
|
|
{
|
|
local v
|
|
for v in ${VARIANT_CHOICES[@]}
|
|
do
|
|
if [ "$v" = "$1" ]
|
|
then
|
|
return 0
|
|
fi
|
|
done
|
|
return 1
|
|
}
|
|
|
|
|
|
# Add directories to PATH that are dependent on the lunch target.
|
|
# For directories that are not lunch-specific, add them in set_global_paths
|
|
function set_lunch_paths()
|
|
{
|
|
local T=$(gettop)
|
|
if [ ! "$T" ]; then
|
|
echo "Couldn't locate the top of the tree. Try setting TOP."
|
|
return
|
|
fi
|
|
|
|
##################################################################
|
|
# #
|
|
# Read me before you modify this code #
|
|
# #
|
|
# This function sets ANDROID_LUNCH_BUILD_PATHS to what it is #
|
|
# adding to PATH, and the next time it is run, it removes that #
|
|
# from PATH. This is required so lunch can be run more than #
|
|
# once and still have working paths. #
|
|
# #
|
|
##################################################################
|
|
|
|
# Note: on windows/cygwin, ANDROID_LUNCH_BUILD_PATHS will contain spaces
|
|
# due to "C:\Program Files" being in the path.
|
|
|
|
# Handle compat with the old ANDROID_BUILD_PATHS variable.
|
|
# TODO: Remove this after we think everyone has lunched again.
|
|
if [ -z "$ANDROID_LUNCH_BUILD_PATHS" -a -n "$ANDROID_BUILD_PATHS" ] ; then
|
|
ANDROID_LUNCH_BUILD_PATHS="$ANDROID_BUILD_PATHS"
|
|
ANDROID_BUILD_PATHS=
|
|
fi
|
|
if [ -n "$ANDROID_PRE_BUILD_PATHS" ] ; then
|
|
export PATH=${PATH/$ANDROID_PRE_BUILD_PATHS/}
|
|
# strip leading ':', if any
|
|
export PATH=${PATH/:%/}
|
|
ANDROID_PRE_BUILD_PATHS=
|
|
fi
|
|
|
|
# Out with the old...
|
|
if [ -n "$ANDROID_LUNCH_BUILD_PATHS" ] ; then
|
|
export PATH=${PATH/$ANDROID_LUNCH_BUILD_PATHS/}
|
|
fi
|
|
|
|
# And in with the new...
|
|
ANDROID_LUNCH_BUILD_PATHS=$(get_abs_build_var SOONG_HOST_OUT_EXECUTABLES)
|
|
ANDROID_LUNCH_BUILD_PATHS+=:$(get_abs_build_var HOST_OUT_EXECUTABLES)
|
|
|
|
# Append llvm binutils prebuilts path to ANDROID_LUNCH_BUILD_PATHS.
|
|
local ANDROID_LLVM_BINUTILS=$(get_abs_build_var ANDROID_CLANG_PREBUILTS)/llvm-binutils-stable
|
|
ANDROID_LUNCH_BUILD_PATHS+=:$ANDROID_LLVM_BINUTILS
|
|
|
|
# Set up ASAN_SYMBOLIZER_PATH for SANITIZE_HOST=address builds.
|
|
export ASAN_SYMBOLIZER_PATH=$ANDROID_LLVM_BINUTILS/llvm-symbolizer
|
|
|
|
# Append asuite prebuilts path to ANDROID_LUNCH_BUILD_PATHS.
|
|
local os_arch=$(get_build_var HOST_PREBUILT_TAG)
|
|
ANDROID_LUNCH_BUILD_PATHS+=:$T/prebuilts/asuite/acloud/$os_arch
|
|
ANDROID_LUNCH_BUILD_PATHS+=:$T/prebuilts/asuite/aidegen/$os_arch
|
|
ANDROID_LUNCH_BUILD_PATHS+=:$T/prebuilts/asuite/atest/$os_arch
|
|
|
|
export ANDROID_JAVA_HOME=$(get_abs_build_var ANDROID_JAVA_HOME)
|
|
export JAVA_HOME=$ANDROID_JAVA_HOME
|
|
export ANDROID_JAVA_TOOLCHAIN=$(get_abs_build_var ANDROID_JAVA_TOOLCHAIN)
|
|
ANDROID_LUNCH_BUILD_PATHS+=:$ANDROID_JAVA_TOOLCHAIN
|
|
|
|
# Fix up PYTHONPATH
|
|
if [ -n $ANDROID_PYTHONPATH ]; then
|
|
export PYTHONPATH=${PYTHONPATH//$ANDROID_PYTHONPATH/}
|
|
fi
|
|
# //development/python-packages contains both a pseudo-PYTHONPATH which
|
|
# mimics an already assembled venv, but also contains real Python packages
|
|
# that are not in that layout until they are installed. We can fake it for
|
|
# the latter type by adding the package source directories to the PYTHONPATH
|
|
# directly. For the former group, we only need to add the python-packages
|
|
# directory itself.
|
|
#
|
|
# This could be cleaned up by converting the remaining packages that are in
|
|
# the first category into a typical python source layout (that is, another
|
|
# layer of directory nesting) and automatically adding all subdirectories of
|
|
# python-packages to the PYTHONPATH instead of manually curating this. We
|
|
# can't convert the packages like adb to the other style because doing so
|
|
# would prevent exporting type info from those packages.
|
|
#
|
|
# http://b/266688086
|
|
export ANDROID_PYTHONPATH=$T/development/python-packages/adb:$T/development/python-packages/gdbrunner:$T/development/python-packages:
|
|
if [ -n $VENDOR_PYTHONPATH ]; then
|
|
ANDROID_PYTHONPATH=$ANDROID_PYTHONPATH$VENDOR_PYTHONPATH
|
|
fi
|
|
export PYTHONPATH=$ANDROID_PYTHONPATH$PYTHONPATH
|
|
|
|
unset ANDROID_PRODUCT_OUT
|
|
export ANDROID_PRODUCT_OUT=$(get_abs_build_var PRODUCT_OUT)
|
|
export OUT=$ANDROID_PRODUCT_OUT
|
|
|
|
unset ANDROID_HOST_OUT
|
|
export ANDROID_HOST_OUT=$(get_abs_build_var HOST_OUT)
|
|
|
|
unset ANDROID_SOONG_HOST_OUT
|
|
export ANDROID_SOONG_HOST_OUT=$(get_abs_build_var SOONG_HOST_OUT)
|
|
|
|
unset ANDROID_HOST_OUT_TESTCASES
|
|
export ANDROID_HOST_OUT_TESTCASES=$(get_abs_build_var HOST_OUT_TESTCASES)
|
|
|
|
unset ANDROID_TARGET_OUT_TESTCASES
|
|
export ANDROID_TARGET_OUT_TESTCASES=$(get_abs_build_var TARGET_OUT_TESTCASES)
|
|
|
|
# Finally, set PATH
|
|
export PATH=$ANDROID_LUNCH_BUILD_PATHS:$PATH
|
|
}
|
|
|
|
# Add directories to PATH that are NOT dependent on the lunch target.
|
|
# For directories that are lunch-specific, add them in set_lunch_paths
|
|
function set_global_paths()
|
|
{
|
|
local T=$(gettop)
|
|
if [ ! "$T" ]; then
|
|
echo "Couldn't locate the top of the tree. Try setting TOP."
|
|
return
|
|
fi
|
|
|
|
##################################################################
|
|
# #
|
|
# Read me before you modify this code #
|
|
# #
|
|
# This function sets ANDROID_GLOBAL_BUILD_PATHS to what it is #
|
|
# adding to PATH, and the next time it is run, it removes that #
|
|
# from PATH. This is required so envsetup.sh can be sourced #
|
|
# more than once and still have working paths. #
|
|
# #
|
|
##################################################################
|
|
|
|
# Out with the old...
|
|
if [ -n "$ANDROID_GLOBAL_BUILD_PATHS" ] ; then
|
|
export PATH=${PATH/$ANDROID_GLOBAL_BUILD_PATHS/}
|
|
fi
|
|
|
|
# And in with the new...
|
|
ANDROID_GLOBAL_BUILD_PATHS=$T/build/soong/bin
|
|
ANDROID_GLOBAL_BUILD_PATHS+=:$T/build/bazel/bin
|
|
ANDROID_GLOBAL_BUILD_PATHS+=:$T/development/scripts
|
|
ANDROID_GLOBAL_BUILD_PATHS+=:$T/prebuilts/devtools/tools
|
|
|
|
# add kernel specific binaries
|
|
if [ $(uname -s) = Linux ] ; then
|
|
ANDROID_GLOBAL_BUILD_PATHS+=:$T/prebuilts/misc/linux-x86/dtc
|
|
ANDROID_GLOBAL_BUILD_PATHS+=:$T/prebuilts/misc/linux-x86/libufdt
|
|
fi
|
|
|
|
# If prebuilts/android-emulator/<system>/ exists, prepend it to our PATH
|
|
# to ensure that the corresponding 'emulator' binaries are used.
|
|
case $(uname -s) in
|
|
Darwin)
|
|
ANDROID_EMULATOR_PREBUILTS=$T/prebuilts/android-emulator/darwin-x86_64
|
|
;;
|
|
Linux)
|
|
ANDROID_EMULATOR_PREBUILTS=$T/prebuilts/android-emulator/linux-x86_64
|
|
;;
|
|
*)
|
|
ANDROID_EMULATOR_PREBUILTS=
|
|
;;
|
|
esac
|
|
if [ -n "$ANDROID_EMULATOR_PREBUILTS" -a -d "$ANDROID_EMULATOR_PREBUILTS" ]; then
|
|
ANDROID_GLOBAL_BUILD_PATHS+=:$ANDROID_EMULATOR_PREBUILTS
|
|
export ANDROID_EMULATOR_PREBUILTS
|
|
fi
|
|
|
|
# Finally, set PATH
|
|
export PATH=$ANDROID_GLOBAL_BUILD_PATHS:$PATH
|
|
}
|
|
|
|
function printconfig()
|
|
{
|
|
local T=$(gettop)
|
|
if [ ! "$T" ]; then
|
|
echo "Couldn't locate the top of the tree. Try setting TOP." >&2
|
|
return
|
|
fi
|
|
get_build_var report_config
|
|
}
|
|
|
|
function set_stuff_for_environment()
|
|
{
|
|
set_lunch_paths
|
|
set_sequence_number
|
|
|
|
export ANDROID_BUILD_TOP=$(gettop)
|
|
}
|
|
|
|
function set_sequence_number()
|
|
{
|
|
export BUILD_ENV_SEQUENCE_NUMBER=13
|
|
}
|
|
|
|
# Takes a command name, and check if it's in ENVSETUP_NO_COMPLETION or not.
|
|
function should_add_completion() {
|
|
local cmd="$(basename $1| sed 's/_completion//' |sed 's/\.\(.*\)*sh$//')"
|
|
case :"$ENVSETUP_NO_COMPLETION": in
|
|
*:"$cmd":*)
|
|
return 1
|
|
;;
|
|
esac
|
|
return 0
|
|
}
|
|
|
|
function addcompletions()
|
|
{
|
|
local f=
|
|
|
|
# Keep us from trying to run in something that's neither bash nor zsh.
|
|
if [ -z "$BASH_VERSION" -a -z "$ZSH_VERSION" ]; then
|
|
return
|
|
fi
|
|
|
|
# Keep us from trying to run in bash that's too old.
|
|
if [ -n "$BASH_VERSION" -a ${BASH_VERSINFO[0]} -lt 3 ]; then
|
|
return
|
|
fi
|
|
|
|
local completion_files=(
|
|
packages/modules/adb/adb.bash
|
|
system/core/fastboot/fastboot.bash
|
|
tools/asuite/asuite.sh
|
|
prebuilts/bazel/common/bazel-complete.bash
|
|
)
|
|
# Completion can be disabled selectively to allow users to use non-standard completion.
|
|
# e.g.
|
|
# ENVSETUP_NO_COMPLETION=adb # -> disable adb completion
|
|
# ENVSETUP_NO_COMPLETION=adb:bit # -> disable adb and bit completion
|
|
local T=$(gettop)
|
|
for f in ${completion_files[*]}; do
|
|
f="$T/$f"
|
|
if [ ! -f "$f" ]; then
|
|
echo "Warning: completion file $f not found"
|
|
elif should_add_completion "$f"; then
|
|
. $f
|
|
fi
|
|
done
|
|
|
|
if should_add_completion bit ; then
|
|
complete -C "bit --tab" bit
|
|
fi
|
|
if [ -z "$ZSH_VERSION" ]; then
|
|
# Doesn't work in zsh.
|
|
complete -o nospace -F _croot croot
|
|
# TODO(b/244559459): Support b autocompletion for zsh
|
|
complete -F _bazel__complete -o nospace b
|
|
fi
|
|
complete -F _lunch lunch
|
|
|
|
complete -F _complete_android_module_names pathmod
|
|
complete -F _complete_android_module_names gomod
|
|
complete -F _complete_android_module_names outmod
|
|
complete -F _complete_android_module_names installmod
|
|
complete -F _complete_android_module_names bmod
|
|
complete -F _complete_android_module_names m
|
|
}
|
|
|
|
function multitree_lunch_help()
|
|
{
|
|
echo "usage: lunch PRODUCT-RELEASE-VARIANT" 1>&2
|
|
echo " Set up android build environment based on a product short name and variant" 1>&2
|
|
echo 1>&2
|
|
echo "lunch COMBO_FILE VARIANT" 1>&2
|
|
echo " Set up android build environment based on a specific lunch combo file" 1>&2
|
|
echo " and variant." 1>&2
|
|
echo 1>&2
|
|
echo "lunch --print [CONFIG]" 1>&2
|
|
echo " Print the contents of a configuration. If CONFIG is supplied, that config" 1>&2
|
|
echo " will be flattened and printed. If CONFIG is not supplied, the currently" 1>&2
|
|
echo " selected config will be printed. Returns 0 on success or nonzero on error." 1>&2
|
|
echo 1>&2
|
|
echo "lunch --list" 1>&2
|
|
echo " List all possible combo files available in the current tree" 1>&2
|
|
echo 1>&2
|
|
echo "lunch --help" 1>&2
|
|
echo "lunch -h" 1>&2
|
|
echo " Prints this message." 1>&2
|
|
}
|
|
|
|
function multitree_lunch()
|
|
{
|
|
local code
|
|
local results
|
|
# Lunch must be run in the topdir, but this way we get a clear error
|
|
# message, instead of FileNotFound.
|
|
local T=$(multitree_gettop)
|
|
if [ -z "$T" ]; then
|
|
_multitree_lunch_error
|
|
return 1
|
|
fi
|
|
if $(echo "$1" | grep -q '^-') ; then
|
|
# Calls starting with a -- argument are passed directly and the function
|
|
# returns with the lunch.py exit code.
|
|
"${T}/orchestrator/build/orchestrator/core/lunch.py" "$@"
|
|
code=$?
|
|
if [[ $code -eq 2 ]] ; then
|
|
echo 1>&2
|
|
multitree_lunch_help
|
|
return $code
|
|
elif [[ $code -ne 0 ]] ; then
|
|
return $code
|
|
fi
|
|
else
|
|
# All other calls go through the --lunch variant of lunch.py
|
|
results=($(${T}/orchestrator/build/orchestrator/core/lunch.py --lunch "$@"))
|
|
code=$?
|
|
if [[ $code -eq 2 ]] ; then
|
|
echo 1>&2
|
|
multitree_lunch_help
|
|
return $code
|
|
elif [[ $code -ne 0 ]] ; then
|
|
return $code
|
|
fi
|
|
|
|
export TARGET_BUILD_COMBO=${results[0]}
|
|
export TARGET_BUILD_VARIANT=${results[1]}
|
|
fi
|
|
}
|
|
|
|
function choosetype()
|
|
{
|
|
echo "Build type choices are:"
|
|
echo " 1. release"
|
|
echo " 2. debug"
|
|
echo
|
|
|
|
local DEFAULT_NUM DEFAULT_VALUE
|
|
DEFAULT_NUM=1
|
|
DEFAULT_VALUE=release
|
|
|
|
export TARGET_BUILD_TYPE=
|
|
local ANSWER
|
|
while [ -z $TARGET_BUILD_TYPE ]
|
|
do
|
|
echo -n "Which would you like? ["$DEFAULT_NUM"] "
|
|
if [ -z "$1" ] ; then
|
|
read ANSWER
|
|
else
|
|
echo $1
|
|
ANSWER=$1
|
|
fi
|
|
case $ANSWER in
|
|
"")
|
|
export TARGET_BUILD_TYPE=$DEFAULT_VALUE
|
|
;;
|
|
1)
|
|
export TARGET_BUILD_TYPE=release
|
|
;;
|
|
release)
|
|
export TARGET_BUILD_TYPE=release
|
|
;;
|
|
2)
|
|
export TARGET_BUILD_TYPE=debug
|
|
;;
|
|
debug)
|
|
export TARGET_BUILD_TYPE=debug
|
|
;;
|
|
*)
|
|
echo
|
|
echo "I didn't understand your response. Please try again."
|
|
echo
|
|
;;
|
|
esac
|
|
if [ -n "$1" ] ; then
|
|
break
|
|
fi
|
|
done
|
|
|
|
build_build_var_cache
|
|
set_stuff_for_environment
|
|
destroy_build_var_cache
|
|
}
|
|
|
|
#
|
|
# This function isn't really right: It chooses a TARGET_PRODUCT
|
|
# based on the list of boards. Usually, that gets you something
|
|
# that kinda works with a generic product, but really, you should
|
|
# pick a product by name.
|
|
#
|
|
function chooseproduct()
|
|
{
|
|
local default_value
|
|
if [ "x$TARGET_PRODUCT" != x ] ; then
|
|
default_value=$TARGET_PRODUCT
|
|
else
|
|
default_value=aosp_arm
|
|
fi
|
|
|
|
export TARGET_BUILD_APPS=
|
|
export TARGET_PRODUCT=
|
|
local ANSWER
|
|
while [ -z "$TARGET_PRODUCT" ]
|
|
do
|
|
echo -n "Which product would you like? [$default_value] "
|
|
if [ -z "$1" ] ; then
|
|
read ANSWER
|
|
else
|
|
echo $1
|
|
ANSWER=$1
|
|
fi
|
|
|
|
if [ -z "$ANSWER" ] ; then
|
|
export TARGET_PRODUCT=$default_value
|
|
else
|
|
if check_product $ANSWER
|
|
then
|
|
export TARGET_PRODUCT=$ANSWER
|
|
else
|
|
echo "** Not a valid product: $ANSWER"
|
|
fi
|
|
fi
|
|
if [ -n "$1" ] ; then
|
|
break
|
|
fi
|
|
done
|
|
|
|
build_build_var_cache
|
|
set_stuff_for_environment
|
|
destroy_build_var_cache
|
|
}
|
|
|
|
function choosevariant()
|
|
{
|
|
echo "Variant choices are:"
|
|
local index=1
|
|
local v
|
|
for v in ${VARIANT_CHOICES[@]}
|
|
do
|
|
# The product name is the name of the directory containing
|
|
# the makefile we found, above.
|
|
echo " $index. $v"
|
|
index=$(($index+1))
|
|
done
|
|
|
|
local default_value=eng
|
|
local ANSWER
|
|
|
|
export TARGET_BUILD_VARIANT=
|
|
while [ -z "$TARGET_BUILD_VARIANT" ]
|
|
do
|
|
echo -n "Which would you like? [$default_value] "
|
|
if [ -z "$1" ] ; then
|
|
read ANSWER
|
|
else
|
|
echo $1
|
|
ANSWER=$1
|
|
fi
|
|
|
|
if [ -z "$ANSWER" ] ; then
|
|
export TARGET_BUILD_VARIANT=$default_value
|
|
elif (echo -n $ANSWER | grep -q -e "^[0-9][0-9]*$") ; then
|
|
if [ "$ANSWER" -le "${#VARIANT_CHOICES[@]}" ] ; then
|
|
export TARGET_BUILD_VARIANT=${VARIANT_CHOICES[@]:$(($ANSWER-1)):1}
|
|
fi
|
|
else
|
|
if check_variant $ANSWER
|
|
then
|
|
export TARGET_BUILD_VARIANT=$ANSWER
|
|
else
|
|
echo "** Not a valid variant: $ANSWER"
|
|
fi
|
|
fi
|
|
if [ -n "$1" ] ; then
|
|
break
|
|
fi
|
|
done
|
|
}
|
|
|
|
function choosecombo()
|
|
{
|
|
choosetype $1
|
|
|
|
echo
|
|
echo
|
|
chooseproduct $2
|
|
|
|
echo
|
|
echo
|
|
choosevariant $3
|
|
|
|
echo
|
|
build_build_var_cache
|
|
set_stuff_for_environment
|
|
printconfig
|
|
destroy_build_var_cache
|
|
}
|
|
|
|
function add_lunch_combo()
|
|
{
|
|
if [ -n "$ZSH_VERSION" ]; then
|
|
echo -n "${funcfiletrace[1]}: "
|
|
else
|
|
echo -n "${BASH_SOURCE[1]}:${BASH_LINENO[0]}: "
|
|
fi
|
|
echo "add_lunch_combo is obsolete. Use COMMON_LUNCH_CHOICES in your AndroidProducts.mk instead."
|
|
}
|
|
|
|
function print_lunch_menu()
|
|
{
|
|
local uname=$(uname)
|
|
local choices
|
|
choices=$(TARGET_BUILD_APPS= TARGET_PRODUCT= TARGET_RELEASE= TARGET_BUILD_VARIANT= get_build_var COMMON_LUNCH_CHOICES 2>/dev/null)
|
|
local ret=$?
|
|
|
|
echo
|
|
echo "You're building on" $uname
|
|
echo
|
|
|
|
if [ $ret -ne 0 ]
|
|
then
|
|
echo "Warning: Cannot display lunch menu."
|
|
echo
|
|
echo "Note: You can invoke lunch with an explicit target:"
|
|
echo
|
|
echo " usage: lunch [target]" >&2
|
|
echo
|
|
return
|
|
fi
|
|
|
|
echo "Lunch menu .. Here are the common combinations:"
|
|
|
|
local i=1
|
|
local choice
|
|
for choice in $(echo $choices)
|
|
do
|
|
echo " $i. $choice"
|
|
i=$(($i+1))
|
|
done
|
|
|
|
echo
|
|
}
|
|
|
|
function lunch()
|
|
{
|
|
local answer
|
|
|
|
if [[ $# -gt 1 ]]; then
|
|
echo "usage: lunch [target]" >&2
|
|
return 1
|
|
fi
|
|
|
|
local used_lunch_menu=0
|
|
|
|
if [ "$1" ]; then
|
|
answer=$1
|
|
else
|
|
print_lunch_menu
|
|
echo "Which would you like? [aosp_cf_x86_64_phone-trunk_staging-eng]"
|
|
echo -n "Pick from common choices above (e.g. 13) or specify your own (e.g. aosp_barbet-trunk_staging-eng): "
|
|
read answer
|
|
used_lunch_menu=1
|
|
fi
|
|
|
|
local selection=
|
|
|
|
if [ -z "$answer" ]
|
|
then
|
|
selection=aosp_cf_x86_64_phone-trunk_staging-eng
|
|
elif (echo -n $answer | grep -q -e "^[0-9][0-9]*$")
|
|
then
|
|
local choices=($(TARGET_BUILD_APPS= TARGET_PRODUCT= TARGET_RELEASE= TARGET_BUILD_VARIANT= get_build_var COMMON_LUNCH_CHOICES 2>/dev/null))
|
|
if [ $answer -le ${#choices[@]} ]
|
|
then
|
|
# array in zsh starts from 1 instead of 0.
|
|
if [ -n "$ZSH_VERSION" ]
|
|
then
|
|
selection=${choices[$(($answer))]}
|
|
else
|
|
selection=${choices[$(($answer-1))]}
|
|
fi
|
|
fi
|
|
else
|
|
selection=$answer
|
|
fi
|
|
|
|
export TARGET_BUILD_APPS=
|
|
|
|
# This must be <product>-<release>-<variant>
|
|
local product release variant
|
|
# Split string on the '-' character.
|
|
IFS="-" read -r product release variant <<< "$selection"
|
|
|
|
if [[ -z "$product" ]] || [[ -z "$release" ]] || [[ -z "$variant" ]]
|
|
then
|
|
echo
|
|
echo "Invalid lunch combo: $selection"
|
|
echo "Valid combos must be of the form <product>-<release>-<variant>"
|
|
return 1
|
|
fi
|
|
|
|
TARGET_PRODUCT=$product \
|
|
TARGET_BUILD_VARIANT=$variant \
|
|
TARGET_RELEASE=$release \
|
|
build_build_var_cache
|
|
if [ $? -ne 0 ]
|
|
then
|
|
if [[ "$product" =~ .*_(eng|user|userdebug) ]]
|
|
then
|
|
echo "Did you mean -${product/*_/}? (dash instead of underscore)"
|
|
fi
|
|
return 1
|
|
fi
|
|
export TARGET_PRODUCT=$(get_build_var TARGET_PRODUCT)
|
|
export TARGET_BUILD_VARIANT=$(get_build_var TARGET_BUILD_VARIANT)
|
|
export TARGET_RELEASE=$release
|
|
# Note this is the string "release", not the value of the variable.
|
|
export TARGET_BUILD_TYPE=release
|
|
|
|
[[ -n "${ANDROID_QUIET_BUILD:-}" ]] || echo
|
|
|
|
set_stuff_for_environment
|
|
[[ -n "${ANDROID_QUIET_BUILD:-}" ]] || printconfig
|
|
|
|
if [ "${TARGET_BUILD_VARIANT}" = "userdebug" ] && [[ -z "${ANDROID_QUIET_BUILD}" ]]; then
|
|
echo
|
|
echo "Want FASTER LOCAL BUILDS? Use -eng instead of -userdebug (however for" \
|
|
"performance benchmarking continue to use userdebug)"
|
|
fi
|
|
if [ $used_lunch_menu -eq 1 ]; then
|
|
echo
|
|
echo "Hint: next time you can simply run 'lunch $selection'"
|
|
fi
|
|
|
|
destroy_build_var_cache
|
|
|
|
if [[ -n "${CHECK_MU_CONFIG:-}" ]]; then
|
|
check_mu_config
|
|
fi
|
|
}
|
|
|
|
unset COMMON_LUNCH_CHOICES_CACHE
|
|
# Tab completion for lunch.
|
|
function _lunch()
|
|
{
|
|
local cur prev opts
|
|
COMPREPLY=()
|
|
cur="${COMP_WORDS[COMP_CWORD]}"
|
|
prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
if [ -z "$COMMON_LUNCH_CHOICES_CACHE" ]; then
|
|
COMMON_LUNCH_CHOICES_CACHE=$(TARGET_BUILD_APPS= get_build_var COMMON_LUNCH_CHOICES)
|
|
fi
|
|
|
|
COMPREPLY=( $(compgen -W "${COMMON_LUNCH_CHOICES_CACHE}" -- ${cur}) )
|
|
return 0
|
|
}
|
|
|
|
# Configures the build to build unbundled apps.
|
|
# Run tapas with one or more app names (from LOCAL_PACKAGE_NAME)
|
|
function tapas()
|
|
{
|
|
local showHelp="$(echo $* | xargs -n 1 echo | \grep -E '^(help)$' | xargs)"
|
|
local arch="$(echo $* | xargs -n 1 echo | \grep -E '^(arm|x86|arm64|x86_64)$' | xargs)"
|
|
# TODO(b/307975293): Expand tapas to take release arguments (and update hmm() usage).
|
|
local release="trunk_staging"
|
|
local variant="$(echo $* | xargs -n 1 echo | \grep -E '^(user|userdebug|eng)$' | xargs)"
|
|
local density="$(echo $* | xargs -n 1 echo | \grep -E '^(ldpi|mdpi|tvdpi|hdpi|xhdpi|xxhdpi|xxxhdpi|alldpi)$' | xargs)"
|
|
local keys="$(echo $* | xargs -n 1 echo | \grep -E '^(devkeys)$' | xargs)"
|
|
local apps="$(echo $* | xargs -n 1 echo | \grep -E -v '^(user|userdebug|eng|arm|x86|arm64|x86_64|ldpi|mdpi|tvdpi|hdpi|xhdpi|xxhdpi|xxxhdpi|alldpi|devkeys)$' | xargs)"
|
|
|
|
|
|
if [ "$showHelp" != "" ]; then
|
|
$(gettop)/build/make/tapasHelp.sh
|
|
return
|
|
fi
|
|
|
|
if [ $(echo $arch | wc -w) -gt 1 ]; then
|
|
echo "tapas: Error: Multiple build archs supplied: $arch"
|
|
return
|
|
fi
|
|
if [ $(echo $release | wc -w) -gt 1 ]; then
|
|
echo "tapas: Error: Multiple build releases supplied: $release"
|
|
return
|
|
fi
|
|
if [ $(echo $variant | wc -w) -gt 1 ]; then
|
|
echo "tapas: Error: Multiple build variants supplied: $variant"
|
|
return
|
|
fi
|
|
if [ $(echo $density | wc -w) -gt 1 ]; then
|
|
echo "tapas: Error: Multiple densities supplied: $density"
|
|
return
|
|
fi
|
|
if [ $(echo $keys | wc -w) -gt 1 ]; then
|
|
echo "tapas: Error: Multiple keys supplied: $keys"
|
|
return
|
|
fi
|
|
|
|
local product=aosp_arm
|
|
case $arch in
|
|
x86) product=aosp_x86;;
|
|
arm64) product=aosp_arm64;;
|
|
x86_64) product=aosp_x86_64;;
|
|
esac
|
|
if [ -n "$keys" ]; then
|
|
product=${product/aosp_/aosp_${keys}_}
|
|
fi;
|
|
|
|
if [ -z "$variant" ]; then
|
|
variant=eng
|
|
fi
|
|
if [ -z "$apps" ]; then
|
|
apps=all
|
|
fi
|
|
if [ -z "$density" ]; then
|
|
density=alldpi
|
|
fi
|
|
|
|
export TARGET_PRODUCT=$product
|
|
export TARGET_RELEASE=$release
|
|
export TARGET_BUILD_VARIANT=$variant
|
|
export TARGET_BUILD_DENSITY=$density
|
|
export TARGET_BUILD_TYPE=release
|
|
export TARGET_BUILD_APPS=$apps
|
|
|
|
build_build_var_cache
|
|
set_stuff_for_environment
|
|
printconfig
|
|
destroy_build_var_cache
|
|
}
|
|
|
|
# Configures the build to build unbundled Android modules (APEXes).
|
|
# Run banchan with one or more module names (from apex{} modules).
|
|
function banchan()
|
|
{
|
|
local showHelp="$(echo $* | xargs -n 1 echo | \grep -E '^(help)$' | xargs)"
|
|
local product="$(echo $* | xargs -n 1 echo | \grep -E '^(.*_)?(arm|x86|arm64|riscv64|x86_64|arm64only|x86_64only)$' | xargs)"
|
|
# TODO: Expand banchan to take release arguments (and update hmm() usage).
|
|
local release="trunk_staging"
|
|
local variant="$(echo $* | xargs -n 1 echo | \grep -E '^(user|userdebug|eng)$' | xargs)"
|
|
local apps="$(echo $* | xargs -n 1 echo | \grep -E -v '^(user|userdebug|eng|(.*_)?(arm|x86|arm64|riscv64|x86_64))$' | xargs)"
|
|
|
|
if [ "$showHelp" != "" ]; then
|
|
$(gettop)/build/make/banchanHelp.sh
|
|
return
|
|
fi
|
|
|
|
if [ -z "$product" ]; then
|
|
product=arm64
|
|
elif [ $(echo $product | wc -w) -gt 1 ]; then
|
|
echo "banchan: Error: Multiple build archs or products supplied: $products"
|
|
return
|
|
fi
|
|
if [ $(echo $release | wc -w) -gt 1 ]; then
|
|
echo "banchan: Error: Multiple build releases supplied: $release"
|
|
return
|
|
fi
|
|
if [ $(echo $variant | wc -w) -gt 1 ]; then
|
|
echo "banchan: Error: Multiple build variants supplied: $variant"
|
|
return
|
|
fi
|
|
if [ -z "$apps" ]; then
|
|
echo "banchan: Error: No modules supplied"
|
|
return
|
|
fi
|
|
|
|
case $product in
|
|
arm) product=module_arm;;
|
|
x86) product=module_x86;;
|
|
arm64) product=module_arm64;;
|
|
riscv64) product=module_riscv64;;
|
|
x86_64) product=module_x86_64;;
|
|
arm64only) product=module_arm64only;;
|
|
x86_64only) product=module_x86_64only;;
|
|
esac
|
|
if [ -z "$variant" ]; then
|
|
variant=eng
|
|
fi
|
|
|
|
export TARGET_PRODUCT=$product
|
|
export TARGET_RELEASE=$release
|
|
export TARGET_BUILD_VARIANT=$variant
|
|
export TARGET_BUILD_DENSITY=alldpi
|
|
export TARGET_BUILD_TYPE=release
|
|
|
|
# This setup currently uses TARGET_BUILD_APPS just like tapas, but the use
|
|
# case is different and it may diverge in the future.
|
|
export TARGET_BUILD_APPS=$apps
|
|
|
|
build_build_var_cache
|
|
set_stuff_for_environment
|
|
printconfig
|
|
destroy_build_var_cache
|
|
}
|
|
|
|
# TODO: Merge into gettop as part of launching multitree
|
|
function multitree_gettop
|
|
{
|
|
local TOPFILE=orchestrator/build/make/core/envsetup.mk
|
|
if [ -n "$TOP" -a -f "$TOP/$TOPFILE" ] ; then
|
|
# The following circumlocution ensures we remove symlinks from TOP.
|
|
(cd "$TOP"; PWD= /bin/pwd)
|
|
else
|
|
if [ -f $TOPFILE ] ; then
|
|
# The following circumlocution (repeated below as well) ensures
|
|
# that we record the true directory name and not one that is
|
|
# faked up with symlink names.
|
|
PWD= /bin/pwd
|
|
else
|
|
local HERE=$PWD
|
|
local T=
|
|
while [ \( ! \( -f $TOPFILE \) \) -a \( "$PWD" != "/" \) ]; do
|
|
\cd ..
|
|
T=`PWD= /bin/pwd -P`
|
|
done
|
|
\cd "$HERE"
|
|
if [ -f "$T/$TOPFILE" ]; then
|
|
echo "$T"
|
|
fi
|
|
fi
|
|
fi
|
|
}
|
|
|
|
function croot()
|
|
{
|
|
local T=$(gettop)
|
|
if [ "$T" ]; then
|
|
if [ "$1" ]; then
|
|
\cd $(gettop)/$1
|
|
else
|
|
\cd $(gettop)
|
|
fi
|
|
else
|
|
echo "Couldn't locate the top of the tree. Try setting TOP."
|
|
fi
|
|
}
|
|
|
|
function _croot()
|
|
{
|
|
local T=$(gettop)
|
|
if [ "$T" ]; then
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
k=0
|
|
for c in $(compgen -d ${T}/${cur}); do
|
|
COMPREPLY[k++]=${c#${T}/}/
|
|
done
|
|
fi
|
|
}
|
|
|
|
function cproj()
|
|
{
|
|
local TOPFILE=build/make/core/envsetup.mk
|
|
local HERE=$PWD
|
|
local T=
|
|
while [ \( ! \( -f $TOPFILE \) \) -a \( $PWD != "/" \) ]; do
|
|
T=$PWD
|
|
if [ -f "$T/Android.mk" ]; then
|
|
\cd $T
|
|
return
|
|
fi
|
|
\cd ..
|
|
done
|
|
\cd $HERE
|
|
echo "can't find Android.mk"
|
|
}
|
|
|
|
# Ensure that we're always using the adb in the tree. This works around the fact
|
|
# that bash caches $PATH lookups, so if you use adb before lunching/building the
|
|
# one in your tree, you'll continue to get /usr/bin/adb or whatever even after
|
|
# you have the one from your current tree on your path. Historically this would
|
|
# cause confusion because glinux had adb in /usr/bin/ by default, though that
|
|
# doesn't appear to be the case on my rodete hosts; it is however still the case
|
|
# that my Mac has /usr/local/bin/adb installed by default and on the default
|
|
# path.
|
|
function adb() {
|
|
# We need `command which` because zsh has a built-in `which` that's more
|
|
# like `type`.
|
|
local ADB=$(command which adb)
|
|
if [ -z "$ADB" ]; then
|
|
echo "Command adb not found; try lunch (and building) first?"
|
|
return 1
|
|
fi
|
|
$ADB "${@}"
|
|
}
|
|
|
|
function run_tool_with_logging() {
|
|
# Run commands in a subshell for us to handle forced terminations with a trap
|
|
# handler.
|
|
(
|
|
local tool_tag="$1"
|
|
shift
|
|
local tool_binary="$1"
|
|
shift
|
|
|
|
# If logging is not enabled or the logger is not configured, run the original command and return.
|
|
if [[ "${ANDROID_ENABLE_TOOL_LOGGING}" != "true" ]] || [[ -z "${ANDROID_TOOL_LOGGER}" ]]; then
|
|
"${tool_binary}" "${@}"
|
|
return $?
|
|
fi
|
|
|
|
# Otherwise, run the original command and call the logger when done.
|
|
local start_time
|
|
start_time=$(date +%s.%N)
|
|
local logger=${ANDROID_TOOL_LOGGER}
|
|
|
|
# Install a trap to call the logger even when the process terminates abnormally.
|
|
# The logger is run in the background and its output suppressed to avoid
|
|
# interference with the user flow.
|
|
trap '
|
|
exit_code=$?;
|
|
# Remove the trap to prevent duplicate log.
|
|
trap - EXIT;
|
|
"${logger}" \
|
|
--tool_tag "${tool_tag}" \
|
|
--start_timestamp "${start_time}" \
|
|
--end_timestamp "$(date +%s.%N)" \
|
|
--tool_args \""${@}"\" \
|
|
--exit_code "${exit_code}" \
|
|
> /dev/null 2>&1 &
|
|
exit ${exit_code}
|
|
' SIGINT SIGTERM SIGQUIT EXIT
|
|
|
|
# Run the original command.
|
|
"${tool_binary}" "${@}"
|
|
)
|
|
}
|
|
|
|
# simplified version of ps; output in the form
|
|
# <pid> <procname>
|
|
function qpid() {
|
|
local prepend=''
|
|
local append=''
|
|
if [ "$1" = "--exact" ]; then
|
|
prepend=' '
|
|
append='$'
|
|
shift
|
|
elif [ "$1" = "--help" -o "$1" = "-h" ]; then
|
|
echo "usage: qpid [[--exact] <process name|pid>"
|
|
return 255
|
|
fi
|
|
|
|
local EXE="$1"
|
|
if [ "$EXE" ] ; then
|
|
qpid | \grep "$prepend$EXE$append"
|
|
else
|
|
adb shell ps \
|
|
| tr -d '\r' \
|
|
| sed -e 1d -e 's/^[^ ]* *\([0-9]*\).* \([^ ]*\)$/\1 \2/'
|
|
fi
|
|
}
|
|
|
|
# syswrite - disable verity, reboot if needed, and remount image
|
|
#
|
|
# Easy way to make system.img/etc writable
|
|
function syswrite() {
|
|
adb wait-for-device && adb root && adb wait-for-device || return 1
|
|
if [[ $(adb disable-verity | grep -i "reboot") ]]; then
|
|
echo "rebooting"
|
|
adb reboot && adb wait-for-device && adb root && adb wait-for-device || return 1
|
|
fi
|
|
adb remount || return 1
|
|
}
|
|
|
|
# coredump_setup - enable core dumps globally for any process
|
|
# that has the core-file-size limit set correctly
|
|
#
|
|
# NOTE: You must call also coredump_enable for a specific process
|
|
# if its core-file-size limit is not set already.
|
|
# NOTE: Core dumps are written to ramdisk; they will not survive a reboot!
|
|
|
|
function coredump_setup()
|
|
{
|
|
echo "Getting root...";
|
|
adb root;
|
|
adb wait-for-device;
|
|
|
|
echo "Remounting root partition read-write...";
|
|
adb shell mount -w -o remount -t rootfs rootfs;
|
|
sleep 1;
|
|
adb wait-for-device;
|
|
adb shell mkdir -p /cores;
|
|
adb shell mount -t tmpfs tmpfs /cores;
|
|
adb shell chmod 0777 /cores;
|
|
|
|
echo "Granting SELinux permission to dump in /cores...";
|
|
adb shell restorecon -R /cores;
|
|
|
|
echo "Set core pattern.";
|
|
adb shell 'echo /cores/core.%p > /proc/sys/kernel/core_pattern';
|
|
|
|
echo "Done."
|
|
}
|
|
|
|
# coredump_enable - enable core dumps for the specified process
|
|
# $1 = PID of process (e.g., $(pid mediaserver))
|
|
#
|
|
# NOTE: coredump_setup must have been called as well for a core
|
|
# dump to actually be generated.
|
|
|
|
function coredump_enable()
|
|
{
|
|
local PID=$1;
|
|
if [ -z "$PID" ]; then
|
|
printf "Expecting a PID!\n";
|
|
return;
|
|
fi;
|
|
echo "Setting core limit for $PID to infinite...";
|
|
adb shell /system/bin/ulimit -P $PID -c unlimited
|
|
}
|
|
|
|
# core - send SIGV and pull the core for process
|
|
# $1 = PID of process (e.g., $(pid mediaserver))
|
|
#
|
|
# NOTE: coredump_setup must be called once per boot for core dumps to be
|
|
# enabled globally.
|
|
|
|
function core()
|
|
{
|
|
local PID=$1;
|
|
|
|
if [ -z "$PID" ]; then
|
|
printf "Expecting a PID!\n";
|
|
return;
|
|
fi;
|
|
|
|
local CORENAME=core.$PID;
|
|
local COREPATH=/cores/$CORENAME;
|
|
local SIG=SEGV;
|
|
|
|
coredump_enable $1;
|
|
|
|
local done=0;
|
|
while [ $(adb shell "[ -d /proc/$PID ] && echo -n yes") ]; do
|
|
printf "\tSending SIG%s to %d...\n" $SIG $PID;
|
|
adb shell kill -$SIG $PID;
|
|
sleep 1;
|
|
done;
|
|
|
|
adb shell "while [ ! -f $COREPATH ] ; do echo waiting for $COREPATH to be generated; sleep 1; done"
|
|
echo "Done: core is under $COREPATH on device.";
|
|
}
|
|
|
|
# systemstack - dump the current stack trace of all threads in the system process
|
|
# to the usual ANR traces file
|
|
function systemstack()
|
|
{
|
|
stacks system_server
|
|
}
|
|
|
|
# Read the ELF header from /proc/$PID/exe to determine if the process is
|
|
# 64-bit.
|
|
function is64bit()
|
|
{
|
|
local PID="$1"
|
|
if [ "$PID" ] ; then
|
|
if [[ "$(adb shell cat /proc/$PID/exe | xxd -l 1 -s 4 -p)" -eq "02" ]] ; then
|
|
echo "64"
|
|
else
|
|
echo ""
|
|
fi
|
|
else
|
|
echo ""
|
|
fi
|
|
}
|
|
|
|
case `uname -s` in
|
|
Darwin)
|
|
function sgrep()
|
|
{
|
|
find -E . -name .repo -prune -o -name .git -prune -o -type f -iregex '.*\.(c|h|cc|cpp|hpp|S|java|kt|xml|sh|mk|aidl|vts|proto|rs|go)' \
|
|
-exec grep --color -n "$@" {} +
|
|
}
|
|
|
|
;;
|
|
*)
|
|
function sgrep()
|
|
{
|
|
find . -name .repo -prune -o -name .git -prune -o -type f -iregex '.*\.\(c\|h\|cc\|cpp\|hpp\|S\|java\|kt\|xml\|sh\|mk\|aidl\|vts\|proto\|rs\|go\)' \
|
|
-exec grep --color -n "$@" {} +
|
|
}
|
|
;;
|
|
esac
|
|
|
|
function gettargetarch
|
|
{
|
|
get_build_var TARGET_ARCH
|
|
}
|
|
|
|
function ggrep()
|
|
{
|
|
find . -name .repo -prune -o -name .git -prune -o -name out -prune -o -type f -name "*\.gradle" \
|
|
-exec grep --color -n "$@" {} +
|
|
}
|
|
|
|
function gogrep()
|
|
{
|
|
find . -name .repo -prune -o -name .git -prune -o -name out -prune -o -type f -name "*\.go" \
|
|
-exec grep --color -n "$@" {} +
|
|
}
|
|
|
|
function jgrep()
|
|
{
|
|
find . -name .repo -prune -o -name .git -prune -o -name out -prune -o -type f -name "*\.java" \
|
|
-exec grep --color -n "$@" {} +
|
|
}
|
|
|
|
function rsgrep()
|
|
{
|
|
find . -name .repo -prune -o -name .git -prune -o -name out -prune -o -type f -name "*\.rs" \
|
|
-exec grep --color -n "$@" {} +
|
|
}
|
|
|
|
function jsongrep()
|
|
{
|
|
find . -name .repo -prune -o -name .git -prune -o -name out -prune -o -type f -name "*\.json" \
|
|
-exec grep --color -n "$@" {} +
|
|
}
|
|
|
|
function tomlgrep()
|
|
{
|
|
find . -name .repo -prune -o -name .git -prune -o -name out -prune -o -type f -name "*\.toml" \
|
|
-exec grep --color -n "$@" {} +
|
|
}
|
|
|
|
function ktgrep()
|
|
{
|
|
find . -name .repo -prune -o -name .git -prune -o -name out -prune -o -type f -name "*\.kt" \
|
|
-exec grep --color -n "$@" {} +
|
|
}
|
|
|
|
function cgrep()
|
|
{
|
|
find . -name .repo -prune -o -name .git -prune -o -name out -prune -o -type f \( -name '*.c' -o -name '*.cc' -o -name '*.cpp' -o -name '*.h' -o -name '*.hpp' \) \
|
|
-exec grep --color -n "$@" {} +
|
|
}
|
|
|
|
function resgrep()
|
|
{
|
|
local dir
|
|
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' -exec grep --color -n "$@" {} +
|
|
done
|
|
}
|
|
|
|
function mangrep()
|
|
{
|
|
find . -name .repo -prune -o -name .git -prune -o -path ./out -prune -o -type f -name 'AndroidManifest.xml' \
|
|
-exec grep --color -n "$@" {} +
|
|
}
|
|
|
|
function owngrep()
|
|
{
|
|
find . -name .repo -prune -o -name .git -prune -o -path ./out -prune -o -type f -name 'OWNERS' \
|
|
-exec grep --color -n "$@" {} +
|
|
}
|
|
|
|
function sepgrep()
|
|
{
|
|
find . -name .repo -prune -o -name .git -prune -o -path ./out -prune -o -name sepolicy -type d \
|
|
-exec grep --color -n -r --exclude-dir=\.git "$@" {} +
|
|
}
|
|
|
|
function rcgrep()
|
|
{
|
|
find . -name .repo -prune -o -name .git -prune -o -name out -prune -o -type f -name "*\.rc*" \
|
|
-exec grep --color -n "$@" {} +
|
|
}
|
|
|
|
function pygrep()
|
|
{
|
|
find . -name .repo -prune -o -name .git -prune -o -name out -prune -o -type f -name "*\.py" \
|
|
-exec grep --color -n "$@" {} +
|
|
}
|
|
|
|
case `uname -s` in
|
|
Darwin)
|
|
function mgrep()
|
|
{
|
|
find -E . -name .repo -prune -o -name .git -prune -o -path ./out -prune -o \( -iregex '.*/(Makefile|Makefile\..*|.*\.make|.*\.mak|.*\.mk|.*\.bp)' -o -regex '(.*/)?(build|soong)/.*[^/]*\.go' \) -type f \
|
|
-exec grep --color -n "$@" {} +
|
|
}
|
|
|
|
function treegrep()
|
|
{
|
|
find -E . -name .repo -prune -o -name .git -prune -o -type f -iregex '.*\.(c|h|cpp|hpp|S|java|kt|xml)' \
|
|
-exec grep --color -n -i "$@" {} +
|
|
}
|
|
|
|
;;
|
|
*)
|
|
function mgrep()
|
|
{
|
|
find . -name .repo -prune -o -name .git -prune -o -path ./out -prune -o \( -regextype posix-egrep -iregex '(.*\/Makefile|.*\/Makefile\..*|.*\.make|.*\.mak|.*\.mk|.*\.bp)' -o -regextype posix-extended -regex '(.*/)?(build|soong)/.*[^/]*\.go' \) -type f \
|
|
-exec grep --color -n "$@" {} +
|
|
}
|
|
|
|
function treegrep()
|
|
{
|
|
find . -name .repo -prune -o -name .git -prune -o -regextype posix-egrep -iregex '.*\.(c|h|cpp|hpp|S|java|kt|xml)' -type f \
|
|
-exec grep --color -n -i "$@" {} +
|
|
}
|
|
|
|
;;
|
|
esac
|
|
|
|
function getprebuilt
|
|
{
|
|
get_abs_build_var ANDROID_PREBUILTS
|
|
}
|
|
|
|
# communicate with a running device or emulator, set up necessary state,
|
|
# and run the hat command.
|
|
function runhat()
|
|
{
|
|
# process standard adb options
|
|
local adbTarget=""
|
|
if [ "$1" = "-d" -o "$1" = "-e" ]; then
|
|
adbTarget=$1
|
|
shift 1
|
|
elif [ "$1" = "-s" ]; then
|
|
adbTarget="$1 $2"
|
|
shift 2
|
|
fi
|
|
local adbOptions=${adbTarget}
|
|
#echo adbOptions = ${adbOptions}
|
|
|
|
# runhat options
|
|
local targetPid=$1
|
|
|
|
if [ "$targetPid" = "" ]; then
|
|
echo "Usage: runhat [ -d | -e | -s serial ] target-pid"
|
|
return
|
|
fi
|
|
|
|
# confirm hat is available
|
|
if [ -z $(which hat) ]; then
|
|
echo "hat is not available in this configuration."
|
|
return
|
|
fi
|
|
|
|
# issue "am" command to cause the hprof dump
|
|
local devFile=/data/local/tmp/hprof-$targetPid
|
|
echo "Poking $targetPid and waiting for data..."
|
|
echo "Storing data at $devFile"
|
|
adb ${adbOptions} shell am dumpheap $targetPid $devFile
|
|
echo "Press enter when logcat shows \"hprof: heap dump completed\""
|
|
echo -n "> "
|
|
read
|
|
|
|
local localFile=/tmp/$$-hprof
|
|
|
|
echo "Retrieving file $devFile..."
|
|
adb ${adbOptions} pull $devFile $localFile
|
|
|
|
adb ${adbOptions} shell rm $devFile
|
|
|
|
echo "Running hat on $localFile"
|
|
echo "View the output by pointing your browser at http://localhost:7000/"
|
|
echo ""
|
|
hat -JXmx512m $localFile
|
|
}
|
|
|
|
function getbugreports()
|
|
{
|
|
local reports=(`adb shell ls /sdcard/bugreports | tr -d '\r'`)
|
|
|
|
if [ ! "$reports" ]; then
|
|
echo "Could not locate any bugreports."
|
|
return
|
|
fi
|
|
|
|
local report
|
|
for report in ${reports[@]}
|
|
do
|
|
echo "/sdcard/bugreports/${report}"
|
|
adb pull /sdcard/bugreports/${report} ${report}
|
|
gunzip ${report}
|
|
done
|
|
}
|
|
|
|
function getsdcardpath()
|
|
{
|
|
adb ${adbOptions} shell echo -n \$\{EXTERNAL_STORAGE\}
|
|
}
|
|
|
|
function getscreenshotpath()
|
|
{
|
|
echo "$(getsdcardpath)/Pictures/Screenshots"
|
|
}
|
|
|
|
function getlastscreenshot()
|
|
{
|
|
local screenshot_path=$(getscreenshotpath)
|
|
local screenshot=`adb ${adbOptions} ls ${screenshot_path} | grep Screenshot_[0-9-]*.*\.png | sort -rk 3 | cut -d " " -f 4 | head -n 1`
|
|
if [ "$screenshot" = "" ]; then
|
|
echo "No screenshots found."
|
|
return
|
|
fi
|
|
echo "${screenshot}"
|
|
adb ${adbOptions} pull ${screenshot_path}/${screenshot}
|
|
}
|
|
|
|
function startviewserver()
|
|
{
|
|
local port=4939
|
|
if [ $# -gt 0 ]; then
|
|
port=$1
|
|
fi
|
|
adb shell service call window 1 i32 $port
|
|
}
|
|
|
|
function stopviewserver()
|
|
{
|
|
adb shell service call window 2
|
|
}
|
|
|
|
function isviewserverstarted()
|
|
{
|
|
adb shell service call window 3
|
|
}
|
|
|
|
function key_home()
|
|
{
|
|
adb shell input keyevent 3
|
|
}
|
|
|
|
function key_back()
|
|
{
|
|
adb shell input keyevent 4
|
|
}
|
|
|
|
function key_menu()
|
|
{
|
|
adb shell input keyevent 82
|
|
}
|
|
|
|
function smoketest()
|
|
{
|
|
if [ ! "$ANDROID_PRODUCT_OUT" ]; then
|
|
echo "Couldn't locate output files. Try running 'lunch' first." >&2
|
|
return
|
|
fi
|
|
local T=$(gettop)
|
|
if [ ! "$T" ]; then
|
|
echo "Couldn't locate the top of the tree. Try setting TOP." >&2
|
|
return
|
|
fi
|
|
|
|
(\cd "$T" && mmm tests/SmokeTest) &&
|
|
adb uninstall com.android.smoketest > /dev/null &&
|
|
adb uninstall com.android.smoketest.tests > /dev/null &&
|
|
adb install $ANDROID_PRODUCT_OUT/data/app/SmokeTestApp.apk &&
|
|
adb install $ANDROID_PRODUCT_OUT/data/app/SmokeTest.apk &&
|
|
adb shell am instrument -w com.android.smoketest.tests/android.test.InstrumentationTestRunner
|
|
}
|
|
|
|
# simple shortcut to the runtest command
|
|
function runtest()
|
|
{
|
|
local T=$(gettop)
|
|
if [ ! "$T" ]; then
|
|
echo "Couldn't locate the top of the tree. Try setting TOP." >&2
|
|
return
|
|
fi
|
|
("$T"/development/testrunner/runtest.py $@)
|
|
}
|
|
|
|
function godir () {
|
|
if [[ -z "$1" ]]; then
|
|
echo "Usage: godir <regex>"
|
|
return
|
|
fi
|
|
local T=$(gettop)
|
|
local FILELIST
|
|
if [ ! "$OUT_DIR" = "" ]; then
|
|
mkdir -p $OUT_DIR
|
|
FILELIST=$OUT_DIR/filelist
|
|
else
|
|
FILELIST=$T/filelist
|
|
fi
|
|
if [[ ! -f $FILELIST ]]; then
|
|
echo -n "Creating index..."
|
|
(\cd $T; find . -wholename ./out -prune -o -wholename ./.repo -prune -o -type f > $FILELIST)
|
|
echo " Done"
|
|
echo ""
|
|
fi
|
|
local lines
|
|
lines=($(\grep "$1" $FILELIST | sed -e 's/\/[^/]*$//' | sort | uniq))
|
|
if [[ ${#lines[@]} = 0 ]]; then
|
|
echo "Not found"
|
|
return
|
|
fi
|
|
local pathname
|
|
local choice
|
|
if [[ ${#lines[@]} > 1 ]]; then
|
|
while [[ -z "$pathname" ]]; do
|
|
local index=1
|
|
local line
|
|
for line in ${lines[@]}; do
|
|
printf "%6s %s\n" "[$index]" $line
|
|
index=$(($index + 1))
|
|
done
|
|
echo
|
|
echo -n "Select one: "
|
|
unset choice
|
|
read choice
|
|
if [[ $choice -gt ${#lines[@]} || $choice -lt 1 ]]; then
|
|
echo "Invalid choice"
|
|
continue
|
|
fi
|
|
pathname=${lines[@]:$(($choice-1)):1}
|
|
done
|
|
else
|
|
pathname=${lines[@]:0:1}
|
|
fi
|
|
\cd $T/$pathname
|
|
}
|
|
|
|
# Update module-info.json in out.
|
|
function refreshmod() {
|
|
if [ ! "$ANDROID_PRODUCT_OUT" ]; then
|
|
echo "No ANDROID_PRODUCT_OUT. Try running 'lunch' first." >&2
|
|
return 1
|
|
fi
|
|
|
|
echo "Refreshing modules (building module-info.json). Log at $ANDROID_PRODUCT_OUT/module-info.json.build.log." >&2
|
|
|
|
# for the output of the next command
|
|
mkdir -p $ANDROID_PRODUCT_OUT || return 1
|
|
|
|
# Note, can't use absolute path because of the way make works.
|
|
m $(get_build_var PRODUCT_OUT)/module-info.json \
|
|
> $ANDROID_PRODUCT_OUT/module-info.json.build.log 2>&1
|
|
}
|
|
|
|
# Verifies that module-info.txt exists, returning nonzero if it doesn't.
|
|
function verifymodinfo() {
|
|
if [ ! "$ANDROID_PRODUCT_OUT" ]; then
|
|
if [ "$QUIET_VERIFYMODINFO" != "true" ] ; then
|
|
echo "No ANDROID_PRODUCT_OUT. Try running 'lunch' first." >&2
|
|
fi
|
|
return 1
|
|
fi
|
|
|
|
if [ ! -f "$ANDROID_PRODUCT_OUT/module-info.json" ]; then
|
|
if [ "$QUIET_VERIFYMODINFO" != "true" ] ; then
|
|
echo "Could not find module-info.json. Please run 'refreshmod' first." >&2
|
|
fi
|
|
return 1
|
|
fi
|
|
}
|
|
|
|
# List all modules for the current device, as cached in all_modules.txt. If any build change is
|
|
# made and it should be reflected in the output, you should run `m nothing` first.
|
|
function allmod() {
|
|
cat $ANDROID_PRODUCT_OUT/all_modules.txt 2>/dev/null
|
|
}
|
|
|
|
# Return the Bazel label of a Soong module if it is converted with bp2build.
|
|
function bmod()
|
|
(
|
|
if [ $# -eq 0 ]; then
|
|
echo "usage: bmod <module 1> <module 2> ... <module n>" >&2
|
|
return 1
|
|
fi
|
|
|
|
# We could run bp2build here, but it might trigger bp2build invalidation
|
|
# when used with `b` (e.g. --run_soong_tests) and/or add unnecessary waiting
|
|
# time overhead.
|
|
#
|
|
# For a snappy result, use the latest generated version in soong_injection,
|
|
# and ask users to run m bp2build if it doesn't exist.
|
|
converted_json="$(get_abs_build_var OUT_DIR)/soong/soong_injection/metrics/converted_modules_path_map.json"
|
|
|
|
if [ ! -f ${converted_json} ]; then
|
|
echo "bp2build files not found. Have you ran 'm bp2build'?" >&2
|
|
return 1
|
|
fi
|
|
|
|
modules=()
|
|
for m in "$@"; do
|
|
modules+=("\"$m\",")
|
|
done
|
|
local res=$(python3 -c "import json
|
|
modules = [${modules[*]}]
|
|
converted_json='$converted_json'
|
|
bp2build_converted_map = json.load(open(converted_json))
|
|
for module in modules:
|
|
if module not in bp2build_converted_map:
|
|
print(module + ' is not converted to Bazel.')
|
|
else:
|
|
print(bp2build_converted_map[module] + ':' + module)")
|
|
|
|
echo "${res}"
|
|
unconverted_count=$(echo "${res}" | grep -c "not converted to Bazel")
|
|
if [[ ${unconverted_count} -ne 0 ]]; then
|
|
return 1
|
|
fi
|
|
)
|
|
|
|
# Get the path of a specific module in the android tree, as cached in module-info.json.
|
|
# If any build change is made, and it should be reflected in the output, you should run
|
|
# 'refreshmod' first. Note: This is the inverse of dirmods.
|
|
function pathmod() {
|
|
if [[ $# -ne 1 ]]; then
|
|
echo "usage: pathmod <module>" >&2
|
|
return 1
|
|
fi
|
|
|
|
verifymodinfo || return 1
|
|
|
|
local relpath=$(python3 -c "import json, os
|
|
module = '$1'
|
|
module_info = json.load(open('$ANDROID_PRODUCT_OUT/module-info.json'))
|
|
if module not in module_info:
|
|
exit(1)
|
|
print(module_info[module]['path'][0])" 2>/dev/null)
|
|
|
|
if [ -z "$relpath" ]; then
|
|
echo "Could not find module '$1' (try 'refreshmod' if there have been build changes?)." >&2
|
|
return 1
|
|
else
|
|
echo "$ANDROID_BUILD_TOP/$relpath"
|
|
fi
|
|
}
|
|
|
|
# Get the path of a specific module in the android tree, as cached in module-info.json.
|
|
# If any build change is made, and it should be reflected in the output, you should run
|
|
# 'refreshmod' first. Note: This is the inverse of pathmod.
|
|
function dirmods() {
|
|
if [[ $# -ne 1 ]]; then
|
|
echo "usage: dirmods <path>" >&2
|
|
return 1
|
|
fi
|
|
|
|
verifymodinfo || return 1
|
|
|
|
python3 -c "import json, os
|
|
dir = '$1'
|
|
while dir.endswith('/'):
|
|
dir = dir[:-1]
|
|
prefix = dir + '/'
|
|
module_info = json.load(open('$ANDROID_PRODUCT_OUT/module-info.json'))
|
|
results = set()
|
|
for m in module_info.values():
|
|
for path in m.get(u'path', []):
|
|
if path == dir or path.startswith(prefix):
|
|
name = m.get(u'module_name')
|
|
if name:
|
|
results.add(name)
|
|
for name in sorted(results):
|
|
print(name)
|
|
"
|
|
}
|
|
|
|
|
|
# Go to a specific module in the android tree, as cached in module-info.json. If any build change
|
|
# is made, and it should be reflected in the output, you should run 'refreshmod' first.
|
|
function gomod() {
|
|
if [[ $# -ne 1 ]]; then
|
|
echo "usage: gomod <module>" >&2
|
|
return 1
|
|
fi
|
|
|
|
local path="$(pathmod $@)"
|
|
if [ -z "$path" ]; then
|
|
return 1
|
|
fi
|
|
cd $path
|
|
}
|
|
|
|
# Gets the list of a module's installed outputs, as cached in module-info.json.
|
|
# If any build change is made, and it should be reflected in the output, you should run 'refreshmod' first.
|
|
function outmod() {
|
|
if [[ $# -ne 1 ]]; then
|
|
echo "usage: outmod <module>" >&2
|
|
return 1
|
|
fi
|
|
|
|
verifymodinfo || return 1
|
|
|
|
local relpath
|
|
relpath=$(python3 -c "import json, os
|
|
module = '$1'
|
|
module_info = json.load(open('$ANDROID_PRODUCT_OUT/module-info.json'))
|
|
if module not in module_info:
|
|
exit(1)
|
|
for output in module_info[module]['installed']:
|
|
print(os.path.join('$ANDROID_BUILD_TOP', output))" 2>/dev/null)
|
|
|
|
if [ $? -ne 0 ]; then
|
|
echo "Could not find module '$1' (try 'refreshmod' if there have been build changes?)" >&2
|
|
return 1
|
|
elif [ ! -z "$relpath" ]; then
|
|
echo "$relpath"
|
|
fi
|
|
}
|
|
|
|
# adb install a module's apk, as cached in module-info.json. If any build change
|
|
# is made, and it should be reflected in the output, you should run 'refreshmod' first.
|
|
# Usage: installmod [adb install arguments] <module>
|
|
# For example: installmod -r Dialer -> adb install -r /path/to/Dialer.apk
|
|
function installmod() {
|
|
if [[ $# -eq 0 ]]; then
|
|
echo "usage: installmod [adb install arguments] <module>" >&2
|
|
echo "" >&2
|
|
echo "Only flags to be passed after the \"install\" in adb install are supported," >&2
|
|
echo "with the exception of -s. If -s is passed it will be placed before the \"install\"." >&2
|
|
echo "-s must be the first flag passed if it exists." >&2
|
|
return 1
|
|
fi
|
|
|
|
local _path
|
|
_path=$(outmod ${@:$#:1})
|
|
if [ $? -ne 0 ]; then
|
|
return 1
|
|
fi
|
|
|
|
_path=$(echo "$_path" | grep -E \\.apk$ | head -n 1)
|
|
if [ -z "$_path" ]; then
|
|
echo "Module '$1' does not produce a file ending with .apk (try 'refreshmod' if there have been build changes?)" >&2
|
|
return 1
|
|
fi
|
|
local serial_device=""
|
|
if [[ "$1" == "-s" ]]; then
|
|
if [[ $# -le 2 ]]; then
|
|
echo "-s requires an argument" >&2
|
|
return 1
|
|
fi
|
|
serial_device="-s $2"
|
|
shift 2
|
|
fi
|
|
local length=$(( $# - 1 ))
|
|
echo adb $serial_device install ${@:1:$length} $_path
|
|
adb $serial_device install ${@:1:$length} $_path
|
|
}
|
|
|
|
function _complete_android_module_names() {
|
|
local word=${COMP_WORDS[COMP_CWORD]}
|
|
COMPREPLY=( $(allmod | grep -E "^$word") )
|
|
}
|
|
|
|
# Print colored exit condition
|
|
function pez {
|
|
"$@"
|
|
local retval=$?
|
|
if [ $retval -ne 0 ]
|
|
then
|
|
echo $'\E'"[0;31mFAILURE\e[00m"
|
|
else
|
|
echo $'\E'"[0;32mSUCCESS\e[00m"
|
|
fi
|
|
return $retval
|
|
}
|
|
|
|
function get_make_command()
|
|
{
|
|
# If we're in the top of an Android tree, use soong_ui.bash instead of make
|
|
if [ -f build/soong/soong_ui.bash ]; then
|
|
# Always use the real make if -C is passed in
|
|
for arg in "$@"; do
|
|
if [[ $arg == -C* ]]; then
|
|
echo command make
|
|
return
|
|
fi
|
|
done
|
|
echo build/soong/soong_ui.bash --make-mode
|
|
else
|
|
echo command make
|
|
fi
|
|
}
|
|
|
|
function _wrap_build()
|
|
{
|
|
if [[ "${ANDROID_QUIET_BUILD:-}" == true ]]; then
|
|
"$@"
|
|
return $?
|
|
fi
|
|
local start_time=$(date +"%s")
|
|
"$@"
|
|
local ret=$?
|
|
local end_time=$(date +"%s")
|
|
local tdiff=$(($end_time-$start_time))
|
|
local hours=$(($tdiff / 3600 ))
|
|
local mins=$((($tdiff % 3600) / 60))
|
|
local secs=$(($tdiff % 60))
|
|
local ncolors=$(tput colors 2>/dev/null)
|
|
if [ -n "$ncolors" ] && [ $ncolors -ge 8 ]; then
|
|
color_failed=$'\E'"[0;31m"
|
|
color_success=$'\E'"[0;32m"
|
|
color_warning=$'\E'"[0;33m"
|
|
color_reset=$'\E'"[00m"
|
|
else
|
|
color_failed=""
|
|
color_success=""
|
|
color_reset=""
|
|
fi
|
|
|
|
echo
|
|
if [ $ret -eq 0 ] ; then
|
|
echo -n "${color_success}#### build completed successfully "
|
|
else
|
|
echo -n "${color_failed}#### failed to build some targets "
|
|
fi
|
|
if [ $hours -gt 0 ] ; then
|
|
printf "(%02g:%02g:%02g (hh:mm:ss))" $hours $mins $secs
|
|
elif [ $mins -gt 0 ] ; then
|
|
printf "(%02g:%02g (mm:ss))" $mins $secs
|
|
elif [ $secs -gt 0 ] ; then
|
|
printf "(%s seconds)" $secs
|
|
fi
|
|
echo " ####${color_reset}"
|
|
echo
|
|
return $ret
|
|
}
|
|
|
|
function _trigger_build()
|
|
(
|
|
local -r bc="$1"; shift
|
|
local T=$(gettop)
|
|
if [ -n "$T" ]; then
|
|
_wrap_build "$T/build/soong/soong_ui.bash" --build-mode --${bc} --dir="$(pwd)" "$@"
|
|
else
|
|
>&2 echo "Couldn't locate the top of the tree. Try setting TOP."
|
|
return 1
|
|
fi
|
|
local ret=$?
|
|
if [[ ret -eq 0 && -z "${ANDROID_QUIET_BUILD:-}" && -n "${ANDROID_BUILD_BANNER}" ]]; then
|
|
echo "${ANDROID_BUILD_BANNER}"
|
|
fi
|
|
return $ret
|
|
)
|
|
|
|
function m()
|
|
(
|
|
_trigger_build "all-modules" "$@"
|
|
)
|
|
|
|
function mm()
|
|
(
|
|
_trigger_build "modules-in-a-dir-no-deps" "$@"
|
|
)
|
|
|
|
function mmm()
|
|
(
|
|
_trigger_build "modules-in-dirs-no-deps" "$@"
|
|
)
|
|
|
|
function mma()
|
|
(
|
|
_trigger_build "modules-in-a-dir" "$@"
|
|
)
|
|
|
|
function mmma()
|
|
(
|
|
_trigger_build "modules-in-dirs" "$@"
|
|
)
|
|
|
|
function make()
|
|
{
|
|
_wrap_build $(get_make_command "$@") "$@"
|
|
}
|
|
|
|
function _multitree_lunch_error()
|
|
{
|
|
>&2 echo "Couldn't locate the top of the tree. Please run \'source build/envsetup.sh\' and multitree_lunch from the root of your workspace."
|
|
}
|
|
|
|
function multitree_build()
|
|
{
|
|
local T=$(multitree_gettop)
|
|
if [ -n "$T" ]; then
|
|
"$T/orchestrator/build/orchestrator/core/orchestrator.py" "$@"
|
|
else
|
|
_multitree_lunch_error
|
|
return 1
|
|
fi
|
|
}
|
|
|
|
function provision()
|
|
{
|
|
if [ ! "$ANDROID_PRODUCT_OUT" ]; then
|
|
echo "Couldn't locate output files. Try running 'lunch' first." >&2
|
|
return 1
|
|
fi
|
|
if [ ! -e "$ANDROID_PRODUCT_OUT/provision-device" ]; then
|
|
echo "There is no provisioning script for the device." >&2
|
|
return 1
|
|
fi
|
|
|
|
# Check if user really wants to do this.
|
|
if [ "$1" = "--no-confirmation" ]; then
|
|
shift 1
|
|
else
|
|
echo "This action will reflash your device."
|
|
echo ""
|
|
echo "ALL DATA ON THE DEVICE WILL BE IRREVOCABLY ERASED."
|
|
echo ""
|
|
echo -n "Are you sure you want to do this (yes/no)? "
|
|
read
|
|
if [[ "${REPLY}" != "yes" ]] ; then
|
|
echo "Not taking any action. Exiting." >&2
|
|
return 1
|
|
fi
|
|
fi
|
|
"$ANDROID_PRODUCT_OUT/provision-device" "$@"
|
|
}
|
|
|
|
# Zsh needs bashcompinit called to support bash-style completion.
|
|
function enable_zsh_completion() {
|
|
# Don't override user's options if bash-style completion is already enabled.
|
|
if ! declare -f complete >/dev/null; then
|
|
autoload -U compinit && compinit
|
|
autoload -U bashcompinit && bashcompinit
|
|
fi
|
|
}
|
|
|
|
function validate_current_shell() {
|
|
local current_sh="$(ps -o command -p $$)"
|
|
case "$current_sh" in
|
|
*bash*)
|
|
function check_type() { type -t "$1"; }
|
|
;;
|
|
*zsh*)
|
|
function check_type() { type "$1"; }
|
|
enable_zsh_completion ;;
|
|
*)
|
|
echo -e "WARNING: Only bash and zsh are supported.\nUse of other shell would lead to erroneous results."
|
|
;;
|
|
esac
|
|
}
|
|
|
|
# Execute the contents of any vendorsetup.sh files we can find.
|
|
# Unless we find an allowed-vendorsetup_sh-files file, in which case we'll only
|
|
# load those.
|
|
#
|
|
# This allows loading only approved vendorsetup.sh files
|
|
function source_vendorsetup() {
|
|
unset VENDOR_PYTHONPATH
|
|
local T="$(gettop)"
|
|
allowed=
|
|
for f in $(cd "$T" && find -L device vendor product -maxdepth 4 -name 'allowed-vendorsetup_sh-files' 2>/dev/null | sort); do
|
|
if [ -n "$allowed" ]; then
|
|
echo "More than one 'allowed_vendorsetup_sh-files' file found, not including any vendorsetup.sh files:"
|
|
echo " $allowed"
|
|
echo " $f"
|
|
return
|
|
fi
|
|
allowed="$T/$f"
|
|
done
|
|
|
|
allowed_files=
|
|
[ -n "$allowed" ] && allowed_files=$(cat "$allowed")
|
|
for dir in device vendor product; do
|
|
for f in $(cd "$T" && test -d $dir && \
|
|
find -L $dir -maxdepth 4 -name 'vendorsetup.sh' 2>/dev/null | sort); do
|
|
|
|
if [[ -z "$allowed" || "$allowed_files" =~ $f ]]; then
|
|
echo "including $f"; . "$T/$f"
|
|
else
|
|
echo "ignoring $f, not in $allowed"
|
|
fi
|
|
done
|
|
done
|
|
|
|
if [[ "${PWD}" == /google/cog/* ]]; then
|
|
f="build/make/cogsetup.sh"
|
|
echo "including $f"; . "$T/$f"
|
|
fi
|
|
}
|
|
|
|
function showcommands() {
|
|
local T=$(gettop)
|
|
if [[ -z "$TARGET_PRODUCT" ]]; then
|
|
>&2 echo "TARGET_PRODUCT not set. Run lunch."
|
|
return
|
|
fi
|
|
case $(uname -s) in
|
|
Darwin)
|
|
PREBUILT_NAME=darwin-x86
|
|
;;
|
|
Linux)
|
|
PREBUILT_NAME=linux-x86
|
|
;;
|
|
*)
|
|
>&2 echo Unknown host $(uname -s)
|
|
return
|
|
;;
|
|
esac
|
|
OUT_DIR="$(get_abs_build_var OUT_DIR)"
|
|
if [[ "$1" == "--regenerate" ]]; then
|
|
shift 1
|
|
NINJA_ARGS="-t commands $@" m
|
|
else
|
|
(cd $T && prebuilts/build-tools/$PREBUILT_NAME/bin/ninja \
|
|
-f $OUT_DIR/combined-${TARGET_PRODUCT}.ninja \
|
|
-t commands "$@")
|
|
fi
|
|
}
|
|
|
|
function avbtool() {
|
|
if [[ ! -f "$ANDROID_SOONG_HOST_OUT"/bin/avbtool ]]; then
|
|
m avbtool
|
|
fi
|
|
"$ANDROID_SOONG_HOST_OUT"/bin/avbtool $@
|
|
}
|
|
|
|
function overrideflags() {
|
|
local T="$(gettop)"
|
|
(\cd "${T}" && build/make/tools/overrideflags.sh "$@")
|
|
}
|
|
|
|
function aninja() {
|
|
local T="$(gettop)"
|
|
(\cd "${T}" && prebuilts/build-tools/linux-x86/bin/ninja -f out/combined-${TARGET_PRODUCT}.ninja "$@")
|
|
}
|
|
|
|
validate_current_shell
|
|
set_global_paths
|
|
source_vendorsetup
|
|
addcompletions
|
|
|