blob: 93c53fc12c0f4088e11bfb29a2f8c8d991ccde96 [file] [log] [blame]
#!/usr/bin/env python
# Copyright (c) 2012, the Dart project authors. Please see the AUTHORS file
# for details. All rights reserved. Use of this source code is governed by a
# BSD-style license that can be found in the LICENSE file.
Find an Android device with a given ABI.
The name of the Android device is printed to stdout.
Optionally configure and launch an emulator if there's no existing device for a
given ABI. Will download and install Android SDK components as needed.
import optparse
import os
import re
import sys
import traceback
import utils
DEBUG = False
def BuildOptions():
result = optparse.OptionParser()
"-a", "--abi",
action="store", type="string",
help="Desired ABI. armeabi-v7a or x86.")
"-b", "--bootstrap",
help='Bootstrap - create an emulator, installing SDK packages if needed.',
default=False, action="store_true")
"-d", "--debug",
help='Turn on debugging diagnostics.',
default=False, action="store_true")
"-v", "--verbose",
help='Verbose output.',
default=False, action="store_true")
return result
def ProcessOptions(options):
global DEBUG
DEBUG = options.debug
global VERBOSE
VERBOSE = options.verbose
if options.abi is None:
sys.stderr.write('--abi not specified.\n')
return False
return True
def ParseAndroidListSdkResult(text):
Parse the output of an 'android list sdk' command.
Return list of (id-num, id-key, type, description).
header_regex = re.compile(
r'Packages available for installation or update: \d+\n')
packages = re.split(header_regex, text)
if len(packages) != 2:
raise utils.Error("Could not get a list of packages to install")
entry_regex = re.compile(
r'^id\: (\d+) or "([^"]*)"\n\s*Type\: ([^\n]*)\n\s*Desc\: (.*)')
entries = []
for entry in packages[1].split('----------\n'):
match = entry_regex.match(entry)
if match == None:
return entries
def AndroidListSdk():
return ParseAndroidListSdkResult(utils.RunCommand(
["android", "list", "sdk", "-a", "-e"]))
def AndroidSdkFindPackage(packages, key):
packages: list of (id-num, id-key, type, description).
key: (id-key, type, description-prefix).
(key_id, key_type, key_description_prefix) = key
for package in packages:
(package_num, package_id, package_type, package_description) = package
if (package_id == key_id and package_type == key_type
and package_description.startswith(key_description_prefix)):
return package
return None
def EnsureSdkPackageInstalled(packages, key):
Makes sure the package with a given key is installed.
key is (id-key, type, description-prefix)
Returns True if the package was not already installed.
entry = AndroidSdkFindPackage(packages, key)
if entry is None:
raise utils.Error("Could not find a package for key %s" % key)
packageId = entry[0]
sys.stderr.write('Checking Android SDK package %s...\n' % str(entry))
out = utils.RunCommand(
["android", "update", "sdk", "-a", "-u", "--filter", str(packageId)])
return '\nInstalling Archives:\n' in out
def SdkPackagesForAbi(abi):
packagesForAbi = {
'armeabi-v7a': [
# The platform needed to install the armeabi ABI system image:
('android-15', 'Platform', 'Android SDK Platform 4.0.3'),
# The armeabi-v7a ABI system image:
('sysimg-15', 'SystemImage', 'Android SDK Platform 4.0.3')
'x86': [
# The platform needed to install the x86 ABI system image:
('android-15', 'Platform', 'Android SDK Platform 4.0.3'),
# The x86 ABI system image:
('sysimg-15', 'SystemImage', 'Android SDK Platform 4.0.4')
if abi not in packagesForAbi:
raise utils.Error('Unsupported abi %s' % abi)
return packagesForAbi[abi]
def TargetForAbi(abi):
for package in SdkPackagesForAbi(abi):
if package[1] == 'Platform':
return package[0]
def EnsureAndroidSdkPackagesInstalled(abi):
"""Return true if at least one package was not already installed."""
abiPackageList = SdkPackagesForAbi(abi)
installedSomething = False
packages = AndroidListSdk()
for package in abiPackageList:
installedSomething |= EnsureSdkPackageInstalled(packages, package)
return installedSomething
def ParseAndroidListAvdResult(text):
Parse the output of an 'android list avd' command.
Return List of {Name: Path: Target: ABI: Skin: Sdcard:}
text = text.split('Available Android Virtual Devices:\n')[-1]
text = text.split(
'The following Android Virtual Devices could not be loaded:\n')[0]
result = []
line_re = re.compile(r'^\s*([^\:]+)\:\s*(.*)$')
for chunk in text.split('\n---------\n'):
entry = {}
for line in chunk.split('\n'):
line = line.strip()
if len(line) == 0:
match = line_re.match(line)
if match is None:
sys.stderr.write('Match fail %s\n' % str(line))
#raise utils.Error('Match failed')
entry[] =
if len(entry) > 0:
return result
def AndroidListAvd():
"""Returns a list of available Android Virtual Devices."""
return ParseAndroidListAvdResult(utils.RunCommand(["android", "list", "avd"]))
def FindAvd(avds, key):
for avd in avds:
if avd['Name'] == key:
return avd
return None
def CreateAvd(avdName, abi):
out = utils.RunCommand(["android", "create", "avd", "--name", avdName,
"--target", TargetForAbi(abi), '--abi', abi],
if out.find('Created AVD ') < 0:
sys.stderr.write('Could not create AVD:\n%s\n' % out)
raise utils.Error('Could not create AVD')
def AvdExists(avdName):
avdList = AndroidListAvd()
return FindAvd(avdList, avdName) is not None
def EnsureAvdExists(avdName, abi):
if AvdExists(avdName):
sys.stderr.write('Checking SDK packages...\n')
if EnsureAndroidSdkPackagesInstalled(abi):
# Installing a new package could have made a previously invalid AVD valid
if AvdExists(avdName):
CreateAvd(avdName, abi)
def StartEmulator(abi, avdName, pollFn):
Start an emulator for a given abi and svdName.
Echo the emulator's stderr and stdout output to our stderr.
Call pollFn repeatedly until it returns False. Leave the emulator running
when we return.
Implementation note: Normally we would call the 'emulator' binary, which
is a wrapper that launches the appropriate abi-specific emulator. But there
is a bug that causes the emulator to exit immediately with a result code of
-11 if run from a ssh shell or a No Machine shell. (And only if called from
three levels of nested python scripts.) Calling the ABI-specific versions
of the emulator directly works around this bug.
emulatorName = {'x86' : 'emulator-x86', 'armeabi-v7a': 'emulator-arm'}[abi]
command = [emulatorName, '-avd', avdName, '-no-boot-anim', '-no-window']
utils.RunCommand(command, pollFn=pollFn, killOnEarlyReturn=False,
outStream=sys.stderr, errStream=sys.stderr)
def ParseAndroidDevices(text):
"""Return Dictionary [name] -> status"""
text = text.split('List of devices attached')[-1]
lines = [line.strip() for line in text.split('\n')]
lines = [line for line in lines if len(line) > 0]
devices = {}
for line in lines:
lineItems = line.split('\t')
devices[lineItems[0]] = lineItems[1]
return devices
def GetAndroidDevices():
return ParseAndroidDevices(utils.RunCommand(["adb", "devices"]))
def FilterOfflineDevices(devices):
online = {}
for device in devices.keys():
status = devices[device]
if status != 'offline':
online[device] = status
return online
def GetOnlineAndroidDevices():
return FilterOfflineDevices(GetAndroidDevices())
def GetAndroidDeviceProperty(device, property):
return utils.RunCommand(
["adb", "-s", device, "shell", "getprop", property]).strip()
def GetAndroidDeviceAbis(device):
abis = []
for property in ['ro.product.cpu.abi', 'ro.product.cpu.abi2']:
out = GetAndroidDeviceProperty(device, property)
if len(out) > 0:
return abis
def FindAndroidRunning(abi):
for device in GetOnlineAndroidDevices().keys():
if abi in GetAndroidDeviceAbis(device):
return device
return None
def AddSdkToolsToPath():
script_dir = os.path.dirname(sys.argv[0])
dart_root = os.path.realpath(os.path.join(script_dir, '..', '..'))
third_party_root = os.path.join(dart_root, 'third_party')
android_tools = os.path.join(third_party_root, 'android_tools')
android_sdk_root = os.path.join(android_tools, 'sdk')
android_sdk_tools = os.path.join(android_sdk_root, 'tools')
android_sdk_platform_tools = os.path.join(android_sdk_root, 'platform-tools')
os.environ['PATH'] = ':'.join([
os.environ['PATH'], android_sdk_tools, android_sdk_platform_tools])
# Remove any environment variables that would affect our build.
if i in os.environ:
del os.environ[i]
def FindAndroid(abi, bootstrap):
sys.stderr.write('Looking for an Android device running abi %s...\n' % abi)
device = FindAndroidRunning(abi)
if not device:
if bootstrap:
sys.stderr.write("No emulator found, try to create one.\n")
avdName = 'dart-build-%s' % abi
EnsureAvdExists(avdName, abi)
# It takes a while to start up an emulator.
# Provide feedback while we wait.
pollResult = [None]
def pollFunction():
pollResult[0] = FindAndroidRunning(abi)
# Stop polling once we have our result.
return pollResult[0] != None
StartEmulator(abi, avdName, pollFunction)
device = pollResult[0]
return device
def Main():
# Parse options.
parser = BuildOptions()
(options, args) = parser.parse_args()
if not ProcessOptions(options):
return 1
# If there are additional arguments, report error and exit.
if args:
return 1
device = FindAndroid(options.abi, options.bootstrap)
if device != None:
sys.stdout.write("%s\n" % device)
return 0
sys.stderr.write('Could not find device\n')
return 2
except utils.Error as e:
sys.stderr.write("error: %s\n" % e)
return -1
if __name__ == '__main__':