diff --git a/packages/flutter_tools/lib/src/android/android_sdk.dart b/packages/flutter_tools/lib/src/android/android_sdk.dart
new file mode 100644
index 0000000..0271f3a
--- /dev/null
+++ b/packages/flutter_tools/lib/src/android/android_sdk.dart
@@ -0,0 +1,214 @@
+// 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:io';
+
+import 'package:path/path.dart' as path;
+import 'package:pub_semver/pub_semver.dart';
+
+import '../base/globals.dart';
+import '../base/os.dart';
+
+// Android SDK layout:
+//
+// $ANDROID_HOME/platform-tools/adb
+// $ANDROID_HOME/build-tools/19.1.0/aapt, dx, zipalign
+// $ANDROID_HOME/build-tools/22.0.1/aapt
+// $ANDROID_HOME/build-tools/23.0.2/aapt
+// $ANDROID_HOME/platforms/android-22/android.jar
+// $ANDROID_HOME/platforms/android-23/android.jar
+
+// TODO(devoncarew): We need a way to locate the Android SDK w/o using an environment variable.
+// Perhaps something like `flutter config --android-home=foo/bar`.
+
+/// Locate ADB. Prefer to use one from an Android SDK, if we can locate that.
+String getAdbPath() {
+  AndroidSdk sdk = AndroidSdk.locateAndroidSdk();
+
+  if (sdk?.latestVersion == null) {
+    return os.which('adb')?.path;
+  } else {
+    return sdk.adbPath;
+  }
+}
+
+class AndroidSdk {
+  AndroidSdk(this.directory) {
+    _init();
+  }
+
+  final String directory;
+
+  List<AndroidSdkVersion> _sdkVersions;
+  AndroidSdkVersion _latestVersion;
+
+  static AndroidSdk locateAndroidSdk() {
+    // TODO: Use explicit configuration information from a metadata file?
+
+    if (Platform.environment.containsKey('ANDROID_HOME')) {
+      String homeDir = Platform.environment['ANDROID_HOME'];
+      if (validSdkDirectory(homeDir))
+        return new AndroidSdk(homeDir);
+      if (validSdkDirectory(path.join(homeDir, 'sdk')))
+        return new AndroidSdk(path.join(homeDir, 'sdk'));
+    }
+
+    File aaptBin = os.which('aapt'); // in build-tools/$version/aapt
+    if (aaptBin != null) {
+      String dir = aaptBin.parent.parent.parent.path;
+      if (validSdkDirectory(dir))
+        return new AndroidSdk(dir);
+    }
+
+    File adbBin = os.which('adb'); // in platform-tools/adb
+    if (adbBin != null) {
+      String dir = adbBin.parent.parent.path;
+      if (validSdkDirectory(dir))
+        return new AndroidSdk(dir);
+    }
+
+    // No dice.
+    printTrace('Unable to locate an Android SDK.');
+    return null;
+  }
+
+  static bool validSdkDirectory(String dir) {
+    return FileSystemEntity.isDirectorySync(path.join(dir, 'platform-tools'));
+  }
+
+  List<AndroidSdkVersion> get sdkVersions => _sdkVersions;
+
+  AndroidSdkVersion get latestVersion => _latestVersion;
+
+  String get adbPath => getPlatformToolsPath('adb');
+
+  bool validateSdkWellFormed({ bool complain: false }) {
+    if (!FileSystemEntity.isFileSync(adbPath)) {
+      if (complain)
+        printError('Android SDK file not found: $adbPath.');
+      return false;
+    }
+
+    if (sdkVersions.isEmpty) {
+      if (complain)
+        printError('Android SDK does not have the proper build-tools.');
+      return false;
+    }
+
+    return latestVersion.validateSdkWellFormed(complain: complain);
+  }
+
+  String getPlatformToolsPath(String binaryName) {
+    return path.join(directory, 'platform-tools', binaryName);
+  }
+
+  void _init() {
+    List<String> platforms = <String>[]; // android-22, ...
+
+    Directory platformsDir = new Directory(path.join(directory, 'platforms'));
+    if (platformsDir.existsSync()) {
+      platforms = platformsDir
+        .listSync()
+        .map((FileSystemEntity entity) => path.basename(entity.path))
+        .where((String name) => name.startsWith('android-'))
+        .toList();
+    }
+
+    List<Version> buildToolsVersions = <Version>[]; // 19.1.0, 22.0.1, ...
+
+    Directory buildToolsDir = new Directory(path.join(directory, 'build-tools'));
+    if (buildToolsDir.existsSync()) {
+      buildToolsVersions = buildToolsDir
+        .listSync()
+        .map((FileSystemEntity entity) {
+          try {
+            return new Version.parse(path.basename(entity.path));
+          } catch (error) {
+            return null;
+          }
+        })
+        .where((Version version) => version != null)
+        .toList();
+    }
+
+    // Here we match up platforms with cooresponding build-tools. If we don't
+    // have a match, we don't return anything for that platform version. So if
+    // the user only have 'android-22' and 'build-tools/19.0.0', we don't find
+    // an Android sdk.
+    _sdkVersions = platforms.map((String platform) {
+      int sdkVersion;
+
+      try {
+        sdkVersion = int.parse(platform.substring('android-'.length));
+      } catch (error) {
+        return null;
+      }
+
+      Version buildToolsVersion = Version.primary(buildToolsVersions.where((Version version) {
+        return version.major == sdkVersion;
+      }).toList());
+
+      if (buildToolsVersion == null)
+        return null;
+
+      return new AndroidSdkVersion(this, platform, buildToolsVersion.toString());
+    }).where((AndroidSdkVersion version) => version != null).toList();
+
+    _sdkVersions.sort();
+
+    _latestVersion = _sdkVersions.isEmpty ? null : _sdkVersions.last;
+  }
+
+  String toString() => 'AndroidSdk: $directory';
+}
+
+class AndroidSdkVersion implements Comparable<AndroidSdkVersion> {
+  AndroidSdkVersion(this.sdk, this.androidVersion, this.buildToolsVersion);
+
+  final AndroidSdk sdk;
+  final String androidVersion;
+  final String buildToolsVersion;
+
+  int get sdkLevel => int.parse(androidVersion.substring('android-'.length));
+
+  String get androidJarPath => getPlatformsPath('android.jar');
+
+  String get aaptPath => getBuildToolsPath('aapt');
+
+  String get dxPath => getBuildToolsPath('dx');
+
+  String get zipalignPath => getBuildToolsPath('zipalign');
+
+  bool validateSdkWellFormed({ bool complain: false }) {
+    return
+      _exists(androidJarPath, complain: complain) &&
+      _exists(aaptPath, complain: complain) &&
+      _exists(dxPath, complain: complain) &&
+      _exists(zipalignPath, complain: complain);
+  }
+
+  String getPlatformsPath(String itemName) {
+    return path.join(sdk.directory, 'platforms', androidVersion, itemName);
+  }
+
+  String getBuildToolsPath(String binaryName) {
+    return path.join(sdk.directory, 'build-tools', buildToolsVersion, binaryName);
+  }
+
+  int compareTo(AndroidSdkVersion other) {
+    return sdkLevel - other.sdkLevel;
+  }
+
+  String toString() => '[${sdk.directory}, SDK version $sdkLevel, build-tools $buildToolsVersion]';
+
+  bool _exists(String path, { bool complain: false }) {
+    if (!FileSystemEntity.isFileSync(path)) {
+      if (complain)
+        printError('Android SDK file not found: $path.');
+      return false;
+    }
+
+    return true;
+  }
+}
diff --git a/packages/flutter_tools/lib/src/android/device_android.dart b/packages/flutter_tools/lib/src/android/device_android.dart
index c55e0d4..0f7c4d0 100644
--- a/packages/flutter_tools/lib/src/android/device_android.dart
+++ b/packages/flutter_tools/lib/src/android/device_android.dart
@@ -50,18 +50,6 @@
   }) : super(id) {
     if (connected != null)
       _connected = connected;
-
-    _adbPath = getAdbPath();
-    _hasAdb = _checkForAdb();
-
-    // Checking for [minApiName] only needs to be done if we are starting an
-    // app, but it has an important side effect, which is to discard any
-    // progress messages if the adb server is restarted.
-    _hasValidAndroid = _checkForSupportedAndroidVersion();
-
-    if (!_hasAdb || !_hasValidAndroid) {
-      printError('Unable to run on Android.');
-    }
   }
 
   final String productID;
@@ -69,32 +57,9 @@
   final String deviceCodeName;
 
   bool _connected;
-  String _adbPath;
-  String get adbPath => _adbPath;
-  bool _hasAdb = false;
-  bool _hasValidAndroid = false;
-
-  static String getAndroidSdkPath() {
-    if (Platform.environment.containsKey('ANDROID_HOME')) {
-      String androidHomeDir = Platform.environment['ANDROID_HOME'];
-      if (FileSystemEntity.isDirectorySync(
-          path.join(androidHomeDir, 'platform-tools'))) {
-        return androidHomeDir;
-      } else if (FileSystemEntity.isDirectorySync(
-          path.join(androidHomeDir, 'sdk', 'platform-tools'))) {
-        return path.join(androidHomeDir, 'sdk');
-      } else {
-        printError('Android SDK not found at $androidHomeDir');
-        return null;
-      }
-    } else {
-      printError('Android SDK not found. The ANDROID_HOME variable must be set.');
-      return null;
-    }
-  }
 
   List<String> adbCommandForDevice(List<String> args) {
-    return <String>[adbPath, '-s', id]..addAll(args);
+    return <String>[androidSdk.adbPath, '-s', id]..addAll(args);
   }
 
   bool _isValidAdbVersion(String adbVersion) {
@@ -121,24 +86,19 @@
     return true;
   }
 
-  bool _checkForAdb() {
-    try {
-      String adbVersion = runCheckedSync(<String>[adbPath, 'version']);
-      if (_isValidAdbVersion(adbVersion)) {
-        return true;
-      }
+  bool _checkForSupportedAdbVersion() {
+    if (androidSdk == null)
+      return false;
 
-      String locatedAdbPath = runCheckedSync(<String>['which', 'adb']);
-      printError('"$locatedAdbPath" is too old. '
-          'Please install version 1.0.32 or later.\n'
-          'Try setting ANDROID_HOME to the path to your Android SDK install. '
-          'Android builds are unavailable.');
-    } catch (e) {
-      printError('"adb" not found in \$PATH. '
-          'Please install the Android SDK or set ANDROID_HOME '
-          'to the path of your Android SDK install.');
-      printTrace('$e');
+    try {
+      String adbVersion = runCheckedSync(<String>[androidSdk.adbPath, 'version']);
+      if (_isValidAdbVersion(adbVersion))
+        return true;
+      printError('The ADB at "${androidSdk.adbPath}" is too old; please install version 1.0.32 or later.');
+    } catch (error, trace) {
+      printError('Error running ADB: $error', trace);
     }
+
     return false;
   }
 
@@ -150,34 +110,29 @@
       //   * daemon started successfully *
       runCheckedSync(adbCommandForDevice(<String>['start-server']));
 
-      String ready = runSync(adbCommandForDevice(<String>['shell', 'echo', 'ready']));
-      if (ready.trim() != 'ready') {
-        printTrace('Android device not found.');
-        return false;
-      }
-
       // Sample output: '22'
       String sdkVersion = runCheckedSync(
         adbCommandForDevice(<String>['shell', 'getprop', 'ro.build.version.sdk'])
       ).trimRight();
 
-      int sdkVersionParsed =
-          int.parse(sdkVersion, onError: (String source) => null);
+      int sdkVersionParsed = int.parse(sdkVersion, onError: (String source) => null);
       if (sdkVersionParsed == null) {
         printError('Unexpected response from getprop: "$sdkVersion"');
         return false;
       }
+
       if (sdkVersionParsed < minApiLevel) {
         printError(
           'The Android version ($sdkVersion) on the target device is too old. Please '
           'use a $minVersionName (version $minApiLevel / $minVersionText) device or later.');
         return false;
       }
+
       return true;
     } catch (e) {
       printError('Unexpected failure from adb: $e');
+      return false;
     }
-    return false;
   }
 
   String _getDeviceSha1Path(ApplicationPackage app) {
@@ -220,11 +175,15 @@
       printTrace('Android device not connected. Not installing.');
       return false;
     }
+
     if (!FileSystemEntity.isFileSync(app.localPath)) {
       printError('"${app.localPath}" does not exist.');
       return false;
     }
 
+    if (!_checkForSupportedAdbVersion() || !_checkForSupportedAndroidVersion())
+      return false;
+
     printStatus('Installing ${app.name} on device.');
     runCheckedSync(adbCommandForDevice(<String>['install', '-r', app.localPath]));
     runCheckedSync(adbCommandForDevice(<String>['shell', 'echo', '-n', _getSourceSha1(app), '>', _getDeviceSha1Path(app)]));
@@ -306,6 +265,9 @@
     int debugPort: observatoryDefaultPort,
     Map<String, dynamic> platformArgs
   }) async {
+    if (!_checkForSupportedAdbVersion() || !_checkForSupportedAndroidVersion())
+      return false;
+
     flx.DirectoryResult buildResult = await flx.buildInTempDir(
       toolchain,
       mainPath: mainPath
@@ -420,7 +382,7 @@
     return null;
   }
 
-  bool isConnected() => _connected ?? _hasValidAndroid;
+  bool isConnected() => _connected ?? androidSdk != null;
 
   void setConnected(bool value) {
     _connected = value;
@@ -447,18 +409,12 @@
   }
 }
 
-/// The [mockAndroid] argument is only to facilitate testing with mocks, so that
-/// we don't have to rely on the test setup having adb available to it.
-List<AndroidDevice> getAdbDevices([AndroidDevice mockAndroid]) {
-  List<AndroidDevice> devices = [];
-  String adbPath = (mockAndroid != null) ? mockAndroid.adbPath : getAdbPath();
+List<AndroidDevice> getAdbDevices() {
+  if (androidSdk == null)
+    return <AndroidDevice>[];
 
-  try {
-    runCheckedSync(<String>[adbPath, 'version']);
-  } catch (e) {
-    printError('Unable to find adb. Is "adb" in your path?');
-    return devices;
-  }
+  String adbPath = androidSdk.adbPath;
+  List<AndroidDevice> devices = [];
 
   List<String> output = runSync(<String>[adbPath, 'devices', '-l']).trim().split('\n');
 
@@ -525,25 +481,6 @@
   return devices;
 }
 
-String getAdbPath() {
-  if (Platform.environment.containsKey('ANDROID_HOME')) {
-    String androidHomeDir = Platform.environment['ANDROID_HOME'];
-    String adbPath1 = path.join(androidHomeDir, 'sdk', 'platform-tools', 'adb');
-    String adbPath2 = path.join(androidHomeDir, 'platform-tools', 'adb');
-    if (FileSystemEntity.isFileSync(adbPath1)) {
-      return adbPath1;
-    } else if (FileSystemEntity.isFileSync(adbPath2)) {
-      return adbPath2;
-    } else {
-      printTrace('"adb" not found at\n  "$adbPath1" or\n  "$adbPath2"\n' +
-          'using default path "$_defaultAdbPath"');
-      return _defaultAdbPath;
-    }
-  } else {
-    return _defaultAdbPath;
-  }
-}
-
 /// A log reader that logs from `adb logcat`. This will have the same output as
 /// another copy of [_AdbLogReader], and the two instances will be equivalent.
 class _AdbLogReader extends DeviceLogReader {