diff --git a/bind/java/seq_test.go b/bind/java/seq_test.go
index 8f741c6..a5151d4 100644
--- a/bind/java/seq_test.go
+++ b/bind/java/seq_test.go
@@ -17,6 +17,7 @@
 	"testing"
 
 	"golang.org/x/mobile/internal/importers/java"
+	"golang.org/x/mobile/internal/sdkpath"
 )
 
 var gomobileBin string
@@ -98,8 +99,8 @@
 // runTest runs the Android java test class specified with javaCls. If javaPkg is
 // set, it is passed with the -javapkg flag to gomobile. The pkgNames lists the Go
 // packages to bind for the test.
-// This requires the gradle command in PATH and
-// the Android SDK whose path is available through ANDROID_HOME environment variable.
+// This requires the gradle command to be in PATH and the Android SDK to be
+// installed.
 func runTest(t *testing.T, pkgNames []string, javaPkg, javaCls string) {
 	if gomobileBin == "" {
 		t.Skipf("no gomobile on %s", runtime.GOOS)
@@ -108,8 +109,8 @@
 	if err != nil {
 		t.Skip("command gradle not found, skipping")
 	}
-	if sdk := os.Getenv("ANDROID_HOME"); sdk == "" {
-		t.Skip("ANDROID_HOME environment var not set, skipping")
+	if _, err := sdkpath.AndroidHome(); err != nil {
+		t.Skip("Android SDK not found, skipping")
 	}
 
 	cwd, err := os.Getwd()
diff --git a/cmd/gomobile/bind.go b/cmd/gomobile/bind.go
index efbc896..c4552e3 100644
--- a/cmd/gomobile/bind.go
+++ b/cmd/gomobile/bind.go
@@ -16,6 +16,7 @@
 	"path/filepath"
 	"strings"
 
+	"golang.org/x/mobile/internal/sdkpath"
 	"golang.org/x/mod/modfile"
 	"golang.org/x/tools/go/packages"
 )
@@ -42,9 +43,10 @@
 the module import wizard (File > New > New Module > Import .JAR or
 .AAR package), and setting it as a new dependency
 (File > Project Structure > Dependencies).  This requires 'javac'
-(version 1.7+) and Android SDK (API level 15 or newer) to build the
-library for Android. The environment variable ANDROID_HOME must be set
-to the path to Android SDK. Use the -javapkg flag to specify the Java
+(version 1.7+) and Android SDK (API level 16 or newer) to build the
+library for Android. The ANDROID_HOME and ANDROID_NDK_HOME environment
+variables can be used to specify the Android SDK and NDK if they are
+not in the default locations. Use the -javapkg flag to specify the Java
 package prefix for the generated classes.
 
 By default, -target=android builds shared libraries for all supported
@@ -85,7 +87,7 @@
 		if bindPrefix != "" {
 			return fmt.Errorf("-prefix is supported only for Apple targets")
 		}
-		if _, err := ndkRoot(); err != nil {
+		if _, err := ndkRoot(targets[0]); err != nil {
 			return err
 		}
 	} else {
@@ -156,7 +158,7 @@
 	if bindBootClasspath != "" {
 		return bindBootClasspath, nil
 	}
-	apiPath, err := androidAPIPath()
+	apiPath, err := sdkpath.AndroidAPIPath(buildAndroidAPI)
 	if err != nil {
 		return "", err
 	}
diff --git a/cmd/gomobile/bind_androidapp.go b/cmd/gomobile/bind_androidapp.go
index 7703868..a56fd82 100644
--- a/cmd/gomobile/bind_androidapp.go
+++ b/cmd/gomobile/bind_androidapp.go
@@ -12,15 +12,15 @@
 	"os"
 	"os/exec"
 	"path/filepath"
-	"strconv"
 	"strings"
 
+	"golang.org/x/mobile/internal/sdkpath"
 	"golang.org/x/tools/go/packages"
 )
 
 func goAndroidBind(gobind string, pkgs []*packages.Package, targets []targetInfo) error {
-	if sdkDir := os.Getenv("ANDROID_HOME"); sdkDir == "" {
-		return fmt.Errorf("this command requires ANDROID_HOME environment variable (path to the Android SDK)")
+	if _, err := sdkpath.AndroidHome(); err != nil {
+		return fmt.Errorf("this command requires the Android SDK to be installed: %w", err)
 	}
 
 	// Run gobind to generate the bindings
@@ -270,7 +270,7 @@
 
 const (
 	javacTargetVer = "1.7"
-	minAndroidAPI  = 15
+	minAndroidAPI  = 16
 )
 
 func buildJar(w io.Writer, srcDir string) error {
@@ -370,46 +370,3 @@
 	}
 	return jarw.Close()
 }
-
-// androidAPIPath returns an android SDK platform directory under ANDROID_HOME.
-// If there are multiple platforms that satisfy the minimum version requirement
-// androidAPIPath returns the latest one among them.
-func androidAPIPath() (string, error) {
-	sdk := os.Getenv("ANDROID_HOME")
-	if sdk == "" {
-		return "", fmt.Errorf("ANDROID_HOME environment var is not set")
-	}
-	sdkDir, err := os.Open(filepath.Join(sdk, "platforms"))
-	if err != nil {
-		return "", fmt.Errorf("failed to find android SDK platform: %v", err)
-	}
-	defer sdkDir.Close()
-	fis, err := sdkDir.Readdir(-1)
-	if err != nil {
-		return "", fmt.Errorf("failed to find android SDK platform (API level: %d): %v", buildAndroidAPI, err)
-	}
-
-	var apiPath string
-	var apiVer int
-	for _, fi := range fis {
-		name := fi.Name()
-		if !strings.HasPrefix(name, "android-") {
-			continue
-		}
-		n, err := strconv.Atoi(name[len("android-"):])
-		if err != nil || n < buildAndroidAPI {
-			continue
-		}
-		p := filepath.Join(sdkDir.Name(), name)
-		_, err = os.Stat(filepath.Join(p, "android.jar"))
-		if err == nil && apiVer < n {
-			apiPath = p
-			apiVer = n
-		}
-	}
-	if apiVer == 0 {
-		return "", fmt.Errorf("failed to find android SDK platform (API level: %d) in %s",
-			buildAndroidAPI, sdkDir.Name())
-	}
-	return apiPath, nil
-}
diff --git a/cmd/gomobile/bind_test.go b/cmd/gomobile/bind_test.go
index 0e9f401..cac3511 100644
--- a/cmd/gomobile/bind_test.go
+++ b/cmd/gomobile/bind_test.go
@@ -14,18 +14,22 @@
 	"strings"
 	"testing"
 	"text/template"
+
+	"golang.org/x/mobile/internal/sdkpath"
 )
 
 func TestBindAndroid(t *testing.T) {
-	androidHome := os.Getenv("ANDROID_HOME")
-	if androidHome == "" {
-		t.Skip("ANDROID_HOME not found, skipping bind")
-	}
-	platform, err := androidAPIPath()
+	platform, err := sdkpath.AndroidAPIPath(minAndroidAPI)
 	if err != nil {
-		t.Skip("No android API platform found in $ANDROID_HOME, skipping bind")
+		t.Skip("No compatible Android API platform found, skipping bind")
 	}
-	platform = strings.Replace(platform, androidHome, "$ANDROID_HOME", -1)
+	// platform is a path like "/path/to/Android/sdk/platforms/android-32"
+	components := strings.Split(platform, string(filepath.Separator))
+	if len(components) < 2 {
+		t.Fatalf("API path is too short: %s", platform)
+	}
+	components = components[len(components)-2:]
+	platformRel := filepath.Join("$ANDROID_HOME", components[0], components[1])
 
 	defer func() {
 		xout = os.Stderr
@@ -77,7 +81,7 @@
 			JavaPkg         string
 		}{
 			outputData:      output,
-			AndroidPlatform: platform,
+			AndroidPlatform: platformRel,
 			JavaPkg:         tc.javaPkg,
 		}
 
@@ -273,12 +277,8 @@
 		t.Run(target, func(t *testing.T) {
 			switch target {
 			case "android":
-				androidHome := os.Getenv("ANDROID_HOME")
-				if androidHome == "" {
-					t.Skip("ANDROID_HOME not found, skipping bind")
-				}
-				if _, err := androidAPIPath(); err != nil {
-					t.Skip("No android API platform found in $ANDROID_HOME, skipping bind")
+				if _, err := sdkpath.AndroidAPIPath(minAndroidAPI); err != nil {
+					t.Skip("No compatible Android API platform found, skipping bind")
 				}
 			case "ios":
 				if !xcodeAvailable() {
diff --git a/cmd/gomobile/build.go b/cmd/gomobile/build.go
index 4c83ca0..64a28fe 100644
--- a/cmd/gomobile/build.go
+++ b/cmd/gomobile/build.go
@@ -17,6 +17,7 @@
 	"strconv"
 	"strings"
 
+	"golang.org/x/mobile/internal/sdkpath"
 	"golang.org/x/tools/go/packages"
 )
 
@@ -60,7 +61,7 @@
 The default version is 13.0.
 
 Flag -androidapi sets the Android API version to compile against.
-The default and minimum is 15.
+The default and minimum is 16.
 
 The -bundleid flag is required for -target ios and sets the bundle ID to use
 with the app.
@@ -215,7 +216,7 @@
 	if tmpdir != "" {
 		cmd = strings.Replace(cmd, tmpdir, "$WORK", -1)
 	}
-	if androidHome := os.Getenv("ANDROID_HOME"); androidHome != "" {
+	if androidHome, err := sdkpath.AndroidHome(); err == nil {
 		cmd = strings.Replace(cmd, androidHome, "$ANDROID_HOME", -1)
 	}
 	if gomobilepath != "" {
diff --git a/cmd/gomobile/build_androidapp.go b/cmd/gomobile/build_androidapp.go
index b06ea29..bcd2664 100644
--- a/cmd/gomobile/build_androidapp.go
+++ b/cmd/gomobile/build_androidapp.go
@@ -25,7 +25,7 @@
 )
 
 func goAndroidBuild(pkg *packages.Package, targets []targetInfo) (map[string]bool, error) {
-	ndkRoot, err := ndkRoot()
+	ndkRoot, err := ndkRoot(targets...)
 	if err != nil {
 		return nil, err
 	}
diff --git a/cmd/gomobile/build_test.go b/cmd/gomobile/build_test.go
index ff21f87..448c6dd 100644
--- a/cmd/gomobile/build_test.go
+++ b/cmd/gomobile/build_test.go
@@ -14,6 +14,8 @@
 	"strings"
 	"testing"
 	"text/template"
+
+	"golang.org/x/mobile/internal/sdkpath"
 )
 
 func TestRFC1034Label(t *testing.T) {
@@ -228,12 +230,8 @@
 		t.Run(target, func(t *testing.T) {
 			switch target {
 			case "android":
-				androidHome := os.Getenv("ANDROID_HOME")
-				if androidHome == "" {
-					t.Skip("ANDROID_HOME not found, skipping bind")
-				}
-				if _, err := androidAPIPath(); err != nil {
-					t.Skip("No android API platform found in $ANDROID_HOME, skipping bind")
+				if _, err := sdkpath.AndroidAPIPath(minAndroidAPI); err != nil {
+					t.Skip("No compatible android API platform found, skipping bind")
 				}
 			case "ios":
 				if !xcodeAvailable() {
diff --git a/cmd/gomobile/env.go b/cmd/gomobile/env.go
index ff32517..43f24b9 100644
--- a/cmd/gomobile/env.go
+++ b/cmd/gomobile/env.go
@@ -1,6 +1,8 @@
 package main
 
 import (
+	"bufio"
+	"encoding/json"
 	"errors"
 	"fmt"
 	"io/fs"
@@ -10,6 +12,8 @@
 	"path/filepath"
 	"runtime"
 	"strings"
+
+	"golang.org/x/mobile/internal/sdkpath"
 )
 
 // General mobile build environment. Initialized by envInit.
@@ -276,29 +280,155 @@
 	return nil
 }
 
-func ndkRoot() (string, error) {
+// abi maps GOARCH values to Android ABI strings.
+// See https://developer.android.com/ndk/guides/abis
+func abi(goarch string) string {
+	switch goarch {
+	case "arm":
+		return "armeabi-v7a"
+	case "arm64":
+		return "arm64-v8a"
+	case "386":
+		return "x86"
+	case "amd64":
+		return "x86_64"
+	default:
+		return ""
+	}
+}
+
+// checkNDKRoot returns nil if the NDK in `ndkRoot` supports the current configured
+// API version and all the specified Android targets.
+func checkNDKRoot(ndkRoot string, targets []targetInfo) error {
+	platformsJson, err := os.Open(filepath.Join(ndkRoot, "meta", "platforms.json"))
+	if err != nil {
+		return err
+	}
+	defer platformsJson.Close()
+	decoder := json.NewDecoder(platformsJson)
+	supportedVersions := struct {
+		Min int
+		Max int
+	}{}
+	if err := decoder.Decode(&supportedVersions); err != nil {
+		return err
+	}
+	if supportedVersions.Min > buildAndroidAPI ||
+		supportedVersions.Max < buildAndroidAPI {
+		return fmt.Errorf("unsupported API version %d (not in %d..%d)", buildAndroidAPI, supportedVersions.Min, supportedVersions.Max)
+	}
+	abisJson, err := os.Open(filepath.Join(ndkRoot, "meta", "abis.json"))
+	if err != nil {
+		return err
+	}
+	defer abisJson.Close()
+	decoder = json.NewDecoder(abisJson)
+	abis := make(map[string]struct{})
+	if err := decoder.Decode(&abis); err != nil {
+		return err
+	}
+	for _, target := range targets {
+		if !isAndroidPlatform(target.platform) {
+			continue
+		}
+		if _, found := abis[abi(target.arch)]; !found {
+			return fmt.Errorf("ndk does not support %s", target.platform)
+		}
+	}
+	return nil
+}
+
+// compatibleNDKRoots searches the side-by-side NDK dirs for compatible SDKs.
+func compatibleNDKRoots(ndkForest string, targets []targetInfo) ([]string, error) {
+	ndkDirs, err := ioutil.ReadDir(ndkForest)
+	if err != nil {
+		return nil, err
+	}
+	compatibleNDKRoots := []string{}
+	var lastErr error
+	for _, dirent := range ndkDirs {
+		ndkRoot := filepath.Join(ndkForest, dirent.Name())
+		lastErr = checkNDKRoot(ndkRoot, targets)
+		if lastErr == nil {
+			compatibleNDKRoots = append(compatibleNDKRoots, ndkRoot)
+		}
+	}
+	if len(compatibleNDKRoots) > 0 {
+		return compatibleNDKRoots, nil
+	}
+	return nil, lastErr
+}
+
+// ndkVersion returns the full version number of an installed copy of the NDK,
+// or "" if it cannot be determined.
+func ndkVersion(ndkRoot string) string {
+	properties, err := os.Open(filepath.Join(ndkRoot, "source.properties"))
+	if err != nil {
+		return ""
+	}
+	defer properties.Close()
+	// Parse the version number out of the .properties file.
+	// See https://en.wikipedia.org/wiki/.properties
+	scanner := bufio.NewScanner(properties)
+	for scanner.Scan() {
+		line := scanner.Text()
+		tokens := strings.SplitN(line, "=", 2)
+		if len(tokens) != 2 {
+			continue
+		}
+		if strings.TrimSpace(tokens[0]) == "Pkg.Revision" {
+			return strings.TrimSpace(tokens[1])
+		}
+	}
+	return ""
+}
+
+// ndkRoot returns the root path of an installed NDK that supports all the
+// specified Android targets. For details of NDK locations, see
+// https://github.com/android/ndk-samples/wiki/Configure-NDK-Path
+func ndkRoot(targets ...targetInfo) (string, error) {
 	if buildN {
 		return "$NDK_PATH", nil
 	}
 
-	androidHome := os.Getenv("ANDROID_HOME")
-	if androidHome != "" {
-		ndkRoot := filepath.Join(androidHome, "ndk-bundle")
-		_, err := os.Stat(ndkRoot)
-		if err == nil {
-			return ndkRoot, nil
+	// Try the ANDROID_NDK_HOME variable.  This approach is deprecated, but it
+	// has the highest priority because it represents an explicit user choice.
+	if ndkRoot := os.Getenv("ANDROID_NDK_HOME"); ndkRoot != "" {
+		if err := checkNDKRoot(ndkRoot, targets); err != nil {
+			return "", fmt.Errorf("ANDROID_NDK_HOME specifies %s, which is unusable: %w", ndkRoot, err)
 		}
+		return ndkRoot, nil
 	}
 
-	ndkRoot := os.Getenv("ANDROID_NDK_HOME")
-	if ndkRoot != "" {
-		_, err := os.Stat(ndkRoot)
-		if err == nil {
-			return ndkRoot, nil
-		}
+	androidHome, err := sdkpath.AndroidHome()
+	if err != nil {
+		return "", fmt.Errorf("could not locate Android SDK: %w", err)
 	}
 
-	return "", fmt.Errorf("no Android NDK found in $ANDROID_HOME/ndk-bundle nor in $ANDROID_NDK_HOME")
+	// Use the newest compatible NDK under the side-by-side path arrangement.
+	ndkForest := filepath.Join(androidHome, "ndk")
+	ndkRoots, sideBySideErr := compatibleNDKRoots(ndkForest, targets)
+	if len(ndkRoots) != 0 {
+		// Choose the latest version that supports the build configuration.
+		// NDKs whose version cannot be determined will be least preferred.
+		// In the event of a tie, the later ndkRoot will win.
+		maxVersion := ""
+		var selected string
+		for _, ndkRoot := range ndkRoots {
+			version := ndkVersion(ndkRoot)
+			if version >= maxVersion {
+				maxVersion = version
+				selected = ndkRoot
+			}
+		}
+		return selected, nil
+	}
+	// Try the deprecated NDK location.
+	ndkRoot := filepath.Join(androidHome, "ndk-bundle")
+	if legacyErr := checkNDKRoot(ndkRoot, targets); legacyErr != nil {
+		return "", fmt.Errorf("no usable NDK in %s: %w, %v", androidHome, sideBySideErr, legacyErr)
+	}
+	return ndkRoot, nil
 }
 
 func envClang(sdkName string) (clang, cflags string, err error) {
diff --git a/cmd/gomobile/env_test.go b/cmd/gomobile/env_test.go
index 2eef8ab..e5ad282 100644
--- a/cmd/gomobile/env_test.go
+++ b/cmd/gomobile/env_test.go
@@ -5,6 +5,7 @@
 package main
 
 import (
+	"fmt"
 	"io/ioutil"
 	"os"
 	"path/filepath"
@@ -18,47 +19,143 @@
 	}
 
 	homeorig := os.Getenv("ANDROID_HOME")
+	os.Unsetenv("ANDROID_HOME")
 	ndkhomeorig := os.Getenv("ANDROID_NDK_HOME")
+	os.Unsetenv("ANDROID_NDK_HOME")
+
 	defer func() {
 		os.Setenv("ANDROID_HOME", homeorig)
 		os.Setenv("ANDROID_NDK_HOME", ndkhomeorig)
 		os.RemoveAll(home)
 	}()
 
-	os.Setenv("ANDROID_HOME", home)
-	sdkNDK := filepath.Join(home, "ndk-bundle")
-	envNDK := filepath.Join(home, "android-ndk")
-	os.Setenv("ANDROID_NDK_HOME", envNDK)
-
-	if ndk, err := ndkRoot(); err == nil {
-		t.Errorf("expected error but got %q", ndk)
-	}
-
-	for _, dir := range []string{sdkNDK, envNDK} {
+	makeMockNDK := func(path, version, platforms, abis string) string {
+		dir := filepath.Join(home, path)
 		if err := os.Mkdir(dir, 0755); err != nil {
 			t.Fatalf("couldn't mkdir %q", dir)
 		}
+		propertiesPath := filepath.Join(dir, "source.properties")
+		propertiesData := []byte("Pkg.Revision = " + version)
+		if err := os.WriteFile(propertiesPath, propertiesData, 0644); err != nil {
+			t.Fatalf("couldn't write source.properties: %v", err)
+		}
+		metaDir := filepath.Join(dir, "meta")
+		if err := os.Mkdir(metaDir, 0755); err != nil {
+			t.Fatalf("couldn't mkdir %q", metaDir)
+		}
+		platformsPath := filepath.Join(metaDir, "platforms.json")
+		platformsData := []byte(platforms)
+		if err := os.WriteFile(platformsPath, platformsData, 0644); err != nil {
+			t.Fatalf("couldn't write platforms.json: %v", err)
+		}
+		abisPath := filepath.Join(metaDir, "abis.json")
+		abisData := []byte(abis)
+		if err := os.WriteFile(abisPath, abisData, 0644); err != nil {
+			t.Fatalf("couldn't populate abis.json: %v", err)
+		}
+		return dir
 	}
 
-	if ndk, _ := ndkRoot(); ndk != sdkNDK {
-		t.Errorf("got %q want %q", ndk, sdkNDK)
-	}
+	t.Run("no NDK in the default location", func(t *testing.T) {
+		os.Setenv("ANDROID_HOME", home)
+		defer os.Unsetenv("ANDROID_HOME")
+		if ndk, err := ndkRoot(); err == nil {
+			t.Errorf("expected error but got %q", ndk)
+		}
+	})
 
-	os.Unsetenv("ANDROID_HOME")
+	t.Run("NDK location is set but is wrong", func(t *testing.T) {
+		os.Setenv("ANDROID_NDK_HOME", filepath.Join(home, "no-such-path"))
+		defer os.Unsetenv("ANDROID_NDK_HOME")
+		if ndk, err := ndkRoot(); err == nil {
+			t.Errorf("expected error but got %q", ndk)
+		}
+	})
 
-	if ndk, _ := ndkRoot(); ndk != envNDK {
-		t.Errorf("got %q want %q", ndk, envNDK)
-	}
+	t.Run("Two NDKs installed", func(t *testing.T) {
+		// Default path for pre-side-by-side NDKs.
+		sdkNDK := makeMockNDK("ndk-bundle", "fake-version", `{"min":16,"max":32}`, "{}")
+		defer os.RemoveAll(sdkNDK)
+		// Arbitrary location for testing ANDROID_NDK_HOME.
+		envNDK := makeMockNDK("custom-location", "fake-version", `{"min":16,"max":32}`, "{}")
 
-	os.RemoveAll(envNDK)
+		// ANDROID_NDK_HOME is sufficient.
+		os.Setenv("ANDROID_NDK_HOME", envNDK)
+		if ndk, err := ndkRoot(); ndk != envNDK {
+			t.Errorf("got (%q, %v) want (%q, nil)", ndk, err, envNDK)
+		}
 
-	if ndk, err := ndkRoot(); err == nil {
-		t.Errorf("expected error but got %q", ndk)
-	}
+		// ANDROID_NDK_HOME takes precedence over ANDROID_HOME.
+		os.Setenv("ANDROID_HOME", home)
+		if ndk, err := ndkRoot(); ndk != envNDK {
+			t.Errorf("got (%q, %v) want (%q, nil)", ndk, err, envNDK)
+		}
 
-	os.Setenv("ANDROID_HOME", home)
+		// ANDROID_NDK_HOME is respected even if there is no NDK there.
+		os.RemoveAll(envNDK)
+		if ndk, err := ndkRoot(); err == nil {
+			t.Errorf("expected error but got %q", ndk)
+		}
 
-	if ndk, _ := ndkRoot(); ndk != sdkNDK {
-		t.Errorf("got %q want %q", ndk, sdkNDK)
-	}
+		// ANDROID_HOME is used if ANDROID_NDK_HOME is not set.
+		os.Unsetenv("ANDROID_NDK_HOME")
+		if ndk, err := ndkRoot(); ndk != sdkNDK {
+			t.Errorf("got (%q, %v) want (%q, nil)", ndk, err, envNDK)
+		}
+	})
+
+	t.Run("Modern 'side-by-side' NDK selection", func(t *testing.T) {
+		defer func() {
+			buildAndroidAPI = minAndroidAPI
+		}()
+
+		ndkForest := filepath.Join(home, "ndk")
+		if err := os.Mkdir(ndkForest, 0755); err != nil {
+			t.Fatalf("couldn't mkdir %q", ndkForest)
+		}
+
+		path := filepath.Join("ndk", "newer")
+		platforms := `{"min":19,"max":32}`
+		abis := `{"arm64-v8a": {}, "armeabi-v7a": {}, "x86_64": {}}`
+		version := "17.2.0"
+		newerNDK := makeMockNDK(path, version, platforms, abis)
+
+		path = filepath.Join("ndk", "older")
+		platforms = `{"min":16,"max":31}`
+		abis = `{"arm64-v8a": {}, "armeabi-v7a": {}, "x86": {}}`
+		version = "17.1.0"
+		olderNDK := makeMockNDK(path, version, platforms, abis)
+
+		testCases := []struct {
+			api         int
+			targets     []targetInfo
+			wantNDKRoot string
+		}{
+			{15, nil, ""},
+			{16, nil, olderNDK},
+			{16, []targetInfo{{"android", "arm"}}, olderNDK},
+			{16, []targetInfo{{"android", "arm"}, {"android", "arm64"}}, olderNDK},
+			{16, []targetInfo{{"android", "x86_64"}}, ""},
+			{19, nil, newerNDK},
+			{19, []targetInfo{{"android", "arm"}}, newerNDK},
+			{19, []targetInfo{{"android", "arm"}, {"android", "arm64"}, {"android", "386"}}, olderNDK},
+			{32, nil, newerNDK},
+			{32, []targetInfo{{"android", "arm"}}, newerNDK},
+			{32, []targetInfo{{"android", "386"}}, ""},
+		}
+
+		for i, tc := range testCases {
+			t.Run(fmt.Sprintf("%d", i), func(t *testing.T) {
+				buildAndroidAPI = tc.api
+				ndk, err := ndkRoot(tc.targets...)
+				if len(tc.wantNDKRoot) != 0 {
+					if ndk != tc.wantNDKRoot || err != nil {
+						t.Errorf("got (%q, %v), want (%q, nil)", ndk, err, tc.wantNDKRoot)
+					}
+				} else if err == nil {
+					t.Error("expected error")
+				}
+			})
+		}
+	})
 }
diff --git a/cmd/gomobile/gendex.go b/cmd/gomobile/gendex.go
index be7470c..88cf554 100644
--- a/cmd/gomobile/gendex.go
+++ b/cmd/gomobile/gendex.go
@@ -13,7 +13,7 @@
 // however that would limit gomobile to working with newer versions of
 // the Android OS, so we do this while we wait.
 //
-// Requires ANDROID_HOME be set to the path of the Android SDK, and
+// Respects ANDROID_HOME to set the path of the Android SDK.
 // javac must be on the PATH.
 package main
 
@@ -29,6 +29,8 @@
 	"os"
 	"os/exec"
 	"path/filepath"
+
+	"golang.org/x/mobile/internal/sdkpath"
 )
 
 var outfile = flag.String("o", "", "result will be written file")
@@ -52,9 +54,9 @@
 }
 
 func gendex() error {
-	androidHome := os.Getenv("ANDROID_HOME")
-	if androidHome == "" {
-		return errors.New("ANDROID_HOME not set")
+	androidHome, err := sdkpath.AndroidHome()
+	if err != nil {
+		return fmt.Errorf("couldn't find Android SDK: %w", err)
 	}
 	if err := os.MkdirAll(tmpdir+"/work/org/golang/app", 0775); err != nil {
 		return err
diff --git a/cmd/gomobile/init.go b/cmd/gomobile/init.go
index 26da302..e7392df 100644
--- a/cmd/gomobile/init.go
+++ b/cmd/gomobile/init.go
@@ -16,6 +16,8 @@
 	"runtime"
 	"strings"
 	"time"
+
+	"golang.org/x/mobile/internal/sdkpath"
 )
 
 var (
@@ -122,11 +124,10 @@
 	if buildN {
 		cmake = "cmake"
 	} else {
-		sdkRoot := os.Getenv("ANDROID_HOME")
-		if sdkRoot == "" {
+		sdkRoot, err := sdkpath.AndroidHome()
+		if err != nil {
 			return nil
 		}
-		var err error
 		cmake, err = exec.LookPath("cmake")
 		if err != nil {
 			cmakePath := filepath.Join(sdkRoot, "cmake")
diff --git a/cmd/gomobile/version.go b/cmd/gomobile/version.go
index b791556..27fd6bd 100644
--- a/cmd/gomobile/version.go
+++ b/cmd/gomobile/version.go
@@ -11,6 +11,8 @@
 	"os/exec"
 	"path/filepath"
 	"strings"
+
+	"golang.org/x/mobile/internal/sdkpath"
 )
 
 var cmdVersion = &command{
@@ -56,8 +58,7 @@
 		platforms += "," + strings.Join(applePlatforms, ",")
 	}
 
-	// ANDROID_HOME, sdk build tool version
-	androidapi, _ := androidAPIPath()
+	androidapi, _ := sdkpath.AndroidAPIPath(buildAndroidAPI)
 
 	fmt.Printf("gomobile version %s (%s); androidSDK=%s\n", version, platforms, androidapi)
 	return nil
diff --git a/example/ivy/android/README.md b/example/ivy/android/README.md
index d5923ea..dc56712 100644
--- a/example/ivy/android/README.md
+++ b/example/ivy/android/README.md
@@ -11,16 +11,12 @@
   - Android NDK
   - `golang.org/x/mobile/cmd/gomobile`
 
-The `gomobile` command uses `ANDROID_HOME` and `ANDROID_NDK_HOME` environment variables.
+The `gomobile` command respects the `ANDROID_HOME` and `ANDROID_NDK_HOME` environment variables.  If `gomobile` can't find your SDK and NDK, you can set these environment variables to specify their locations:
 ```
 export ANDROID_HOME=/path/to/sdk-directory
 export ANDROID_NDK_HOME=/path/to/ndk-directory
 ```
 
-Note: Both ANDROID_SDK_ROOT and ANDROID_NDK_HOME are deprecated in Android tooling, but `gomobile` still uses it. In many cases, `ANDROID_HOME` corresponds to the new [`ANDROID_SDK_ROOT`](https://developer.android.com/studio/command-line/variables). If you installed NDK using [Android Studio's SDK manager](https://developer.android.com/studio/projects/install-ndk#default-version), use the `$ANDROID_SDK_ROOT/ndk/<ndk-version>/` directory as `ANDROID_NDK_HOME` (where `<ndk-version>` is the NDK version you want to use when compiling `robpike.io/ivy` for Android.
-
-(TODO: update `gomobile` to work with modern Android layout)
-
 From this directory, run:
 
 ```sh
diff --git a/internal/binres/binres.go b/internal/binres/binres.go
index 78b874f..d77bde2 100644
--- a/internal/binres/binres.go
+++ b/internal/binres/binres.go
@@ -82,10 +82,13 @@
 
 	ResXMLResourceMap ResType = 0x0180
 
-	ResTablePackage  ResType = 0x0200
-	ResTableType     ResType = 0x0201
-	ResTableTypeSpec ResType = 0x0202
-	ResTableLibrary  ResType = 0x0203
+	ResTablePackage           ResType = 0x0200
+	ResTableType              ResType = 0x0201
+	ResTableTypeSpec          ResType = 0x0202
+	ResTableLibrary           ResType = 0x0203
+	ResTableOverlayable       ResType = 0x0204
+	ResTableOverlayablePolicy ResType = 0x0205
+	ResTableStagedAlias       ResType = 0x0206
 )
 
 var (
@@ -247,14 +250,14 @@
 							Space: "",
 							Local: "platformBuildVersionCode",
 						},
-						Value: "15",
+						Value: "16",
 					},
 					xml.Attr{
 						Name: xml.Name{
 							Space: "",
 							Local: "platformBuildVersionName",
 						},
-						Value: "4.0.4-1406430",
+						Value: "4.1.2-1425332",
 					})
 
 				q = append(q, ltoken{tkn, line})
diff --git a/internal/binres/binres_test.go b/internal/binres/binres_test.go
index 93e7a18..dbac875 100644
--- a/internal/binres/binres_test.go
+++ b/internal/binres/binres_test.go
@@ -16,6 +16,8 @@
 	"sort"
 	"strings"
 	"testing"
+
+	"golang.org/x/mobile/internal/sdkpath"
 )
 
 func init() {
@@ -408,10 +410,9 @@
 			}
 		}
 		if err == nil && v == "__" {
-			if !strings.HasPrefix(x, "4.0.") {
+			if !strings.HasPrefix(x, "4.1.") {
 				// as of the time of this writing, the current version of build tools being targeted
-				// reports 4.0.4-1406430. Previously, this was 4.0.3. This number is likely still due
-				// to change so only report error if 4.x incremented.
+				// reports 4.1.2-1425332.
 				//
 				// TODO this check has the potential to hide real errors but can be fixed once more
 				// of the xml document is unmarshalled and XML can be queried to assure this is related
@@ -455,9 +456,8 @@
 }
 
 func TestOpenTable(t *testing.T) {
-	sdkdir := os.Getenv("ANDROID_HOME")
-	if sdkdir == "" {
-		t.Skip("ANDROID_HOME env var not set")
+	if _, err := sdkpath.AndroidHome(); err != nil {
+		t.Skipf("Could not locate Android SDK: %v", err)
 	}
 	tbl, err := OpenTable()
 	if err != nil {
@@ -577,8 +577,10 @@
 			if typ.entryCount != xtyp.entryCount {
 				t.Fatal("typ.entryCount doesn't match")
 			}
-			if typ.entriesStart != xtyp.entriesStart {
-				t.Fatal("typ.entriesStart doesn't match")
+			// Config size can differ after serialization due to the loss of extended fields
+			// during reserialization, but the fixed portions of the Type header must not change.
+			if uint32(typ.headerByteSize)-typ.config.size != uint32(xtyp.headerByteSize)-uint32(xtyp.config.size) {
+				t.Fatal("fixed size header portions don't match")
 			}
 			if len(typ.indices) != len(xtyp.indices) {
 				t.Fatal("typ.indices length don't match")
@@ -629,9 +631,8 @@
 
 func checkResources(t *testing.T) {
 	t.Helper()
-	sdkdir := os.Getenv("ANDROID_HOME")
-	if sdkdir == "" {
-		t.Skip("ANDROID_HOME env var not set")
+	if _, err := sdkpath.AndroidHome(); err != nil {
+		t.Skip("Could not locate Android SDK")
 	}
 	rscPath, err := apiResourcesPath()
 	if err != nil {
@@ -643,9 +644,8 @@
 }
 
 func BenchmarkTableRefByName(b *testing.B) {
-	sdkdir := os.Getenv("ANDROID_HOME")
-	if sdkdir == "" {
-		b.Fatal("ANDROID_HOME env var not set")
+	if _, err := sdkpath.AndroidHome(); err != nil {
+		b.Fatal("Could not locate Android SDK")
 	}
 
 	b.ReportAllocs()
diff --git a/internal/binres/genarsc.go b/internal/binres/genarsc.go
index e93ae88..4ec35fb 100644
--- a/internal/binres/genarsc.go
+++ b/internal/binres/genarsc.go
@@ -8,8 +8,7 @@
 // Genarsc generates stripped down version of android.jar resources used
 // for validation of manifest entries.
 //
-// Requires ANDROID_HOME be set to the path of the Android SDK and the
-// current sdk platform installed that matches MinSDK.
+// Requires the selected Android SDK to support the MinSDK platform version.
 package main
 
 import (
diff --git a/internal/binres/sdk.go b/internal/binres/sdk.go
index 6c1c343..607e0b7 100644
--- a/internal/binres/sdk.go
+++ b/internal/binres/sdk.go
@@ -7,13 +7,14 @@
 	"fmt"
 	"io"
 	"os"
-	"path"
+	"path/filepath"
+
+	"golang.org/x/mobile/internal/sdkpath"
 )
 
 // MinSDK is the targeted sdk version for support by package binres.
-const MinSDK = 15
+const MinSDK = 16
 
-// Requires environment variable ANDROID_HOME to be set.
 func apiResources() ([]byte, error) {
 	apiResPath, err := apiResourcesPath()
 	if err != nil {
@@ -50,14 +51,11 @@
 }
 
 func apiResourcesPath() (string, error) {
-	// TODO(elias.naur): use the logic from gomobile's androidAPIPath and use the any installed version of the
-	// Android SDK instead. Currently, the binres_test.go tests fail on anything newer than android-15.
-	sdkdir := os.Getenv("ANDROID_HOME")
-	if sdkdir == "" {
-		return "", fmt.Errorf("ANDROID_HOME env var not set")
+	platformDir, err := sdkpath.AndroidAPIPath(MinSDK)
+	if err != nil {
+		return "", err
 	}
-	platform := fmt.Sprintf("android-%v", MinSDK)
-	return path.Join(sdkdir, "platforms", platform, "android.jar"), nil
+	return filepath.Join(platformDir, "android.jar"), nil
 }
 
 // PackResources produces a stripped down gzip version of the resources.arsc from api jar.
diff --git a/internal/binres/table.go b/internal/binres/table.go
index 304736d..b552cba 100644
--- a/internal/binres/table.go
+++ b/internal/binres/table.go
@@ -248,7 +248,8 @@
 	typePool *Pool // type names; e.g. theme
 	keyPool  *Pool // resource names; e.g. Theme.NoTitleBar
 
-	specs []*TypeSpec
+	aliases []*StagedAlias
+	specs   []*TypeSpec
 }
 
 func (pkg *Package) UnmarshalBinary(bin []byte) error {
@@ -298,7 +299,7 @@
 		return nil
 	}
 
-	buf := bin[idOffset:]
+	buf := bin[idOffset:pkg.byteSize]
 	for len(buf) > 0 {
 		t := ResType(btou16(buf))
 		switch t {
@@ -317,8 +318,15 @@
 			last := pkg.specs[len(pkg.specs)-1]
 			last.types = append(last.types, typ)
 			buf = buf[typ.byteSize:]
+		case ResTableStagedAlias:
+			alias := new(StagedAlias)
+			if err := alias.UnmarshalBinary(buf); err != nil {
+				return err
+			}
+			pkg.aliases = append(pkg.aliases, alias)
+			buf = buf[alias.byteSize:]
 		default:
-			return errWrongType(t, ResTableTypeSpec, ResTableType)
+			return errWrongType(t, ResTableTypeSpec, ResTableType, ResTableStagedAlias)
 		}
 	}
 
@@ -371,6 +379,14 @@
 		bin = append(bin, b...)
 	}
 
+	for _, alias := range pkg.aliases {
+		b, err := alias.MarshalBinary()
+		if err != nil {
+			return nil, err
+		}
+		bin = append(bin, b...)
+	}
+
 	for _, spec := range pkg.specs {
 		b, err := spec.MarshalBinary()
 		if err != nil {
@@ -537,14 +553,15 @@
 	// fmt.Println("language/country:", u16tos(typ.config.locale.language), u16tos(typ.config.locale.country))
 
 	buf := bin[typ.headerByteSize:typ.entriesStart]
-	for len(buf) > 0 {
-		typ.indices = append(typ.indices, btou32(buf))
-		buf = buf[4:]
+	if len(buf) != 4*int(typ.entryCount) {
+		return fmt.Errorf("index buffer len[%v] doesn't match entryCount[%v]", len(buf), typ.entryCount)
 	}
 
-	if len(typ.indices) != int(typ.entryCount) {
-		return fmt.Errorf("indices len[%v] doesn't match entryCount[%v]", len(typ.indices), typ.entryCount)
+	typ.indices = make([]uint32, typ.entryCount)
+	for i := range typ.indices {
+		typ.indices[i] = btou32(buf[i*4:])
 	}
+
 	typ.entries = make([]*Entry, typ.entryCount)
 
 	for i, x := range typ.indices {
@@ -572,9 +589,9 @@
 	putu32(bin[12:], uint32(len(typ.entries)))
 	putu32(bin[16:], uint32(56+len(typ.entries)*4))
 
-	// assure typ.config.size is always written as 52; extended configuration beyond supported
+	// assure typ.config.size is always written as 36; extended configuration beyond supported
 	// API level is not supported by this marshal implementation but will be forward-compatible.
-	putu32(bin[20:], 52)
+	putu32(bin[20:], 36)
 
 	putu16(bin[24:], typ.config.imsi.mcc)
 	putu16(bin[26:], typ.config.imsi.mnc)
@@ -616,6 +633,65 @@
 	return bin, nil
 }
 
+type StagedAliasEntry struct {
+	stagedID    uint32
+	finalizedID uint32
+}
+
+func (ae *StagedAliasEntry) MarshalBinary() ([]byte, error) {
+	bin := make([]byte, 8)
+	putu32(bin, ae.stagedID)
+	putu32(bin[4:], ae.finalizedID)
+	return bin, nil
+}
+
+func (ae *StagedAliasEntry) UnmarshalBinary(bin []byte) error {
+	ae.stagedID = btou32(bin)
+	ae.finalizedID = btou32(bin[4:])
+	return nil
+}
+
+type StagedAlias struct {
+	chunkHeader
+	count   uint32
+	entries []StagedAliasEntry
+}
+
+func (a *StagedAlias) UnmarshalBinary(bin []byte) error {
+	if err := (&a.chunkHeader).UnmarshalBinary(bin); err != nil {
+		return err
+	}
+	if a.typ != ResTableStagedAlias {
+		return errWrongType(a.typ, ResTableStagedAlias)
+	}
+	a.count = btou32(bin[8:])
+	a.entries = make([]StagedAliasEntry, a.count)
+	for i := range a.entries {
+		if err := a.entries[i].UnmarshalBinary(bin[12+i*8:]); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (a *StagedAlias) MarshalBinary() ([]byte, error) {
+	chunkHeaderBin, err := a.chunkHeader.MarshalBinary()
+	if err != nil {
+		return nil, err
+	}
+	countBin := make([]byte, 4)
+	putu32(countBin, a.count)
+	bin := append(chunkHeaderBin, countBin...)
+	for _, entry := range a.entries {
+		entryBin, err := entry.MarshalBinary()
+		if err != nil {
+			return nil, err
+		}
+		bin = append(bin, entryBin...)
+	}
+	return bin, nil
+}
+
 // Entry is a resource key typically followed by a value or resource map.
 type Entry struct {
 	size  uint16
diff --git a/internal/binres/testdata/bootstrap.arsc b/internal/binres/testdata/bootstrap.arsc
index 60c1dda..4705191 100644
--- a/internal/binres/testdata/bootstrap.arsc
+++ b/internal/binres/testdata/bootstrap.arsc
Binary files differ
diff --git a/internal/binres/testdata/bootstrap.bin b/internal/binres/testdata/bootstrap.bin
index 35d3df6..ff5617c 100644
--- a/internal/binres/testdata/bootstrap.bin
+++ b/internal/binres/testdata/bootstrap.bin
Binary files differ
diff --git a/internal/binres/testdata/gen.sh b/internal/binres/testdata/gen.sh
index e37f21b..b19318f 100755
--- a/internal/binres/testdata/gen.sh
+++ b/internal/binres/testdata/gen.sh
@@ -1,10 +1,10 @@
 #! /usr/bin/env bash
 
 # version of build-tools tests run against
-AAPT=${ANDROID_HOME}/build-tools/23.0.1/aapt
+AAPT=${ANDROID_HOME:-${HOME}/Android/Sdk}/build-tools/32.0.0/aapt
 
 # minimum version of android api for resource identifiers supported
-APIJAR=${ANDROID_HOME}/platforms/android-15/android.jar
+APIJAR=${ANDROID_HOME:-${HOME}/Android/Sdk}/platforms/android-16/android.jar
 
 for f in *.xml; do
 	RES=""
diff --git a/internal/sdkpath/sdkpath.go b/internal/sdkpath/sdkpath.go
new file mode 100644
index 0000000..91e9a51
--- /dev/null
+++ b/internal/sdkpath/sdkpath.go
@@ -0,0 +1,89 @@
+// Copyright 2022 The Go Authors.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package sdkpath provides functions for locating the Android SDK.
+// These functions respect the ANDROID_HOME environment variable, and
+// otherwise use the default SDK location.
+package sdkpath
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strconv"
+	"strings"
+)
+
+// AndroidHome returns the absolute path of the selected Android SDK,
+// if one can be found.
+func AndroidHome() (string, error) {
+	androidHome := os.Getenv("ANDROID_HOME")
+	if androidHome == "" {
+		home, err := os.UserHomeDir()
+		if err != nil {
+			return "", err
+		}
+		switch runtime.GOOS {
+		case "windows":
+			// See https://android.googlesource.com/platform/tools/adt/idea/+/85b4bfb7a10ad858a30ffa4003085b54f9424087/native/installer/win/setup_android_studio.nsi#100
+			androidHome = filepath.Join(home, "AppData", "Local", "Android", "sdk")
+		case "darwin":
+			// See https://android.googlesource.com/platform/tools/asuite/+/67e0cd9604379e9663df57f16a318d76423c0aa8/aidegen/lib/ide_util.py#88
+			androidHome = filepath.Join(home, "Library", "Android", "sdk")
+		default: // Linux, BSDs, etc.
+			// See LINUX_ANDROID_SDK_PATH in ide_util.py above.
+			androidHome = filepath.Join(home, "Android", "Sdk")
+		}
+	}
+	if info, err := os.Stat(androidHome); err != nil {
+		return "", fmt.Errorf("%w; Android SDK was not found at %s", err, androidHome)
+	} else if !info.IsDir() {
+		return "", fmt.Errorf("%s is not a directory", androidHome)
+	}
+	return androidHome, nil
+}
+
+// AndroidAPIPath returns an android SDK platform directory within the configured SDK.
+// If there are multiple platforms that satisfy the minimum version requirement,
+// AndroidAPIPath returns the latest one among them.
+func AndroidAPIPath(api int) (string, error) {
+	sdk, err := AndroidHome()
+	if err != nil {
+		return "", err
+	}
+	sdkDir, err := os.Open(filepath.Join(sdk, "platforms"))
+	if err != nil {
+		return "", fmt.Errorf("failed to find android SDK platform: %w", err)
+	}
+	defer sdkDir.Close()
+	fis, err := sdkDir.Readdir(-1)
+	if err != nil {
+		return "", fmt.Errorf("failed to find android SDK platform (API level: %d): %w", api, err)
+	}
+
+	var apiPath string
+	var apiVer int
+	for _, fi := range fis {
+		name := fi.Name()
+		if !strings.HasPrefix(name, "android-") {
+			continue
+		}
+		n, err := strconv.Atoi(name[len("android-"):])
+		if err != nil || n < api {
+			continue
+		}
+		p := filepath.Join(sdkDir.Name(), name)
+		_, err = os.Stat(filepath.Join(p, "android.jar"))
+		if err == nil && apiVer < n {
+			apiPath = p
+			apiVer = n
+		}
+	}
+	if apiVer == 0 {
+		return "", fmt.Errorf("failed to find android SDK platform (API level: %d) in %s",
+			api, sdkDir.Name())
+	}
+	return apiPath, nil
+}