Skip to content
Snippets Groups Projects
Select Git revision
  • a416c743671aec74109ce3ad24e6f438d0da21f9
  • master default protected
  • release/202005
  • release/202001
  • release/201912
  • release/windows-test/201910
  • release/201908
  • release/201906
  • release/201905
  • release/201904
  • release/201903
  • release/201902
  • release/201901
  • release/201812
  • release/201811
  • release/201808
  • wip/patches_poly_2017/cedryk_doucet/abderahmane_bouziane
  • releases/beta1
  • android/release_463
  • android/release_462
  • android/release_461
  • android/release_460
  • android/release_459
  • android/release_458
  • android/release_457
  • android/release_456
  • android/release_455
  • android/release_454
  • android/release_453
  • android/release_452
  • android/release_451
  • android/release_450
  • android/release_449
  • android/release_448
  • android/release_447
  • android/release_446
  • android/release_445
  • android/release_444
38 results

compile.sh

Blame
  • Code owners
    Assign users and groups as approvers for specific file changes. Learn more.
    compile.sh 12.64 KiB
    #! /bin/bash
    
    # Read the Android Wiki http://wiki.videolan.org/AndroidCompile
    # Setup all that stuff correctly.
    # Get the latest Android SDK Platform or modify numbers in configure.sh and sflphone-android/default.properties.
    
    #for OSX/BSD
    realpath() {
        [[ $1 = /* ]] && echo "$1" || echo "$PWD/${1#./}"
    }
    
    set -e
    
    if [ -z "$ANDROID_NDK" -o -z "$ANDROID_SDK" ]; then
       echo "You must define ANDROID_NDK, ANDROID_SDK and ANDROID_ABI before starting."
       echo "They must point to your NDK and SDK directories.\n"
       exit 1
    fi
    
    if [ -z "$ANDROID_ABI" ]; then
       echo "Please set ANDROID_ABI to your architecture: armeabi-v7a, armeabi, arm64-v8a, x86, x86_64 or mips."
       exit 1
    fi
    
    if [ -z "$NO_FPU" ];then
        NO_FPU=0
    fi
    if [ -z "$NO_ARMV6" ];then
        NO_ARMV6=0
    fi
    
    BUILD=0
    FETCH=0
    RELEASE=0
    JNI=0
    
    for i in ${@}; do
        case "$i" in
            --fetch)
            FETCH=1
            ;;
            --build)
            BUILD=1
            ;;
            release|--release)
            RELEASE=1
            ;;
            jni|--jni)
            JNI=1
            ;;
            *)
            ;;
        esac
    done
    
    if [ "$BUILD" = 0 -a "$FETCH" = 0 ];then
        BUILD=1
        FETCH=1
    fi
    
    if [ `set -- ${ANDROID_ABI}; echo $#` -gt 1 ]; then
        ANDROID_ABI_LIST="${ANDROID_ABI}"
        echo "More than one ABI specified: ${ANDROID_ABI_LIST}"
        for i in ${ANDROID_ABI_LIST}; do
            echo "$i starts building"
            ANDROID_NDK=$ANDROID_NDK ANDROID_SDK=$ANDROID_SDK \
                NO_FPU=$NO_FPU NO_ARMV6=$NO_ARMV6 ANDROID_ABI=$i \
                ./compile.sh $* --jni || { echo "$i build KO"; exit 1; }
            mkdir -p obj/
            cp -r ring-android/app/src/main/libs/$i obj
            echo "$i build OK"
        done
        for i in ${ANDROID_ABI_LIST}; do
            cp -r obj/$i ring-android/libs/
            rm -rf obj/$i
        done
        make -b -j1 RELEASE=$RELEASE apk || exit 1
        exit 0
    fi
    
    HAVE_ARM=0
    HAVE_X86=0
    HAVE_MIPS=0
    HAVE_64=0
    
    
    # Set up ABI variables
    if [ ${ANDROID_ABI} = "x86" ] ; then
        TARGET_TUPLE="i686-linux-android"
        PATH_HOST="x86"
        HAVE_X86=1
        PLATFORM_SHORT_ARCH="x86"
    elif [ ${ANDROID_ABI} = "x86_64" ] ; then
        TARGET_TUPLE="x86_64-linux-android"
        PATH_HOST="x86_64"
        HAVE_X86=1
        HAVE_64=1
        PLATFORM_SHORT_ARCH="x86_64"
    elif [ ${ANDROID_ABI} = "mips" ] ; then
        TARGET_TUPLE="mipsel-linux-android"
        PATH_HOST=$TARGET_TUPLE
        HAVE_MIPS=1
        PLATFORM_SHORT_ARCH="mips"
    elif [ ${ANDROID_ABI} = "arm64-v8a" ] ; then
        TARGET_TUPLE="aarch64-linux-android"
        PATH_HOST=$TARGET_TUPLE
        HAVE_ARM=1
        HAVE_64=1
        PLATFORM_SHORT_ARCH="arm64"
    else
        TARGET_TUPLE="arm-linux-androideabi"
        PATH_HOST=$TARGET_TUPLE
        HAVE_ARM=1
        PLATFORM_SHORT_ARCH="arm"
    fi
    
    # try to detect NDK version
    GCCVER=4.9
    REL=$(grep -o '^r[0-9]*.*' $ANDROID_NDK/RELEASE.TXT 2>/dev/null|cut -b2-)
    case "$REL" in
        10*)
            if [ "${HAVE_64}" = 1 ];then
                ANDROID_API=android-21
            else
                ANDROID_API=android-16
            fi
            CXXSTL="/"${GCCVER}
        ;;
        9*)
            if [ "${HAVE_64}" = 1 ];then
                echo "You need the NDKv10 or later for 64 bits build"
                exit 1
            fi
            ANDROID_API=android-16
            CXXSTL="/"${GCCVER}
        ;;
        7|8|*)
            echo "You need the NDKv9 or later"
            exit 1
        ;;
    esac
    
    export GCCVER
    export CXXSTL
    export ANDROID_API
    
    # XXX : important!
    [ "$HAVE_ARM" = 1 ] && cat << EOF
    For an ARMv6 device without FPU:
    $ export NO_FPU=1
    For an ARMv5 device:
    $ export NO_ARMV6=1
    
    If you plan to use a release build, run 'compile.sh release'
    EOF
    
    export TARGET_TUPLE
    export PATH_HOST
    export HAVE_ARM
    export HAVE_X86
    export HAVE_MIPS
    export HAVE_64
    export PLATFORM_SHORT_ARCH
    
    # Add the NDK toolchain to the PATH, needed both for contribs and for building
    # stub libraries
    NDK_TOOLCHAIN_PATH=`echo ${ANDROID_NDK}/toolchains/${PATH_HOST}-${GCCVER}/prebuilt/\`uname|tr A-Z a-z\`-*/bin`
    export NDK_TOOLCHAIN_PATH=${NDK_TOOLCHAIN_PATH}
    export PATH=${NDK_TOOLCHAIN_PATH}:${PATH}
    
    ANDROID_PATH="`pwd`"
    
    # Fetch ring daemon source
    if [ "$FETCH" = 1 ]
    then
        # 1/ dring
        TESTED_HASH=0b08a64fc8826807d02448941279074da206b8d7
        if [ ! -d "ring-daemon" ]; then
            echo "ring daemon source not found, cloning"
            git clone https://gerrit-ring.savoirfairelinux.com/ring-daemon.git
            pushd ring-daemon
            echo android/ >> .git/info/exclude
            echo contrib/android/ >> .git/info/exclude
    	    git checkout $TESTED_HASH
        else
            echo "ring daemon source found"
            pushd ring-daemon
    	    git fetch
            #git checkout ${TESTED_HASH}
    #        if ! git cat-file -e ${TESTED_HASH}; then
    #            cat << EOF
    #***
    #*** Error: Your ring checkout does not contain the latest tested commit ***
    #***
    #
    #Please update your source with something like:
    #
    #cd ring
    #git reset --hard origin
    #git pull origin master
    #git checkout -B android ${TESTED_HASH}
    #
    #*** : This will delete any changes you made to the current branch ***
    #
    #EOF
    #           exit 1
    #        fi
        fi
    else
        pushd ring
    fi
    
    if [ -z "$BUILD" ]
    then
        echo "Not building anything, please run $0 --build"
        exit 0
    fi
    
    # Setup CFLAGS
    if [ ${ANDROID_ABI} = "armeabi-v7a-hard" ] ; then
        EXTRA_CFLAGS="-march=armv7-a -mfpu=vfpv3-d16 -mcpu=cortex-a8 -D_NDK_MATH_NO_SOFTFP=1"
    elif [ ${ANDROID_ABI} = "armeabi-v7a" ] ; then
        EXTRA_CFLAGS="-march=armv7-a -mfloat-abi=softfp -mfpu=vfpv3-d16 -mthumb"
        #EXTRA_CFLAGS="-march=armv7-a -mfpu=vfpv3-d16 -mthumb -mcpu=cortex-a8"
    elif [ ${ANDROID_ABI} = "armeabi" ] ; then
        if [ -n "${NO_ARMV6}" ]; then
            EXTRA_CFLAGS="-march=armv5te -mtune=arm9tdmi -msoft-float "
        else
            if [ -n "${NO_FPU}" ]; then
                EXTRA_CFLAGS="-march=armv6j -mtune=arm1136j-s -msoft-float"
            else
                EXTRA_CFLAGS="-mfpu=vfp -mcpu=arm1136jf-s -mfloat-abi=softfp"
            fi
        fi
    elif [ ${ANDROID_ABI} = "arm64-v8a" ] ; then
        EXTRA_CFLAGS=""
    elif [ ${ANDROID_ABI} = "x86" ] ; then
        EXTRA_CFLAGS="-march=pentium -m32"
    elif [ ${ANDROID_ABI} = "x86_64" ] ; then
        EXTRA_CFLAGS=""
    elif [ ${ANDROID_ABI} = "mips" ] ; then
        EXTRA_CFLAGS="-march=mips32 -mtune=mips32r2 -mhard-float"
        # All MIPS Linux kernels since 2.4.4 will trap any unimplemented FPU
        # instruction and emulate it, so we select -mhard-float.
        # See http://www.linux-mips.org/wiki/Floating_point#The_Linux_kernel_and_floating_point
    else
        echo "Unknown ABI ${ANDROID_ABI}. Die, die, die!"
        exit 2
    fi
    
    EXTRA_CFLAGS="${EXTRA_CFLAGS} -O2 -DHAVE_PTHREADS"
    EXTRA_CFLAGS="${EXTRA_CFLAGS} -I${ANDROID_NDK}/sources/cxx-stl/gnu-libstdc++${CXXSTL}/include"
    EXTRA_CFLAGS="${EXTRA_CFLAGS} -I${ANDROID_NDK}/sources/cxx-stl/gnu-libstdc++${CXXSTL}/libs/${ANDROID_ABI}/include"
    EXTRA_CXXFLAGS="${EXTRA_CFLAGS}"
    EXTRA_CFLAGS="-std=gnu11 ${EXTRA_CFLAGS}"
    
    # Setup LDFLAGS
    if [ ${ANDROID_ABI} = "armeabi-v7a-hard" ] ; then
        EXTRA_LDFLAGS="-march=armv7-a -mfpu=vfpv3-d16 -mcpu=cortex-a8 -lm_hard -D_NDK_MATH_NO_SOFTFP=1"
    elif [ ${ANDROID_ABI} = "armeabi-v7a" ] ; then
        EXTRA_LDFLAGS="-march=armv7-a -mthumb"
    fi
    EXTRA_LDFLAGS="${EXTRA_LDFLAGS} -L${ANDROID_NDK}/sources/cxx-stl/gnu-libstdc++${CXXSTL}/libs/${ANDROID_ABI} -lgnustl_static"
    
    # Make in //
    UNAMES=$(uname -s)
    MAKEFLAGS=
    if which nproc >/dev/null
    then
    MAKEFLAGS=-j`nproc`
    elif [ "$UNAMES" == "Darwin" ] && which sysctl >/dev/null
    then
    MAKEFLAGS=-j`sysctl -n machdep.cpu.thread_count`
    fi
    
    # Build buildsystem tools
    export PATH=`pwd`/extras/tools/build/bin:$PATH
    echo "Building tools"
    pushd extras/tools
    ./bootstrap
    make $MAKEFLAGS
    #FIXME
    echo "HACK for old Jenkins builder...forcing libtool to be built"
    make .libtool
    popd
    
    ############
    # Contribs #
    ############
    echo "Building the contribs"
    mkdir -p contrib/native
    
    gen_pc_file() {
        echo "Generating $1 pkg-config file"
        echo "Name: $1
    Description: $1
    Version: $2
    Libs: -l$1
    Cflags:" > contrib/${TARGET_TUPLE}/lib/pkgconfig/`echo $1|tr 'A-Z' 'a-z'`.pc
    }
    
    
    ANDROID_BIN=${NDK_TOOLCHAIN_PATH}
    CROSS_COMPILE=${ANDROID_BIN}/${TARGET_TUPLE}-
    export CROSS_COMPILE="${CROSS_COMPILE}"
    
    
    mkdir -p contrib/${TARGET_TUPLE}/lib/pkgconfig
    
    pushd contrib/native
    ../bootstrap --host=${TARGET_TUPLE}
    
    # Some libraries have arm assembly which won't build in thumb mode
    # We append -marm to the CFLAGS of these libs to disable thumb mode
    [ ${ANDROID_ABI} = "armeabi-v7a" ] && echo "NOTHUMB := -marm" >> config.mak
    [ ${ANDROID_ABI} = "armeabi-v7a-hard" ] && echo "NOTHUMB := -marm" >> config.mak
    
    # Release or not?
    if [ $# -ne 0 ] && [ "$1" = "release" ]; then
        OPTS=""
        EXTRA_CFLAGS="${EXTRA_CFLAGS} -DNDEBUG "
        RELEASE=1
    else
        OPTS="--enable-debug"
        EXTRA_CFLAGS="${EXTRA_CFLAGS} -DNDEBUG "
        RELEASE=0
    fi
    
    echo "EXTRA_CFLAGS= -g -fpic ${EXTRA_CFLAGS}" >> config.mak
    echo "EXTRA_CXXFLAGS= -g -fpic ${EXTRA_CXXFLAGS}" >> config.mak
    echo "EXTRA_LDFLAGS= ${EXTRA_LDFLAGS}" >> config.mak
    export RING_EXTRA_CFLAGS="${EXTRA_CFLAGS}"
    export RING_EXTRA_CXXFLAGS="${EXTRA_CXXFLAGS}"
    export RING_EXTRA_LDFLAGS="${EXTRA_LDFLAGS}"
    #export LOCAL_EXTRA_LDFLAGS="${EXTRA_LDFLAGS}"
    
    make list
    make install
    echo ${PWD}
    # We already have zlib available
    [ -e .zlib ] || (mkdir -p zlib; touch .zlib)
    which autopoint >/dev/null || make $MAKEFLAGS .gettext
    export PATH="$PATH:$PWD/../$TARGET_TUPLE/bin"
    popd
    
    ############
    # Make Ring #
    ############
    RING_SRC_DIR="${PWD}"
    RING_BUILD_DIR="`realpath build-android-${TARGET_TUPLE}`"
    #RING_INSTALL_DIR="`realpath install-android-${TARGET_TUPLE}`"
    export RING_SRC_DIR="${RING_SRC_DIR}"
    export RING_BUILD_DIR="${RING_BUILD_DIR}"
    
    #mkdir -p ${RING_INSTALL_DIR}
    mkdir -p build-android-${TARGET_TUPLE} && pushd build-android-${TARGET_TUPLE}
    DRING_PATH="`pwd`"
    
    if [ "$JNI" = 1 ]; then
        CLEAN="jniclean"
        TARGET="ring-android/app/src/main/obj/local/${ANDROID_ABI}/libring.so"
    else
        CLEAN="distclean"
        TARGET=
    fi
    
    if [ ! -f config.h ]; then
        echo "Bootstraping"
        cd ../
        ./autogen.sh
        cd ../
        cd ring-android
        ./make-swig.sh
        cd ../ring-daemon/build-android-${TARGET_TUPLE}
        echo "Configuring"
        ${ANDROID_PATH}/configure.sh ${OPTS}
    fi
    
    # ANDROID NDK FIXUP (BLAME GOOGLE)
    config_undef ()
    {
        previous_change=`stat -c "%y" config.h`
        sed -i 's,#define '$1' 1,/\* #undef '$1' \*/,' config.h
        # don't change modified date in order to don't trigger a full build
        touch -d "$previous_change" config.h
    }
    
    # if config dependencies change, ./config.status --recheck
    # is run and overwrite previously hacked config.h. So call make Makefile here
    # and hack config.h after.
    
    make $MAKEFLAGS Makefile
    
    if [ ${ANDROID_ABI} = "x86" -a ${ANDROID_API} != "android-21" ] ; then
        # NDK x86 libm.so has nanf symbol but no nanf definition, we don't known if
        # intel devices has nanf. Assume they don't have it.
        config_undef HAVE_NANF
    fi
    if [ ${ANDROID_API} = "android-21" ] ; then
        # android-21 has empty sys/shm.h headers that triggers shm detection but it
        # doesn't have any shm functions and/or symbols. */
        config_undef HAVE_SYS_SHM_H
    fi
    # END OF ANDROID NDK FIXUP
    
    echo "Building dring ${MAKEFLAGS}"
    V=99 make $MAKEFLAGS
    
    ####################################
    # Ring android UI and specific code
    ####################################
    cd ../..
    
    echo "Building Ring for Android ${PWD}" 
    make $CLEAN
    ANDROID_ABI="${ANDROID_ABI}" make -j1 TARGET_TUPLE=$TARGET_TUPLE PLATFORM_SHORT_ARCH=$PLATFORM_SHORT_ARCH CXXSTL=$CXXSTL RELEASE=$RELEASE $TARGET
    
    #
    # Exporting a environment script with all the necessary variables
    #
    echo "Generating environment script."
    cat <<EOF
    This is a script that will export many of the variables used in this
    script. It will allow you to compile parts of the build without having
    to rebuild the entire build (e.g. recompile only the Java part).
    
    To use it, include the script into your shell, like this:
        source env.sh
    
    Now, you can use this command to build the Java portion:
        make -e
    
    The file will be automatically regenerated by compile.sh, so if you change
    your NDK/SDK locations or any build configurations, just re-run this
    script (sh compile.sh) and it will automatically update the file.
    
    EOF
    
    echo "# This file was automatically generated by compile.sh" > env.sh
    echo "# Re-run 'sh compile.sh' to update this file." >> env.sh
    
    # The essentials
    cat <<EssentialsA >> env.sh
    export ANDROID_ABI=$ANDROID_ABI
    export ANDROID_SDK=$ANDROID_SDK
    export ANDROID_NDK=$ANDROID_NDK
    export GCCVER=$GCCVER
    export CXXSTL=$CXXSTL
    export RING_BUILD_DIR=$RING_BUILD_DIR
    export TARGET_TUPLE=$TARGET_TUPLE
    export PATH_HOST=$PATH_HOST
    export PLATFORM_SHORT_ARCH=$PLATFORM_SHORT_ARCH
    EssentialsA
    
    # PATH
    echo "export PATH=$NDK_TOOLCHAIN_PATH:\${ANDROID_SDK}/platform-tools:\${PATH}" >> env.sh
    
    # CPU flags
    if [ -n "${HAVE_ARM}" ]; then
        echo "export HAVE_ARM=1" >> env.sh
    elif [ -n "${HAVE_X86}" ]; then
        echo "export HAVE_X86=1" >> env.sh
    elif [ -n "${HAVE_MIPS}" ]; then
        echo "export HAVE_MIPS=1" >> env.sh
    fi
    
    if [ -n "${NO_ARMV6}" ]; then
        echo "export NO_ARMV6=1" >> env.sh
    fi
    if [ -n "${NO_FPU}" ]; then
        echo "export NO_FPU=1" >> env.sh
    fi