xref: /frameworks/base/packages/SystemUI/src/com/android/systemui/media/controls/domain/pipeline/MediaActions.kt

/*
 * Copyright (C) 2024 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.systemui.media.controls.domain.pipeline

import android.annotation.WorkerThread
import android.app.ActivityOptions
import android.app.BroadcastOptions
import android.app.Notification
import android.app.PendingIntent
import android.content.Context
import android.graphics.drawable.Animatable
import android.graphics.drawable.Icon
import android.media.session.MediaController
import android.media.session.PlaybackState
import android.service.notification.StatusBarNotification
import android.util.Log
import androidx.media.utils.MediaConstants
import com.android.systemui.Flags
import com.android.systemui.media.NotificationMediaManager.isConnectingState
import com.android.systemui.media.NotificationMediaManager.isPlayingState
import com.android.systemui.media.controls.domain.pipeline.LegacyMediaDataManagerImpl.Companion.MAX_COMPACT_ACTIONS
import com.android.systemui.media.controls.domain.pipeline.LegacyMediaDataManagerImpl.Companion.MAX_NOTIFICATION_ACTIONS
import com.android.systemui.media.controls.shared.MediaControlDrawables
import com.android.systemui.media.controls.shared.model.MediaAction
import com.android.systemui.media.controls.shared.model.MediaButton
import com.android.systemui.media.controls.shared.model.MediaNotificationAction
import com.android.systemui.plugins.ActivityStarter
import com.android.systemui.res.R
import com.android.systemui.util.kotlin.logI

private const val TAG = "MediaActions"

/**
 * Generates action button info for this media session based on the PlaybackState
 *
 * @param packageName Package name for the media app
 * @param controller MediaController for the current session
 * @return a Pair consisting of a list of media actions, and a list of ints representing which of
 *   those actions should be shown in the compact player
 */
@WorkerThread
fun createActionsFromState(
    context: Context,
    packageName: String,
    controller: MediaController,
): MediaButton? {
    val state = controller.playbackState ?: return null
    // First, check for standard actions
    val playOrPause =
        if (isConnectingState(state.state)) {
            // Spinner needs to be animating to render anything. Start it here.
            val drawable =
                context.getDrawable(com.android.internal.R.drawable.progress_small_material)
            (drawable as Animatable).start()
            MediaAction(
                drawable,
                null, // no action to perform when clicked
                context.getString(R.string.controls_media_button_connecting),
                if (Flags.mediaControlsUiUpdate()) {
                    context.getDrawable(R.drawable.ic_media_connecting_button_container)
                } else {
                    context.getDrawable(R.drawable.ic_media_connecting_container)
                },
                // Specify a rebind id to prevent the spinner from restarting on later binds.
                com.android.internal.R.drawable.progress_small_material,
            )
        } else if (isPlayingState(state.state)) {
            getStandardAction(context, controller, state.actions, PlaybackState.ACTION_PAUSE)
        } else {
            getStandardAction(context, controller, state.actions, PlaybackState.ACTION_PLAY)
        }
    val prevButton =
        getStandardAction(context, controller, state.actions, PlaybackState.ACTION_SKIP_TO_PREVIOUS)
    val nextButton =
        getStandardAction(context, controller, state.actions, PlaybackState.ACTION_SKIP_TO_NEXT)

    // Then, create a way to build any custom actions that will be needed
    val customActions =
        state.customActions
            .asSequence()
            .filterNotNull()
            .map { getCustomAction(context, packageName, controller, it) }
            .iterator()
    fun nextCustomAction() = if (customActions.hasNext()) customActions.next() else null

    // Finally, assign the remaining button slots: play/pause A B C D
    // A = previous, else custom action (if not reserved)
    // B = next, else custom action (if not reserved)
    // C and D are always custom actions
    val reservePrev =
        controller.extras?.getBoolean(
            MediaConstants.SESSION_EXTRAS_KEY_SLOT_RESERVATION_SKIP_TO_PREV
        ) == true
    val reserveNext =
        controller.extras?.getBoolean(
            MediaConstants.SESSION_EXTRAS_KEY_SLOT_RESERVATION_SKIP_TO_NEXT
        ) == true

    val prevOrCustom =
        if (prevButton != null) {
            prevButton
        } else if (!reservePrev) {
            nextCustomAction()
        } else {
            null
        }

    val nextOrCustom =
        if (nextButton != null) {
            nextButton
        } else if (!reserveNext) {
            nextCustomAction()
        } else {
            null
        }

    return MediaButton(
        playOrPause,
        nextOrCustom,
        prevOrCustom,
        nextCustomAction(),
        nextCustomAction(),
        reserveNext,
        reservePrev,
    )
}

/**
 * Create a [MediaAction] for a given action and media session
 *
 * @param controller MediaController for the session
 * @param stateActions The actions included with the session's [PlaybackState]
 * @param action A [PlaybackState.Actions] value representing what action to generate. One of:
 *   [PlaybackState.ACTION_PLAY] [PlaybackState.ACTION_PAUSE]
 *   [PlaybackState.ACTION_SKIP_TO_PREVIOUS] [PlaybackState.ACTION_SKIP_TO_NEXT]
 * @return A [MediaAction] with correct values set, or null if the state doesn't support it
 */
private fun getStandardAction(
    context: Context,
    controller: MediaController,
    stateActions: Long,
    @PlaybackState.Actions action: Long,
): MediaAction? {
    if (!includesAction(stateActions, action)) {
        return null
    }

    return when (action) {
        PlaybackState.ACTION_PLAY -> {
            MediaAction(
                if (Flags.mediaControlsUiUpdate()) {
                    context.getDrawable(R.drawable.ic_media_play_button)
                } else {
                    context.getDrawable(R.drawable.ic_media_play)
                },
                { controller.transportControls.play() },
                context.getString(R.string.controls_media_button_play),
                if (Flags.mediaControlsUiUpdate()) {
                    context.getDrawable(R.drawable.ic_media_play_button_container)
                } else {
                    context.getDrawable(R.drawable.ic_media_play_container)
                },
            )
        }
        PlaybackState.ACTION_PAUSE -> {
            MediaAction(
                if (Flags.mediaControlsUiUpdate()) {
                    context.getDrawable(R.drawable.ic_media_pause_button)
                } else {
                    context.getDrawable(R.drawable.ic_media_pause)
                },
                { controller.transportControls.pause() },
                context.getString(R.string.controls_media_button_pause),
                if (Flags.mediaControlsUiUpdate()) {
                    context.getDrawable(R.drawable.ic_media_pause_button_container)
                } else {
                    context.getDrawable(R.drawable.ic_media_pause_container)
                },
            )
        }
        PlaybackState.ACTION_SKIP_TO_PREVIOUS -> {
            MediaAction(
                MediaControlDrawables.getPrevIcon(context),
                { controller.transportControls.skipToPrevious() },
                context.getString(R.string.controls_media_button_prev),
                null,
            )
        }
        PlaybackState.ACTION_SKIP_TO_NEXT -> {
            MediaAction(
                MediaControlDrawables.getNextIcon(context),
                { controller.transportControls.skipToNext() },
                context.getString(R.string.controls_media_button_next),
                null,
            )
        }
        else -> null
    }
}

/** Get a [MediaAction] representing a [PlaybackState.CustomAction] */
private fun getCustomAction(
    context: Context,
    packageName: String,
    controller: MediaController,
    customAction: PlaybackState.CustomAction,
): MediaAction {
    return MediaAction(
        Icon.createWithResource(packageName, customAction.icon).loadDrawable(context),
        { controller.transportControls.sendCustomAction(customAction, customAction.extras) },
        customAction.name,
        null,
    )
}

/** Check whether the actions from a [PlaybackState] include a specific action */
private fun includesAction(stateActions: Long, @PlaybackState.Actions action: Long): Boolean {
    if (
        (action == PlaybackState.ACTION_PLAY || action == PlaybackState.ACTION_PAUSE) &&
            (stateActions and PlaybackState.ACTION_PLAY_PAUSE > 0L)
    ) {
        return true
    }
    return (stateActions and action != 0L)
}

/** Generate action buttons based on notification actions */
fun createActionsFromNotification(
    context: Context,
    sbn: StatusBarNotification,
): Pair<List<MediaNotificationAction>, List<Int>> {
    val notif = sbn.notification
    val actionIcons: MutableList<MediaNotificationAction> = ArrayList()
    val actions = notif.actions
    var actionsToShowCollapsed =
        notif.extras.getIntArray(Notification.EXTRA_COMPACT_ACTIONS)?.toMutableList()
            ?: mutableListOf()
    if (actionsToShowCollapsed.size > MAX_COMPACT_ACTIONS) {
        Log.e(
            TAG,
            "Too many compact actions for ${sbn.key}, limiting to first $MAX_COMPACT_ACTIONS",
        )
        actionsToShowCollapsed = actionsToShowCollapsed.subList(0, MAX_COMPACT_ACTIONS)
    }

    actions?.let {
        if (it.size > MAX_NOTIFICATION_ACTIONS) {
            Log.w(
                TAG,
                "Too many notification actions for ${sbn.key}, " +
                    "limiting to first $MAX_NOTIFICATION_ACTIONS",
            )
        }

        for ((index, action) in it.take(MAX_NOTIFICATION_ACTIONS).withIndex()) {
            if (action.getIcon() == null) {
                logI(TAG) { "No icon for action $index ${action.title}" }
                actionsToShowCollapsed.remove(index)
                continue
            }

            val themeText =
                com.android.settingslib.Utils.getColorAttr(
                        context,
                        com.android.internal.R.attr.textColorPrimary,
                    )
                    .defaultColor

            val mediaActionIcon =
                when (action.getIcon().type) {
                        Icon.TYPE_RESOURCE ->
                            Icon.createWithResource(sbn.packageName, action.getIcon()!!.getResId())
                        else -> action.getIcon()
                    }
                    .setTint(themeText)
                    .loadDrawable(context)

            val mediaAction =
                MediaNotificationAction(
                    action.isAuthenticationRequired,
                    action.actionIntent,
                    mediaActionIcon,
                    action.title,
                )
            actionIcons.add(mediaAction)
        }
    }
    return Pair(actionIcons, actionsToShowCollapsed)
}

/**
 * Converts [MediaNotificationAction] list into [MediaAction] list
 *
 * @param actions list of [MediaNotificationAction]
 * @param activityStarter starter for activities
 * @return list of [MediaAction]
 */
fun getNotificationActions(
    actions: List<MediaNotificationAction>,
    activityStarter: ActivityStarter,
): List<MediaAction> {
    return actions.map { action ->
        val runnable =
            action.actionIntent?.let { actionIntent ->
                Runnable {
                    when {
                        actionIntent.isActivity ->
                            activityStarter.startPendingIntentDismissingKeyguard(
                                action.actionIntent
                            )
                        action.isAuthenticationRequired ->
                            activityStarter.dismissKeyguardThenExecute(
                                { sendPendingIntent(action.actionIntent) },
                                {},
                                true,
                            )
                        else -> sendPendingIntent(actionIntent)
                    }
                }
            }
        MediaAction(action.icon, runnable, action.contentDescription, background = null)
    }
}

private fun sendPendingIntent(intent: PendingIntent): Boolean {
    return try {
        intent.send(
            BroadcastOptions.makeBasic()
                .apply {
                    setInteractive(true)
                    setPendingIntentBackgroundActivityStartMode(
                        ActivityOptions.MODE_BACKGROUND_ACTIVITY_START_ALLOWED
                    )
                }
                .toBundle()
        )
        true
    } catch (e: PendingIntent.CanceledException) {
        Log.d(TAG, "Intent canceled", e)
        false
    }
}