<?xml version="1.0" encoding="utf-8"?>
<!--
  ~ Copyright (C) 2018 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"
     xmlns:tools="http://schemas.android.com/tools"
     package="com.android.tv.tuner.sample.network">

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

    <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION"/>
    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/>
    <uses-permission android:name="android.permission.INTERNET"/>
    <uses-permission android:name="android.permission.READ_CONTENT_RATING_SYSTEMS"/>
    <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>
    <uses-permission android:name="android.permission.READ_TV_LISTINGS"/>
    <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED"/>
    <uses-permission android:name="com.android.providers.tv.permission.READ_EPG_DATA"/>
    <uses-permission android:name="com.android.providers.tv.permission.WRITE_EPG_DATA"/>
    <!-- Permission to modify Recorded Program -->
    <uses-permission android:name="com.android.providers.tv.permission.ACCESS_ALL_EPG_DATA"/>

    <!-- Permissions/feature for USB tuner -->
    <uses-permission android:name="android.permission.DVB_DEVICE"/>

    <uses-feature android:name="android.hardware.usb.host"
         android:required="false"/>

    <!-- Limit only for Android TV -->
    <uses-feature android:name="android.software.leanback"
         android:required="true"/>
    <uses-feature android:name="android.software.live_tv"
         android:required="true"/>
    <uses-feature android:name="android.hardware.touchscreen"
         android:required="false"/>

    <application tools:replace="android:appComponentFactory"
         android:name="com.android.tv.tuner.sample.network.app.SampleNetworkTuner"
         android:appComponentFactory="android.support.v4.app.CoreComponentFactory"
         android:icon="@mipmap/ic_launcher"
         android:label="@string/sample_network_tuner_app_name">

        <activity android:name="com.android.tv.tuner.sample.network.setup.SampleNetworkTunerSetupActivity"
             android:configChanges="keyboard|keyboardHidden"
             android:exported="true"
             android:label="@string/sample_network_tuner_app_name"
             android:launchMode="singleInstance"
             android:theme="@style/Theme.Setup.GuidedStep">
            <intent-filter>
                <action android:name="android.intent.action.MAIN"/>
            </intent-filter>
        </activity>

        <service android:name="com.android.tv.tuner.sample.network.tvinput.SampleNetworkTunerTvInputService"
             android:label="@string/sample_network_tuner_app_name"
             android:permission="android.permission.BIND_TV_INPUT"
             android:process="com.android.tv.tuner.sample.network.tvinput"
             android:exported="true">
            <intent-filter>
                <action android:name="android.media.tv.TvInputService"/>
            </intent-filter>

            <meta-data android:name="android.media.tv.input"
                 android:resource="@xml/sample_network_tvinputservice"/>
        </service>
        <service android:name="com.android.tv.tuner.tvinput.TunerStorageCleanUpService"
             android:exported="false"
             android:permission="android.permission.BIND_JOB_SERVICE"
             android:process="com.android.tv.tuner"/>
    </application>

</manifest>
