android/carrierdefaultapp/SlicePurchaseBroadcastReceiver.java

/*
 * Copyright (C) 2022 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 com.android.carrierdefaultapp;

import android.annotation.NonNull;
import android.annotation.Nullable;
import android.app.Notification;
import android.app.NotificationChannel;
import android.app.NotificationManager;
import android.app.PendingIntent;
import android.content.BroadcastReceiver;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.res.Configuration;
import android.content.res.Resources;
import android.graphics.drawable.Icon;
import android.os.LocaleList;
import android.os.SystemProperties;
import android.os.UserHandle;
import android.telephony.AnomalyReporter;
import android.telephony.SubscriptionManager;
import android.telephony.TelephonyManager;
import android.text.TextUtils;
import android.util.Log;
import android.webkit.URLUtil;
import android.webkit.WebView;

import com.android.internal.annotations.VisibleForTesting;
import com.android.phone.slice.SlicePurchaseController;

import java.net.MalformedURLException;
import java.net.URISyntaxException;
import java.net.URL;
import java.util.HashMap;
import java.util.Locale;
import java.util.Map;
import java.util.UUID;

/**
 * The SlicePurchaseBroadcastReceiver listens for
 * {@link SlicePurchaseController#ACTION_START_SLICE_PURCHASE_APP} from the SlicePurchaseController
 * in the phone process to start the slice purchase application. It displays the performance boost
 * notification to the user and will start the {@link SlicePurchaseActivity} to display the
 * {@link WebView} to purchase performance boosts from the user's carrier.
 */
public class SlicePurchaseBroadcastReceiver extends BroadcastReceiver{
    private static final String TAG = "SlicePurchaseBroadcastReceiver";

    /**
     * UUID to report an anomaly when receiving a PendingIntent from an application or process
     * other than the Phone process.
     */
    private static final String UUID_BAD_PENDING_INTENT = "c360246e-95dc-4abf-9dc1-929a76cd7e53";

    /** Channel ID for the performance boost notification. */
    private static final String PERFORMANCE_BOOST_NOTIFICATION_CHANNEL_ID = "performance_boost";
    /** Tag for the performance boost notification. */
    public static final String PERFORMANCE_BOOST_NOTIFICATION_TAG = "SlicePurchaseApp.Notification";
    /**
     * Action for when the user clicks the "Not now" button on the performance boost notification.
     */
    private static final String ACTION_NOTIFICATION_CANCELED =
            "com.android.phone.slice.action.NOTIFICATION_CANCELED";

    /**
     * A map of Intents sent by {@link SlicePurchaseController} for each capability.
     * If this map contains an Intent for a given capability, the performance boost notification to
     * purchase the capability is visible to the user.
     * If this map does not contain an Intent for a given capability, either the capability was
     * never requested or the {@link SlicePurchaseActivity} is visible to the user.
     * An Intent is added to this map when the performance boost notification is displayed to the
     * user and removed from the map when the notification is canceled.
     */
    private static final Map<Integer, Intent> sIntents = new HashMap<>();

    /**
     * Cancel the performance boost notification for the given capability and
     * remove the corresponding notification intent from the map.
     *
     * @param context The context to cancel the notification in.
     * @param capability The premium capability to cancel the notification for.
     */
    public static void cancelNotification(@NonNull Context context,
            @TelephonyManager.PremiumCapability int capability) {
        context.getSystemService(NotificationManager.class).cancelAsUser(
                PERFORMANCE_BOOST_NOTIFICATION_TAG, capability, UserHandle.ALL);
        sIntents.remove(capability);
    }

    /**
     * Send the PendingIntent containing the corresponding slice purchase application response.
     *
     * @param intent The Intent containing the PendingIntent extra.
     * @param extra The extra to get the PendingIntent to send.
     */
    public static void sendSlicePurchaseAppResponse(@NonNull Intent intent, @NonNull String extra) {
        PendingIntent pendingIntent = intent.getParcelableExtra(extra, PendingIntent.class);
        if (pendingIntent == null) {
            loge("PendingIntent does not exist for extra: " + extra);
            return;
        }
        try {
            pendingIntent.send();
        } catch (PendingIntent.CanceledException e) {
            loge("Unable to send " + getPendingIntentType(extra) + " intent: " + e);
        }
    }

    /**
     * Send the PendingIntent containing the corresponding slice purchase application response
     * with additional data.
     *
     * @param context The Context to use to send the PendingIntent.
     * @param intent The Intent containing the PendingIntent extra.
     * @param extra The extra to get the PendingIntent to send.
     * @param data The Intent containing additional data to send with the PendingIntent.
     */
    public static void sendSlicePurchaseAppResponseWithData(@NonNull Context context,
            @NonNull Intent intent, @NonNull String extra, @NonNull Intent data) {
        PendingIntent pendingIntent = intent.getParcelableExtra(extra, PendingIntent.class);
        if (pendingIntent == null) {
            loge("PendingIntent does not exist for extra: " + extra);
            return;
        }
        try {
            pendingIntent.send(context, 0 /* unused */, data);
        } catch (PendingIntent.CanceledException e) {
            loge("Unable to send " + getPendingIntentType(extra) + " intent: " + e);
        }
    }

    /**
     * Check whether the Intent is valid and can be used to complete purchases in the slice purchase
     * application. This checks that all necessary extras exist and that the values are valid.
     *
     * @param intent The intent to check.
     * @return {@code true} if the intent is valid and {@code false} otherwise.
     */
    public static boolean isIntentValid(@NonNull Intent intent) {
        int phoneId = intent.getIntExtra(SlicePurchaseController.EXTRA_PHONE_ID,
                SubscriptionManager.INVALID_PHONE_INDEX);
        if (phoneId == SubscriptionManager.INVALID_PHONE_INDEX) {
            loge("isIntentValid: invalid phone index: " + phoneId);
            return false;
        }

        int subId = intent.getIntExtra(SlicePurchaseController.EXTRA_SUB_ID,
                SubscriptionManager.INVALID_SUBSCRIPTION_ID);
        if (subId == SubscriptionManager.INVALID_SUBSCRIPTION_ID) {
            loge("isIntentValid: invalid subscription ID: " + subId);
            return false;
        }

        int capability = intent.getIntExtra(SlicePurchaseController.EXTRA_PREMIUM_CAPABILITY,
                SlicePurchaseController.PREMIUM_CAPABILITY_INVALID);
        if (capability == SlicePurchaseController.PREMIUM_CAPABILITY_INVALID) {
            loge("isIntentValid: invalid premium capability: " + capability);
            return false;
        }

        String purchaseUrl = intent.getStringExtra(SlicePurchaseController.EXTRA_PURCHASE_URL);
        String userData = intent.getStringExtra(SlicePurchaseController.EXTRA_USER_DATA);
        String contentsType = intent.getStringExtra(SlicePurchaseController.EXTRA_CONTENTS_TYPE);
        if (getPurchaseUrl(purchaseUrl, userData, TextUtils.isEmpty(contentsType)) == null) {
            loge("isIntentValid: invalid purchase URL: " + purchaseUrl);
            return false;
        }

        String carrier = intent.getStringExtra(SlicePurchaseController.EXTRA_CARRIER);
        if (TextUtils.isEmpty(carrier)) {
            loge("isIntentValid: empty carrier: " + carrier);
            return false;
        }

        return isPendingIntentValid(intent, SlicePurchaseController.EXTRA_INTENT_CANCELED)
                && isPendingIntentValid(intent, SlicePurchaseController.EXTRA_INTENT_CARRIER_ERROR)
                && isPendingIntentValid(intent, SlicePurchaseController.EXTRA_INTENT_REQUEST_FAILED)
                && isPendingIntentValid(intent,
                        SlicePurchaseController.EXTRA_INTENT_NOT_DEFAULT_DATA_SUBSCRIPTION)
                && isPendingIntentValid(intent,
                        SlicePurchaseController.EXTRA_INTENT_NOTIFICATIONS_DISABLED)
                && isPendingIntentValid(intent, SlicePurchaseController.EXTRA_INTENT_SUCCESS)
                && isPendingIntentValid(intent,
                        SlicePurchaseController.EXTRA_INTENT_NOTIFICATION_SHOWN);
    }

    /**
     * Get the {@link URL} from the given purchase URL String and user data, if it is valid.
     *
     * @param purchaseUrl The purchase URL String to use to create the URL.
     * @param userData The user data parameter from the entitlement server.
     * @param shouldAppendUserData If this is {@code true} and the {@code userData} exists,
     *        the {@code userData} should be appended to the {@code purchaseUrl} to create the URL.
     *        If this is false, only the {@code purchaseUrl} should be used and the {@code userData}
     *        will be sent as data to the POST request instead.
     * @return The URL from the given purchase URL and user data or {@code null} if it is invalid.
     */
    @Nullable public static URL getPurchaseUrl(@Nullable String purchaseUrl,
            @Nullable String userData, boolean shouldAppendUserData) {
        if (purchaseUrl == null) {
            return null;
        }
        // Only append user data if it exists, otherwise just return the purchase URL
        if (!shouldAppendUserData || TextUtils.isEmpty(userData)) {
            return getPurchaseUrl(purchaseUrl);
        }
        URL url = getPurchaseUrl(purchaseUrl + "?" + userData);
        if (url == null) {
            url = getPurchaseUrl(purchaseUrl);
        }
        return url;
    }

    /**
     * Get the {@link URL} from the given purchase URL String, if it is valid.
     *
     * @param purchaseUrl The purchase URL String to use to create the URL.
     * @return The purchase URL from the given String or {@code null} if it is invalid.
     */
    @Nullable private static URL getPurchaseUrl(@Nullable String purchaseUrl) {
        if (!URLUtil.isValidUrl(purchaseUrl)) {
            return null;
        }
        if (URLUtil.isAssetUrl(purchaseUrl)
                && !purchaseUrl.equals(SlicePurchaseController.SLICE_PURCHASE_TEST_FILE)) {
            return null;
        }
        URL url = null;
        try {
            url = new URL(purchaseUrl);
            url.toURI();
        } catch (MalformedURLException | URISyntaxException e) {
            loge("Invalid purchase URL: " + purchaseUrl + ", " + e);
        }
        return url;
    }

    private static boolean isPendingIntentValid(@NonNull Intent intent, @NonNull String extra) {
        String intentType = getPendingIntentType(extra);
        PendingIntent pendingIntent = intent.getParcelableExtra(extra, PendingIntent.class);
        if (pendingIntent == null) {
            loge("isPendingIntentValid: " + intentType + " intent not found.");
            return false;
        }
        String creatorPackage = pendingIntent.getCreatorPackage();
        if (!creatorPackage.equals(TelephonyManager.PHONE_PROCESS_NAME)) {
            String logStr = "isPendingIntentValid: " + intentType + " intent was created by "
                    + creatorPackage + " instead of the phone process.";
            loge(logStr);
            AnomalyReporter.reportAnomaly(UUID.fromString(UUID_BAD_PENDING_INTENT), logStr);
            return false;
        }
        if (!pendingIntent.isBroadcast()) {
            loge("isPendingIntentValid: " + intentType + " intent is not a broadcast.");
            return false;
        }
        return true;
    }

    @NonNull private static String getPendingIntentType(@NonNull String extra) {
        switch (extra) {
            case SlicePurchaseController.EXTRA_INTENT_CANCELED: return "canceled";
            case SlicePurchaseController.EXTRA_INTENT_CARRIER_ERROR: return "carrier error";
            case SlicePurchaseController.EXTRA_INTENT_REQUEST_FAILED: return "request failed";
            case SlicePurchaseController.EXTRA_INTENT_NOT_DEFAULT_DATA_SUBSCRIPTION:
                return "not default data subscription";
            case SlicePurchaseController.EXTRA_INTENT_NOTIFICATIONS_DISABLED:
                return "notifications disabled";
            case SlicePurchaseController.EXTRA_INTENT_SUCCESS: return "success";
            case SlicePurchaseController.EXTRA_INTENT_NOTIFICATION_SHOWN:
                return "notification shown";
            default: {
                loge("Unknown pending intent extra: " + extra);
                return "unknown(" + extra + ")";
            }
        }
    }

    @Override
    public void onReceive(@NonNull Context context, @NonNull Intent intent) {
        logd("onReceive intent: " + intent.getAction());
        switch (intent.getAction()) {
            case Intent.ACTION_LOCALE_CHANGED:
                onLocaleChanged(context);
                break;
            case SlicePurchaseController.ACTION_START_SLICE_PURCHASE_APP:
                onDisplayPerformanceBoostNotification(context, intent, false);
                break;
            case SlicePurchaseController.ACTION_SLICE_PURCHASE_APP_RESPONSE_TIMEOUT:
                onTimeout(context, intent);
                break;
            case ACTION_NOTIFICATION_CANCELED:
                onUserCanceled(context, intent);
                break;
            default:
                loge("Received unknown action: " + intent.getAction());
        }
    }

    private void onLocaleChanged(@NonNull Context context) {
        if (sIntents.isEmpty()) return;

        for (int capability : new int[]{TelephonyManager.PREMIUM_CAPABILITY_PRIORITIZE_LATENCY}) {
            if (sIntents.get(capability) != null) {
                // Notification is active -- update notification for new locale
                context.getSystemService(NotificationManager.class).cancelAsUser(
                        PERFORMANCE_BOOST_NOTIFICATION_TAG, capability, UserHandle.ALL);
                onDisplayPerformanceBoostNotification(context, sIntents.get(capability), true);
            }
        }
    }

    private void onDisplayPerformanceBoostNotification(@NonNull Context context,
            @NonNull Intent intent, boolean localeChanged) {
        if (!localeChanged && !isIntentValid(intent)) {
            sendSlicePurchaseAppResponse(intent,
                    SlicePurchaseController.EXTRA_INTENT_REQUEST_FAILED);
            return;
        }

        Resources res = getResources(context);
        NotificationManager notificationManager =
                context.getSystemService(NotificationManager.class);
        NotificationChannel channel = notificationManager.getNotificationChannel(
                PERFORMANCE_BOOST_NOTIFICATION_CHANNEL_ID);
        if (channel == null) {
            channel = new NotificationChannel(
                    PERFORMANCE_BOOST_NOTIFICATION_CHANNEL_ID,
                    res.getString(R.string.performance_boost_notification_channel),
                    NotificationManager.IMPORTANCE_DEFAULT);
            // CarrierDefaultApp notifications are unblockable by default.
            // Make this channel blockable to allow users to disable notifications posted to this
            // channel without affecting other notifications in this application.
            channel.setBlockable(true);
            context.getSystemService(NotificationManager.class).createNotificationChannel(channel);
        } else if (localeChanged) {
            // If the channel already exists but the locale has changed, update the channel name.
            channel.setName(res.getString(R.string.performance_boost_notification_channel));
        }

        boolean channelNotificationsDisabled =
                channel.getImportance() == NotificationManager.IMPORTANCE_NONE;
        if (channelNotificationsDisabled || !notificationManager.areNotificationsEnabled()) {
            // If notifications are disabled for the app or channel, fail the purchase request.
            logd("Purchase request failed because notifications are disabled for the "
                    + (channelNotificationsDisabled ? "channel." : "application."));
            sendSlicePurchaseAppResponse(intent,
                    SlicePurchaseController.EXTRA_INTENT_NOTIFICATIONS_DISABLED);
            return;
        }

        String carrier = intent.getStringExtra(SlicePurchaseController.EXTRA_CARRIER);
        Notification notification =
                new Notification.Builder(context, PERFORMANCE_BOOST_NOTIFICATION_CHANNEL_ID)
                        .setContentTitle(res.getString(
                                R.string.performance_boost_notification_title))
                        .setContentText(String.format(res.getString(
                                R.string.performance_boost_notification_detail), carrier))
                        .setSmallIcon(R.drawable.ic_performance_boost)
                        .setContentIntent(createContentIntent(context, intent, 1))
                        .setDeleteIntent(intent.getParcelableExtra(
                                SlicePurchaseController.EXTRA_INTENT_CANCELED, PendingIntent.class))
                        // Add an action for the "Not now" button, which has the same behavior as
                        // the user canceling or closing the notification.
                        .addAction(new Notification.Action.Builder(
                                Icon.createWithResource(context, R.drawable.ic_performance_boost),
                                res.getString(
                                        R.string.performance_boost_notification_button_not_now),
                                createCanceledIntent(context, intent)).build())
                        // Add an action for the "Manage" button, which has the same behavior as
                        // the user clicking on the notification.
                        .addAction(new Notification.Action.Builder(
                                Icon.createWithResource(context, R.drawable.ic_performance_boost),
                                res.getString(
                                        R.string.performance_boost_notification_button_manage),
                                createContentIntent(context, intent, 2)).build())
                        .build();

        int capability = intent.getIntExtra(SlicePurchaseController.EXTRA_PREMIUM_CAPABILITY,
                SlicePurchaseController.PREMIUM_CAPABILITY_INVALID);
        logd((localeChanged ? "Update" : "Display")
                + " the performance boost notification for capability "
                + TelephonyManager.convertPremiumCapabilityToString(capability));
        context.getSystemService(NotificationManager.class).notifyAsUser(
                PERFORMANCE_BOOST_NOTIFICATION_TAG, capability, notification, UserHandle.ALL);
        if (!localeChanged) {
            sIntents.put(capability, intent);
            sendSlicePurchaseAppResponse(intent,
                    SlicePurchaseController.EXTRA_INTENT_NOTIFICATION_SHOWN);
        }
    }

    /**
     * Get the {@link Resources} for the current locale.
     *
     * @param context The context to get the resources in.
     *
     * @return The resources in the current locale.
     */
    @VisibleForTesting
    @NonNull public Resources getResources(@NonNull Context context) {
        Resources resources = context.getResources();
        Configuration config = resources.getConfiguration();
        config.setLocale(getCurrentLocale());
        return new Resources(resources.getAssets(), resources.getDisplayMetrics(), config);
    }

    /**
     * Get the current {@link Locale} from the system property {@code persist.sys.locale}.
     *
     * @return The user's default/preferred language.
     */
    @VisibleForTesting
    @NonNull public Locale getCurrentLocale() {
        String languageTag = SystemProperties.get("persist.sys.locale");
        if (TextUtils.isEmpty(languageTag)) {
            return LocaleList.getAdjustedDefault().get(0);
        }
        return Locale.forLanguageTag(languageTag);
    }

    /**
     * Create the intent for when the user clicks on the "Manage" button on the performance boost
     * notification or the notification itself. This will open {@link SlicePurchaseActivity}.
     *
     * @param context The Context to create the intent for.
     * @param intent The source Intent used to launch the slice purchase application.
     * @param requestCode The request code for the PendingIntent.
     *
     * @return The intent to start {@link SlicePurchaseActivity}.
     */
    @VisibleForTesting
    @NonNull public PendingIntent createContentIntent(@NonNull Context context,
            @NonNull Intent intent, int requestCode) {
        Intent i = new Intent(context, SlicePurchaseActivity.class);
        i.setComponent(ComponentName.unflattenFromString(
                "com.android.carrierdefaultapp/.SlicePurchaseActivity"));
        i.setFlags(Intent.FLAG_ACTIVITY_BROUGHT_TO_FRONT
                | Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TASK);
        i.putExtras(intent);
        return PendingIntent.getActivityAsUser(context, requestCode, i,
                PendingIntent.FLAG_CANCEL_CURRENT | PendingIntent.FLAG_MUTABLE, null /* options */,
                UserHandle.CURRENT);
    }

    /**
     * Create the canceled intent for when the user clicks the "Not now" button on the performance
     * boost notification. This will send {@link #ACTION_NOTIFICATION_CANCELED} and has the same
     * behavior as if the user had canceled or removed the notification.
     *
     * @param context The Context to create the intent for.
     * @param intent The source Intent used to launch the slice purchase application.
     *
     * @return The canceled intent.
     */
    @VisibleForTesting
    @NonNull public PendingIntent createCanceledIntent(@NonNull Context context,
            @NonNull Intent intent) {
        Intent i = new Intent(ACTION_NOTIFICATION_CANCELED);
        i.setComponent(ComponentName.unflattenFromString(
                "com.android.carrierdefaultapp/.SlicePurchaseBroadcastReceiver"));
        i.putExtras(intent);
        return PendingIntent.getBroadcast(context, 0, i,
                PendingIntent.FLAG_CANCEL_CURRENT | PendingIntent.FLAG_MUTABLE);
    }

    private void onTimeout(@NonNull Context context, @NonNull Intent intent) {
        int capability = intent.getIntExtra(SlicePurchaseController.EXTRA_PREMIUM_CAPABILITY,
                SlicePurchaseController.PREMIUM_CAPABILITY_INVALID);
        logd("Purchase capability " + TelephonyManager.convertPremiumCapabilityToString(capability)
                + " timed out.");
        if (sIntents.get(capability) != null) {
            // Notification is still active -- cancel pending notification
            logd("Closing performance boost notification since the user did not respond in time.");
            cancelNotification(context, capability);
        } else {
            // SlicePurchaseActivity is still active -- ignore timer
            logd("Ignoring timeout since the SlicePurchaseActivity is still active.");
        }
    }

    private void onUserCanceled(@NonNull Context context, @NonNull Intent intent) {
        if (!isIntentValid(intent)) {
            loge("Ignoring onUserCanceled called with invalid intent.");
            return;
        }
        int capability = intent.getIntExtra(SlicePurchaseController.EXTRA_PREMIUM_CAPABILITY,
                SlicePurchaseController.PREMIUM_CAPABILITY_INVALID);
        logd("onUserCanceled: " + TelephonyManager.convertPremiumCapabilityToString(capability));
        cancelNotification(context, capability);
        sendSlicePurchaseAppResponse(intent, SlicePurchaseController.EXTRA_INTENT_CANCELED);
    }

    private static void logd(String s) {
        Log.d(TAG, s);
    }

    private static void loge(String s) {
        Log.e(TAG, s);
    }
}