build/android/preprocess_google_play_services.py

   1 #!/usr/bin/env python
   2 #
   3 # Copyright 2015 The Chromium Authors. All rights reserved.
   4 # Use of this source code is governed by a BSD-style license that can be
   5 # found in the LICENSE file.
   6
   7 '''Prepares the Google Play services split client libraries before usage by
   8 Chrome's build system.
   9
  10 We need to preprocess Google Play services before using it in Chrome
  11 builds for 2 main reasons:
  12
  13 - Getting rid of unused resources: unsupported languages, unused
  14 drawables, etc.
  15
  16 - Merging the differents jars so that it can be proguarded more
  17 easily. This is necessary since debug and test apks get very close
  18 to the dex limit.
  19
  20 The script is supposed to be used with the maven repository that can be
  21 obtained by downloading the "extra-google-m2repository" from the Android SDK
  22 Manager. It also supports importing from already extracted AAR files using the
  23 --is-extracted-repo flag. The expected directory structure in that case would
  24 look like:
  25
  26     REPOSITORY_DIR
  27     +-- CLIENT_1
  28     |   +-- <content of the first AAR file>
  29     +-- CLIENT_2
  30     +-- etc.
  31
  32 The json config (see the -c argument) file should provide the following fields:
  33
  34 - lib_version: String. Used when building from the maven repository. It should
  35   be the package's version (e.g. "7.3.0"). Unused with extracted repositories.
  36
  37 - clients: String array. List of clients to pick. For example, when building
  38   from the maven repository, it's the artifactId (e.g. "play-services-base") of
  39   each client. With an extracted repository, it's the name of the
  40   subdirectories.
  41
  42 - locale_whitelist: String array. Locales that should be allowed in the final
  43   resources. They are specified the same way they are appended to the `values`
  44   directory in android resources (e.g. "us-GB", "it", "fil").
  45
  46 The output is a directory with the following structure:
  47
  48     OUT_DIR
  49     +-- google-play-services.jar
  50     +-- res
  51     |   +-- CLIENT_1
  52     |   |   +-- color
  53     |   |   +-- values
  54     |   |   +-- etc.
  55     |   +-- CLIENT_2
  56     |       +-- ...
  57     +-- stub
  58         +-- res/[.git-keep-directory]
  59         +-- src/android/UnusedStub.java
  60
  61 Requires the `jar` utility in the path.
  62
  63 '''
  64
  65 import argparse
  66 import glob
  67 import itertools
  68 import json
  69 import os
  70 import re
  71 import shutil
  72 import stat
  73 import sys
  74
  75 from datetime import datetime
  76 from devil.utils import cmd_helper
  77 from pylib import constants
  78
  79 sys.path.append(
  80     os.path.join(constants.DIR_SOURCE_ROOT, 'build', 'android', 'gyp'))
  81 from util import build_utils # pylint: disable=import-error
  82
  83
  84 M2_PKG_PATH = os.path.join('com', 'google', 'android', 'gms')
  85 OUTPUT_FORMAT_VERSION = 1
  86 VERSION_FILE_NAME = 'version_info.json'
  87 VERSION_NUMBER_PATTERN = re.compile(
  88     r'<integer name="google_play_services_version">(\d+)<\/integer>')
  89
  90 def main():
  91   parser = argparse.ArgumentParser(description=("Prepares the Google Play "
  92       "services split client libraries before usage by Chrome's build system. "
  93       "See the script's documentation for more a detailed help."))
  94   parser.add_argument('-r',
  95                       '--repository',
  96                       help='The Google Play services repository location',
  97                       required=True,
  98                       metavar='FILE')
  99   parser.add_argument('-o',
 100                       '--out-dir',
 101                       help='The output directory',
 102                       required=True,
 103                       metavar='FILE')
 104   parser.add_argument('-c',
 105                       '--config-file',
 106                       help='Config file path',
 107                       required=True,
 108                       metavar='FILE')
 109   parser.add_argument('-x',
 110                       '--is-extracted-repo',
 111                       action='store_true',
 112                       default=False,
 113                       help='The provided repository is not made of AAR files.')
 114
 115   args = parser.parse_args()
 116
 117   ProcessGooglePlayServices(args.repository,
 118                             args.out_dir,
 119                             args.config_file,
 120                             args.is_extracted_repo)
 121
 122
 123 def ProcessGooglePlayServices(repo, out_dir, config_path, is_extracted_repo):
 124   with open(config_path, 'r') as json_file:
 125     config = json.load(json_file)
 126
 127   with build_utils.TempDir() as tmp_root:
 128     tmp_paths = _SetupTempDir(tmp_root)
 129
 130     if is_extracted_repo:
 131       _ImportFromExtractedRepo(config, tmp_paths, repo)
 132     else:
 133       _ImportFromAars(config, tmp_paths, repo)
 134
 135     _GenerateCombinedJar(tmp_paths)
 136     _ProcessResources(config, tmp_paths)
 137
 138     if is_extracted_repo:
 139       printable_repo = repo
 140     else:
 141       printable_repo = 'm2repository - ' + config['lib_version']
 142     _BuildOutput(config, tmp_paths, out_dir, printable_repo)
 143
 144
 145 def _SetupTempDir(tmp_root):
 146   tmp_paths = {
 147     'root': tmp_root,
 148     'imported_clients': os.path.join(tmp_root, 'imported_clients'),
 149     'extracted_jars': os.path.join(tmp_root, 'jar'),
 150     'combined_jar': os.path.join(tmp_root, 'google-play-services.jar'),
 151   }
 152   os.mkdir(tmp_paths['imported_clients'])
 153   os.mkdir(tmp_paths['extracted_jars'])
 154
 155   return tmp_paths
 156
 157
 158 def _SetupOutputDir(out_dir):
 159   out_paths = {
 160     'root': out_dir,
 161     'res': os.path.join(out_dir, 'res'),
 162     'jar': os.path.join(out_dir, 'google-play-services.jar'),
 163     'stub': os.path.join(out_dir, 'stub'),
 164   }
 165
 166   shutil.rmtree(out_paths['jar'], ignore_errors=True)
 167   shutil.rmtree(out_paths['res'], ignore_errors=True)
 168   shutil.rmtree(out_paths['stub'], ignore_errors=True)
 169
 170   return out_paths
 171
 172
 173 def _MakeWritable(dir_path):
 174   for root, dirs, files in os.walk(dir_path):
 175     for path in itertools.chain(dirs, files):
 176       st = os.stat(os.path.join(root, path))
 177       os.chmod(os.path.join(root, path), st.st_mode | stat.S_IWUSR)
 178
 179
 180 def _ImportFromAars(config, tmp_paths, repo):
 181   for client in config['clients']:
 182     aar_name = '%s-%s.aar' % (client, config['lib_version'])
 183     aar_path = os.path.join(repo, M2_PKG_PATH, client,
 184                             config['lib_version'], aar_name)
 185     aar_out_path = os.path.join(tmp_paths['imported_clients'], client)
 186     build_utils.ExtractAll(aar_path, aar_out_path)
 187
 188     client_jar_path = os.path.join(aar_out_path, 'classes.jar')
 189     build_utils.ExtractAll(client_jar_path, tmp_paths['extracted_jars'],
 190                            no_clobber=False)
 191
 192
 193 def _ImportFromExtractedRepo(config, tmp_paths, repo):
 194   # Import the clients
 195   try:
 196     for client in config['clients']:
 197       client_out_dir = os.path.join(tmp_paths['imported_clients'], client)
 198       shutil.copytree(os.path.join(repo, client), client_out_dir)
 199
 200       client_jar_path = os.path.join(client_out_dir, 'classes.jar')
 201       build_utils.ExtractAll(client_jar_path, tmp_paths['extracted_jars'],
 202                              no_clobber=False)
 203   finally:
 204     _MakeWritable(tmp_paths['imported_clients'])
 205
 206
 207 def _GenerateCombinedJar(tmp_paths):
 208   out_file_name = tmp_paths['combined_jar']
 209   working_dir = tmp_paths['extracted_jars']
 210   cmd_helper.Call(['jar', '-cf', out_file_name, '-C', working_dir, '.'])
 211
 212
 213 def _ProcessResources(config, tmp_paths):
 214   LOCALIZED_VALUES_BASE_NAME = 'values-'
 215   locale_whitelist = set(config['locale_whitelist'])
 216
 217   glob_pattern = os.path.join(tmp_paths['imported_clients'], '*', 'res', '*')
 218   for res_dir in glob.glob(glob_pattern):
 219     dir_name = os.path.basename(res_dir)
 220
 221     if dir_name.startswith('drawable'):
 222       shutil.rmtree(res_dir)
 223       continue
 224
 225     if dir_name.startswith(LOCALIZED_VALUES_BASE_NAME):
 226       dir_locale = dir_name[len(LOCALIZED_VALUES_BASE_NAME):]
 227       if dir_locale not in locale_whitelist:
 228         shutil.rmtree(res_dir)
 229
 230
 231 def _GetVersionNumber(config, tmp_paths):
 232   version_file_path = os.path.join(tmp_paths['imported_clients'],
 233                                    config['base_client'],
 234                                    'res',
 235                                    'values',
 236                                    'version.xml')
 237
 238   with open(version_file_path, 'r') as version_file:
 239     version_file_content = version_file.read()
 240
 241   match = VERSION_NUMBER_PATTERN.search(version_file_content)
 242   if not match:
 243     raise AttributeError('A value for google_play_services_version was not '
 244                          'found in ' + version_file_path)
 245
 246   return match.group(1)
 247
 248
 249 def _BuildOutput(config, tmp_paths, out_dir, printable_repo):
 250   generation_date = datetime.utcnow()
 251   play_services_full_version = _GetVersionNumber(config, tmp_paths)
 252
 253   # Create a version text file to allow quickly checking the version
 254   gen_info = {
 255     '@Description@': 'Preprocessed Google Play services clients for chrome',
 256     'Generator script': os.path.basename(__file__),
 257     'Repository source': printable_repo,
 258     'Library version': play_services_full_version,
 259     'Directory format version': OUTPUT_FORMAT_VERSION,
 260     'Generation Date (UTC)': str(generation_date)
 261   }
 262   tmp_version_file_path = os.path.join(tmp_paths['root'], VERSION_FILE_NAME)
 263   with open(tmp_version_file_path, 'w') as version_file:
 264     json.dump(gen_info, version_file, indent=2, sort_keys=True)
 265
 266   out_paths = _SetupOutputDir(out_dir)
 267
 268   # Copy the resources to the output dir
 269   for client in config['clients']:
 270     res_in_tmp_dir = os.path.join(tmp_paths['imported_clients'], client, 'res')
 271     if os.path.isdir(res_in_tmp_dir) and os.listdir(res_in_tmp_dir):
 272       res_in_final_dir = os.path.join(out_paths['res'], client)
 273       shutil.copytree(res_in_tmp_dir, res_in_final_dir)
 274
 275   # Copy the jar
 276   shutil.copyfile(tmp_paths['combined_jar'], out_paths['jar'])
 277
 278   # Write the java dummy stub. Needed for gyp to create the resource jar
 279   stub_location = os.path.join(out_paths['stub'], 'src', 'android')
 280   os.makedirs(stub_location)
 281   with open(os.path.join(stub_location, 'UnusedStub.java'), 'w') as stub:
 282     stub.write('package android;'
 283                'public final class UnusedStub {'
 284                '    private UnusedStub() {}'
 285                '}')
 286
 287   # Create the main res directory. It is needed by gyp
 288   stub_res_location = os.path.join(out_paths['stub'], 'res')
 289   os.makedirs(stub_res_location)
 290   with open(os.path.join(stub_res_location, '.res-stamp'), 'w') as stamp:
 291     content_str = 'google_play_services_version: %s\nutc_date: %s\n'
 292     stamp.write(content_str % (play_services_full_version, generation_date))
 293
 294   shutil.copyfile(tmp_version_file_path,
 295                   os.path.join(out_paths['root'], VERSION_FILE_NAME))
 296
 297
 298 if __name__ == '__main__':
 299   sys.exit(main())