rom

#!/usr/bin/env bash
#
# ROM compilation script
#
# Copyright (C) 2016-2017 Nathan Chancellor
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>


###############
#             #
#  FUNCTIONS  #
#             #
###############

# SOURCE OUR UNIVERSAL FUNCTIONS SCRIPT AND MAC CHECK
source common

# CHECKS IF MKA EXISTS
function make_command() {
    if [[ $(command -v mka) ]]; then
        mka $@
    else
        make ${JOBS_FLAG} $@
    fi
}


################
#              #
#  PARAMETERS  #
#              #
################

PARAMS="$@"
while [[ $# -ge 1 ]]; do
    case "${1}" in
        # REQUIRED OPTIONS
        # DEVICE TO BUILD
        "-d"|"--device")
            shift && enforce_value $@

            DEVICE=${1} ;;

        # ROM TO BUILD
        "-r"|"--rom")
            shift && enforce_value $@

            ROM=${1} ;;

        # STANDARD OPTIONS
        # SYNC TREE BEFORE BUILDING
        "-s"|"--sync")
            SYNC=true ;;

        # CUSTOM CLEAN TARGET
        "-c"|"--clean")
            export CLEAN_TYPE=${1} ;;

        # CUSTOM MAKE TARGET
        "-m"|"--make")
            shift && enforce_value $@

            export MAKE_TYPE=${1} ;;

        # USER, USERDEBUG, and ENG
        "-v"|"--version")
            shift && enforce_value $@

            export VARIANT=${1} ;;

        # REPOPICK SEQUENCE
        "-rp"|"--repopick")
            export REPOPICK=true ;;

        # SPECIAL OPTIONS
        # KREXUS, DU, VANILLA
        "-t"|"--type")
            shift && enforce_value $@

            export BUILD_TAG=${1}
            export DU_BUILD_TYPE=${1} ;;

        # DU
        "-ng"|"--no-gapps")
            export HAS_GAPPS=false ;;

        # VANILLA
        "-pix"|"--pixel")
            export PIXEL=true ;;

        "-pub"|"--public")
            export PUBLIC=true ;;

        *)
            report_error "Invalid parameter detected!" ;;
    esac

    shift
done

# PARAMETER VERIFICATION
# IF ROM WASN'T SPECIFIED, IT'S A BUILD FOR ME
if [[ -z ${ROM} ]]; then
    ROM=du-aosp
    DEVICE=angler
fi

[[ -z ${DEVICE} ]] && report_error "The device to build is a required parameter!"

if [[ -z ${VARIANT} ]]; then
    case ${ROM} in
        "krexus"|"pn")
            VARIANT=user ;;
        *)
            VARIANT=userdebug ;;
    esac
fi

###############
#             #
#  VARIABLES  #
#             #
###############

# OUT_FOLDER: Directory that holds the compiled ROM files
# SOURCE_FOLDER: Directory that holds the ROM source
# ZIP_MOVE: Directory to hold completed ROM zips
ZIP_MOVE_PARENT=${WEB_FOLDER}/me/roms

# Otherwise, define them for our various ROMs
case "${ROM}" in
    "aosp")
        SOURCE_FOLDER=${ROM_FOLDER}/aosp
        ZIP_MOVE=${ZIP_MOVE_PARENT}/aosp/${DEVICE} ;;
    "du-aosp")
        SOURCE_FOLDER=${ROM_FOLDER}/du-aosp
        ZIP_MOVE=${ZIP_MOVE_PARENT}/../du/${DEVICE} ;;
    "du-caf")
        SOURCE_FOLDER=${ROM_FOLDER}/du-caf
        ZIP_MOVE=${ZIP_MOVE_PARENT}/../du/${DEVICE} ;;
    "du-personal")
        SOURCE_FOLDER=${ROM_FOLDER}/du
        ZIP_MOVE=${ZIP_MOVE_PARENT}/../du/personal ;;
    "krexus")
        SOURCE_FOLDER=${ROM_FOLDER}/krexus
        ZIP_MOVE=${ZIP_MOVE_PARENT}/krexus/${DEVICE} ;;
    "lineageos")
        SOURCE_FOLDER=${ROM_FOLDER}/los
        ZIP_MOVE=${ZIP_MOVE_PARENT}/los/${DEVICE} ;;
    "lineageoms")
        SOURCE_FOLDER=${ROM_FOLDER}/loms
        ZIP_MOVE=${ZIP_MOVE_PARENT}/loms/${DEVICE} ;;
    "pn")
        SOURCE_FOLDER=${ROM_FOLDER}/pn
        ZIP_MOVE=${ZIP_MOVE_PARENT}/pn/${DEVICE} ;;
    "vanilla")
        SOURCE_FOLDER=${ROM_FOLDER}/vanilla
        ZIP_MOVE=${ZIP_MOVE_PARENT}/vanilla/${DEVICE} ;;
    *)
        report_error "Unknown ROM "${1}" passed!" ;;
esac

OUT_FOLDER=${SOURCE_FOLDER}/out/target/product/${DEVICE}

# LOG NAME
LOG_NAME=${LOG_FOLDER}/compilation/roms/${ROM}-${DEVICE}-$(date +"%Y%m%d-%H%M").log

###########################
# MOVE INTO SOURCE FOLDER #
# AND START TRACKING TIME #
###########################

START=$(date +%s)
clear && cd ${SOURCE_FOLDER}


#############
# REPO SYNC #
#############

REPO_SYNC="repo sync"
FLAGS="${JOBS_FLAG} --force-sync -c --no-clone-bundle --no-tags --optimized-fetch --prune"

# IF THE SYNC IS REQUESTED, DO SO
if [[ ${SYNC} = true ]]; then
    header "SYNCING LATEST SOURCES"; echo

    ${REPO_SYNC} ${FLAGS}

    if [[ ${ROM} = "du-personal" ]]; then
        source ${SCRIPTS_FOLDER}/du_merge
    fi
fi


###########################
# SETUP BUILD ENVIRONMENT #
###########################

header "SETTING UP BUILD ENVIRONMENT"

# CHECK AND SEE IF WE ARE ON ARCH
# IF SO, ACTIVARE A VIRTUAL ENVIRONMENT FOR PROPER PYTHON SUPPORT
if [[ -f /etc/arch-release ]]; then
    virtualenv2 ${HOME}/venv && source ${HOME}/venv/bin/activate
fi

source build/envsetup.sh


##################
# PREPARE DEVICE #
##################

header "PREPARING $(echo ${DEVICE} | awk '{print toupper($0)}')"

# NOT ALL ROMS USE BREAKFAST
case "${ROM}" in
    "aosp"|"krexus"|"vanilla")
        lunch ${ROM}_${DEVICE}-${VARIANT} ;;
    du*)
        lunch du_${DEVICE}-${VARIANT} ;;
    *)
        breakfast ${DEVICE} ${VARIANT} ;;
esac


############
# REPOPICK #
############

if [[ ${REPOPICK} = true ]]; then
    header "RUNNING REPOPICK"
    # Execute in a subshell otherwise everything is fubared
    (
    while [[ ${YN} != "n" ]]; do
        read -p "Do you have changes to pick? (y/n) " YN
        case ${YN} in
            y|Y)
                read -p "Please enter the change number or topic: " PARAMS
                if [[ -n ${PARAMS//[0-9]/} ]]; then
                    repopick -i --topic ${PARAMS}
                else
                    repopick -i ${PARAMS}
                fi ;;
            n|N)
                break ;;
        esac
    done
    )
fi


############
# CLEAN UP #
############

header "CLEANING UP OUT DIRECTORY"

if [[ -n ${CLEAN_TYPE} ]] && [[ ${CLEAN_TYPE} != "noclean" ]]; then
    make_command ${CLEAN_TYPE}
elif [[ -z ${CLEAN_TYPE} ]]; then
    make_command clobber
fi


##################
# START BUILDING #
##################

header "MAKING FILES"; echo

# MAKE THE REQUESTED ITEM
if [[ -n ${MAKE_TYPE} ]]; then
    make_command ${MAKE_TYPE} | tee -a ${LOG_NAME}

    ################
    # PRINT RESULT #
    ################

    echo; header "BUILD COMPLETED!"
else
    # NOT ALL ROMS USE BACON
    case "${ROM}" in
        "aosp"|"krexus")
            make_command otapackage | tee -a ${LOG_NAME} ;;
        "vanilla")
            make_command vanilla | tee -a ${LOG_NAME} ;;
        *)
            make_command bacon | tee -a ${LOG_NAME} ;;
    esac

    ###################
    # IF ROM COMPILED #
    ###################

    # THERE WILL BE A ZIP IN THE OUT FOLDER IF SUCCESSFUL
    FILES=$(ls ${OUT_FOLDER}/*.zip 2>/dev/null | wc -l)
    if [[ ${FILES} != 0 ]]; then
        # MAKE BUILD RESULT STRING REFLECT SUCCESSFUL COMPILATION
        BUILD_RESULT_STRING="BUILD SUCCESSFUL"
        SUCCESS=true


        ##################
        # ZIP_MOVE LOGIC #
        ##################

        # MAKE ZIP_MOVE IF IT DOESN'T EXIST OR CLEAN IT IF IT DOES
        if [[ ! -d "${ZIP_MOVE}" ]]; then
            mkdir -p "${ZIP_MOVE}"
        else
            rm -rf "${ZIP_MOVE}"/*
        fi


        ####################
        # MOVING ROM FILES #
        ####################

        if [[ ${FILES} = 1 ]]; then
            mv "${OUT_FOLDER}"/*.zip* "${ZIP_MOVE}"
        else
            for FILE in $(ls ${OUT_FOLDER}/*.zip* | grep -v ota); do
                mv "${FILE}" "${ZIP_MOVE}"
            done
        fi


    ###################
    # IF BUILD FAILED #
    ###################

    else
        BUILD_RESULT_STRING="BUILD FAILED"
        SUCCESS=false
    fi

    ################
    # PRINT RESULT #
    ################

    header "${BUILD_RESULT_STRING}!"
fi


# DEACTIVATE VIRTUALENV IF WE ARE ON ARCH
if [[ -f /etc/arch-release ]]; then
    deactivate && rm -rf ${HOME}/venv
fi


######################
# ENDING INFORMATION #
######################

# STOP TRACKING TIME
END=$(date +%s)

# IF THE BUILD WAS SUCCESSFUL, PRINT FILE LOCATION, AND SIZE
if [[ ${SUCCESS} = true ]]; then
    echo ${RED}"FILE LOCATION: $(web_link ${ZIP_MOVE})"
    echo "SIZE: $(du -h ${ZIP_MOVE}/*.zip | awk '{print $1}')"${RST}
fi

# PRINT THE TIME THE SCRIPT FINISHED
# AND HOW LONG IT TOOK REGARDLESS OF SUCCESS
echo ${RED}"TIME: $(date +%D\ %r | awk '{print toupper($0)}')"
echo ${RED}"DURATION: $(format_time ${END} ${START})"${RST}
echo "\a"


##################
# LOG GENERATION #
##################

# DATE: BASH_SOURCE (PARAMETERS)
echo "\n$(date +"%m/%d/%Y %H:%M:%S"): ${BASH_SOURCE} ${PARAMS}" >> ${LOG}

# BUILD <SUCCESSFUL|FAILED> IN # MINUTES AND # SECONDS
if [[ -n ${BUILD_RESULT_STRING} ]]; then
    echo "${BUILD_RESULT_STRING} IN \c" >> ${LOG}
fi
echo "$(format_time ${END} ${START})" >> ${LOG}

# ONLY ADD A LINE ABOUT FILE LOCATION IF SCRIPT COMPLETED SUCCESSFULLY
if [[ ${SUCCESS} = true ]]; then
    # FILE LOCATION: <PATH>
    echo "FILE LOCATION: $(web_link ${ZIP_MOVE})" >> ${LOG}
fi