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)