android: Use a separate SDK for the emulator again.

build/android/install_emulator_deps.py

 #!/usr/bin/env python
 # Copyright (c) 2013 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """Installs deps for using SDK emulator for testing.
 
-The script will download system images, if they are not present, and
+The script will download the SDK and system images, if they are not present, and
 install and enable KVM, if virtualization has been enabled in the BIOS.
 """
 
 
 import logging
 import os
 import shutil
 import sys
 
 from pylib import cmd_helper
 from pylib import constants
 from pylib.utils import run_tests_helper
 
-# Android ARMv7 system image for the SDK.
-ARMV7_IMG_URL = 'https://dl-ssl.google.com/android/repository/sysimg_armv7a-18_r01.zip'
+# From the Android Developer's website.
+SDK_BASE_URL = 'http://dl.google.com/android/adt'
+SDK_ZIP = 'adt-bundle-linux-x86_64-20130729.zip'
 
 # Android x86 system image from the Intel website:
 # http://software.intel.com/en-us/articles/intel-eula-x86-android-4-2-jelly-bean-bin
 X86_IMG_URL = 'http://download-software.intel.com/sites/landingpage/android/sysimg_x86-18_r01.zip'
 
 # Android API level
 API_TARGET = 'android-%s' % constants.ANDROID_SDK_VERSION
 
 
 def CheckSDK():
   """Check if SDK is already installed.
 
   Returns:
-    True if android_tools directory exists in current directory.
+    True if the emulator SDK directory (src/android_emulator_sdk/) exists.
   """
-  return os.path.exists(os.path.join(constants.EMULATOR_SDK_ROOT,
-                                     'android_tools'))
-
-
-def CheckARMv7Image():
-  """Check if the ARMv7 system images have been installed.
-
-  Returns:
-    True if the armeabi-v7a directory is present inside the Android SDK
-    checkout directory.
-  """
-  return os.path.exists(os.path.join(constants.EMULATOR_SDK_ROOT,
-                                     'android_tools', 'sdk', 'system-images',
-                                     API_TARGET, 'armeabi-v7a'))
+  return os.path.exists(constants.EMULATOR_SDK_ROOT)
 
 
 def CheckX86Image():
   """Check if Android system images have been installed.
 
   Returns:
-    True if android_tools/sdk/system-images directory exists.
+    True if sdk/system-images/<API TARGET>/x86 exists inside EMULATOR_SDK_ROOT.
   """
   return os.path.exists(os.path.join(constants.EMULATOR_SDK_ROOT,
-                                     'android_tools', 'sdk', 'system-images',
+                                     'sdk', 'system-images',
                                      API_TARGET, 'x86'))
 
 
 def CheckKVM():
   """Check if KVM is enabled.
 
   Returns:
     True if kvm-ok returns 0 (already enabled)
   """
   try:
     return not cmd_helper.RunCmd(['kvm-ok'])
   except OSError:
     logging.info('kvm-ok not installed')
     return False
 
 
+def GetSDK():
+  """Download the SDK and unzip it into EMULATOR_SDK_ROOT."""
+  logging.info('Download Android SDK.')
+  sdk_url = '%s/%s' % (SDK_BASE_URL, SDK_ZIP)
+  try:
+    cmd_helper.RunCmd(['curl', '-o', '/tmp/sdk.zip', sdk_url])
+    print 'curled unzipping...'
+    rc = cmd_helper.RunCmd(['unzip', '-o', '/tmp/sdk.zip', '-d', '/tmp/'])
+    if rc:
+      raise Exception('ERROR: could not download/unzip Android SDK.')
+    # Get the name of the sub-directory that everything will be extracted to.
+    dirname, _ = os.path.splitext(SDK_ZIP)
+    zip_dir = '/tmp/%s' % dirname
+    # Move the extracted directory to EMULATOR_SDK_ROOT
+    shutil.move(zip_dir, constants.EMULATOR_SDK_ROOT)

[navabi1, 2013/10/04 18:41:48]

Won't this move the unzipped directory adt-bundle-linux-...zip into
src/android_emulator_sdk/ so that it looks like this:

src/android_emulator_sdk/adt-linux-bundle-linux/sdk
instead of
src/android_emulator_sdk/sdk

[Raphael Kubo da Costa (rakuco), 2013/10/04 19:04:19]

This function is only called if src/android_emulator does not exist; in this
case, it's similar to calling "mv /tmp/adt-linux-bundle-linux
/path/to/src/android_emulator_sdk", which leaves us with
src/android_emulator_sdk/{eclipse,sdk}.

The implementation is practically identical to the one that existed until
r222120, but I was indeed going to ask on the bug how people handled SDK updates
before: if we want to download a new zip file but the directory already exists,
nothing will be done at all.

[navabi, 2013/10/04 19:11:58]

Ah! Right. That looks good.
Updates were not handled by this script before. Developer would have to update
the emulator SDK (another reason it was not part of the android_tools sdk). It
would make sense to have the script take a --update or --force option to force
overwriting of the emulator sdk.

+  finally:
+    os.unlink('/tmp/sdk.zip')
+
+
 def InstallKVM():
   """Installs KVM packages."""
   rc = cmd_helper.RunCmd(['sudo', 'apt-get', 'install', 'kvm'])
   if rc:
     logging.critical('ERROR: Did not install KVM. Make sure hardware '
                      'virtualization is enabled in BIOS (i.e. Intel VT-x or '
                      'AMD SVM).')
   # TODO(navabi): Use modprobe kvm-amd on AMD processors.
   rc = cmd_helper.RunCmd(['sudo', 'modprobe', 'kvm-intel'])
   if rc:
     logging.critical('ERROR: Did not add KVM module to Linux Kernal. Make sure '
                      'hardware virtualization is enabled in BIOS.')
   # Now check to ensure KVM acceleration can be used.
   rc = cmd_helper.RunCmd(['kvm-ok'])
   if rc:
     logging.critical('ERROR: Can not use KVM acceleration. Make sure hardware '
                      'virtualization is enabled in BIOS (i.e. Intel VT-x or '
                      'AMD SVM).')
 
 
-def GetARMv7Image():
-  """Download and install the ARMv7 system image."""
-  logging.info('Download ARMv7 system image directory into sdk directory.')
-  try:
-    cmd_helper.RunCmd(['curl', '-o', '/tmp/armv7_img.zip', ARMV7_IMG_URL])
-    rc = cmd_helper.RunCmd(['unzip', '-o', '/tmp/armv7_img.zip', '-d', '/tmp/'])
-    if rc:
-      raise Exception('ERROR: Could not download/unzip image zip.')
-    sys_imgs = os.path.join(constants.EMULATOR_SDK_ROOT, 'android_tools', 'sdk',
-                            'system-images', API_TARGET, 'armeabi-v7a')
-    shutil.move('/tmp/armeabi-v7a', sys_imgs)
-  finally:
-    os.unlink('/tmp/armv7_img.zip')
-
-
 def GetX86Image():
   """Download x86 system image from Intel's website."""
   logging.info('Download x86 system image directory into sdk directory.')
   try:
     cmd_helper.RunCmd(['curl', '-o', '/tmp/x86_img.zip', X86_IMG_URL])
     rc = cmd_helper.RunCmd(['unzip', '-o', '/tmp/x86_img.zip', '-d', '/tmp/'])
     if rc:
       raise Exception('ERROR: Could not download/unzip image zip.')
-    sys_imgs = os.path.join(constants.EMULATOR_SDK_ROOT, 'android_tools', 'sdk',
+    sys_imgs = os.path.join(constants.EMULATOR_SDK_ROOT, 'sdk',
                             'system-images', API_TARGET, 'x86')
     shutil.move('/tmp/x86', sys_imgs)
   finally:
     os.unlink('/tmp/x86_img.zip')
 
 
 def main(argv):
   logging.basicConfig(level=logging.INFO,
                       format='# %(asctime)-15s: %(message)s')
   run_tests_helper.SetLogLevel(verbose_count=1)
 
-  if not CheckSDK():
-    logging.critical(
-      'ERROR: android_tools does not exist. Make sure your .gclient file '
-      'contains the right \'target_os\' entry. See '
-      'https://code.google.com/p/chromium/wiki/AndroidBuildInstructions for '
-      'more information.')
-    return 1
+  # Calls below will download emulator SDK and/or system images only if needed.
+  if CheckSDK():
+    logging.info('android_emulator_sdk/ already exists, skipping download.')
+  else:
+    GetSDK()
 
-  # Download system images only if needed.
-  if CheckARMv7Image():
-    logging.info('The ARMv7 image is already present.')
-  else:
-    GetARMv7Image()
-
+  # Download the x86 system image only if needed.
   if CheckX86Image():
-    logging.info('The x86 image is already present.')
+    logging.info('The x86 image is already present, skipping download.')
   else:
     GetX86Image()
 
   # Make sure KVM packages are installed and enabled.
   if CheckKVM():
     logging.info('KVM already installed and enabled.')
   else:
     InstallKVM()
 
 
 if __name__ == '__main__':
   sys.exit(main(sys.argv))