From d11679a06e6a992216148fd2ce1730c9912c8564 Mon Sep 17 00:00:00 2001 From: Ryan Houdek Date: Tue, 19 Mar 2013 21:53:09 -0500 Subject: [PATCH 1/6] Android mega commit of trash. --- Source/Android/.classpath | 8 + Source/Android/.gitignore | 7 + Source/Android/.project | 33 + .../.settings/org.eclipse.jdt.core.prefs | 4 + Source/Android/AndroidManifest.xml | 29 + Source/Android/android.toolchain.cmake | 1125 +++++++++++++++++ Source/Android/assets/ButtonA.png | Bin 0 -> 5178 bytes Source/Android/assets/ButtonB.png | Bin 0 -> 4971 bytes Source/Android/build.xml | 92 ++ Source/Android/custom_rules.xml | 16 + Source/Android/jni/Android.mk | 189 +++ Source/Android/jni/Application.mk | 4 + Source/Android/project.properties | 14 + Source/Android/res/drawable-hdpi/launcher.png | Bin 0 -> 14225 bytes Source/Android/res/drawable-mdpi/launcher.png | Bin 0 -> 8634 bytes .../Android/res/drawable-xhdpi/launcher.png | Bin 0 -> 23020 bytes .../Android/res/drawable-xxhdpi/launcher.png | Bin 0 -> 82300 bytes Source/Android/res/layout/main.xml | 26 + Source/Android/res/values/strings.xml | 6 + .../src/org/dolphinemu/dolphinemu/Button.java | 33 + .../dolphinemu/dolphinemu/ButtonManager.java | 43 + .../dolphinemu/DolphinEmulator.java | 124 ++ .../dolphinemu/FileArrayAdapter.java | 53 + .../dolphinemu/NativeGLSurfaceView.java | 61 + .../dolphinemu/dolphinemu/NativeListView.java | 94 ++ .../dolphinemu/dolphinemu/NativeRenderer.java | 168 +++ .../src/org/dolphinemu/dolphinemu/Option.java | 38 + Source/Core/Common/Src/StringUtil.cpp | 3 +- Source/Core/Core/Src/ConfigManager.cpp | 2 + Source/Core/Core/Src/HW/GCPad.cpp | 11 + Source/Core/DolphinWX/Src/GLInterface.h | 2 + Source/Core/DolphinWX/Src/MainAndroid.cpp | 66 +- .../Plugin_VideoSoftware/Src/SWRenderer.cpp | 93 +- 33 files changed, 2311 insertions(+), 33 deletions(-) create mode 100644 Source/Android/.classpath create mode 100644 Source/Android/.gitignore create mode 100644 Source/Android/.project create mode 100644 Source/Android/.settings/org.eclipse.jdt.core.prefs create mode 100644 Source/Android/AndroidManifest.xml create mode 100644 Source/Android/android.toolchain.cmake create mode 100644 Source/Android/assets/ButtonA.png create mode 100644 Source/Android/assets/ButtonB.png create mode 100644 Source/Android/build.xml create mode 100644 Source/Android/custom_rules.xml create mode 100644 Source/Android/jni/Android.mk create mode 100644 Source/Android/jni/Application.mk create mode 100644 Source/Android/project.properties create mode 100644 Source/Android/res/drawable-hdpi/launcher.png create mode 100644 Source/Android/res/drawable-mdpi/launcher.png create mode 100644 Source/Android/res/drawable-xhdpi/launcher.png create mode 100644 Source/Android/res/drawable-xxhdpi/launcher.png create mode 100644 Source/Android/res/layout/main.xml create mode 100644 Source/Android/res/values/strings.xml create mode 100644 Source/Android/src/org/dolphinemu/dolphinemu/Button.java create mode 100644 Source/Android/src/org/dolphinemu/dolphinemu/ButtonManager.java create mode 100644 Source/Android/src/org/dolphinemu/dolphinemu/DolphinEmulator.java create mode 100644 Source/Android/src/org/dolphinemu/dolphinemu/FileArrayAdapter.java create mode 100644 Source/Android/src/org/dolphinemu/dolphinemu/NativeGLSurfaceView.java create mode 100644 Source/Android/src/org/dolphinemu/dolphinemu/NativeListView.java create mode 100644 Source/Android/src/org/dolphinemu/dolphinemu/NativeRenderer.java create mode 100644 Source/Android/src/org/dolphinemu/dolphinemu/Option.java diff --git a/Source/Android/.classpath b/Source/Android/.classpath new file mode 100644 index 000000000000..3f9691c5dda2 --- /dev/null +++ b/Source/Android/.classpath @@ -0,0 +1,8 @@ + + + + + + + + diff --git a/Source/Android/.gitignore b/Source/Android/.gitignore new file mode 100644 index 000000000000..31bce7aa4171 --- /dev/null +++ b/Source/Android/.gitignore @@ -0,0 +1,7 @@ +gen +obj +#ui_atlas.zim +ui_atlas.zim.png +#assets/ui_atlas.zim +#jni/ui_atlas.cpp +#jni/ui_atlas.h diff --git a/Source/Android/.project b/Source/Android/.project new file mode 100644 index 000000000000..a79d8a1840e6 --- /dev/null +++ b/Source/Android/.project @@ -0,0 +1,33 @@ + + + ppsspp + + + + + + com.android.ide.eclipse.adt.ResourceManagerBuilder + + + + + com.android.ide.eclipse.adt.PreCompilerBuilder + + + + + org.eclipse.jdt.core.javabuilder + + + + + com.android.ide.eclipse.adt.ApkBuilder + + + + + + com.android.ide.eclipse.adt.AndroidNature + org.eclipse.jdt.core.javanature + + diff --git a/Source/Android/.settings/org.eclipse.jdt.core.prefs b/Source/Android/.settings/org.eclipse.jdt.core.prefs new file mode 100644 index 000000000000..f77b31c2d2c0 --- /dev/null +++ b/Source/Android/.settings/org.eclipse.jdt.core.prefs @@ -0,0 +1,4 @@ +eclipse.preferences.version=1 +org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.5 +org.eclipse.jdt.core.compiler.compliance=1.5 +org.eclipse.jdt.core.compiler.source=1.5 diff --git a/Source/Android/AndroidManifest.xml b/Source/Android/AndroidManifest.xml new file mode 100644 index 000000000000..e22370dd1689 --- /dev/null +++ b/Source/Android/AndroidManifest.xml @@ -0,0 +1,29 @@ + + + + + + + + + + + + + + + + + + + + diff --git a/Source/Android/android.toolchain.cmake b/Source/Android/android.toolchain.cmake new file mode 100644 index 000000000000..69b402670d6c --- /dev/null +++ b/Source/Android/android.toolchain.cmake @@ -0,0 +1,1125 @@ +# ------------------------------------------------------------------------------ +# Android CMake toolchain file, for use with the Android NDK r5-r8 +# Requires cmake 2.6.3 or newer (2.8.5 or newer is recommended). +# See home page: http://code.google.com/p/android-cmake/ +# +# The file is mantained by the OpenCV project. And also can be found at +# http://code.opencv.org/projects/opencv/repository/revisions/master/changes/android/android.toolchain.cmake +# +# Usage Linux: +# $ export ANDROID_NDK=/absolute/path/to/the/android-ndk +# $ mkdir build && cd build +# $ cmake -DCMAKE_TOOLCHAIN_FILE=path/to/the/android.toolchain.cmake .. +# $ make -j8 +# +# Usage Linux (using standalone toolchain): +# $ export ANDROID_STANDALONE_TOOLCHAIN=/absolute/path/to/android-toolchain +# $ mkdir build && cd build +# $ cmake -DCMAKE_TOOLCHAIN_FILE=path/to/the/android.toolchain.cmake .. +# $ make -j8 +# +# Usage Windows: +# You need native port of make to build your project. +# Android NDK r7 (or newer) already has make.exe on board. +# For older NDK you have to install it separately. +# For example, this one: http://gnuwin32.sourceforge.net/packages/make.htm +# +# $ SET ANDROID_NDK=C:\absolute\path\to\the\android-ndk +# $ mkdir build && cd build +# $ cmake.exe -G"MinGW Makefiles" +# -DCMAKE_TOOLCHAIN_FILE=path\to\the\android.toolchain.cmake +# -DCMAKE_MAKE_PROGRAM="%ANDROID_NDK%\prebuilt\windows\bin\make.exe" .. +# $ "%ANDROID_NDK%\prebuilt\windows\bin\make.exe" +# +# +# Options (can be set as cmake parameters: -D=): +# ANDROID_NDK=/opt/android-ndk - path to the NDK root. +# Can be set as environment variable. Can be set only at first cmake run. +# +# ANDROID_STANDALONE_TOOLCHAIN=/opt/android-toolchain - path to the +# standalone toolchain. This option is not used if full NDK is found +# (ignored if ANDROID_NDK is set). +# Can be set as environment variable. Can be set only at first cmake run. +# +# ANDROID_ABI=armeabi-v7a - specifies the target Application Binary +# Interface (ABI). This option nearly matches to the APP_ABI variable +# used by ndk-build tool from Android NDK. +# +# Possible targets are: +# "armeabi" - matches to the NDK ABI with the same name. +# See ${ANDROID_NDK}/docs/CPU-ARCH-ABIS.html for the documentation. +# "armeabi-v7a" - matches to the NDK ABI with the same name. +# See ${ANDROID_NDK}/docs/CPU-ARCH-ABIS.html for the documentation. +# "armeabi-v7a with NEON" - same as armeabi-v7a, but +# sets NEON as floating-point unit +# "armeabi-v7a with VFPV3" - same as armeabi-v7a, but +# sets VFPV3 as floating-point unit (has 32 registers instead of 16). +# "armeabi-v6 with VFP" - tuned for ARMv6 processors having VFP. +# "x86" - matches to the NDK ABI with the same name. +# See ${ANDROID_NDK}/docs/CPU-ARCH-ABIS.html for the documentation. +# "mips" - matches to the NDK ABI with the same name +# (not testes on real devices) +# +# ANDROID_NATIVE_API_LEVEL=android-8 - level of Android API compile for. +# Option is read-only when standalone toolchain used. +# +# ANDROID_FORCE_ARM_BUILD=OFF - set true to generate 32-bit ARM instructions +# instead of Thumb-1. Is not available for "x86" (inapplicable) and +# "armeabi-v6 with VFP" (forced) ABIs. +# +# ANDROID_NO_UNDEFINED=ON - set true to show all undefined symbols as linker +# errors even if they are not used. +# +# ANDROID_SO_UNDEFINED=OFF - set true to allow undefined symbols in shared +# libraries. Automatically turned on for NDK r5x and r6x due to GLESv2 +# problems. +# +# LIBRARY_OUTPUT_PATH_ROOT=${CMAKE_SOURCE_DIR} - where to output binary +# files. See additional details below. +# +# ANDROID_SET_OBSOLETE_VARIABLES=ON - it set, then toolchain defines some +# obsolete variables which were set by previous versions of this file for +# backward compatibility. +# +# +# What?: +# android-cmake toolchain searches for NDK/toolchain in the following order: +# ANDROID_NDK - cmake parameter +# ANDROID_NDK - environment variable +# ANDROID_STANDALONE_TOOLCHAIN - cmake parameter +# ANDROID_STANDALONE_TOOLCHAIN - environment variable +# ANDROID_NDK - default locations +# ANDROID_STANDALONE_TOOLCHAIN - default locations +# +# Make sure to do the following in your scripts: +# SET( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${my_cxx_flags}" ) +# SET( CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${my_cxx_flags}" ) +# The flags will be prepopulated with critical flags, so don't loose them. +# Also be aware that toolchain also sets configuration-specific compiler +# flags and linker flags. +# +# ANDROID and BUILD_ANDROID will be set to true, you may test any of these +# variables to make necessary Android-specific configuration changes. +# +# Also ARMEABI or ARMEABI_V7A or X86 will be set true, mutually exclusive. +# NEON option will be set true if VFP is set to NEON. +# +# LIBRARY_OUTPUT_PATH_ROOT should be set in cache to determine where Android +# libraries will be installed. +# Default is ${CMAKE_SOURCE_DIR}, and the android libs will always be +# under the ${LIBRARY_OUTPUT_PATH_ROOT}/libs/${ANDROID_NDK_ABI_NAME} +# (depending on the target ABI). This is convenient for Android packaging. +# +# Authors: +# Ethan Rublee ethan.ruble@gmail.com +# Andrey Kamaev andrey.kamaev@itseez.com +# +# Change Log: +# - initial version December 2010 +# - modified April 2011 +# [+] added possibility to build with NDK (without standalone toolchain) +# [+] support cross-compilation on Windows (native, no cygwin support) +# [+] added compiler option to force "char" type to be signed +# [+] added toolchain option to compile to 32-bit ARM instructions +# [+] added toolchain option to disable SWIG search +# [+] added platform "armeabi-v7a with VFPV3" +# [~] ARM_TARGETS renamed to ARM_TARGET +# [+] EXECUTABLE_OUTPUT_PATH is set by toolchain (required on Windows) +# [~] Fixed bug with ANDROID_API_LEVEL variable +# [~] turn off SWIG search if it is not found first time +# - modified May 2011 +# [~] ANDROID_LEVEL is renamed to ANDROID_API_LEVEL +# [+] ANDROID_API_LEVEL is detected by toolchain if not specified +# [~] added guard to prevent changing of output directories on the first +# cmake pass +# [~] toolchain exits with error if ARM_TARGET is not recognized +# - modified June 2011 +# [~] default NDK path is updated for version r5c +# [+] variable CMAKE_SYSTEM_PROCESSOR is set based on ARM_TARGET +# [~] toolchain install directory is added to linker paths +# [-] removed SWIG-related stuff from toolchain +# [+] added macro find_host_package, find_host_program to search +# packages/programs on the host system +# [~] fixed path to STL library +# - modified July 2011 +# [~] fixed options caching +# [~] search for all supported NDK versions +# [~] allowed spaces in NDK path +# - modified September 2011 +# [~] updated for NDK r6b +# - modified November 2011 +# [*] rewritten for NDK r7 +# [+] x86 toolchain support (experimental) +# [+] added "armeabi-v6 with VFP" ABI for ARMv6 processors. +# [~] improved compiler and linker flags management +# [+] support different build flags for Release and Debug configurations +# [~] by default compiler flags the same as used by ndk-build (but only +# where reasonable) +# [~] ANDROID_NDK_TOOLCHAIN_ROOT is splitted to ANDROID_STANDALONE_TOOLCHAIN +# and ANDROID_TOOLCHAIN_ROOT +# [~] ARM_TARGET is renamed to ANDROID_ABI +# [~] ARMEABI_NDK_NAME is renamed to ANDROID_NDK_ABI_NAME +# [~] ANDROID_API_LEVEL is renamed to ANDROID_NATIVE_API_LEVEL +# - modified January 2012 +# [+] added stlport_static support (experimental) +# [+] added special check for cygwin +# [+] filtered out hidden files (starting with .) while globbing inside NDK +# [+] automatically applied GLESv2 linkage fix for NDK revisions 5-6 +# [+] added ANDROID_GET_ABI_RAWNAME to get NDK ABI names by CMake flags +# - modified February 2012 +# [+] updated for NDK r7b +# [~] fixed cmake try_compile() command +# [~] Fix for missing install_name_tool on OS X +# - modified March 2012 +# [~] fixed incorrect C compiler flags +# [~] fixed CMAKE_SYSTEM_PROCESSOR change on ANDROID_ABI change +# [+] improved toolchain loading speed +# [+] added assembler language support (.S) +# [+] allowed preset search paths and extra search suffixes +# - modified April 2012 +# [+] updated for NDK r7c +# [~] fixed most of problems with compiler/linker flags and caching +# [+] added option ANDROID_FUNCTION_LEVEL_LINKING +# - modified May 2012 +# [+] updated for NDK r8 +# [+] added mips architecture support +# - modified August 2012 +# [+] updated for NDK r8b +# [~] all intermediate files generated by toolchain are moved into CMakeFiles +# [~] libstdc++ and libsupc are removed from explicit link libraries +# ------------------------------------------------------------------------------ + +cmake_minimum_required( VERSION 2.6.3 ) + +if( DEFINED CMAKE_CROSSCOMPILING ) + # subsequent toolchain loading is not really needed + return() +endif() + +get_property(_CMAKE_IN_TRY_COMPILE GLOBAL PROPERTY IN_TRY_COMPILE) +if( _CMAKE_IN_TRY_COMPILE ) + include( "${CMAKE_CURRENT_SOURCE_DIR}/../android.toolchain.config.cmake" OPTIONAL ) +endif() + +# this one is important +set( CMAKE_SYSTEM_NAME Linux ) +# this one not so much +set( CMAKE_SYSTEM_VERSION 1 ) + +set( ANDROID_SUPPORTED_NDK_VERSIONS ${ANDROID_EXTRA_NDK_VERSIONS} -r8b -r8 -r7c -r7b -r7 -r6b -r6 -r5c -r5b -r5 "" ) +if(NOT DEFINED ANDROID_NDK_SEARCH_PATHS) + if( CMAKE_HOST_WIN32 ) + file( TO_CMAKE_PATH "$ENV{PROGRAMFILES}" ANDROID_NDK_SEARCH_PATHS ) + set( ANDROID_NDK_SEARCH_PATHS "${ANDROID_NDK_SEARCH_PATHS}/android-ndk" "$ENV{SystemDrive}/NVPACK/android-ndk" ) + else() + file( TO_CMAKE_PATH "$ENV{HOME}" ANDROID_NDK_SEARCH_PATHS ) + set( ANDROID_NDK_SEARCH_PATHS /opt/android-ndk "${ANDROID_NDK_SEARCH_PATHS}/NVPACK/android-ndk" ) + endif() +endif() +if(NOT DEFINED ANDROID_STANDALONE_TOOLCHAIN_SEARCH_PATH) + set( ANDROID_STANDALONE_TOOLCHAIN_SEARCH_PATH /opt/android-toolchain ) +endif() + +set( ANDROID_SUPPORTED_ABIS_arm "armeabi-v7a;armeabi;armeabi-v7a with NEON;armeabi-v7a with VFPV3;armeabi-v6 with VFP" ) +set( ANDROID_SUPPORTED_ABIS_x86 "x86" ) +set( ANDROID_SUPPORTED_ABIS_mipsel "mips" ) + +set( ANDROID_DEFAULT_NDK_API_LEVEL 9 ) +set( ANDROID_DEFAULT_NDK_API_LEVEL_x86 9 ) +set( ANDROID_DEFAULT_NDK_API_LEVEL_mips 9 ) + + +macro( __LIST_FILTER listvar regex ) + if( ${listvar} ) + foreach( __val ${${listvar}} ) + if( __val MATCHES "${regex}" ) + list( REMOVE_ITEM ${listvar} "${__val}" ) + endif() + endforeach() + endif() +endmacro() + +macro( __INIT_VARIABLE var_name ) + set( __test_path 0 ) + foreach( __var ${ARGN} ) + if( __var STREQUAL "PATH" ) + set( __test_path 1 ) + break() + endif() + endforeach() + if( __test_path AND NOT EXISTS "${${var_name}}" ) + unset( ${var_name} CACHE ) + endif() + if( "${${var_name}}" STREQUAL "" ) + set( __values 0 ) + foreach( __var ${ARGN} ) + if( __var STREQUAL "VALUES" ) + set( __values 1 ) + elseif( NOT __var STREQUAL "PATH" ) + set( __obsolete 0 ) + if( __var MATCHES "^OBSOLETE_.*$" ) + string( REPLACE "OBSOLETE_" "" __var "${__var}" ) + set( __obsolete 1 ) + endif() + if( __var MATCHES "^ENV_.*$" ) + string( REPLACE "ENV_" "" __var "${__var}" ) + set( __value "$ENV{${__var}}" ) + elseif( DEFINED ${__var} ) + set( __value "${${__var}}" ) + else() + if( __values ) + set( __value "${__var}" ) + else() + set( __value "" ) + endif() + endif() + if( NOT "${__value}" STREQUAL "" ) + if( __test_path ) + if( EXISTS "${__value}" ) + set( ${var_name} "${__value}" ) + if( __obsolete ) + message( WARNING "Using value of obsolete variable ${__var} as initial value for ${var_name}. Please note, that ${__var} can be completely removed in future versions of the toolchain." ) + endif() + break() + endif() + else() + set( ${var_name} "${__value}" ) + if( __obsolete ) + message( WARNING "Using value of obsolete variable ${__var} as initial value for ${var_name}. Please note, that ${__var} can be completely removed in future versions of the toolchain." ) + endif() + break() + endif() + endif() + endif() + endforeach() + unset( __value ) + unset( __values ) + unset( __obsolete ) + endif() + unset( __test_path ) +endmacro() + +macro( __DETECT_NATIVE_API_LEVEL _var _path ) + SET( __ndkApiLevelRegex "^[\t ]*#define[\t ]+__ANDROID_API__[\t ]+([0-9]+)[\t ]*$" ) + FILE( STRINGS ${_path} __apiFileContent REGEX "${__ndkApiLevelRegex}" ) + if( NOT __apiFileContent ) + message( SEND_ERROR "Could not get Android native API level. Probably you have specified invalid level value, or your copy of NDK/toolchain is broken." ) + endif() + string( REGEX REPLACE "${__ndkApiLevelRegex}" "\\1" ${_var} "${__apiFileContent}" ) + unset( __apiFileContent ) + unset( __ndkApiLevelRegex ) +endmacro() + +macro( __DETECT_TOOLCHAIN_MACHINE_NAME _var _root ) + file( GLOB __gccExePath "${_root}/bin/*-gcc${TOOL_OS_SUFFIX}" ) + __LIST_FILTER( __gccExePath "bin/[.].*-gcc${TOOL_OS_SUFFIX}$" ) + list( LENGTH __gccExePath __gccExePathsCount ) + if( NOT __gccExePathsCount EQUAL 1 ) + message( WARNING "Could not uniquely determine machine name for compiler from ${_root}." ) + set( ${_var} "" ) + else() + get_filename_component( __gccExeName "${__gccExePath}" NAME_WE ) + string( REPLACE "-gcc" "" ${_var} "${__gccExeName}" ) + endif() + unset( __gccExePath ) + unset( __gccExePathsCount ) + unset( __gccExeName ) +endmacro() + +macro( __COPY_IF_DIFFERENT _source _destination ) + execute_process( COMMAND "${CMAKE_COMMAND}" -E copy_if_different "${_source}" "${_destination}" RESULT_VARIABLE __fileCopyProcess ) + if( NOT __fileCopyProcess EQUAL 0 OR NOT EXISTS "${_destination}") + message( SEND_ERROR "Failed copying of ${_source} to the ${_destination}" ) + endif() + unset( __fileCopyProcess ) +endmacro() + + +# stl version: by default gnustl_static will be used +set( ANDROID_USE_STLPORT FALSE CACHE BOOL "Experimental: use stlport_static instead of gnustl_static") +mark_as_advanced( ANDROID_USE_STLPORT ) + +# fight against cygwin +set( ANDROID_FORBID_SYGWIN TRUE CACHE BOOL "Prevent cmake from working under cygwin and using cygwin tools") +mark_as_advanced( ANDROID_FORBID_SYGWIN ) +if( ANDROID_FORBID_SYGWIN ) + if( CYGWIN ) + message( FATAL_ERROR "Android NDK and android-cmake toolchain are not welcome Cygwin. It is unlikely that this cmake toolchain will work under cygwin. But if you want to try then you can set cmake variable ANDROID_FORBID_SYGWIN to FALSE and rerun cmake." ) + endif() + + if( CMAKE_HOST_WIN32 ) + # remove cygwin from PATH + set( __new_path "$ENV{PATH}") + __LIST_FILTER( __new_path "cygwin" ) + set(ENV{PATH} "${__new_path}") + unset(__new_path) + endif() +endif() + +# detect current host platform +set( TOOL_OS_SUFFIX "" ) +if( CMAKE_HOST_APPLE ) + set( ANDROID_NDK_HOST_SYSTEM_NAME "darwin-x86" ) +elseif( CMAKE_HOST_WIN32 ) + set( ANDROID_NDK_HOST_SYSTEM_NAME "windows" ) + set( TOOL_OS_SUFFIX ".exe" ) +elseif( CMAKE_HOST_UNIX ) + set( ANDROID_NDK_HOST_SYSTEM_NAME "linux-x86" ) +else() + message( FATAL_ERROR "Cross-compilation on your platform is not supported by this cmake toolchain" ) +endif() + +# see if we have path to Android NDK +__INIT_VARIABLE( ANDROID_NDK PATH ENV_ANDROID_NDK ) +if( NOT ANDROID_NDK ) + # see if we have path to Android standalone toolchain + __INIT_VARIABLE( ANDROID_STANDALONE_TOOLCHAIN PATH ENV_ANDROID_STANDALONE_TOOLCHAIN OBSOLETE_ANDROID_NDK_TOOLCHAIN_ROOT OBSOLETE_ENV_ANDROID_NDK_TOOLCHAIN_ROOT ) + + if( NOT ANDROID_STANDALONE_TOOLCHAIN ) + #try to find Android NDK in one of the the default locations + set( __ndkSearchPaths ) + foreach( __ndkSearchPath ${ANDROID_NDK_SEARCH_PATHS} ) + foreach( suffix ${ANDROID_SUPPORTED_NDK_VERSIONS} ) + list( APPEND __ndkSearchPaths "${__ndkSearchPath}${suffix}" ) + endforeach() + endforeach() + __INIT_VARIABLE( ANDROID_NDK PATH VALUES ${__ndkSearchPaths} ) + unset( __ndkSearchPaths ) + + if( ANDROID_NDK ) + message( STATUS "Using default path for Android NDK: ${ANDROID_NDK}" ) + message( STATUS " If you prefer to use a different location, please define a cmake or environment variable: ANDROID_NDK" ) + else() + #try to find Android standalone toolchain in one of the the default locations + __INIT_VARIABLE( ANDROID_STANDALONE_TOOLCHAIN PATH ANDROID_STANDALONE_TOOLCHAIN_SEARCH_PATH ) + + if( ANDROID_STANDALONE_TOOLCHAIN ) + message( STATUS "Using default path for standalone toolchain ${ANDROID_STANDALONE_TOOLCHAIN}" ) + message( STATUS " If you prefer to use a different location, please define the variable: ANDROID_STANDALONE_TOOLCHAIN" ) + endif( ANDROID_STANDALONE_TOOLCHAIN ) + endif( ANDROID_NDK ) + endif( NOT ANDROID_STANDALONE_TOOLCHAIN ) +endif( NOT ANDROID_NDK ) + +# remember found paths +if( ANDROID_NDK ) + get_filename_component( ANDROID_NDK "${ANDROID_NDK}" ABSOLUTE ) + # try to detect change + if( CMAKE_AR ) + string( LENGTH "${ANDROID_NDK}" __length ) + string( SUBSTRING "${CMAKE_AR}" 0 ${__length} __androidNdkPreviousPath ) + if( NOT __androidNdkPreviousPath STREQUAL ANDROID_NDK ) + message( FATAL_ERROR "It is not possible to change path to the NDK on subsequent run." ) + endif() + unset( __androidNdkPreviousPath ) + unset( __length ) + endif() + set( ANDROID_NDK "${ANDROID_NDK}" CACHE INTERNAL "Path of the Android NDK" ) + set( BUILD_WITH_ANDROID_NDK True ) +elseif( ANDROID_STANDALONE_TOOLCHAIN ) + get_filename_component( ANDROID_STANDALONE_TOOLCHAIN "${ANDROID_STANDALONE_TOOLCHAIN}" ABSOLUTE ) + # try to detect change + if( CMAKE_AR ) + string( LENGTH "${ANDROID_STANDALONE_TOOLCHAIN}" __length ) + string( SUBSTRING "${CMAKE_AR}" 0 ${__length} __androidStandaloneToolchainPreviousPath ) + if( NOT __androidStandaloneToolchainPreviousPath STREQUAL ANDROID_STANDALONE_TOOLCHAIN ) + message( FATAL_ERROR "It is not possible to change path to the Android standalone toolchain on subsequent run." ) + endif() + unset( __androidStandaloneToolchainPreviousPath ) + unset( __length ) + endif() + set( ANDROID_STANDALONE_TOOLCHAIN "${ANDROID_STANDALONE_TOOLCHAIN}" CACHE INTERNAL "Path of the Android standalone toolchain" ) + set( BUILD_WITH_STANDALONE_TOOLCHAIN True ) +else() + list(GET ANDROID_NDK_SEARCH_PATHS 0 ANDROID_NDK_SEARCH_PATH) + message( FATAL_ERROR "Could not find neither Android NDK nor Android standalone toolcahin. + You should either set an environment variable: + export ANDROID_NDK=~/my-android-ndk + or + export ANDROID_STANDALONE_TOOLCHAIN=~/my-android-toolchain + or put the toolchain or NDK in the default path: + sudo ln -s ~/my-android-ndk ${ANDROID_NDK_SEARCH_PATH} + sudo ln -s ~/my-android-toolchain ${ANDROID_STANDALONE_TOOLCHAIN_SEARCH_PATH}" ) +endif() + +# get all the details about standalone toolchain +if( BUILD_WITH_STANDALONE_TOOLCHAIN ) + __DETECT_NATIVE_API_LEVEL( ANDROID_SUPPORTED_NATIVE_API_LEVELS "${ANDROID_STANDALONE_TOOLCHAIN}/sysroot/usr/include/android/api-level.h" ) + set( ANDROID_STANDALONE_TOOLCHAIN_API_LEVEL ${ANDROID_SUPPORTED_NATIVE_API_LEVELS} ) + set( __availableToolchains "standalone" ) + __DETECT_TOOLCHAIN_MACHINE_NAME( __availableToolchainMachines "${ANDROID_STANDALONE_TOOLCHAIN}" ) + if( NOT __availableToolchainMachines ) + message( FATAL_ERROR "Could not determine machine name of your toolchain. Probably your Android standalone toolchain is broken." ) + endif() + if( __availableToolchainMachines MATCHES i686 ) + set( __availableToolchainArchs "x86" ) + elseif( __availableToolchainMachines MATCHES arm ) + set( __availableToolchainArchs "arm" ) + elseif( __availableToolchainMachines MATCHES mipsel ) + set( __availableToolchainArchs "mipsel" ) + endif() + if( ANDROID_COMPILER_VERSION ) + # do not run gcc every time because it is relatevely expencive + set( __availableToolchainCompilerVersions "${ANDROID_COMPILER_VERSION}" ) + else() + execute_process( COMMAND "${ANDROID_STANDALONE_TOOLCHAIN}/bin/${__availableToolchainMachines}-gcc${TOOL_OS_SUFFIX}" --version + OUTPUT_VARIABLE __availableToolchainCompilerVersions OUTPUT_STRIP_TRAILING_WHITESPACE ) + string( REGEX MATCH "[0-9]+.[0-9]+.[0-9]+" __availableToolchainCompilerVersions "${__availableToolchainCompilerVersions}" ) + endif() +endif() + +# get all the details about NDK +if( BUILD_WITH_ANDROID_NDK ) + file( GLOB ANDROID_SUPPORTED_NATIVE_API_LEVELS RELATIVE "${ANDROID_NDK}/platforms" "${ANDROID_NDK}/platforms/android-*" ) + string( REPLACE "android-" "" ANDROID_SUPPORTED_NATIVE_API_LEVELS "${ANDROID_SUPPORTED_NATIVE_API_LEVELS}" ) + file( GLOB __availableToolchains RELATIVE "${ANDROID_NDK}/toolchains" "${ANDROID_NDK}/toolchains/*" ) + __LIST_FILTER( __availableToolchains "^[.]" ) + set( __availableToolchainMachines "" ) + set( __availableToolchainArchs "" ) + set( __availableToolchainCompilerVersions "" ) + foreach( __toolchain ${__availableToolchains} ) + __DETECT_TOOLCHAIN_MACHINE_NAME( __machine "${ANDROID_NDK}/toolchains/${__toolchain}/prebuilt/${ANDROID_NDK_HOST_SYSTEM_NAME}" ) + if( __machine ) + string( REGEX MATCH "[0-9]+[.][0-9]+[.]*[0-9]*$" __version "${__toolchain}" ) + string( REGEX MATCH "^[^-]+" __arch "${__toolchain}" ) + list( APPEND __availableToolchainMachines "${__machine}" ) + list( APPEND __availableToolchainArchs "${__arch}" ) + list( APPEND __availableToolchainCompilerVersions "${__version}" ) + else() + list( REMOVE_ITEM __availableToolchains "${__toolchain}" ) + endif() + endforeach() + if( NOT __availableToolchains ) + message( FATAL_ERROR "Could not any working toolchain in the NDK. Probably your Android NDK is broken." ) + endif() +endif() + +# build list of available ABIs +if( NOT ANDROID_SUPPORTED_ABIS ) + set( ANDROID_SUPPORTED_ABIS "" ) + set( __uniqToolchainArchNames ${__availableToolchainArchs} ) + list( REMOVE_DUPLICATES __uniqToolchainArchNames ) + list( SORT __uniqToolchainArchNames ) + foreach( __arch ${__uniqToolchainArchNames} ) + list( APPEND ANDROID_SUPPORTED_ABIS ${ANDROID_SUPPORTED_ABIS_${__arch}} ) + endforeach() + unset( __uniqToolchainArchNames ) + if( NOT ANDROID_SUPPORTED_ABIS ) + message( FATAL_ERROR "No one of known Android ABIs is supported by this cmake toolchain." ) + endif() +endif() + +# choose target ABI +__INIT_VARIABLE( ANDROID_ABI OBSOLETE_ARM_TARGET OBSOLETE_ARM_TARGETS VALUES ${ANDROID_SUPPORTED_ABIS} ) +# verify that target ABI is supported +list( FIND ANDROID_SUPPORTED_ABIS "${ANDROID_ABI}" __androidAbiIdx ) +if( __androidAbiIdx EQUAL -1 ) + string( REPLACE ";" "\", \"", PRINTABLE_ANDROID_SUPPORTED_ABIS "${ANDROID_SUPPORTED_ABIS}" ) + message( FATAL_ERROR "Specified ANDROID_ABI = \"${ANDROID_ABI}\" is not supported by this cmake toolchain or your NDK/toolchain. + Supported values are: \"${PRINTABLE_ANDROID_SUPPORTED_ABIS}\" + " ) +endif() +unset( __androidAbiIdx ) + +# remember target ABI +set( ANDROID_ABI "${ANDROID_ABI}" CACHE STRING "The target ABI for Android. If arm, then armeabi-v7a is recommended for hardware floating point." FORCE ) + +# set target ABI options +if( ANDROID_ABI STREQUAL "x86" ) + set( X86 true ) + set( ANDROID_NDK_ABI_NAME "x86" ) + set( ANDROID_ARCH_NAME "x86" ) + set( ANDROID_ARCH_FULLNAME "x86" ) + set( CMAKE_SYSTEM_PROCESSOR "i686" ) +elseif( ANDROID_ABI STREQUAL "mips" ) + set( MIPS true ) + set( ANDROID_NDK_ABI_NAME "mips" ) + set( ANDROID_ARCH_NAME "mips" ) + set( ANDROID_ARCH_FULLNAME "mipsel" ) + set( CMAKE_SYSTEM_PROCESSOR "mips" ) +elseif( ANDROID_ABI STREQUAL "armeabi" ) + set( ARMEABI true ) + set( ANDROID_NDK_ABI_NAME "armeabi" ) + set( ANDROID_ARCH_NAME "arm" ) + set( ANDROID_ARCH_FULLNAME "arm" ) + set( CMAKE_SYSTEM_PROCESSOR "armv5te" ) +elseif( ANDROID_ABI STREQUAL "armeabi-v6 with VFP" ) + set( ARMEABI_V6 true ) + set( ANDROID_NDK_ABI_NAME "armeabi" ) + set( ANDROID_ARCH_NAME "arm" ) + set( ANDROID_ARCH_FULLNAME "arm" ) + set( CMAKE_SYSTEM_PROCESSOR "armv6" ) + # need always fallback to older platform + set( ARMEABI true ) +elseif( ANDROID_ABI STREQUAL "armeabi-v7a") + set( ARMEABI_V7A true ) + set( ANDROID_NDK_ABI_NAME "armeabi-v7a" ) + set( ANDROID_ARCH_NAME "arm" ) + set( ANDROID_ARCH_FULLNAME "arm" ) + set( CMAKE_SYSTEM_PROCESSOR "armv7-a" ) +elseif( ANDROID_ABI STREQUAL "armeabi-v7a with VFPV3" ) + set( ARMEABI_V7A true ) + set( ANDROID_NDK_ABI_NAME "armeabi-v7a" ) + set( ANDROID_ARCH_NAME "arm" ) + set( ANDROID_ARCH_FULLNAME "arm" ) + set( CMAKE_SYSTEM_PROCESSOR "armv7-a" ) + set( VFPV3 true ) +elseif( ANDROID_ABI STREQUAL "armeabi-v7a with NEON" ) + set( ARMEABI_V7A true ) + set( ANDROID_NDK_ABI_NAME "armeabi-v7a" ) + set( ANDROID_ARCH_NAME "arm" ) + set( ANDROID_ARCH_FULLNAME "arm" ) + set( CMAKE_SYSTEM_PROCESSOR "armv7-a" ) + set( VFPV3 true ) + set( NEON true ) +else() + message( SEND_ERROR "Unknown ANDROID_ABI=\"${ANDROID_ABI}\" is specified." ) +endif() + +if( CMAKE_BINARY_DIR AND EXISTS "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeSystem.cmake" ) + # really dirty hack + # it is not possible to change CMAKE_SYSTEM_PROCESSOR after the first run... + file( APPEND "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeSystem.cmake" "SET(CMAKE_SYSTEM_PROCESSOR \"${CMAKE_SYSTEM_PROCESSOR}\")\n" ) +endif() + +set( ANDROID_SUPPORTED_ABIS ${ANDROID_SUPPORTED_ABIS_${ANDROID_ARCH_FULLNAME}} CACHE INTERNAL "ANDROID_ABI can be changed only to one of these ABIs. Changing to any other ABI requires to reset cmake cache." ) +if( CMAKE_VERSION VERSION_GREATER "2.8" ) + list( SORT ANDROID_SUPPORTED_ABIS_${ANDROID_ARCH_FULLNAME} ) + set_property( CACHE ANDROID_ABI PROPERTY STRINGS ${ANDROID_SUPPORTED_ABIS_${ANDROID_ARCH_FULLNAME}} ) +endif() + +if( ANDROID_ARCH_NAME STREQUAL "arm" AND NOT ARMEABI_V6 ) + __INIT_VARIABLE( ANDROID_FORCE_ARM_BUILD OBSOLETE_FORCE_ARM VALUES OFF ) + set( ANDROID_FORCE_ARM_BUILD ${ANDROID_FORCE_ARM_BUILD} CACHE BOOL "Use 32-bit ARM instructions instead of Thumb-1" FORCE ) + mark_as_advanced( ANDROID_FORCE_ARM_BUILD ) +else() + unset( ANDROID_FORCE_ARM_BUILD CACHE ) +endif() + +# choose toolchain +if( ANDROID_TOOLCHAIN_NAME ) + list( FIND __availableToolchains "${ANDROID_TOOLCHAIN_NAME}" __toolchainIdx ) + if( __toolchainIdx EQUAL -1 ) + message( FATAL_ERROR "Previously selected toolchain \"${ANDROID_TOOLCHAIN_NAME}\" is missing. You need to remove CMakeCache.txt and rerun cmake manually to change the toolchain" ) + endif() + list( GET __availableToolchainArchs ${__toolchainIdx} __toolchainArch ) + if( NOT __toolchainArch STREQUAL ANDROID_ARCH_FULLNAME ) + message( SEND_ERROR "Previously selected toolchain \"${ANDROID_TOOLCHAIN_NAME}\" is not able to compile binaries for the \"${ANDROID_ARCH_NAME}\" platform." ) + endif() +else() + set( __toolchainIdx -1 ) + set( __applicableToolchains "" ) + set( __toolchainMaxVersion "0.0.0" ) + list( LENGTH __availableToolchains __availableToolchainsCount ) + math( EXPR __availableToolchainsCount "${__availableToolchainsCount}-1" ) + foreach( __idx RANGE ${__availableToolchainsCount} ) + list( GET __availableToolchainArchs ${__idx} __toolchainArch ) + if( __toolchainArch STREQUAL ANDROID_ARCH_FULLNAME ) + list( GET __availableToolchainCompilerVersions ${__idx} __toolchainVersion ) + if( __toolchainVersion VERSION_GREATER __toolchainMaxVersion ) + set( __toolchainMaxVersion "${__toolchainVersion}" ) + set( __toolchainIdx ${__idx} ) + endif() + endif() + endforeach() + unset( __availableToolchainsCount ) + unset( __toolchainMaxVersion ) + unset( __toolchainVersion ) +endif() +unset( __toolchainArch ) +if( __toolchainIdx EQUAL -1 ) + message( FATAL_ERROR "No one of available compiler toolchains is able to compile for ${ANDROID_ARCH_NAME} platform." ) +endif() +list( GET __availableToolchains ${__toolchainIdx} ANDROID_TOOLCHAIN_NAME ) +list( GET __availableToolchainMachines ${__toolchainIdx} ANDROID_TOOLCHAIN_MACHINE_NAME ) +list( GET __availableToolchainCompilerVersions ${__toolchainIdx} ANDROID_COMPILER_VERSION ) +set( ANDROID_TOOLCHAIN_NAME "${ANDROID_TOOLCHAIN_NAME}" CACHE INTERNAL "Name of toolchain used" ) +set( ANDROID_COMPILER_VERSION "${ANDROID_COMPILER_VERSION}" CACHE INTERNAL "compiler version from selected toolchain" ) +unset( __toolchainIdx ) +unset( __availableToolchains ) +unset( __availableToolchainMachines ) +unset( __availableToolchainArchs ) +unset( __availableToolchainCompilerVersions ) + +# choose native API level +__INIT_VARIABLE( ANDROID_NATIVE_API_LEVEL ENV_ANDROID_NATIVE_API_LEVEL ANDROID_API_LEVEL ENV_ANDROID_API_LEVEL ANDROID_STANDALONE_TOOLCHAIN_API_LEVEL ANDROID_DEFAULT_NDK_API_LEVEL_${ANDROID_ARCH_NAME} ANDROID_DEFAULT_NDK_API_LEVEL ) +string( REGEX MATCH "[0-9]+" ANDROID_NATIVE_API_LEVEL "${ANDROID_NATIVE_API_LEVEL}" ) +# validate +list( FIND ANDROID_SUPPORTED_NATIVE_API_LEVELS "${ANDROID_NATIVE_API_LEVEL}" __levelIdx ) +if( __levelIdx EQUAL -1 ) + message( SEND_ERROR "Specified Android native API level (${ANDROID_NATIVE_API_LEVEL}) is not supported by your NDK/toolchain." ) +endif() +unset( __levelIdx ) +if( BUILD_WITH_ANDROID_NDK ) + __DETECT_NATIVE_API_LEVEL( __realApiLevel "${ANDROID_NDK}/platforms/android-${ANDROID_NATIVE_API_LEVEL}/arch-${ANDROID_ARCH_NAME}/usr/include/android/api-level.h" ) + if( NOT __realApiLevel EQUAL ANDROID_NATIVE_API_LEVEL ) + message( SEND_ERROR "Specified Android API level (${ANDROID_NATIVE_API_LEVEL}) does not match to the level found (${__realApiLevel}). Probably your copy of NDK is broken." ) + endif() + unset( __realApiLevel ) +endif() +set( ANDROID_NATIVE_API_LEVEL "${ANDROID_NATIVE_API_LEVEL}" CACHE STRING "Android API level for native code" FORCE ) +if( CMAKE_VERSION VERSION_GREATER "2.8" ) + list( SORT ANDROID_SUPPORTED_NATIVE_API_LEVELS ) + set_property( CACHE ANDROID_NATIVE_API_LEVEL PROPERTY STRINGS ${ANDROID_SUPPORTED_NATIVE_API_LEVELS} ) +endif() + +# setup paths +if( BUILD_WITH_STANDALONE_TOOLCHAIN ) + set( ANDROID_TOOLCHAIN_ROOT "${ANDROID_STANDALONE_TOOLCHAIN}" ) + set( ANDROID_SYSROOT "${ANDROID_STANDALONE_TOOLCHAIN}/sysroot" ) + set( __stlLibPath "${ANDROID_STANDALONE_TOOLCHAIN}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib" ) +endif() +if( BUILD_WITH_ANDROID_NDK ) + set( ANDROID_TOOLCHAIN_ROOT "${ANDROID_NDK}/toolchains/${ANDROID_TOOLCHAIN_NAME}/prebuilt/${ANDROID_NDK_HOST_SYSTEM_NAME}" ) + set( ANDROID_SYSROOT "${ANDROID_NDK}/platforms/android-${ANDROID_NATIVE_API_LEVEL}/arch-${ANDROID_ARCH_NAME}" ) + if( ANDROID_USE_STLPORT ) + set( __stlIncludePath "${ANDROID_NDK}/sources/cxx-stl/stlport/stlport" ) + set( __stlLibPath "${ANDROID_NDK}/sources/cxx-stl/stlport/libs/${ANDROID_NDK_ABI_NAME}" ) + else() + if( EXISTS "${ANDROID_NDK}/sources/cxx-stl/gnu-libstdc++/${ANDROID_COMPILER_VERSION}" ) + set( __stlIncludePath "${ANDROID_NDK}/sources/cxx-stl/gnu-libstdc++/${ANDROID_COMPILER_VERSION}/include" ) + set( __stlLibPath "${ANDROID_NDK}/sources/cxx-stl/gnu-libstdc++/${ANDROID_COMPILER_VERSION}/libs/${ANDROID_NDK_ABI_NAME}" ) + else() + set( __stlIncludePath "${ANDROID_NDK}/sources/cxx-stl/gnu-libstdc++/include" ) + set( __stlLibPath "${ANDROID_NDK}/sources/cxx-stl/gnu-libstdc++/libs/${ANDROID_NDK_ABI_NAME}" ) + endif() + endif() +endif() + +# specify the cross compiler +set( CMAKE_C_COMPILER "${ANDROID_TOOLCHAIN_ROOT}/bin/${ANDROID_TOOLCHAIN_MACHINE_NAME}-gcc${TOOL_OS_SUFFIX}" CACHE PATH "gcc" ) +set( CMAKE_CXX_COMPILER "${ANDROID_TOOLCHAIN_ROOT}/bin/${ANDROID_TOOLCHAIN_MACHINE_NAME}-g++${TOOL_OS_SUFFIX}" CACHE PATH "g++" ) +set( CMAKE_ASM_COMPILER "${ANDROID_TOOLCHAIN_ROOT}/bin/${ANDROID_TOOLCHAIN_MACHINE_NAME}-gcc${TOOL_OS_SUFFIX}" CACHE PATH "Assembler" ) +if( CMAKE_VERSION VERSION_LESS 2.8.5 ) + set( CMAKE_ASM_COMPILER_ARG1 "-c" ) +endif() +# there may be a way to make cmake deduce these TODO deduce the rest of the tools +set( CMAKE_STRIP "${ANDROID_TOOLCHAIN_ROOT}/bin/${ANDROID_TOOLCHAIN_MACHINE_NAME}-strip${TOOL_OS_SUFFIX}" CACHE PATH "strip" ) +set( CMAKE_AR "${ANDROID_TOOLCHAIN_ROOT}/bin/${ANDROID_TOOLCHAIN_MACHINE_NAME}-ar${TOOL_OS_SUFFIX}" CACHE PATH "archive" ) +set( CMAKE_LINKER "${ANDROID_TOOLCHAIN_ROOT}/bin/${ANDROID_TOOLCHAIN_MACHINE_NAME}-ld${TOOL_OS_SUFFIX}" CACHE PATH "linker" ) +set( CMAKE_NM "${ANDROID_TOOLCHAIN_ROOT}/bin/${ANDROID_TOOLCHAIN_MACHINE_NAME}-nm${TOOL_OS_SUFFIX}" CACHE PATH "nm" ) +set( CMAKE_OBJCOPY "${ANDROID_TOOLCHAIN_ROOT}/bin/${ANDROID_TOOLCHAIN_MACHINE_NAME}-objcopy${TOOL_OS_SUFFIX}" CACHE PATH "objcopy" ) +set( CMAKE_OBJDUMP "${ANDROID_TOOLCHAIN_ROOT}/bin/${ANDROID_TOOLCHAIN_MACHINE_NAME}-objdump${TOOL_OS_SUFFIX}" CACHE PATH "objdump" ) +set( CMAKE_RANLIB "${ANDROID_TOOLCHAIN_ROOT}/bin/${ANDROID_TOOLCHAIN_MACHINE_NAME}-ranlib${TOOL_OS_SUFFIX}" CACHE PATH "ranlib" ) +set( _CMAKE_TOOLCHAIN_PREFIX "${ANDROID_TOOLCHAIN_MACHINE_NAME}-" ) +if( APPLE ) + find_program( CMAKE_INSTALL_NAME_TOOL NAMES install_name_tool ) + if( NOT CMAKE_INSTALL_NAME_TOOL ) + message( FATAL_ERROR "Could not find install_name_tool, please check your installation." ) + endif() + mark_as_advanced( CMAKE_INSTALL_NAME_TOOL ) +endif() + +# export directories +set( ANDROID_SYSTEM_INCLUDE_DIRS "" ) +set( ANDROID_SYSTEM_LIB_DIRS "" ) + +# setup output directories +set( LIBRARY_OUTPUT_PATH_ROOT ${CMAKE_SOURCE_DIR} CACHE PATH "root for library output, set this to change where android libs are installed to" ) +set( CMAKE_INSTALL_PREFIX "${ANDROID_TOOLCHAIN_ROOT}/user" CACHE STRING "path for installing" ) + +if(NOT _CMAKE_IN_TRY_COMPILE) + if( EXISTS "${CMAKE_SOURCE_DIR}/jni/CMakeLists.txt" ) + set( EXECUTABLE_OUTPUT_PATH "${LIBRARY_OUTPUT_PATH_ROOT}/bin/${ANDROID_NDK_ABI_NAME}" CACHE PATH "Output directory for applications" ) + else() + set( EXECUTABLE_OUTPUT_PATH "${LIBRARY_OUTPUT_PATH_ROOT}/bin" CACHE PATH "Output directory for applications" ) + endif() + set( LIBRARY_OUTPUT_PATH "${LIBRARY_OUTPUT_PATH_ROOT}/libs/${ANDROID_NDK_ABI_NAME}" CACHE PATH "path for android libs" ) +endif() + +# includes +list( APPEND ANDROID_SYSTEM_INCLUDE_DIRS "${ANDROID_SYSROOT}/usr/include" ) +if( __stlIncludePath AND EXISTS "${__stlIncludePath}" ) + list( APPEND ANDROID_SYSTEM_INCLUDE_DIRS "${__stlIncludePath}" ) +endif() + +# c++ bits includes +if( __stlLibPath AND EXISTS "${__stlLibPath}/include" ) + list( APPEND ANDROID_SYSTEM_INCLUDE_DIRS "${__stlLibPath}/include" ) +endif() +if( ANDROID_ARCH_NAME STREQUAL "arm" AND EXISTS "${ANDROID_TOOLCHAIN_ROOT}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/include/c++/${ANDROID_COMPILER_VERSION}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/${CMAKE_SYSTEM_PROCESSOR}/thumb/bits" ) + list( APPEND ANDROID_SYSTEM_INCLUDE_DIRS "${ANDROID_TOOLCHAIN_ROOT}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/include/c++/${ANDROID_COMPILER_VERSION}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/${CMAKE_SYSTEM_PROCESSOR}/thumb" ) +elseif( EXISTS "${ANDROID_TOOLCHAIN_ROOT}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/include/c++/${ANDROID_COMPILER_VERSION}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/${CMAKE_SYSTEM_PROCESSOR}/bits" ) + list( APPEND ANDROID_SYSTEM_INCLUDE_DIRS "${ANDROID_TOOLCHAIN_ROOT}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/include/c++/${ANDROID_COMPILER_VERSION}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/${CMAKE_SYSTEM_PROCESSOR}" ) +elseif( ANDROID_ARCH_NAME STREQUAL "arm" AND EXISTS "${ANDROID_TOOLCHAIN_ROOT}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/include/c++/${ANDROID_COMPILER_VERSION}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/thumb/bits" ) + list( APPEND ANDROID_SYSTEM_INCLUDE_DIRS "${ANDROID_TOOLCHAIN_ROOT}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/include/c++/${ANDROID_COMPILER_VERSION}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/thumb" ) +elseif( EXISTS "${ANDROID_TOOLCHAIN_ROOT}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/include/c++/${ANDROID_COMPILER_VERSION}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/bits" ) + list( APPEND ANDROID_SYSTEM_INCLUDE_DIRS "${ANDROID_TOOLCHAIN_ROOT}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/include/c++/${ANDROID_COMPILER_VERSION}/${ANDROID_TOOLCHAIN_MACHINE_NAME}" ) +endif() + +# flags and definitions +if(ANDROID_SYSROOT MATCHES "[ ;\"]") + set( ANDROID_CXX_FLAGS "--sysroot=\"${ANDROID_SYSROOT}\"" ) + # quotes will break try_compile and compiler identification + message(WARNING "Your Android system root has non-alphanumeric symbols. It can break compiler features detection and the whole build.") +else() + set( ANDROID_CXX_FLAGS "--sysroot=${ANDROID_SYSROOT}" ) +endif() + +remove_definitions( -DANDROID ) +add_definitions( -DANDROID ) + +# Force set compilers because standard identification works badly for us +include( CMakeForceCompiler ) +CMAKE_FORCE_C_COMPILER( "${CMAKE_C_COMPILER}" GNU ) +set( CMAKE_C_PLATFORM_ID Linux ) +set( CMAKE_C_SIZEOF_DATA_PTR 4 ) +set( CMAKE_C_HAS_ISYSROOT 1 ) +set( CMAKE_C_COMPILER_ABI ELF ) +CMAKE_FORCE_CXX_COMPILER( "${CMAKE_CXX_COMPILER}" GNU ) +set( CMAKE_CXX_PLATFORM_ID Linux ) +set( CMAKE_CXX_SIZEOF_DATA_PTR 4 ) +set( CMAKE_CXX_HAS_ISYSROOT 1 ) +set( CMAKE_CXX_COMPILER_ABI ELF ) +# force ASM compiler (required for CMake < 2.8.5) +set( CMAKE_ASM_COMPILER_ID_RUN TRUE ) +set( CMAKE_ASM_COMPILER_ID GNU ) +set( CMAKE_ASM_COMPILER_WORKS TRUE ) +set( CMAKE_ASM_COMPILER_FORCED TRUE ) +set( CMAKE_COMPILER_IS_GNUASM 1) + +# NDK flags +if( ARMEABI OR ARMEABI_V7A ) + # NDK also defines -ffunction-sections -funwind-tables but they result in worse OpenCV performance + set( _CMAKE_CXX_FLAGS "-fPIC -Wno-psabi" ) + set( _CMAKE_C_FLAGS "-fPIC -Wno-psabi" ) + remove_definitions( -D__ARM_ARCH_5__ -D__ARM_ARCH_5T__ -D__ARM_ARCH_5E__ -D__ARM_ARCH_5TE__ ) + add_definitions( -D__ARM_ARCH_5__ -D__ARM_ARCH_5T__ -D__ARM_ARCH_5E__ -D__ARM_ARCH_5TE__ ) + # extra arm-specific flags + set( ANDROID_CXX_FLAGS "${ANDROID_CXX_FLAGS} -fsigned-char" ) +elseif( X86 ) + set( _CMAKE_CXX_FLAGS "-funwind-tables" ) + set( _CMAKE_C_FLAGS "-funwind-tables" ) +elseif( MIPS ) + set( _CMAKE_CXX_FLAGS "-fpic -Wno-psabi -fno-strict-aliasing -finline-functions -ffunction-sections -funwind-tables -fmessage-length=0 -fno-inline-functions-called-once -fgcse-after-reload -frerun-cse-after-loop -frename-registers" ) + set( _CMAKE_CXX_FLAGS "-fpic -Wno-psabi -fno-strict-aliasing -finline-functions -ffunction-sections -funwind-tables -fmessage-length=0 -fno-inline-functions-called-once -fgcse-after-reload -frerun-cse-after-loop -frename-registers" ) + set( ANDROID_CXX_FLAGS "${ANDROID_CXX_FLAGS} -fsigned-char" ) +else() + set( _CMAKE_CXX_FLAGS "" ) + set( _CMAKE_C_FLAGS "" ) +endif() + +if( ANDROID_USE_STLPORT ) + set( _CMAKE_CXX_FLAGS "${_CMAKE_CXX_FLAGS} -fno-rtti -fno-exceptions" ) + set( _CMAKE_C_FLAGS "${_CMAKE_C_FLAGS} -fno-exceptions" ) +else() + set( _CMAKE_CXX_FLAGS "${_CMAKE_CXX_FLAGS} -frtti -fexceptions" ) + set( _CMAKE_C_FLAGS "${_CMAKE_C_FLAGS} -fexceptions" ) +endif() + +# release and debug flags +if( ARMEABI OR ARMEABI_V7A ) + if( NOT ANDROID_FORCE_ARM_BUILD AND NOT ARMEABI_V6 ) + # It is recommended to use the -mthumb compiler flag to force the generation + # of 16-bit Thumb-1 instructions (the default being 32-bit ARM ones). + # O3 instead of O2/Os in release mode - like cmake sets for desktop gcc + set( _CMAKE_CXX_FLAGS_RELEASE "-mthumb -O3" ) + set( _CMAKE_C_FLAGS_RELEASE "-mthumb -O3" ) + set( _CMAKE_CXX_FLAGS_DEBUG "-marm -Os -finline-limit=64" ) + set( _CMAKE_C_FLAGS_DEBUG "-marm -Os -finline-limit=64" ) + else() + # always compile ARMEABI_V6 in arm mode; otherwise there is no difference from ARMEABI + # O3 instead of O2/Os in release mode - like cmake sets for desktop gcc + set( _CMAKE_CXX_FLAGS_RELEASE "-marm -O3 -fstrict-aliasing" ) + set( _CMAKE_C_FLAGS_RELEASE "-marm -O3 -fstrict-aliasing" ) + set( _CMAKE_CXX_FLAGS_DEBUG "-marm -O0 -finline-limit=300" ) + set( _CMAKE_C_FLAGS_DEBUG "-marm -O0 -finline-limit=300" ) + endif() +elseif( X86 ) + set( _CMAKE_CXX_FLAGS_RELEASE "-O3 -fstrict-aliasing" ) + set( _CMAKE_C_FLAGS_RELEASE "-O3 -fstrict-aliasing" ) + set( _CMAKE_CXX_FLAGS_DEBUG "-O0 -finline-limit=300" ) + set( _CMAKE_C_FLAGS_DEBUG "-O0 -finline-limit=300" ) +elseif( MIPS ) + set( _CMAKE_CXX_FLAGS_RELEASE "-O3 -funswitch-loops -finline-limit=300" ) + set( _CMAKE_C_FLAGS_RELEASE "-O3 -funswitch-loops -finline-limit=300" ) + set( _CMAKE_CXX_FLAGS_DEBUG "-O0 -g" ) + set( _CMAKE_C_FLAGS_DEBUG "-O0 -g" ) +endif() +set( _CMAKE_CXX_FLAGS_RELEASE "${_CMAKE_CXX_FLAGS_RELEASE} -fomit-frame-pointer -DNDEBUG" ) +set( _CMAKE_C_FLAGS_RELEASE "${_CMAKE_C_FLAGS_RELEASE} -fomit-frame-pointer -DNDEBUG" ) +set( _CMAKE_CXX_FLAGS_DEBUG "${_CMAKE_CXX_FLAGS_DEBUG} -fno-strict-aliasing -fno-omit-frame-pointer -DDEBUG -D_DEBUG" ) +set( _CMAKE_C_FLAGS_DEBUG "${_CMAKE_C_FLAGS_DEBUG} -fno-strict-aliasing -fno-omit-frame-pointer -DDEBUG -D_DEBUG" ) + +# ABI-specific flags +if( ARMEABI_V7A ) + set( ANDROID_CXX_FLAGS "${ANDROID_CXX_FLAGS} -march=armv7-a -mfloat-abi=softfp" ) + if( NEON ) + set( ANDROID_CXX_FLAGS "${ANDROID_CXX_FLAGS} -mfpu=neon" ) + elseif( VFPV3 ) + set( ANDROID_CXX_FLAGS "${ANDROID_CXX_FLAGS} -mfpu=vfpv3" ) + else() + set( ANDROID_CXX_FLAGS "${ANDROID_CXX_FLAGS} -mfpu=vfp" ) + endif() +elseif( ARMEABI_V6 ) + set( ANDROID_CXX_FLAGS "${ANDROID_CXX_FLAGS} -march=armv6 -mfloat-abi=softfp -mfpu=vfp" ) +elseif( ARMEABI ) + set( ANDROID_CXX_FLAGS "${ANDROID_CXX_FLAGS} -march=armv5te -mtune=xscale -msoft-float" ) +elseif( X86 ) + set( ANDROID_CXX_FLAGS "${ANDROID_CXX_FLAGS}" )#sse? +endif() + +# linker flags +if( NOT DEFINED __ndklibspath ) + set( __ndklibspath "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/ndklibs/${ANDROID_NDK_ABI_NAME}" ) +endif() +list( APPEND ANDROID_SYSTEM_LIB_DIRS "${CMAKE_INSTALL_PREFIX}/libs/${ANDROID_NDK_ABI_NAME}" ) +set( ANDROID_LINKER_FLAGS "" ) + +# STL +if( ANDROID_USE_STLPORT ) + if( EXISTS "${__stlLibPath}/libstlport_static.a" ) + set( CMAKE_CXX_CREATE_SHARED_LIBRARY " -o \"${__stlLibPath}/libstlport_static.a\"") + set( CMAKE_CXX_CREATE_SHARED_MODULE " -o \"${__stlLibPath}/libstlport_static.a\"") + endif() +else( ANDROID_USE_STLPORT ) + if( EXISTS "${__stlLibPath}/libgnustl_static.a" ) + __COPY_IF_DIFFERENT( "${__stlLibPath}/libgnustl_static.a" "${__ndklibspath}/libstdc++.a" ) + elseif( ANDROID_ARCH_NAME STREQUAL "arm" AND EXISTS "${__stlLibPath}/${CMAKE_SYSTEM_PROCESSOR}/thumb/libstdc++.a" ) + __COPY_IF_DIFFERENT( "${__stlLibPath}/${CMAKE_SYSTEM_PROCESSOR}/thumb/libstdc++.a" "${__ndklibspath}/libstdc++.a" ) + elseif( ANDROID_ARCH_NAME STREQUAL "arm" AND EXISTS "${__stlLibPath}/${CMAKE_SYSTEM_PROCESSOR}/libstdc++.a" ) + __COPY_IF_DIFFERENT( "${__stlLibPath}/${CMAKE_SYSTEM_PROCESSOR}/libstdc++.a" "${__ndklibspath}/libstdc++.a" ) + elseif( ANDROID_ARCH_NAME STREQUAL "arm" AND EXISTS "${__stlLibPath}/thumb/libstdc++.a" ) + __COPY_IF_DIFFERENT( "${__stlLibPath}/thumb/libstdc++.a" "${__ndklibspath}/libstdc++.a" ) + elseif( EXISTS "${__stlLibPath}/libstdc++.a" ) + __COPY_IF_DIFFERENT( "${__stlLibPath}/libstdc++.a" "${__ndklibspath}/libstdc++.a" ) + endif() + if( EXISTS "${__stlLibPath}/libsupc++.a" ) + __COPY_IF_DIFFERENT( "${__stlLibPath}/libsupc++.a" "${__ndklibspath}/libsupc++.a" ) + elseif( ANDROID_ARCH_NAME STREQUAL "arm" AND EXISTS "${ANDROID_TOOLCHAIN_ROOT}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib/${CMAKE_SYSTEM_PROCESSOR}/thumb/libsupc++.a" ) + __COPY_IF_DIFFERENT( "${ANDROID_TOOLCHAIN_ROOT}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib/${CMAKE_SYSTEM_PROCESSOR}/thumb/libsupc++.a" "${__ndklibspath}/libsupc++.a" ) + elseif( ANDROID_ARCH_NAME STREQUAL "arm" AND EXISTS "${ANDROID_TOOLCHAIN_ROOT}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib/${CMAKE_SYSTEM_PROCESSOR}/libsupc++.a" ) + __COPY_IF_DIFFERENT( "${ANDROID_TOOLCHAIN_ROOT}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib/${CMAKE_SYSTEM_PROCESSOR}/libsupc++.a" "${__ndklibspath}/libsupc++.a" ) + elseif( ANDROID_ARCH_NAME STREQUAL "arm" AND EXISTS "${ANDROID_TOOLCHAIN_ROOT}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib/thumb/libsupc++.a" ) + __COPY_IF_DIFFERENT( "${ANDROID_TOOLCHAIN_ROOT}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib/thumb/libsupc++.a" "${__ndklibspath}/libsupc++.a" ) + elseif( EXISTS "${ANDROID_TOOLCHAIN_ROOT}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib/libsupc++.a" ) + __COPY_IF_DIFFERENT( "${ANDROID_TOOLCHAIN_ROOT}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib/libsupc++.a" "${__ndklibspath}/libsupc++.a" ) + endif() + list( APPEND ANDROID_SYSTEM_LIB_DIRS "${__ndklibspath}" ) +endif( ANDROID_USE_STLPORT ) + +# cleanup for STL search +unset( __stlIncludePath ) +unset( __stlLibPath ) + +# other linker flags +__INIT_VARIABLE( ANDROID_NO_UNDEFINED OBSOLETE_NO_UNDEFINED VALUES ON ) +set( ANDROID_NO_UNDEFINED ${ANDROID_NO_UNDEFINED} CACHE BOOL "Show all undefined symbols as linker errors" FORCE ) +mark_as_advanced( ANDROID_NO_UNDEFINED ) +if( ANDROID_NO_UNDEFINED ) + set( ANDROID_LINKER_FLAGS "-Wl,--no-undefined ${ANDROID_LINKER_FLAGS}" ) +endif() + +if (ANDROID_NDK MATCHES "-r[56].?$") + # libGLESv2.so in NDK's prior to r7 refers to exteranal symbols. So this flag option is required for all projects using OpenGL from native. + __INIT_VARIABLE( ANDROID_SO_UNDEFINED VALUES ON ) +else() + __INIT_VARIABLE( ANDROID_SO_UNDEFINED VALUES OFF ) +endif() + +set( ANDROID_SO_UNDEFINED ${ANDROID_SO_UNDEFINED} CACHE BOOL "Allows or disallows undefined symbols in shared libraries" FORCE ) +mark_as_advanced( ANDROID_SO_UNDEFINED ) +if( ANDROID_SO_UNDEFINED ) + set( ANDROID_LINKER_FLAGS "${ANDROID_LINKER_FLAGS} -Wl,-allow-shlib-undefined" ) +endif() + +__INIT_VARIABLE( ANDROID_FUNCTION_LEVEL_LINKING VALUES ON ) +set( ANDROID_FUNCTION_LEVEL_LINKING ON CACHE BOOL "Allows or disallows undefined symbols in shared libraries" FORCE ) +mark_as_advanced( ANDROID_FUNCTION_LEVEL_LINKING ) +if( ANDROID_FUNCTION_LEVEL_LINKING ) + set( ANDROID_CXX_FLAGS "${ANDROID_CXX_FLAGS} -fdata-sections -ffunction-sections" ) + set( ANDROID_LINKER_FLAGS "-Wl,--gc-sections ${ANDROID_LINKER_FLAGS}" ) +endif() + +if( ARMEABI_V7A ) + # this is *required* to use the following linker flags that routes around + # a CPU bug in some Cortex-A8 implementations: + set( ANDROID_LINKER_FLAGS "-Wl,--fix-cortex-a8 ${ANDROID_LINKER_FLAGS}" ) +endif() + +# cache flags +set( CMAKE_CXX_FLAGS "${_CMAKE_CXX_FLAGS}" CACHE STRING "c++ flags" ) +set( CMAKE_C_FLAGS "${_CMAKE_C_FLAGS}" CACHE STRING "c flags" ) +set( CMAKE_CXX_FLAGS_RELEASE "${_CMAKE_CXX_FLAGS_RELEASE}" CACHE STRING "c++ Release flags" ) +set( CMAKE_C_FLAGS_RELEASE "${_CMAKE_C_FLAGS_RELEASE}" CACHE STRING "c Release flags" ) +set( CMAKE_CXX_FLAGS_DEBUG "${_CMAKE_CXX_FLAGS_DEBUG}" CACHE STRING "c++ Debug flags" ) +set( CMAKE_C_FLAGS_DEBUG "${_CMAKE_C_FLAGS_DEBUG}" CACHE STRING "c Debug flags" ) +set( CMAKE_SHARED_LINKER_FLAGS "" CACHE STRING "linker flags" ) +set( CMAKE_MODULE_LINKER_FLAGS "" CACHE STRING "linker flags" ) +set( CMAKE_EXE_LINKER_FLAGS "-Wl,-z,nocopyreloc" CACHE STRING "linker flags" ) + +include_directories( SYSTEM ${ANDROID_SYSTEM_INCLUDE_DIRS} ) +link_directories( ${ANDROID_SYSTEM_LIB_DIRS} ) + +# finish flags +set( ANDROID_CXX_FLAGS "${ANDROID_CXX_FLAGS}" CACHE INTERNAL "Extra Android compiler flags") +set( ANDROID_LINKER_FLAGS "${ANDROID_LINKER_FLAGS}" CACHE INTERNAL "Extra Android linker flags") +set( CMAKE_CXX_FLAGS "${ANDROID_CXX_FLAGS} ${CMAKE_CXX_FLAGS}" ) +set( CMAKE_C_FLAGS "${ANDROID_CXX_FLAGS} ${CMAKE_C_FLAGS}" ) +if( MIPS AND BUILD_WITH_ANDROID_NDK ) + set( CMAKE_SHARED_LINKER_FLAGS "-Wl,-T,${ANDROID_NDK}/toolchains/${ANDROID_TOOLCHAIN_NAME}/mipself.xsc ${ANDROID_LINKER_FLAGS} ${CMAKE_SHARED_LINKER_FLAGS}" ) + set( CMAKE_MODULE_LINKER_FLAGS "-Wl,-T,${ANDROID_NDK}/toolchains/${ANDROID_TOOLCHAIN_NAME}/mipself.xsc ${ANDROID_LINKER_FLAGS} ${CMAKE_MODULE_LINKER_FLAGS}" ) + set( CMAKE_EXE_LINKER_FLAGS "-Wl,-T,${ANDROID_NDK}/toolchains/${ANDROID_TOOLCHAIN_NAME}/mipself.x ${ANDROID_LINKER_FLAGS} ${CMAKE_EXE_LINKER_FLAGS}" ) +else() + set( CMAKE_SHARED_LINKER_FLAGS "${ANDROID_LINKER_FLAGS} ${CMAKE_SHARED_LINKER_FLAGS}" ) + set( CMAKE_MODULE_LINKER_FLAGS "${ANDROID_LINKER_FLAGS} ${CMAKE_MODULE_LINKER_FLAGS}" ) + set( CMAKE_EXE_LINKER_FLAGS "${ANDROID_LINKER_FLAGS} ${CMAKE_EXE_LINKER_FLAGS}" ) +endif() + +# set these global flags for cmake client scripts to change behavior +set( ANDROID True ) +set( BUILD_ANDROID True ) + +# where is the target environment +set( CMAKE_FIND_ROOT_PATH "${ANDROID_TOOLCHAIN_ROOT}/bin" "${ANDROID_TOOLCHAIN_ROOT}/${ANDROID_TOOLCHAIN_MACHINE_NAME}" "${ANDROID_SYSROOT}" "${CMAKE_INSTALL_PREFIX}" "${CMAKE_INSTALL_PREFIX}/share" ) + +# only search for libraries and includes in the ndk toolchain +set( CMAKE_FIND_ROOT_PATH_MODE_PROGRAM ONLY ) +set( CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY ) +set( CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY ) + + +# macro to find packages on the host OS +macro( find_host_package ) + set( CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER ) + set( CMAKE_FIND_ROOT_PATH_MODE_LIBRARY NEVER ) + set( CMAKE_FIND_ROOT_PATH_MODE_INCLUDE NEVER ) + if( CMAKE_HOST_WIN32 ) + SET( WIN32 1 ) + SET( UNIX ) + elseif( CMAKE_HOST_APPLE ) + SET( APPLE 1 ) + SET( UNIX ) + endif() + find_package( ${ARGN} ) + SET( WIN32 ) + SET( APPLE ) + SET( UNIX 1 ) + set( CMAKE_FIND_ROOT_PATH_MODE_PROGRAM ONLY ) + set( CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY ) + set( CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY ) +endmacro() + + +# macro to find programs on the host OS +macro( find_host_program ) + set( CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER ) + set( CMAKE_FIND_ROOT_PATH_MODE_LIBRARY NEVER ) + set( CMAKE_FIND_ROOT_PATH_MODE_INCLUDE NEVER ) + if( CMAKE_HOST_WIN32 ) + SET( WIN32 1 ) + SET( UNIX ) + elseif( CMAKE_HOST_APPLE ) + SET( APPLE 1 ) + SET( UNIX ) + endif() + find_program( ${ARGN} ) + SET( WIN32 ) + SET( APPLE ) + SET( UNIX 1 ) + set( CMAKE_FIND_ROOT_PATH_MODE_PROGRAM ONLY ) + set( CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY ) + set( CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY ) +endmacro() + + +macro( ANDROID_GET_ABI_RAWNAME TOOLCHAIN_FLAG VAR ) + if( "${TOOLCHAIN_FLAG}" STREQUAL "ARMEABI" ) + set( ${VAR} "armeabi" ) + elseif( "${TOOLCHAIN_FLAG}" STREQUAL "ARMEABI_V7A" ) + set( ${VAR} "armeabi-v7a" ) + elseif( "${TOOLCHAIN_FLAG}" STREQUAL "X86" ) + set( ${VAR} "x86" ) + else() + set( ${VAR} "unknown" ) + endif() +endmacro() + + +# export toolchain settings for the try_compile() command +if( NOT PROJECT_NAME STREQUAL "CMAKE_TRY_COMPILE" ) + set( __toolchain_config "") + foreach( __var ANDROID_ABI ANDROID_FORCE_ARM_BUILD ANDROID_NATIVE_API_LEVEL ANDROID_NO_UNDEFINED ANDROID_SO_UNDEFINED ANDROID_SET_OBSOLETE_VARIABLES LIBRARY_OUTPUT_PATH_ROOT ANDROID_USE_STLPORT ANDROID_FORBID_SYGWIN ANDROID_NDK ANDROID_STANDALONE_TOOLCHAIN ANDROID_FUNCTION_LEVEL_LINKING __ndklibspath ) + if( DEFINED ${__var} ) + if( "${__var}" MATCHES " ") + set( __toolchain_config "${__toolchain_config}set( ${__var} \"${${__var}}\" CACHE INTERNAL \"\" )\n" ) + else() + set( __toolchain_config "${__toolchain_config}set( ${__var} ${${__var}} CACHE INTERNAL \"\" )\n" ) + endif() + endif() + endforeach() + file( WRITE "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/android.toolchain.config.cmake" "${__toolchain_config}" ) + unset( __toolchain_config ) + unset( __ndklibspath ) +endif() + + +# set some obsolete variables for backward compatibility +set( ANDROID_SET_OBSOLETE_VARIABLES ON CACHE BOOL "Define obsolete Andrid-specific cmake variables" ) +mark_as_advanced( ANDROID_SET_OBSOLETE_VARIABLES ) +if( ANDROID_SET_OBSOLETE_VARIABLES ) + set( ANDROID_API_LEVEL ${ANDROID_NATIVE_API_LEVEL} ) + set( ARM_TARGET "${ANDROID_ABI}" ) + set( ARMEABI_NDK_NAME "${ANDROID_NDK_ABI_NAME}" ) +endif() + + +# Variables controlling behavior or set by cmake toolchain: +# ANDROID_ABI : "armeabi-v7a" (default), "armeabi", "armeabi-v7a with NEON", "armeabi-v7a with VFPV3", "armeabi-v6 with VFP", "x86", "mips" +# ANDROID_NATIVE_API_LEVEL : 3,4,5,8,9,14 (depends on NDK version) +# ANDROID_SET_OBSOLETE_VARIABLES : ON/OFF +# ANDROID_USE_STLPORT : OFF/ON - EXPERIMENTAL!!! +# ANDROID_FORBID_SYGWIN : ON/OFF +# ANDROID_NO_UNDEFINED : ON/OFF +# ANDROID_SO_UNDEFINED : OFF/ON (default depends on NDK version) +# ANDROID_FUNCTION_LEVEL_LINKING : ON/OFF +# Variables that takes effect only at first run: +# ANDROID_FORCE_ARM_BUILD : ON/OFF +# LIBRARY_OUTPUT_PATH_ROOT : +# Can be set only at the first run: +# ANDROID_NDK +# ANDROID_STANDALONE_TOOLCHAIN +# ANDROID_TOOLCHAIN_NAME : "arm-linux-androideabi-4.4.3" or "arm-linux-androideabi-4.6" or "mipsel-linux-android-4.4.3" or "mipsel-linux-android-4.6" or "x86-4.4.3" or "x86-4.6" +# Obsolete: +# ANDROID_API_LEVEL : superseded by ANDROID_NATIVE_API_LEVEL +# ARM_TARGET : superseded by ANDROID_ABI +# ARM_TARGETS : superseded by ANDROID_ABI (can be set only) +# ANDROID_NDK_TOOLCHAIN_ROOT : superseded by ANDROID_STANDALONE_TOOLCHAIN (can be set only) +# ANDROID_LEVEL : superseded by ANDROID_NATIVE_API_LEVEL (completely removed) +# +# Primary read-only variables: +# ANDROID : always TRUE +# ARMEABI : TRUE for arm v6 and older devices +# ARMEABI_V6 : TRUE for arm v6 +# ARMEABI_V7A : TRUE for arm v7a +# NEON : TRUE if NEON unit is enabled +# VFPV3 : TRUE if VFP version 3 is enabled +# X86 : TRUE if configured for x86 +# BUILD_ANDROID : always TRUE +# BUILD_WITH_ANDROID_NDK : TRUE if NDK is used +# BUILD_WITH_STANDALONE_TOOLCHAIN : TRUE if standalone toolchain is used +# ANDROID_NDK_HOST_SYSTEM_NAME : "windows", "linux-x86" or "darwin-x86" depending on host platform +# ANDROID_NDK_ABI_NAME : "armeabi", "armeabi-v7a" or "x86" depending on ANDROID_ABI +# ANDROID_ARCH_NAME : "arm" or "x86" or "mips" depending on ANDROID_ABI +# TOOL_OS_SUFFIX : "" or ".exe" depending on host platform +# ANDROID_SYSROOT : path to the compiler sysroot +# ANDROID_SYSTEM_INCLUDE_DIRS +# ANDROID_SYSTEM_LIB_DIRS +# Obsolete: +# ARMEABI_NDK_NAME : superseded by ANDROID_NDK_ABI_NAME +# +# Secondary (less stable) read-only variables: +# ANDROID_COMPILER_VERSION : GCC version used +# ANDROID_CXX_FLAGS : C/C++ compiler flags required by Android platform +# ANDROID_SUPPORTED_ABIS : list of currently allowed values for ANDROID_ABI +# ANDROID_TOOLCHAIN_MACHINE_NAME : "arm-linux-androideabi", "arm-eabi" or "i686-android-linux" +# ANDROID_TOOLCHAIN_ROOT : path to the top level of toolchain (standalone or placed inside NDK) +# ANDROID_SUPPORTED_NATIVE_API_LEVELS : list of native API levels found inside NDK +# +# Defaults: +# ANDROID_DEFAULT_NDK_API_LEVEL +# ANDROID_DEFAULT_NDK_API_LEVEL_${ARCH} +# ANDROID_NDK_SEARCH_PATHS +# ANDROID_STANDALONE_TOOLCHAIN_SEARCH_PATH +# ANDROID_SUPPORTED_ABIS_${ARCH} +# ANDROID_SUPPORTED_NDK_VERSIONS diff --git a/Source/Android/assets/ButtonA.png b/Source/Android/assets/ButtonA.png new file mode 100644 index 0000000000000000000000000000000000000000..7e685324ae8a4ad016eb1033d64b659966cfcd0c GIT binary patch literal 5178 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 literal 0 HcmV?d00001 diff --git a/Source/Android/assets/ButtonB.png b/Source/Android/assets/ButtonB.png new file mode 100644 index 0000000000000000000000000000000000000000..21da4c20f123fe6409b57cc6d837fd0f60786098 GIT binary patch literal 4971 zcmV-x6O`Px#1ZP1_K>z@;j|==^1poj532;bRa{vGi!vFvd!vV){sAK>D02*{fSaefwW^{L9 za%BKeVQFr3E>1;MAa*k@H7+qQF!XYv000u&Nkl#ha<5{UH9txuIOkZs809n`&%Ts0+5dL7Mp+hx=8#iZN56lus~=G z^GCTaaPJYVwOL@?*!;U~#ueG%;YhSLCE<7mhNB0Na5}l)^@HUA@@`!uHsv#ADq?zo zpYg=zwNdDhX!8d-c_aTCE$TUE&YT=*_Uzdn@p|suxjFOZ>sC!i70?@py>=vnsf* zABcEaGs-XfrT!6#bQYs~VAgKTFnuJ!bnJ?0)28K2ojNsV%9JU&(B#RJ)5w0N`*OK| z`t<2JGiT1ssjRH@!1;S5@3b(JN@!YiKc8p6`(ykD&dIg$6ywpV4`Zf9vFvPwk$;b-RBzM@e$?6 z$Wr6Kj#sx*H;kk5H85_N&9zL99XmEUX3Ut_op;_D8$EiorMO5+{3x7k%M;3nl;MCf)`3~PTphN*gfO?uFFfb?2Oo%oz0URm<_{0chZ(StP zy7A)7;!Z-5eOQ9|=>GQ#3c47zMPf055Qn6~`Fg)VYF()Ji^Krb0@CNj4)MQ7+@pI7 z#dtm>AoE0Vv_hZ9&?>Fx0ipFh-vYDFzD(4K);2o`R`S-nqw;^~(4k11VN)^LYMvyM zuZ)J|mf>gJyuI(hX_Ilj`(*GUpYu(#k%(N4=m6L3(|4-05#k#i8`h}8u zfdSTnU`@l*24pB09UW`tTteFdVUU+03lu$0AWuS z3Lbu|@%COl)MI>*T7o)|Z6GZLgu{+M6KfjBpyQr7wWYKAh7A-nm)K{_o3~0fE z1(rUi|N97(Q$;5Uuu@$CtVBR|1WY{#ZE7J<3Z*Iem>W*gm_!b~0S+8tc|L)t(PR+n zBKf6(P`B^H7A*?plyG=aZ6uEkX@fA|T8wuPQzc^dL{aa>ix;0JIzx2!k|j&d6I~#> z=>|;HqW+?D1jOe>eF02B^kyxzh_$5|ZO|}*Q6y8zM-xmqWj{Fr z!+;P~0)=CYAN?>A`-t;MlR&UZj!~<333GBto~P&G*gR4}@`ib&UMdhyg>f->ju^gB z%wD!^*|IN+1}tB`{94f<(U(Qnnb!k#&o%n|N`2>2z9TwE+Hxj9XuVznqbr)FXSD?c zfX5sp3_@qFt~qj&9st-r2~sLSiyp|@A0$%IR6hQ`vN}B|N8UMCL~M^s64*U9-ww%( zdLngg{46o>1;aQ@Uw`kt_ug{PJ@*XOb;!zeo7h^qzSB?97He1`#{o6&^U))Y*l%WeWx;F}hfb8oVs5k;o^b#D_fKE5X3cET{IzS>E)*@& z>qWfQbzW6fRi*Bkrh5To3_wUDZqZtp$7T2sqY1tBtS&fP0nm~VNmj|eBp?q2mr4I& zDq7Vj0D@n#($_Z@WH#+ zuV24PR3%!sVZ(+8MC}JzzH;5Vb<1?`0s%5ZU`!AYBL(8^_zgh7r(j}e8_y-j zAkhKR$)1%j|TsiBx z8*chZHUPNyzS*_=zaCw%P)f9VlFVU*wCX0Uf0dqdzCh?hcqCaOV-(~04geu$5G!{g z!v2hAkO&{Kx)cD3_-XAQ^%wITZ1VM9vCwZ%7AJ}Hm3m$z=?_BslH7PCh+4nhwfnz= zAZ*>b^}E})ZTp_C-{1b&V?TId(c)Kse`4v!!TVnB+wTLJ&@6#aE)c$IOaU!8QyS1y z8qiT*zm)(eU|;MHL9t(#NmI8-Mud#@1Hbx557UQO-;>Dw{PG6Gw8`DpZuxlN4u&w?tiak z8!vlv>9N^!)?*3+pp5l-juNG_$rz;pC7d0knH~UWr(P4LeE^sY(JS24n;rTO6e*9% zf-DRG!-o%#iwb0G#Nkc?fNTx>$NAkV0LI9P&64!**|>4zrngIbrvdQPQ&0Uu^opTh z?AWp6B|v%YimUz+1Ylc5#a012Lk{sy!XpV45rMQ>;kS!Spp7J6WRBV%0AYS0a83w6 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 + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Source/Android/custom_rules.xml b/Source/Android/custom_rules.xml new file mode 100644 index 000000000000..3c6d5b53ba0c --- /dev/null +++ b/Source/Android/custom_rules.xml @@ -0,0 +1,16 @@ + + + + + + + + + + + + + + + + diff --git a/Source/Android/jni/Android.mk b/Source/Android/jni/Android.mk new file mode 100644 index 000000000000..68366e380cb4 --- /dev/null +++ b/Source/Android/jni/Android.mk @@ -0,0 +1,189 @@ +LOCAL_PATH := $(call my-dir) + +# BEGIN Native Audio Separate Library - copy paste this section to your Android.mk + +include $(CLEAR_VARS) + +LOCAL_MODULE := native_audio +LOCAL_CFLAGS := -O2 -fsigned-char -ffast-math -Wall -Wno-multichar -Wno-psabi -std=gnu++0x +NATIVE := ../../native +LOCAL_SRC_FILES := \ + $(NATIVE)/android/native-audio-so.cpp +LOCAL_LDLIBS := -lOpenSLES -llog + +include $(BUILD_SHARED_LIBRARY) + +# END Native Audio Separate Library - copy paste this section to your Android.mk + +include $(CLEAR_VARS) + +#TARGET_PLATFORM := android-8 + +LOCAL_MODULE := ppsspp_jni + +NATIVE := ../../native +SRC := ../.. + +LOCAL_CFLAGS := -DUSE_PROFILER -DARM -DGL_GLEXT_PROTOTYPES -DUSING_GLES2 -O2 -fsigned-char -Wall -Wno-multichar -Wno-psabi -Wno-unused-variable -fno-strict-aliasing -ffast-math +LOCAL_CXXFLAGS := -std=gnu++0x +LOCAL_C_INCLUDES := \ + $(LOCAL_PATH)/../../Common \ + $(LOCAL_PATH)/../.. \ + $(LOCAL_PATH)/$(NATIVE)/base \ + $(LOCAL_PATH)/$(NATIVE)/ext/libzip \ + $(LOCAL_PATH)/$(NATIVE) \ + $(LOCAL_PATH) \ + +LOCAL_STATIC_LIBRARIES := native libzip +LOCAL_LDLIBS := -lz -lGLESv2 -ldl -llog + + +# $(SRC)/Core/EmuThread.cpp \ + +LOCAL_SRC_FILES := \ + NativeApp.cpp \ + EmuScreen.cpp \ + MenuScreens.cpp \ + UIShader.cpp \ + GamepadEmu.cpp \ + ArmEmitterTest.cpp \ + ui_atlas.cpp \ + $(SRC)/native/android/app-android.cpp \ + $(SRC)/ext/disarm.cpp \ + $(SRC)/ext/libkirk/AES.c \ + $(SRC)/ext/libkirk/SHA1.c \ + $(SRC)/ext/libkirk/bn.c \ + $(SRC)/ext/libkirk/ec.c \ + $(SRC)/ext/libkirk/kirk_engine.c \ + $(SRC)/ext/snappy/snappy-c.cpp \ + $(SRC)/ext/snappy/snappy.cpp \ + $(SRC)/Common/ArmEmitter.cpp \ + $(SRC)/Common/ArmCPUDetect.cpp \ + $(SRC)/Common/ArmThunk.cpp \ + $(SRC)/Common/LogManager.cpp \ + $(SRC)/Common/MemArena.cpp \ + $(SRC)/Common/MemoryUtil.cpp \ + $(SRC)/Common/MsgHandler.cpp \ + $(SRC)/Common/IniFile.cpp \ + $(SRC)/Common/FileUtil.cpp \ + $(SRC)/Common/StringUtil.cpp \ + $(SRC)/Common/Thread.cpp \ + $(SRC)/Common/Timer.cpp \ + $(SRC)/Common/Misc.cpp \ + $(SRC)/Common/MathUtil.cpp \ + $(SRC)/GPU/Math3D.cpp \ + $(SRC)/GPU/GPUCommon.cpp \ + $(SRC)/GPU/GPUState.cpp \ + $(SRC)/GPU/GeDisasm.cpp \ + $(SRC)/GPU/GLES/Framebuffer.cpp \ + $(SRC)/GPU/GLES/DisplayListInterpreter.cpp \ + $(SRC)/GPU/GLES/TextureCache.cpp \ + $(SRC)/GPU/GLES/IndexGenerator.cpp \ + $(SRC)/GPU/GLES/TransformPipeline.cpp \ + $(SRC)/GPU/GLES/StateMapping.cpp \ + $(SRC)/GPU/GLES/VertexDecoder.cpp \ + $(SRC)/GPU/GLES/ShaderManager.cpp \ + $(SRC)/GPU/GLES/VertexShaderGenerator.cpp \ + $(SRC)/GPU/GLES/FragmentShaderGenerator.cpp \ + $(SRC)/GPU/Null/NullGpu.cpp \ + $(SRC)/Core/ELF/ElfReader.cpp \ + $(SRC)/Core/ELF/PrxDecrypter.cpp \ + $(SRC)/Core/ELF/ParamSFO.cpp \ + $(SRC)/Core/HW/MemoryStick.cpp \ + $(SRC)/Core/HW/MediaEngine.cpp \ + $(SRC)/Core/HW/SasAudio.cpp \ + $(SRC)/Core/Core.cpp \ + $(SRC)/Core/Config.cpp \ + $(SRC)/Core/CoreTiming.cpp \ + $(SRC)/Core/CPU.cpp \ + $(SRC)/Core/Host.cpp \ + $(SRC)/Core/Loaders.cpp \ + $(SRC)/Core/PSPLoaders.cpp \ + $(SRC)/Core/MemMap.cpp \ + $(SRC)/Core/MemMapFunctions.cpp \ + $(SRC)/Core/SaveState.cpp \ + $(SRC)/Core/System.cpp \ + $(SRC)/Core/PSPMixer.cpp \ + $(SRC)/Core/Debugger/Breakpoints.cpp \ + $(SRC)/Core/Debugger/SymbolMap.cpp \ + $(SRC)/Core/Dialog/PSPDialog.cpp \ + $(SRC)/Core/Dialog/PSPMsgDialog.cpp \ + $(SRC)/Core/Dialog/PSPOskDialog.cpp \ + $(SRC)/Core/Dialog/PSPPlaceholderDialog.cpp \ + $(SRC)/Core/Dialog/PSPSaveDialog.cpp \ + $(SRC)/Core/Dialog/SavedataParam.cpp \ + $(SRC)/Core/HLE/HLETables.cpp \ + $(SRC)/Core/HLE/HLE.cpp \ + $(SRC)/Core/HLE/sceAtrac.cpp \ + $(SRC)/Core/HLE/__sceAudio.cpp \ + $(SRC)/Core/HLE/sceAudio.cpp \ + $(SRC)/Core/HLE/sceCtrl.cpp \ + $(SRC)/Core/HLE/sceDisplay.cpp \ + $(SRC)/Core/HLE/sceDmac.cpp \ + $(SRC)/Core/HLE/sceGe.cpp \ + $(SRC)/Core/HLE/sceFont.cpp \ + $(SRC)/Core/HLE/sceHprm.cpp \ + $(SRC)/Core/HLE/sceHttp.cpp \ + $(SRC)/Core/HLE/sceImpose.cpp \ + $(SRC)/Core/HLE/sceIo.cpp \ + $(SRC)/Core/HLE/sceKernel.cpp \ + $(SRC)/Core/HLE/sceKernelAlarm.cpp \ + $(SRC)/Core/HLE/sceKernelEventFlag.cpp \ + $(SRC)/Core/HLE/sceKernelInterrupt.cpp \ + $(SRC)/Core/HLE/sceKernelMemory.cpp \ + $(SRC)/Core/HLE/sceKernelModule.cpp \ + $(SRC)/Core/HLE/sceKernelMutex.cpp \ + $(SRC)/Core/HLE/sceKernelMbx.cpp \ + $(SRC)/Core/HLE/sceKernelMsgPipe.cpp \ + $(SRC)/Core/HLE/sceKernelSemaphore.cpp \ + $(SRC)/Core/HLE/sceKernelThread.cpp \ + $(SRC)/Core/HLE/sceKernelTime.cpp \ + $(SRC)/Core/HLE/sceKernelVTimer.cpp \ + $(SRC)/Core/HLE/sceMpeg.cpp \ + $(SRC)/Core/HLE/sceNet.cpp \ + $(SRC)/Core/HLE/sceOpenPSID.cpp \ + $(SRC)/Core/HLE/sceParseHttp.cpp \ + $(SRC)/Core/HLE/sceParseUri.cpp \ + $(SRC)/Core/HLE/scePower.cpp \ + $(SRC)/Core/HLE/sceRtc.cpp \ + $(SRC)/Core/HLE/scePsmf.cpp \ + $(SRC)/Core/HLE/sceSas.cpp \ + $(SRC)/Core/HLE/sceSsl.cpp \ + $(SRC)/Core/HLE/sceUmd.cpp \ + $(SRC)/Core/HLE/sceUsb.cpp \ + $(SRC)/Core/HLE/sceUtility.cpp \ + $(SRC)/Core/HLE/sceVaudio.cpp \ + $(SRC)/Core/FileSystems/BlockDevices.cpp \ + $(SRC)/Core/FileSystems/ISOFileSystem.cpp \ + $(SRC)/Core/FileSystems/MetaFileSystem.cpp \ + $(SRC)/Core/FileSystems/DirectoryFileSystem.cpp \ + $(SRC)/Core/MIPS/MIPS.cpp.arm \ + $(SRC)/Core/MIPS/MIPSAnalyst.cpp \ + $(SRC)/Core/MIPS/MIPSDis.cpp \ + $(SRC)/Core/MIPS/MIPSDisVFPU.cpp \ + $(SRC)/Core/MIPS/MIPSInt.cpp.arm \ + $(SRC)/Core/MIPS/MIPSIntVFPU.cpp.arm \ + $(SRC)/Core/MIPS/MIPSTables.cpp.arm \ + $(SRC)/Core/MIPS/MIPSVFPUUtils.cpp \ + $(SRC)/Core/MIPS/MIPSCodeUtils.cpp \ + $(SRC)/Core/MIPS/MIPSDebugInterface.cpp \ + $(SRC)/Core/MIPS/JitCommon/JitCommon.cpp \ + $(SRC)/Core/MIPS/ARM/ArmJitCache.cpp \ + $(SRC)/Core/MIPS/ARM/ArmCompALU.cpp \ + $(SRC)/Core/MIPS/ARM/ArmCompBranch.cpp \ + $(SRC)/Core/MIPS/ARM/ArmCompFPU.cpp \ + $(SRC)/Core/MIPS/ARM/ArmCompLoadStore.cpp \ + $(SRC)/Core/MIPS/ARM/ArmCompVFPU.cpp \ + $(SRC)/Core/MIPS/ARM/ArmAsm.cpp \ + $(SRC)/Core/MIPS/ARM/ArmJit.cpp \ + $(SRC)/Core/MIPS/ARM/ArmRegCache.cpp \ + $(SRC)/Core/MIPS/ARM/ArmRegCacheFPU.cpp \ + $(SRC)/Core/Util/BlockAllocator.cpp \ + $(SRC)/Core/Util/ppge_atlas.cpp \ + $(SRC)/Core/Util/PPGeDraw.cpp + + +include $(BUILD_SHARED_LIBRARY) + +$(call import-module,libzip) +$(call import-module,native) diff --git a/Source/Android/jni/Application.mk b/Source/Android/jni/Application.mk new file mode 100644 index 000000000000..d18d3a46ff86 --- /dev/null +++ b/Source/Android/jni/Application.mk @@ -0,0 +1,4 @@ +APP_STL := stlport_static +APP_ABI := armeabi-v7a armeabi + +#APP_ABI := armeabi-v7a diff --git a/Source/Android/project.properties b/Source/Android/project.properties new file mode 100644 index 000000000000..a3ee5ab64f5e --- /dev/null +++ b/Source/Android/project.properties @@ -0,0 +1,14 @@ +# This file is automatically generated by Android Tools. +# Do not modify this file -- YOUR CHANGES WILL BE ERASED! +# +# This file must be checked in Version Control Systems. +# +# To customize properties used by the Ant build system edit +# "ant.properties", and override values to adapt the script to your +# project structure. +# +# To enable ProGuard to shrink and obfuscate your code, uncomment this (available properties: sdk.dir, user.home): +#proguard.config=${sdk.dir}/tools/proguard/proguard-android.txt:proguard-project.txt + +# Project target. +target=android-17 diff --git a/Source/Android/res/drawable-hdpi/launcher.png b/Source/Android/res/drawable-hdpi/launcher.png new file mode 100644 index 0000000000000000000000000000000000000000..da35bbad811a8217ca7d998c325b3a91f00a94e1 GIT binary patch literal 14225 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 literal 0 HcmV?d00001 diff --git a/Source/Android/res/drawable-mdpi/launcher.png b/Source/Android/res/drawable-mdpi/launcher.png new file mode 100644 index 0000000000000000000000000000000000000000..03e5eea949090370c821413cb847a29ac4b6389a GIT binary patch literal 8634 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 M07*qoM6N<$g7H)GPXGV_ literal 0 HcmV?d00001 diff --git a/Source/Android/res/drawable-xhdpi/launcher.png b/Source/Android/res/drawable-xhdpi/launcher.png new file mode 100644 index 0000000000000000000000000000000000000000..28770da81ffb17177a98722acd3aabd23c51aaf7 GIT binary patch literal 23020 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 O0000 + + + + + + + + + diff --git a/Source/Android/res/values/strings.xml b/Source/Android/res/values/strings.xml new file mode 100644 index 000000000000..2cfdcb6e7eab --- /dev/null +++ b/Source/Android/res/values/strings.xml @@ -0,0 +1,6 @@ + + + + Dolphin Emulator + + diff --git a/Source/Android/src/org/dolphinemu/dolphinemu/Button.java b/Source/Android/src/org/dolphinemu/dolphinemu/Button.java new file mode 100644 index 000000000000..629e572d8347 --- /dev/null +++ b/Source/Android/src/org/dolphinemu/dolphinemu/Button.java @@ -0,0 +1,33 @@ +package org.dolphinemu.dolphinemu; + +public class Button { + private String ButtonID; + private float _x; + private float _y; + private float _ex; + private float _ey; + public Button(String Button, float[] Coords) + { + ButtonID = Button; + _x = Coords[0]; + _y = Coords[1]; + _ex = Coords[4]; + _ey = Coords[5]; + } + public float X() + { + return _x; + } + public float Y() + { + return _y; + } + public float EX() + { + return _ex; + } + public float EY() + { + return _ey; + } +} diff --git a/Source/Android/src/org/dolphinemu/dolphinemu/ButtonManager.java b/Source/Android/src/org/dolphinemu/dolphinemu/ButtonManager.java new file mode 100644 index 000000000000..ee7a8f79d005 --- /dev/null +++ b/Source/Android/src/org/dolphinemu/dolphinemu/ButtonManager.java @@ -0,0 +1,43 @@ +package org.dolphinemu.dolphinemu; + +public class ButtonManager { + + private final int NUMBUTTONS = 15; + + Button[] Buttons; + float[][] ButtonCoords = + { // X, Y, X, EY, EX, EY, EX, Y + {0.75f, -1.0f, 0.75f, -0.75f, 1.0f, -0.75f, 1.0f, -1.0f}, + {0.50f, -1.0f, 0.50f, -0.75f, 0.75f, -0.75f, 0.75f, -1.0f}, + }; + public ButtonManager() + { + Buttons = new Button[NUMBUTTONS]; + + Buttons[0] = new Button("A", ButtonCoords[0]); + Buttons[1] = new Button("B", ButtonCoords[1]); + + } + Button GetButton(int ID) + { + return Buttons[ID]; + } + float[][] GetButtonCoords() + { + return ButtonCoords; + } + public int ButtonPressed(int action, float x, float y) + { + for (int a = 0; a < 2; ++a) + { + if (x >= Buttons[a].X() && + x <= Buttons[a].EX() && + -y >= Buttons[a].Y() && + -y <= Buttons[a].EY()) + { + return a; + } + } + return -1; + } +} diff --git a/Source/Android/src/org/dolphinemu/dolphinemu/DolphinEmulator.java b/Source/Android/src/org/dolphinemu/dolphinemu/DolphinEmulator.java new file mode 100644 index 000000000000..f95195b53e3c --- /dev/null +++ b/Source/Android/src/org/dolphinemu/dolphinemu/DolphinEmulator.java @@ -0,0 +1,124 @@ +package org.dolphinemu.dolphinemu; + +import javax.microedition.khronos.egl.EGL10; +import javax.microedition.khronos.egl.EGLConfig; +import javax.microedition.khronos.egl.EGLContext; +import javax.microedition.khronos.egl.EGLDisplay; + +import android.app.Activity; +import android.content.Intent; +import android.content.res.Configuration; +import android.opengl.GLSurfaceView; +import android.os.Bundle; +import android.util.DisplayMetrics; +import android.util.Log; +import android.view.MotionEvent; +import android.view.WindowManager; + +public class DolphinEmulator extends Activity { + + static private NativeGLSurfaceView GLview = null; + static private NativeRenderer Renderer = null; + static private boolean Running = false; + + private float screenWidth; + private float screenHeight; + + public static native void SetKey(int Value, int Key); + + static + { + try + { + System.loadLibrary("dolphin-emu-nogui"); + } + catch (Exception ex) + { + Log.w("me", ex.toString()); + } + } + @Override + public void onStop() + { + super.onStop(); + if (Running) + Renderer.StopEmulation(); + } + @Override + public void onPause() + { + super.onPause(); + if (Running) + Renderer.PauseEmulation(); + } + @Override + public void onResume() + { + super.onResume(); + if (Running) + Renderer.UnPauseEmulation(); + } + + /** Called when the activity is first created. */ + @Override + public void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + + if (savedInstanceState == null) + { + Intent ListIntent = new Intent(this, NativeListView.class); + startActivityForResult(ListIntent, 1); + } + } + + @Override + public void onActivityResult(int requestCode, int resultCode, Intent data) + { + super.onActivityResult(requestCode, resultCode, data); + + if (resultCode == Activity.RESULT_OK) + { + DisplayMetrics displayMetrics = new DisplayMetrics(); + WindowManager wm = (WindowManager) getApplicationContext().getSystemService(getApplicationContext().WINDOW_SERVICE); // the results will be higher than using the activity context object or the getWindowManager() shortcut + wm.getDefaultDisplay().getMetrics(displayMetrics); + screenWidth = displayMetrics.widthPixels; + screenHeight = displayMetrics.heightPixels; + + + String FileName = data.getStringExtra("Select"); + Renderer = new NativeRenderer(); + Renderer.setContext(getApplicationContext()); + + GLview = new NativeGLSurfaceView(this); + GLview.setEGLContextClientVersion(2); + GLview.setRenderer(Renderer); + + GLview.SetFileName(FileName); + setContentView(GLview); + Running = true; + } + } + + @Override + public boolean onTouchEvent(MotionEvent event) + { + float X, Y; + int Action; + X = event.getX(); + Y = event.getY(); + Action = event.getActionMasked(); + + int Button = Renderer.ButtonPressed(Action, ((X / screenWidth) * 2.0f) - 1.0f, ((Y / screenHeight) * 2.0f) - 1.0f); + + if (Button != -1) + SetKey(Action, Button); + + return false; + } + + public boolean overrideKeys() + { + return false; + } + +} \ No newline at end of file diff --git a/Source/Android/src/org/dolphinemu/dolphinemu/FileArrayAdapter.java b/Source/Android/src/org/dolphinemu/dolphinemu/FileArrayAdapter.java new file mode 100644 index 000000000000..b49149a36cf4 --- /dev/null +++ b/Source/Android/src/org/dolphinemu/dolphinemu/FileArrayAdapter.java @@ -0,0 +1,53 @@ +package org.dolphinemu.dolphinemu; + +import java.util.List; + +import android.content.Context; +import android.view.LayoutInflater; +import android.view.View; +import android.view.ViewGroup; +import android.widget.ArrayAdapter; +import android.widget.TextView; + +public class FileArrayAdapter extends ArrayAdapter