MOTO-HUB

Android Auto 17.4 removed the entry points an app could use to ask it to project: the activity it used is no longer exported and the receiver behind it ships disabled, so MOTO-HUB's request is refused or silently ignored. This affects every app of this kind, not only MOTO-HUB — the headunit-revived project reports the same in its issue #698. Android Auto 17.2.662634 is verified working; 17.4.663004 is not.

There is no need to install an older Android Auto. Android Auto can be asked to listen instead, using the head unit server its own Desktop Head Unit connects to, and MOTO-HUB connects to that:

1. Open the Android Auto app, scroll to the bottom and tap Version ten times to reveal Developer settings.
2. In Developer settings, enable Add new cars to Android Auto (older wording: Unknown sources).
3. Open the ⋮ menu at the top right of Developer settings and choose Start head unit server. It lives in that menu, not in the list of settings below it. A notification confirms it is running, and it stays running until stopped or the phone restarts.
4. Start Android Auto from MOTO-HUB as usual. MOTO-HUB polls that server and connects on its own.

The same instructions are in the app under Settings ▸ Android Auto does not start, and the error shown when projection fails links to them.

• Pair with a motorcycle T-Box by scanning its QR code, importing a photo of it, or entering the network manually.
• Read the QR dialects other manufacturers use — such as Moto Morini's MotoFun code — and accept an unrecognized one after a warning rather than refusing it.
• Store multiple motorcycle profiles and select the active motorcycle.
• Store a private motorcycle photo and use it throughout the app UI.
• Connect to the T-Box Wi-Fi access point without requiring manual SSID entry, with a separate Wi-Fi Direct path for dashboards that advertise a DIRECT- network.
• Discover the EasyConn service and establish the T-Box session.
• Mirror the entire phone screen or a single Android app.
• Start Android Auto through an embedded local head-unit receiver, including on Android Auto versions that no longer accept a direct start request.
• Drive Android Auto from the motorcycle's handlebar buttons, after a short guided calibration, with per-motorcycle mappings for press, double press and hold.
• Control music volume, jump to a saved destination, or open the assistant from the handlebar without touching the phone.
• Stream the phone screen to a USB (AOA) external display, independently of the T-Box.
• Choose the Android Auto TFT layout per motorcycle: FIT (preserve the complete image, black bars when necessary), STRETCH (use the complete TFT area with geometric stretching), or CROP (use the complete TFT area without stretching, cropping edges when necessary).
• Calibrate per-motorcycle TFT safe margins so Android Auto video and touch stay inside the projection area not occupied by native motorcycle UI.
• Let Android Auto lay out at the dashboard's real shape instead of a letterboxed band inside it.
• Keep the phone preview available for Android Auto touch control, or disable the touchscreen entirely and ride with focus and handlebar controls.
• Select Smoother, Balanced or Sharper image detail, and a Smooth/Balanced/Saver/adaptive power behavior for the next stream.
• Override Android Auto with landscape or portrait SD/HD source resolutions, or keep automatic selection.
• Optionally connect to the saved motorcycle when MOTO-HUB opens.
• Optionally recover or seamlessly resume a stalled or dropped TFT stream when the T-Box returns.
• Show persistent diagnostics, run network tests, and share application logs as an exported file for troubleshooting.
• Check GitHub releases and pre-releases from inside the app, showing release notes before installing a newer APK.
• Run in English, Italian, Spanish, French, Portuguese or Korean, or follow the phone language.

The garage stores multiple motorcycle profiles. Each profile can contain the T-Box SSID and encrypted Wi-Fi password, QR-provided metadata, a user-defined display name, a private motorcycle photo, the Android Auto display format (FIT, STRETCH, or CROP), TFT safe margins, its own handlebar button calibration and mapping, and observed T-Box capability snapshots. Existing single-profile data is migrated automatically when the app is upgraded.

Mirror uses Android MediaProjection and supports either the complete phone display or an app selected through Android's system picker.

Auto runs Android Auto through a local Android Auto Projection receiver. The decoded Android Auto video is composited, encoded as H.264, and sent to the T-Box through the ridedaemon transport. The compositor supports FIT, STRETCH, and CROP against the usable TFT projection area. When Android Auto declares internal letterbox margins, STRETCH uses the active Android Auto content rather than stretching black bars. By default MOTO-HUB asks Android Auto to lay out at the dashboard's real shape, so the map fills the panel instead of sitting between black bars; the per-motorcycle TFT safe margins can be advertised instead by switching content insets to Manual.

External appears only when a USB (AOA) accessory head unit is attached. It captures the phone screen and writes H.264 access units straight to the USB accessory endpoint, completely independently of the T-Box, EasyConn and ridedaemon path.

The Ride Dashboard, Navigation and Trips are not part of this app — they live in MOTO-HUB ADVANCED, which connects through this app's IPC boundary.

These dashboards forward their handlebar buttons to the phone as ordinary Bluetooth media commands — a volume change, a play/pause, a next/previous track — and which physical press produces which command differs per motorcycle, and per brand. MOTO-HUB therefore starts from a calibration: the rider performs each press once, and the app learns what that motorcycle actually sends. Nothing is assumed from the model name.

Each calibrated press (Up, Down, Left, Right, Select, each as press, double press or hold) can then be mapped to an Android Auto action: rotary forward/back, D-pad, Select, Back, Home, the assistant, or one-press navigation to one of three saved destinations. Mapping, calibration and the on/off switch are stored per motorcycle. The feature is on by default, and MOTO-HUB keeps the media session it needs alive so the dashboard keeps sending presses instead of handing them to another app.

Music volume is expressed in presses, not steps, because that is how the dashboard rocker behaves.

Video quality sets image detail against the negotiated base bitrate: Balanced is the recommended default, Smoother uses 70% and Sharper 160%. Power mode selects Auto (adapt bitrate and frame rate to phone temperature and Wi-Fi quality), Smooth (30 FPS), Balanced (24 FPS) or Saver (20 FPS). Disable touchscreen lets the rider use focus and handlebar controls even on a dashboard that reports a touch display.

Android Auto selects the source resolution — Auto (dynamic orientation from the learned T-Box geometry), 800 x 480, 1280 x 720, 720 x 1280 or 1080 x 1920 — and how content insets are advertised. The T-Box output canvas is still negotiated at runtime and is not replaced by the Android Auto source resolution.

Connection & automation holds auto-connect, which requests the saved motorcycle network and discovers EasyConn on app launch and after deliberate projection stops, and the optional recovery watchdog, which monitors outgoing TFT frame progress and rebuilds the T-Box network, discovery, handshake, and encoder path after a post-start stall while keeping the local Android Auto receiver alive. Seamless resume can park a projection across a longer T-Box interruption and resume when the motorcycle network returns.

Diagnostics provides network tests (T-Box discovery, Wi-Fi binding, cellular routes), the application log with copy/share/clear, a master switch that stops all logging — and with it the error reports described under crash and error reporting — and verbose T-Box logging for protocol-level troubleshooting.

The general section holds the app language, launch-time update checks, and seamless resume.

The T-Box Wi-Fi network is a local display transport and may not provide Internet access. MOTO-HUB requests the T-Box network explicitly and keeps the T-Box transport separate from normal phone connectivity where Android allows it. OEM network behavior can vary, especially on OnePlus devices.

MOTO-HUB is a local-first app. The permissions below are used to connect to the motorcycle, scan its pairing QR code, keep an active projection running, and give the rider controls. The app does not require an account and does not upload screen content.

The app also declares network and foreground-service permissions required by Android for this workflow: Internet and network-state access, Wi-Fi state/change access, Wi-Fi multicast discovery, foreground services for media projection, connected devices and microphone, and a wake lock. These maintain the local T-Box connection and the projection; they are not separate user accounts or remote services.

The Android Auto receiver also declares package visibility for Android Auto and Google Play services so MOTO-HUB can detect and launch the installed Android Auto component. This does not give MOTO-HUB access to Google account data.

The app should continue to open normally. Only the related feature is unavailable: without Camera, use QR import from a photo, manual pairing, or an already saved motorcycle; without Nearby Wi-Fi or Location, the T-Box connection cannot be discovered; without Notifications, projection cannot be kept as a managed foreground session; without screen-capture approval, mirroring cannot start; without Bluetooth, handlebar buttons cannot be identified; without Microphone, the Android Auto assistant has no voice input. Optional display dimming simply remains disabled unless overlay access is granted.

MOTO-HUB is designed to operate without an account or proprietary telemetry service. It handles screen content, T-Box credentials, and diagnostic data on the phone. Wi-Fi passwords are encrypted with Android Keystore. Screen frames are processed in memory for the active projection and are not intentionally recorded to disk.

This app contacts two Internet hosts on its own: GitHub, to check for a newer release when you ask it to or when launch-time update checks are enabled, and Sentry, for crash and error reporting (see below). It has no maps, geocoding, routing or weather features, requests no location updates, and sends no ride or position data anywhere. Anything Android Auto itself does over the network is Android Auto's own traffic, under your Google account, not MOTO-HUB's.

Official MOTO-HUB release APKs report crashes and connection failures to Sentry, in its EU region. This exists because the failures that matter here — a dashboard that will not associate, a stream that dies mid-ride — take a motorcycle and a rider to reproduce, and a single rider's report rarely says whether it is one bike or one model.

What is sent:

• Crashes, and why a previous process of the app ended.
• Errors already written to the in-app diagnostic log, redacted and capped at 50 per app run. They are sent as plain messages, never as raw exception objects, precisely because the local log can contain connection details that must not leave the phone.
• Coarse tags used to group reports across riders — for example whether the dashboard's Wi-Fi network was visible at all in the moment before a failed join. Values are deliberately kept low-cardinality, so they describe a situation rather than a rider.
• The app version and build number, so a report can be attributed to a release.

What is not sent: Sentry's "default PII" collection is switched off, so no account, contact, device identifier or IP-derived user data is attached. Screen content, T-Box passwords, trips and position are never sent — the app has no position data to begin with.

Turning off Settings ▸ Diagnostics ▸ Enable logging stops the diagnostic log entirely, and with it the error events described above. Crash reports are handled by the Sentry SDK itself and are not covered by that switch.

Builds from this source send nothing. The Sentry DSN is supplied at build time from a private properties file or CI secret, exactly like the Android Auto identity. A source build without it has telemetry disabled outright, not merely unconfigured.

Review Security and Privacy before distributing an APK outside personal use.

The public source does not include the Android Auto identity or APK-signing keystore. APKs attached to official MOTO-HUB releases are complete runtime builds and include Android Auto support.

MOTO-HUB/
├── apps/android/
│   ├── app/                Android application and projection pipelines
│   └── ipc-contract/       AIDL boundary MOTO-HUB ADVANCED connects through
├── packages/contracts/     Future platform-neutral contracts
├── tooling/                AAR build metadata and reproducibility helpers
├── translations/           Source strings and their translations
├── documentation/          Architecture, decisions, security, testing, and roadmap
└── README.md               Project overview and setup instructions

The public repository contains only the MOTO-HUB source, documentation, build metadata, and non-sensitive required artifacts. External projects are referenced by their public URLs and are not vendored into this repository.

• JDK 21. Gradle 8.13 / AGP 8.12.3 do not run on newer JDKs, and the JDK bundled with current Android Studio versions is too new — point JAVA_HOME at a JDK 21 explicitly.
• Android SDK platform/API 36.
• A physical Android device. An emulator cannot reproduce the motorcycle Wi-Fi, camera, NSD, or Android Auto behavior.
• A generated hudlib.aar from the MOTO-HUB ridedaemon fork.

From apps/android/:

export JAVA_HOME="/opt/homebrew/opt/openjdk@21/libexec/openjdk.jdk/Contents/Home"
export ANDROID_HOME="$HOME/Library/Android/sdk"

./gradlew lintDebug testDebugUnitTest assembleDebug

The generated Android binding is expected at:

apps/android/app/libs/hudlib.aar

To rebuild it, install Go and gomobile, then run these commands from the directory that contains the MOTO-HUB folder:

git clone https://github.com/vincenzobpt/ridedaemon-lib ridedaemon-lib
cd ridedaemon-lib
gomobile bind -target=android -androidapi 31 -o ../MOTO-HUB/apps/android/app/libs/hudlib.aar ./hud/api

The source commit and AAR checksum must be updated in tooling/ridedaemon.lock whenever the artifact changes.

The public source intentionally does not contain the static Android Auto head-unit identity (aa_cert and aa_identity_data) or the APK-signing keystore. Maintainer-built release APKs include Android Auto support and require no certificate setup or technical configuration from the user.

A normal source build without those inputs remains usable for pairing, T-Box streaming, mirroring, and diagnostics, but Android Auto reports that its identity is unavailable. This separation keeps private build inputs out of Git history; it does not make identity material embedded in a publicly downloadable APK confidential.

For a local Android Auto build, place the two identity files in tooling/private/android-auto/ and run:

./gradlew -PincludeAndroidAutoIdentity=true assembleDebug

For a local build without Android Auto identity files, use the default build:

./gradlew assembleDebug

Maintainers can find the complete release process and required GitHub secret names in documentation/PUBLIC_RELEASE.md.

• Architecture
• Android implementation
• Reference analysis
• T-Box streaming contract
• Dynamic Android Auto profile
• Security, privacy, and licensing
• Test strategy
• Projection settings
• Public release process

MOTO-HUB was developed using the following public projects as technical sources. The links below are references and attribution; they are not claims of endorsement.

• vincenzobpt/ridedaemon-lib - the fork used to generate the Android hudlib.aar binding.
• charliecharlieO-o/ridedaemon-lib - upstream project and protocol implementation.

The library implements EasyConn discovery, the T-Box handshake, control channels, media polling, H.264 framing, and the gomobile Android API.

• charliecharlieO-o/ridedaemon-android - reference Android integration used to study QR parsing, Wi-Fi provisioning, NSD discovery, MediaCodec configuration, and frame delivery.

• BojanJ/open-cfmoto - independent Android Auto and CFMOTO T-Box research used to understand the local Android Auto receiver flow, self-mode startup, touch input, and video pipeline behavior.
• zanderp/open-cfmoto - AGPL-licensed implementation studied for user-selectable bitrate, Android Auto source profiles, startup automation, and stream recovery behavior.

These services are not contacted by this app. They are used by MOTO-HUB ADVANCED, which builds on this repository's transport, and are credited here because the documentation kept in this repository describes them.

• OpenStreetMap - underlying map, address, and routing data, credited to OpenStreetMap contributors.
• CARTO basemaps - raster basemap tiles.
• Photon (Komoot) - the free geocoding API used to turn a searched address or place name into coordinates.
• Valhalla - the open-source routing engine used for turn-by-turn motorcycle routing.
• Stadia Maps - hosts the Valhalla routing API used by default, with the rider's own free API key.
• FOSSGIS public Valhalla demo server - an optional, rate-limited, keyless routing fallback.
• Open-Meteo - free weather API used for the route weather estimates.
• Mapillary - street-level imagery, with the rider's own token.

• EasyConn - vendor context for the T-Box ecosystem.
• Sentry - crash and error reporting in official release builds; see the permissions and privacy section.
• Android MediaProjection - Android screen capture API.
• Android MediaCodec - hardware video encoding and decoding API.
• Android Open Accessory - USB accessory protocol used by the external display mode.
• Android Wi-Fi network requests - Android Wi-Fi provisioning APIs.

This section is intentionally explicit because the project combines original MOTO-HUB code with external components and research.

• MOTO-HUB (this repository) is licensed under the GNU Affero General Public License v3.0 (AGPL-3.0) — see LICENSE. AGPL-3.0 was chosen because the repository combines GPL-3.0 material (hudlib.aar, the T-Box transport) with AGPL-3.0-derived material (aa/, the Android Auto receiver technique ported from headunit-revived); AGPL-3.0 satisfies both components' obligations for a combined work and additionally covers network-facing use.
• ridedaemon-lib and the reference Android project are distributed under AGPL-3.0 according to their repositories and license files; the generated hudlib.aar is derived from that fork. Redistributing it (including inside this repository) must comply with the applicable AGPL obligations — the corresponding source must remain available to anyone who interacts with it, including over a network.
• The open-cfmoto project used for research is licensed under AGPL-3.0-or-later (it carries both a LICENSE and a NOTICE, and an SPDX header on each source file). That statement replaces an earlier note here that it had no license file, which was true of the snapshot reviewed at the time and is no longer true. Code may therefore flow in either direction under the AGPL, provided the copyright notices and the modification notices required by section 5 travel with it. The influence recorded in the research references above is behavioural — bitrate, source profiles, startup automation, stream recovery — not source. In the other direction, EcBtpProtocol.kt was written here on 2026-08-13 and appears in OpenCfMoto the same day; see the note in that file.
• MOTO-HUB ADVANCED is a separate, closed-source companion application maintained in a private repository. It contains no GPL-3.0 or AGPL-3.0 code — it reaches this repository's T-Box transport and Android Auto receiver exclusively through a documented Binder IPC boundary (apps/android/ipc-contract/, IpcBridgeService), which is why it can be distributed under different terms. ADVANCED requires MOTO-HUB to be installed to function; MOTO-HUB does not require ADVANCED.
• CFMOTO, Voge, Zontes, Moto Morini, MotoFun, Benelli, QJ Motor, Morbidelli, MBP, KOVE, ThinkerRide, EasyConn, Carbit, MotoPlay, Android Auto, Google, and related names remain the property of their respective owners. MOTO-HUB is an independent project and must not imply official support from any of them.

This README documents the project's licensing rationale; it is not a substitute for legal advice.