# MiAuto setup: install the APK and pair with CarWith, Car+ or Jovi InCar

> AI Release · @ai_release1 · https://ai-release.org/guides/miauto-ustanovka-apk-podklyuchenie_en.html

## TL;DR
- Time: 10–20 minutes (planning estimate; depends on head-unit access)
- Difficulty: Intermediate
- You need: MiAuto APK from the `PiggyBackBayonet/MiAuto` GitHub repository, an Android car head unit that allows APK sideloading, a phone with Xiaomi CarWith, OPPO Car+, or vivo Jovi InCar, a data-capable USB cable, and `adb` on a workstation. Root and an adapter box are not required according to the project authors.

## Requirements and setup
![Illustration: Requirements and setup](https://ai-release.org/guides/img/miauto-ustanovka-apk-podklyuchenie-en-1.jpg?v=1793695774)

MiAuto is the car-side receiver for ICCOA CarLink, the projection protocol used by CarWith, Car+, and Jovi InCar. Install it on the car head unit, not on the phone. The source post confirms wireless operation and says no root or adapter box is required; it does not publish a version number, package ID, minimum Android version, ABI list, or exact pairing screens.

| Side | Component | Role |
|---|---|---|
| Car head unit | MiAuto APK | ICCOA CarLink receiver; accepts the phone stream |
| Phone | CarWith / Car+ / Jovi InCar | Sender app that starts projection |

- Car head unit running Android with permission to install a sideloaded APK. Check the head-unit documentation for the exact menu path; stock Android usually exposes it under Settings → Apps → Special app access → Install unknown apps.
- Phone with one of the three supported projection apps. The post does not list supported phone models; verify in the app and project documentation.
- MiAuto APK from `PiggyBackBayonet/MiAuto`. The source post does not name a release file or version, so read the repository documentation before downloading.
- USB cable that supports data, or a USB drive/file-transfer method accepted by the head unit.
- `adb` on a workstation for command-line installation. The source post does not specify an `adb` version; use the Android SDK platform-tools build you already have.
- No root changes. The authors claim root is not required. Do not root the phone or head unit for this procedure.
- If you need a refresher on verifying an APK before sideloading, use the checklist in [WordCraft APK for Android: download, verify and install safely](https://ai-release.org/guides/wordcraft-apk-android-skachat.html?utm_source=tg&utm_medium=channel&utm_campaign=guide_inline&utm_content=guide_to_guide).

## Step 1. Prepare the car head unit and verify the APK
![Illustration: Step 1. Prepare the car head unit and verify the APK](https://ai-release.org/guides/img/miauto-ustanovka-apk-podklyuchenie-en-2.jpg?v=1793695780)

**What to do:** Confirm that `adb` can see the car head unit, then inspect the APK package metadata. Save the package ID for the verification step.

**Why:** MiAuto must run on the car side. A successful `adb devices` result proves only that the workstation can talk to the head unit; it does not prove that MiAuto is installed or that projection will work.

**How to check:** Run the commands below. The head unit must appear as `device`, not `unauthorized` or `offline`.

```bash
adb devices
```

Expected output:

```text
List of devices attached
<car-head-unit-serial>    device
```

Then check that the APK exists and read its package line:

```bash
ls -lh MiAuto.apk
aapt dump badging MiAuto.apk | head -n 1
```

Expected output, with values from your APK:

```text
package: name='<package.id>' versionCode='<n>' versionName='<value>'
```

**Example:** If the head unit serial is `ABCD1234`, `adb devices` shows `ABCD1234    device`. That means USB debugging and the cable are working. If `aapt` prints `package: name='com.example.miauto'`, save `com.example.miauto` as `<package.id>` for Step 3. This works because `adb` talks to the Android Debug Bridge daemon on the head unit, while `aapt` reads the manifest inside the APK.

For a general GitHub-based install workflow, see [Sideraven: install from GitHub and migrate your bookmarks](https://ai-release.org/guides/sideraven-ustanovka-s-github.html?utm_source=tg&utm_medium=channel&utm_campaign=guide_inline&utm_content=guide_to_guide).

Checklist before continuing:

- [ ] Car head unit appears as `device` in `adb devices`.
- [ ] APK file is present and non-zero in size.
- [ ] Package ID from `aapt dump badging` is saved.
- [ ] MiAuto is not being installed on the phone.
- [ ] No root or adapter box has been added.

## Step 2. Install MiAuto and start the receiver
**What to do:** Install the APK on the car head unit, open MiAuto, and start the receiver. Then open CarWith, Car+, or Jovi InCar on the phone and use its wireless connection entry to connect to the car.

**Why:** MiAuto implements the car side of ICCOA CarLink. The phone app already implements the phone side, so the two sides must be started in that order: receiver first, sender second.

**How to check:** `adb install` must return `Success`. The package path must resolve. The MiAuto screen must show a receiver-ready state, and the phone must show a connected or projecting state.

```bash
adb install -r MiAuto.apk
```

Expected output:

```text
Success
```

Verify that the package manager registered the app:

```bash
PKG=$(aapt dump badging MiAuto.apk | sed -n "s/^package: name='\([^']*\)'.*/\1/p")
adb shell pm path "$PKG"
```

Expected output:

```text
package:/data/app/.../base.apk
```

Open MiAuto from the head-unit launcher and start the receiver. The source post does not document the exact button label or permission list, so use the receiver/start control shown on the main screen and grant only permissions the app requests and the head-unit policy allows.

On the phone, open CarWith, Car+, or Jovi InCar and choose its wireless connection entry. The exact discovery screen, PIN flow, and radio requirements are not documented in the source post; follow the prompts shown by the phone app.

**Example:** On a phone using CarWith, open CarWith, select the wireless connection option, and wait for the car entry. The car display should leave the MiAuto receiver screen and show the phone projection interface. This works because the phone app and MiAuto speak the two sides of the same ICCOA CarLink session.

## Step 3. Verify projection and capture a working baseline
![Illustration: Step 3. Verify projection and capture a working baseline](https://ai-release.org/guides/img/miauto-ustanovka-apk-podklyuchenie-en-3.jpg?v=1793695782)

**What to do:** Start projection once, confirm that the phone UI appears on the car display, and capture the package-specific log. Record the working phone app, head-unit state, and package ID.

**Why:** A successful APK install does not prove that the wireless session completed. The log confirms that the MiAuto package is running on the head unit; the screen confirms that the phone-to-car path works.

**How to check:** The car display must show the phone projection UI, and the phone app must show a connected state. The log command should return lines containing the MiAuto package ID.

```bash
PKG=$(aapt dump badging MiAuto.apk | sed -n "s/^package: name='\([^']*\)'.*/\1/p")
adb logcat -d | grep -i "$PKG" | tail -n 50
```

Expected result: log lines that include `<package.id>`. Exact MiAuto messages are not published in the source post, so do not treat a missing known string as proof of failure; use the screen state and process check together.

```bash
adb shell ps -A | grep "$PKG"
```

Expected result: a process line for the MiAuto package. If the process is absent, open MiAuto again and repeat the projection attempt.

| Check | Success signal |
|---|---|
| APK install | `Success` |
| Package registration | `package:/data/app/.../base.apk` |
| Receiver process | Process line for `<package.id>` |
| Projection | Phone UI visible on the car display |
| Phone app | Connected/projecting state shown |

**Example:** After starting Car+ on the phone, the head unit shows the phone’s projection screen instead of the MiAuto receiver screen. `adb shell ps -A | grep "$PKG"` returns a MiAuto process line. This works because the receiver stays active while the phone app supplies the display stream.

## Troubleshooting

**Problem. ADB cannot see the car head unit.**
- Error: `adb: no devices/emulators found`
- Cause: USB debugging is disabled, the cable is charge-only, or the head unit does not expose ADB over USB.
- Solution: Enable Developer options and USB debugging on the head unit, replace the cable with a data-capable one, then restart the ADB server:
```bash
adb kill-server
adb start-server
adb devices
```
If the unit still does not appear, install from a USB drive with the head-unit file manager instead of ADB.

**Problem. ADB sees the unit but installation is blocked by authorization.**
- Error: `adb: device unauthorized. Please check the confirmation dialog on your device.`
- Cause: The RSA key prompt on the head unit was not accepted.
- Solution: Reconnect the cable, accept “Allow USB debugging” on the head unit, and confirm the fingerprint. If no dialog appears, revoke USB debugging authorizations in Developer options and reconnect:
```bash
adb kill-server
adb devices
```

**Problem. APK installation fails with a native library error.**
- Error: `Failure [INSTALL_FAILED_NO_MATCHING_ABIS: Failed to extract native libraries, res=-113]`
- Cause: The APK contains native libraries for an ABI the head unit does not support.
- Solution: Compare the head-unit ABI with the APK contents:
```bash
adb shell getprop ro.product.cpu.abi
unzip -l MiAuto.apk | grep 'lib/'
```
Use a MiAuto build that matches the reported ABI. The source post does not list supported ABIs, so check the repository documentation; do not force-install an incompatible build.

## Summary and next steps
You installed MiAuto on the car side and verified the receiver, package, and projection path with ADB and on-screen checks. Before updating, re-read the `PiggyBackBayonet/MiAuto` repository documentation because the source post does not publish version, compatibility, or pairing details.

## FAQ
**Does MiAuto require root?**
No. The project authors claim root is not required for the car-side receiver.

**Where do I install MiAuto: on the phone or on the car?**
On the car head unit. MiAuto is the ICCOA CarLink receiver that accepts the stream from CarWith, Car+, or Jovi InCar on the phone.

**Which phone apps are supported?**
The source post names Xiaomi CarWith, OPPO Car+, and vivo Jovi InCar. It does not list supported phone models.

**What Android version does the car head unit need?**
The source post does not state a minimum Android version. Check the MiAuto repository documentation and the head-unit firmware details before installing.