adb.dart 12.2 KB
Newer Older
1 2 3 4 5 6 7 8
// Copyright 2016 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

import 'dart:async';
import 'dart:io';
import 'dart:math' as math;

9
import 'package:meta/meta.dart';
10 11 12 13
import 'package:path/path.dart' as path;

import 'utils.dart';

14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34
/// The root of the API for controlling devices.
DeviceDiscovery get devices => new DeviceDiscovery();

/// Device operating system the test is configured to test.
enum DeviceOperatingSystem { android, ios }

/// Device OS to test on.
DeviceOperatingSystem deviceOperatingSystem = DeviceOperatingSystem.android;

/// Discovers available devices and chooses one to work with.
abstract class DeviceDiscovery {
  factory DeviceDiscovery() {
    switch(deviceOperatingSystem) {
      case DeviceOperatingSystem.android:
        return new AndroidDeviceDiscovery();
      case DeviceOperatingSystem.ios:
        return new IosDeviceDiscovery();
      default:
        throw new StateError('Unsupported device operating system: {config.deviceOperatingSystem}');
    }
  }
35

36 37 38 39 40 41
  /// Selects a device to work with, load-balancing between devices if more than
  /// one are available.
  ///
  /// Calling this method does not guarantee that the same device will be
  /// returned. For such behavior see [workingDevice].
  Future<Null> chooseWorkingDevice();
42

43 44 45 46 47 48
  /// A device to work with.
  ///
  /// Returns the same device when called repeatedly (unlike
  /// [chooseWorkingDevice]). This is useful when you need to perform multiple
  /// perations on one.
  Future<Device> get workingDevice;
49

50 51
  /// Lists all available devices' IDs.
  Future<List<String>> discoverDevices();
52

53 54
  /// Checks the health of the available devices.
  Future<Map<String, HealthCheckResult>> checkDevices();
55

56 57
  /// Prepares the system to run tasks.
  Future<Null> performPreflightTasks();
58 59
}

60 61 62 63
/// A proxy for one specific device.
abstract class Device {
  /// A unique device identifier.
  String get deviceId;
64

65 66
  /// Whether the device is awake.
  Future<bool> isAwake();
67

68 69
  /// Whether the device is asleep.
  Future<bool> isAsleep();
70

71 72
  /// Wake up the device if it is not awake.
  Future<Null> wakeUp();
73

74 75
  /// Send the device to sleep mode.
  Future<Null> sendToSleep();
76

77 78
  /// Emulates pressing the power button, toggling the device's on/off state.
  Future<Null> togglePower();
79

80 81 82 83
  /// Unlocks the device.
  ///
  /// Assumes the device doesn't have a secure unlock pattern.
  Future<Null> unlock();
84 85 86 87 88 89

  /// Read memory statistics for a process.
  Future<Map<String, dynamic>> getMemoryStats(String packageName);

  /// Stop a process.
  Future<Null> stop(String packageName);
90
}
91

92
class AndroidDeviceDiscovery implements DeviceDiscovery {
93 94 95 96 97
  // Parses information about a device. Example:
  //
  // 015d172c98400a03       device usb:340787200X product:nakasi model:Nexus_7 device:grouper
  static final RegExp _kDeviceRegex = new RegExp(r'^(\S+)\s+(\S+)(.*)');

98 99 100 101 102 103 104 105 106 107 108 109 110 111
  static AndroidDeviceDiscovery _instance;

  factory AndroidDeviceDiscovery() {
    return _instance ??= new AndroidDeviceDiscovery._();
  }

  AndroidDeviceDiscovery._();

  AndroidDevice _workingDevice;

  @override
  Future<AndroidDevice> get workingDevice async {
    if (_workingDevice == null) {
      await chooseWorkingDevice();
112
    }
113 114

    return _workingDevice;
115 116
  }

117 118 119 120
  /// Picks a random Android device out of connected devices and sets it as
  /// [workingDevice].
  @override
  Future<Null> chooseWorkingDevice() async {
121
    final List<Device> allDevices = (await discoverDevices())
122 123 124 125 126 127 128 129
      .map((String id) => new AndroidDevice(deviceId: id))
      .toList();

    if (allDevices.isEmpty)
      throw 'No Android devices detected';

    // TODO(yjbanov): filter out and warn about those with low battery level
    _workingDevice = allDevices[new math.Random().nextInt(allDevices.length)];
130 131
  }

132 133
  @override
  Future<List<String>> discoverDevices() async {
134
    final List<String> output = (await eval(adbPath, <String>['devices', '-l'], canFail: false))
135
        .trim().split('\n');
136
    final List<String> results = <String>[];
137 138
    for (String line in output) {
      // Skip lines like: * daemon started successfully *
139 140
      if (line.startsWith('* daemon '))
        continue;
141

142 143
      if (line.startsWith('List of devices'))
        continue;
144 145

      if (_kDeviceRegex.hasMatch(line)) {
146
        final Match match = _kDeviceRegex.firstMatch(line);
147

148 149
        final String deviceID = match[1];
        final String deviceState = match[2];
150 151 152 153 154 155 156 157 158 159 160 161

        if (!const <String>['unauthorized', 'offline'].contains(deviceState)) {
          results.add(deviceID);
        }
      } else {
        throw 'Failed to parse device from adb output: $line';
      }
    }

    return results;
  }

162 163
  @override
  Future<Map<String, HealthCheckResult>> checkDevices() async {
164
    final Map<String, HealthCheckResult> results = <String, HealthCheckResult>{};
165 166
    for (String deviceId in await discoverDevices()) {
      try {
167
        final AndroidDevice device = new AndroidDevice(deviceId: deviceId);
168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196
        // Just a smoke test that we can read wakefulness state
        // TODO(yjbanov): check battery level
        await device._getWakefulness();
        results['android-device-$deviceId'] = new HealthCheckResult.success();
      } catch(e, s) {
        results['android-device-$deviceId'] = new HealthCheckResult.error(e, s);
      }
    }
    return results;
  }

  @override
  Future<Null> performPreflightTasks() async {
    // Kills the `adb` server causing it to start a new instance upon next
    // command.
    //
    // Restarting `adb` helps with keeping device connections alive. When `adb`
    // runs non-stop for too long it loses connections to devices. There may be
    // a better method, but so far that's the best one I've found.
    await exec(adbPath, <String>['kill-server'], canFail: false);
  }
}

class AndroidDevice implements Device {
  AndroidDevice({@required this.deviceId});

  @override
  final String deviceId;

197
  /// Whether the device is awake.
198
  @override
199 200 201 202 203
  Future<bool> isAwake() async {
    return await _getWakefulness() == 'Awake';
  }

  /// Whether the device is asleep.
204
  @override
205 206 207 208 209
  Future<bool> isAsleep() async {
    return await _getWakefulness() == 'Asleep';
  }

  /// Wake up the device if it is not awake using [togglePower].
210
  @override
211
  Future<Null> wakeUp() async {
212 213
    if (!(await isAwake()))
      await togglePower();
214 215 216
  }

  /// Send the device to sleep mode if it is not asleep using [togglePower].
217
  @override
218
  Future<Null> sendToSleep() async {
219 220
    if (!(await isAsleep()))
      await togglePower();
221 222 223 224
  }

  /// Sends `KEYCODE_POWER` (26), which causes the device to toggle its mode
  /// between awake and asleep.
225
  @override
226 227 228 229 230 231 232
  Future<Null> togglePower() async {
    await shellExec('input', const <String>['keyevent', '26']);
  }

  /// Unlocks the device by sending `KEYCODE_MENU` (82).
  ///
  /// This only works when the device doesn't have a secure unlock pattern.
233
  @override
234 235 236 237 238 239 240 241 242
  Future<Null> unlock() async {
    await wakeUp();
    await shellExec('input', const <String>['keyevent', '82']);
  }

  /// Retrieves device's wakefulness state.
  ///
  /// See: https://android.googlesource.com/platform/frameworks/base/+/master/core/java/android/os/PowerManagerInternal.java
  Future<String> _getWakefulness() async {
243 244
    final String powerInfo = await shellEval('dumpsys', <String>['power']);
    final String wakefulness = grep('mWakefulness=', from: powerInfo).single.split('=')[1].trim();
245 246 247 248
    return wakefulness;
  }

  /// Executes [command] on `adb shell` and returns its exit code.
249 250
  Future<Null> shellExec(String command, List<String> arguments, { Map<String, String> environment }) async {
    await exec(adbPath, <String>['shell', command]..addAll(arguments), environment: environment, canFail: false);
251 252 253
  }

  /// Executes [command] on `adb shell` and returns its standard output as a [String].
254 255
  Future<String> shellEval(String command, List<String> arguments, { Map<String, String> environment }) {
    return eval(adbPath, <String>['shell', command]..addAll(arguments), environment: environment, canFail: false);
256
  }
257 258 259

  @override
  Future<Map<String, dynamic>> getMemoryStats(String packageName) async {
260 261
    final String meminfo = await shellEval('dumpsys', <String>['meminfo', packageName]);
    final Match match = new RegExp(r'TOTAL\s+(\d+)').firstMatch(meminfo);
262 263 264 265 266 267 268 269 270
    return <String, dynamic>{
      'total_kb': int.parse(match.group(1)),
    };
  }

  @override
  Future<Null> stop(String packageName) async {
    return shellExec('am', <String>['force-stop', packageName]);
  }
271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297
}

class IosDeviceDiscovery implements DeviceDiscovery {

  static IosDeviceDiscovery _instance;

  factory IosDeviceDiscovery() {
    return _instance ??= new IosDeviceDiscovery._();
  }

  IosDeviceDiscovery._();

  IosDevice _workingDevice;

  @override
  Future<IosDevice> get workingDevice async {
    if (_workingDevice == null) {
      await chooseWorkingDevice();
    }

    return _workingDevice;
  }

  /// Picks a random iOS device out of connected devices and sets it as
  /// [workingDevice].
  @override
  Future<Null> chooseWorkingDevice() async {
298
    final List<IosDevice> allDevices = (await discoverDevices())
299 300 301
      .map((String id) => new IosDevice(deviceId: id))
      .toList();

302
    if (allDevices.isEmpty)
303 304 305 306 307 308
      throw 'No iOS devices detected';

    // TODO(yjbanov): filter out and warn about those with low battery level
    _workingDevice = allDevices[new math.Random().nextInt(allDevices.length)];
  }

309 310 311 312 313 314 315 316
  // Physical device line format to be matched:
  // My iPhone (10.3.2) [75b90e947c5f429fa67f3e9169fda0d89f0492f1]
  //
  // Other formats in output (desktop, simulator) to be ignored:
  // my-mac-pro [2C10513E-4dA5-405C-8EF5-C44353DB3ADD]
  // iPhone 6s (9.3) [F6CEE7CF-81EB-4448-81B4-1755288C7C11] (Simulator)
  static final RegExp _deviceRegex = new RegExp(r'^.* +\(.*\) +\[(.*)\]$');

317 318
  @override
  Future<List<String>> discoverDevices() async {
319 320 321 322 323 324 325 326 327 328 329 330
    final List<String> iosDeviceIDs = <String>[];
    final Iterable<String> deviceLines = (await eval('instruments', <String>['-s', 'devices']))
        .split('\n')
        .map((String line) => line.trim());
    for (String line in deviceLines) {
      final Match match = _deviceRegex.firstMatch(line);
      if (match != null) {
        final String deviceID = match.group(1);
        iosDeviceIDs.add(deviceID);
      }
    }
    if (iosDeviceIDs.isEmpty)
331 332
      throw 'No connected iOS devices found.';

333
    return iosDeviceIDs;
334
  }
335 336 337

  @override
  Future<Map<String, HealthCheckResult>> checkDevices() async {
338
    final Map<String, HealthCheckResult> results = <String, HealthCheckResult>{};
339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381
    for (String deviceId in await discoverDevices()) {
      // TODO: do a more meaningful connectivity check than just recording the ID
      results['ios-device-$deviceId'] = new HealthCheckResult.success();
    }
    return results;
  }

  @override
  Future<Null> performPreflightTasks() async {
    // Currently we do not have preflight tasks for iOS.
    return null;
  }
}

/// iOS device.
class IosDevice implements Device {
  const IosDevice({ @required this.deviceId });

  @override
  final String deviceId;

  // The methods below are stubs for now. They will need to be expanded.
  // We currently do not have a way to lock/unlock iOS devices. So we assume the
  // devices are already unlocked. For now we'll just keep them at minimum
  // screen brightness so they don't drain battery too fast.

  @override
  Future<bool> isAwake() async => true;

  @override
  Future<bool> isAsleep() async => false;

  @override
  Future<Null> wakeUp() async {}

  @override
  Future<Null> sendToSleep() async {}

  @override
  Future<Null> togglePower() async {}

  @override
  Future<Null> unlock() async {}
382 383 384 385 386 387 388 389

  @override
  Future<Map<String, dynamic>> getMemoryStats(String packageName) async {
    throw 'Not implemented';
  }

  @override
  Future<Null> stop(String packageName) async {}
390 391 392 393
}

/// Path to the `adb` executable.
String get adbPath {
394
  final String androidHome = Platform.environment['ANDROID_HOME'];
395 396 397 398 399

  if (androidHome == null)
    throw 'ANDROID_HOME environment variable missing. This variable must '
        'point to the Android SDK directory containing platform-tools.';

400
  final String adbPath = path.join(androidHome, 'platform-tools/adb');
401

402 403
  if (!canRun(adbPath))
    throw 'adb not found at: $adbPath';
404

405
  return path.absolute(adbPath);
406
}