<?xml version="1.0" encoding="utf-8"?>
<!--
  Copyright (C) 2019 The Android Open Source Project

  Licensed under the Apache License, Version 2.0 (the "License");
  you may not use this file except in compliance with the License.
  You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.
  -->

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.android.car.ui.paintbooth">

  <uses-sdk
      android:minSdkVersion="28"
      android:targetSdkVersion="28"/>

  <uses-permission android:name="android.permission.INTERACT_ACROSS_USERS"/>
  <uses-permission android:name="android.permission.INTERACT_ACROSS_USERS_FULL"/>
  <uses-permission android:name="android.permission.CHANGE_OVERLAY_PACKAGES"/>
  <uses-permission android:name="android.permission.MANAGE_USERS"/>
  <!-- Required to use the TYPE_DISPLAY_OVERLAY layout param for the current activity overlay -->
  <uses-permission android:name="android.permission.INTERNAL_SYSTEM_WINDOW" />
  <!-- Required for listening to android task stack changes -->
  <uses-permission android:name="android.permission.MANAGE_ACTIVITY_STACKS" />
  <uses-permission android:name="android.permission.REAL_GET_TASKS" />
  <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
  <!-- Required for using TYPE_APPLICATION_OVERLAY to display overlays -->
  <uses-permission android:name="android.permission.SYSTEM_ALERT_WINDOW" />
  <!-- Required to test permission dialogs -->
  <uses-permission android:name="android.permission.CAMERA"/>
  <uses-permission android:name="android.permission.READ_CONTACTS"/>
  <uses-permission android:name="android.permission.SEND_SMS"/>
  <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION"/>
  <uses-permission android:name="android.permission.ACCESS_BACKGROUND_LOCATION"/>

  <application
      android:supportsRtl="true"
      android:icon="@drawable/ic_launcher"
      android:label="@string/app_name"
      android:theme="@style/Theme.CarUi.WithToolbar">
    <activity
        android:name=".MainActivity"
        android:exported="true">
      <intent-filter>
        <action android:name="android.intent.action.MAIN"/>
        <category android:name="android.intent.category.LAUNCHER"/>
      </intent-filter>
      <meta-data android:name="distractionOptimized" android:value="true"/>
    </activity>

    <activity
        android:name=".dialogs.DialogsActivity"
        android:exported="false"
        android:parentActivityName=".MainActivity"/>
    <activity
        android:name=".caruirecyclerview.CarUiRecyclerViewActivity"
        android:exported="false"
        android:parentActivityName=".MainActivity"/>
    <activity
        android:name=".caruirecyclerview.GridCarUiRecyclerViewActivity"
        android:exported="false"
        android:parentActivityName=".MainActivity"/>
    <activity
        android:name=".preferences.PreferenceActivity"
        android:exported="false"
        android:parentActivityName=".MainActivity">
      <meta-data android:name="distractionOptimized" android:value="true"/>
    </activity>
    <activity
        android:name=".preferences.SplitPreferenceActivity"
        android:exported="false"
        android:parentActivityName=".MainActivity"/>
    <activity
        android:name=".widescreenime.WideScreenImeActivity"
        android:windowSoftInputMode="stateHidden|adjustNothing"
        android:exported="false"
        android:parentActivityName=".MainActivity">
    </activity>
    <activity
        android:name=".toolbar.ToolbarActivity"
        android:exported="false"
        android:parentActivityName=".MainActivity">
      <meta-data android:name="distractionOptimized" android:value="true"/>
    </activity>
    <activity
        android:name=".toolbar.NoCarUiToolbarActivity"
        android:exported="false"
        android:parentActivityName=".MainActivity"
        android:theme="@style/Theme.AppCompat.Light.NoActionBar"/>
    <activity
        android:name=".toolbar.OldToolbarActivity"
        android:exported="false"
        android:parentActivityName=".MainActivity"
        android:theme="@style/Theme.CarUi"/>
    <activity
        android:name=".overlays.OverlayActivity"
        android:exported="false"
        android:parentActivityName=".MainActivity">
      <meta-data android:name="distractionOptimized" android:value="true"/>
    </activity>
    <activity
        android:name=".widgets.WidgetActivity"
        android:exported="false"
        android:parentActivityName=".MainActivity"/>
    <activity
        android:name=".caruirecyclerview.CarUiListItemActivity"
        android:exported="false"
        android:parentActivityName=".MainActivity"/>

    <service
        android:label="Current Activity Service"
        android:exported="false"
        android:name=".currentactivity.CurrentActivityService"/>
    <service
        android:label="Visible Bounds Simulator"
        android:exported="false"
        android:name=".VisibleBoundsSimulator"/>
  </application>
</manifest>
