Add support for building Go for Android.

go/mobile_env.py

+#!/usr/bin/env python
+# Copyright 2014 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.
+
+"""Like env.py, but for building go-on-mobile.
+
+It wraps env.py, runs `gomobile init`, and adds mobile-specific env vars.
+"""
+
+assert __name__ == '__main__'
+
+import os
+import pipes
+import platform
+import subprocess
+import sys
+
+
+ANDROID_NDK_PATH = os.path.join(
+    os.path.abspath(os.path.dirname(__file__)), '.vendor', 'pkg', 'gomobile',
+    'android-ndk-r12b')
+
+# Used for mapping GOARCH values to NDK toolsets.
+ANDROID_TOOLSETS = {
+  'arm': 'arm',
+  'arm64': 'aarch64',
+  '386': 'x86',
+  'amd64': 'x86_64',
+}
+
+
+def _get_android_env(env):
+  """Adds GO* and C* environment variables needed for building for android."""
+  if platform.system() != 'Linux':
+    raise Exception(
+        'Only Linux hosts supported for android cross-compiling')
+
+  arch = env.get('GOARCH')
+  if arch not in ANDROID_TOOLSETS:
+    raise Exception(
+        'Specified arch not currently supported on android: %s' % arch)

[iannucci, 2016/08/11 01:20:48]

I'm still not comfortable with this check. The go toolchain will raise this
error if GOARCH is unsupported, and a very typical usecase that works with
env.py right now is to just put GOOS and GOARCH on the same line as the `go`
command (e.g. `GOARCH=x86 GOOS=windows go build ./...`). I don't think that we
should require users to export this environment variable just to be able to use
this script.

I think a better thing to do would be to print something to standard error after
all the env.py work is done that says something like:

```
To build for android, set the following environment variables when building:
  GOARCH=arm
  GOOS=android
```

[bpastene, 2016/08/11 17:27:54]

GOARCH needs to be specified during the call to mobile_env.py. It sets a number
of other environment variables based on that value below. I'm assuming the go
toolchain does all of this magic itself for GOOS=(win|darwin|linux). There's no
magic for GOOS=android right now. This is that magic :)

Also, you can still inline all the env vars you want, you just have to wrap
mobile_env.py around the go command:
GOOS=android GOARCH=arm64 python mobile_env.py go build ....

+
+  toolset = ANDROID_TOOLSETS[arch]
+
+  # Needed when cross-compiling uses of cgo.
+  env['CGO_ENABLED'] = '1'
+  env['CC'] = os.path.join(
+      ANDROID_NDK_PATH, arch, 'bin', '%s-linux-androideabi-clang' % toolset)
+  env['CXX'] = os.path.join(
+      ANDROID_NDK_PATH, arch, 'bin', '%s-linux-androideabi-clang++' % toolset)
+
+  # Compiler/linker needs access to android system headers in the NDK.
+  sysroot_path = os.path.join(ANDROID_NDK_PATH, arch, 'sysroot')
+  env['CGO_CFLAGS'] = '-I %s/usr/include --sysroot %s' % (
+      sysroot_path, sysroot_path)
+  env['CGO_LDFLAGS'] = '-L %s/usr/lib --sysroot %s' % (
+      sysroot_path, sysroot_path)
+
+
+# Run `gomobile init` to fetch the android NDK.
+if not os.path.exists(ANDROID_NDK_PATH):
+  cmd = [sys.executable, 'env.py', 'gomobile', 'init']
+  subprocess.check_call(cmd)
+
+# Keep track of any changed env vars for printing to stdout later.
+old = os.environ.copy()
+new = os.environ.copy()
+if 'android' in old.get('GOOS', ''):
+  _get_android_env(new)
+
+cwd = os.path.dirname(os.path.realpath(__file__))
+if len(sys.argv) == 1:
+  cmd = [sys.executable, 'env.py']
+  print subprocess.check_output(cmd, env=new, cwd=cwd).strip()
+  for key, value in sorted(new.iteritems()):
+    if old.get(key) != value:
+      print 'export %s=%s' % (key, pipes.quote(value))
+else:
+  cmd = [sys.executable, 'env.py']
+  cmd.extend(sys.argv[1:])
+  sys.exit(subprocess.call(cmd, env=new, cwd=cwd))