android-16.0.0_r2/s

/*
 * 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.
 */
package android.packageinstaller.install.cts

import android.Manifest
import android.app.Activity.RESULT_CANCELED
import android.app.Activity.RESULT_FIRST_USER
import android.app.Activity.RESULT_OK
import android.content.Intent
import android.content.pm.InstallSourceInfo
import android.net.Uri
import android.platform.test.annotations.AppModeFull
import android.platform.test.annotations.RequiresFlagsDisabled
import android.platform.test.flag.junit.CheckFlagsRule
import android.platform.test.flag.junit.DeviceFlagsValueProvider
import android.platform.test.rule.ScreenRecordRule.ScreenRecord
import androidx.test.uiautomator.By
import androidx.test.uiautomator.Until
import com.android.bedstead.harrier.DeviceState
import com.android.bedstead.nene.TestApis
import com.android.bedstead.nene.userrestrictions.CommonUserRestrictions.DISALLOW_INSTALL_APPS
import com.android.bedstead.nene.userrestrictions.CommonUserRestrictions.DISALLOW_INSTALL_UNKNOWN_SOURCES
import com.android.compatibility.common.util.SystemUtil
import com.android.xts.root.annotations.RequireAdbRoot
import com.google.testing.junit.testparameterinjector.TestParameterInjector
import java.util.concurrent.TimeUnit
import org.junit.After
import org.junit.Assert.assertEquals
import org.junit.Assert.assertNotNull
import org.junit.Assert.assertNull
import org.junit.ClassRule
import org.junit.Ignore
import org.junit.Rule
import org.junit.Test
import org.junit.runner.RunWith

@RunWith(TestParameterInjector::class)
@AppModeFull(reason = "Instant apps cannot install packages")
@ScreenRecord
class IntentTest : PackageInstallerTestBase() {

    @get:Rule
    val checkFlagsRule: CheckFlagsRule = DeviceFlagsValueProvider.createCheckFlagsRule()

    companion object {
        // An invalid package name that exceeds the maximum file name length.
        const val LONG_PACKAGE_NAME = "android.packageinstaller.install.cts.invalidname." +
                "27jEBRNRG3ozwBsGr1sVIM9U0bVTI2TdyIyeRkZgW4JrJefwNIBAmCg4AzqXiCvG6JjqA0u" +
                "TCWSFu2YqAVxVdiRKAay19k5VFlSaM7QW9uhvlrLQqsTW01ofFzxNDbp2QfIFHZR6rebKzK" +
                "Bz6byQFM0DYQnYMwFWXjWkMPNdqkRLykoFLyBup53G68k2n8wl27jEBRNRG3ozwBsGr"
        const val NO_INSTALL_APPS_RESTRICTION_TEXT = "This user is not allowed to install apps"
        const val DISABLED_LAUNCHER_ACTIVITY_PKG_NAME =
                "android.packageinstaller.disabledlauncheractivity.cts"
        const val INSTALL_SUCCESS_TEXT = "App installed."
        const val TEST_VERIFIER_APK_NAME = "CtsSufficientVerifierReject.apk"
        const val TEST_VERIFIER_PACKAGE_NAME = "android.packageinstaller.sufficientverifierreject"
        const val TEST_REJECTED_BY_VERIFIER_APK_NAME = "CtsEmptyTestApp_RejectedByVerifier.apk"
        const val TEST_REJECTED_BY_VERIFIER_PACKAGE_NAME =
            "android.packageinstaller.emptytestapp.rejectedbyverifier.cts"
        const val TEST_APK_V2_NAME = "CtsEmptyTestAppV2.apk"

        @JvmField
        @ClassRule
        @Rule
        val deviceState = DeviceState()
    }

    @After
    fun disableSecureFrp() {
        setSecureFrp(false)
    }

    /**
     * Check that we can install an app via a package-installer intent
     */
    @Test
    fun confirmInstallation() {
        val installation = startInstallationViaIntent()
        clickInstallerUIButton(INSTALL_BUTTON_ID)

        // Install should have succeeded
        assertEquals(RESULT_OK, installation.get(GLOBAL_TIMEOUT, TimeUnit.MILLISECONDS))
        assertInstalled()
        var originatingPackageName: String? = null
        SystemUtil.runWithShellPermissionIdentity(
            { originatingPackageName = getInstallSourceInfo().originatingPackageName },
            Manifest.permission.INSTALL_PACKAGES
        )
        assertNotNull(originatingPackageName)
        assertEquals(context.packageName, originatingPackageName)
    }

    /**
     * Install an app via a package-installer intent, but then cancel it when the package installer
     * pops open.
     */
    @Test
    fun cancelInstallation() {
        val installation = startInstallationViaIntent()
        clickInstallerUIButton(CANCEL_BUTTON_ID)

        // Install should have been aborted
        assertEquals(RESULT_CANCELED, installation.get(GLOBAL_TIMEOUT, TimeUnit.MILLISECONDS))
        assertNotInstalled()
    }

    @Test
    fun failedInstallation_requireFailureDialog() {
        installPackage(TEST_APK_V2_NAME)

        // Install a lower version of the same app to trigger an install failure
        // We want the InstallFailed dialog to be visible. Thus, pass EXTRA_RETURN_RESULT as false
        val intent = getInstallationIntent()
        intent.putExtra(Intent.EXTRA_RETURN_RESULT, false)
        val installation = startInstallationViaIntent(intent)

        clickInstallerUIButton(INSTALL_BUTTON_ID)

        // Click the positive button on InstallFailed dialog.
        clickInstallerUIButton(INSTALL_BUTTON_ID)

        assertEquals(RESULT_CANCELED, installation.get(GLOBAL_TIMEOUT, TimeUnit.MILLISECONDS))
    }

    @Test
    fun failedInstallation_noRequireFailureDialog() {
        // The InstallFailed dialog isn't shown here as the default intent used by
        // startInstallationViaIntent contains EXTRA_RETURN_RESULT set to true

        installPackage(TEST_APK_V2_NAME)

        val installation = startInstallationViaIntent()
        clickInstallerUIButton(INSTALL_BUTTON_ID)

        assertEquals(RESULT_FIRST_USER, installation.get(GLOBAL_TIMEOUT, TimeUnit.MILLISECONDS))
    }

    /**
     * Install an app via a package-installer intent, and assign itself as the installer.
     */
    @Test
    fun installWithCallingInstallerPackageName() {
        val intent = getInstallationIntent()
        intent.putExtra(Intent.EXTRA_INSTALLER_PACKAGE_NAME, context.opPackageName)
        val installation = startInstallationViaIntent(intent)
        clickInstallerUIButton(INSTALL_BUTTON_ID)

        // Install should have succeeded, and system will use the given installer package name
        // in EXTRA_INSTALLER_PACKAGE_NAME as the installer.
        assertEquals(RESULT_OK, installation.get(GLOBAL_TIMEOUT, TimeUnit.MILLISECONDS))
        assertEquals(context.opPackageName, getInstallSourceInfo().installingPackageName)
    }

    /**
     * Install an app via a package-installer intent, but assign another package as installer
     * package name.
     */
    @Ignore("b/317736655")
    @Test
    fun installWithAnotherInstallerPackageName() {
        val intent = getInstallationIntent()
        intent.putExtra(Intent.EXTRA_INSTALLER_PACKAGE_NAME, context.opPackageName + ".another")
        val installation = startInstallationViaIntent(intent)
        clickInstallerUIButton(INSTALL_BUTTON_ID)

        // Install should have succeeded, but system won't use the given installer package name
        // in EXTRA_INSTALLER_PACKAGE_NAME as the installer.
        assertEquals(RESULT_OK, installation.get(GLOBAL_TIMEOUT, TimeUnit.MILLISECONDS))
        assertEquals(
            getInstallSourceInfo().initiatingPackageName,
            getInstallSourceInfo().installingPackageName
        )
    }

    /**
     * Install an app via a package-installer intent, but assign an invalid installer
     * package name which exceeds the maximum file name length.
     */
    @Test
    fun installWithLongInstallerPackageName() {
        val intent = getInstallationIntent()
        intent.putExtra(Intent.EXTRA_INSTALLER_PACKAGE_NAME, LONG_PACKAGE_NAME)
        val installation = startInstallationViaIntent(intent)
        clickInstallerUIButton(INSTALL_BUTTON_ID)

        // Install should have succeeded, but system won't use the given installer package name
        // in EXTRA_INSTALLER_PACKAGE_NAME as the installer.
        assertEquals(RESULT_OK, installation.get(GLOBAL_TIMEOUT, TimeUnit.MILLISECONDS))
        assertEquals(
            getInstallSourceInfo().initiatingPackageName,
            getInstallSourceInfo().installingPackageName
        )
    }

    /**
     * Make sure that an already installed app can be reinstalled via a "package" uri
     */
    @Test
    fun reinstallViaPackageUri() {
        // Regular install
        confirmInstallation()

        // Reinstall
        val intent = Intent(Intent.ACTION_INSTALL_PACKAGE)
        intent.data = Uri.fromParts("package", TEST_APK_PACKAGE_NAME, null)
        intent.putExtra(Intent.EXTRA_RETURN_RESULT, true)
        intent.flags = Intent.FLAG_GRANT_READ_URI_PERMISSION

        val reinstall = installDialogStarter.activity.startActivityForResult(intent)

        clickInstallerUIButton(INSTALL_BUTTON_ID)

        // Install should have succeeded
        assertEquals(RESULT_OK, reinstall.get(GLOBAL_TIMEOUT, TimeUnit.MILLISECONDS))
        assertInstalled()
    }

    /**
     * Check that we can't install an app via a package-installer intent if Secure FRP is enabled
     */
    @Test
    @RequiresFlagsDisabled(android.security.Flags.FLAG_FRP_ENFORCEMENT)
    fun packageNotInstalledSecureFrp() {
        setSecureFrp(true)
        try {
            val installation = startInstallationViaIntent()
            clickInstallerUIButton(INSTALL_BUTTON_ID)

            // Install should not have succeeded
            assertNotInstalled()
        } finally {
            setSecureFrp(false)
        }
    }

    @Test
    @RequireAdbRoot(reason = "b/322830652 Required for TestApis to set user restriction")
    fun disallowInstallApps_installFails() {
        try {
            TestApis.devicePolicy().userRestrictions().set(DISALLOW_INSTALL_APPS, true)

            val installation = startInstallationViaIntent()

            assertNotNull(
                "Error dialog not shown",
                uiDevice.wait(
                    Until.findObject(By.text(NO_INSTALL_APPS_RESTRICTION_TEXT)),
                    GLOBAL_TIMEOUT
                )
            )
            clickInstallerUIButton(INSTALL_BUTTON_ID)

            assertEquals(RESULT_CANCELED, installation.get(GLOBAL_TIMEOUT, TimeUnit.MILLISECONDS))
        } finally {
            TestApis.devicePolicy().userRestrictions().set(DISALLOW_INSTALL_APPS, false)
        }
    }

    @Test
    @RequireAdbRoot(reason = "b/322830652 Required for TestApis to set user restriction")
    fun disallowInstallApps_installFromTrustedSource_installFails() {
        try {
            TestApis.devicePolicy().userRestrictions().set(DISALLOW_INSTALL_APPS, true)

            instrumentation.uiAutomation.adoptShellPermissionIdentity(
                Manifest.permission.INSTALL_PACKAGES
            )
            var installation = startInstallationViaIntent()

            assertNotNull(
                "Error dialog not shown",
                uiDevice.wait(
                    Until.findObject(By.text(NO_INSTALL_APPS_RESTRICTION_TEXT)),
                    GLOBAL_TIMEOUT
                )
            )
            clickInstallerUIButton(INSTALL_BUTTON_ID)

            assertEquals(RESULT_CANCELED, installation.get(GLOBAL_TIMEOUT, TimeUnit.MILLISECONDS))
        } finally {
            TestApis.devicePolicy().userRestrictions().set(DISALLOW_INSTALL_APPS, false)
            instrumentation.uiAutomation.dropShellPermissionIdentity()
        }
    }

    @Test
    @RequireAdbRoot(reason = "b/322830652 Required for TestApis to set user restriction")
    fun disallowInstallUnknownSources_installFromTrustedSource_installSucceeds() {
        try {
            TestApis.devicePolicy().userRestrictions().set(DISALLOW_INSTALL_UNKNOWN_SOURCES, true)

            instrumentation.uiAutomation.adoptShellPermissionIdentity(
                Manifest.permission.INSTALL_PACKAGES
            )
            var installation = startInstallationViaIntent()

            clickInstallerUIButton(INSTALL_BUTTON_ID)

            assertEquals(RESULT_OK, installation.get(GLOBAL_TIMEOUT, TimeUnit.MILLISECONDS))
        } finally {
            TestApis.devicePolicy().userRestrictions().set(DISALLOW_INSTALL_UNKNOWN_SOURCES, false)
            instrumentation.uiAutomation.dropShellPermissionIdentity()
        }
    }

    @Test
    fun launcherActivityDisabled_cannotLaunchApp() {
        val intent = Intent(Intent.ACTION_INSTALL_PACKAGE)
        intent.data = Uri.fromParts("package", DISABLED_LAUNCHER_ACTIVITY_PKG_NAME, null)
        intent.putExtra(Intent.EXTRA_RETURN_RESULT, false)
        intent.flags = Intent.FLAG_GRANT_READ_URI_PERMISSION

        startInstallationViaIntent(intent)
        clickInstallerUIButton(INSTALL_BUTTON_ID)

        // Wait for success dialog
        assertNotNull(
            "Success dialog not shown",
            uiDevice.wait(Until.findObject(By.text(INSTALL_SUCCESS_TEXT)), GLOBAL_TIMEOUT)
        )

        // Since the dialog is already visible, no need to wait for long for the "Open" button.
        assertNull(
            "Open button should not be shown",
            uiDevice.wait(Until.findObject(getBySelector(INSTALL_BUTTON_ID)), 5000)
        )
    }

    /**
     * Using a sufficient verifier, test whether InstallFailed dialog is shown when the sufficient
     * verifier rejects installation of a test app.
     */
    @Test
    fun installRejectedByVerifier_installFailedVisible() {
        uninstallPackage(TEST_VERIFIER_PACKAGE_NAME)
        uninstallPackage(TEST_REJECTED_BY_VERIFIER_PACKAGE_NAME)

        installPackage(TEST_VERIFIER_APK_NAME)
        assertInstalled(TEST_VERIFIER_PACKAGE_NAME)

        // We want the InstallFailed dialog to be visible. Thus, pass EXTRA_RETURN_RESULT as false
        val installIntent = getInstallationIntent(TEST_REJECTED_BY_VERIFIER_APK_NAME)
        installIntent.putExtra(Intent.EXTRA_RETURN_RESULT, false)

        val installation = startInstallationViaIntent(installIntent)
        clickInstallerUIButton(INSTALL_BUTTON_ID)

        // Click the positive button on the InstallFailed dialog
        clickInstallerUIButton(INSTALL_BUTTON_ID)

        assertEquals(RESULT_CANCELED, installation.get(GLOBAL_TIMEOUT, TimeUnit.MILLISECONDS))
        assertNotInstalled(TEST_REJECTED_BY_VERIFIER_PACKAGE_NAME)
    }

    private fun getInstallSourceInfo(): InstallSourceInfo {
        return pm.getInstallSourceInfo(TEST_APK_PACKAGE_NAME)
    }
}