koreader/kodev

#!/bin/bash

CURDIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"

function assert_ret_zero {
    if [ $1 -ne 0 ]; then
        if [ ! -z $2 ]; then
            echo $2
        fi
        exit 1
    fi
}

function setup_env {
    files=`ls -d ./koreader-emulator-*/koreader`
    export EMU_DIR=${files[0]}
}

function kodev-fetch-thirdparty {
    make fetchthirdparty
}

SUPPORTED_TARGETS="
    kindle          For kindle with touch support
    kindle-legacy   For kindle2/3/4/DXG
    kobo
    android
    pocketbook
    ubuntu-touch
    emu             (*default) If no TARGET is given, assume emulator
    win32
"

function kodev-build {
    BUILD_HELP_MSG="
usage: build <OPTIONS> <TARGET>

OPTIONS:

    -v, --verbose   Build in verbose mode.

TARGET:
${SUPPORTED_TARGETS}"

    while [[ $1 == '-'* ]]; do
        PARAM=`echo $1 | awk -F= '{print $1}'`
        VALUE=`echo $1 | awk -F= '{print $2}'`
        case $PARAM in
            -v | --verbose)
                export VERBOSE=1
                ;;
            -h | --help)
                echo "${BUILD_HELP_MSG}"
                exit 0
                ;;
            *)
                echo "ERROR: unknown option \"$PARAM\""
                echo "${BUILD_HELP_MSG}"
                exit 1
                ;;
        esac
        shift 1
    done

    case $1 in
        kindle)
            make TARGET=kindle
            assert_ret_zero $?
            ;;
        kobo)
            make TARGET=kobo
            assert_ret_zero $?
            ;;
        kindle-legacy)
            make TARGET=kindle-legacy
            assert_ret_zero $?
            ;;
        android)
            if [ ! -d ${CURDIR}/base/toolchain/android-toolchain ]; then
                make android-toolchain
                assert_ret_zero $?
            fi
            make TARGET=android
            assert_ret_zero $?
            ;;
        pocketbook)
            if [ ! -d ${CURDIR}/base/toolchain/pocketbook-toolchain ]; then
                make pocketbook-toolchain
                assert_ret_zero $?
            fi
            make TARGET=pocketbook
            assert_ret_zero $?
            ;;
        ubuntu-touch)
            make TARGET=ubuntu-touch
            assert_ret_zero $?
            ;;
        win32)
            make TARGET=win32
            assert_ret_zero $?
            ;;
        *)
            make
            assert_ret_zero $? "Failed to build emulator!"
            setup_env
            ;;
    esac
}

function kodev-clean {
    CLEAN_HELP_MSG="
usage: clean <TARGET>

TARGET:
${SUPPORTED_TARGETS}"

    case $1 in
        -h | --help)
            echo "${CLEAN_HELP_MSG}"
            exit 0
            ;;
        kindle)
            make TARGET=kindle clean
            ;;
        kobo)
            make TARGET=kobo clean
            ;;
        kindle-legacy)
            make TARGET=kindle-legacy clean
            ;;
        android)
            make TARGET=android clean
            rm -f *.apk
            ;;
        pocketbook)
            make TARGET=pocketbook clean
            ;;
        ubuntu-touch)
            make TARGET=ubuntu-touch clean
            ;;
        win32)
            make TARGET=win32 clean
            ;;
        *)
            make clean
            ;;
    esac
}

function kodev-release {
    # SUPPORTED_RELEASE_TARGETS=$(echo ${SUPPORTED_TARGETS} | sed 's/win32//')
    SUPPORTED_RELEASE_TARGETS="${SUPPORTED_TARGETS/emu*/""}"
    RELEASE_HELP_MSG="
usage: release <TARGET>

TARGET:
${SUPPORTED_RELEASE_TARGETS}"

    if [ $# -lt 1 ]; then
        echo "${RELEASE_HELP_MSG}"
        exit 1
    fi

    case $1 in
        -h | --help)
            echo "${RELEASE_HELP_MSG}"
            exit 0
            ;;
        kindle)
            kodev-build kindle
            make TARGET=kindle update
            ;;
        kobo)
            kodev-build kobo
            make TARGET=kobo update
            ;;
        kindle-legacy)
            kodev-build kindle-legacy
            make TARGET=kindle-legacy update
            ;;
        android)
            kodev-build android
            make TARGET=android update
            ;;
        pocketbook)
            kodev-build pocketbook
            make TARGET=pocketbook update
            ;;
        ubuntu-touch)
            kodev-build pocketbook
            make TARGET=ubuntu-touch update
            ;;
        *)
            echo "Unsupported target for release: $1."
            echo "${RELEASE_HELP_MSG}"
            exit 1
            ;;
    esac
}


function kodev-wbuilder {
    kodev-build
    echo "[*] Running wbuilder.lua..."
    pushd ${EMU_DIR}
    EMULATE_READER_W=540 EMULATE_READER_H=720 ./luajit ./utils/wbuilder.lua
    popd
}

function kodev-run {
    RUN_HELP_MSG="
usage: run <OPTIONS> <ARGS>

OPTIONS:

    --no-build          run reader without rebuilding
    --disable-touch     use this if you want to simulate keyboard only devices
    "
    while [[ $1 == '-'* ]]; do
        PARAM=`echo $1 | awk -F= '{print $1}'`
        VALUE=`echo $1 | awk -F= '{print $2}'`
        case $PARAM in
            --disable-touch)
                export DISABLE_TOUCH=1
                ;;
            --no-build)
                no_build=true
                ;;
            -h | --help)
                echo "${RUN_HELP_MSG}"
                exit 0
                ;;
            *)
                echo "ERROR: unknown option \"$PARAM\""
                echo "${RUN_HELP_MSG}"
                exit 1
                ;;
        esac
        shift
    done

    if [ ! ${no_build} ]; then
        echo "[*] Building KOReader..."
        kodev-build
    else
        setup_env
    fi

    if [ ! -d ${EMU_DIR} ]; then
        echo "Failed to find emulator directory! Please try build command first."
        exit 1
    fi

    echo "[*] Running KOReader..."
    pushd ${EMU_DIR}

    if [ $# -lt 1 ]; then
        args=${CURDIR}/test
    else
        args="$1"
        [[ $args != /* ]] && args="${CURDIR}/$1"
    fi

    EMULATE_READER_W=540 EMULATE_READER_H=720 ./reader.lua -d $args
    popd
}

function kodev-test {
    TEST_HELP_MSG="
usage: test <OPTIONS> [front|base] <TEST_NAME>

    TEST_NAME is optional. If no TEST_NAME is given, all tests will be run.

OPTIONS:

    --tags=TAGS     only run tests with given tags
    "
    while [[ $1 == '-'* ]]; do
        PARAM=`echo $1 | awk -F= '{print $1}'`
        VALUE=`echo $1 | awk -F= '{print $2}'`
        case $PARAM in
            --tags)
                opts="--tags=${VALUE}"
                ;;
            -h | --help)
                echo "${TEST_HELP_MSG}"
                exit 0
                ;;
            *)
                echo "ERROR: unknown option \"$PARAM\""
                echo "${TEST_HELP_MSG}"
                exit 1
                ;;
        esac
        shift
    done

    if [ $# -lt 1 ]; then
        echo "${TEST_HELP_MSG}"
        exit 1
    fi

    setup_env
    make ${EMU_DIR}/.busted
    pushd ${EMU_DIR}

    test_path=./spec/$1/unit

    if [ ! -z $2 ]; then
        test_path="${test_path}/$2"
    fi
    busted --lua=./luajit ${opts} \
        -o ./spec/$1/unit/verbose_print \
        --exclude-tags=notest ${test_path}

    popd
}

function kodev-log {
    LOG_HELP_MSG="
usage: log <TARGET>

TARGET:

    android
"

    if [ $# -lt 1 ]; then
        echo "${LOG_HELP_MSG}"
        exit 1
    fi

    case $1 in
        -h | --help)
            echo "${LOG_HELP_MSG}"
            exit 0
            ;;
        android)
            adb logcat 'luajit-launcher:D *:S'
            ;;
        *)
            echo "Unsupported target: $1."
            echo "${LOG_HELP_MSG}"
            exit 1
            ;;
    esac
}



HELP_MSG="
usage: $0 COMMAND <ARGS>

Supported commands:

    fetch-thirdparty    Fetch thirdparty dependencies for build
    build               Build KOReader
    clean               Clean KOReader build
    release             Build KOReader release package
    run                 Run KOReader
    wbuilder            Run wbuilder.lua script (useful for building new UI widget)
    test                Run tests
    log                 Tail log stream for a running KOReader app
"

if [ $# -lt 1 ]; then
    echo "Missing command."
    echo "${HELP_MSG}"
    exit 1
fi

case $1 in
    fetch-thirdparty)
        kodev-fetch-thirdparty
        ;;
    clean)
        shift 1
        kodev-clean $@
        ;;
    build)
        shift 1
        kodev-build $@
        ;;
    release)
        shift 1
        kodev-release $@
        ;;
    wbuilder)
        kodev-wbuilder
        ;;
    run)
        shift 1
        kodev-run $@
        ;;
    test)
        shift 1
        kodev-test $@
        ;;
    log)
        shift 1
        kodev-log $@
        ;;
    --help | -h)
        echo "${HELP_MSG}"
        exit 0
        ;;
    *)
        echo "Unknown command: $1."
        echo "${HELP_MSG}"
        exit 1
        ;;
esac