<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    package="com.stevesoltys.seedvault"
    android:versionCode="30000201"
    android:versionName="11-2.0">
    <!--
    The version code is the targeted SDK_VERSION plus 6 digits for our own version code.
    The version name is the targeted Android version followed by - and our own version name.
    -->

    <uses-permission
        android:name="android.permission.BACKUP"
        tools:ignore="ProtectedPermissions" />

    <!-- This is needed to check for internet access when backup is stored on network storage -->
    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />

    <!-- This is needed to retrieve the available storage roots -->
    <uses-permission
        android:name="android.permission.MANAGE_DOCUMENTS"
        tools:ignore="ProtectedPermissions" />

    <!-- This is needed to access the serial number of USB mass storage devices -->
    <uses-permission
        android:name="android.permission.MANAGE_USB"
        tools:ignore="ProtectedPermissions" />

    <!-- This is needed to change system backup settings -->
    <uses-permission
        android:name="android.permission.WRITE_SECURE_SETTINGS"
        tools:ignore="ProtectedPermissions" />

    <!-- This is needed to re-install backed-up packages when restoring from backup -->
    <uses-permission
        android:name="android.permission.INSTALL_PACKAGES"
        tools:ignore="ProtectedPermissions" />

    <!-- This is needed when using auto-restore with removable storage
         to allow the user to uninstall an app when storage was not plugged in during install -->
    <uses-permission android:name="android.permission.REQUEST_DELETE_PACKAGES" />

    <!-- Getting info about installed packages via PackageManager is restricted since Android 11
         We need to know what is installed, with what signatures, etc. for APK backup,
         triggering manual backup and other tasks -->
    <uses-permission
        android:name="android.permission.QUERY_ALL_PACKAGES"
        tools:ignore="QueryAllPackagesPermission" />

    <application
        android:name=".App"
        android:allowBackup="false"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:roundIcon="@mipmap/ic_launcher_round"
        android:supportsRtl="true"
        android:theme="@style/AppTheme"
        tools:ignore="GoogleAppIndexingWarning">

        <activity
            android:name=".settings.SettingsActivity"
            android:exported="true" />

        <activity
            android:name=".ui.storage.StorageActivity"
            android:theme="@style/AppTheme.NoActionBar" />

        <activity
            android:name=".ui.storage.PermissionGrantActivity"
            android:exported="false"
            android:permission="android.permission.MANAGE_DOCUMENTS" />

        <activity
            android:name=".ui.recoverycode.RecoveryCodeActivity"
            android:label="@string/recovery_code_title"
            android:theme="@style/AppTheme.NoActionBar" />

        <activity
            android:name=".restore.RestoreActivity"
            android:exported="true"
            android:label="@string/restore_title"
            android:theme="@style/AppTheme.NoActionBar">
            <intent-filter>
                <action android:name="com.stevesoltys.seedvault.RESTORE_BACKUP" />
                <category android:name="android.intent.category.DEFAULT" />
            </intent-filter>
        </activity>

        <service
            android:name=".transport.ConfigurableBackupTransportService"
            android:exported="false">
            <intent-filter>
                <action android:name="android.backup.TRANSPORT_HOST" />
            </intent-filter>
        </service>

        <receiver
            android:name=".UsbIntentReceiver"
            android:exported="true">
            <intent-filter>
                <action android:name="android.hardware.usb.action.USB_DEVICE_ATTACHED" />
            </intent-filter>
            <meta-data
                android:name="android.hardware.usb.action.USB_DEVICE_ATTACHED"
                android:resource="@xml/device_filter" />
        </receiver>

        <receiver
            android:name=".restore.RestoreErrorBroadcastReceiver"
            android:exported="false">
            <intent-filter>
                <action android:name="com.stevesoltys.seedvault.action.UNINSTALL" />
            </intent-filter>
        </receiver>

        <!-- Used to start actual BackupService depending on scheduling criteria -->
        <service
            android:name=".storage.StorageBackupJobService"
            android:exported="false"
            android:label="BackupJobService"
            android:permission="android.permission.BIND_JOB_SERVICE" />
        <!-- Does the actual backup work as a foreground service -->
        <service
            android:name=".storage.StorageBackupService"
            android:exported="false"
            android:foregroundServiceType="dataSync"
            android:label="BackupService" />
        <!-- Does restore as a foreground service -->
        <service
            android:name=".storage.StorageRestoreService"
            android:exported="false"
            android:foregroundServiceType="dataSync"
            android:label="RestoreService" />

    </application>
</manifest>
