Construct and run Android Automotive OS on Raspberry Pi 4B – Grape Up
18 min read
Introduction
Have you ever ever wished to construct your personal Android? It’s simple in keeping with the official guide, nevertheless it’s getting more durable on a Home windows (or Mac) machine, or should you’d prefer to run it on bodily {hardware}. Nonetheless too simple? Let’s construct Android Automotive OS – the identical supply code, however one other layer of complexity. On this guide, we’ll cowl all steps wanted to construct and run Android Automotive OS 11 AOSP on Raspberry Pi 4B utilizing Home windows. The answer isn’t excellent, nonetheless. Essentially the most principal difficulty is an absence of Google Companies as a result of the complete AAOS is on an open-source undertaking and Google doesn’t present its companies this fashion. However, let’s construct the open-source model first, after which we are able to attempt to face incoming points.
Conditions
{Hardware}
If you wish to run the system on a bodily machine, you want one. I exploit the Raspberry Pi 4 mannequin B with 8GB of RAM (https://www.raspberrypi.com/products/raspberry-pi-4-model-b/). By the way in which, if you wish to construct and run an emulator from the supply, it’s additionally attainable, however there’s a small limitation – packaging the emulator to a zipper file, shifting it to a different pc, and even operating it beneath Android Studio was launched in Android 12.
To energy your Raspberry, you want an influence adapter (USB C, min. 5V 3A). I exploit the Raspberry-official 5.1V 3A mannequin. You can even energy the Raspberry pc out of your desktop/laptop computer’s USB port, particularly should you’re going to debug it through a serial connection. Examine the “If it doesn’t work” part under for the required {hardware}.
One other piece of {hardware} wanted is an SD card. In principle, 4GB is all you want, nonetheless, I like to recommend shopping for a bigger card to have some additional house on your purposes on Android. I exploit 32GB and 64GB playing cards. You’ll additionally want a built-in or exterior card reader. I exploit the latter.
The following step is a display. It’s non-compulsory however fancy. You may join your mouse and optionally keyboard to your Raspberry Pi through USB and join any show you may have through micro-HDMI however utilizing a contact display is way more intuitive. I exploit a Waveshare 10-inch display devoted to Raspberry (https://www.waveshare.com/wiki/10.1inch_HDMI_LCD_(B)_(with_case). The display field has a spot to screw the Raspberry too, so that you don’t want any additional case. You can even purchase it with an influence adapter and a show cable.
For those who don’t purchase a bundle, be sure to have all mandatory equipment: micro-HDMI – HDMI cable to attach a display (Waveshare or another), USB A – USB mini A cable to attach a contact sensor of the display, USB mini A 5V 3A adapter to energy the display.
In fact, you want a pc. On this guide, we use a Home windows machine with not less than 512GB of storage (the Android supply is big) and 16GB of RAM.
Software program
You may most likely construct all the pieces in pure Home windows, however the beneficial methodology is to make use of WSL. I assume you have already got it put in, so simply be sure to have the latest WSL2 model. If in case you have by no means used WSL earlier than, see the complete guide right here https://learn.microsoft.com/en-us/windows/wsl/install.
WSL changes
The usual WSL set up makes use of a too-small digital drive and restricted RAM, so it’s essential alter it.
Let’s begin with the disk. Make sure that the WSL is shut down by operating ‘wsl –shutdown’ within the command immediate. Open Home windows Command Immediate with admin privileges and enter ‘diskpart’. Then run ‘choose vdisk file=”<path to WSL drive file>”’. For me, the trail is “C:Customers<person>AppDataLocalPackagesCanonicalGroupLimited.Ubuntu_<WSL_instance_id>LocalStateext4.vhdx”. Now you’ll be able to develop it with the command ‘develop vdisk most=512000’. Round 300GB is sufficient for Android 11, however if you wish to play with a number of branches of Android on the similar time, you want extra space. Now you’ll be able to shut the diskpart with the ‘exit’ command. Subsequent, open the WSL and run ‘sudo resize2fs /dev/sdb 512000M’. I assume you may have solely a single drive hooked up to the WSL and it’s seen within the Linux subsystem as /dev/sdb. You may examine it with the instructions ‘sudo mount -t devtmpfs none /dev || mount | grep ext4’.
Now, let’s alter the reminiscence. Cease the WSL once more. Open your own home listing in Home windows and open .wslconfig file. Create it if this file doesn’t exist but. Within the file, it’s essential create a [wsl2] part and reminiscence configuration. The entire file ought to seem like this:
As you’ll be able to see, I’ve hooked up 16GB to the digital machine. It’s assigned dynamically, in keeping with wants, however you have to be conscious that the digital machine can take all of it, so should you permit it to eat your complete RAM, it may pressure your Home windows to make use of a tough disk to outlive (which can sluggish all the pieces down considerably).
Disclaimer:
Constructing Android on 8 cores, 16GB RAM machine takes round 4 hours. If you wish to do it sooner otherwise you don’t have a pc highly effective sufficient at your own home or workplace, you’ll be able to take into account constructing within the cloud. Easy AWS EC2 with 32 cores and 64GB of reminiscence does the job in a single hour (to obtain and construct) and prices just some bucks.
Let’s Get Able to Rumble!!!
..or not less than to constructing.
Extra stipulations
We’d like some software program however not a lot. Simply set up the next packages. This set of libraries means that you can construct Android Automotive OS variations 11 to 13.
sudo apt replace && sudo apt set up gcc-aarch64-linux-gnu libssl-dev bc python3-setuptools repo python-is-python3 libncurses5 zip unzip make gcc flex bison -y
Supply code downloading
Let’s create a house listing for our android and obtain sources.
mkdir android-11.0.0_r48 && cd android-11.0.0_r48
repo init -u https://android.googlesource.com/platform/manifest -b android-11.0.0_r48 --partial-clone --clone-filter=blob:restrict=10M
git clone https://github.com/android-rpi/local_manifests .repo/local_manifests -b arpi-11
repo sync
“repo init” will ask you for some private information. It’s collected by Google. To be taught extra about optimizations right here, examine this guide: https://docs.gitlab.com/ee/topics/git/partial_clone.html. ‘git clone’ provides a customized code from Android RPI undertaking (https://groups.google.com/g/android-rpi) with drivers on your Raspberry Pi. The undertaking is nice and it’s all you want if you wish to run Android TV. To run Android Automotive OS, we’ll want to regulate it barely (see “Changes” part under). ‘repo sync’ will take a while as a result of it’s essential obtain round 200GB of code. If in case you have a robust machine with an amazing Web connection, you should utilize extra threads with ‘-j X’ parameter added to the command. The default thread depend is 4. If in case you have already synchronized your supply code with out android-rpi native manifest, it’s essential add –force-sync to the ’repo-sync’ command.
Changes
All modifications from this part can obtain as a patch file hooked up to this text. See the “Path file” part under.
Android-rpi supplies Android TV for Raspberry Pi. We have to take away the TV-related configuration and add the Automotive OS one.
Let’s begin with eradicating pointless recordsdata. You may safely take away the next recordsdata and directories:
- machine/arpi/rpi4/overlay/frameworks/base/core/res/res/anim
- machine/arpi/rpi4/overlay/frameworks/base/core/res/res/values-television
- machine/arpi/rpi4/overlay/frameworks/base/core/res/res/values/dimens.xml
- machine/arpi/rpi4/overlay/frameworks/base/core/res/res/values/kinds.xml
- machine/arpi/rpi4/overlay/frameworks/base/packages
To take away the person discover display not wanted in Automotive OS, create a brand new file machine/arpi/rpi4/overlay/packages/companies/Automotive/service/res/values/config.xml with the next content material:
<?xml model="1.0" encoding="utf-8"?>
<assets xmlns:xliff="urn:oasis:names:tc:xliff:doc:1.2">
<string title="config_userNoticeUiService" translatable="false"></string>
</assets>
To interchange the fundamental TV overlay config with the Automotive overlay config, alter the configuration in machine/arpi/rpi4/overlay/frameworks/base/core/res/res/values/config.xml.
Take away:
- <integer title=”config_defaultUiModeType”>4</integer> <!–disable compelled UI_MODE_TYPE_TELEVISION, as there may be solely MODE_TYPE_CAR out there now–>
- <integer title=”config_longPressOnHomeBehavior”>0</integer> <!–disable dwelling button lengthy press motion–>
- <bool title=”config_hasPermanentDpad”>true</bool> <!–disable D-pad–>
- <string title=”config_appsAuthorizedForSharedAccounts”>;com.android.television.settings;</string> <!–take away pointless entry for a shared account as there may be nothing in com.android.television.* now–>
… and add:
- <bool title=”config_showNavigationBar”>true</bool> <!–allow software program navigation bar, as there isn’t any hardwave one–>
- <bool title=”config_enableMultiUserUI”>true</bool> <!–allow multi-user, as AAOS makes use of background processes referred to as in one other periods –>
- <integer title=”config_multiuserMaximumUsers”>8</integer> <!–set most person depend, required by the earlier one–>
Additionally in machine/arpi/rpi4/overlay/frameworks/base/packages/SystemUI/res/values/config.xml, take away <string title=”config_statusBarComponent” translatable=”false”>com.android.systemui.statusbar.television.TvStatusBar</string>.
Now let’s rename the android-rpi authentic /machine/arpi/rpi4/rpi4.mk to /machine/arpi/rpi4/android_rpi4.mk. We have to alter the file somewhat bit.
Take away the next variables definitions. A few of them you’ll re-create in one other file, whereas a few of them should not wanted.
- PRODUCT_NAME
- PRODUCT_DEVICE
- PRODUCT_BRAND
- PRODUCT_MANUFACTURER
- PRODUCT_MODEL
- USE_OEM_TV_APP
- DEVICE_PACKAGE_OVERLAYS
- PRODUCT_AAPT_PRED_CONFIG
- PRODUCT_CHARACTERISTICS
Take away the next invocations. We’re going to name mandatory exterior recordsdata in one other mk file.
- $(name inherit-product, machine/google/atv/merchandise/atv_base.mk)
- $(name inherit-product, $(SRC_TARGET_DIR)/product/core_64_bit_only.mk)
- $(name inherit-product, $(SRC_TARGET_DIR)/product/languages_full.mk)
- embody frameworks/native/construct/tablet-10in-xhdpi-2048-dalvik-heap.mk
In PRODUCT_PROPERTY_OVERRIDES take away debug.drm.mode.pressure=1280×720 and add the next properties. This manner you take away the TV launcher configuration and override the default automotive launcher configuration.
- dalvik.vm.dex2oat64.enabled=true
- keyguard.no_require_sim=true
- ro.logd.measurement=1m
Now it’s essential utterly take away the android-rpi TV launcher and add RenderScript assist for Automotive OS. In PRODUCT_PACKAGES take away:
… and add:
Create a brand new rpi4.mk4 with the next content material:
PRODUCT_PACKAGE_OVERLAYS += machine/generic/automotive/frequent/overlay
$(name inherit-product, $(SRC_TARGET_DIR)/product/core_64_bit.mk)
$(name inherit-product, machine/arpi/rpi4/android_rpi4.mk)
$(name inherit-product, $(SRC_TARGET_DIR)/product/full_base.mk)
$(name inherit-product, machine/generic/automotive/frequent/automotive.mk)
PRODUCT_SYSTEM_DEFAULT_PROPERTIES +=
android.automotive.number_pre_created_users=1
android.automotive.number_pre_created_guests=1
android.automotive.user_hal_enabled=true
DEVICE_PACKAGE_OVERLAYS += machine/arpi/rpi4/overlay machine/generic/automotive/car_x86_64/overlay
PRODUCT_NAME := rpi4
PRODUCT_DEVICE := rpi4
PRODUCT_BRAND := arpi
PRODUCT_MODEL := Raspberry Pi 4
PRODUCT_MANUFACTURER := GrapeUp and ARPi
As a result of license, bear in mind so as to add your self to the PRODUCT_MANUFACTURER area.
Now you may have two mk recordsdata – android-rpi.mk is borrowed from android-rpi undertaking and adjusted, and rpi.mk comprises all modifications for Automotive OS. You may meld these two collectively or cut up them into extra recordsdata should you’d like, however understand that the order of invocations does matter (not at all times, however nonetheless).
As Android Automotive OS is larger than Android TV, we have to improve the system partition measurement to suit the brand new picture. In machine/arpi/rpi4/BoardConfig.mk improve BOARD_SYSTEMIMAGE_PARTITION_SIZE to 2147483648, which suggests 2GB.
It’s worthwhile to apply all modifications described in https://github.com/android-rpi/device_arpi_rpi4/wiki/arpi-11-:-framework-patch too. These modifications are additionally included within the patch file hooked up.
For those who use the 8GB model of Raspberry Pi, it’s essential change machine/arpi/rpi4/boot/fixup4.dat and machine/arpi/rpi4/boot/start4.elf recordsdata. You will discover the right recordsdata within the patch file hooked up or you might use the official supply: https://github.com/raspberrypi/firmware/tree/master/boot. It’s most likely not wanted for 4GB model of Raspberry, however I don’t have such a tool for verification.
Path file
For those who desire to use all modifications described above as a single file, go to your sources listing and run ‘git apply –no-index <path_to_patch_file>’. There may be additionally a boot animation changed within the patch file. If you wish to create one in all your personal, observe the official guide right here: https://android.googlesource.com/platform/frameworks/base/+/master/cmds/bootanimation/FORMAT.md.
Now we are able to construct!
That’s the straightforward half. Simply run a number of instructions from under. Firstly, we have to construct a customized kernel for Android. ‘merge_config.sh’ script simply configures all variables required. The primary ‘make’ command builds the true kernel picture (which may take a couple of minutes). Subsequent, construct a tool tree configuration.
cd kernel/arpi
ARCH=arm64 scripts/kconfig/merge_config.sh arch/arm64/configs/bcm2711_defconfig kernel/configs/android-base.config kernel/configs/android-recommended.config
ARCH=arm64 CROSS_COMPILE=aarch64-linux-gnu- make Picture.gz
ARCH=arm64 CROSS_COMPILE=aarch64-linux-gnu- DTC_FLAGS="-@" make broadcom/bcm2711-rpi-4-b.dtb
ARCH=arm64 CROSS_COMPILE=aarch64-linux-gnu- DTC_FLAGS="-@" make overlays/vc4-kms-v3d-pi4.dtbo
cd ../..
The following half is to construct the complete system. “envsetup.sh” script units up variables and provides customized instructions to your terminal. Then you’ll be able to decide the right pair of Android variations and gadgets with “lunch”. You may run it with out parameters to see (virtually) all attainable configurations. On this step, you’ll be able to determine to construct a system for devoted {hardware} (eg. Dragonboard) and change between cellphone/pill/TV/wearable/automotive variations of Android. The final line is an actual constructing. We are able to’t run simply “make” or “m”, as documented within the official guide as a result of we have to create three particular photographs to jot down them on an SD card and run them on Raspberry Pi. Exchange “X” in ‘-j X’ with the variety of threads you wish to use. The default worth is the variety of logical processors in your pc.
supply construct/envsetup.sh
lunch rpi4-eng
make -j X ramdisk systemimage vendorimage
I hope you may have a pleasant e book subsequent to you as a result of the final constructing takes a number of hours relying in your {hardware}. Excellent news! If it’s essential adapt one thing and construct once more, typically you simply want the three final strains (and even simply the final one) – to supply the surroundings setup, to choose the lunch configuration, and to make ramdisk, system, and vendor photographs. And it takes hours for the primary time solely.
Creating an SD card
This step appears to be simple, nevertheless it isn’t. WSL doesn’t comprise drivers for the USB card reader. You need to use usbip to ahead a tool from Home windows to the subsystem, nevertheless it doesn’t work properly with exterior storage with out partitions. The answer is a VirtualBox with Ubuntu put in. Simply create a digital machine, set up Ubuntu, and set up Visitor Additions. Then you’ll be able to join the cardboard reader and move it to the digital machine. For those who’re a minimalist, you should utilize Ubuntu Server or another Linux distribution you want. Bear in mind that utilizing a card reader constructed into your pc could also be difficult relying on drivers and the {hardware} connection kind (USB-like, or PCI-e).
Now, it’s essential create a partition schema on the SD card. I assume the cardboard is loaded to the system as /dev/sdb. Examine your configuration earlier than persevering with to keep away from formatting your foremost drive or one other catastrophe. Let’s erase the present partition desk and create a brand new one.
sudo umount /dev/sdb*
sudo wipefs -a /dev/sdb
sudo fdisk /dev/sdb
Now let’s create partitions. First, you want a 128MB energetic partition of the W95 FAT32 (LBA) kind, second a 2GB Linux partition, third a 128MB Linux partition, and the remainder of the cardboard for person information (additionally Linux partition). Right here’s the way to navigate by way of fdisk menu to configure all partitions.
Welcome to fdisk (util-linux 2.37.2).
Adjustments will stay in reminiscence solely, till you determine to jot down them.
Watch out earlier than utilizing the write command.
Gadget doesn't comprise a acknowledged partition desk.
Created a brand new DOS disklabel with disk identifier 0x179fb9bc.
Command (m for assist): n
Partition kind
p main (0 main, 0 prolonged, 4 free)
e prolonged (container for logical partitions)
Choose (default p):
Utilizing default response p.
Partition quantity (1-4, default 1):
First sector (2048-61022207, default 2048):
Final sector, +/-sectors or +/-sizeK,M,G,T,P (2048-61022207, default 61022207): +128M
Created a brand new partition 1 of kind 'Linux' and of measurement 128 MiB.
Command (m for assist): a
Chosen partition 1
The bootable flag on partition 1 is enabled now.
Command (m for assist): t
Chosen partition 1
Hex code or alias (kind L to listing all): 0c
Modified kind of partition 'Linux' to 'W95 FAT32 (LBA)'.
Command (m for assist): n
Partition kind
p main (1 main, 0 prolonged, 3 free)
e prolonged (container for logical partitions)
Choose (default p):
Utilizing default response p.
Partition quantity (2-4, default 2):
First sector (264192-61022207, default 264192):
Final sector, +/-sectors or +/-sizeK,M,G,T,P (264192-61022207, default 61022207): +2G
Created a brand new partition 2 of kind 'Linux' and of measurement 2 GiB.
Command (m for assist): n
Partition kind
p main (2 main, 0 prolonged, 2 free)
e prolonged (container for logical partitions)
Choose (default p):
Utilizing default response p.
Partition quantity (3,4, default 3):
First sector (4458496-61022207, default 4458496):
Final sector, +/-sectors or +/-sizeK,M,G,T,P (4458496-61022207, default 61022207): +128M
Created a brand new partition 3 of kind 'Linux' and of measurement 128 MiB.
Command (m for assist): n
Partition kind
p main (3 main, 0 prolonged, 1 free)
e prolonged (container for logical partitions)
Choose (default e): p
Chosen partition 4
First sector (4720640-61022207, default 4720640):
Final sector, +/-sectors or +/-sizeK,M,G,T,P (4720640-61022207, default 61022207):
Created a brand new partition 4 of kind 'Linux' and of measurement 26,8 GiB.
Command (m for assist): w
The partition desk has been altered.
Calling ioctl() to re-read partition desk.
Syncing disks.
Watch out with the final partition – fdisk proposes creating an prolonged one by default, which isn’t wanted in our use case.
For those who don’t do it for the primary time on the identical card, you may even see a warning that some partition already comprises a file system signature. You may safely conform to take away it.
Partition #4 comprises a ext4 signature.
Do you wish to take away the signature? [Y]es/[N]o: Y
The signature will probably be eliminated by a write command.
Now, let’s provide file techniques for the primary and the final partitions.
sudo mkdosfs -F 32 /dev/sdb1
sudo mkfs.ext4 -L userdata /dev/sdb4
We received’t write something to the final one, because it’s for person information solely and will probably be stuffed by Android in the course of the first boot. However we have to write some recordsdata for the primary one. Let’s create a brief mount listing beneath /mnt/p1 (like “partition 1”), mount it, and replica the required recordsdata from the Android constructed within the earlier part. It’s unusual, however we’re going to repeat recordsdata from one digital machine (WSL) to a different (VirtualBox). You may merely mount a wsl drive as a shared folder in VirtualBox. For those who don’t see a WSL drive in your Home windows Explorer, you’ll be able to map it as a community drive utilizing “wsl$Ubuntu” path
sudo mkdir /mnt/p1
sudo mount /dev/sdb1 /mnt/p1
sudo mkdir /mnt/p1/overlays
cd <PATH_TO_YOUR_ANDROID_SOURCES_IN_WSL>
sudo cp machine/arpi/rpi4/boot/* /mnt/p1
sudo cp kernel/arpi/arch/arm64/boot/Picture.gz /mnt/p1
sudo cp kernel/arpi/arch/arm64/boot/dts/broadcom/bcm2711-rpi-4-b.dtb /mnt/p1
sudo cp kernel/arpi/arch/arm/boot/dts/overlays/vc4-kms-v3d-pi4.dtbo /mnt/p1/overlays/
sudo cp out/goal/product/rpi4/ramdisk.img /mnt/p1
sudo umount /mnt/p1
sudo rm -rf /mnt/p1
For those who’re wanting on the official android-rpi undertaking guide, there’s a totally different path for vc4-kms-v3d-pi4.dtbo file. That’s OK – they use a symbolic hyperlink we’re unable to make use of on this filesystem.
Generally, you’ll be able to see an error message when creating an “overlays” listing. It occurs once in a while, as a result of “mount” returns to the console earlier than actually mounting the drive. In such a case, simply name “mkdir” once more. Pay attention to that, particularly should you’re going to copy-paste the complete itemizing from above.
Now, let’s copy the 2 remaining partitions. For those who’re combating dd command (it might grasp), you’ll be able to attempt to copy massive *.img recordsdata from WSL to VirtualBox first.
cd <PATH_TO_YOUR_ANDROID_SOURCES_IN_WSL>/out/goal/product/rpi4/
sudo dd if=system.img of=/dev/sdb2 bs=1M standing=progress
sudo dd if=vendor.img of=/dev/sdb3 bs=1M standing=progress
Congratulations!
You’re performed. You’ve downloaded, ready, constructed, and saved your personal Android Automotive OS. Now you’ll be able to put the SD card into Raspberry, and join all cables (be sure to join the Raspberry energy cable on the finish). There isn’t any “energy” button, and it doesn’t matter which micro-HDMI or USB port of Raspberry you utilize. It’s now time to take pleasure in your personal Android Automotive OS!
If it doesn’t work
The world isn’t excellent and typically one thing goes terribly mistaken. For those who see the boot animation for a very long time, or in case your machine crashes in a loop a number of seconds after boot, you’ll be able to attempt to debug it.
You want a USB-TTL bridge (like this one https://www.sunrom.com/p/cp2102-usb-ttl-uart-module) to attach the right pins from the Raspberry to the USB. It’s worthwhile to join pin 6 (floor) to the GND pin within the bridge, pin 8 (RXD) to the RXD pin of the bridge and pin 10 (TXD) to the TXD pin of the bridge. If you wish to energy the Raspberry through the bridge, it’s essential additionally join pin 2 to +5V pin of the bridge. It’s not beneficial, due to the decrease voltage, so your system is perhaps unstable. For those who don’t have an influence adapter, you’ll be able to merely join a USB cable between your pc port and the USB C port of the Raspberry. Warning! You may’t join each a +5V connector right here and a USB C energy port of the Raspberry otherwise you’ll burn the Raspberry board.
See the schema for the connection reference.
Relying in your bridge mannequin, you might want a further driver. I exploit this one: https://www.silabs.com/developers/usb-to-uart-bridge-vcp-drivers?tab=downloads.
Whenever you join the +5V pin or USB-C energy adapter (once more, by no means each on the similar time!), the Raspberry begins. Now you’ll be able to open Putty and connect with your Android. Choose Serial and sort COMX within the serial line definition. X is the variety of your COM port. You may examine it in your machine supervisor – search for “USB to UART bridge (COM4)” or the like. The proper connection pace is 115200.
Open the connection to entry the Android shell. By default, Android spawns all logs to the usual output, so you must see a variety of them immediately. Anyway, it’s dual-side communication and you’ve got full terminal entry to your Android if it’s essential examine/modify any file or name any command. Simply strike enter to see the command immediate. You may even name ‘su’ to realize superuser entry in your Android operating on Raspberry.
Connecting through adb
If you wish to use Android Debug Bridge to connect with your machine, utilizing a USB bridge isn’t sufficient. When operating ‘adb gadgets’ in your pc, the Android Automotive OS operating on Raspberry isn’t acknowledged. You need to use a putty connection to activate a TCP debug bridge as a substitute.
Be sure to’ve related Android and your pc to the identical community. Open putty and connect with the operating Android console. Log as root and allow ADB through TCP. Then examine your IP deal with.
su
setprop service.adb.tcp.port 5555
cease adbd
begin adbd
ifconfig wlan0
Now, utilizing your Home windows command line, go to the Android SDK platform-tools listing and connect with your machine. As you’ll be able to see, the IP deal with of mine Raspnberry is 192.168.50.47.
cd %userprofilepercentAppDataLocalAndroidSdkplatform-tools
adb join 192.168.50.47:5555
If you wish to use ADB in WSL, you’ll be able to hyperlink the Home windows program in WSL utilizing the next command.
sudo ln -s /mnt/c/Customers/<your_username>/AppData/Native/Android/Sdk/platform-tools/adb.exe /usr/bin/adb
Now you can use ADB to make use of logcat with out putty or to put in purposes with out manually transferring APK recordsdata to the SD card. Enjoyable truth – should you use a USB bridge and USB energy provide, you may have two bodily connections between your pc and the Android-running one, nonetheless, you continue to want to make use of ADB over WiFi to make use of the debug bridge.
Abstract
That’s all. Android Automotive OS 11 is operating. You may set up the apps you want, take them to your automotive, or do no matter you’d like with them. Utilizing {hardware} as a substitute of an emulator means that you can manually handle partitions (e.g. for the OTA replace) and join exterior gadgets like an actual GPS receiver or accelerometer. The naked metallic {hardware} overperforms the emulator too. And most significantly – you’ll be able to simply take it to your automotive, obtain energy from an in-car USB port, join it to an ODB-II port and run real-life exams with no laptop computer.
