def RunCommand(name, value=None, length=None):
if name in COMMANDS:
return utils.RunCommand(COMMANDS[name])
elif name == "change_volume":
return utils.RunCommand([QTOOL, "--volume=%d" % int(value)])
elif name == "change_position":
secs = int(length * int(value) / 100)
time = "%d:%d" % (secs / 60, secs % 60)
print(length, value, time)
return utils.RunCommand([QTOOL, "--seek=%s" % time])
else:
logging.error("unknown command %s", name)
return None, None
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
# Setup arguments to the snapshot generator binary.
script_args = ["--ignore_unrecognized_flags"]
for flag in options.vm_flag:
script_args.append(flag)
# Pass along the packages if there is one.
if options.packages:
script_args.append(''.join(["--packages=", options.packages]))
# First setup the vm isolate and regular isolate snapshot output filename.
script_args.append(''.join(["--snapshot_kind=", options.snapshot_kind]))
script_args.append(''.join(["--vm_snapshot_data=", options.vm_output_bin]))
script_args.append(''.join(
["--isolate_snapshot_data=", options.isolate_output_bin]))
if options.vm_instructions_output_bin != None:
script_args.append(''.join(
["--vm_snapshot_instructions=",
options.vm_instructions_output_bin]))
if options.isolate_instructions_output_bin != None:
script_args.append(''.join([
"--isolate_snapshot_instructions=",
options.isolate_instructions_output_bin
]))
# Finally append the script name if one is specified.
if options.script:
script_args.append(options.script)
# Construct command line to execute the snapshot generator binary and invoke.
command = [options.executable] + script_args
try:
utils.RunCommand(
command,
outStream=sys.stderr,
errStream=sys.stderr,
verbose=options.verbose,
printErrorInfo=True)
except Exception as e:
return -1
# Success, update timestamp file.
CreateTimestampFile(options)
return 0
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')
def RunCommand(name):
for s in OPTIONS.system_commands:
tokens = s.split(":")
if name == tokens[0]:
return utils.RunCommand(tokens[1].split())
logging.error("unknown command %s", name)
return None, None
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
# Setup arguments to the snapshot generator binary.
script_args = ["--error_on_bad_type", "--error_on_bad_override"]
# Pass along the package_root if there is one.
if options.package_root:
script_args.append(''.join(["--package_root=", options.package_root]))
# First setup the vm isolate and regular isolate snapshot output filename.
script_args.append(''.join(
["--vm_isolate_snapshot=", options.vm_output_bin]))
script_args.append(''.join(["--isolate_snapshot=", options.output_bin]))
# Next setup all url mapping options specified.
for url_arg in options.url_mapping:
url_mapping_argument = ''.join(["--url_mapping=", url_arg])
script_args.append(url_mapping_argument)
# Finally append the script name if one is specified.
if options.script:
script_args.append(options.script)
# Construct command line to execute the snapshot generator binary and invoke.
command = [options.executable] + script_args
try:
utils.RunCommand(command,
outStream=sys.stderr,
errStream=sys.stderr,
verbose=options.verbose,
printErrorInfo=True)
except Exception as e:
return -1
# Success, update timestamp file.
CreateTimestampFile(options)
return 0
def GetJpeg(camera):
logging.info("GetJpeg " + camera)
filename = "/tmp/hocuspocus%s.jpeg" % camera.replace("/", "-")
if os.path.exists(filename):
os.remove(filename)
cmd = COMMAND % (camera, OPTIONS.webcam_resolution, filename)
_, _ = utils.RunCommand(cmd.split())
logging.info("opening")
try:
with open(filename, "rb") as fp:
logging.info("reading")
data = fp.read()
logging.info("GetJpeg completed %d", len(data))
return data
except Exception as err:
logging.error("webcam issues: " + str(err))
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]
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
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
# Setup arguments to the snapshot generator binary.
script_args = []
# First setup the snapshot output filename.
script_args.append(''.join(["--snapshot=", options.output_bin]))
# Next setup all url mapping options specified.
for url_arg in options.url_mapping:
url_mapping_argument = ''.join(["--url_mapping=", url_arg])
script_args.append(url_mapping_argument)
# Finally append the script name if one is specified.
if options.script:
script_args.append(options.script)
# Construct command line to execute the snapshot generator binary and invoke.
if options.target_os == 'android':
RunOnAndroid(options)
else:
command = [options.executable] + script_args
try:
utils.RunCommand(command,
outStream=sys.stderr,
errStream=sys.stderr,
verbose=options.verbose,
printErrorInfo=True)
except Exception as e:
return -1
return 0
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 RunOnAndroid(options):
outputBin = options.output_bin
android_workspace = os.getenv("ANDROID_DART", "/data/local/dart")
android_outputBin = join(android_workspace, basename(outputBin))
executable = options.executable
android_executable = join(android_workspace, basename(executable))
filesToPush = [] # (src, dest)
filesToPull = [] # (src, dest)
# Setup arguments to the snapshot generator binary.
script_args = [android_executable]
# First setup the snapshot output filename.
filesToPull.append((android_outputBin, outputBin))
script_args.append(''.join(["--snapshot=", android_outputBin]))
# We don't know what source files are needed to fully satisfy a dart script,
# so we can't support the general case of url mapping or script inclusion.
if options.url_mapping:
raise Exception(
"--url_mapping is not supported when building for Android")
if options.script:
raise Exception("--script is not supported when building for Android")
filesToPush.append((executable, android_executable))
abi = options.abi or 'x86'
# We know we're run in the runtime directory, and we know the relative path
# to the tools we want to execute:
command = ["tools/android_finder.py", "--bootstrap", "--abi", abi]
if VERBOSE:
command += ['--verbose']
device = utils.RunCommand(command, errStream=sys.stderr)
if device == None:
raise Exception("Could not find Android device for abi %s" % abi)
device = device.strip()
if VERBOSE:
sys.write.stderr('Using Android device %s for abi %s' % (device, abi))
RunAdbShell(device, ["mkdir", android_workspace])
try:
if VERBOSE:
sys.write.stderr('pushing files to %s' % device)
for src, dest in filesToPush:
RunAdb(device, ["push", src, dest])
if VERBOSE:
sys.write.stderr('running snapshot generator')
RunAdbShell(device, script_args)
if VERBOSE:
sys.write.stderr('retrieving snapshot')
for src, dest in filesToPull:
RunAdb(device, ["pull", src, dest])
finally:
if VERBOSE:
sys.write.stderr('cleaning intermediate files')
for src, dest in filesToPush:
RunAdbShell(device, ["rm", dest])
for src, dest in filesToPull:
RunAdbShell(device, ["rm", src])
def RunAdb(device, command):
"""Run a raw adb command."""
return utils.RunCommand(["adb", "-s", device] + command)
def AndroidListSdk():
return ParseAndroidListSdkResult(utils.RunCommand(
["android", "list", "sdk", "-a", "-e"]))
def _PulseCommand(s):
logging.info("Pulse command: %s", s)
return utils.RunCommand([PACTL] + s)
def AndroidListAvd(): """Returns a list of available Android Virtual Devices.""" return ParseAndroidListAvdResult(utils.RunCommand(["android", "list", "avd"]))
def ChromeVersion():
_, content = utils.RunCommand([CHROME, "--version"])
return content
def ChromeOpenURL(url):
_, content = utils.RunCommand([CHROME, "--new-window", url])
return content
def GetAndroidDevices(): return ParseAndroidDevices(utils.RunCommand(["adb", "devices"]))
def GetAndroidDeviceProperty(device, property):
return utils.RunCommand(
["adb", "-s", device, "shell", "getprop", property]).strip()
def VlcKill():
logging.info("kill vlc")
utils.RunCommand(VLC_KILL_CMD)
