Skip to main content
skill CX Codex

android-for-cars-parked-apps — Claude Code skill: install & guide

android-for-cars-parked-apps — a skill for Claude Code adapts existing Android video apps, games, and web browsers for parked use on Android Auto and Android Automotive OS.

Apache-2.0 537 installs ★ 10,691 updated 2026-11-11

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add android/skills --skill android-for-cars-parked-apps -a claude-code
Open on GitHub

What android-for-cars-parked-apps does

The skill adjusts AndroidManifest.xml, declares Google Play hardware flags, and sets application categories for parked car scenarios. Games target both Android Auto and Android Automotive OS, while video and browser categories apply to Automotive OS.

It covers handling WindowInsets, maintaining display state across cutouts via configChanges, and restricting media playback with CarUxRestrictionsManager. Android Auto apps receive the CAR_LAUNCHER intent filter, while Automotive OS tracks require the android.hardware.type.automotive declaration.

Standalone audio streaming, navigation tools, and Car App Library templates are unsupported. The workflow relies on an existing adaptive Android project.

What it helps with

  • configure AndroidManifest.xml declarations for parked car modes
  • handle display continuity across vehicle screen changes
  • enforce CarUxRestrictionsManager playback pauses while driving
  • audit browser or game compliance against Car App Quality rules

Example prompts for the agent

  • Audit our AndroidManifest.xml for Android Automotive OS video requirements
  • Configure configChanges and WindowInsets for our game on Android Auto
  • Add CarUxRestrictionsManager checks to halt video playback when driving

How to install android-for-cars-parked-apps

1Skills CLI (Vercel)

npx skills add android/skills --skill android-for-cars-parked-apps -a claude-code

2Manually: put the files in place

~/.claude/skills/android-for-cars-parked-apps/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/android-for-cars-parked-apps/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about android-for-cars-parked-apps

How to install android-for-cars-parked-apps in Claude Code?

Run npx skills add android/skills --skill android-for-cars-parked-apps -a claude-code or save the definition file at ~/.claude/skills/android-for-cars-parked-apps/SKILL.md.

What does android-for-cars-parked-apps do?

It prepares adaptive Android video services, browsers, and games to satisfy Google Play Car App Quality guidelines for parked vehicles.

What is required before using android-for-cars-parked-apps?

You need an existing adaptive Android codebase in the video streaming, game, or web browser category.

Source text

SKILL.md · Apache-2.0
---
name: android-for-cars-parked-apps
description: Adapt existing Android video streaming apps, games, and web browsers
  to run as parked apps on Android Auto and Android Automotive OS. Covers manifest
  configuration, Google Play hardware feature declarations, compatibility mode, back
  navigation affordances, orientation and display continuity, controllable system
  bar insets, irregular display cutouts, driver distraction lifecycle handling, MediaSession
  playback restrictions with CarUxRestrictionsManager, background audio while driving,
  and browser sensitive data protection. Use this skill when migrating, building,
  or auditing parked apps for cars to meet Car App Quality guidelines. Don't use for
  media audio apps, templated Car App Library navigation, point of interest, internet
  of things, weather, or communication apps designed for use while driving.
license: Complete terms in LICENSE.txt
metadata:
  author: Google LLC
  last-updated: '2026-11-07'
  keywords:
  - Android Auto
  - Android Automotive OS
  - parked apps
  - video
  - games
  - browsers
  - adaptive
---

Adapt existing Android video apps, games, and web browsers to run as parked
apps on Android Auto and Android Automotive OS. Follow these steps to meet the
car app quality guidelines for Google Play distribution.

## Prerequisites

- Begin with an existing adaptive Android app in one of the supported parked app categories: video streaming apps, games, or web browsers.

## Glossary

- **Parked apps**: Parked apps run on Android Auto and Android Automotive OS only while the vehicle is parked. The three parked categories are video, games, and browsers; other categories can't be published as parked apps.
- **Android Auto**: Android Auto is a phone-powered projection system. Apps execute on the user's phone and are projected to the in-car display over a wired or wireless connection. Android Auto is a separate platform from Android Automotive OS.
- **Android Automotive OS**: Android Automotive OS, or AAOS, is a variant of Android that runs directly on the vehicle itself. Android Automotive OS is a separate platform from Android Auto.
- **Video category**: Video apps display streaming videos while parked. Generally available on Android Automotive OS; unsupported on Android Auto.
- **Games category**: Game apps provide gameplay while parked. Generally available on Android Automotive OS and Android Auto.
- **Browsers category**: Web browsers let users browse the web while parked. Available in beta on Android Automotive OS; unsupported on Android Auto.
- **Media category**: Not a parked category. Media apps play audio content (music, radio, audiobooks, excluding video) while driving or parked.
- **Android for Cars platform**: Android for Cars is an umbrella term that consists of Android Auto and Android Automotive OS.
- **Generally available categories**: Permitted on internal testing, closed testing, open testing, and production Google Play tracks for a supported platform.
- **Beta categories**: Permitted on internal or closed testing tracks; open testing and production tracks require acceptance into an early access program.
- **Audio while driving**: A beta feature on Android Automotive OS that lets video apps play audio while the vehicle is in motion.
- **Car app quality guidelines** : When auditing an app against the Tier 3 (*Car ready* ), Tier 2 (*Car optimized* ), or Tier 1 (*Car differentiated* ) criteria, **MUST** check [car app quality guidelines](references/android/docs/quality-guidelines/car-app-quality/index.md).
- **Android Automotive OS compatibility mode** : Compatibility mode (`android.software.car.display_compatibility`) is a system feature on select vehicles providing a system back affordance, safe area rendering, density scaling, and opaque driving-mode blocking (moving activities to *Stopped*). Compatibility mode is only relevant to apps that support Android Automotive OS; it isn't relevant for apps that only support Android Auto.

## Codebase exploration

Search the codebase for `AndroidManifest.xml` (or create
`Assets/Plugins/Android/AndroidManifest.xml` in Unity projects),
`res/xml/automotive_app_desc.xml`, `build.gradle`, `build.gradle.kts`,
or `gradle/libs.versions.toml` files. Locate existing video players,
`MediaSession` classes, `requestedOrientation` calls, and `WindowInsets`
handlers. Unless instructed otherwise by the user, ask permission before adding
dependencies.

## Step 1: Configure the app manifest

Declare the app category, target platforms, hardware feature requirements, and
activity configuration in `AndroidManifest.xml`.

### 1.1: Identify the app category

- **Video apps** : Video apps **MUST** set `android:appCategory="video"` on `<application>` and **MUST NOT** include `app/src/main/res/xml/automotive_app_desc.xml` with `uses name="video"`.
- **Games** : Games **MUST** set `android:appCategory="game"` on `<application>`. Declare `android.hardware.gamepad` with `android:required="false"` if controller input is supported by the app.
- **Browsers** : Browsers **MUST** include `<category
  android:name="android.intent.category.APP_BROWSER"/>` in the `MAIN` `<intent-filter>` of an exported `<activity>` (`android:exported="true"`).

### 1.2: Identify target platforms and hardware features

- **Android Auto** : Apps targeting Android Auto (Android 15+) **MUST** add `<category android:name="android.intent.category.CAR_LAUNCHER"/>` to an `<intent-filter>` in the `AndroidManifest.xml` file. Add it to the `MAIN` `<intent-filter>` unless the user specifies a different intent filter. **NEVER** add this category if the app is solely targeting Android Automotive OS.
- **Android Automotive OS** : Apps targeting Android Automotive OS **MUST** declare `<uses-feature android:name="android.hardware.type.automotive"
  android:required="false"/>` (`"false"` for mobile or multi-form-factor tracks; `"true"` only if the app will be published on the dedicated Automotive OS track) in the `AndroidManifest.xml` file. **NEVER** add this feature tag if the app is solely targeting Android Auto.
- **Unrequired hardware features (`DO-1`)** : To satisfy Google Play feature requirements and `DO-1`, declare unsupported features (`android.hardware.wifi`, `android.hardware.screen.portrait`, `android.hardware.screen.landscape`, `android.hardware.camera`) with `android:required="false"`, and remove `android:required="true"` on features absent in cars.
- **Display continuity (`LS-C1`)** : Configure `android:configChanges` for `screenSize`, `smallestScreenSize`, `orientation`, `screenLayout`, and `density` on `<activity>` so moving to or from a distant display does not recreate the activity or stutter playback.
- **Compatibility mode and distraction** : Declaring compatibility mode is optional and is only relevant for apps that support Android Automotive OS. **NEVER** add compatibility mode for apps that only support Android Auto. Adding `android.hardware.type.automotive` disables compatibility mode unless `<meta-data android:name="android.software.car.display_compatibility"
  android:value="true"/>` is added to `<application>`. When an app declares `android.software.car.display_compatibility` in `AndroidManifest.xml`, the app **MUST** check `PackageManager.hasSystemFeature("android.software.car.display_compatibility")` at runtime and hide duplicate in-app back or close affordances when it returns `true`. Parked apps **MUST NOT** include `<meta-data android:name="distractionOptimized" android:value="true"/>` on any `<activity>` (`DD-2`, `DD-3`).

## Step 2: Provide back navigation and orientation support

### 2.1: Add in-app back and close affordances

Android Automotive OS vehicles aren't required to have a hardware or software
back button or gesture navigation (`AN-1`). Provide explicit UI back and close
controls on every non-root screen, including detail screens and full-screen
players:

- **If `AndroidManifest.xml` does not declare
  `android.software.car.display_compatibility`**: Display explicit in-app back and close controls unconditionally.
- **If `AndroidManifest.xml` declares
  `android.software.car.display_compatibility` with `android:value="true"`** : Show in-app back and close controls only when `PackageManager.hasSystemFeature("android.software.car.display_compatibility")` returns `false`.

### 2.2: Guard runtime orientation requests

Vehicle displays have fixed orientations. Requesting landscape on a
fixed-portrait car display causes letterboxing or flickering loops (`DO-1`).
Remove hardcoded `android:screenOrientation` manifest attributes and check
`PackageManager.FEATURE_SCREEN_LANDSCAPE` and
`PackageManager.FEATURE_SCREEN_PORTRAIT` before setting `requestedOrientation`.

## Step 3: Adapt to system bars and irregular display cutouts

### 3.1: Track controllable system bar insets

On Android Automotive OS, OEMs are permitted to lock system bars visible so
climate and vehicle controls remain accessible (`AR-1`). Track controllable
insets with `OnControllableInsetsChangedListener`, hide only controllable bars,
and apply `windowInsetsPadding` for uncontrollable `statusBars`,
`navigationBars`, and `displayCutout` insets.

### 3.2: Render into irregular display cutouts safely

To meet Tier 1 criterion `AR-2` on curved or non-rectangular car displays,
**NEVER** use `LAYOUT_IN_DISPLAY_CUTOUT_MODE_DEFAULT` (`0`) or
`LAYOUT_IN_DISPLAY_CUTOUT_MODE_SHORT_EDGES` (`1`). Configure
`LAYOUT_IN_DISPLAY_CUTOUT_MODE_ALWAYS` (`3`) or
`LAYOUT_IN_DISPLAY_CUTOUT_MODE_NEVER` (`2`) using the `car` resource qualifier
in `res/values-car-v30/integers.xml`:


```xml
<integer name="windowLayoutInDisplayCutoutMode">3</integer>
```

<br />

Protect interactive UI, app bars, and scrollable lists with
`WindowInsets.safeDrawing`.

## Step 4: Meet driver distraction and media playback requirements

### 4.1: Pause playback on lifecycle transitions and block driving resumption

When a vehicle begins moving, the OS covers parked activities with a blocking
overlay and triggers `onPause` (and `onStop` on compatibility mode vehicles). To
satisfy `DD-2`, `DD-3`, and `MC-1`:

1. Pause playback on `ON_PAUSE` or `ON_STOP` using `LifecycleEventEffect` from `androidx.lifecycle:lifecycle-runtime-compose`.
2. Expose a `MediaSession` (`androidx.media3:media3-session`) with play, pause, or stop commands and item metadata (`MC-1`), and release it in `onCleared`.
3. Add `useLibrary("android.car")` in `build.gradle.kts` and wrap `ExoPlayer` in `ForwardingSimpleBasePlayer`. Retain the `Car` instance from `Car.createCar(context)`, listen to `CarUxRestrictionsManager`, and pause playback when `isRequiresDistractionOptimization` becomes `true`. Remove `COMMAND_PLAY_PAUSE` in `getState` while driving, and unregister the listener and call `car.disconnect()` in `handleRelease()`:


```kotlin
@UnstableApi
class CarAwarePlayer(context: Context) :
    ForwardingSimpleBasePlayer(ExoPlayer.Builder(context).build()) {
    private var shouldPreventPlay = false
    private var pausedByUxRestrictions = false
    private lateinit var carUxRestrictionsManager: CarUxRestrictionsManager

    init {
        if (context.packageManager.hasSystemFeature(PackageManager.FEATURE_AUTOMOTIVE)) {
            val car = Car.createCar(context)
            carUxRestrictionsManager =
                car.getCarManager(Car.CAR_UX_RESTRICTION_SERVICE) as CarUxRestrictionsManager
            shouldPreventPlay =
                carUxRestrictionsManager.currentCarUxRestrictions.isRequiresDistractionOptimization
            invalidateState()

            carUxRestrictionsManager.registerListener { restrictions: CarUxRestrictions ->
                shouldPreventPlay = restrictions.isRequiresDistractionOptimization
                if (!shouldPreventPlay && pausedByUxRestrictions) {
                    handleSetPlayWhenReady(true)
                    invalidateState()
                } else if (shouldPreventPlay && isPlaying) {
                    pausedByUxRestrictions = true
                    handleSetPlayWhenReady(false)
                    invalidateState()
                }
            }
        }
    }

    override fun getState(): State {
        val state = super.getState()
        return state.buildUpon()
            .setAvailableCommands(
                state.availableCommands.buildUpon()
                    .removeIf(COMMAND_PLAY_PAUSE, shouldPreventPlay)
                    .build()
            )
            .build()
    }

    override fun handleRelease(): ListenableFuture<*> {
        if (::carUxRestrictionsManager.isInitialized) {
            carUxRestrictionsManager.unregisterListener()
        }
        return super.handleRelease()
    }
}
```

<br />

### 4.2: Support background audio while driving (optional beta feature)

Because this is an optional beta feature, **NEVER** implement this feature
unless the user requests it. To implement the feature:

1. Declare `<uses-feature
   android:name="com.android.car.background_audio_while_driving"
   android:required="false" />` in `AndroidManifest.xml`, along with `FOREGROUND_SERVICE` and `FOREGROUND_SERVICE_MEDIA_PLAYBACK` permissions.
2. Check runtime vehicle support with `CarFeatures.isFeatureEnabled(context,
   CarFeatures.FEATURE_BACKGROUND_AUDIO_WHILE_DRIVING)` from `androidx.car.app:app`. Only set `shouldPreventPlay` when `!isBackgroundAudioWhileDrivingSupported &&
   restrictions.isRequiresDistractionOptimization`.
3. Host the `MediaSession` and player inside an exported `MediaSessionService` with `android:foregroundServiceType="mediaPlayback"`, and connect from the UI using `MediaController.Builder` and `buildAsync`.

## Step 5: Protect sensitive data in browser apps

Because vehicles are shared devices, browsers **MUST** block access to
saved passwords and payment methods unless protected by a profile lock (`SD-1`).
Before syncing passwords or payment data to the vehicle, browsers **MUST**
prompt the user to authenticate and display a notice on the car screen stating
that their data will be synchronized to the car (`SD-2`).

Check whether a PIN, pattern, or password is set using `KeyguardManager`, and
open `Settings.ACTION_SECURITY_SETTINGS` if unset. Initialize `BiometricPrompt`
with a `FragmentActivity` (or `Fragment`),
`ContextCompat.getMainExecutor(context)`, and an `AuthenticationCallback`.
Authenticate using
`BiometricManager.Authenticators.DEVICE_CREDENTIAL` only (vehicles don't have
biometric hardware):


```kotlin
val keyguardManager = context.getSystemService<KeyguardManager>()
val isDeviceSecure = keyguardManager?.isDeviceSecure == true
lateinit var biometricPrompt: BiometricPrompt

if (!isDeviceSecure) {
    context.startActivity(
        Intent(Settings.ACTION_SECURITY_SETTINGS).addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
    )
} else {
    val promptInfo = BiometricPrompt.PromptInfo.Builder()
        .setTitle(context.getString(R.string.auth_title))
        .setSubtitle(context.getString(R.string.sync_data_to_car_notice))
        .setAllowedAuthenticators(BiometricManager.Authenticators.DEVICE_CREDENTIAL)
        .build()
    biometricPrompt.authenticate(promptInfo)
}
```

<br />

## Step 6: Verify implementation

Build the app using `./gradlew assembleDebug`. Find and fix any build errors.

## Post-implementation guidance

Provide this guidance to the user after implementation:

- For Android Auto apps, install the app on a phone and test using the Desktop Head Unit (DHU).
- For Android Automotive OS, install the app on the Android Automotive OS emulator in Android Studio.
- If the app is in a beta category for the target platform, acceptance into the early access program is required before submitting the app to an open testing or production track.
- If the app implements the beta audio while driving feature, acceptance into the early access program is required before submitting the app to an open testing or production track.
- Test the app against the relevant criteria in the car app quality guidelines before submitting the app.

## Antipatterns

- **NEVER** include `<meta-data android:name="distractionOptimized"
  android:value="true"/>` on any `<activity>` in a parked app, or include `res/xml/automotive_app_desc.xml` with `uses name="video"` in a video app.
- **NEVER** assume a hardware or software back button exists on Android Automotive OS.
- **NEVER** assume system bars are positioned only at the top and bottom or can always be hidden.
- **NEVER** use `LAYOUT_IN_DISPLAY_CUTOUT_MODE_DEFAULT` or `LAYOUT_IN_DISPLAY_CUTOUT_MODE_SHORT_EDGES` on Android Automotive OS.
- **NEVER** infer UX restrictions from vehicle speed or gear state instead of reading `isRequiresDistractionOptimization` from `CarUxRestrictionsManager`.
- **NEVER** use biometric authenticators (`BIOMETRIC_STRONG`, `BIOMETRIC_WEAK`) with `BiometricPrompt` on browser apps on Android Automotive OS; use `DEVICE_CREDENTIAL` only.
- **NEVER** add the `CAR_LAUNCHER` intent category if the user only requests Android Automotive OS support.
- **NEVER** add the `android.hardware.type.automotive` feature tag if the user only requests Android Auto support.

## Best practices

- **MUST** declare `android:required="false"` on unsupported hardware features (`wifi`, `screen.portrait`, `screen.landscape`, `camera`) and guard `requestedOrientation` calls by checking `FEATURE_SCREEN_LANDSCAPE` and `FEATURE_SCREEN_PORTRAIT` (`DO-1`).
- **MUST** provide in-app back and close affordances (`AN-1`) for Android Automotive OS when not in compatibility mode and protect all interactive UI and text from system bars and display cutouts using `WindowInsets.safeDrawing` and `OnControllableInsetsChangedListener` (`AR-1`, `AR-2`).
- **MUST** pause playback when UX restrictions become active and strip `COMMAND_PLAY_PAUSE` from `MediaSession` while driving unless audio while driving is supported and enabled (`DD-2`, `DD-4`, `MC-1`).
- **MUST** require profile lock authentication and display an on-screen sync disclosure before saving, accessing, or syncing browser passwords or payment information (`SD-1`, `SD-2`).

© Google LLC · Apache-2.0 · android/skills

Similar skills

All skills for Mobile →

From the same set36

The whole set →
anr-audit-and-fix The anr-audit-and-fix Claude Code skill finds ANR risks in Android projects and examines ANR stack dumps. Run it to inspect blocking calls or investigate an unresponsive app. CX Codex +1 694installs glance-canonical-layouts Generates home screen widgets using Jetpack Glance canonical layouts from Android Platform Samples. Activates when adding checklist, action list, or grid widget patterns. CX Codex +1 599installs litert-runtime litert-runtime walks through Kotlin code and Gradle setup for running .tflite models on Android with the CompiledModel API. Covers CPU and GPU inference, buffer reuse, preprocessing, and migration from the legacy TFLite stack. CX Codex +1 558installs wear-widgets wear-widgets — a skill that builds, migrates, and checks Wear OS widgets using Glance Wear and Remote Compose. It steps in when an Android project needs a new widget, a TileService migration, or a review of an existing implementation. CX Codex +1 544installs litert-lm This Claude Code skill guides Android app work with on-device text language models. It covers chat, summarization, and extraction through LiteRT-LM. CX Codex +1 451installs projected-hardware The projected-hardware Claude Code skill explains how Android apps access hardware on Android XR glasses. It covers camera and microphone permissions, device connections, and audio routing. CX Codex +1 444installs glance-appwidget-updates-and-memory glance-appwidget-updates-and-memory — a Claude Code skill for updating Android AppWidgets built with Jetpack Glance and keeping their images within memory limits. It covers widget setup, state sync, and crash fixes. CX Codex +1 400installs ink-app-builder The ink-app-builder Claude Code skill adds stylus and touch drawing to Android apps with Jetpack Ink and Compose. It activates for drawing surfaces, stroke rendering, erasing, undo history, or stroke storage. CX Codex +1 387installs

Project sponsors

Companies that keep this analytics open