StrixOS/build
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

auto import from //depot/cupcake/@135843

Browse Source
This commit is contained in:
The Android Open Source Project
2009-03-03 19:28:42 -08:00
parent 05806d7af6
commit 88b607994a
404 changed files with 43942 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

981
tools/dexpreopt/dexpreopt.py Executable file
View File

@@ -0,0 +1,981 @@
#!/usr/bin/env python
#
# Copyright (C) 2008 The Android Open Source Project
#
# Licensed under the Apache License, Version 2.0 (the 'License');
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an 'AS IS' BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
"""Creates optimized versions of APK files.
A tool and associated functions to communicate with an Android
emulator instance, run commands, and scrape out files.
Requires at least python2.4.
"""
import array
import datetime
import optparse
import os
import posix
import select
import signal
import struct
import subprocess
import sys
import tempfile
import time
import zlib
_emulator_popen = None
_DEBUG_READ = 1
def EnsureTempDir(path=None):
"""Creates a temporary directory and returns its path.
Creates any necessary parent directories.
Args:
path: If specified, used as the temporary directory. If not specified,
a safe temporary path is created. The caller is responsible for
deleting the directory.
Returns:
The path to the new directory, or None if a problem occurred.
"""
if path is None:
path = tempfile.mkdtemp('', 'dexpreopt-')
elif not os.path.exists(path):
os.makedirs(path)
elif not os.path.isdir(path):
return None
return path
def CreateZeroedFile(path, length):
"""Creates the named file and writes <length> zero bytes to it.
Unlinks the file first if it already exists.
Creates its containing directory if necessary.
Args:
path: The path to the file to create.
length: The number of zero bytes to write to the file.
Returns:
True on success.
"""
subprocess.call(['rm', '-f', path])
d = os.path.dirname(path)
if d and not os.path.exists(d): os.makedirs(os.path.dirname(d))
# TODO: redirect child's stdout to /dev/null
ret = subprocess.call(['dd', 'if=/dev/zero', 'of=%s' % path,
'bs=%d' % length, 'count=1'])
return not ret # i.e., ret == 0; i.e., the child exited successfully.
def StartEmulator(exe_name='emulator', kernel=None,
ramdisk=None, image=None, userdata=None, system=None):
"""Runs the emulator with the specified arguments.
Args:
exe_name: The name of the emulator to run. May be absolute, relative,
or unqualified (and left to exec() to find).
kernel: If set, passed to the emulator as "-kernel".
ramdisk: If set, passed to the emulator as "-ramdisk".
image: If set, passed to the emulator as "-image".
userdata: If set, passed to the emulator as "-initdata" and "-data".
system: If set, passed to the emulator as "-system".
Returns:
A subprocess.Popen that refers to the emulator process, or None if
a problem occurred.
"""
#exe_name = './stuff'
args = [exe_name]
if kernel: args += ['-kernel', kernel]
if ramdisk: args += ['-ramdisk', ramdisk]
if image: args += ['-image', image]
if userdata: args += ['-initdata', userdata, '-data', userdata]
if system: args += ['-system', system]
args += ['-no-window', '-netfast', '-noaudio']
_USE_PIPE = True
if _USE_PIPE:
# Use dedicated fds instead of stdin/out to talk to the
# emulator so that the emulator doesn't try to tty-cook
# the data.
em_stdin_r, em_stdin_w = posix.pipe()
em_stdout_r, em_stdout_w = posix.pipe()
args += ['-shell-serial', 'fdpair:%d:%d' % (em_stdin_r, em_stdout_w)]
else:
args += ['-shell']
# Ensure that this environment variable isn't set;
# if it is, the emulator will print the log to stdout.
if os.environ.get('ANDROID_LOG_TAGS'):
del os.environ['ANDROID_LOG_TAGS']
try:
# bufsize=1 line-buffered, =0 unbuffered,
# <0 system default (fully buffered)
Trace('Running emulator: %s' % ' '.join(args))
if _USE_PIPE:
ep = subprocess.Popen(args)
else:
ep = subprocess.Popen(args, close_fds=True,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
if ep:
if _USE_PIPE:
# Hijack the Popen.stdin/.stdout fields to point to our
# pipes. These are the same fields that would have been set
# if we called Popen() with stdin=subprocess.PIPE, etc.
# Note that these names are from the point of view of the
# child process.
#
# Since we'll be using select.select() to read data a byte
# at a time, it's important that these files are unbuffered
# (bufsize=0). If Popen() took care of the pipes, they're
# already unbuffered.
ep.stdin = os.fdopen(em_stdin_w, 'w', 0)
ep.stdout = os.fdopen(em_stdout_r, 'r', 0)
return ep
except OSError, e:
print >>sys.stderr, 'Could not start emulator:', e
return None
def IsDataAvailable(fo, timeout=0):
"""Indicates whether or not data is available to be read from a file object.
Args:
fo: A file object to read from.
timeout: The number of seconds to wait for data, or zero for no timeout.
Returns:
True iff data is available to be read.
"""
return select.select([fo], [], [], timeout) == ([fo], [], [])
def ConsumeAvailableData(fo):
"""Reads data from a file object while it's available.
Stops when no more data is immediately available or upon reaching EOF.
Args:
fo: A file object to read from.
Returns:
An unsigned byte array.array of the data that was read.
"""
buf = array.array('B')
while IsDataAvailable(fo):
try:
buf.fromfile(fo, 1)
except EOFError:
break
return buf
def ShowTimeout(timeout, end_time):
"""For debugging, display the timeout info.
Args:
timeout: the timeout in seconds.
end_time: a time.time()-based value indicating when the timeout should
expire.
"""
if _DEBUG_READ:
if timeout:
remaining = end_time - time.time()
Trace('ok, time remaining %.1f of %.1f' % (remaining, timeout))
else:
Trace('ok (no timeout)')
def WaitForString(inf, pattern, timeout=0, max_len=0, eat_to_eol=True,
reset_on_activity=False):
"""Reads from a file object and returns when the pattern matches the data.
Reads a byte at a time to avoid consuming extra data, so do not call
this function when you expect the pattern to match a large amount of data.
Args:
inf: The file object to read from.
pattern: The string to look for in the input data.
May be a tuple of strings.
timeout: How long to wait, in seconds. No timeout if it evaluates to False.
max_len: Return None if this many bytes have been read without matching.
No upper bound if it evaluates to False.
eat_to_eol: If true, the input data will be consumed until a '\\n' or EOF
is encountered.
reset_on_activity: If True, reset the timeout whenever a character is
read.
Returns:
The input data matching the expression as an unsigned char array,
or None if the operation timed out or didn't match after max_len bytes.
Raises:
IOError: An error occurred reading from the input file.
"""
if timeout:
end_time = time.time() + timeout
else:
end_time = 0
if _DEBUG_READ:
Trace('WaitForString: "%s", %.1f' % (pattern, timeout))
buf = array.array('B') # unsigned char array
eating = False
while True:
if end_time:
remaining = end_time - time.time()
if remaining <= 0:
Trace('Timeout expired after %.1f seconds' % timeout)
return None
else:
remaining = None
if IsDataAvailable(inf, remaining):
if reset_on_activity and timeout:
end_time = time.time() + timeout
buf.fromfile(inf, 1)
if _DEBUG_READ:
c = buf.tostring()[-1:]
ci = ord(c)
if ci < 0x20: c = '.'
if _DEBUG_READ > 1:
print 'read [%c] 0x%02x' % (c, ci)
if not eating:
if buf.tostring().endswith(pattern):
if eat_to_eol:
if _DEBUG_READ > 1:
Trace('Matched; eating to EOL')
eating = True
else:
ShowTimeout(timeout, end_time)
return buf
if _DEBUG_READ > 2:
print '/%s/ ? "%s"' % (pattern, buf.tostring())
else:
if buf.tostring()[-1:] == '\n':
ShowTimeout(timeout, end_time)
return buf
if max_len and len(buf) >= max_len: return None
def WaitForEmulator(ep, timeout=0):
"""Waits for the emulator to start up and print the first prompt.
Args:
ep: A subprocess.Popen object referring to the emulator process.
timeout: How long to wait, in seconds. No timeout if it evaluates to False.
Returns:
True on success, False if the timeout occurred.
"""
# Prime the pipe; the emulator doesn't start without this.
print >>ep.stdin, ''
# Wait until the console is ready and the first prompt appears.
buf = WaitForString(ep.stdout, '#', timeout=timeout, eat_to_eol=False)
if buf:
Trace('Saw the prompt: "%s"' % buf.tostring())
return True
return False
def WaitForPrompt(ep, prompt=None, timeout=0, reset_on_activity=False):
"""Blocks until the prompt appears on ep.stdout or the timeout elapses.
Args:
ep: A subprocess.Popen connection to the emulator process.
prompt: The prompt to wait for. If None, uses ep.prompt.
timeout: How many seconds to wait for the prompt. Waits forever
if timeout is zero.
reset_on_activity: If True, reset the timeout whenever a character is
read.
Returns:
A string containing the data leading up to the prompt. The string
will always end in '\\n'. Returns None if the prompt was not seen
within the timeout, or if some other error occurred.
"""
if not prompt: prompt = ep.prompt
if prompt:
#Trace('waiting for prompt "%s"' % prompt)
data = WaitForString(ep.stdout, prompt,
timeout=timeout, reset_on_activity=reset_on_activity)
if data:
# data contains everything on ep.stdout up to and including the prompt,
# plus everything up 'til the newline. Scrape out the prompt
# and everything that follows, and ensure that the result ends
# in a newline (which is important if it would otherwise be empty).
s = data.tostring()
i = s.rfind(prompt)
s = s[:i]
if s[-1:] != '\n':
s += '\n'
if _DEBUG_READ:
print 'WaitForPrompt saw """\n%s"""' % s
return s
return None
def ReplaceEmulatorPrompt(ep, prompt=None):
"""Replaces PS1 in the emulator with a different value.
This is useful for making the prompt unambiguous; i.e., something
that probably won't appear in the output of another command.
Assumes that the emulator is already sitting at a prompt,
waiting for shell input.
Puts the new prompt in ep.prompt.
Args:
ep: A subprocess.Popen object referring to the emulator process.
prompt: The new prompt to use
Returns:
True on success, False if the timeout occurred.
"""
if not prompt:
prompt = '-----DEXPREOPT-PROMPT-----'
print >>ep.stdin, 'PS1="%s\n"' % prompt
ep.prompt = prompt
# Eat the command echo.
data = WaitForPrompt(ep, timeout=2)
if not data:
return False
# Make sure it's actually there.
return WaitForPrompt(ep, timeout=2)
def RunEmulatorCommand(ep, cmd, timeout=0):
"""Sends the command to the emulator's shell and waits for the result.
Assumes that the emulator is already sitting at a prompt,
waiting for shell input.
Args:
ep: A subprocess.Popen object referring to the emulator process.
cmd: The shell command to run in the emulator.
timeout: The number of seconds to wait for the command to complete,
or zero for no timeout.
Returns:
If the command ran and returned to the console prompt before the
timeout, returns the output of the command as a string.
Returns None otherwise.
"""
ConsumeAvailableData(ep.stdout)
Trace('Running "%s"' % cmd)
print >>ep.stdin, '%s' % cmd
# The console will echo the command.
#Trace('Waiting for echo')
if WaitForString(ep.stdout, cmd, timeout=timeout):
#Trace('Waiting for completion')
return WaitForPrompt(ep, timeout=timeout, reset_on_activity=True)
return None
def ReadFileList(ep, dir_list, timeout=0):
"""Returns a list of emulator files in each dir in dir_list.
Args:
ep: A subprocess.Popen object referring to the emulator process.
dir_list: List absolute paths to directories to read.
timeout: The number of seconds to wait for the command to complete,
or zero for no timeout.
Returns:
A list of absolute paths to files in the named directories,
in the context of the emulator's filesystem.
None on failure.
"""
ret = []
for d in dir_list:
output = RunEmulatorCommand(ep, 'ls ' + d, timeout=timeout)
if not output:
Trace('Could not ls ' + d)
return None
ret += ['%s/%s' % (d, f) for f in output.splitlines()]
return ret
def DownloadDirectoryHierarchy(ep, src, dest, timeout=0):
"""Recursively downloads an emulator directory to the local filesystem.
Args:
ep: A subprocess.Popen object referring to the emulator process.
src: The path on the emulator's filesystem to download from.
dest: The path on the local filesystem to download to.
timeout: The number of seconds to wait for the command to complete,
or zero for no timeout. (CURRENTLY IGNORED)
Returns:
True iff the files downloaded successfully, False otherwise.
"""
ConsumeAvailableData(ep.stdout)
if not os.path.exists(dest):
os.makedirs(dest)
cmd = 'afar %s' % src
Trace('Running "%s"' % cmd)
print >>ep.stdin, '%s' % cmd
# The console will echo the command.
#Trace('Waiting for echo')
if not WaitForString(ep.stdout, cmd, timeout=timeout):
return False
#TODO: use a signal to support timing out?
#
# Android File Archive format:
#
# magic[5]: 'A' 'F' 'A' 'R' '\n'
# version[4]: 0x00 0x00 0x00 0x01
# for each file:
# file magic[4]: 'F' 'I' 'L' 'E'
# namelen[4]: Length of file name, including NUL byte (big-endian)
# name[*]: NUL-terminated file name
# datalen[4]: Length of file (big-endian)
# data[*]: Unencoded file data
# adler32[4]: adler32 of the unencoded file data (big-endian)
# file end magic[4]: 'f' 'i' 'l' 'e'
# end magic[4]: 'E' 'N' 'D' 0x00
#
# Read the header.
HEADER = array.array('B', 'AFAR\n\000\000\000\001')
buf = array.array('B')
buf.fromfile(ep.stdout, len(HEADER))
if buf != HEADER:
Trace('Header does not match: "%s"' % buf)
return False
# Read the file entries.
FILE_START = array.array('B', 'FILE')
FILE_END = array.array('B', 'file')
END = array.array('B', 'END\000')
while True:
# Entry magic.
buf = array.array('B')
buf.fromfile(ep.stdout, 4)
if buf == FILE_START:
# Name length (4 bytes, big endian)
buf = array.array('B')
buf.fromfile(ep.stdout, 4)
(name_len,) = struct.unpack('>I', buf)
#Trace('name len %d' % name_len)
# Name, NUL-terminated.
buf = array.array('B')
buf.fromfile(ep.stdout, name_len)
buf.pop() # Remove trailing NUL byte.
file_name = buf.tostring()
Trace('FILE: %s' % file_name)
# File length (4 bytes, big endian)
buf = array.array('B')
buf.fromfile(ep.stdout, 4)
(file_len,) = struct.unpack('>I', buf)
# File data.
data = array.array('B')
data.fromfile(ep.stdout, file_len)
#Trace('FILE: read %d bytes from %s' % (file_len, file_name))
# adler32 (4 bytes, big endian)
buf = array.array('B')
buf.fromfile(ep.stdout, 4)
(adler32,) = struct.unpack('>i', buf) # adler32 wants a signed int ('i')
data_adler32 = zlib.adler32(data)
# Because of a difference in behavior of zlib.adler32 on 32-bit and 64-bit
# systems (one returns signed values, the other unsigned), we take the
# modulo 2**32 of the checksums, and compare those.
# See also http://bugs.python.org/issue1202
if (adler32 % (2**32)) != (data_adler32 % (2**32)):
Trace('adler32 does not match: calculated 0x%08x != expected 0x%08x' %
(data_adler32, adler32))
return False
# File end magic.
buf = array.array('B')
buf.fromfile(ep.stdout, 4)
if buf != FILE_END:
Trace('Unexpected file end magic "%s"' % buf)
return False
# Write to the output file
out_file_name = dest + '/' + file_name[len(src):]
p = os.path.dirname(out_file_name)
if not os.path.exists(p): os.makedirs(p)
fo = file(out_file_name, 'w+b')
fo.truncate(0)
Trace('FILE: Writing %d bytes to %s' % (len(data), out_file_name))
data.tofile(fo)
fo.close()
elif buf == END:
break
else:
Trace('Unexpected magic "%s"' % buf)
return False
return WaitForPrompt(ep, timeout=timeout, reset_on_activity=True)
def ReadBootClassPath(ep, timeout=0):
"""Reads and returns the default bootclasspath as a list of files.
Args:
ep: A subprocess.Popen object referring to the emulator process.
timeout: The number of seconds to wait for the command to complete,
or zero for no timeout.
Returns:
The bootclasspath as a list of strings.
None on failure.
"""
bcp = RunEmulatorCommand(ep, 'echo $BOOTCLASSPATH', timeout=timeout)
if not bcp:
Trace('Could not find bootclasspath')
return None
return bcp.strip().split(':') # strip trailing newline
def RunDexoptOnFileList(ep, files, dest_root, move=False, timeout=0):
"""Creates the corresponding .odex file for all jar/apk files in 'files'.
Copies the .odex file to a location under 'dest_root'. If 'move' is True,
the file is moved instead of copied.
Args:
ep: A subprocess.Popen object referring to the emulator process.
files: The list of files to optimize
dest_root: directory to copy/move odex files to. Must already exist.
move: if True, move rather than copy files
timeout: The number of seconds to wait for the command to complete,
or zero for no timeout.
Returns:
True on success, False on failure.
"""
for jar_file in files:
if jar_file.endswith('.apk') or jar_file.endswith('.jar'):
odex_file = jar_file[:jar_file.rfind('.')] + '.odex'
cmd = 'dexopt-wrapper %s %s' % (jar_file, odex_file)
if not RunEmulatorCommand(ep, cmd, timeout=timeout):
Trace('"%s" failed' % cmd)
return False
# Always copy the odex file. There's no cp(1), so we
# cat out to the new file.
dst_odex = dest_root + odex_file
cmd = 'cat %s > %s' % (odex_file, dst_odex) # no cp(1)
if not RunEmulatorCommand(ep, cmd, timeout=timeout):
Trace('"%s" failed' % cmd)
return False
# Move it if we're asked to. We can't use mv(1) because
# the files tend to move between filesystems.
if move:
cmd = 'rm %s' % odex_file
if not RunEmulatorCommand(ep, cmd, timeout=timeout):
Trace('"%s" failed' % cmd)
return False
return True
def InstallCacheFiles(cache_system_dir, out_system_dir):
"""Install files in cache_system_dir to the proper places in out_system_dir.
cache_system_dir contains various files from /system, plus .odex files
for most of the .apk/.jar files that live there.
This function copies each .odex file from the cache dir to the output dir
and removes "classes.dex" from each appropriate .jar/.apk.
E.g., <cache_system_dir>/app/NotePad.odex would be copied to
<out_system_dir>/app/NotePad.odex, and <out_system_dir>/app/NotePad.apk
would have its classes.dex file removed.
Args:
cache_system_dir: The directory containing the cache files scraped from
the emulator.
out_system_dir: The local directory that corresponds to "/system"
on the device filesystem. (the root of system.img)
Returns:
True if everything succeeded, False if any problems occurred.
"""
# First, walk through cache_system_dir and copy every .odex file
# over to out_system_dir, ensuring that the destination directory
# contains the corresponding source file.
for root, dirs, files in os.walk(cache_system_dir):
for name in files:
if name.endswith('.odex'):
odex_file = os.path.join(root, name)
# Find the path to the .odex file's source apk/jar file.
out_stem = odex_file[len(cache_system_dir):odex_file.rfind('.')]
out_stem = out_system_dir + out_stem;
jar_file = out_stem + '.jar'
if not os.path.exists(jar_file):
jar_file = out_stem + '.apk'
if not os.path.exists(jar_file):
Trace('Cannot find source .jar/.apk for %s: %s' %
(odex_file, out_stem + '.{jar,apk}'))
return False
# Copy the cache file next to the source file.
cmd = ['cp', odex_file, out_stem + '.odex']
ret = subprocess.call(cmd)
if ret: # non-zero exit status
Trace('%s failed' % ' '.join(cmd))
return False
# Walk through the output /system directory, making sure
# that every .jar/.apk has an odex file. While we do this,
# remove the classes.dex entry from each source archive.
for root, dirs, files in os.walk(out_system_dir):
for name in files:
if name.endswith('.apk') or name.endswith('.jar'):
jar_file = os.path.join(root, name)
odex_file = jar_file[:jar_file.rfind('.')] + '.odex'
if not os.path.exists(odex_file):
if root.endswith('/system/app') or root.endswith('/system/framework'):
Trace('jar/apk %s has no .odex file %s' % (jar_file, odex_file))
return False
else:
continue
# Attempting to dexopt a jar with no classes.dex currently
# creates a 40-byte odex file.
# TODO: use a more reliable check
if os.path.getsize(odex_file) > 100:
# Remove classes.dex from the .jar file.
cmd = ['zip', '-dq', jar_file, 'classes.dex']
ret = subprocess.call(cmd)
if ret: # non-zero exit status
Trace('"%s" failed' % ' '.join(cmd))
return False
else:
# Some of the apk files don't contain any code.
if not name.endswith('.apk'):
Trace('%s has a zero-length odex file' % jar_file)
return False
cmd = ['rm', odex_file]
ret = subprocess.call(cmd)
if ret: # non-zero exit status
Trace('"%s" failed' % ' '.join(cmd))
return False
return True
def KillChildProcess(p, sig=signal.SIGTERM, timeout=0):
"""Waits for a child process to die without getting stuck in wait().
After Jean Brouwers's 2004 post to python-list.
Args:
p: A subprocess.Popen representing the child process to kill.
sig: The signal to send to the child process.
timeout: How many seconds to wait for the child process to die.
If zero, do not time out.
Returns:
The exit status of the child process, if it was successfully killed.
The final value of p.returncode if it wasn't.
"""
os.kill(p.pid, sig)
if timeout > 0:
while p.poll() < 0:
if timeout > 0.5:
timeout -= 0.25
time.sleep(0.25)
else:
os.kill(p.pid, signal.SIGKILL)
time.sleep(0.5)
p.poll()
break
else:
p.wait()
return p.returncode
def Trace(msg):
"""Prints a message to stdout.
Args:
msg: The message to print.
"""
#print 'dexpreopt: %s' % msg
when = datetime.datetime.now()
print '%02d:%02d.%d dexpreopt: %s' % (when.minute, when.second, when.microsecond, msg)
def KillEmulator():
"""Attempts to kill the emulator process, if it is running.
Returns:
The exit status of the emulator process, or None if the emulator
was not running or was unable to be killed.
"""
global _emulator_popen
if _emulator_popen:
Trace('Killing emulator')
try:
ret = KillChildProcess(_emulator_popen, sig=signal.SIGINT, timeout=5)
except OSError:
Trace('Could not kill emulator')
ret = None
_emulator_popen = None
return ret
return None
def Fail(msg=None):
"""Prints an error and causes the process to exit.
Args:
msg: Additional error string to print (optional).
Returns:
Does not return.
"""
s = 'dexpreopt: ERROR'
if msg: s += ': %s' % msg
print >>sys.stderr, msg
KillEmulator()
sys.exit(1)
def PrintUsage(msg=None):
"""Prints commandline usage information for the tool and exits with an error.
Args:
msg: Additional string to print (optional).
Returns:
Does not return.
"""
if msg:
print >>sys.stderr, 'dexpreopt: %s', msg
print >>sys.stderr, """Usage: dexpreopt <options>
Required options:
-kernel <kernel file> Kernel to use when running the emulator
-ramdisk <ramdisk.img file> Ramdisk to use when running the emulator
-image <system.img file> System image to use when running the
emulator. /system/app should contain the
.apk files to optimize, and any required
bootclasspath libraries must be present
in the correct locations.
-system <path> The product directory, which usually contains
files like 'system.img' (files other than
the kernel in that directory won't
be used)
-outsystemdir <path> A fully-populated /system directory, ready
to be modified to contain the optimized
files. The appropriate .jar/.apk files
will be stripped of their classes.dex
entries, and the optimized .dex files
will be added alongside the packages
that they came from.
Optional:
-tmpdir <path> If specified, use this directory for
intermediate objects. If not specified,
a unique directory under the system
temp dir is used.
"""
sys.exit(2)
def ParseArgs(argv):
"""Parses commandline arguments.
Args:
argv: A list of arguments; typically sys.argv[1:]
Returns:
A tuple containing two dictionaries; the first contains arguments
that will be passsed to the emulator, and the second contains other
arguments.
"""
parser = optparse.OptionParser()
parser.add_option('--kernel', help='Passed to emulator')
parser.add_option('--ramdisk', help='Passed to emulator')
parser.add_option('--image', help='Passed to emulator')
parser.add_option('--system', help='Passed to emulator')
parser.add_option('--outsystemdir', help='Destination /system directory')
parser.add_option('--tmpdir', help='Optional temp directory to use')
options, args = parser.parse_args(args=argv)
if args: PrintUsage()
emulator_args = {}
other_args = {}
if options.kernel: emulator_args['kernel'] = options.kernel
if options.ramdisk: emulator_args['ramdisk'] = options.ramdisk
if options.image: emulator_args['image'] = options.image
if options.system: emulator_args['system'] = options.system
if options.outsystemdir: other_args['outsystemdir'] = options.outsystemdir
if options.tmpdir: other_args['tmpdir'] = options.tmpdir
return (emulator_args, other_args)
def DexoptEverything(ep, dest_root):
"""Logic for finding and dexopting files in the necessary order.
Args:
ep: A subprocess.Popen object referring to the emulator process.
dest_root: directory to copy/move odex files to
Returns:
True on success, False on failure.
"""
_extra_tests = False
if _extra_tests:
if not RunEmulatorCommand(ep, 'ls /system/app', timeout=5):
Fail('Could not ls')
# We're very short on space, so remove a bunch of big stuff that we
# don't need.
cmd = 'rm -r /system/sounds /system/media /system/fonts /system/xbin'
if not RunEmulatorCommand(ep, cmd, timeout=40):
Trace('"%s" failed' % cmd)
return False
Trace('Read file list')
jar_dirs = ['/system/framework', '/system/app']
files = ReadFileList(ep, jar_dirs, timeout=5)
if not files:
Fail('Could not list files in %s' % ' '.join(jar_dirs))
#Trace('File list:\n"""\n%s\n"""' % '\n'.join(files))
bcp = ReadBootClassPath(ep, timeout=2)
if not files:
Fail('Could not sort by bootclasspath')
# Remove bootclasspath entries from the main file list.
for jar in bcp:
try:
files.remove(jar)
except ValueError:
Trace('File list does not contain bootclasspath entry "%s"' % jar)
return False
# Create the destination directories.
for d in ['', '/system'] + jar_dirs:
cmd = 'mkdir %s%s' % (dest_root, d)
if not RunEmulatorCommand(ep, cmd, timeout=4):
Trace('"%s" failed' % cmd)
return False
# First, dexopt the bootclasspath. Keep their cache files in place.
Trace('Dexopt %d bootclasspath files' % len(bcp))
if not RunDexoptOnFileList(ep, bcp, dest_root, timeout=120):
Trace('Could not dexopt bootclasspath')
return False
# dexopt the rest. To avoid running out of space on the emulator
# volume, move each cache file after it's been created.
Trace('Dexopt %d files' % len(files))
if not RunDexoptOnFileList(ep, files, dest_root, move=True, timeout=120):
Trace('Could not dexopt files')
return False
if _extra_tests:
if not RunEmulatorCommand(ep, 'ls /system/app', timeout=5):
Fail('Could not ls')
return True
def MainInternal():
"""Main function that can be wrapped in a try block.
Returns:
Nothing.
"""
emulator_args, other_args = ParseArgs(sys.argv[1:])
tmp_dir = EnsureTempDir(other_args.get('tmpdir'))
if not tmp_dir: Fail('Could not create temp dir')
Trace('Creating data image')
userdata = '%s/data.img' % tmp_dir
if not CreateZeroedFile(userdata, 32 * 1024 * 1024):
Fail('Could not create data image file')
emulator_args['userdata'] = userdata
ep = StartEmulator(**emulator_args)
if not ep: Fail('Could not start emulator')
global _emulator_popen
_emulator_popen = ep
# TODO: unlink the big userdata file now, since the emulator
# has it open.
if not WaitForEmulator(ep, timeout=20): Fail('Emulator did not respond')
if not ReplaceEmulatorPrompt(ep): Fail('Could not replace prompt')
dest_root = '/data/dexpreopt-root'
if not DexoptEverything(ep, dest_root): Fail('Could not dexopt files')
# Grab the odex files that were left in dest_root.
cache_system_dir = tmp_dir + '/cache-system'
if not DownloadDirectoryHierarchy(ep, dest_root + '/system',
cache_system_dir,
timeout=20):
Fail('Could not download %s/system from emulator' % dest_root)
if not InstallCacheFiles(cache_system_dir=cache_system_dir,
out_system_dir=other_args['outsystemdir']):
Fail('Could not install files')
Trace('dexpreopt successful')
# Success!
def main():
try:
MainInternal()
finally:
KillEmulator()
if __name__ == '__main__':
main()