Android: Update the gradle file to use android studio 2.2 cmake.

AndroidSetup.md

@@ -4,17 +4,10 @@ If you'd like to contribute to the Android project, but do not currently have a

## Prerequisites

* A Linux VM or host, or a Mac.
* JDK 7 for your platform.
* CMake
* [Android NDK](https://developer.android.com/tools/sdk/ndk/index.html) 
* [Android Studio](http://developer.android.com/tools/studio/index.html) **OR**
* [Android SDK Tools](http://developer.android.com/sdk/index.html#Other) (for command-line usage)
* [Android Studio](http://developer.android.com/tools/studio/index.html)

If you downloaded Android Studio, extract it and then see [Setting up Android Studio](#setting-up-android-studio).

If you instead chose to download the commoand-line SDK tools, see [Setting up the SDK Tools](#setting-up-the-sdk-tools).

## Setting up Android Studio

1. Launch Android Studio, which will start a first-launch wizard.
@@ -26,12 +19,6 @@ If you instead chose to download the commoand-line SDK tools, see [Setting up th
7. Use the SDK Manager to get necessary dependencies, as described in [Getting Dependencies](#getting-dependencies).
8. When done, follow the steps in [Readme.md](Readme.md#installation-on-android) to compile and deploy the application.

## Setting up the SDK Tools

1. In `Source/Android`, create a file called `local.properties`.
2. Add a single line: `sdk.dir=<sdk-path>`, where `<sdk-path>` is the path where you extracted the SDK Tools package.
3. Follow the steps in [Readme.md](Readme.md#installation-on-android) to compile and deploy the application.

## Executing Gradle Tasks

In Android Studio, you can find a list of possible Gradle tasks in a tray at the top right of the screen:
@@ -50,19 +37,14 @@ For command-line users, any task may be executed with `Source/Android/gradlew <t

Most dependencies for the Android project are supplied by Gradle automatically. However, Android platform libraries (and a few Google-supplied supplementary libraries) must be downloaded through the Android package manager.

1. Launch the Android SDK Manager from the commandline by executing `<sdk-path>/tools/android`, or by clicking on its icon in Android Studio's main toolbar:
1. Launch the Android SDK Manager by clicking on its icon in Android Studio's main toolbar:
![Android Studio Package Icon][package-icon]
2. At the bottom of the window, click "Deselect All", and then "Updates".
3. Install or update the following packages:

* SDK Platform, under "Android 5.0.1 (API 21)". This will allow compiling apps that target Lollipop.
* Android Support Repository
* Android Support Library
* Google Repository
2. Install or update the SDK Platform. Choose the API level selected as [compileSdkVersion](Source/Android/app/build.gradle#L5).
3. Install or update the SDK Tools. CMake, LLDB and NDK. If you don't use android-studio, please check out https://github.com/Commit451/android-cmake-installer.

In the future, if the project targets a newer version of Android, or use newer versions of the tools/build-tools packages, it will be necessary to use this tool to download updates.

[components]: http://i.imgur.com/Oo1Fs93.png
[package-icon]: http://i.imgur.com/NUpkAH8.png
[gradle]: http://i.imgur.com/dXIH6o3.png
[shortcut]: http://i.imgur.com/eCWP4Yy.png
[shortcut]: http://i.imgur.com/eCWP4Yy.png

CMakeLists.txt

@@ -188,36 +188,28 @@ else()
	add_definitions(-D_ARCH_32=1)
endif()

if(NOT ENABLE_GENERIC)
	if(${CMAKE_SYSTEM_PROCESSOR} MATCHES "^x86" OR
	   ${CMAKE_SYSTEM_PROCESSOR} MATCHES "i.86" OR
	   ${CMAKE_SYSTEM_PROCESSOR} MATCHES "amd64" OR
	   APPLE)
		if(_ARCH_64)
			set(_M_X86 1)
			set(_M_X86_64 1)
			add_definitions(-D_M_X86=1 -D_M_X86_64=1 -msse2)
			set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fno-pie")
		else()
			message(FATAL_ERROR "x86_32 is an unsupported platform. Enable generic build if you really want a JIT-less binary.")
		endif()
	elseif(${CMAKE_SYSTEM_PROCESSOR} MATCHES "^arm")
		message(FATAL_ERROR "ARMv7 is an unsupported platform. Enable generic build if you really want a JIT-less binary.")
	elseif(${CMAKE_SYSTEM_PROCESSOR} STREQUAL "aarch64")
		# This option only applies to 64bit ARM
		set(_M_ARM 1)
		set(_M_ARM_64 1)
		add_definitions(-D_M_ARM=1 -D_M_ARM_64=1)
		add_definitions(-march=armv8-a+crc)
	else()
		set(ENABLE_GENERIC 1)
	endif()
endif()

if(ENABLE_GENERIC)
	message("Warning! Building generic build!")
	set(_M_GENERIC 1)
	add_definitions(-D_M_GENERIC=1)
elseif(_ARCH_64 AND (
	${CMAKE_SYSTEM_PROCESSOR} MATCHES "^x86" OR
	${CMAKE_SYSTEM_PROCESSOR} MATCHES "i.86" OR
	${CMAKE_SYSTEM_PROCESSOR} MATCHES "amd64" OR
	APPLE
))
	set(_M_X86 1)
	set(_M_X86_64 1)
	add_definitions(-D_M_X86=1 -D_M_X86_64=1 -msse2)
	set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fno-pie")
elseif(${CMAKE_SYSTEM_PROCESSOR} STREQUAL "aarch64")
	set(_M_ARM 1)
	set(_M_ARM_64 1)
	add_definitions(-D_M_ARM=1 -D_M_ARM_64=1)
	add_definitions(-march=armv8-a+crc)
else()
	message(FATAL_ERROR "You're building on an unsupported platform. Enable generic build if you really want a JIT-less binary.")
endif()

include(CheckCXXCompilerFlag)
@@ -423,6 +415,8 @@ if(ANDROID)
	# We are cross compiling, search only the toolchain for libraries and includes
	SET(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
	SET(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
	SET(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM ONLY)
	SET(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY)
elseif(NOT APPLE AND NOT CMAKE_SYSTEM_NAME MATCHES OpenBSD)
	list(APPEND LIBS rt)
endif()

Readme.md

@@ -99,29 +99,7 @@ If using Android Studio, import the Gradle project located in `./Source/Android`

Android apps are compiled using a build system called Gradle. Dolphin's native component,
however, is compiled using CMake. The Gradle script will attempt to run a CMake build
automatically while building the Java code, if you create the file `Source/Android/build.properties`,
and place the following inside:

```
# Specifies arguments for the 'make' command. Can be blank.
makeArgs=

# The path to your machine's Git executable. Will autodetect if blank (on Linux only).
gitPath=

# The path to the CMake executable. Will autodetect if blank (on Linux only).
cmakePath=

# The path to the extracted NDK package. Will autodetect if blank (on Linux only).
ndkPath=
```

If you prefer, you can run the CMake step manually, and it will copy the resulting
binary into the correct location for inclusion in the Android APK.

Execute the Gradle task `assembleArm_64Debug` to build, or `installArm_64Debug` to
install the application onto a connected device. If other ABIs are eventually supported,
execute the tasks corresponding to the desired ABI.
automatically while building the Java code.

## Uninstalling
When Dolphin has been installed with the NSIS installer, you can uninstall

Source/Android/app/.gitignore

@@ -1 +1,2 @@
/build
/.externalNativeBuild

Source/Android/app/build.gradle

@@ -2,8 +2,8 @@ apply plugin: 'com.android.application'

android {
    // Leanback support requires >22
    compileSdkVersion 23
    buildToolsVersion '23.0.2'
    compileSdkVersion 24
    buildToolsVersion '24.0.3'

    lintOptions {
        // This is important as it will run lint but not abort on error
@@ -53,213 +53,40 @@ android {
            applicationIdSuffix ".debug"
            versionNameSuffix '-debug'
            jniDebuggable true

            tasks.withType(JavaCompile) {
                compileTask -> compileTask.dependsOn(compileNative)
            }
        }
    }

    // Define product flavors, which can be split into categories. Common examples
    // of product flavors are paid vs. free, ARM vs. x86, etc.
    productFlavors {
        arm_64 {
            dimension "abi"
            ndk {
                abiFilter "arm64-v8a"
            }
    externalNativeBuild {
        cmake {
            path "../../../CMakeLists.txt"
        }
    }

        x86_64 {
            dimension "abi"
            ndk {
                abiFilter "x86_64"
    defaultConfig {
        externalNativeBuild {
            cmake {
                arguments "-DANDROID_STL=c++_static", "-DCMAKE_BUILD_TYPE=RelWithDebInfo", "-DENABLE_PCH=OFF" // , "-DENABLE_GENERIC=ON"
                abiFilters "arm64-v8a" //, "armeabi-v7a", "x86_64", "x86"
            }
        }
    }
}

dependencies {
    compile 'com.android.support:support-v13:23.1.1'
    compile 'com.android.support:cardview-v7:23.1.1'
    compile 'com.android.support:recyclerview-v7:23.1.1'
    compile 'com.android.support:design:23.1.1'
    compile 'com.android.support:support-v13:24.2.1'
    compile 'com.android.support:cardview-v7:24.2.1'
    compile 'com.android.support:recyclerview-v7:24.2.1'
    compile 'com.android.support:design:24.2.1'

    // Android TV UI libraries.
    compile 'com.android.support:leanback-v17:23.1.1'
    compile 'com.android.support:leanback-v17:24.2.1'

    // For showing the banner as a circle a-la Material Design Guidelines
    compile 'de.hdodenhof:circleimageview:1.2.2'
    compile 'de.hdodenhof:circleimageview:2.1.0'

    // For loading huge screenshots from the disk.
    compile 'com.squareup.picasso:picasso:2.5.2'

    // Allows FRP-style asynchronous operations in Android.
    compile 'io.reactivex:rxandroid:1.1.0'
}

task setupCMake(type: Exec) {
    // Check if a build properties file exists.
    def propsFile = rootProject.file("build.properties")

    // If it does, call CMake.
    if (propsFile.canRead()) {
        // Read the properties file's contents.
        def buildProperties = new Properties()
        buildProperties.load(new FileInputStream(propsFile))

        String abi = getAbi()

        mkdir('build/' + abi)
        workingDir 'build/' + abi

        executable getExecutablePath("cmake")

        args "-DANDROID=true",
                "-DANDROID_NATIVE_API_LEVEL=android-18",
                "-DCMAKE_TOOLCHAIN_FILE=../../../android.toolchain.cmake",
                "../../../../..",
                "-DGIT_EXECUTABLE=" + getExecutablePath("git"),
                "-DANDROID_NDK=" + getNdkPath(),
                "-DANDROID_TOOLCHAIN_NAME=" + getToolchainName(),
                "-DANDROID_ABI=" + abi
    } else {
        executable 'echo'
        args 'No build.properties found; skipping CMake.'
    }
    compile 'io.reactivex:rxandroid:1.2.1'
}

task compileNative(type: Exec, dependsOn: 'setupCMake') {
    // Check if a build properties file exists.
    def propsFile = rootProject.file("build.properties")

    // If it does, call make.
    if (propsFile.canRead()) {
        // Read the properties file's contents.
        def buildProperties = new Properties()
        buildProperties.load(new FileInputStream(propsFile))

        String abi = getAbi()

        workingDir 'build/' + abi

        executable 'make'

        if (buildProperties.makeArgs == null || buildProperties.makeArgs.isEmpty()) {
            // TODO
        } else {
            args buildProperties.makeArgs
        }
    } else {
        executable 'echo'
        args 'No build.properties found; skipping native build.'
    }
}

String getExecutablePath(String command) {
    def propsFile = rootProject.file("build.properties")
    def path = null

    if (propsFile.canRead()) {
        def buildProperties = new Properties()
        buildProperties.load(new FileInputStream(propsFile))
        println buildProperties
        path = buildProperties[command + "Path"]
    }

    if (path == null || path.isEmpty()) {
        try {
            def stdout = new ByteArrayOutputStream()

            exec {
                commandLine 'which', command
                standardOutput = stdout
            }

            path = stdout.toString().trim()
        } catch (ignored) {
            project.logger.error("Gradle error: Couldn't find " + command + " executable.")
        }
    }

    if (path != null) {
        project.logger.quiet("Gradle: Found " + command + " executuable:" + path)
    }

    return path
}

String getNdkPath() {
    def propsFile = rootProject.file("build.properties")
    def ndkPath = null

    if (propsFile.canRead()) {
        def buildProperties = new Properties()
        buildProperties.load(new FileInputStream(propsFile))
        ndkPath = buildProperties.ndkPath
    }

    if (ndkPath == null || ndkPath.isEmpty()) {
        try {
            def stdout = new ByteArrayOutputStream()

            exec {
                // ndk-build.cmd is a file unique to the root directory of android-ndk-r10e.
                commandLine 'locate', 'ndk-build.cmd'
                standardOutput = stdout
            }

            def ndkCmdPath = stdout.toString()
            ndkPath = ndkCmdPath.substring(0, ndkCmdPath.lastIndexOf('/'))
        } catch (ignored) {
            project.logger.error("Gradle error: Couldn't find NDK.")
        }
    }

    if (ndkPath != null) {
        project.logger.quiet("Gradle: Found Android NDK: " + ndkPath)
    }
    return ndkPath
}

String getAbi() {
    String taskName = getGradle().startParameter.taskNames[0]
    String abi;

    if (taskName == null) {
        return ""
    }

    project.logger.quiet("Gradle: Build = " + taskName)

    if (taskName.contains("Arm_64")) {
        abi = "arm64-v8a"
    } else if (taskName.contains("Arm")) {
        abi = "armeabi-v7a"
    } else if (taskName.contains("X86_64")) {
        abi = "x86_64"
    }

    project.logger.quiet("Gradle: ABI name: " + abi)
    return abi;
}

String getToolchainName() {
    String taskName = getGradle().startParameter.taskNames[0]
    String toolchain;

    if (taskName == null) {
        return ""
    }

    if (taskName.contains("Arm_64")) {
        toolchain = "aarch64-linux-android-4.9"
    } else if (taskName.contains("Arm")) {
        toolchain = "arm-linux-androideabi-4.9"
    } else if (taskName.contains("X86_64")) {
        toolchain = "x86_64-4.9"
    }

    project.logger.quiet("Gradle: ABI name: " + toolchain)
    return toolchain;
}