| function __print_cm_functions_help() { |
| cat <<EOF |
| Additional LineageOS functions: |
| - cout: Changes directory to out. |
| - mmp: Builds all of the modules in the current directory and pushes them to the device. |
| - mmap: Builds all of the modules in the current directory and its dependencies, then pushes the package to the device. |
| - mmmp: Builds all of the modules in the supplied directories and pushes them to the device. |
| - mms: Short circuit builder. Quickly re-build the kernel, rootfs, boot and system images |
| without deep dependencies. Requires the full build to have run before. |
| - cmgerrit: A Git wrapper that fetches/pushes patch from/to LineageOS Gerrit Review. |
| - cmrebase: Rebase a Gerrit change and push it again. |
| - cmremote: Add git remote for LineageOS Gerrit Review. |
| - aospremote: Add git remote for matching AOSP repository. |
| - cafremote: Add git remote for matching CodeAurora repository. |
| - mka: Builds using SCHED_BATCH on all processors. |
| - mkap: Builds the module(s) using mka and pushes them to the device. |
| - cmka: Cleans and builds using mka. |
| - repodiff: Diff 2 different branches or tags within the same repo |
| - repolastsync: Prints date and time of last repo sync. |
| - reposync: Parallel repo sync using ionice and SCHED_BATCH. |
| - repopick: Utility to fetch changes from Gerrit. |
| - installboot: Installs a boot.img to the connected device. |
| - installrecovery: Installs a recovery.img to the connected device. |
| EOF |
| } |
| |
| function brunch() |
| { |
| breakfast $* |
| if [ $? -eq 0 ]; then |
| mka bacon |
| else |
| echo "No such item in brunch menu. Try 'breakfast'" |
| return 1 |
| fi |
| return $? |
| } |
| |
| function breakfast() |
| { |
| target=$1 |
| local variant=$2 |
| CM_DEVICES_ONLY="true" |
| unset LUNCH_MENU_CHOICES |
| add_lunch_combo full-eng |
| for f in `/bin/ls vendor/cm/vendorsetup.sh 2> /dev/null` |
| do |
| echo "including $f" |
| . $f |
| done |
| unset f |
| |
| if [ $# -eq 0 ]; then |
| # No arguments, so let's have the full menu |
| lunch |
| else |
| echo "z$target" | grep -q "-" |
| if [ $? -eq 0 ]; then |
| # A buildtype was specified, assume a full device name |
| lunch $target |
| else |
| # This is probably just the CM model name |
| if [ -z "$variant" ]; then |
| variant="userdebug" |
| fi |
| lunch cm_$target-$variant |
| fi |
| fi |
| return $? |
| } |
| |
| alias bib=breakfast |
| |
| function eat() |
| { |
| if [ "$OUT" ] ; then |
| MODVERSION=$(get_build_var CM_VERSION) |
| ZIPFILE=lineage-$MODVERSION.zip |
| ZIPPATH=$OUT/$ZIPFILE |
| if [ ! -f $ZIPPATH ] ; then |
| echo "Nothing to eat" |
| return 1 |
| fi |
| adb start-server # Prevent unexpected starting server message from adb get-state in the next line |
| if [ $(adb get-state) != device -a $(adb shell test -e /sbin/recovery 2> /dev/null; echo $?) != 0 ] ; then |
| echo "No device is online. Waiting for one..." |
| echo "Please connect USB and/or enable USB debugging" |
| until [ $(adb get-state) = device -o $(adb shell test -e /sbin/recovery 2> /dev/null; echo $?) = 0 ];do |
| sleep 1 |
| done |
| echo "Device Found.." |
| fi |
| if (adb shell getprop ro.cm.device | grep -q "$CM_BUILD"); |
| then |
| # if adbd isn't root we can't write to /cache/recovery/ |
| adb root |
| sleep 1 |
| adb wait-for-device |
| cat << EOF > /tmp/command |
| --sideload_auto_reboot |
| EOF |
| if adb push /tmp/command /cache/recovery/ ; then |
| echo "Rebooting into recovery for sideload installation" |
| adb reboot recovery |
| adb wait-for-sideload |
| adb sideload $ZIPPATH |
| fi |
| rm /tmp/command |
| else |
| echo "Nothing to eat" |
| return 1 |
| fi |
| return $? |
| else |
| echo "The connected device does not appear to be $CM_BUILD, run away!" |
| fi |
| } |
| |
| function omnom() |
| { |
| brunch $* |
| eat |
| } |
| |
| function cout() |
| { |
| if [ "$OUT" ]; then |
| cd $OUT |
| else |
| echo "Couldn't locate out directory. Try setting OUT." |
| fi |
| } |
| |
| function dddclient() |
| { |
| local OUT_ROOT=$(get_abs_build_var PRODUCT_OUT) |
| local OUT_SYMBOLS=$(get_abs_build_var TARGET_OUT_UNSTRIPPED) |
| local OUT_SO_SYMBOLS=$(get_abs_build_var TARGET_OUT_SHARED_LIBRARIES_UNSTRIPPED) |
| local OUT_VENDOR_SO_SYMBOLS=$(get_abs_build_var TARGET_OUT_VENDOR_SHARED_LIBRARIES_UNSTRIPPED) |
| local OUT_EXE_SYMBOLS=$(get_symbols_directory) |
| local PREBUILTS=$(get_abs_build_var ANDROID_PREBUILTS) |
| local ARCH=$(get_build_var TARGET_ARCH) |
| local GDB |
| case "$ARCH" in |
| arm) GDB=arm-linux-androideabi-gdb;; |
| arm64) GDB=arm-linux-androideabi-gdb; GDB64=aarch64-linux-android-gdb;; |
| mips|mips64) GDB=mips64el-linux-android-gdb;; |
| x86) GDB=x86_64-linux-android-gdb;; |
| x86_64) GDB=x86_64-linux-android-gdb;; |
| *) echo "Unknown arch $ARCH"; return 1;; |
| esac |
| |
| if [ "$OUT_ROOT" -a "$PREBUILTS" ]; then |
| local EXE="$1" |
| if [ "$EXE" ] ; then |
| EXE=$1 |
| if [[ $EXE =~ ^[^/].* ]] ; then |
| EXE="system/bin/"$EXE |
| fi |
| else |
| EXE="app_process" |
| fi |
| |
| local PORT="$2" |
| if [ "$PORT" ] ; then |
| PORT=$2 |
| else |
| PORT=":5039" |
| fi |
| |
| local PID="$3" |
| if [ "$PID" ] ; then |
| if [[ ! "$PID" =~ ^[0-9]+$ ]] ; then |
| PID=`pid $3` |
| if [[ ! "$PID" =~ ^[0-9]+$ ]] ; then |
| # that likely didn't work because of returning multiple processes |
| # try again, filtering by root processes (don't contain colon) |
| PID=`adb shell ps | \grep $3 | \grep -v ":" | awk '{print $2}'` |
| if [[ ! "$PID" =~ ^[0-9]+$ ]] |
| then |
| echo "Couldn't resolve '$3' to single PID" |
| return 1 |
| else |
| echo "" |
| echo "WARNING: multiple processes matching '$3' observed, using root process" |
| echo "" |
| fi |
| fi |
| fi |
| adb forward "tcp$PORT" "tcp$PORT" |
| local USE64BIT="$(is64bit $PID)" |
| adb shell gdbserver$USE64BIT $PORT --attach $PID & |
| sleep 2 |
| else |
| echo "" |
| echo "If you haven't done so already, do this first on the device:" |
| echo " gdbserver $PORT /system/bin/$EXE" |
| echo " or" |
| echo " gdbserver $PORT --attach <PID>" |
| echo "" |
| fi |
| |
| OUT_SO_SYMBOLS=$OUT_SO_SYMBOLS$USE64BIT |
| OUT_VENDOR_SO_SYMBOLS=$OUT_VENDOR_SO_SYMBOLS$USE64BIT |
| |
| echo >|"$OUT_ROOT/gdbclient.cmds" "set solib-absolute-prefix $OUT_SYMBOLS" |
| echo >>"$OUT_ROOT/gdbclient.cmds" "set solib-search-path $OUT_SO_SYMBOLS:$OUT_SO_SYMBOLS/hw:$OUT_SO_SYMBOLS/ssl/engines:$OUT_SO_SYMBOLS/drm:$OUT_SO_SYMBOLS/egl:$OUT_SO_SYMBOLS/soundfx:$OUT_VENDOR_SO_SYMBOLS:$OUT_VENDOR_SO_SYMBOLS/hw:$OUT_VENDOR_SO_SYMBOLS/egl" |
| echo >>"$OUT_ROOT/gdbclient.cmds" "source $ANDROID_BUILD_TOP/development/scripts/gdb/dalvik.gdb" |
| echo >>"$OUT_ROOT/gdbclient.cmds" "target remote $PORT" |
| # Enable special debugging for ART processes. |
| if [[ $EXE =~ (^|/)(app_process|dalvikvm)(|32|64)$ ]]; then |
| echo >> "$OUT_ROOT/gdbclient.cmds" "art-on" |
| fi |
| echo >>"$OUT_ROOT/gdbclient.cmds" "" |
| |
| local WHICH_GDB= |
| # 64-bit exe found |
| if [ "$USE64BIT" != "" ] ; then |
| WHICH_GDB=$ANDROID_TOOLCHAIN/$GDB64 |
| # 32-bit exe / 32-bit platform |
| elif [ "$(get_build_var TARGET_2ND_ARCH)" = "" ]; then |
| WHICH_GDB=$ANDROID_TOOLCHAIN/$GDB |
| # 32-bit exe / 64-bit platform |
| else |
| WHICH_GDB=$ANDROID_TOOLCHAIN_2ND_ARCH/$GDB |
| fi |
| |
| ddd --debugger $WHICH_GDB -x "$OUT_ROOT/gdbclient.cmds" "$OUT_EXE_SYMBOLS/$EXE" |
| else |
| echo "Unable to determine build system output dir." |
| fi |
| } |
| |
| function cmremote() |
| { |
| if ! git rev-parse --git-dir &> /dev/null |
| then |
| echo ".git directory not found. Please run this from the root directory of the Android repository you wish to set up." |
| return 1 |
| fi |
| git remote rm cmremote 2> /dev/null |
| GERRIT_REMOTE=$(git config --get remote.github.projectname) |
| CMUSER=$(git config --get review.review.lineageos.org.username) |
| if [ -z "$CMUSER" ] |
| then |
| git remote add cmremote ssh://review.lineageos.org:29418/$GERRIT_REMOTE |
| else |
| git remote add cmremote ssh://$CMUSER@review.lineageos.org:29418/$GERRIT_REMOTE |
| fi |
| echo "Remote 'cmremote' created" |
| } |
| |
| function aospremote() |
| { |
| if ! git rev-parse --git-dir &> /dev/null |
| then |
| echo ".git directory not found. Please run this from the root directory of the Android repository you wish to set up." |
| return 1 |
| fi |
| git remote rm aosp 2> /dev/null |
| PROJECT=$(pwd -P | sed -e "s#$ANDROID_BUILD_TOP\/##; s#-caf.*##; s#\/default##") |
| if (echo $PROJECT | grep -qv "^device") |
| then |
| PFX="platform/" |
| fi |
| git remote add aosp https://android.googlesource.com/$PFX$PROJECT |
| echo "Remote 'aosp' created" |
| } |
| |
| function cafremote() |
| { |
| if ! git rev-parse --git-dir &> /dev/null |
| then |
| echo ".git directory not found. Please run this from the root directory of the Android repository you wish to set up." |
| return 1 |
| fi |
| git remote rm caf 2> /dev/null |
| PROJECT=$(pwd -P | sed -e "s#$ANDROID_BUILD_TOP\/##; s#-caf.*##; s#\/default##") |
| if (echo $PROJECT | grep -qv "^device") |
| then |
| PFX="platform/" |
| fi |
| git remote add caf git://codeaurora.org/$PFX$PROJECT |
| echo "Remote 'caf' created" |
| } |
| |
| function installboot() |
| { |
| if [ ! -e "$OUT/recovery/root/etc/recovery.fstab" ]; |
| then |
| echo "No recovery.fstab found. Build recovery first." |
| return 1 |
| fi |
| if [ ! -e "$OUT/boot.img" ]; |
| then |
| echo "No boot.img found. Run make bootimage first." |
| return 1 |
| fi |
| PARTITION=`grep "^\/boot" $OUT/recovery/root/etc/recovery.fstab | awk {'print $3'}` |
| if [ -z "$PARTITION" ]; |
| then |
| # Try for RECOVERY_FSTAB_VERSION = 2 |
| PARTITION=`grep "[[:space:]]\/boot[[:space:]]" $OUT/recovery/root/etc/recovery.fstab | awk {'print $1'}` |
| PARTITION_TYPE=`grep "[[:space:]]\/boot[[:space:]]" $OUT/recovery/root/etc/recovery.fstab | awk {'print $3'}` |
| if [ -z "$PARTITION" ]; |
| then |
| echo "Unable to determine boot partition." |
| return 1 |
| fi |
| fi |
| adb start-server |
| adb wait-for-online |
| adb root |
| sleep 1 |
| adb wait-for-online shell mount /system 2>&1 > /dev/null |
| adb wait-for-online remount |
| if (adb shell getprop ro.cm.device | grep -q "$CM_BUILD"); |
| then |
| adb push $OUT/boot.img /cache/ |
| for i in $OUT/system/lib/modules/*; |
| do |
| adb push $i /system/lib/modules/ |
| done |
| adb shell dd if=/cache/boot.img of=$PARTITION |
| adb shell chmod 644 /system/lib/modules/* |
| echo "Installation complete." |
| else |
| echo "The connected device does not appear to be $CM_BUILD, run away!" |
| fi |
| } |
| |
| function installrecovery() |
| { |
| if [ ! -e "$OUT/recovery/root/etc/recovery.fstab" ]; |
| then |
| echo "No recovery.fstab found. Build recovery first." |
| return 1 |
| fi |
| if [ ! -e "$OUT/recovery.img" ]; |
| then |
| echo "No recovery.img found. Run make recoveryimage first." |
| return 1 |
| fi |
| PARTITION=`grep "^\/recovery" $OUT/recovery/root/etc/recovery.fstab | awk {'print $3'}` |
| if [ -z "$PARTITION" ]; |
| then |
| # Try for RECOVERY_FSTAB_VERSION = 2 |
| PARTITION=`grep "[[:space:]]\/recovery[[:space:]]" $OUT/recovery/root/etc/recovery.fstab | awk {'print $1'}` |
| PARTITION_TYPE=`grep "[[:space:]]\/recovery[[:space:]]" $OUT/recovery/root/etc/recovery.fstab | awk {'print $3'}` |
| if [ -z "$PARTITION" ]; |
| then |
| echo "Unable to determine recovery partition." |
| return 1 |
| fi |
| fi |
| adb start-server |
| adb wait-for-online |
| adb root |
| sleep 1 |
| adb wait-for-online shell mount /system 2>&1 >> /dev/null |
| adb wait-for-online remount |
| if (adb shell getprop ro.cm.device | grep -q "$CM_BUILD"); |
| then |
| adb push $OUT/recovery.img /cache/ |
| adb shell dd if=/cache/recovery.img of=$PARTITION |
| echo "Installation complete." |
| else |
| echo "The connected device does not appear to be $CM_BUILD, run away!" |
| fi |
| } |
| |
| function makerecipe() { |
| if [ -z "$1" ] |
| then |
| echo "No branch name provided." |
| return 1 |
| fi |
| cd android |
| sed -i s/'default revision=.*'/'default revision="refs\/heads\/'$1'"'/ default.xml |
| git commit -a -m "$1" |
| cd .. |
| |
| repo forall -c ' |
| |
| if [ "$REPO_REMOTE" = "github" ] |
| then |
| pwd |
| cmremote |
| git push cmremote HEAD:refs/heads/'$1' |
| fi |
| ' |
| } |
| |
| function cmgerrit() { |
| if [ "$(__detect_shell)" = "zsh" ]; then |
| # zsh does not define FUNCNAME, derive from funcstack |
| local FUNCNAME=$funcstack[1] |
| fi |
| |
| if [ $# -eq 0 ]; then |
| $FUNCNAME help |
| return 1 |
| fi |
| local user=`git config --get review.review.lineageos.org.username` |
| local review=`git config --get remote.github.review` |
| local project=`git config --get remote.github.projectname` |
| local command=$1 |
| shift |
| case $command in |
| help) |
| if [ $# -eq 0 ]; then |
| cat <<EOF |
| Usage: |
| $FUNCNAME COMMAND [OPTIONS] [CHANGE-ID[/PATCH-SET]][{@|^|~|:}ARG] [-- ARGS] |
| |
| Commands: |
| fetch Just fetch the change as FETCH_HEAD |
| help Show this help, or for a specific command |
| pull Pull a change into current branch |
| push Push HEAD or a local branch to Gerrit for a specific branch |
| |
| Any other Git commands that support refname would work as: |
| git fetch URL CHANGE && git COMMAND OPTIONS FETCH_HEAD{@|^|~|:}ARG -- ARGS |
| |
| See '$FUNCNAME help COMMAND' for more information on a specific command. |
| |
| Example: |
| $FUNCNAME checkout -b topic 1234/5 |
| works as: |
| git fetch http://DOMAIN/p/PROJECT refs/changes/34/1234/5 \\ |
| && git checkout -b topic FETCH_HEAD |
| will checkout a new branch 'topic' base on patch-set 5 of change 1234. |
| Patch-set 1 will be fetched if omitted. |
| EOF |
| return |
| fi |
| case $1 in |
| __cmg_*) echo "For internal use only." ;; |
| changes|for) |
| if [ "$FUNCNAME" = "cmgerrit" ]; then |
| echo "'$FUNCNAME $1' is deprecated." |
| fi |
| ;; |
| help) $FUNCNAME help ;; |
| fetch|pull) cat <<EOF |
| usage: $FUNCNAME $1 [OPTIONS] CHANGE-ID[/PATCH-SET] |
| |
| works as: |
| git $1 OPTIONS http://DOMAIN/p/PROJECT \\ |
| refs/changes/HASH/CHANGE-ID/{PATCH-SET|1} |
| |
| Example: |
| $FUNCNAME $1 1234 |
| will $1 patch-set 1 of change 1234 |
| EOF |
| ;; |
| push) cat <<EOF |
| usage: $FUNCNAME push [OPTIONS] [LOCAL_BRANCH:]REMOTE_BRANCH |
| |
| works as: |
| git push OPTIONS ssh://USER@DOMAIN:29418/PROJECT \\ |
| {LOCAL_BRANCH|HEAD}:refs/for/REMOTE_BRANCH |
| |
| Example: |
| $FUNCNAME push fix6789:gingerbread |
| will push local branch 'fix6789' to Gerrit for branch 'gingerbread'. |
| HEAD will be pushed from local if omitted. |
| EOF |
| ;; |
| *) |
| $FUNCNAME __cmg_err_not_supported $1 && return |
| cat <<EOF |
| usage: $FUNCNAME $1 [OPTIONS] CHANGE-ID[/PATCH-SET][{@|^|~|:}ARG] [-- ARGS] |
| |
| works as: |
| git fetch http://DOMAIN/p/PROJECT \\ |
| refs/changes/HASH/CHANGE-ID/{PATCH-SET|1} \\ |
| && git $1 OPTIONS FETCH_HEAD{@|^|~|:}ARG -- ARGS |
| EOF |
| ;; |
| esac |
| ;; |
| __cmg_get_ref) |
| $FUNCNAME __cmg_err_no_arg $command $# && return 1 |
| local change_id patchset_id hash |
| case $1 in |
| */*) |
| change_id=${1%%/*} |
| patchset_id=${1#*/} |
| ;; |
| *) |
| change_id=$1 |
| patchset_id=1 |
| ;; |
| esac |
| hash=$(($change_id % 100)) |
| case $hash in |
| [0-9]) hash="0$hash" ;; |
| esac |
| echo "refs/changes/$hash/$change_id/$patchset_id" |
| ;; |
| fetch|pull) |
| $FUNCNAME __cmg_err_no_arg $command $# help && return 1 |
| $FUNCNAME __cmg_err_not_repo && return 1 |
| local change=$1 |
| shift |
| git $command $@ http://$review/p/$project \ |
| $($FUNCNAME __cmg_get_ref $change) || return 1 |
| ;; |
| push) |
| $FUNCNAME __cmg_err_no_arg $command $# help && return 1 |
| $FUNCNAME __cmg_err_not_repo && return 1 |
| if [ -z "$user" ]; then |
| echo >&2 "Gerrit username not found." |
| return 1 |
| fi |
| local local_branch remote_branch |
| case $1 in |
| *:*) |
| local_branch=${1%:*} |
| remote_branch=${1##*:} |
| ;; |
| *) |
| local_branch=HEAD |
| remote_branch=$1 |
| ;; |
| esac |
| shift |
| git push $@ ssh://$user@$review:29418/$project \ |
| $local_branch:refs/for/$remote_branch || return 1 |
| ;; |
| changes|for) |
| if [ "$FUNCNAME" = "cmgerrit" ]; then |
| echo >&2 "'$FUNCNAME $command' is deprecated." |
| fi |
| ;; |
| __cmg_err_no_arg) |
| if [ $# -lt 2 ]; then |
| echo >&2 "'$FUNCNAME $command' missing argument." |
| elif [ $2 -eq 0 ]; then |
| if [ -n "$3" ]; then |
| $FUNCNAME help $1 |
| else |
| echo >&2 "'$FUNCNAME $1' missing argument." |
| fi |
| else |
| return 1 |
| fi |
| ;; |
| __cmg_err_not_repo) |
| if [ -z "$review" -o -z "$project" ]; then |
| echo >&2 "Not currently in any reviewable repository." |
| else |
| return 1 |
| fi |
| ;; |
| __cmg_err_not_supported) |
| $FUNCNAME __cmg_err_no_arg $command $# && return |
| case $1 in |
| #TODO: filter more git commands that don't use refname |
| init|add|rm|mv|status|clone|remote|bisect|config|stash) |
| echo >&2 "'$FUNCNAME $1' is not supported." |
| ;; |
| *) return 1 ;; |
| esac |
| ;; |
| #TODO: other special cases? |
| *) |
| $FUNCNAME __cmg_err_not_supported $command && return 1 |
| $FUNCNAME __cmg_err_no_arg $command $# help && return 1 |
| $FUNCNAME __cmg_err_not_repo && return 1 |
| local args="$@" |
| local change pre_args refs_arg post_args |
| case "$args" in |
| *--\ *) |
| pre_args=${args%%-- *} |
| post_args="-- ${args#*-- }" |
| ;; |
| *) pre_args="$args" ;; |
| esac |
| args=($pre_args) |
| pre_args= |
| if [ ${#args[@]} -gt 0 ]; then |
| change=${args[${#args[@]}-1]} |
| fi |
| if [ ${#args[@]} -gt 1 ]; then |
| pre_args=${args[0]} |
| for ((i=1; i<${#args[@]}-1; i++)); do |
| pre_args="$pre_args ${args[$i]}" |
| done |
| fi |
| while ((1)); do |
| case $change in |
| ""|--) |
| $FUNCNAME help $command |
| return 1 |
| ;; |
| *@*) |
| if [ -z "$refs_arg" ]; then |
| refs_arg="@${change#*@}" |
| change=${change%%@*} |
| fi |
| ;; |
| *~*) |
| if [ -z "$refs_arg" ]; then |
| refs_arg="~${change#*~}" |
| change=${change%%~*} |
| fi |
| ;; |
| *^*) |
| if [ -z "$refs_arg" ]; then |
| refs_arg="^${change#*^}" |
| change=${change%%^*} |
| fi |
| ;; |
| *:*) |
| if [ -z "$refs_arg" ]; then |
| refs_arg=":${change#*:}" |
| change=${change%%:*} |
| fi |
| ;; |
| *) break ;; |
| esac |
| done |
| $FUNCNAME fetch $change \ |
| && git $command $pre_args FETCH_HEAD$refs_arg $post_args \ |
| || return 1 |
| ;; |
| esac |
| } |
| |
| function cmrebase() { |
| local repo=$1 |
| local refs=$2 |
| local pwd="$(pwd)" |
| local dir="$(gettop)/$repo" |
| |
| if [ -z $repo ] || [ -z $refs ]; then |
| echo "LineageOS Gerrit Rebase Usage: " |
| echo " cmrebase <path to project> <patch IDs on Gerrit>" |
| echo " The patch IDs appear on the Gerrit commands that are offered." |
| echo " They consist on a series of numbers and slashes, after the text" |
| echo " refs/changes. For example, the ID in the following command is 26/8126/2" |
| echo "" |
| echo " git[...]ges_apps_Camera refs/changes/26/8126/2 && git cherry-pick FETCH_HEAD" |
| echo "" |
| return |
| fi |
| |
| if [ ! -d $dir ]; then |
| echo "Directory $dir doesn't exist in tree." |
| return |
| fi |
| cd $dir |
| repo=$(cat .git/config | grep git://github.com | awk '{ print $NF }' | sed s#git://github.com/##g) |
| echo "Starting branch..." |
| repo start tmprebase . |
| echo "Bringing it up to date..." |
| repo sync . |
| echo "Fetching change..." |
| git fetch "http://review.lineageos.org/p/$repo" "refs/changes/$refs" && git cherry-pick FETCH_HEAD |
| if [ "$?" != "0" ]; then |
| echo "Error cherry-picking. Not uploading!" |
| return |
| fi |
| echo "Uploading..." |
| repo upload . |
| echo "Cleaning up..." |
| repo abandon tmprebase . |
| cd $pwd |
| } |
| |
| function mka() { |
| local T=$(gettop) |
| if [ "$T" ]; then |
| case `uname -s` in |
| Darwin) |
| make -C $T -j `sysctl hw.ncpu|cut -d" " -f2` "$@" |
| ;; |
| *) |
| mk_timer schedtool -B -n 10 -e ionice -n 7 make -C $T -j$(cat /proc/cpuinfo | grep "^processor" | wc -l) "$@" |
| ;; |
| esac |
| |
| else |
| echo "Couldn't locate the top of the tree. Try setting TOP." |
| fi |
| } |
| |
| function cmka() { |
| if [ ! -z "$1" ]; then |
| for i in "$@"; do |
| case $i in |
| bacon|otapackage|systemimage) |
| mka installclean |
| mka $i |
| ;; |
| *) |
| mka clean-$i |
| mka $i |
| ;; |
| esac |
| done |
| else |
| mka clean |
| mka |
| fi |
| } |
| |
| function mms() { |
| local T=$(gettop) |
| if [ -z "$T" ] |
| then |
| echo "Couldn't locate the top of the tree. Try setting TOP." |
| return 1 |
| fi |
| |
| case `uname -s` in |
| Darwin) |
| local NUM_CPUS=$(sysctl hw.ncpu|cut -d" " -f2) |
| ONE_SHOT_MAKEFILE="__none__" \ |
| make -C $T -j $NUM_CPUS "$@" |
| ;; |
| *) |
| local NUM_CPUS=$(cat /proc/cpuinfo | grep "^processor" | wc -l) |
| ONE_SHOT_MAKEFILE="__none__" \ |
| mk_timer schedtool -B -n 1 -e ionice -n 1 \ |
| make -C $T -j $NUM_CPUS "$@" |
| ;; |
| esac |
| } |
| |
| function repolastsync() { |
| RLSPATH="$ANDROID_BUILD_TOP/.repo/.repo_fetchtimes.json" |
| RLSLOCAL=$(date -d "$(stat -c %z $RLSPATH)" +"%e %b %Y, %T %Z") |
| RLSUTC=$(date -d "$(stat -c %z $RLSPATH)" -u +"%e %b %Y, %T %Z") |
| echo "Last repo sync: $RLSLOCAL / $RLSUTC" |
| } |
| |
| function reposync() { |
| case `uname -s` in |
| Darwin) |
| repo sync -j 4 "$@" |
| ;; |
| *) |
| schedtool -B -n 1 -e ionice -n 1 `which repo` sync -j 4 "$@" |
| ;; |
| esac |
| } |
| |
| function repodiff() { |
| if [ -z "$*" ]; then |
| echo "Usage: repodiff <ref-from> [[ref-to] [--numstat]]" |
| return |
| fi |
| diffopts=$* repo forall -c \ |
| 'echo "$REPO_PATH ($REPO_REMOTE)"; git diff ${diffopts} 2>/dev/null ;' |
| } |
| |
| # Return success if adb is up and not in recovery |
| function _adb_connected { |
| { |
| if [[ "$(adb get-state)" == device && |
| "$(adb shell test -e /sbin/recovery; echo $?)" != 0 ]] |
| then |
| return 0 |
| fi |
| } 2>/dev/null |
| |
| return 1 |
| }; |
| |
| # Credit for color strip sed: http://goo.gl/BoIcm |
| function dopush() |
| { |
| local func=$1 |
| shift |
| |
| adb start-server # Prevent unexpected starting server message from adb get-state in the next line |
| if ! _adb_connected; then |
| echo "No device is online. Waiting for one..." |
| echo "Please connect USB and/or enable USB debugging" |
| until _adb_connected; do |
| sleep 1 |
| done |
| echo "Device Found." |
| fi |
| |
| if (adb shell getprop ro.cm.device | grep -q "$CM_BUILD") || [ "$FORCE_PUSH" = "true" ]; |
| then |
| # retrieve IP and PORT info if we're using a TCP connection |
| TCPIPPORT=$(adb devices \ |
| | egrep '^(([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9\-]*[a-zA-Z0-9])\.)*([A-Za-z0-9]|[A-Za-z0-9][A-Za-z0-9\-]*[A-Za-z0-9]):[0-9]+[^0-9]+' \ |
| | head -1 | awk '{print $1}') |
| adb root &> /dev/null |
| sleep 0.3 |
| if [ -n "$TCPIPPORT" ] |
| then |
| # adb root just killed our connection |
| # so reconnect... |
| adb connect "$TCPIPPORT" |
| fi |
| adb wait-for-device &> /dev/null |
| sleep 0.3 |
| adb remount &> /dev/null |
| |
| mkdir -p $OUT |
| ($func $*|tee $OUT/.log;return ${PIPESTATUS[0]}) |
| ret=$?; |
| if [ $ret -ne 0 ]; then |
| rm -f $OUT/.log;return $ret |
| fi |
| |
| # Install: <file> |
| if [ `uname` = "Linux" ]; then |
| LOC="$(cat $OUT/.log | sed -r -e 's/\x1B\[([0-9]{1,2}(;[0-9]{1,2})?)?[m|K]//g' -e 's/^\[ {0,2}[0-9]{1,3}% [0-9]{1,6}\/[0-9]{1,6}\] +//' \ |
| | grep '^Install: ' | cut -d ':' -f 2)" |
| else |
| LOC="$(cat $OUT/.log | sed -E "s/"$'\E'"\[([0-9]{1,3}((;[0-9]{1,3})*)?)?[m|K]//g" -E "s/^\[ {0,2}[0-9]{1,3}% [0-9]{1,6}\/[0-9]{1,6}\] +//" \ |
| | grep '^Install: ' | cut -d ':' -f 2)" |
| fi |
| |
| # Copy: <file> |
| if [ `uname` = "Linux" ]; then |
| LOC="$LOC $(cat $OUT/.log | sed -r -e 's/\x1B\[([0-9]{1,2}(;[0-9]{1,2})?)?[m|K]//g' -e 's/^\[ {0,2}[0-9]{1,3}% [0-9]{1,6}\/[0-9]{1,6}\] +//' \ |
| | grep '^Copy: ' | cut -d ':' -f 2)" |
| else |
| LOC="$LOC $(cat $OUT/.log | sed -E "s/"$'\E'"\[([0-9]{1,3}((;[0-9]{1,3})*)?)?[m|K]//g" -E 's/^\[ {0,2}[0-9]{1,3}% [0-9]{1,6}\/[0-9]{1,6}\] +//' \ |
| | grep '^Copy: ' | cut -d ':' -f 2)" |
| fi |
| |
| # If any files are going to /data, push an octal file permissions reader to device |
| if [ -n "$(echo $LOC | egrep '(^|\s)/data')" ]; then |
| CHKPERM="/data/local/tmp/chkfileperm.sh" |
| ( |
| cat <<'EOF' |
| #!/system/xbin/sh |
| FILE=$@ |
| if [ -e $FILE ]; then |
| ls -l $FILE | awk '{k=0;for(i=0;i<=8;i++)k+=((substr($1,i+2,1)~/[rwx]/)*2^(8-i));if(k)printf("%0o ",k);print}' | cut -d ' ' -f1 |
| fi |
| EOF |
| ) > $OUT/.chkfileperm.sh |
| echo "Pushing file permissions checker to device" |
| adb push $OUT/.chkfileperm.sh $CHKPERM |
| adb shell chmod 755 $CHKPERM |
| rm -f $OUT/.chkfileperm.sh |
| fi |
| |
| stop_n_start=false |
| for FILE in $(echo $LOC | tr " " "\n"); do |
| # Make sure file is in $OUT/system or $OUT/data |
| case $FILE in |
| $OUT/system/*|$OUT/data/*) |
| # Get target file name (i.e. /system/bin/adb) |
| TARGET=$(echo $FILE | sed "s#$OUT##") |
| ;; |
| *) continue ;; |
| esac |
| |
| case $TARGET in |
| /data/*) |
| # fs_config only sets permissions and se labels for files pushed to /system |
| if [ -n "$CHKPERM" ]; then |
| OLDPERM=$(adb shell $CHKPERM $TARGET) |
| OLDPERM=$(echo $OLDPERM | tr -d '\r' | tr -d '\n') |
| OLDOWN=$(adb shell ls -al $TARGET | awk '{print $2}') |
| OLDGRP=$(adb shell ls -al $TARGET | awk '{print $3}') |
| fi |
| echo "Pushing: $TARGET" |
| adb push $FILE $TARGET |
| if [ -n "$OLDPERM" ]; then |
| echo "Setting file permissions: $OLDPERM, $OLDOWN":"$OLDGRP" |
| adb shell chown "$OLDOWN":"$OLDGRP" $TARGET |
| adb shell chmod "$OLDPERM" $TARGET |
| else |
| echo "$TARGET did not exist previously, you should set file permissions manually" |
| fi |
| adb shell restorecon "$TARGET" |
| ;; |
| /system/priv-app/SystemUI/SystemUI.apk|/system/framework/*) |
| # Only need to stop services once |
| if ! $stop_n_start; then |
| adb shell stop |
| stop_n_start=true |
| fi |
| echo "Pushing: $TARGET" |
| adb push $FILE $TARGET |
| ;; |
| *) |
| echo "Pushing: $TARGET" |
| adb push $FILE $TARGET |
| ;; |
| esac |
| done |
| if [ -n "$CHKPERM" ]; then |
| adb shell rm $CHKPERM |
| fi |
| if $stop_n_start; then |
| adb shell start |
| fi |
| rm -f $OUT/.log |
| return 0 |
| else |
| echo "The connected device does not appear to be $CM_BUILD, run away!" |
| fi |
| } |
| |
| alias mmp='dopush mm' |
| alias mmmp='dopush mmm' |
| alias mmap='dopush mma' |
| alias mmmap='dopush mmma' |
| alias mkap='dopush mka' |
| alias cmkap='dopush cmka' |
| |
| function repopick() { |
| T=$(gettop) |
| $T/vendor/cm/build/tools/repopick.py $@ |
| } |
| |
| function fixup_common_out_dir() { |
| common_out_dir=$(get_build_var OUT_DIR)/target/common |
| target_device=$(get_build_var TARGET_DEVICE) |
| if [ ! -z $CM_FIXUP_COMMON_OUT ]; then |
| if [ -d ${common_out_dir} ] && [ ! -L ${common_out_dir} ]; then |
| mv ${common_out_dir} ${common_out_dir}-${target_device} |
| ln -s ${common_out_dir}-${target_device} ${common_out_dir} |
| else |
| [ -L ${common_out_dir} ] && rm ${common_out_dir} |
| mkdir -p ${common_out_dir}-${target_device} |
| ln -s ${common_out_dir}-${target_device} ${common_out_dir} |
| fi |
| else |
| [ -L ${common_out_dir} ] && rm ${common_out_dir} |
| mkdir -p ${common_out_dir} |
| fi |
| } |
| |
| # Enable SD-LLVM if available |
| if [ -d $(gettop)/prebuilts/snapdragon-llvm/toolchains ]; then |
| case `uname -s` in |
| Darwin) |
| # Darwin is not supported yet |
| ;; |
| *) |
| export SDCLANG=true |
| export SDCLANG_PATH=$(gettop)/prebuilts/snapdragon-llvm/toolchains/llvm-Snapdragon_LLVM_for_Android_3.8/prebuilt/linux-x86_64/bin |
| export SDCLANG_LTO_DEFS=$(gettop)/device/qcom/common/sdllvm-lto-defs.mk |
| ;; |
| esac |
| fi |
| |
| # Android specific JACK args |
| if [ -n "$JACK_SERVER_VM_ARGUMENTS" ] && [ -z "$ANDROID_JACK_VM_ARGS" ]; then |
| export ANDROID_JACK_VM_ARGS=$JACK_SERVER_VM_ARGUMENTS |
| fi |