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