src/platform/android.nit

   1 # This file is part of NIT ( http://www.nitlanguage.org ).
   2 #
   3 # Copyright 2014 Alexis Laferrière <alexis.laf@xymus.net>
   4 #
   5 # Licensed under the Apache License, Version 2.0 (the "License");
   6 # you may not use this file except in compliance with the License.
   7 # You may obtain a copy of the License at
   8 #
   9 #     http://www.apache.org/licenses/LICENSE-2.0
  10 #
  11 # Unless required by applicable law or agreed to in writing, software
  12 # distributed under the License is distributed on an "AS IS" BASIS,
  13 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 # See the License for the specific language governing permissions and
  15 # limitations under the License.
  16
  17 # Compile program for the Android platform
  18 module android
  19
  20 import platform
  21 import compiler::abstract_compiler
  22 import ffi
  23 intrude import ffi::extra_java_files
  24 import android_annotations
  25
  26 redef class ToolContext
  27         redef fun platform_from_name(name)
  28         do
  29                 if name == "android" then return new AndroidPlatform
  30                 return super
  31         end
  32 end
  33
  34 class AndroidPlatform
  35         super Platform
  36
  37         redef fun name do return "android"
  38
  39         redef fun supports_libgc do return true
  40
  41         redef fun supports_libunwind do return false
  42
  43         redef fun supports_linker_script do return false
  44
  45         redef fun toolchain(toolcontext) do return new AndroidToolchain(toolcontext)
  46 end
  47
  48 class AndroidToolchain
  49         super MakefileToolchain
  50
  51         var android_project_root: nullable String = null
  52
  53         redef fun compile_dir
  54         do
  55                 var android_project_root = "{super}/android/"
  56                 self.android_project_root = android_project_root
  57                 return "{android_project_root}/jni/nit_compile/"
  58         end
  59
  60         redef fun default_outname(mainmodule) do return "{mainmodule.name}.apk"
  61
  62         redef fun write_files(compiler, compile_dir, cfiles)
  63         do
  64                 var android_project_root = android_project_root.as(not null)
  65                 var project = toolcontext.modelbuilder.android_project_for(compiler.mainmodule)
  66                 var short_project_name = compiler.mainmodule.name.replace("-", "_")
  67                 var release = toolcontext.opt_release.value
  68
  69                 var app_name = project.name
  70                 if app_name == null then app_name = compiler.mainmodule.name
  71                 if not release then app_name += " Debug"
  72
  73                 var app_package = project.java_package
  74                 if app_package == null then app_package = "org.nitlanguage.{short_project_name}"
  75                 if not release then app_package += "_debug"
  76
  77                 var app_version = project.version
  78                 if app_version == null then app_version = "1.0"
  79
  80                 var app_min_api = project.min_api
  81                 if app_min_api == null then app_min_api = 10
  82
  83                 var app_target_api = project.target_api
  84                 if app_target_api == null then app_target_api = app_min_api
  85
  86                 var app_max_api = ""
  87                 if project.max_api != null then app_max_api = "android:maxSdkVersion=\"{project.max_api.as(not null)}\""
  88
  89                 # Clear the previous android project, so there is no "existing project warning"
  90                 # or conflict between Java files of different projects
  91                 if android_project_root.file_exists then android_project_root.rmdir
  92
  93                 var args = ["android", "-s",
  94                         "create", "project",
  95                         "--name", short_project_name,
  96                         "--target", "android-{app_target_api}",
  97                         "--path", android_project_root,
  98                         "--package", app_package,
  99                         "--activity", short_project_name]
 100                 toolcontext.exec_and_check(args, "Android project error")
 101
 102                 # create compile_dir
 103                 var dir = "{android_project_root}/jni/"
 104                 if not dir.file_exists then dir.mkdir
 105
 106                 dir = compile_dir
 107                 if not dir.file_exists then dir.mkdir
 108
 109                 # compile normal C files
 110                 super(compiler, compile_dir, cfiles)
 111
 112                 # Gather extra C files generated elsewhere than in super
 113                 for f in compiler.extern_bodies do
 114                         if f isa ExternCFile then cfiles.add(f.filename.basename(""))
 115                 end
 116
 117                 # Is there an icon?
 118                 var resolutions = ["ldpi", "mdpi", "hdpi", "xhdpi", "xxhdpi", "xxxhdpi"]
 119                 var icon_available = false
 120                 for res in resolutions do
 121                         var path = "res/drawable-{res}/icon.png"
 122                         if path.file_exists then
 123                                 icon_available = true
 124                                 break
 125                         end
 126                 end
 127
 128                 var icon_declaration
 129                 if icon_available then
 130                         icon_declaration = "android:icon=\"@drawable/icon\""
 131                 else icon_declaration = ""
 132
 133                 # Also copy over the java files
 134                 dir = "{android_project_root}/src/"
 135                 for mmodule in compiler.mainmodule.in_importation.greaters do
 136                         var extra_java_files = mmodule.extra_java_files
 137                         if extra_java_files != null then for file in extra_java_files do
 138                                 var path = file.filename
 139                                 path.file_copy_to(dir/path.basename(""))
 140                         end
 141                 end
 142
 143                 ## Generate Application.mk
 144                 dir = "{android_project_root}/jni/"
 145                 """
 146 APP_ABI := armeabi armeabi-v7a x86 mips
 147 APP_PLATFORM := android-{{{app_target_api}}}
 148 """.write_to_file "{dir}/Application.mk"
 149
 150                 ## Generate delegating makefile
 151                 """
 152 include $(call all-subdir-makefiles)
 153 """.write_to_file "{dir}/Android.mk"
 154
 155                 # Gather ldflags for Android
 156                 var ldflags = new Array[String]
 157                 var platform_name = "android"
 158                 for mmodule in compiler.mainmodule.in_importation.greaters do
 159                         if mmodule.ldflags.keys.has(platform_name) then
 160                                 ldflags.add_all mmodule.ldflags[platform_name]
 161                         end
 162                 end
 163
 164                 ### generate makefile into "{compile_dir}/Android.mk"
 165                 dir = compile_dir
 166                 """
 167 LOCAL_PATH := $(call my-dir)
 168 include $(CLEAR_VARS)
 169
 170 LOCAL_CFLAGS    := -D ANDROID -D WITH_LIBGC
 171 LOCAL_MODULE    := main
 172 LOCAL_SRC_FILES := \\
 173 {{{cfiles.join(" \\\n")}}}
 174 LOCAL_LDLIBS    := {{{ldflags.join(" ")}}} $(TARGET_ARCH)/libgc.a
 175 LOCAL_STATIC_LIBRARIES := android_native_app_glue png
 176
 177 include $(BUILD_SHARED_LIBRARY)
 178
 179 $(call import-module,android/native_app_glue)
 180                 """.write_to_file("{dir}/Android.mk")
 181
 182                 ### generate AndroidManifest.xml
 183                 dir = android_project_root
 184                 """<?xml version="1.0" encoding="utf-8"?>
 185 <!-- BEGIN_INCLUDE(manifest) -->
 186 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
 187         package="{{{app_package}}}"
 188         android:versionCode="{{{project.version_code}}}"
 189         android:versionName="{{{app_version}}}">
 190
 191     <!-- This is the platform API where NativeActivity was introduced. -->
 192     <uses-sdk
 193         android:minSdkVersion="{{{app_min_api}}}"
 194         android:targetSdkVersion="{{{app_target_api}}}"
 195         {{{app_max_api}}} />
 196
 197     <application
 198                 android:label="@string/app_name"
 199                 android:hasCode="true"
 200                 android:debuggable="{{{not release}}}"
 201                 {{{icon_declaration}}}
 202                 android:configChanges="mcc|mnc|locale|touchscreen|keyboard|keyboardHidden|navigation|screenLayout|fontScale|uiMode|orientation">
 203
 204         <!-- Our activity is the built-in NativeActivity framework class.
 205              This will take care of integrating with our NDK code. -->
 206         <activity android:name="android.app.NativeActivity"
 207                 android:label="@string/app_name"
 208                 {{{project.manifest_activity_attributes.join("\n")}}}
 209                 {{{icon_declaration}}}>
 210             <!-- Tell NativeActivity the name of our .so -->
 211             <meta-data android:name=\"android.app.lib_name\"
 212                     android:value=\"main\" />
 213             <intent-filter>
 214                 <action android:name="android.intent.action.MAIN" />
 215                 <category android:name="android.intent.category.LAUNCHER" />
 216             </intent-filter>
 217         </activity>
 218
 219 {{{project.manifest_application_lines.join("\n")}}}
 220
 221     </application>
 222
 223 {{{project.manifest_lines.join("\n")}}}
 224
 225 </manifest>
 226 <!-- END_INCLUDE(manifest) -->
 227                 """.write_to_file("{dir}/AndroidManifest.xml")
 228
 229                 ### Link to png sources
 230                 # libpng is not available on Android NDK
 231                 # FIXME make obtionnal when we have alternatives to mnit
 232                 var nit_dir = toolcontext.nit_dir
 233                 var share_dir =  nit_dir/"share/"
 234                 if not share_dir.file_exists then
 235                         print "Android project error: Nit share directory not found, please use the environment variable NIT_DIR"
 236                         exit 1
 237                 end
 238                 share_dir = share_dir.realpath
 239                 var target_png_dir = "{android_project_root}/jni/png"
 240                 if not target_png_dir.file_exists then
 241                         toolcontext.exec_and_check(["ln", "-s", "{share_dir}/png/", target_png_dir], "Android project error")
 242                 end
 243
 244                 # Ensure that android-setup-libgc.sh has been executed
 245                 if not "{share_dir}/libgc/arm/lib".file_exists then
 246                         toolcontext.exec_and_check(["{share_dir}/libgc/android-setup-libgc.sh"], "Android project error")
 247                 end
 248
 249                 # Copy GC files
 250                 for arch in ["arm", "x86", "mips"] do
 251                         dir = android_project_root/arch
 252                         dir.mkdir
 253                         toolcontext.exec_and_check(["cp", "{share_dir}/libgc/{arch}/lib/libgc.a",
 254                                 dir/"libgc.a"], "Android project error")
 255                 end
 256
 257                 toolcontext.exec_and_check(["ln", "-s", "{share_dir}/libgc/arm/include/gc/",
 258                         "{android_project_root}/jni/nit_compile/gc"], "Android project error")
 259
 260                 ### Link to assets (for mnit and others)
 261                 # This will be accessed from `android_project_root`
 262                 var assets_dir
 263                 if compiler.mainmodule.location.file != null then
 264                         # it is a real file, use "{file}/../assets"
 265                         assets_dir = "{compiler.mainmodule.location.file.filename.dirname}/../assets"
 266                 else
 267                         # probably used -m, use "."
 268                         assets_dir = "assets"
 269                 end
 270                 if assets_dir.file_exists then
 271                         assets_dir = assets_dir.realpath
 272                         var target_assets_dir = "{android_project_root}/assets"
 273                         if not target_assets_dir.file_exists then
 274                                 toolcontext.exec_and_check(["ln", "-s", assets_dir, target_assets_dir], "Android project error")
 275                         end
 276                 end
 277
 278                 ### Copy resources and libs where expected by the SDK
 279                 var project_root
 280                 if compiler.mainmodule.location.file != null then
 281                         # it is a real file, use "{file}/../res"
 282                         project_root = "{compiler.mainmodule.location.file.filename.dirname}/.."
 283                 else
 284                         # probably used -m, use "."
 285                         project_root = "."
 286                 end
 287
 288                 # Android resources folder
 289                 var res_dir = project_root / "res"
 290                 if res_dir.file_exists then
 291                         # copy the res folder to .nit_compile
 292                         res_dir = res_dir.realpath
 293                         toolcontext.exec_and_check(["cp", "-R", res_dir, android_project_root], "Android project error")
 294                 end
 295
 296                 if not res_dir.file_exists or not "{res_dir}/values/strings.xml".file_exists then
 297                         # Create our own custom `res/values/string.xml` with the App name
 298 """<?xml version="1.0" encoding="utf-8"?>
 299 <resources>
 300     <string name="app_name">{{{app_name}}}</string>
 301 </resources>""".write_to_file "{android_project_root}/res/values/strings.xml"
 302                 end
 303
 304                 # Android libs folder
 305                 var libs_dir = project_root / "libs"
 306                 if libs_dir.file_exists then
 307                         toolcontext.exec_and_check(["cp", "-r", libs_dir, android_project_root], "Android project error")
 308                 end
 309         end
 310
 311         redef fun write_makefile(compiler, compile_dir, cfiles)
 312         do
 313                 # Do nothing, already done in `write_files`
 314         end
 315
 316         redef fun compile_c_code(compiler, compile_dir)
 317         do
 318                 var android_project_root = android_project_root.as(not null)
 319                 var short_project_name = compiler.mainmodule.name.replace("-", "_")
 320                 var release = toolcontext.opt_release.value
 321
 322                 # Compile C code (and thus Nit)
 323                 toolcontext.exec_and_check(["ndk-build", "-s", "-j", "-C", android_project_root], "Android project error")
 324
 325                 # Generate the apk
 326                 var args = ["ant", "-q", "-f", android_project_root+"/build.xml"]
 327                 if release then
 328                         args.add "release"
 329                 else args.add "debug"
 330                 toolcontext.exec_and_check(args, "Android project error")
 331
 332                 # Move the apk to the target
 333                 var outname = outfile(compiler.mainmodule)
 334
 335                 if release then
 336                         var apk_path = "{android_project_root}/bin/{short_project_name}-release-unsigned.apk"
 337
 338                         # Sign APK
 339                         var keystore_path= "KEYSTORE".environ
 340                         var key_alias= "KEY_ALIAS".environ
 341                         var tsa_server= "TSA_SERVER".environ
 342
 343                         if key_alias.is_empty then
 344                                 toolcontext.fatal_error(null,
 345                                         "Fatal Error: the environment variable `KEY_ALIAS` must be set to use the `--release` option on Android projects.")
 346                         end
 347
 348                         args = ["jarsigner", "-sigalg", "MD5withRSA", "-digestalg", "SHA1", apk_path, key_alias]
 349
 350                         ## Use a custom keystore
 351                         if not keystore_path.is_empty then args.add_all(["-keystore", keystore_path])
 352
 353                         ## Use a TSA server
 354                         if not tsa_server.is_empty then args.add_all(["-tsa", tsa_server])
 355
 356                         toolcontext.exec_and_check(args, "Android project error")
 357
 358                         # Clean output file
 359                         if outname.to_path.exists then outname.to_path.delete
 360
 361                         # Align APK
 362                         args = ["zipalign", "4", apk_path, outname]
 363                         toolcontext.exec_and_check(args, "Android project error")
 364                 else
 365                         # Move to the expected output path
 366                         args = ["mv", "{android_project_root}/bin/{short_project_name}-debug.apk", outname]
 367                         toolcontext.exec_and_check(args, "Android project error")
 368                 end
 369         end
 370 end
 371
 372 redef class JavaClassTemplate
 373         redef fun write_to_files(compdir)
 374         do
 375                 var jni_path = "jni/nit_compile/"
 376                 if compdir.has_suffix(jni_path) then
 377                         var path = "{compdir.substring(0, compdir.length-jni_path.length)}/src/"
 378                         return super(path)
 379                 else return super
 380         end
 381 end