rhodes 6.2.0 → 7.5.1

data/platform/android/build/android.rake

@@ -26,20 +26,27 @@
 
 require File.dirname(__FILE__) + '/androidcommon.rb'
 require File.dirname(__FILE__) + '/android_tools.rb'
+require File.dirname(__FILE__) + '/apk_builder.rb'
+require File.dirname(__FILE__) + '/aapt2_helper.rb'
 require File.dirname(__FILE__) + '/maven_deps_extractor.rb'
 require File.dirname(__FILE__) + '/manifest_generator.rb'
 require File.dirname(__FILE__) + '/eclipse_project_generator.rb'
 require File.dirname(__FILE__) + '/android_studio_project_generator.rb'
 require File.dirname(__FILE__) + '/android_debug.rb'
 require File.dirname(__FILE__) + '/../../../lib/build/BuildConfig'
+
+require_relative 'dex_builder'
+require_relative 'build_tools_finder'
+
 load File.dirname(__FILE__) + '/android-repack.rake'
 require 'pathname'
 require 'tempfile'
+require 'zip'
 
 include FileUtils
 
 USE_OWN_STLPORT = false
-#USE_TRACES = # see androidcommon.rb
+$rhodes_as_lib = false
 
 def get_market_version(apilevel)
   AndroidTools.get_market_version(apilevel)
@@ -55,8 +62,8 @@ JAVA_PACKAGE_NAME = 'com.rhomobile.rhodes'
 # For complete list of android API levels and its mapping to
 # market names (such as "Android-1.5" etc) see output of
 # command "android list targets"
-ANDROID_MIN_SDK_LEVEL = 19
-ANDROID_SDK_LEVEL = 26
+ANDROID_MIN_SDK_LEVEL = 21 #21 is the minimum API that supports arm64
+ANDROID_SDK_LEVEL = 31
 
 ANDROID_PERMISSIONS = {
     'audio' => ['RECORD_AUDIO', 'MODIFY_AUDIO_SETTINGS'],
@@ -80,9 +87,14 @@ ANDROID_CAPS_ALWAYS_ENABLED = ['network_state']
 
 def set_app_icon_android
 
+  #if $rhodes_as_lib 
+  #  puts "Skip building copy resources (not needed for aar library)"
+  #  return
+  #end
+
   res_path = File.join($app_path, 'resources', 'android', 'res')
   if File.exists? res_path
-    # NEW resource - just copy it to res folder
+    # NEW resource - just copy it to res folder -->>
     puts "add resources from application'sresource folder [#{res_path}] to [#{$tmpdir}]"
     cp_r res_path, $tmpdir
 
@@ -149,6 +161,10 @@ def set_app_name_android(newname)
   rm_rf $appres
   cp_r $rhores, $appres
 
+  buildToolsVerMajor = $build_tools_ver.split('.')[0].to_i
+  canRenderNetworkSecurityConfig = (($found_api_level.to_i >= 24) && (buildToolsVerMajor>=24))
+  rm_rf File.join($appres, 'xml', 'network_security_config.xml') if(!canRenderNetworkSecurityConfig)
+
   rhostrings = File.join($rhores, "values", "strings.xml")
   appstrings = File.join($appres, "values", "strings.xml")
   doc = REXML::Document.new(File.new(rhostrings))
@@ -156,6 +172,17 @@ def set_app_name_android(newname)
   File.open(appstrings, "w") { |f| doc.write f }
 end
 
+def set_app_name_android_post(newname)
+  puts "set_app_name_post"
+
+  Dir.glob(File.join($appres, '**', 'strings.xml')).each do |res|
+    doc = REXML::Document.new(File.new(res))
+    doc.elements["resources/string[@name='app_name']"].text = newname
+    rm_rf res
+    File.open(res, "w") { |f| doc.write f }
+  end
+end
+
 
 def get_boolean(arg)
   arg == 'true' or arg == 'yes' or arg == 'enabled' or arg == 'enable' or arg == '1'
@@ -296,15 +323,34 @@ namespace 'project' do
       project_app_path = File.join $app_path,'project','android_studio', 'app'
 
       cmake_template_path = File.join( project_template_path, 'app', 'CMakeLists.txt.erb' )
+
       cmake_template_ruby = File.join( $shareddir, 'ruby', 'CMakeLists.txt.erb')
+      source_template_ruby = File.join('platform', 'android', 'build', 'libruby_build.files')
+
       cmake_template_curl = File.join( $shareddir, 'curl', 'CMakeLists.txt.erb')
+      source_template_curl = File.join('platform', 'android', 'build', 'libcurl_build.files')
+
       cmake_template_db = File.join( $shareddir, 'db', 'CMakeLists.txt.erb')
+      source_template_db = File.join('platform', 'android', 'build', 'librhodb_build.files')
+
       cmake_template_common = File.join( $shareddir, 'common', 'CMakeLists.txt.erb')
+      source_template_common = File.join('platform', 'android', 'build', 'librhocommon_build.files')
+      source_template_rhomain = File.join('platform', 'android', 'build', 'librhomain_build.files')
+
       cmake_template_logging = File.join( $shareddir, 'logging', 'CMakeLists.txt.erb')
+      source_template_logging = File.join('platform', 'android', 'build', 'librholog_build.files')
+
       cmake_template_sync = File.join( $shareddir, 'sync', 'CMakeLists.txt.erb')
+      source_template_sync = File.join('platform', 'android', 'build', 'librhosync_build.files')
+
       cmake_template_json = File.join( $shareddir, 'json.new', 'CMakeLists.txt.erb')
+      source_template_json = File.join('platform', 'android', 'build', 'libjson_build.files')
+
       cmake_template_sqlite = File.join( $shareddir, 'sqlite', 'CMakeLists.txt.erb')
+      source_template_sqlite = File.join('platform', 'android', 'build', 'libsqlite_build.files')
+
       cmake_template_rhodes = File.join('platform', 'android', 'build', 'CMakeLists.txt.erb')
+      source_template_rhodes = File.join('platform', 'android', 'build', 'librhodes_build.files')
 
       $abis = $app_config['android']['abis'] if $app_config["android"]
       $abis = ['arm'] unless $abis
@@ -324,8 +370,12 @@ namespace 'project' do
       extlibs.each do |lib|
 
         extname = File.basename(lib).gsub('lib', '').gsub('.a', '')
-        external_string += ("add_library(#{extname} STATIC IMPORTED GLOBAL)\n" +
-            "set_property(TARGET #{extname} PROPERTY IMPORTED_LOCATION #{lib})\n")
+        #TODO support ${ANDROID_ABI} in cmake template
+        if extname == "openssl.so"
+           external_string += ("add_library(#{extname} STATIC IMPORTED GLOBAL)\n" +
+              "set_property(TARGET #{extname} PROPERTY IMPORTED_LOCATION #{lib})\n")
+        end
+
         if extname == "coreapi"
           next
         end
@@ -333,9 +383,16 @@ namespace 'project' do
       end
       ext_libs += 'coreapi'
 
-
-
-      cpp_stub_path = File.join( project_template_path, 'app', 'stub.cpp' )
+      extensions_deps = ''
+      $ext_android_build_scripts.each do |ext, builddata|
+        ext_native_files = File.join(builddata[2], 'ext', 'platform', 'android', 'ext_native.files')
+        ext_native_files2 = File.join(builddata[0], 'ext_native.files')
+        ext_native_final = (File.exists? ext_native_files) ? ext_native_files : ext_native_files2
+        if(File.exists? ext_native_final)
+          mkdir_p File.join(project_app_path, ext)        
+          extensions_deps += "add_subdirectory(./#{ext})\n"
+        end
+      end
 
       rhodes_path = File.absolute_path '.'
 
@@ -350,6 +407,7 @@ namespace 'project' do
       generator.externalDeps = external_string
       generator.extLibs = ext_libs
       generator.targetArch = studio_realabi
+      generator.extensionsDeps = extensions_deps
 
       generator.compileSdkVersion = $found_api_level
       generator.versionName = $app_config["version"]
@@ -377,17 +435,35 @@ namespace 'project' do
       cmake_path_rholog = File.join( project_path, 'app', 'rholog', 'CMakeLists.txt')
       cmake_path_rhodes = File.join( project_path, 'app', 'rhodes', 'CMakeLists.txt')
 
-      File.open( app_gradle_path, 'w' ) { |f| f.write generator.render_app_gradle( app_gradle_template ) }
       File.open( cmake_path_main, 'w' ) { |f| f.write generator.render_app_gradle( cmake_template_path ) }
-      File.open( cmake_path_ruby, 'w' ) { |f| f.write generator.render_app_gradle( cmake_template_ruby ) }
-      File.open( cmake_path_curl, 'w' ) { |f| f.write generator.render_app_gradle( cmake_template_curl ) }
-      File.open( cmake_path_rhodb, 'w' ) { |f| f.write generator.render_app_gradle( cmake_template_db ) }
-      File.open( cmake_path_rhocommon, 'w' ) { |f| f.write generator.render_app_gradle( cmake_template_common ) }
-      File.open( cmake_path_rhosync, 'w' ) { |f| f.write generator.render_app_gradle( cmake_template_sync ) }
-      File.open( cmake_path_sqlite, 'w' ) { |f| f.write generator.render_app_gradle( cmake_template_sqlite ) }
-      File.open( cmake_path_json, 'w' ) { |f| f.write generator.render_app_gradle( cmake_template_json ) }
-      File.open( cmake_path_rholog, 'w' ) { |f| f.write generator.render_app_gradle( cmake_template_logging ) }
-      File.open( cmake_path_rhodes, 'w' ) { |f| f.write generator.render_app_gradle( cmake_template_rhodes ) }
+      File.open( cmake_path_ruby, 'w' ) { |f| f.write generator.render_app_gradle_ex( cmake_template_ruby, source_template_ruby ) }
+      File.open( cmake_path_curl, 'w' ) { |f| f.write generator.render_app_gradle_ex( cmake_template_curl, source_template_curl ) }
+      File.open( cmake_path_rhodb, 'w' ) { |f| f.write generator.render_app_gradle_ex( cmake_template_db, source_template_db ) }
+      File.open( cmake_path_rhocommon, 'w' ) { |f| f.write generator.render_app_gradle_ex2( cmake_template_common, source_template_common, source_template_rhomain ) }
+      File.open( cmake_path_rhosync, 'w' ) { |f| f.write generator.render_app_gradle_ex( cmake_template_sync, source_template_sync ) }
+      File.open( cmake_path_sqlite, 'w' ) { |f| f.write generator.render_app_gradle_ex( cmake_template_sqlite, source_template_sqlite ) }
+      File.open( cmake_path_json, 'w' ) { |f| f.write generator.render_app_gradle_ex( cmake_template_json, source_template_json ) }
+      File.open( cmake_path_rholog, 'w' ) { |f| f.write generator.render_app_gradle_ex( cmake_template_logging, source_template_logging ) }
+      File.open( cmake_path_rhodes, 'w' ) { |f| f.write generator.render_app_gradle_ex( cmake_template_rhodes,  source_template_rhodes) }
+
+      cmake_template_extension = File.join('platform', 'android', 'build', 'CMakeListsExts.txt.erb')
+      $ext_android_build_scripts.each do |ext, builddata|
+        ext_native_files = File.join(builddata[2], 'ext', 'platform', 'android', 'ext_native.files')
+        ext_native_files2 = File.join(builddata[0], 'ext_native.files')
+        ext_native_final = (File.exists? ext_native_files) ? ext_native_files : ext_native_files2
+        if(File.exists? ext_native_final)
+          cmake_path_ext = File.join( project_path, 'app', ext, 'CMakeLists.txt')
+          generator.extdir = builddata[2]
+          generator.extName = ext
+          File.open( cmake_path_ext, 'w' ) { |f| f.write generator.render_cmake_extension( cmake_template_extension, ext_native_final ) }
+        end
+      end
+
+      $ext_android_additional_sources.each do |extpath, list|
+        
+      end
+      File.open( app_gradle_path, 'w' ) { |f| f.write generator.render_app_gradle( app_gradle_template ) }
+
 
       cp main_gradle_script,  project_path
       cp gradle_properties,   project_path
@@ -443,7 +519,7 @@ def setup_ext_env( extpath, extname )
   env["RHO_APP_DIR"] = $app_path
   env["ANDROID_SDK"] = $androidsdkpath
   env["ANDROID_NDK"] = $androidndkpath
-  env["ANDROID_API_LEVEL"] = $found_api_level.to_s
+  env["ANDROID_API_LEVEL"] = $min_sdk_level.to_s
   env["RHO_ROOT"] = $startdir
   env["BUILD_DIR"] ||= $startdir + "/platform/android/build"
   env["RHO_INC"] = $appincdir
@@ -461,6 +537,70 @@ def setup_ext_env( extpath, extname )
   env
 end
 
+def get_android_major_minor(version)
+  major, minor, patch = version.split('.').map { |z| z.to_i }
+  major = 0 if major.nil?
+  minor = 0 if minor.nil?
+  patch = 0 if patch.nil?
+
+  $logger.debug( "Splitting version #{version}, result is: #{major}.#{minor}.#{patch}" )
+
+  return major,minor,patch
+end
+
+def get_case_insensetive_property(property)
+  $app_config["android"].each do |x|
+    if (x[0].downcase == property.downcase)
+      return x[1]
+    end
+  end
+  return nil
+end
+
+def select_aapt2
+
+  platform_dir = ''
+  
+  if OS.windows?
+    platform_dir = 'windows'
+  elsif OS.mac?
+    platform_dir = 'osx'
+  elsif OS.linux?
+    platform_dir = 'linux'
+  else
+    raise "unknown host OS"
+  end  
+
+  File.join($startdir, "res", "build-tools", "aapt2", platform_dir , 'aapt2'+$exe_ext)
+end
+
+
+def init_aapt2_helper
+  helper = Aapt2Helper.instance
+
+  helper.logger = $logger
+  helper.res_dir = $appres
+  helper.output_path = $targetdir
+  helper.dex_path = File.join( $bindir, 'classes.dex' )
+  helper.apk_path = File.join( $bindir, 'rhodes.ap_')
+  #builder.res_dirs << AndroidTools::MavenDepsExtractor.instance.res_dirs
+
+  helper.build_dir = $tmpdir
+  helper.androidjar = $androidjar
+  helper.manifest = $appmanifest
+
+  helper.aapt2 = select_aapt2
+  helper.bundletool = $bundletool
+  helper.javabin = File.join( $java, 'java' + $exe_ext )
+  helper.rjava_dir = $app_rjava_dir
+  helper.maven_deps = AndroidTools::MavenDepsExtractor.instance
+  helper.assets_dir = $appassets
+
+  helper.no_compress_exts = $no_compression
+
+  helper.init
+end
+
 namespace "config" do
   task :set_android_platform do
     $current_platform = "android"
@@ -500,15 +640,20 @@ namespace "config" do
       end
     end
 
-    $min_sdk_level = $app_config["android"]["minSDK"] unless $app_config["android"].nil?
-    $min_sdk_level = $config["android"]["minSDK"] if $min_sdk_level.nil? and not $config["android"].nil?
+    $min_sdk_level = get_case_insensetive_property("minSDK") unless $app_config["android"].nil?
+    $min_sdk_level = get_case_insensetive_property("minSDK") if $min_sdk_level.nil? and not $config["android"].nil?
+    $min_sdk_level = get_case_insensetive_property("minSdkVer") if $min_sdk_level.nil?
     $min_sdk_level = $min_sdk_level.to_i unless $min_sdk_level.nil?
     $min_sdk_level = ANDROID_MIN_SDK_LEVEL if $min_sdk_level.nil?
 
-
-    $target_sdk_level = $app_config["android"]["targetSDK"] unless $app_config["android"].nil?
-    $target_sdk_level = $config["android"]["targetSDK"] if $target_sdk_level.nil? and not $config["android"].nil?
+    $build_bundle = false
+    $build_bundle = get_case_insensetive_property("build_bundle").to_i == 1 unless $app_config["android"].nil?
+    
+    $target_sdk_level = get_case_insensetive_property("targetSdk") unless $app_config["android"].nil?
+    $target_sdk_level = get_case_insensetive_property("targetSdk") if $target_sdk_level.nil? and not $config["android"].nil?
+    $target_sdk_level = get_case_insensetive_property("targetSdkVer") if $target_sdk_level.nil?
     $target_sdk_level = $target_sdk_level.to_i unless $target_sdk_level.nil?
+
     $target_sdk_level = ANDROID_SDK_LEVEL if $target_sdk_level.nil?
 
     $max_sdk_level = $app_config["android"]["maxSDK"] unless $app_config["android"].nil?
@@ -527,10 +672,23 @@ namespace "config" do
       puts AndroidTools.get_installed_market_versions
       
       $found_api_level = android_api_levels.last
+      $major_version = 0
+      $minor_version = 0
+      $patch_version = 0
 
       #If user has mentioned version under android, then select that particular api level.
       if $app_config["android"]["version"]
         apilevel = AndroidTools.get_api_level $app_config["android"]["version"]
+        version = $app_config["android"]["version"]
+        $major_version, $minor_version, $patch_version = get_android_major_minor(version)
+
+        market_version = AndroidTools.get_market_version($target_sdk_level)
+        if market_version.nil?
+          apilevel = android_api_levels.last
+        else
+          apilevel = $target_sdk_level
+        end
+
         if(!apilevel)
           apilevel = AndroidTools.get_api_level ($app_config["android"]["version"] + ".0")
         end
@@ -544,9 +702,13 @@ namespace "config" do
         else
           puts "No Android platform found of version #{$app_config['android']['version']}. Picking the latest one Android #{AndroidTools.get_market_version $found_api_level} available in machine"
         end
-      end
+      else
+        $major_version, $minor_version, $patch_version = 
+          get_android_major_minor( AndroidTools.get_market_version($found_api_level) )
+      end    
     end
 
+    $logger.info("Set up build API Level: #{$found_api_level}, version: #{$major_version}.#{$minor_version}")
 
     $gapikey = $app_config["android"]["apikey"] unless $app_config["android"].nil?
     $gapikey = $config["android"]["apikey"] if $gapikey.nil? and not $config["android"].nil?
@@ -571,7 +733,7 @@ namespace "config" do
       puts "Custom config.xml path: #{$config_xml}"
     end
 
-    puts "Use Google addon API (1): #{$use_google_addon_api}" if USE_TRACES
+    $logger.debug "Use Google addon API (1): #{$use_google_addon_api}"    
 
     $uri_scheme = $app_config["android"]["URIScheme"] unless $app_config["android"].nil?
     $uri_scheme = "http" if $uri_scheme.nil?
@@ -592,12 +754,14 @@ namespace "config" do
     $srcdir = File.join $tmpdir,'assets' #File.join($bindir, "RhoBundle")
 
     $rhomanifesterb = File.join($app_path, $app_config['android']['manifest_template']) unless $app_config["android"].nil? || $app_config['android']['manifest_template'].nil?
-    $rhomanifesterb = File.join $androidpath, "Rhodes", "AndroidManifest.xml.erb" if $rhomanifesterb.nil?
+    #$rhomanifesterb = File.join $androidpath, "Rhodes", "AndroidManifest.xml.erb" if $rhomanifesterb.nil?
+    $rhomanifesterb = File.join $startdir, 'res', 'generators', 'templates', 'application', 'AndroidManifest.erb' if $rhomanifesterb.nil?
 
     $appmanifest = File.join $tmpdir, "AndroidManifest.xml"
 
     $rhores = File.join $androidpath, 'Rhodes','res'
     $appres = File.join $tmpdir,'res'
+    $appres_flats = File.join $tmpdir,'flats' #do we really need a global var for that?
     $appassets = $srcdir
     $applibs = File.join $tmpdir,'lib'
 
@@ -630,64 +794,31 @@ namespace "config" do
       # TODO: add ruby executable for Linux
     end
 
-    AndroidTools::MavenDepsExtractor.instance.set_logger($logger)
-    AndroidTools::MavenDepsExtractor.instance.set_temp_dir($tmpdir)
-    AndroidTools::MavenDepsExtractor.instance.set_java_home($java)
-
-
-    build_tools_path = nil
+    build_tools_ver = nil
 
     if !$skip_checking_Android_SDK
-      if File.exist?(File.join($androidsdkpath, "build-tools"))
-
 
+      AndroidTools::MavenDepsExtractor.instance.set_logger($logger)
+      AndroidTools::MavenDepsExtractor.instance.set_temp_dir($tmpdir)
+      AndroidTools::MavenDepsExtractor.instance.set_java_home($java)
 
-        toolsver = $app_config['android']['buildtools'] if ($app_config['android'] and $app_config['android']['buildtools'])
+      toolsver = $app_config['android']['buildtools'] if ($app_config['android'] and $app_config['android']['buildtools'])
+      build_tools_path = AndroidTools::findBuildToolsPath(toolsver,$androidsdkpath,$androidplatform)
 
-        if toolsver
-          #will try to find user-specified build tools
-          path = File.join($androidsdkpath,'build-tools',toolsver)
-          if File.directory?(path)
-            build_tools_path = toolsver
-          else
-            $logger.warn("Android build tools v#{toolsver} specified in build.yml were not found, will use latest")
-          end
-        end
+      $logger.info "Detected Android build tools at #{build_tools_path}"
 
+      $aapt2 = File.join(build_tools_path, "aapt2#{$exe_ext}")
 
-        build_tools = {}
+      $aapt = File.join(build_tools_path, "aapt#{$exe_ext}")
+      $aapt = File.join($androidsdkpath, "platform-tools", "aapt" + $exe_ext) unless File.exists? $aapt
 
-        if !build_tools_path
-          Dir.foreach(File.join($androidsdkpath, "build-tools")) do |entry|
-            next if entry == '.' or entry == '..'
+      AndroidTools::DexBuilder.instance.logger = $logger
+      AndroidTools::DexBuilder.instance.sdk_path = $androidsdkpath
+      AndroidTools::DexBuilder.instance.build_tools_path = build_tools_path
+      AndroidTools::DexBuilder.instance.androidplatform = $androidplatform
+      AndroidTools::DexBuilder.instance.javabin = File.join($java, 'java'+$exe_ext)
 
-            #Lets read source.properties file to get highest available build-tools
-            src_prop_path = File.join($androidsdkpath, "build-tools",entry,"source.properties")
-            next unless File.file?(src_prop_path)
-
-            File.open(src_prop_path) do |f|
-              f.each_line do |line|
-                build_tools[entry] = line.split('=')[1].gsub("\n",'') if line.match(/^Pkg.Revision=/)
-              end
-            end
-          end
-
-          latest_build_tools = build_tools.sort_by{|folder_name,sdk_version| sdk_version}.last
-          build_tools_path = latest_build_tools[0]
-        end
-      end
-
-      if build_tools_path
-        puts "Using Android SDK build-tools: #{build_tools_path}"
-        build_tools_path = File.join $androidsdkpath,'build-tools',build_tools_path
-        $dxjar = File.join(build_tools_path,'lib','dx.jar')
-        $aapt = File.join(build_tools_path, "aapt#{$exe_ext}")
-      else
-        $dxjar = File.join($androidsdkpath, "platforms", $androidplatform, "tools", "lib", "dx.jar")
-        $dxjar = File.join($androidsdkpath, "platform-tools", "lib", "dx.jar") unless File.exists? $dxjar
-        $aapt = File.join($androidsdkpath, "platforms", $androidplatform, "tools", "aapt" + $exe_ext)
-        $aapt = File.join($androidsdkpath, "platform-tools", "aapt" + $exe_ext) unless File.exists? $aapt
-      end
+      $bundletool = File.join($startdir, "res", "build-tools", "bundletool.jar")
 
       $androidbin = File.join($androidsdkpath, "tools", "android" + $bat_ext)
       $adb = find_file( "adb" + $exe_ext,
@@ -710,6 +841,7 @@ namespace "config" do
       $keytool = File.join($java, "keytool" + $exe_ext)
       $jarsigner = File.join($java, "jarsigner" + $exe_ext)
       $jarbin = File.join($java, "jar" + $exe_ext)
+      $javabin = File.join( $java, 'java' + $exe_ext )
 
       $keystore = nil
       $keystore = $app_config["android"]["production"]["certificate"] if !$app_config["android"].nil? and !$app_config["android"]["production"].nil?
@@ -734,15 +866,15 @@ namespace "config" do
       AndroidTools.jarsigner = $jarsigner
       AndroidTools.zipalign = $zipalign
       AndroidTools.keytool = $keytool
-
-      $sdklibjar = AndroidTools.findSdkLibJar $androidsdkpath
+      AndroidTools.jarbin = $jarbin
+      AndroidTools.apksigner = File.join(build_tools_path,'apksigner'+$bat_ext)
     end
 
     $app_config["capabilities"] += ANDROID_CAPS_ALWAYS_ENABLED
     $app_config["capabilities"].map! { |cap| cap.is_a?(String) ? cap : nil }.delete_if { |cap| cap.nil? }
     $use_google_addon_api = true unless $app_config["capabilities"].index("push").nil?
 
-    puts "Use Google addon API (2): #{$use_google_addon_api}" if USE_TRACES
+    $logger.debug "Use Google addon API (2): #{$use_google_addon_api}"    
 
     $appname = $app_config["name"]
     $appname = "Rhodes" if $appname.nil?
@@ -781,20 +913,30 @@ namespace "config" do
     if !$skip_checking_Android_SDK
       # Detect Google API add-on path
       if $use_google_addon_api
-        puts "Looking for Google API SDK add-on..." if USE_TRACES
-        #google_jars = ['com.google.android.maps']
+        $logger.debug "Looking for Google API SDK add-on..."
         $google_classpath = AndroidTools::get_addon_classpath('Google APIs', $found_api_level)
       end
 
-      AndroidTools::MavenDepsExtractor.instance.add_dependency('com.android.support:support-v4:25.2.0')
-
       #setup_ndk($androidndkpath, $found_api_level, 'arm')
       $abis = $app_config['android']['abis'] if $app_config["android"]
       $abis = ['arm'] unless $abis
-    end
 
-    $native_libs = ["sqlite", "curl", "ruby", "json", "rhocommon", "rhodb", "rholog", "rhosync", "rhomain"]
+      #build config
+      core_build_cfg = {}
 
+      begin
+        core_build_cfg = YAML.load_file(File.join( $builddir, 'config.yml'))
+      rescue Exception => e
+        $logger.warn "Can't read core build config: #{e.inspect}"
+      end
+
+      if core_build_cfg['maven_deps']
+        core_build_cfg['maven_deps'].each { |d|
+          AndroidTools::MavenDepsExtractor.instance.add_dependency( d )      
+        }
+      end
+    end
+    
     unless $debug
       $confdir = "release"
     else
@@ -803,15 +945,6 @@ namespace "config" do
 
     $app_builddir = File.join($bindir, 'target', 'android', $confdir)
 
-    $objdir = {}
-    $libname = {}
-    $native_libs.each do |x|
-      $objdir[x] = File.join($tmpdir, x)
-
-      #TODO: path is actually incorrect since library build splits it to dirname and basename inserting ABI in between. Not touching it right now not wanting to break things, but need to review/fix it eventually.
-      $libname[x] = File.join($app_builddir, x, "lib#{x}.a")
-    end
-
     $push_sender = nil
     $push_sender = $config["android"]["push"]["sender"] if !$config["android"].nil? and !$config["android"]["push"].nil?
     $push_sender = $app_config["android"]["push"]["sender"] if !$app_config["android"].nil? and !$app_config["android"]["push"].nil?
@@ -881,6 +1014,7 @@ namespace "config" do
     mkdir_p $targetdir if not File.exists? $targetdir
     mkdir_p $srcdir if not File.exists? $srcdir
 
+    init_aapt2_helper
 
     print_timestamp('config:android FINISH')
 
@@ -916,6 +1050,8 @@ namespace "config" do
       $ext_android_library_deps = {}
       $ext_android_platform_lib = []
 
+      preload_java_classes = []
+
       $app_extensions_list.each do |ext, extpath|
         next if extpath.nil?
 
@@ -1100,11 +1236,11 @@ namespace "config" do
           else
             rakepath = extpath
           end
-          $ext_android_build_scripts[ext] = [rakepath, 'rake']
+          $ext_android_build_scripts[ext] = [rakepath, 'rake', extpath]
 
           if prebuild_rake_task
             args = [ prebuild_rake_task ]
-            args << '--trace' if USE_TRACES
+            args << '--trace' if Rake.application.options.trace
             cc_run( 'rake', args, rakepath, true, setup_ext_env( extpath, ext ) ) or raise "Extension prebuild failed: #{extpath}"
           end
 
@@ -1119,19 +1255,20 @@ namespace "config" do
           end
         end
 
+        preload_java_classes.push(*extconf_android["preload_java_classes"]) if (extconf_android && extconf_android["preload_java_classes"])
+
         puts "#{extpath} is configured"
       end # $app_extensions_list.each
 
+      mkdir_p(File.join( $tmpdir, "include" ) )
+      File.open( File.join( $tmpdir, "include", "rhojava_extra.inc" ), "w" ) { |f|
+        preload_java_classes.each { |cls| f.puts( "\"#{cls}\"," ) }
+      }
+
       puts "Extensions' java source lists: #{$ext_android_additional_sources.inspect}"
 
       AndroidTools::MavenDepsExtractor.instance.extract_all
 
-      if !AndroidTools::MavenDepsExtractor.instance.have_v4_support_lib?
-        v4jar = Dir.glob(File.join($androidsdkpath,'extras','android','**','v4','android-support-v4.jar'))
-        raise "Support-v4 library was not found neither in SDK extras nor in m2 repository" if v4jar.size !=1
-        $v4support_classpath = v4jar.first
-      end
-
 
       print_timestamp('android:extensions FINISH')
 
@@ -1173,6 +1310,54 @@ end
 namespace "build" do
   namespace "android" do
 
+    task :rhodeslib_bundle, [:target_path]  => ["config:set_android_platform", "config:common"] do |t, args|
+      print_timestamp('build:android:rhodeslib_bundle START')
+        target_path = args[:target_path]
+
+        $skip_build_rhodes_main = true
+        $skip_build_extensions = true
+        $skip_build_xmls = true
+        $use_prebuild_data = true
+
+        Rake::Task['config:android'].invoke
+
+        appname = $app_config["name"] ? $app_config["name"] : "rhorunner"
+        appname_fixed = appname.split(/[^a-zA-Z0-9]/).map { |w| w }.join("")
+
+        Rake::Task['build:android:rhobundle'].invoke
+
+        mkdir_p target_path if not File.exists? target_path
+
+        source_RhoBundle = $appassets
+
+        rm_rf File.join(target_path, "apps") if File.exists? File.join(target_path, "apps")
+        rm_rf File.join(target_path, "db") if File.exists? File.join(target_path, "db")
+        rm_rf File.join(target_path, "lib") if File.exists? File.join(target_path, "lib")
+        rm_rf File.join(target_path, "hash") if File.exists? File.join(target_path, "hash")
+        rm_rf File.join(target_path, "name") if File.exists? File.join(target_path, "name")
+        rm_rf File.join(target_path, "rho.dat") if File.exists? File.join(target_path, "rho.dat")
+
+        cp_r File.join(source_RhoBundle, "apps"), target_path
+        cp_r File.join(source_RhoBundle, "db"), target_path
+        cp_r File.join(source_RhoBundle, "lib"), target_path
+        cp_r File.join(source_RhoBundle, "hash"), target_path
+        cp_r File.join(source_RhoBundle, "name"), target_path
+        cp_r File.join(source_RhoBundle, "rho.dat"), target_path
+
+      print_timestamp('build:android:rhodeslib_bundle FINISH')
+    end
+
+    task :rhodeslib_lib, [:target_path] => [:rhobundle] do |t, args|
+      print_timestamp('build:android:rhodeslib_lib START')
+      $rhodes_as_lib = true
+      Rake::Task["package:android"].invoke
+      target_path = args[:target_path]
+      mkdir_p target_path if not File.exists? target_path
+      cp_r File.join($bindir, "#{$appname}-#{$app_config["version"]}.aar"), target_path
+      print_timestamp('build:android:rhodeslib_lib FINISH')
+    end
+
+
     desc "Build RhoBundle for android"
     task :rhobundle => ["config:android"] do
       print_timestamp('build:android:rhobundle START')
@@ -1219,7 +1404,7 @@ namespace "build" do
       ENV["RHO_APP_DIR"] = $app_path
       ENV["ANDROID_SDK"] = $androidsdkpath
       ENV["ANDROID_NDK"] = $androidndkpath
-      ENV["ANDROID_API_LEVEL"] = $found_api_level.to_s
+      ENV["ANDROID_API_LEVEL"] = $min_sdk_level.to_s
       ENV["RHO_ROOT"] = $startdir
       ENV["BUILD_DIR"] ||= $startdir + "/platform/android/build"
       ENV["RHO_INC"] = $appincdir
@@ -1228,9 +1413,25 @@ namespace "build" do
       ENV["NEON_ROOT"] = $neon_root unless $neon_root.nil?
       ENV["CONFIG_XML"] = $config_xml unless $config_xml.nil?
       ENV["RHO_DEBUG"] = $debug.to_s
-      ENV["CUSTOM_FCM_SENDER_ID"] = $app_config["android"]["fcmSenderID"] unless $app_config["android"].nil?
-      ENV["CUSTOM_FCM_APPLICATION_ID"] = $app_config["android"]["fcmAppID"] unless $app_config["android"].nil?
+      if (not $app_config["android"].nil?) and (not $app_config["android"]["fcm"].nil?)
+        ENV["FCM_MPBILESDK_APP_ID"] = $app_config["android"]["fcm"]["mobilesdk_app_id"]
+        ENV["FCM_PROJECT_NUMBER"] = $app_config["android"]["fcm"]["project_number"]
+        ENV["FCM_CURRENT_KEY"] = $app_config["android"]["fcm"]["current_key"]
+        ENV["FCM_PROJECT_ID"] = $app_config["android"]["fcm"]["project_id"]
+      end
+      
+      ENV["BARCODE_ENGINE"] = 'google' #by default
 
+      unless $app_config['android']&.[]('barcode_engine').nil?
+        engine = $app_config['android']['barcode_engine']
+        case engine
+        when 'zxing'
+          ENV["BARCODE_ENGINE"] = 'zxing'
+        else
+          raise 'Only supported barcode engines are: google(default) and zxing'
+        end
+      end
+      
       $ext_android_build_scripts.each do |ext, builddata|
 
         puts "Building #{ext}: #{builddata.inspect}"
@@ -1273,10 +1474,13 @@ namespace "build" do
                 args << "-f"
                 args << "\"#{File.join($startdir,'platform','android','build','Rakefile')}\""
               end
-              args << '--trace' if USE_TRACES
+              args << '--trace' if Rake.application.options.trace
             end
 
-            cc_run(builddata[1], args, builddata[0], false, nil, USE_TRACES) or raise "Extension build failed: #{builddata[0]}"
+            
+            #puts "builddata: " + builddata[1] + " args: " + args.to_s + " builddata0: " + builddata[0].to_s
+            #puts ENV.to_s
+            cc_run(builddata[1], args, builddata[0], false, nil, Rake.application.options.trace) or raise "Extension build failed: #{builddata[0]}"
           else
             currentdir = Dir.pwd()
             Dir.chdir builddata[0]
@@ -1348,37 +1552,100 @@ namespace "build" do
       print_timestamp('build:android:extensions FINISH')
     end #task :extensions
 
+    class BuildContext
+      attr_accessor :libname
+      attr_accessor :sourcelist
+      attr_accessor :extra_copmiler_args
+    end
+
+    class LibBuilder     
+
+      attr_accessor :context
+
+      @@results = {}
+
+      def self.results
+        @@results
+      end
+
+      def self.results=v
+        @@results = v
+      end
+
+      def initialize
+        @context = BuildContext.new
+        @context.extra_copmiler_args = []
+      end
+
+      def build
+        objdir = File.join($tmpdir, @context.libname)
+        libdir = File.join($app_builddir, @context.libname)
+        mkdir_p libdir unless File.directory? libdir
+
+        args = []
+
+        args.concat @context.extra_copmiler_args        
+
+        ENV['SOURCEPATH'] = File.join($androidpath,'..','..')
+        ENV['SOURCELIST'] = @context.sourcelist
+        ENV["ANDROID_NDK"] = $androidndkpath
+        ENV["ANDROID_API_LEVEL"] = $min_sdk_level.to_s
+        ENV["RHO_ROOT"] = $startdir
+        ENV["RHO_INC"] = $appincdir
+        ENV["TARGETPATH"] = libdir
+        ENV['TARGETLIB'] = "lib#{@context.libname}.a"
+        ENV['TEMP_FILES_DIR'] = objdir
+        ENV['BUILDARGS'] = args.join(' ')
+
+        $abis.each { |abi|
+          args = ['-f', "\"#{File.join( $builddir,'Rakefile')}\"", "arch:#{abi}"]
+          args << '-m'
+          args << '--trace' if Rake.application.options.trace
+          cc_run('rake', args, nil, false, nil, Rake.application.options.trace) or raise "Build failed: #{@context.libname}"
+        }
+
+        LibBuilder.results[@context.libname] = libdir
+      end
+    end
+
     task :libsqlite => "config:android" do
       print_timestamp('build:android:libsqlite START')
 
+      b = LibBuilder.new
+      b.context.libname = 'sqlite'
+      b.context.sourcelist = File.join($builddir, 'libsqlite_build.files')
+
       srcdir = File.join($shareddir, "sqlite")
-      objdir = $objdir["sqlite"]
-      libname = $libname["sqlite"]
-      sourcelist = File.join($builddir, 'libsqlite_build.files')
+      b.context.extra_copmiler_args = [
+        "-I\"#{srcdir}\"",
+        "-I\"#{$shareddir}\""
+      ]
+      b.build
 
-      libdir = File.dirname(libname)
-      mkdir_p libdir unless File.directory? libdir
+      print_timestamp('build:android:libsqlite FINISH')
+    end
 
-      args = ["-I\"#{srcdir}\"", "-I\"#{$shareddir}\""]
+    #not real build, just copy existing .so to build dir
+    task :libopenssl => "config:android" do
 
-      ENV['SOURCEPATH'] = File.join($androidpath,'..','..')
-      ENV['SOURCELIST'] = File.join($builddir, 'libsqlite_build.files')
-      ENV["ANDROID_NDK"] = $androidndkpath
-      ENV["ANDROID_API_LEVEL"] = $found_api_level.to_s
-      ENV["RHO_ROOT"] = $startdir
-      ENV["RHO_INC"] = $appincdir
-      ENV["TARGETPATH"] = File.dirname($libname["sqlite"])
-      ENV['TARGETLIB'] = File.basename($libname["sqlite"])
-      ENV['TEMP_FILES_DIR'] = $objdir["sqlite"]
-      ENV['BUILDARGS'] = args.join(' ')
+      skip = ($app_config['extensions'].index('openssl.so') || $app_config['extensions'].index('openssl'))    
+      next if skip
+
+      print_timestamp('build:android:libopenssl START')
+
+      libdir = File.join($app_builddir, 'openssl')
+      mkdir_p libdir unless File.directory? libdir
+
+      src_dir = "#{$shareddir}/../../lib/extensions/openssl.so/ext/android"
 
       $abis.each do |abi|
-        args = ['-f', "\"#{File.join($builddir,'Rakefile')}\"", "arch:#{abi}"]
-        args << '-m'
-        args << '--trace' if USE_TRACES
-        cc_run('rake', args, nil, false, nil, USE_TRACES) or raise "Build failed: sqlite"
+        realabi = abi
+        realabi = 'armeabi' if abi == 'arm'
+        mkdir_p File.join(libdir, realabi) unless File.directory? File.join(libdir, realabi)
+        cp_r File.join(src_dir, realabi, "libopenssl.so.a"), File.join(libdir, realabi, "libopenssl.a")
       end
-      print_timestamp('build:android:libsqlite FINISH')
+
+      LibBuilder.results['openssl'] = libdir
     end
 
     task :libcurl => "config:android" do
@@ -1391,291 +1658,166 @@ namespace "build" do
       #export CPPFLAGS="--sysroot <ndkroot>/build/platforms/android-3/arch-arm -fPIC -mandroid -DANDROID -DOS_ANDROID"
       #./configure --without-ssl --without-ca-bundle --without-ca-path --without-libssh2 --without-libidn --disable-ldap --disable-ldaps --host=arm-eabi
 
-      srcdir = File.join $shareddir, "curl", "lib"
-      objdir = $objdir["curl"]
-      libname = $libname["curl"]
-      sourcelist = File.join($builddir, 'libcurl_build.files')
+      b = LibBuilder.new      
+      b.context.libname = 'curl'
+      b.context.sourcelist = File.join($builddir, 'libcurl_build.files')
 
-      libdir = File.dirname(libname)
-      mkdir_p libdir unless File.directory? libdir
-
-      args = []
-      args << "-DHAVE_CONFIG_H"
-      args << "-I\"#{srcdir}/../include\""
-      args << "-I\"#{srcdir}\""
-      args << "-I\"#{$shareddir}\""
-
-      ENV['SOURCEPATH'] = File.join($androidpath,'..','..')
-      ENV['SOURCELIST'] = File.join($builddir, 'libcurl_build.files')
-      ENV["ANDROID_NDK"] = $androidndkpath
-      ENV["ANDROID_API_LEVEL"] = $found_api_level.to_s
-      ENV["RHO_ROOT"] = $startdir
-      ENV["RHO_INC"] = $appincdir
-      ENV["TARGETPATH"] = File.dirname($libname["curl"])
-      ENV['TARGETLIB'] = File.basename($libname["curl"])
-      ENV['TEMP_FILES_DIR'] = $objdir["curl"]
-      ENV['BUILDARGS'] = args.join(' ')
+      srcdir = File.join $shareddir, "curl", "lib"
+      b.context.extra_copmiler_args = [
+        "-DHAVE_CONFIG_H",
+        "-I\"#{srcdir}/../include\"",
+        "-I\"#{srcdir}\"",
+        "-I\"#{srcdir}/vtls\"",
+        "-I\"#{srcdir}/vauth\"",
+        "-I\"#{$shareddir}\"",
+        "-I\"#{$shareddir}/../../lib/extensions/openssl.so/ext/sources/include\""
+      ]
+      b.build
 
-      $abis.each do |abi|
-        args = ['-f', "\"#{File.join($builddir,'Rakefile')}\"", "arch:#{abi}"]
-        args << '-m'
-        args << '--trace' if USE_TRACES
-        cc_run('rake', args, nil, false, nil, USE_TRACES) or raise "Build failed: curl"
-      end
       print_timestamp('build:android:libcurl FINISH')
     end
 
     task :libruby => "config:android" do
       print_timestamp('build:android:libruby START')
-      srcdir = File.join $shareddir, "ruby"
-      objdir = $objdir["ruby"]
-      libname = $libname["ruby"]
-      sourcelist = File.join($builddir, 'libruby_build.files')
-
-      libdir = File.dirname(libname)
-      mkdir_p libdir unless File.directory? libdir
-
-      args = []
-      args << "-DRUBY_EXPORT"
-      args << "-Wno-uninitialized"
-      args << "-Wno-missing-field-initializers"
-      args << '-Wno-shadow'
-      args << "-I\"#{srcdir}/include\""
-      args << "-I\"#{srcdir}/android\""
-      args << "-I\"#{srcdir}/generated\""
-      args << "-I\"#{srcdir}\""
-      args << "-I\"#{srcdir}/..\""
-      args << "-I\"#{srcdir}/../sqlite\""
 
-      ENV['SOURCEPATH'] = File.join($androidpath,'..','..')
-      ENV['SOURCELIST'] = File.join($builddir, 'libruby_build.files')
-      ENV["ANDROID_NDK"] = $androidndkpath
-      ENV["ANDROID_API_LEVEL"] = $found_api_level.to_s
-      ENV["RHO_ROOT"] = $startdir
-      ENV["RHO_INC"] = $appincdir
-      ENV["TARGETPATH"] = File.dirname($libname["ruby"])
-      ENV['TARGETLIB'] = File.basename($libname["ruby"])
-      ENV['TEMP_FILES_DIR'] = $objdir["ruby"]
-      ENV['BUILDARGS'] = args.join(' ')
+      b = LibBuilder.new      
+      b.context.libname = 'ruby'
+      b.context.sourcelist = File.join($builddir, 'libruby_build.files')
+
+      srcdir = File.join($shareddir, "ruby")
+      b.context.extra_copmiler_args = [   
+        "-DRUBY_EXPORT",
+        "-Wno-uninitialized",
+        "-Wno-missing-field-initializers",
+        '-Wno-shadow',
+        "-I\"#{srcdir}/include\"",
+        "-I\"#{srcdir}/android\"",
+        "-I\"#{srcdir}/generated\"",
+        "-I\"#{srcdir}\"",
+        "-I\"#{srcdir}/..\""
+#        "-I\"#{b.context.srcdir}/../sqlite\""    
+      ]
+      b.build
 
-      $abis.each do |abi|
-        args = ['-f', "\"#{File.join($builddir,'Rakefile')}\"", "arch:#{abi}"]
-        args << '-m'
-        args << '--trace' if USE_TRACES
-        cc_run('rake', args, nil, false, nil, USE_TRACES) or raise "Build failed: ruby"
-      end
       print_timestamp('build:android:libruby FINISH')
     end
 
     task :libjson => "config:android" do
       print_timestamp('build:android:libjson START')
-      srcdir = File.join $shareddir, "json"
-      objdir = $objdir["json"]
-      libname = $libname["json"]
-      sourcelist = File.join($builddir, 'libjson_build.files')
 
-      libdir = File.dirname(libname)
-      mkdir_p libdir unless File.directory? libdir
+      b = LibBuilder.new      
+      b.context.libname = 'json'
+      b.context.sourcelist = File.join($builddir, 'libjson_build.files')
 
-      args = []
-      args << "-I\"#{srcdir}\""
-      args << "-I\"#{srcdir}/..\""
+      srcdir = File.join($shareddir, "json")
+      b.context.extra_copmiler_args = [   
+        "-I\"#{srcdir}\"",
+        "-I\"#{srcdir}/..\""
+      ]
+      b.build
 
-      ENV['SOURCEPATH'] = File.join($androidpath,'..','..')
-      ENV['SOURCELIST'] = File.join($builddir, 'libjson_build.files')
-      ENV["ANDROID_NDK"] = $androidndkpath
-      ENV["ANDROID_API_LEVEL"] = $found_api_level.to_s
-      ENV["RHO_ROOT"] = $startdir
-      ENV["RHO_INC"] = $appincdir
-      ENV["TARGETPATH"] = File.dirname($libname["json"])
-      ENV['TARGETLIB'] = File.basename($libname["json"])
-      ENV['TEMP_FILES_DIR'] = $objdir["json"]
-      ENV['BUILDARGS'] = args.join(' ')
-
-      $abis.each do |abi|
-        args = ['-f', "\"#{File.join($builddir,'Rakefile')}\"", "arch:#{abi}"]
-        args << '-m'
-        args << '--trace' if USE_TRACES
-        cc_run('rake', args, nil, false, nil, USE_TRACES) or raise "Build failed: json"
-      end
       print_timestamp('build:android:libjson FINISH')
     end
 
     task :librholog => "config:android" do
       print_timestamp('build:android:librholog START')
-      srcdir = File.join $shareddir, "logging"
-      objdir = $objdir["rholog"]
-      libname = $libname["rholog"]
-      sourcelist = File.join($builddir, 'librholog_build.files')
-
-      libdir = File.dirname(libname)
-      mkdir_p libdir unless File.directory? libdir
 
-      args = []
-      args << "-I\"#{srcdir}/..\""
+      b = LibBuilder.new      
+      b.context.libname = 'rholog'
+      b.context.sourcelist = File.join($builddir, 'librholog_build.files')
 
-      ENV['SOURCEPATH'] = File.join($androidpath,'..','..')
-      ENV['SOURCELIST'] = File.join($builddir, 'librholog_build.files')
-      ENV["ANDROID_NDK"] = $androidndkpath
-      ENV["ANDROID_API_LEVEL"] = $found_api_level.to_s
-      ENV["RHO_ROOT"] = $startdir
-      ENV["RHO_INC"] = $appincdir
-      ENV["TARGETPATH"] = File.dirname($libname['rholog'])
-      ENV['TARGETLIB'] = File.basename($libname['rholog'])
-      ENV['TEMP_FILES_DIR'] = $objdir['rholog']
-      ENV['BUILDARGS'] = args.join(' ')
+      srcdir = File.join($shareddir, "logging")
+      b.context.extra_copmiler_args = [   
+        "-I\"#{srcdir}/..\""
+      ]
+      b.build
 
-      $abis.each do |abi|
-        args = ['-f', "\"#{File.join($builddir,'Rakefile')}\"", "arch:#{abi}"]
-        args << '-m'
-        args << '--trace' if USE_TRACES
-        cc_run('rake', args, nil, false, nil, USE_TRACES) or raise "Build failed: rholog"
-      end
       print_timestamp('build:android:librholog FINISH')
     end
 
     task :librhomain => "config:android" do
       print_timestamp('build:android:librhomain START')
-      srcdir = $shareddir
-      objdir = $objdir["rhomain"]
-      libname = $libname["rhomain"]
-      sourcelist = File.join($builddir, 'librhomain_build.files')
-
-      libdir = File.dirname(libname)
-      mkdir_p libdir unless File.directory? libdir
-
-      args = []
-      args << "-I\"#{srcdir}\""
-      args << "-I\"#{$commonapidir}\""
 
-      ENV['SOURCEPATH'] = File.join($androidpath,'..','..')
-      ENV['SOURCELIST'] = File.join($builddir, 'librhomain_build.files')
-      ENV["ANDROID_NDK"] = $androidndkpath
-      ENV["ANDROID_API_LEVEL"] = $found_api_level.to_s
-      ENV["RHO_ROOT"] = $startdir
-      ENV["RHO_INC"] = $appincdir
-      ENV["TARGETPATH"] = File.dirname($libname['rhomain'])
-      ENV['TARGETLIB'] = File.basename($libname['rhomain'])
-      ENV['TEMP_FILES_DIR'] = $objdir['rhomain']
-      ENV['BUILDARGS'] = args.join(' ')
+      b = LibBuilder.new
+      b.context.libname = 'rhomain'
+      b.context.sourcelist = File.join($builddir, 'librhomain_build.files')
+      b.context.extra_copmiler_args = [   
+        "-I\"#{$shareddir}\"",
+        "-I\"#{$commonapidir}\""
+      ]
+      b.build
 
-      $abis.each do |abi|
-        args = ['-f', "\"#{File.join($builddir,'Rakefile')}\"", "arch:#{abi}"]
-        args << '-m'
-        args << '--trace' if USE_TRACES
-        cc_run('rake', args, nil, false, nil, USE_TRACES) or raise "Build failed: rhomain"
-      end
       print_timestamp('build:android:librhomain FINISH')
     end
 
     task :librhocommon => "config:android" do
       print_timestamp('build:android:librhocommon START')
-      objdir = $objdir["rhocommon"]
-      libname = $libname["rhocommon"]
-      sourcelist = File.join($builddir, 'librhocommon_build.files')
 
-      libdir = File.dirname(libname)
-      mkdir_p libdir unless File.directory? libdir
+      b = LibBuilder.new
+      b.context.libname = 'rhocommon'
+      b.context.sourcelist = File.join($builddir, 'librhocommon_build.files')
+      b.context.extra_copmiler_args = [   
+        "-I\"#{$shareddir}\"",
+        "-I\"#{$shareddir}/curl/include\"",
+        "-I\"#{$shareddir}/ruby/include\"",
+        "-I\"#{$shareddir}/ruby/android\"",
+        "-I\"#{$shareddir}/../../lib/extensions/openssl.so/ext/sources/include\""
+      ]
+      b.build
 
-      args = []
-      args << "-I\"#{$shareddir}\""
-      args << "-I\"#{$shareddir}/curl/include\""
-      args << "-I\"#{$shareddir}/ruby/include\""
-      args << "-I\"#{$shareddir}/ruby/android\""
-
-      ENV['SOURCEPATH'] = File.join($androidpath,'..','..')
-      ENV['SOURCELIST'] = File.join($builddir, 'librhocommon_build.files')
-      ENV["ANDROID_NDK"] = $androidndkpath
-      ENV["ANDROID_API_LEVEL"] = $found_api_level.to_s
-      ENV["RHO_ROOT"] = $startdir
-      ENV["RHO_INC"] = $appincdir
-      ENV["TARGETPATH"] = File.dirname($libname['rhocommon'])
-      ENV['TARGETLIB'] = File.basename($libname['rhocommon'])
-      ENV['TEMP_FILES_DIR'] = $objdir['rhocommon']
-      ENV['BUILDARGS'] = args.join(' ')
-
-      $abis.each do |abi|
-        args = ['-f', "\"#{File.join($builddir,'Rakefile')}\"", "arch:#{abi}"]
-        args << '-m'
-        args << '--trace' if USE_TRACES
-        cc_run('rake', args, nil, false, nil, USE_TRACES) or raise "Build failed: rhocommon"
-      end
       print_timestamp('build:android:librhocommon FINISH')
     end
 
     task :librhodb => "config:android" do
       print_timestamp('build:android:librhodb START')
-      srcdir = File.join $shareddir, "db"
-      objdir = $objdir["rhodb"]
-      libname = $libname["rhodb"]
-      sourcelist = File.join($builddir, 'librhodb_build.files')
-
-      libdir = File.dirname(libname)
-      mkdir_p libdir unless File.directory? libdir
 
-      args = []
-      args << "-I\"#{srcdir}\""
-      args << "-I\"#{srcdir}/..\""
-      args << "-I\"#{srcdir}/../sqlite\""
-      args << "-I\"#{$shareddir}/ruby/include\""
-      args << "-I\"#{$shareddir}/ruby/android\""
+      b = LibBuilder.new      
+      b.context.libname = 'rhodb'
+      b.context.sourcelist = File.join($builddir, 'librhodb_build.files')
 
-      ENV['SOURCEPATH'] = File.join($androidpath,'..','..')
-      ENV['SOURCELIST'] = File.join($builddir, 'librhodb_build.files')
-      ENV["ANDROID_NDK"] = $androidndkpath
-      ENV["ANDROID_API_LEVEL"] = $found_api_level.to_s
-      ENV["RHO_ROOT"] = $startdir
-      ENV["RHO_INC"] = $appincdir
-      ENV["TARGETPATH"] = File.dirname($libname['rhodb'])
-      ENV['TARGETLIB'] = File.basename($libname['rhodb'])
-      ENV['TEMP_FILES_DIR'] = $objdir['rhodb']
-      ENV['BUILDARGS'] = args.join(' ')
+      srcdir = File.join($shareddir, "db")
+      b.context.extra_copmiler_args = [   
+        "-I\"#{srcdir}\"",
+        "-I\"#{srcdir}/..\"",
+        "-I\"#{srcdir}/../sqlite\"",
+        "-I\"#{$shareddir}/ruby/include\"",
+        "-I\"#{$shareddir}/ruby/android\""
+      ]
+      b.build
 
-      $abis.each do |abi|
-        args = ['-f', "\"#{File.join($builddir,'Rakefile')}\"", "arch:#{abi}"]
-        args << '-m'
-        args << '--trace' if USE_TRACES
-        cc_run('rake', args, nil, false, nil, USE_TRACES) or raise "Build failed: rhodb"
-      end
       print_timestamp('build:android:librhodb FINISH')
     end
 
     task :librhosync => "config:android" do
       print_timestamp('build:android:librhosync START')
-      srcdir = File.join $shareddir, "sync"
-      objdir = $objdir["rhosync"]
-      libname = $libname["rhosync"]
-      sourcelist = File.join($builddir, 'librhosync_build.files')
-
-      libdir = File.dirname(libname)
-      mkdir_p libdir unless File.directory? libdir
 
-      args = []
-      args << "-I\"#{srcdir}\""
-      args << "-I\"#{srcdir}/..\""
-      args << "-I\"#{srcdir}/../sqlite\""
+      b = LibBuilder.new      
+      b.context.libname = 'rhosync'
+      b.context.sourcelist = File.join($builddir, 'librhosync_build.files')
 
-      ENV['SOURCEPATH'] = File.join($androidpath,'..','..')
-      ENV['SOURCELIST'] = File.join($builddir, 'librhosync_build.files')
-      ENV["ANDROID_NDK"] = $androidndkpath
-      ENV["ANDROID_API_LEVEL"] = $found_api_level.to_s
-      ENV["RHO_ROOT"] = $startdir
-      ENV["RHO_INC"] = $appincdir
-      ENV["TARGETPATH"] = File.dirname($libname['rhosync'])
-      ENV['TARGETLIB'] = File.basename($libname['rhosync'])
-      ENV['TEMP_FILES_DIR'] = $objdir['rhosync']
-      ENV['BUILDARGS'] = args.join(' ')
+      srcdir = File.join($shareddir, "sync")
+      b.context.extra_copmiler_args = [
+        "-I\"#{srcdir}\"",   
+        "-I\"#{srcdir}/..\"",
+        "-I\"#{srcdir}/../sqlite\""
+      ]
+      b.build      
 
-      $abis.each do |abi|
-        args = ['-f', "\"#{File.join($builddir,'Rakefile')}\"", "arch:#{abi}"]
-        args << '-m'
-        args << '--trace' if USE_TRACES
-        cc_run('rake', args, nil, false, nil, USE_TRACES) or raise "Build failed: rhosync"
-      end
       print_timestamp('build:android:librhosync FINISH')
     end
 
-    task :libs => [:libsqlite, :libcurl, :libruby, :libjson, :librhodb, :librhocommon, :librhomain, :librhosync, :librholog]
+    task :libs => [
+      :libsqlite, 
+      :libcurl, 
+      :libruby, 
+      :libjson, 
+      :librhodb, 
+      :librhocommon, 
+      :librhomain, 
+      :librhosync, 
+      :librholog, 
+      :libopenssl
+    ]
 
     task :genconfig => "config:android" do
       print_timestamp('build:android:genconfig START')
@@ -1745,6 +1887,12 @@ namespace "build" do
       print_timestamp('build:android:genconfig FINISH')
     end
 
+    def clear_flats(path)
+      Dir.glob(File.join(path,'**','*.flat')) do |filepath|
+        rm_rf filepath
+      end
+    end
+
     task :librhodes => [:libs, :extensions, :genconfig] do
       print_timestamp('build:android:librhodes START')
       if $skip_so_build
@@ -1764,12 +1912,14 @@ namespace "build" do
       args << "-I\"#{$shareddir}/curl/include\""
       args << "-I\"#{$shareddir}/ruby/include\""
       args << "-I\"#{$shareddir}/ruby/android\""
+      args << "-I\"#{$shareddir}/../../lib/extensions/openssl.so/ext/sources/include\""
       args << "-I\"#{$coreapidir}\""
+      args << "-I\"#{File.join($tmpdir,"include")}\""
 
       ENV['SOURCEPATH'] = File.join($androidpath,'..','..')
       ENV['SOURCELIST'] = File.join($builddir, 'librhodes_build.files')
       ENV["ANDROID_NDK"] = $androidndkpath
-      ENV["ANDROID_API_LEVEL"] = $found_api_level.to_s
+      ENV["ANDROID_API_LEVEL"] = $min_sdk_level.to_s
       ENV["RHO_ROOT"] = $startdir
       ENV["RHO_INC"] = $appincdir
       ENV["TARGETPATH"] = File.join $app_builddir, 'librhodes', 'lib'
@@ -1799,23 +1949,14 @@ namespace "build" do
           args << "-L\"#{File.dirname(lib)}\""
         end
 
-        libandroid_support = File.join($androidndkpath, "sources", "cxx-stl", "llvm-libc++", "libs", realabi)
-        
-        if File.exists? libandroid_support
-          args << "-L\"#{libandroid_support}\""
-          args << "-landroid_support"
-          puts "libandroid_support exists"
-        end
-
-
-        
+       
         deps = []
         libs = []
 
-        $libname.each do |name, lib|
-          deps << File.join( File.dirname(lib), realabi, File.basename(lib) )
+        LibBuilder.results.each do |name, libdir|
+          deps << File.join( libdir, realabi, "lib#{name}.a" )
           libs << name
-          args << "-L\"#{File.dirname(lib)}/#{realabi}\""
+          args << "-L\"#{libdir}/#{realabi}\""
         end
         libs.map! { |x| "-l#{x}" }
 
@@ -1853,7 +1994,7 @@ namespace "build" do
         ENV['LINKDEPS'] = (deps+extlibs).join(' ')
 
         args = ['-f', "\"#{File.join($builddir,'Rakefile')}\"", "link:#{abi}"]
-        args << '--trace' #if USE_TRACES
+        args << '--trace'
         cc_run('rake', args, nil, false, nil, true) or raise "Build failed: rhodes"
         #Jake.run3("rake #{args.join(' ')}")
       end
@@ -1885,7 +2026,9 @@ namespace "build" do
 
       version = version["major"]*1000000 + version["minor"]*10000 + version["patch"]*100 + version["build"]
 
-      usesPermissions = ['android.permission.INTERNET', 'android.permission.PERSISTENT_ACTIVITY', 'android.permission.WAKE_LOCK']
+      usesPermissions = ['android.permission.RECEIVE_BOOT_COMPLETED', 'android.permission.INTERNET', 'android.permission.PERSISTENT_ACTIVITY', 'android.permission.WAKE_LOCK']
+      usesPermissions << 'android.permission.FOREGROUND_SERVICE' if ($target_sdk_level >= 28)
+
       $app_config["capabilities"].each do |cap|
         cap = ANDROID_PERMISSIONS[cap]
         next if cap.nil?
@@ -1920,6 +2063,10 @@ namespace "build" do
       generator.hardwareAcceleration = true if $app_config["capabilities"].index('hardware_acceleration')
       generator.apikey = $gapikey if $gapikey
       generator.debuggable = $debug
+      generator.buildSdkVer = $found_api_level
+      generator.buildToolsVer = $build_tools_ver
+      generator.androidVerMaj = $major_version
+      generator.androidVerMin = $minor_version
 
       generator.addUriParams $uri_scheme, $uri_host, $uri_path_prefix
 
@@ -2034,6 +2181,8 @@ namespace "build" do
         end
       end
 
+      set_app_name_android_post($appname)
+
       #copy icon after extension resources in case it overwrites them (like rhoelementsext...)
       set_app_icon_android
 
@@ -2047,17 +2196,44 @@ namespace "build" do
       mkdir_p File.join($applibs,'armeabi')
       mkdir_p File.join($applibs,'armeabi-v7a')
       mkdir_p File.join($applibs,'x86')
+      mkdir_p File.join($applibs,'arm64-v8a')
+
       # Add .so libraries
       Dir.glob($app_builddir + "/**/lib*.so").each do |lib|
         arch = File.basename(File.dirname(lib))
         file = File.basename(lib)
+        arch = 'arm64-v8a' if arch == "aarch64"
         cp_r lib, File.join($applibs,arch,file)
+        
+        localabi = arch
+        localabi = "armeabi-v7a" if arch == "armeabi"
+        llvm_stl = File.join($androidndkpath, "sources", "cxx-stl", "llvm-libc++", "libs", localabi, "libc++_shared.so")
+        if File.exists? llvm_stl
+          cp_r llvm_stl, File.join($applibs,arch)
+        end
       end
       $ext_android_additional_lib.each do |lib|
         arch = File.basename(File.dirname(lib))
         file = File.basename(lib)
         cp_r lib, File.join($applibs,arch,file)
       end
+
+      abi_alter_names = { "armeabi" => "arm", "arm64-v8a" => "aarch64", "x86" => "x86", "armeabi-v7a" => "arm", "x86_64" => "x86_64" }
+      if !$rhodes_as_lib
+        $android_jni_libs = AndroidTools::MavenDepsExtractor.instance.jni_libs
+        $android_jni_libs.each do |lib|
+          arch = File.basename(File.dirname(lib))
+          if !$abis.include?(abi_alter_names[arch])
+            next
+          end
+
+          arch = "armeabi" if arch == "armeabi-v7a"
+          file = File.basename(lib)
+          if Dir.exists? File.join($applibs,arch)
+            cp_r lib, File.join($applibs,arch,file)
+          end
+        end
+      end
       print_timestamp('build:android:resources FINISH')
     end
 
@@ -2167,38 +2343,104 @@ namespace "build" do
     task :genrjava => [:manifest, :resources] do
       mkdir_p $app_rjava_dir
 
-      puts "Generate initial R.java at #{$app_rjava_dir}"
+      $logger.info "Generate initial R.java at #{$app_rjava_dir}"
 
-      args = ["package", "-f", "-M", $appmanifest, "-S", $appres, "-A", $appassets, "-I", $androidjar, "-J", $app_rjava_dir]
-      args += AndroidTools::MavenDepsExtractor.instance.aapt_args
+      $logger.debug $appres.to_s
+      $logger.debug $app_rjava_dir.to_s
 
-      args << '-v' if USE_TRACES
+      unless ($rhodes_as_lib)
+        Aapt2Helper.instance.build_resources( $build_bundle )
+      else
+        mkdir_p $appres_flats
 
-      Jake.run($aapt, args)
+        #walkthrough resources dir
+        Dir.glob(File.join($appres,'**','*.*')) do |filepath|
+          args = ["compile", PathToWindowsWay(filepath), "-o", PathToWindowsWay(File.dirname(filepath))]
+          args << '-v' if Rake.application.options.trace
+          Jake.run($aapt2, args)
+        end
 
-      raise 'Error in AAPT: R.java' unless $?.success?
+        res_dirs = AndroidTools::MavenDepsExtractor.instance.aapt2_res_dirs
+        res_dirs.each do |dir|
+          Dir.glob(File.join(dir,'**','*.*')) do |filepath|
+            args = ["compile", PathToWindowsWay(filepath), "-o", PathToWindowsWay(File.dirname(filepath))]
+            args << '-v' if Rake.application.options.trace
+            Jake.run($aapt2, args)
+          end
+        end
+
+        flaten_list_file_path = File.join($tmpdir, "flaten_list.txt")
+        File.open(flaten_list_file_path, "w") do |f|     
+          Dir.glob(File.join($appres,'**','*.flat')) do |filepath|
+            f.write(filepath)            
+            f.write(" ")
+          end
+
+          res_dirs.each do |dir|
+            Dir.glob(File.join(dir,'**','*.flat')) do |filepath|
+              f.write(filepath)            
+              f.write(" ")
+            end
+          end
+        end
 
-      @packs = AndroidTools::MavenDepsExtractor.instance.extract_packages
-      @packs.each do |p|
+        FormatManifestToAapt2Compat($appmanifest) #what is that?
+        
+        args = 
+        [
+          "link", 
+          "-o", PathToWindowsWay(File.join($bindir, "_tmp.aar")), 
+          "-I", PathToWindowsWay($androidjar),
+          "--manifest", PathToWindowsWay($appmanifest), 
+          "-A", PathToWindowsWay($appassets), 
+          "--java", PathToWindowsWay($app_rjava_dir), 
+          "-R", "@" + PathToWindowsWay(flaten_list_file_path),
+          "--auto-add-overlay"
+        ]
+        
+        args << "--output-text-symbols"
+        args << PathToWindowsWay(File.join($app_rjava_dir, 'R.txt'))
+        args << '-v' if Rake.application.options.trace
+
+        require 'nokogiri'
+        
+        FormatManifestToAarCompat($appmanifest)
+        
+        Jake.run($aapt2, args)
+        raise 'Error in AAPT2: ' + $aapt2 + " " + args.join(' ') unless $?.success?
+
+        #how about some comments on this magic?
+        if(File.exists?(File.join($app_rjava_dir, 'com', $vendor, $appname, 'R.java')))
+          cp_r File.join($app_rjava_dir, 'com', $vendor, $appname, 'R.java'), File.join($app_rjava_dir, 'R.java')
+          rm_rf File.join($app_rjava_dir, 'com', $vendor, $appname, 'R.java')
+        elsif (File.exists?(File.join($app_rjava_dir, $app_package_name.split('.'), 'R.java')))
+          cp_r File.join($app_rjava_dir, $app_package_name.split('.'), 'R.java'), File.join($app_rjava_dir, 'R.java')
+          rm_rf File.join($app_rjava_dir, $app_package_name.split('.'), 'R.java')
+        end
+
+        clear_flats($appres)
+        res_dirs = AndroidTools::MavenDepsExtractor.instance.aapt2_res_dirs
+        res_dirs.each do |dir|
+          clear_flats(dir)
+        end            
+      end            
+      
+      #We should've generated R.java at this point. Now let's duplicate it for our dependencies substituting package names
+      packs = AndroidTools::MavenDepsExtractor.instance.extract_packages
+      packs.each do |p|
         path_to_p = File.join $tmpdir, 'gen', p.split('.')
         mkdir_p path_to_p
         buf = File.new(File.join($app_rjava_dir, "R.java"), "r").read.gsub(/^\s*package\s*#{$app_package_name};\s*$/, "\npackage " + p + ";\n")
         File.open(File.join(path_to_p, "R.java"), "w") { |f| f.write(buf) }
       end
 
-      #buf = File.new($rho_android_r, "r").read.gsub(/^\s*import com\.rhomobile\..*\.R;\s*$/, "\nimport #{$app_package_name}.R;\n")
-      #File.open($app_android_r, "w") { |f| f.write(buf) }
-
       mkdir_p File.join($app_rjava_dir, "R") if not File.exists? File.join($app_rjava_dir, "R")
       buf = File.new(File.join($app_rjava_dir, "R.java"), "r").read.gsub(/^\s*package\s*#{$app_package_name};\s*$/, "\npackage com.rhomobile.rhodes;\n")
-      #buf.gsub!(/public\s*static\s*final\s*int/, "public static int")
       File.open(File.join($app_rjava_dir, "R", "R.java"), "w") { |f| f.write(buf) }
 
       $ext_android_library_deps.each do |package, path|
-
         if !File.directory?(path)
           puts "[WARN] Path for dependency #{package} does not exists (#{path})"
-          #next
         end
 
         next if ((!package) or (package.empty?))
@@ -2261,7 +2503,6 @@ namespace "build" do
       classpath = $androidjar
       classpath += $path_separator + $google_classpath if $google_classpath
       classpath += $path_separator + File.join($tmpdir, 'Rhodes')
-      classpath += $path_separator + $v4support_classpath if $v4support_classpath
       classpath += $path_separator + AndroidTools::MavenDepsExtractor.instance.classpath($path_separator)
 
       javalibsdir = Jake.get_absolute("platform/android/lib")
@@ -2295,7 +2536,6 @@ namespace "build" do
       classpath += $path_separator + $google_classpath if $google_classpath
       #######################################################################
 
-      classpath += $path_separator + $v4support_classpath if $v4support_classpath
       classpath += $path_separator + AndroidTools::MavenDepsExtractor.instance.classpath($path_separator)
       classpath += $path_separator + File.join($tmpdir, 'Rhodes')
       Dir.glob(File.join($app_builddir, '**', '*.jar')).each do |jar|
@@ -2336,7 +2576,6 @@ namespace "build" do
       end
 
       print_timestamp('build:android:extensions_java FINISH')
-      $android_jars << $v4support_classpath if $v4support_classpath
       $android_jars += AndroidTools::MavenDepsExtractor.instance.jars
     end
 
@@ -2489,20 +2728,180 @@ namespace "build" do
   end
 end
 
+def FormatManifestToAarCompat(path)
+  doc = File.open(path) { |f| Nokogiri::XML(f) }
+  root = doc.xpath("//manifest/*")
+  application = root.xpath("//application/*")
+
+  doc2 = doc.xpath("//manifest")
+  doc2[0].remove_attribute("versionCode")
+  doc2[0].remove_attribute("installLocation")
+  doc2[0]["xmlns:tools"] = "http://schemas.android.com/tools"
+
+  root.each do |node|
+    node["tools:node"] = "merge" if node.name.to_s == 'uses-permission'
+    node["tools:node"] = "merge" if node.name.to_s == 'uses-feature'
+    if node.name.to_s == 'application'
+      node["tools:node"] = "merge"
+      node.remove_attribute("name")
+      node.remove_attribute("label")
+      node.remove_attribute("icon")
+    end
+  end
+
+  application.each do |node|
+    node["tools:node"] = "merge" if node["tools:node"] != "replace"
+    if node["android:name"] == 'com.rhomobile.rhodes.RhodesActivity'
+      intent_filters = node.xpath(".//*/*")
+      intent_filters.each do |child|
+        if child["android:name"] == 'android.intent.action.MAIN'
+          child.parent.remove
+        end
+      end
+    end
+  end
+
+  new_doc = Nokogiri::XML::Document.parse(doc.to_s, nil, "UTF-8")
+  File.open(path, "w") {|file| file << new_doc.to_xml }
+end
+
+
+def prepare_aar_package
+  alljars = Dir.glob(File.join($app_builddir, '**', '*.jar'))
+  #alljars += AndroidTools::MavenDepsExtractor.instance.jars
+
+  require 'set'
+  unique_jars = Set.new
+
+  args = ['cvf', 'classes.jar', '-C', '.', '.']
+  jarNamesCounter = 0
+  
+  $allclasses = File.join($tmpdir, '.allclasses')
+  mkdir_p $allclasses
+
+  puts "Creating classes.jar for aar package"
+  
+  if File.exist?(File.join($allclasses, 'classes.jar'))
+    rm_rf File.join($allclasses, 'classes.jar')
+  end
+
+  alljars.each do |jar|
+    Zip::File.open(jar) do |archive|
+      archive.glob("**/*.*").each do |pfile|
+        next if !(pfile.name =~ /.*\.class$/)
+        target = File.join($allclasses, pfile.name)
+        mkdir_p File.dirname(target)
+        rm target if File.file?(target)
+        archive.extract( pfile, File.join(target) )
+      end
+    end
+  end
+
+  if(Dir.exists?(File.join($allclasses, 'com', $vendor , $appname.downcase)))  
+    FileUtils.remove_dir File.join($allclasses, 'com', $vendor , $appname.downcase)
+  elsif(Dir.exists?(File.join($allclasses, $app_package_name.split('.'))))  
+    FileUtils.remove_dir File.join($allclasses, $app_package_name.split('.'))
+  end
+
+  #res_dirs = AndroidTools::MavenDepsExtractor.instance.aapt2_res_dirs
+  #res_dirs.each do |dir|
+  #  Dir.glob(File.join(dir,'**')) do |filepath|
+  #    #cp_r filepath, File.join($tmpdir, 'res', File.basename(filepath) + '-' + File.basename(File.expand_path("..", dir)))
+  #    cp_r filepath, File.join($tmpdir, 'res', File.basename(filepath))
+  #  end
+  #end
+
+  Jake.run($jarbin, args, $allclasses)
+
+  unless $?.success?
+    raise "Error while creating classes.jar"
+  end
+
+  resourcepkg = File.join($bindir, "#{$appname}-#{$app_config["version"]}.aar")
+
+  args = ["cvf", resourcepkg, 'classes.jar']
+  Jake.run($jarbin, args, $allclasses)
+  unless $?.success?
+    raise "Error packaging classes.jar file"
+  end
+
+  mkdir_p File.join($tmpdir, 'jni')
+
+  Dir.glob(File.join($tmpdir, 'lib', '*')).each do |lib|
+    cp_r lib, File.join($tmpdir, 'jni')
+  end
+
+  args = ["uf", resourcepkg]
+  Dir.glob(File.join(File.join($tmpdir, 'jni'),'**','lib*.so')).each do |jni|
+    arch = File.basename(File.dirname(jni))
+    args << "jni/#{arch}/#{File.basename(jni)}"
+  end
+  Jake.run($jarbin, args, $tmpdir)
+  unless $?.success?
+    raise "Error packaging native libraries"
+  end
+
+  args = ["uf", resourcepkg, 'R.txt']
+  Jake.run($jarbin, args, $app_rjava_dir)
+  unless $?.success?
+    raise "Error packaging R.txt file"
+  end
+
+  args = ["uf", resourcepkg, '-C', '.', 'res']
+  Jake.run($jarbin, args, $tmpdir)
+
+  FormatManifestToAarCompat($appmanifest)
+  args = ["uf", resourcepkg, 'AndroidManifest.xml']
+  Jake.run($jarbin, args, File.dirname($appmanifest))
+
+end
+
+def create_bundle()
+  $logger.info "Creating android bundle"
+
+  builder = Aapt2Helper.instance
+
+  bundle = builder.build_aab
+
+  signed_bundle = File.join($targetdir,"#{$appname}-bundle-signed.aab")  
+
+  builder.debug = $debug
+  if $debug
+    builder.keystore = $keystore
+    builder.keypass = $keypass
+    builder.storepass = $storepass
+    builder.storealias = $storealias
+  end
+  builder.sign_aab( bundle, signed_bundle )  
+
+  apk = File.join($targetdir,"#{$appname}-universal.apk")
+  apks = File.join($targetdir,"#{$appname}.apks")
+  Jake.run( $javabin, ["-jar", $bundletool, "build-apks","--bundle=#{signed_bundle}", "--output=#{apks}", "--mode=universal"] )
+  rm apk if File.file? apk
+  Zip::File.open(apks) { |zip|
+    e = zip.get_entry('universal.apk')
+    zip.extract(e,apk)
+  }
+
+
+end
+
 namespace "package" do
   task :android => "build:android:all" do
     print_timestamp('package:android START')
-    puts "Running dx utility"
-    args = []
-    args << "-Xmx1024m"
-    args << "-jar"
-    args << $dxjar
-    args << "--dex"
-    args << "--output=#{$bindir}/classes.dex"
+
+    if $rhodes_as_lib
+      prepare_aar_package()
+      next
+    end
+    
+    $logger.info "Running DEX builder"    
 
     alljars = Dir.glob(File.join($app_builddir, '**', '*.jar'))
     alljars += AndroidTools::MavenDepsExtractor.instance.jars
 
+    jarsForDX = []
+
     require 'set'
     unique_jars = Set.new
 
@@ -2547,7 +2946,7 @@ namespace "package" do
       isFromMaven = (basename == 'classes.jar')# && Pathname.new(jar).split.include?('.m2')
       if (!unique_jars.member?(basename)) || isFromMaven
         if !useProguard
-          args << jar
+          jarsForDX << jar
         else
           jarNamesCounter += 1
           cp jar, File.join(proguardPreBuild, jarNamesCounter.to_s + '.jar')
@@ -2562,56 +2961,19 @@ namespace "package" do
       progArgs << File.join(proguardDir, 'proguard.jar')
       progArgs << '@' + proguardRules
       Jake.run(File.join($java, 'java'+$exe_ext), progArgs)
-      args << File.join(proguardPostBuild, "classes-processed.jar")
+      jarsForDX << File.join(proguardPostBuild, "classes-processed.jar")
     end
 
-    Jake.run(File.join($java, 'java'+$exe_ext), args)
-
-    unless $?.success?
-      raise "Error running DX utility"
+    unless AndroidTools::DexBuilder.instance.build( jarsForDX, "#{File.join($bindir,'classes.dex')}")
+      raise "Error running DEX builder"
     end
 
     resourcepkg = $bindir + "/rhodes.ap_"
 
-    puts "Packaging Assets and Jars"
-
-    # this task already caaled during build "build:android:all"
-    #set_app_name_android($appname)
-
-    args = ["package", "-f", "-M", $appmanifest, "-S", $appres, "-A", $appassets, "-I", $androidjar, "-F", resourcepkg]
-    args += AndroidTools::MavenDepsExtractor.instance.aapt_args
-    if $no_compression
-      $no_compression.each do |ext|
-        args << '-0'
-        args << ext
-      end
-    end
-
-    Jake.run($aapt, args)
-    unless $?.success?
-      raise "Error running AAPT (1)"
-    end
-
-    # Workaround: manually add files starting with '_' because aapt silently ignore such files when creating package
-    args = [ USE_TRACES ? "uvf" : "uf", resourcepkg]
-
-    skip_underscores = true
-
-    Dir.glob(File.join($appassets, "**/*")).each do |f|
-      next unless File.basename(f) =~ /^_/
-      relpath = Pathname.new(f).relative_path_from(Pathname.new($tmpdir)).to_s
-      puts "Add #{relpath} to #{resourcepkg}..."
-      args << relpath
-      skip_underscores = false
-    end
-
-    unless skip_underscores
-      Jake.run($jarbin, args, $tmpdir)
-      unless $?.success?
-        raise "Error packaging assets"
-      end
-    end
+    $logger.info "Packaging Assets and Jars"
 
+    Aapt2Helper.instance.build_intermediate_apk(resourcepkg)
+   
     puts "Packaging Native Libs"
 
     args = ["uf", resourcepkg]
@@ -2655,7 +3017,7 @@ namespace "package" do
       end
     end
 
-    args = [ USE_TRACES ? "uvf" : "uf", resourcepkg]
+    args = [ Rake.application.options.trace ? "uvf" : "uf", resourcepkg]
 
     Dir.glob(File.join(respath,"**/*")).each do |f|
       next if not File.file?(f)
@@ -2665,8 +3027,12 @@ namespace "package" do
     end
 
     Jake.run($jarbin, args, respath) if File.directory?(respath)
-
     rm_rf proguardTempJarDir if File.exists? proguardTempJarDir
+
+    if $build_bundle
+      create_bundle()
+    end
+
     puts "Finish packaging"
     print_timestamp('package:android FINISH')
   end
@@ -2678,20 +3044,17 @@ namespace "device" do
     desc "Build debug self signed for device"
     task :debug => "package:android" do
       print_timestamp('device:android:debug START')
-      dexfile = $bindir + "/classes.dex"
-      simple_apkfile = $targetdir + "/" + $appname + "-tmp.apk"
-      signed_apkfile = $targetdir + "/" + $appname + "-tmp_signed.apk"
-      final_apkfile = $targetdir + "/" + $appname + "-debug.apk"
-      resourcepkg = $bindir + "/rhodes.ap_"
 
-      apk_build $androidsdkpath, simple_apkfile, resourcepkg, dexfile, true
+      final_apkfile = File.join $targetdir, "#{$appname}-debug.apk"
 
-      AndroidTools.signApkDebug( simple_apkfile, signed_apkfile )
-      AndroidTools.alignApk( signed_apkfile, final_apkfile )
+      builder = ApkBuilder.new
+      builder.sdk_path = $androidsdkpath
+      builder.dex_path = File.join $bindir, "classes.dex"
+      builder.output_path = final_apkfile
+      builder.res_pkg = File.join $bindir, "rhodes.ap_"
+      builder.debug = true
 
-      #remove temporary files
-      rm_rf simple_apkfile
-      rm_rf signed_apkfile
+      builder.build
 
       File.open(File.join(File.dirname(final_apkfile), "app_info.txt"), "w") do |f|
         f.puts $app_package_name
@@ -2739,25 +3102,25 @@ namespace "device" do
     desc "Build production signed for device"
     task :production => "package:android" do
       print_timestamp('device:android:production START')
-      dexfile = $bindir + "/classes.dex"
-      simple_apkfile = $targetdir + "/" + $appname + "_tmp.apk"
-      final_apkfile = $targetdir + "/" + $appname + "_signed.apk"
-      signed_apkfile = $targetdir + "/" + $appname + "_tmp_signed.apk"
-      resourcepkg = $bindir + "/rhodes.ap_"
-
-      apk_build $androidsdkpath, simple_apkfile, resourcepkg, dexfile, false
 
       if not File.exists? $keystore
         AndroidTools.generateKeystore( $keystore, $storealias, $storepass, $keypass )
       end
 
+      final_apkfile = File.join $targetdir, "#{$appname}_signed.apk"
 
-      AndroidTools.signApk( simple_apkfile, signed_apkfile, $keystore, $keypass, $storepass, $storealias )
-      AndroidTools.alignApk( signed_apkfile, final_apkfile )
+      builder = ApkBuilder.new
+      builder.sdk_path = $androidsdkpath
+      builder.dex_path = File.join $bindir,"classes.dex"      
+      builder.output_path = final_apkfile
+      builder.res_pkg = File.join $bindir, "rhodes.ap_"
+      builder.debug = false
+      builder.keystore = $keystore
+      builder.keypass = $keypass
+      builder.storepass = $storepass
+      builder.storealias = $storealias
 
-      #remove temporary files
-      rm_rf simple_apkfile
-      rm_rf signed_apkfile
+      builder.build
 
       File.open(File.join(File.dirname(final_apkfile), "app_info.txt"), "w") do |f|
         f.puts $app_package_name
@@ -2794,11 +3157,16 @@ def run_as_spec(device_flag, uninstall_app)
   AndroidTools.logclear(device_flag)
   # Start emulator with options: hidden window display and wipe user data
   AndroidTools.run_emulator(:hidden => true, :wipe => true) if device_flag == '-e'
-  do_uninstall(device_flag)
+
+  begin
+    do_uninstall(device_flag)
+  rescue Exception => e
+    puts "Uninstalling application exception: " + e.to_s
+  end
 
   # Failsafe to prevent eternal hangs
   Thread.new {
-    sleep 2000
+    sleep 10000
     if device_flag == '-e'
       #AndroidTools.kill_adb_and_emulator
       puts "%%% was AndroidTools.kill_adb_and_emulator !!!"
@@ -3049,7 +3417,7 @@ namespace "run" do
       end
 
       task :spec, :uninstall_app do |t, args|
-        Jake.decorate_spec { run_as_spec('-e', args.uninstall_app) }
+          Jake.decorate_spec { run_as_spec('-e', args.uninstall_app) }
       end
     end