watchface

#! /bin/bash
VERSION="1.1"

function showVersion {
    echo "watchface v${VERSION}"
}

function showHelp {
    showVersion
    cat << EOF
watchface [option] [command...]
Utility functions for AsteroidOS watchfaces.  By default, uses "Developer Mode"
over ssh, but can also use "ADB Mode" using ADB.

Available options:
-h or --help    print this help screen and quit
-a or --adb     use ADB command to communicate with watch
-b or --boot    reboot watch after deploying multiple watchfaces
-e or --every   select every watchface (deploy only)
-g or --gui     use the GTK+ gui
-p or --port    specify an IP port to use for ssh and scp commands
-r or --remote  specify the remote (watch)  name or address for ssh and scp commands
-q or --qemu    communicate with QEMU emulated watch (same as -r localhost -p 2222 )
-w or --wall WP set the wallpaper for deploy or test to the named file

Available commands:
update          use git to update your local copy of the unoffical-watchfaces repository
version         display the version of this program and exit
deploy WF       push the named watchface to the watch and activate it
deployall       deploy all watchfaces
clone WF NEWWF  clone the named watchface WF to new watchface NEWWF
test WF         test the named watchface on the computer using qmlscene

EOF
}

function runWatchCommand {
    local user="$1"
    local cmd=$2
    case ${user} in
        root)
            if [ "$ADB" = "true" ] ; then
                adb shell "${cmd}"
            else
                ssh -p "${WATCHPORT}" -t root@"${WATCHADDR}" ${cmd}
            fi
            ;;
        ceres)
            if [ "$ADB" = "true" ] ; then
                printf -v cmd %q "${cmd}"
                adb shell "su -l -c ${cmd} ceres"
            else
                ssh -p "${WATCHPORT}" -t ceres@"${WATCHADDR}" ${cmd}
            fi
            ;;
        *)
            echo "Error: unknown watch user ${user}"
            ;;
    esac
}

function setDconf {
    local dconfsetting="$1"
    local filename="$2"
    runWatchCommand "ceres" "dconf write ${dconfsetting} '\"file://${filename}\"'"
}

function pushFiles {
    local user="$1"
    local sourcedir="$2"
    local destdir="$3"
    if [ "$ADB" = "true" ] ; then
        adb push ${sourcedir} "${destdir}"
    else
        scp -P"${WATCHPORT}" -r ${sourcedir} "${user}@${WATCHADDR}:${destdir}"
    fi
}

function pushWatchface {
    pushFiles "root" "${1}"'/usr/share/*' "/usr/share/"
}

function pushWallpaper {
    local source="$1"
    local wallpaper
    wallpaper="$(basename "$1")"
    local destination="/usr/share/asteroid-launcher/wallpapers/full/${wallpaper}"
    pushFiles "root" "${source}" "${destination}"
    setDconf "/desktop/asteroid/background-filename" "${destination}"
}

function restartCeres {
    runWatchCommand "root" "systemctl restart user@1000"
}

function rebootWatch {
    runWatchCommand "ceres" "reboot"
}

function activateWatchface {
    setDconf "/desktop/asteroid/watchface" "/usr/share/asteroid-launcher/watchfaces/${1}.qml"
}

function watchfaceClone {
    local files
    mapfile -t files <<<"$(find . -path './'"$1"'/*' -type f | awk '{ dst=$0 ; gsub(/'"$1"'/,"'"$2"'",dst);  print $0 "|" dst }')"
    for filepair in "${files[@]}" ; do
        IFS="|" read -r -a srcDstPaths <<< "${filepair}"
        #echo "Copying from ${srcDstPaths[0]} to ${srcDstPaths[1]}"
        destdir="${srcDstPaths[1]%/*}"
        extension="${srcDstPaths[1]##*.}"
        mkdir -p "${destdir}"
        cp "${srcDstPaths[0]}" "${srcDstPaths[1]}"
        if [ "${extension}" = "qml" ] ; then
            sed -i "s/$1/$2/g" "${srcDstPaths[1]}"
        fi
    done
}

function sanitizeSourceWatchface {
    # trim trailing / if present
    local face="${1%/*}"
    if [[ ! -d "${face}/usr/share/asteroid-launcher/watchfaces/" ]] ; then
        echo "Error: ${face} does not appear to be a watchface" >&2
        exit 1
    fi
    echo "${face}"
}

function deployface {
    local sourcewatchface
    local activate="$2"
    if ! sourcewatchface=$(sanitizeSourceWatchface "$1") ; then
        exit 1
    fi
    echo "Deploying ${sourcewatchface}"
    pushWatchface "${sourcewatchface}"
    if [ "${activate}" = "true" ] ; then
        activateWatchface "${sourcewatchface}"
        if [ -n "${WALLPAPER}" ] ; then
            pushWallpaper "${WALLPAPER}"
        fi
    fi
}

function testface {
    local sourcewatchface
    if ! sourcewatchface=$(sanitizeSourceWatchface "$1") ; then
        exit 1
    fi
    echo "Testing ${sourcewatchface}"
    if [ -n "${WALLPAPER}" ] ; then
        qmlscene "${sourcewatchface}" "${WALLPAPER}" loader.qml
    else
        qmlscene "${sourcewatchface}" "background.jpg" loader.qml
    fi
}

function cloneface {
    local sourcewatchface
    local destwatchface="$2"
    if ! sourcewatchface=$(sanitizeSourceWatchface "$1") ; then
        exit 1
    fi
    echo "Cloning ${sourcewatchface} into ${destwatchface}"
    if [ -e "${destwatchface}" ] ; then
        echo "Error:  ${destwatchface} already exists, exiting program"
        exit
    fi
    watchfaceClone "${sourcewatchface}" "${destwatchface}"
}

function guiMenu {
    local watchface
    local action
    local default
    if ! action=$(zenity --title="Select action" --list --radiolist \
        --column="selected" --column="action" \
        TRUE deploy \
        FALSE clone \
        FALSE test); then
        exit
    fi
    if [ "${DEFAULTOPTION}" == "ON" ] ; then
        default=TRUE
    else
        default=FALSE
    fi
    case $action in
        deploy)
            declare -a args=('--title="Choose watchfaces"' "--list" "--checklist" '--column="Selected"' '--column="Name"')
            for wf in "${WATCHFACES[@]}" ; do
                args+=("${default}" "${wf}")
            done
            if ! watchface=$(zenity "${args[@]}"); then
                exit
            fi
            ;;
        clone|test)
            if ! watchface=$(zenity --title="Choose a watchface" --list --column="Name" "${WATCHFACES[@]}"); then
                exit
            fi
            ;;
    esac
    # convert | chars to spaces
    watchface=${watchface//|/ }
    if zenity --question --title="Confirming" --text="${action} ${watchface}" ; then
        echo "OK!"
        if [ "${action}" = "clone" ] ; then
            if newface=$(zenity --entry --title="Cloning ${watchface}" \
                --text="Enter name of new watchface:" \
                --entry-text "newface")
            then cloneface "${watchface}" "${newface}"
            else echo "No name entered"
            fi
        elif [ "${action}" = "deploy" ] ; then
            local first=true
            for wf in ${watchface}; do
                deployface "${wf}" "${first}"
                first=false
            done
            restartCeres
            if [ "${REBOOT}" = "true" ] ; then
                rebootWatch
            fi
        else
            testface "${watchface}"
        fi
    else
        echo "Canceled"
    fi
}

function textMenu {
    local args
    local watchface
    local newface
    if ! action=$(${MENUPROGRAM} --title "Select action" --clear --radiolist \
        "Select action" 0 0 3 \
        "deploy" "Deploy watchface to watch" ON \
        "clone" "Clone watchface to new name" OFF \
        "test" "Test watchface on computer" OFF \
        3>&1 1>&2 2>&3); then
        exit
    fi
    case $action in
        deploy)
            declare -a args=("--title" "Watchfaces" "--clear" "--checklist" "Choose watchfaces:" 25 78 15 "--" )
            for wf in "${WATCHFACES[@]}" ; do
                args+=("${wf}" "" "${DEFAULTOPTION}")
            done
            if ! watchface=$(${MENUPROGRAM} "${args[@]}" 3>&1 1>&2 2>&3); then
                exit
            fi
            ;;
        clone|test)
            declare -a args=("--title" "Watchfaces" "--clear" "--menu" "Choose a watchface:" 25 78 15 "--" )
            for wf in "${WATCHFACES[@]}" ; do
                args+=("${wf}" "")
            done
            if ! watchface=$(${MENUPROGRAM} "${args[@]}" 3>&1 1>&2 2>&3); then
                exit
            fi
            ;;
    esac
    if (${MENUPROGRAM} --clear --title "Confirming" --yesno "${action} ${watchface}" 0 0); then
        echo "OK!"
        if [ "${action}" = "clone" ] ; then
            if newface=$(${MENUPROGRAM} \
                --title "Cloning ${watchface}" --clear \
                --inputbox "Enter name of new watchface:" \
                8 50 "newface" \
                3>&1 1>&2 2>&3)
            then
                cloneface "${watchface}" "${newface}"
            else
                echo "No name entered"
            fi
        elif [ "${action}" = "deploy" ] ; then
            local first=true
            for wf in ${watchface}; do
                deployface "${wf}" "${first}"
                first=false
            done
            if [ "${REBOOT}" = "true" ] ; then
                rebootWatch
            fi
        else
            testface "${watchface}"
        fi
    else
        echo "Canceled"
    fi
}

function deployall {
    for wf in "${WATCHFACES[@]}" ; do
        deployface "${wf}" false
    done
}


# These are the defaults for SSH access
WATCHPORT=22
WATCHADDR=192.168.2.15
# These are the defaults for local QEMU target
QEMUPORT=2222
QEMUADDR=localhost
# Assume no ADB unless told otherwise
ADB=false
# Assume no GUI unless told otherwise
GUI=false
# Only show interactive prompt if the user hasn't
# already specified a command on the command line
SKIP_INTERACTIVE_PROMPT=false
# No wallpaper unless asked
WALLPAPER=""
# Default to all watchfaces unselected for deploy
DEFAULTOPTION=OFF
# Default to not deploying all watchfaces
DEPLOY_ALL=false
# Assume Dialog unless unavailable
if hash dialog 2>/dev/null; then
    MENUPROGRAM="dialog"
elif hash whiptail 2>/dev/null; then
    MENUPROGRAM="whiptail --separate-output"
fi

while [[ $# -gt 0 ]] ; do
    case $1 in
        -a|--adb)
            ADB=true
            shift
            ;;
        -b|--boot)
            REBOOT=true
            shift
            ;;
        -e|--every)
            DEFAULTOPTION=ON
            shift
            ;;
        -g|--gui)
            GUI=true
            shift
            ;;
        -q|--qemu)
            WATCHPORT=${QEMUPORT}
            WATCHADDR=${QEMUADDR}
            shift
            ;;
        -p|--port)
            WATCHPORT="$2"
            shift
            shift
            ;;
        -r|--remote)
            WATCHADDR="$2"
            shift
            shift
            ;;
        -h|--help)
            showHelp
            exit 1
            ;;
        -w|--wall)
            WALLPAPER="$2"
            shift
            shift
            ;;
        clone)
            cloneface "$2" "$3"
            shift
            shift
            shift
            SKIP_INTERACTIVE_PROMPT=true
            ;;
        deployall)
            DEPLOY_ALL=true
            shift
            SKIP_INTERACTIVE_PROMPT=true
            ;;
        deploy)
            deployface "$2" true
            restartCeres
            shift
            shift
            SKIP_INTERACTIVE_PROMPT=true
            ;;
        test)
            testface "$2"
            shift
            shift
            SKIP_INTERACTIVE_PROMPT=true
            ;;
        update)
            git pull
            shift
            SKIP_INTERACTIVE_PROMPT=true
            ;;
        version)
            showVersion
            shift
            SKIP_INTERACTIVE_PROMPT=true
            ;;
        *)
            echo "Ignoring unknown option $1"
            shift
            ;;
    esac
done

mapfile -t WATCHFACES < <(find . -maxdepth 3 -type d -path "*/usr/share" -printf "%h\n" | sort | awk -F '/' '{print $2}' )
if [ "${SKIP_INTERACTIVE_PROMPT}" != "true" ] ; then
    if [ "${GUI}" = "true" ] ; then
        if hash zenity 2>/dev/null; then
            echo "Error: install 'zenity' to use gui menus."
        else
            guiMenu
        fi
    else
        if [ -z "${MENUPROGRAM}" ] ; then
            echo "Error: install either 'dialog' or 'whiptail' to use text menus."
        else
            textMenu
        fi
    fi
elif [ "${DEPLOY_ALL}" == "true" ] ; then
    deployall
fi