Update the readme to use build.py and explain Rust

Updated the README to build using build.py and explain how the Rust
portion is built on Linux.

Bug: 179821440
Tag: #floss
Test: atest --host bluetooth_test_gd
Change-Id: Ibb58fae9b9ca8aaaf1dcce7c5d33204c46fd9678

3 files changed, 103 insertions, 87 deletions

diff --git a/README.md b/README.md
index f6ba4ada6d..38d2e2ebc1 100644
--- a/README.md
+++ b/README.md
@@ -5,8 +5,29 @@ Just build AOSP - Fluoride is there by default.
 
 ## Building and running on Linux
 
-Instructions for Ubuntu, tested on 14.04 with Clang 3.5.0 and 16.10 with Clang
- 3.8.0
+Instructions for a Debian based distribution:
+* Debian Bullseye or newer
+* Ubuntu 20.10 or newer
+* Clang-11 or Clang-12
+* Flex 2.6.x
+* Bison 3.x.x (tested with 3.0.x, 3.2.x and 3.7.x)
+
+You'll want to download some pre-requisite packages as well. If you're currently
+configured for AOSP development, you should have all required packages.
+Otherwise, you can use the following apt-get list:
+
+```sh
+sudo apt-get install repo git-core gnupg flex bison gperf build-essential \
+  zip curl zlib1g-dev gcc-multilib g++-multilib \
+  x11proto-core-dev libx11-dev lib32z-dev libncurses5 \
+  libgl1-mesa-dev libxml2-utils xsltproc unzip liblz4-tool libssl-dev \
+  libc++-dev libevent-dev \
+  flatbuffers-compiler libflatbuffers1 \
+  openssl openssl-dev
+```
+
+You will also need a recent-ish version of Rust and Cargo. Please follow the
+instructions on [Rustup](https://rustup.rs/) to install a recent version.
 
 ### Download source
 
@@ -16,96 +37,74 @@ cd ~/fluoride
 git clone https://android.googlesource.com/platform/packages/modules/Bluetooth/system
 ```
 
-Install dependencies (require sudo access):
+Install dependencies (require sudo access). This adds some Ubuntu dependencies
+and also installs GN (which is the build tool we're using).
 
 ```sh
 cd ~/fluoride/bt
 build/install_deps.sh
 ```
 
-Then fetch third party dependencies:
+The following third-party dependencies are necessary but currently unavailable
+via a package manager. You may have to build these from source and install them
+to your local environment.
 
-```sh
-cd ~/fluoride/bt
-mkdir third_party
-cd third_party
-git clone https://github.com/google/googletest.git
-git clone https://android.googlesource.com/platform/external/aac
-git clone https://android.googlesource.com/platform/external/libchrome
-git clone https://android.googlesource.com/platform/external/libldac
-git clone https://android.googlesource.com/platform/external/modp_b64
-git clone https://android.googlesource.com/platform/external/tinyxml2
-```
-
-And third party dependencies of third party dependencies:
-
-```sh
-cd fluoride/bt/third_party/libchrome/base/third_party
-mkdir valgrind
-cd valgrind
-curl https://chromium.googlesource.com/chromium/src/base/+/master/third_party/valgrind/valgrind.h?format=TEXT | base64 -d > valgrind.h
-curl https://chromium.googlesource.com/chromium/src/base/+/master/third_party/valgrind/memcheck.h?format=TEXT | base64 -d > memcheck.h
-```
+TODO(abhishekpandit) - Provide a pre-packaged option for these or proper build
+instructions from source.
 
-NOTE: If packages/modules/Bluetooth/system is checked out under AOSP, then create symbolic links instead
-of downloading sources
+* libchrome
+* modp_b64
+* tinyxml2
 
-```
-cd packages/modules/Bluetooth/system
-mkdir third_party
-cd third_party
-ln -s ../../../external/aac aac
-ln -s ../../../external/libchrome libchrome
-ln -s ../../../external/libldac libldac
-ln -s ../../../external/modp_b64 modp_b64
-ln -s ../../../external/tinyxml2 tinyxml2
-ln -s ../../../external/googletest googletest
-```
+### Stage your build environment
 
-### Generate your build files
+For host build, we depend on a few other repositories:
+* [Platform2](https://chromium.googlesource.com/chromiumos/platform2/)
+* [Rust crates](https://chromium.googlesource.com/chromiumos/third_party/rust_crates/)
+* [Proto logging](https://android.googlesource.com/platform/frameworks/proto_logging/)
 
+Clone these all somewhere and create your staging environment.
 ```sh
-cd ~/fluoride/bt
-gn gen out/Default
+export STAGING_DIR=path/to/your/staging/dir
+mkdir ${STAGING_DIR}
+mkdir -p ${STAGING_DIR}/external
+ln -s $(readlink -f ${PLATFORM2_DIR}/common-mk) ${STAGING_DIR}/common-mk
+ln -s $(readlink -f ${PLATFORM2_DIR}/.gn) ${STAGING_DIR}/.gn
+ln -s $(readlink -f ${RUST_CRATE_DIR}) ${STAGING_DIR}/external/rust
+ln -s $(readlink -f ${PROTO_LOG_DIR}) ${STAGING_DIR}/external/proto_logging
 ```
 
 ### Build
 
-```sh
-cd ~/fluoride/bt
-ninja -C out/Default all
-```
-
-This will build all targets (the shared library, executables, tests, etc) and
- put them in out/Default. To build an individual target, replace "all" with the
- target of your choice, e.g. ```ninja -C out/Default net_test_osi```.
+We provide a build script to automate building assuming you've staged your build
+environment already as above.
 
-### Run
 
 ```sh
-cd ~/fluoride/bt/out/Default
-LD_LIBRARY_PATH=./ ./bluetoothtbd -create-ipc-socket=fluoride
+./build.py --output ${OUTPUT_DIR} --platform-dir ${STAGING_DIR} --clang
 ```
 
-### Eclipse IDE Support
-
-1. Follows the Chromium project
- [Eclipse Setup Instructions](https://chromium.googlesource.com/chromium/src.git/+/master/docs/linux/eclipse_dev.md)
- until "Optional: Building inside Eclipse" section (don't do that section, we
- will set it up differently)
+This will build all targets to the output directory you've given. You can also
+build each stage separately (if you want to iterate on something specific):
 
-2. Generate Eclipse settings:
+* prepare - Generate the GN rules
+* tools - Generate host tools
+* rust - Build the rust portion of the build
+* main - Build all the C/C++ code
+* test - Build all targets and run the tests
+* clean - Clean the output directory
 
-  ```sh
-  cd packages/modules/Bluetooth/system
-  gn gen --ide=eclipse out/Default
-  ```
+You can choose to run only a specific stage by passing an arg via `--target`.
 
-3. In Eclipse, do File->Import->C/C++->C/C++ Project Settings, choose the XML
- location under packages/modules/Bluetooth/system/out/Default
+Currently, Rust builds are a separate stage that uses Cargo to build. See
+[gd/rust/README.md](gd/rust/README.md) for more information.
 
-4. Right click on the project. Go to Preferences->C/C++ Build->Builder Settings.
- Uncheck "Use default build command", but instead using "ninja -C out/Default"
+### Run
 
-5. Goto Behaviour tab, change clean command to "-t clean"
+By default on Linux, we statically link libbluetooth so you can just run the
+binary directly:
 
+```sh
+cd ~/fluoride/bt/out/Default
+./bluetoothtbd -create-ipc-socket=fluoride
+```
diff --git a/system/build/install_deps.sh b/system/build/install_deps.sh
index 06056078e8..2f994e1c23 100755
--- a/system/build/install_deps.sh
+++ b/system/build/install_deps.sh
@@ -1,7 +1,7 @@
 #!/bin/bash
 CLANG_PACKAGE=clang
 GNSHA1_URL="https://chromium.googlesource.com/chromium/buildtools/\
-+/central/linux64/gn.sha1?format=TEXT"
+  +/central/linux64/gn.sha1?format=TEXT"
 
 # Check if clang is already installed on current system
 clang_path=`which clang`
@@ -20,7 +20,7 @@ fi
 
 if [ ! -z "$CLANG_PACKAGE" ]; then
   # Try to find clang from a known list
-  for clang_version in 3.9 3.8 3.7 3.6 3.5
+  for clang_version in 12.0 11.0
   do
     clang_path=`which clang-$clang_version`
     if [ -f "$clang_path" ]; then
@@ -34,24 +34,24 @@ fi
 if [ ! -z "$CLANG_PACKAGE" ]; then
   echo "clang not found on current system, installing"
   if [ -f /etc/lsb-release ]; then
-	  # Ubuntu
-	  ubuntu_version=$(lsb_release --release --short)
-	  IFS="." read -ra ubuntu_version_array <<< "$ubuntu_version"
-	  ubuntu_version_major=${ubuntu_version_array[0]}
-	  ubuntu_version_minor=${ubuntu_version_array[1]}
-	  if [ $ubuntu_version_major -lt 15 ]; then
-	    echo "Choose clang-3.8 for Ubuntu 14 and below"
-	    CLANG_PACKAGE=clang-3.8
-	  fi
+    # Ubuntu
+    ubuntu_version=$(lsb_release --release --short)
+    IFS="." read -ra ubuntu_version_array <<< "$ubuntu_version"
+    ubuntu_version_major=${ubuntu_version_array[0]}
+    ubuntu_version_minor=${ubuntu_version_array[1]}
+    if [ $ubuntu_version_major -lt 15 ]; then
+      echo "Choose clang-3.8 for Ubuntu 14 and below"
+      CLANG_PACKAGE=clang-3.8
+    fi
   fi
 fi
 
 sudo apt-get -y install $CLANG_PACKAGE libevent-dev libc++-dev libc++abi-dev \
-                        ninja-build
-gn_path=`which gn`
-if [ -z $gn_path ]; then
-  gnsha1=$(curl $GNSHA1_URL | base64 -d)
-  wget -O gn http://storage.googleapis.com/chromium-gn/$gnsha1
-  chmod a+x ./gn
-  sudo mv ./gn /usr/bin/
-fi
+  ninja-build
+  gn_path=`which gn`
+  if [ -z $gn_path ]; then
+    gnsha1=$(curl $GNSHA1_URL | base64 -d)
+    wget -O gn http://storage.googleapis.com/chromium-gn/$gnsha1
+    chmod a+x ./gn
+    sudo mv ./gn /usr/bin/
+  fi
diff --git a/system/gd/rust/README.md b/system/gd/rust/README.md
new file mode 100644
index 0000000000..0e9985cb25
--- /dev/null
+++ b/system/gd/rust/README.md
@@ -0,0 +1,17 @@
+Rust build
+======
+
+Currently, the Rust components are built differently on Android vs Linux. We are
+missing Rust support in our GN toolchain so we currently build the Rust
+libraries as a staticlib and link in C++. This may change in the future once we
+have better support.
+
+For now, you can build all of the Rust code using Cargo.
+
+There are some dependencies:
+* You must have the protobuf-compiler package installed
+* You must have a recent version of Cargo + Rust
+
+You should use `build.py` at the root to do your Rust builds so that it
+correctly points your dependencies towards the vendored crates and sets your
+$CARGO_HOME to the correct location.