Merge "Use CopyOnWrite ControlListingController callbacks" into main

import com.android.systemui.util.asIndenting

import com.android.systemui.util.indentIfPossible

import java.io.PrintWriter

import java.util.concurrent.CopyOnWriteArraySet

import java.util.concurrent.Executor

import java.util.concurrent.atomic.AtomicInteger

import javax.inject.Inject

private fun createServiceListing(context: Context): ServiceListing {

    return ServiceListing.Builder(context).apply {

    return ServiceListing.Builder(context)

        .apply {

            setIntentAction(ControlsProviderService.SERVICE_CONTROLS)

            setPermission("android.permission.BIND_CONTROLS")

            setNoun("Controls Provider")

            setSetting("controls_providers")

            setTag("controls_providers")

            setAddDeviceLockedFlags(true)

    }.build()

        }

        .build()

}

/**

 * Provides a listing of components to be used as ControlsServiceProvider.

 *

 * This controller keeps track of components that satisfy:

 *

 * * Has an intent-filter responding to [ControlsProviderService.CONTROLS_ACTION]

 * * Has the bind permission `android.permission.BIND_CONTROLS`

 */

@SysUISingleton

class ControlsListingControllerImpl @VisibleForTesting constructor(

class ControlsListingControllerImpl

@VisibleForTesting

constructor(

    private val context: Context,

    @Background private val backgroundExecutor: Executor,

    private val serviceListingBuilder: (Context) -> ServiceListing,

    private var serviceListing = serviceListingBuilder(context)

    // All operations in background thread

    private val callbacks = mutableSetOf<ControlsListingController.ControlsListingCallback>()

    private val callbacks = CopyOnWriteArraySet<ControlsListingController.ControlsListingCallback>()

    companion object {

        private const val TAG = "ControlsListingControllerImpl"

    override var currentUserId = userTracker.userId

        private set

    private val serviceListingCallback = ServiceListing.Callback { list ->

    private val serviceListingCallback =

        ServiceListing.Callback { list ->

            Log.d(TAG, "ServiceConfig reloaded, count: ${list.size}")

            val newServices = list.map { ControlsServiceInfo(userTracker.userContext, it) }

        // After here, `list` is not captured, so we don't risk modifying it outside of the callback

            // After here, `list` is not captured, so we don't risk modifying it outside of the

            // callback

            backgroundExecutor.execute {

                if (userChangeInProgress.get() > 0) return@execute

                updateServices(newServices)

    private fun updateServices(newServices: List<ControlsServiceInfo>) {

        if (activityTaskManagerProxy.supportsMultiWindow(context)) {

            newServices.forEach {

                it.resolvePanelActivity() }

            newServices.forEach { it.resolvePanelActivity() }

        }

        if (newServices != availableServices) {

            availableServices = newServices

            callbacks.forEach {

                it.onServicesUpdated(getCurrentServices())

            }

            callbacks.forEach { it.onServicesUpdated(getCurrentServices()) }

        }

    }

    /**

     * Adds a callback to this controller.

     *

     * The callback will be notified after it is added as well as any time that the valid

     * components change.

     * The callback will be notified after it is added as well as any time that the valid components

     * change.

     *

     * @param listener a callback to be notified

     */

    }

    /**

     * @return a list of components that satisfy the requirements to be a

     *         [ControlsProviderService]

     * @return a list of components that satisfy the requirements to be a [ControlsProviderService]

     */

    override fun getCurrentServices(): List<ControlsServiceInfo> =

        availableServices.map(ControlsServiceInfo::copy)

        val packageManager = context.packageManager

        val intent = Intent(ControlsProviderService.SERVICE_CONTROLS)

        val user = userTracker.userHandle

        val flags = PackageManager.GET_SERVICES or

        val flags =

            PackageManager.GET_SERVICES or

                PackageManager.GET_META_DATA or

                PackageManager.MATCH_DIRECT_BOOT_UNAWARE or

                PackageManager.MATCH_DIRECT_BOOT_AWARE

        val services = packageManager.queryIntentServicesAsUser(

        val services =

            packageManager

                .queryIntentServicesAsUser(

                    intent,

                    PackageManager.ResolveInfoFlags.of(flags.toLong()),

                    user

        ).map { ControlsServiceInfo(userTracker.userContext, it.serviceInfo) }

                )

                .map { ControlsServiceInfo(userTracker.userContext, it.serviceInfo) }

        updateServices(services)

    }

     * @return a label as returned by [CandidateInfo.loadLabel] or `null`.

     */

    override fun getAppLabel(name: ComponentName): CharSequence? {

        return availableServices.firstOrNull { it.componentName == name }

                ?.loadLabel()

        return availableServices.firstOrNull { it.componentName == name }?.loadLabel()

    }

    override fun dump(writer: PrintWriter, args: Array<out String>) {