How To Securely Manage Secrets with HashiCorp Vault on Ubuntu 16.04


Android is considered the most operating that is popular in the world today. Hundreds of different equipment that is original, or OEMs, decide to set it up on the products since it is free, available supply, and it has a big ecosystem of apps and solutions built around it. Unfortuitously, numerous OEMs cannot push over-the-air (OTA) updates for Android os frequently. As well as other OEMs just offer updates for a period that is limited of after a device’s launch. Additionally, OEMs tend to customize Android extensively to make sure that their devices sport a look that is unique feel. Their customizations consist of alternate launchers, themed system individual interfaces, and apps that is pre-installed

If you wish to eliminate those customizations, or for it yourself if you want to run the latest version of pure Android on your device, you can build new firmware. Into the Android os modding community, such firmware is generally called a ROM, brief for browse just Memory.

In this guide, you are going to build an Android os Oreo ROM that is on the basis of the Android os Open provider venture, or AOSP for brief. To help keep this device-independent that is tutorial generic, we are going to be focusing on just the AOSP emulator, you could use exactly the same approaches for real products.


To have the ability to follow along, you may need:

  • One Ubuntu 16.04 x64 host with at the least 16 GB of RAM, 4 CPUs, and 120 GB of space for storage create by after the Ubuntu 16.04 initial host setup guide, including a sudo non-root individual and a firewall. The compilation procedure calls for countless RAM, and much more CPUs will accelerate time that is compile. In addition, the files you’ll be downloading and building are quite large. DigitalOcean has High CPU Droplets which might be a fit that is great this task.
  • Git set up by after how exactly to Install Git on Ubuntu 16.04.

Step 1 — begin a Screen Session

Some of commands you are going to perform inside guide can run for hours potentially. If the SSH connection between your PC and your server is interrupted while the commands are running, they’ll be terminated abruptly. To avoid such a situation, use the screen utility, which lets you run multiple console sessions in a terminal that is single. With display, it is possible to detatch from a session that is running reattach to it later on. If you should be not used to Screen, find out more inside guide on utilizing Screen on Ubuntu.

Start a fresh screen session.

whenever you operate display the time that is first you will end up given a permit contract. Press Enter to simply accept the permit.

From this time on, when your SSH connection fail, your commands that are long-running consistently run inside back ground. When you re-establish the SSH connection, you can resume the session by operating screen -r.

Next, let us install the elements we have to compile Android os.

Step 2 — Putting In Dependencies

The AOSP supply rule is spread across a number of different Git repositories. The AOSP community has created a command-line tool called repo to make it easier for users to download all those repositories.

We'll install the most recent form of the device utilizing wget and shop it inside ~/bin directory. First, create the ~/bin directory:

Then down load the repo script:

  • wget '' -P ~/bin

Note: if you should be worried about the safety of operating a script on your own device you downloaded from another website, examine the articles of script:

Once you are more comfortable with the script's articles, carry on using this guide.

Use chmod to give your user that is current the to perform repo.

The repo device utilizes Git internally and needs you create a Git setup indicating your individual title and current email address. Execute these commands to accomplish this:

  • git config that is--global "your name"
  • git config that is--global "[email protected]"

Android's supply rule mainly is made of Java, C++, and XML files. To compile the origin rule, you will have to install OpenJDK 8, GNU C and C++ compilers, XML parsing libraries, ImageMagick, and many other packages that are related. Fortunately, you can install all of them using apt. You update your server's package lists.( before you do so, make sure******)

Once the listings upgrade, install the dependencies:

  • sudo apt-get install openjdk-8-jdk android-tools-adb bc bison build-essential curl flex g++-multilib gcc-multilib gnupg gperf imagemagick lib32ncurses5-dev lib32readline-dev lib32z1-dev libesd0-dev libncurses5-dev libsdl1.2-dev that is liblz4-tool libssl-dev libwxgtk3.0-dev libxml2 libxml2-utils lzop pngcrush rsync schedtool squashfs-tools xsltproc yasm zip zlib1g-dev

Once the dependencies down load, we are able to make use of the repo script to obtain the Android os supply.

Step 3 — getting the foundation Code

We'll make use of the repo script to peform a tasks that are few prepare our workspace. Create a new directory to store the Android source you're going to ( that is download******)

You'll work with this directory through the sleep of the guide, therefore now switch to it:

The directory needs to be initialized aided by the AOSP manifest repository, a Git that is special repository an XML file called default.xml, which specifies the paths of all other Git repositories that together form the AOSP codebase.

Working aided by the entirety of AOSP rule tree will get cumbersome. Consequently, you need to furthermore specify the title of a revision that is specific branch you are interested in. In this tutorial, because we're building an Oreo ROM, we'll use the android-8.0.0_r33 branch, whose build ID is OPD1.170816.025. You can get a list of all build that is available and branch names from AOSP's formal Codenames, Tags, and develop Numbers web page.

Furthermore, you will not be requiring the complete history that is commit of code tree for this tutorial. You can save both right some time space for storage by truncating the real history to a depth of 1.

Accordingly, make use of the repo init demand to initialize the directory and specify these choices:

  • repo init -u -b android-8.0.0_r33 --depth=1

whenever prompted make it possible for display that is color press Y, accompanied by Enter.

Finally, install the AOSP files from repositories that are various operating the repo sync demand:

The above demand packages over 30 GB of information, therefore show patience although it completes. As soon as it can, we are going to set a cache up to accelerate compilation.

Step 4 — planning a Compiler Cache

To speed your builds up, you should use a compiler cache. As the title shows, a compiler cache can help you avoid recompiling portions of ROM which can be currently put together.

To allow the application of a compiler cache, set a breeding ground variable called USE_CCACHE.

so you can limit its size unless you have lots of free disk space, you wouldn't want the cache to grow too large. You can limit it to 15 GB if you are building your ROM for a single device. To do this, make use of the ccache demand.

  • prebuilts/misc/linux-x86/ccache/ccache -M 15G

You'll see production that confirms you have made this modification:


Set cache size restriction to 15.0 Gbytes

There's an additional optimization we have to make before we are able to compile. Let us do this next.

Step 5 — Configuring Jack

The Jack host, which can be in charge of building all of the Java-based portions of ROM, calls for countless memory. To prevent memory allocation mistakes, you should use a breeding ground variable called ANDROID_JACK_VM_ARGS to specify exactly how memory that is much is permitted to utilize. Frequently, allocating about 50per cent of one's host's RAM is enough. This environment variable additionally specifies other compilation settings.

Execute the command that is following allocate 8 GB of RAM to your Jack host and protect the standard compilation choices Jack requires:

  • export ANDROID_JACK_VM_ARGS="-Xmx(***************************) that are****************************)8g.encoding=UTF-8 -XX:+TieredCompilation"

Now you are prepared to grow your Android os ROM.

Step 6 — beginning the develop

The AOSP rule tree contains a script called, which includes a few helper that is build-related. While many of the helper functions, such as mm, mma, and mmm, serve as shortcuts for the make command, others such as lunch set environment that is important that, among other items, determine the Central Processing Unit architecture of ROM, additionally the sort of the create.

Source the script to achieve use of the helper functions.


including device/asus/fugu/ including device/generic/car/car-arm64/ that is device/generic/car/car-armv7-a-neon/vendorsetup Including**************************************************************)_ that are device/generic/car/car-x(***************************************************************)/ Including**************************************************************)/ that is device/generic/car/car-x including device/generic/mini-emulator-arm64/ that is device/generic/mini-emulator-armv7-a-neon/vendorsetup including device/generic/mini-emulator-mips64/ including device/generic/mini-emulator-mips/ Including**************************************************************)_ that are device/generic/mini-emulator-x(***************************************************************)/ Including**************************************************************)/ that is device/generic/mini-emulator-x including device/google/dragon/ including device/google/marlin/ including device/google/muskie/ including device/google/taimen/ including device/huawei/angler/ including device/lge/bullhead/ including device/linaro/hikey/ including sdk/bash_completion/adb.bash

Next, operate lunch and pass the codename of one's unit to it, suffixed with a create kind, that can be either eng, userdebug, or user. Theuser build type is recommended for production use.( while the eng and userdebug build types result in ROMs that are best suited for testing purposes******)

To build a test ROM that may run using the AOSP ARM emulator, pass aosp_arm-eng to your lunch demand:

You'll see this production, showing the environmental surroundings settings:


============================================ PLATFORM_VERSION_CODENAME=REL PLATFORM_VERSION=8.0.0 TARGET_PRODUCT=aosp_arm TARGET_BUILD_VARIANT=eng TARGET_BUILD_TYPE=release TARGET_PLATFORM_VERSION=OPD1 TARGET_BUILD_APPS= TARGET_ARCH=arm TARGET_ARCH_VARIANT=armv7-a TARGET_CPU_VARIANT=generic TARGET_2ND_ARCH= TARGET_2ND_ARCH_VARIANT= TARGET_2ND_CPU_VARIANT= HOST_ARCH=x86_64 HOST_2ND_ARCH=x86 HOST_OS=linux HOST_OS_EXTRA=Linux-4.4.0-(**************************************************************)_ that is************************************************************)-generic-x(***************************************************************)-with-Ubuntu-16.04-xenial HOST_CROSS_OS=windows HOST_CROSS_ARCH=x86 HOST_CROSS_2ND_ARCH=x86_64 HOST_BUILD_TYPE=release BUILD_ID=OPD1.170816.025 OUT_DIR=out AUX_OS_VARIANT_LIST= ============================================

Finally, operate make to start out the create. make supports synchronous jobs, in order to speed the build up quite a bit utilizing the -j choice to set how many synchronous jobs add up to how many CPUs obtainable in the host.

Use the nproc demand to observe how CPUs that are many have actually:

The demand comes back how many CPUS:



You may then make use of this quantity with make to specify execution that is parallel******)

Even with 8 CPUs, you will need to watch for over one hour the create to perform, supplied there are not any other processes that are CPU-intensive on your server. The duration of the build is directly proportional to the amount of RAM and the true amount of CPUs you have got. If you prefer faster builds, contemplate using High that is specialized CPU, which help as much as 32 CPUs and 48 GB of memory.

Note: you'll see numerous messages that are warning throughout the create. You'll properly ignore them.

Once the ROM is prepared, you need to see an email saying the create finished effectively. You will also have the ability to start to see the duration that is exact of create.


... Producing filesystem with parameters: Size: 2147483648 Block size: 4096 Obstructs per team: 32768 Inodes per team: 8192 Inode size: 256 Journal obstructs: 8192 Label: system Obstructs: 524288 Block teams: 16 Reserved block team size: 127 Developed filesystem with 2266/131072 inodes and 178244/524288 obstructs [100% 63193/63193] Install system fs i... out/target/product/generic/system.img out/target/product/generic/system.img+ maxsize=2192446080 blocksize=2112 total=2147483648 reserve=22146432 #### make completed successfully (01:05:44 (hh:mm:ss)) ####

Let's verify that things built properly.

Step 7 — confirming the develop

The production of build procedure is made of numerous filesystem pictures, which together form the ROM. You will discover them inside out/target/product/generic/ directory.

  • ls -l out/target/product/generic/*.img


-rw-r--r-- 1 sammy sammy 69206016 Jan 5 18:51 out/target/product/generic/cache.img -rw-rw-r-- 1 sammy sammy 1699731 Jan 5 19:09 out/target/product/generic/ramdisk.img -rw-r--r-- 1 sammy sammy 2147483648 Jan 5 19:10 out/target/product/generic/system.img -rw-r--r-- 1 sammy sammy 576716800 Jan 5 19:09 out/target/product/generic/userdata.img

To test the ROM, you can look at as well an emulator up with it by running the emulator command. If you're in a environment that is non-GUI always pass the -no-window and -noaudio flags to it.

  • emulator -no-window -noaudio > /dev/null 2>&1 &

To verify that the emulator surely could start up effectively, watch for a moment and make use of the Android os debug connection device, adb, to start a shell in the emulator.

If the ROM doesn't have dilemmas, you will see a prompt from a shell operating on the emulator.


* daemon maybe not operating; beginning now at tcp:5037 * daemon began effectively generic:/ #

Exit this shell by typing exit and pushing ENTER, or by pushing CTRL+D.

Note: that the emulator is offline if you try to open the shell before the emulator starts, you'll see an error message informing you. Watch for some time and take to once more.


If your develop unsuccessful, probably the most most likely cause is memory that is insufficient. To fix it, first kill the Jack server by running the command that is following******)

Then begin the create once more, however with less jobs that are parallel. For example, here's how you can reduce the true amount of synchronous jobs to simply 2:

If your develop unsuccessful due to inadequate disk area, you are most likely wanting to build times that are multiple cleaning up the results of previous builds. To discard the results of previous builds, you can run the command that is following******)

Alternatively, you can include more disk area towards Droplet making use of DigitalOcean's Block space.


In this guide, you effectively built an ROM that is AOSP-based for Oreo. The techniques you learned are applicable to all forks of AOSP too, such as Lineage OS and Resurrection Remix OS today. You might be interested in modifying small portions of the AOSP codebase to give your ROM a personal touch.( if you have experience developing Android apps,******)

To find out more about building the AOSP supply rule, search through the Android os Building forum on Bing Groups.

All you need to find out about AMP as well as its value

Previous article

Groups, Microsoft’s Slack competitor, is mostly about to be a lot that is whole competitive

Next article

You may also like


Leave a reply

Your email address will not be published. Required fields are marked *

More in Linux