android_finder Namespace Reference

Functions
def	BuildOptions ()
def	ProcessOptions (options)
def	ParseAndroidListSdkResult (text)
def	AndroidListSdk ()
def	AndroidSdkFindPackage (packages, key)
def	EnsureSdkPackageInstalled (packages, key)
def	SdkPackagesForAbi (abi)
def	TargetForAbi (abi)
def	EnsureAndroidSdkPackagesInstalled (abi)
def	ParseAndroidListAvdResult (text)
def	AndroidListAvd ()
def	FindAvd (avds, key)
def	CreateAvd (avdName, abi)
def	AvdExists (avdName)
def	EnsureAvdExists (avdName, abi)
def	StartEmulator (abi, avdName, pollFn)
def	ParseAndroidDevices (text)
def	GetAndroidDevices ()
def	FilterOfflineDevices (devices)
def	GetOnlineAndroidDevices ()
def	GetAndroidDeviceProperty (device, property)
def	GetAndroidDeviceAbis (device)
def	FindAndroidRunning (abi)
def	AddSdkToolsToPath ()
def	FindAndroid (abi, bootstrap)
def	Main ()

Variables
bool	DEBUG = False
bool	VERBOSE = False

Function Documentation

AddSdkToolsToPath()

def android_finder.AddSdkToolsToPath

(

)

Definition at line 312 of file android_finder.py.

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.
    for i in [
            'ANDROID_NDK_ROOT', 'ANDROID_SDK_ROOT', 'ANDROID_TOOLCHAIN', 'AR',
            'BUILDTYPE', 'CC', 'CXX', 'GYP_DEFINES', 'LD_LIBRARY_PATH', 'LINK',
            'MAKEFLAGS', 'MAKELEVEL', 'MAKEOVERRIDES', 'MFLAGS', 'NM'
    ]:
        if i in os.environ:
            del os.environ[i]
 
 

AndroidListAvd()

def android_finder.AndroidListAvd

(

)

Returns a list of available Android Virtual Devices.

Definition at line 194 of file android_finder.py.

def AndroidListAvd():
    """Returns a list of available Android Virtual Devices."""
    return ParseAndroidListAvdResult(
        utils.RunCommand(["android", "list", "avd"]))
 
 

AndroidListSdk()

def android_finder.AndroidListSdk

(

)

Definition at line 90 of file android_finder.py.

def AndroidListSdk():
    return ParseAndroidListSdkResult(
        utils.RunCommand(["android", "list", "sdk", "-a", "-e"]))
 
 

AndroidSdkFindPackage()

def android_finder.AndroidSdkFindPackage	(		packages,
			key
	)

Args:
packages: list of (id-num, id-key, type, description).
key: (id-key, type, description-prefix).

Definition at line 95 of file android_finder.py.

def AndroidSdkFindPackage(packages, key):
    """
  Args:
    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
 
 

AvdExists()

def android_finder.AvdExists

(

avdName

)

Definition at line 219 of file android_finder.py.

def AvdExists(avdName):
    avdList = AndroidListAvd()
    return FindAvd(avdList, avdName) is not None
 
 

BuildOptions()

def android_finder.BuildOptions

(

)

Definition at line 26 of file android_finder.py.

def BuildOptions():
    result = optparse.OptionParser()
    result.add_option(
        "-a",
        "--abi",
        action="store",
        type="string",
        help="Desired ABI. armeabi-v7a or x86.")
    result.add_option(
        "-b",
        "--bootstrap",
        help=
        'Bootstrap - create an emulator, installing SDK packages if needed.',
        default=False,
        action="store_true")
    result.add_option(
        "-d",
        "--debug",
        help='Turn on debugging diagnostics.',
        default=False,
        action="store_true")
    result.add_option(
        "-v",
        "--verbose",
        help='Verbose output.',
        default=False,
        action="store_true")
    return result
 
 

CreateAvd()

def android_finder.CreateAvd	(		avdName,
			abi
	)

Definition at line 207 of file android_finder.py.

def CreateAvd(avdName, abi):
    out = utils.RunCommand([
        "android", "create", "avd", "--name", avdName, "--target",
        TargetForAbi(abi), '--abi', abi
    ],
                           input="no\n")
    if out.find('Created AVD ') < 0:
        if VERBOSE:
            sys.stderr.write('Could not create AVD:\n%s\n' % out)
        raise utils.Error('Could not create AVD')
 
 

EnsureAndroidSdkPackagesInstalled()

def android_finder.EnsureAndroidSdkPackagesInstalled

(

abi

)

Return true if at least one package was not already installed.

Definition at line 157 of file android_finder.py.

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
 
 

EnsureAvdExists()

def android_finder.EnsureAvdExists	(		avdName,
			abi
	)

Definition at line 224 of file android_finder.py.

def EnsureAvdExists(avdName, abi):
    if AvdExists(avdName):
        return
    if VERBOSE:
        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):
            return
    CreateAvd(avdName, abi)
 
 

EnsureSdkPackageInstalled()

def android_finder.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.

Definition at line 110 of file android_finder.py.

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]
    if VERBOSE:
        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
 
 

FilterOfflineDevices()

def android_finder.FilterOfflineDevices

(

devices

)

Definition at line 278 of file android_finder.py.

def FilterOfflineDevices(devices):
    online = {}
    for device in devices.keys():
        status = devices[device]
        if status != 'offline':
            online[device] = status
    return online
 
 

FindAndroid()

def android_finder.FindAndroid	(		abi,
			bootstrap
	)

Definition at line 333 of file android_finder.py.

def FindAndroid(abi, bootstrap):
    if VERBOSE:
        sys.stderr.write(
            'Looking for an Android device running abi %s...\n' % abi)
    AddSdkToolsToPath()
    device = FindAndroidRunning(abi)
    if not device:
        if bootstrap:
            if VERBOSE:
                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():
                if VERBOSE:
                    sys.stderr.write('.')
                pollResult[0] = FindAndroidRunning(abi)
                # Stop polling once we have our result.
                return pollResult[0] != None
 
            StartEmulator(abi, avdName, pollFunction)
            device = pollResult[0]
    return device
 
 

FindAndroidRunning()

def android_finder.FindAndroidRunning

(

abi

)

Definition at line 305 of file android_finder.py.

def FindAndroidRunning(abi):
    for device in GetOnlineAndroidDevices().keys():
        if abi in GetAndroidDeviceAbis(device):
            return device
    return None
 
 

FindAvd()

def android_finder.FindAvd	(		avds,
			key
	)

Definition at line 200 of file android_finder.py.

def FindAvd(avds, key):
    for avd in avds:
        if avd['Name'] == key:
            return avd
    return None
 
 

GetAndroidDeviceAbis()

def android_finder.GetAndroidDeviceAbis

(

device

)

Definition at line 296 of file android_finder.py.

def GetAndroidDeviceAbis(device):
    abis = []
    for property in ['ro.product.cpu.abi', 'ro.product.cpu.abi2']:
        out = GetAndroidDeviceProperty(device, property)
        if len(out) > 0:
            abis.append(out)
    return abis
 
 

GetAndroidDeviceProperty()

def android_finder.GetAndroidDeviceProperty	(		device,
			property
	)

Definition at line 291 of file android_finder.py.

def GetAndroidDeviceProperty(device, property):
    return utils.RunCommand(["adb", "-s", device, "shell", "getprop",
                             property]).strip()
 
 

GetAndroidDevices()

def android_finder.GetAndroidDevices

(

)

Definition at line 274 of file android_finder.py.

def GetAndroidDevices():
    return ParseAndroidDevices(utils.RunCommand(["adb", "devices"]))
 
 

GetOnlineAndroidDevices()

def android_finder.GetOnlineAndroidDevices

(

)

Definition at line 287 of file android_finder.py.

def GetOnlineAndroidDevices():
    return FilterOfflineDevices(GetAndroidDevices())
 
 

Main()

def android_finder.Main

(

)

Definition at line 362 of file android_finder.py.

def Main():
    # Parse options.
    parser = BuildOptions()
    (options, args) = parser.parse_args()
    if not ProcessOptions(options):
        parser.print_help()
        return 1
 
    # If there are additional arguments, report error and exit.
    if args:
        parser.print_help()
        return 1
 
    try:
        device = FindAndroid(options.abi, options.bootstrap)
        if device != None:
            sys.stdout.write("%s\n" % device)
            return 0
        else:
            if VERBOSE:
                sys.stderr.write('Could not find device\n')
            return 2
    except utils.Error as e:
        sys.stderr.write("error: %s\n" % e)
        if DEBUG:
            traceback.print_exc(file=sys.stderr)
        return -1
 
 

ParseAndroidDevices()

def android_finder.ParseAndroidDevices

(

text

)

Return Dictionary [name] -> status

Definition at line 262 of file android_finder.py.

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
 
 

ParseAndroidListAvdResult()

def android_finder.ParseAndroidListAvdResult

(

text

)

Parse the output of an 'android list avd' command.
Return List of {Name: Path: Target: ABI: Skin: Sdcard:}

Definition at line 167 of file android_finder.py.

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:
                continue
            match = line_re.match(line)
            if match is None:
                sys.stderr.write('Match fail %s\n' % str(line))
                continue
                #raise utils.Error('Match failed')
            entry[match.group(1)] = match.group(2)
        if len(entry) > 0:
            result.append(entry)
    return result
 
 

ParseAndroidListSdkResult()

def android_finder.ParseAndroidListSdkResult

(

text

)

Parse the output of an 'android list sdk' command.

Return list of (id-num, id-key, type, description).

Definition at line 67 of file android_finder.py.

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:
            continue
        entries.append((int(match.group(1)), match.group(2), match.group(3),
                        match.group(4)))
    return entries
 
 

ProcessOptions()

def android_finder.ProcessOptions

(

options

)

Definition at line 56 of file android_finder.py.

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
 
 

SdkPackagesForAbi()

def android_finder.SdkPackagesForAbi

(

abi

)

Definition at line 130 of file android_finder.py.

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]
 
 

StartEmulator()

def android_finder.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.

Definition at line 236 of file android_finder.py.

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)
 
 

TargetForAbi()

def android_finder.TargetForAbi

(

abi

)

Definition at line 151 of file android_finder.py.

def TargetForAbi(abi):
    for package in SdkPackagesForAbi(abi):
        if package[1] == 'Platform':
            return package[0]
 
 

Variable Documentation

DEBUG

bool android_finder.DEBUG = False

Definition at line 22 of file android_finder.py.

VERBOSE

bool android_finder.VERBOSE = False

Definition at line 23 of file android_finder.py.