Update the readme to use build.py and explain Rust

## 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

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:

```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:

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/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

```

We provide a build script to automate building assuming you've staged your build

environment already as above.

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```.

### 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

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):

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)

* 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

2. Generate Eclipse settings:

You can choose to run only a specific stage by passing an arg via `--target`.

  ```sh

  cd packages/modules/Bluetooth/system

  gn gen --ide=eclipse 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.

3. In Eclipse, do File->Import->C/C++->C/C++ Project Settings, choose the XML

 location under packages/modules/Bluetooth/system/out/Default

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

```

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

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.