plugins/android/androidtools.cpp

   1 #include <msp/builder/architecture.h>
   2 #include <msp/builder/builder.h>
   3 #include <msp/core/algorithm.h>
   4 #include <msp/core/environ.h>
   5 #include <msp/fs/dir.h>
   6 #include <msp/fs/stat.h>
   7 #include <msp/strings/format.h>
   8 #include <msp/strings/lexicalcast.h>
   9 #include <msp/strings/utils.h>
  10 #include "androidarchiver.h"
  11 #include "androidassetpackagingtool.h"
  12 #include "androidcompiler.h"
  13 #include "androidlinker.h"
  14 #include "androidmanifestgenerator.h"
  15 #include "androidtools.h"
  16 #include "apkbuilder.h"
  17 #include "jarsigner.h"
  18
  19 using namespace std;
  20 using namespace Msp;
  21
  22 unsigned parse_version(const std::string &version_str)
  23 {
  24         vector<string> version_parts = split(version_str, '.');
  25         unsigned version = lexical_cast<unsigned>(version_parts[0])<<16;
  26         if(version_parts.size()>1)
  27                 version += lexical_cast<unsigned>(version_parts[1])<<8;
  28         if(version_parts.size()>2)
  29                 version += lexical_cast<unsigned>(version_parts[2]);
  30         return version;
  31 }
  32
  33
  34 AndroidDevKit::AndroidDevKit(Builder &b, const string &type, const FS::Path &default_path):
  35         builder(b)
  36 {
  37         string var = format("ANDROID_%s_ROOT", type);
  38         root = getenv(var);
  39         if(root.empty())
  40         {
  41                 if(!default_path.empty() && FS::exists(default_path))
  42                         root = default_path;
  43                 else
  44                 {
  45                         builder.get_logger().log("problems", "Android %s not found", type);
  46                         return;
  47                 }
  48         }
  49
  50         FS::Path platforms_dir = root/"platforms";
  51         if(!FS::exists(platforms_dir))
  52                 return;
  53
  54         builder.get_logger().log("files", "Traversing %s", platforms_dir.str());
  55         for(const string &p: list_filtered(platforms_dir, "^android-[1-9][0-9]*$"))
  56         {
  57                 unsigned api = lexical_cast<unsigned>(p.substr(8));
  58                 if(api>63)
  59                         builder.get_logger().log("problems", "API level %d is too high", api);
  60                 else
  61                         supported_api_levels |= static_cast<uint64_t>(1)<<api;
  62         }
  63 }
  64
  65 void AndroidDevKit::select_api_level(unsigned api)
  66 {
  67         if(!((supported_api_levels>>api)&1))
  68                 throw invalid_argument("AndroidDevKit::select_api_level");
  69
  70         init_api_level(api);
  71 }
  72
  73
  74 AndroidSdk::AndroidSdk(Builder &b):
  75         AndroidDevKit(b, "SDK")
  76 {
  77         find_build_tools_dir();
  78 }
  79
  80 void AndroidSdk::find_build_tools_dir()
  81 {
  82         FS::Path bt_dir = root/"build-tools";
  83         if(!FS::exists(bt_dir))
  84         {
  85                 builder.get_logger().log("problems", "Android build-tools not found");
  86                 return;
  87         }
  88
  89         builder.get_logger().log("files", "Traversing %s", bt_dir.str());
  90         string use_tools;
  91         unsigned latest_version = 0;
  92         for(const string &v: list_files(bt_dir))
  93         {
  94                 unsigned version = parse_version(v);
  95                 if(version>latest_version)
  96                 {
  97                         use_tools = v;
  98                         latest_version = version;
  99                 }
 100         }
 101
 102         if(use_tools.empty())
 103         {
 104                 builder.get_logger().log("problems", "Android build-tools not found");
 105                 return;
 106         }
 107
 108         build_tools_dir = bt_dir/use_tools;
 109         builder.get_logger().log("tools", "Android build-tools found in %s", build_tools_dir.str());
 110 }
 111
 112 void AndroidSdk::init_api_level(unsigned api)
 113 {
 114         platform_jar = root/"platforms"/format("android-%d", api)/"android.jar";
 115 }
 116
 117
 118 AndroidNdk::AndroidNdk(Builder &b, const Architecture &a, const AndroidSdk &sdk):
 119         AndroidDevKit(b, "NDK", create_default_path(sdk)),
 120         architecture(a)
 121 {
 122         if(!root.empty())
 123         {
 124                 FS::Path csr = root/"sysroot";
 125                 if(FS::exists(csr))
 126                 {
 127                         common_sysroot = csr;
 128                         builder.get_logger().log("tools", "Android NDK common sysroot is %s", common_sysroot);
 129                 }
 130         }
 131
 132         find_toolchain_dir();
 133 }
 134
 135 FS::Path AndroidNdk::create_default_path(const AndroidSdk &sdk)
 136 {
 137         if(sdk.get_root_dir().empty())
 138                 return FS::Path();
 139         return sdk.get_root_dir()/"ndk-bundle";
 140 }
 141
 142 void AndroidNdk::find_toolchain_dir()
 143 {
 144         if(root.empty())
 145                 return;
 146
 147         FS::Path toolchains_dir = root/"toolchains";
 148         if(!FS::exists(toolchains_dir))
 149         {
 150                 builder.get_logger().log("problems", "Android NDK toolchains not found");
 151                 return;
 152         }
 153
 154         builder.get_logger().log("files", "Traversing %s", toolchains_dir.str());
 155         string prefix = architecture.get_cross_prefix()+"-";
 156         string use_toolchain;
 157         unsigned latest_version = 0;
 158         for(const string &t: list_filtered(toolchains_dir, "^"+prefix))
 159         {
 160                 string version_str = t.substr(prefix.size());
 161                 string compiler = "gcc";
 162                 if(!isdigit(version_str[0]))
 163                 {
 164                         unsigned j;
 165                         for(j=1; (j<version_str.size() && !isdigit(version_str[j])); ++j) ;
 166                         compiler = version_str.substr(0, j);
 167                         version_str = version_str.substr(j);
 168                 }
 169
 170                 if(compiler!="gcc")
 171                         continue;
 172
 173                 unsigned version = parse_version(version_str);
 174                 if(version>latest_version)
 175                 {
 176                         use_toolchain = t;
 177                         latest_version = version;
 178                 }
 179         }
 180
 181         if(use_toolchain.empty())
 182         {
 183                 builder.get_logger().log("problems", "No applicable Android NDK toolchains found");
 184                 return;
 185         }
 186
 187         const Architecture &native_arch = builder.get_native_arch();
 188
 189         FS::Path tc_archs_dir = toolchains_dir/use_toolchain/"prebuilt";
 190         builder.get_logger().log("files", "Traversing %s", tc_archs_dir.str());
 191         string use_arch = native_arch.best_match(list_files(tc_archs_dir));
 192
 193         if(use_arch.empty())
 194         {
 195                 builder.get_logger().log("problems", "No applicable Android NDK toolchains found");
 196                 return;
 197         }
 198
 199         bin_dir = toolchains_dir/use_toolchain/"prebuilt"/use_arch/"bin";
 200         builder.get_logger().log("tools", "Android NDK toolchain binaries found in %s", bin_dir.str());
 201 }
 202
 203 void AndroidNdk::init_api_level(unsigned api)
 204 {
 205         FS::Path platform_archs_dir = root/"platforms"/format("android-%d", api);
 206         builder.get_logger().log("files", "Traversing %s", platform_archs_dir.str());
 207         vector<string> platform_archs = list_filtered(platform_archs_dir, "^arch-");
 208         for(string &a: platform_archs)
 209                 a.erase(0, 5);
 210         string use_arch = architecture.best_match(platform_archs);
 211
 212         if(use_arch.empty())
 213         {
 214                 builder.get_logger().log("problems", "No matching Android NDK platform found");
 215                 return;
 216         }
 217
 218         platform_sysroot = platform_archs_dir/("arch-"+use_arch);
 219         builder.get_logger().log("tools", "Android NDK platform sysroot is %s", platform_sysroot);
 220 }
 221
 222
 223 AndroidTools::AndroidTools(Builder &builder, const Architecture &arch):
 224         Toolchain("android-gnu", get_priority(arch)),
 225         sdk(builder),
 226         ndk(builder, arch, sdk)
 227 {
 228         if(uint64_t common_api_levels = sdk.get_supported_api_levels()&ndk.get_supported_api_levels())
 229         {
 230                 unsigned api = 0;
 231                 for(unsigned i=32; i>0; i>>=1)
 232                         api += i*!!(common_api_levels>>(api+i));
 233                 builder.get_logger().log("tools", "Using Android API level %d", api);
 234                 sdk.select_api_level(api);
 235                 ndk.select_api_level(api);
 236         }
 237         else
 238                 builder.get_logger().log("problems", "No usable Android platforms found");
 239
 240         add_tool(new AndroidCompiler(builder, arch, "CC", ndk));
 241         add_tool(new AndroidCompiler(builder, arch, "CXX", ndk));
 242         add_tool(new AndroidLinker(builder, arch, ndk));
 243         add_tool(new AndroidArchiver(builder, arch, ndk));
 244         add_tool(new AndroidManifestGenerator(builder));
 245         add_tool(new AndroidAssetPackagingTool(builder, sdk));
 246         add_tool(new ApkBuilder(builder));
 247         add_tool(new JarSigner(builder));
 248 }
 249
 250 int AndroidTools::get_priority(const Architecture &arch)
 251 {
 252         if(arch.get_system()=="android")
 253                 return 30;
 254         else
 255                 return -10;
 256 }