Merge "Adding ViewCaptureAwareWindowManager to system ui windows." into main

import androidx.lifecycle.LifecycleRegistry

import androidx.test.ext.junit.runners.AndroidJUnit4

import androidx.test.filters.SmallTest

import com.android.app.viewcapture.ViewCapture

import com.android.app.viewcapture.ViewCaptureAwareWindowManager

import com.android.app.viewcapture.ViewCaptureFactory

import com.android.compose.animation.scene.ObservableTransitionState

import com.android.internal.logging.UiEventLogger

import com.android.keyguard.KeyguardUpdateMonitor

import org.mockito.Mockito

import org.mockito.Mockito.clearInvocations

import org.mockito.Mockito.isNull

import org.mockito.Mockito.spy

import org.mockito.Mockito.verify

import org.mockito.MockitoAnnotations

    @Mock lateinit var mDreamOverlayCallbackController: DreamOverlayCallbackController

    @Mock lateinit var mLazyViewCapture: Lazy<ViewCapture>

    private lateinit var mViewCaptureAwareWindowManager: ViewCaptureAwareWindowManager

    private lateinit var bouncerRepository: FakeKeyguardBouncerRepository

    private lateinit var communalRepository: FakeCommunalSceneRepository

    private var viewCaptureSpy = spy(ViewCaptureFactory.getInstance(context))

    @Captor var mViewCaptor: ArgumentCaptor<View>? = null

    private lateinit var mService: DreamOverlayService

        whenever(mDreamOverlayContainerViewController.containerView)

            .thenReturn(mDreamOverlayContainerView)

        whenever(mScrimManager.getCurrentController()).thenReturn(mScrimController)

        whenever(mLazyViewCapture.value).thenReturn(viewCaptureSpy)

        mWindowParams = WindowManager.LayoutParams()

        mViewCaptureAwareWindowManager = ViewCaptureAwareWindowManager(mWindowManager,

                mLazyViewCapture, isViewCaptureEnabled = false)

        mService =

            DreamOverlayService(

                mContext,

                mLifecycleOwner,

                mMainExecutor,

                mWindowManager,

                mViewCaptureAwareWindowManager,

                mComplicationComponentFactory,

                mDreamComplicationComponentFactory,

                mDreamOverlayComponentFactory,

package com.android.systemui.dagger;

import static com.android.systemui.Flags.enableViewCaptureTracing;

import static com.android.systemui.util.ConvenienceExtensionsKt.toKotlinLazy;

import android.annotation.Nullable;

import android.annotation.SuppressLint;

import android.app.ActivityManager;

import androidx.asynclayoutinflater.view.AsyncLayoutInflater;

import androidx.core.app.NotificationManagerCompat;

import com.android.app.viewcapture.ViewCapture;

import com.android.app.viewcapture.ViewCaptureAwareWindowManager;

import com.android.app.viewcapture.ViewCaptureFactory;

import com.android.internal.app.IBatteryStats;

import com.android.internal.appwidget.IAppWidgetService;

import com.android.internal.jank.InteractionJankMonitor;

import com.android.systemui.user.utils.UserScopedService;

import com.android.systemui.user.utils.UserScopedServiceImpl;

import dagger.Lazy;

import dagger.Module;

import dagger.Provides;

        return context.getSystemService(WindowManager.class);

    }

    @Provides

    @Singleton

    static ViewCaptureAwareWindowManager provideViewCaptureAwareWindowManager(

            WindowManager windowManager, Lazy<ViewCapture> daggerLazyViewCapture) {

        return new ViewCaptureAwareWindowManager(windowManager,

                /* lazyViewCapture= */ toKotlinLazy(daggerLazyViewCapture),

                /* isViewCaptureEnabled= */ enableViewCaptureTracing());

    }

    @Provides

    @Singleton

    static PermissionManager providePermissionManager(Context context) {

        return IDeviceIdleController.Stub.asInterface(

                ServiceManager.getService(Context.DEVICE_IDLE_CONTROLLER));

    }

    @Provides

    @Singleton

    static ViewCapture provideViewCapture(Context context) {

        return ViewCaptureFactory.getInstance(context);

    }

}

import androidx.lifecycle.ServiceLifecycleDispatcher;

import androidx.lifecycle.ViewModelStore;

import com.android.app.viewcapture.ViewCaptureAwareWindowManager;

import com.android.dream.lowlight.dagger.LowLightDreamModule;

import com.android.internal.logging.UiEvent;

import com.android.internal.logging.UiEventLogger;

    @Nullable

    private final ComponentName mHomeControlPanelDreamComponent;

    private final UiEventLogger mUiEventLogger;

    private final WindowManager mWindowManager;

    private final ViewCaptureAwareWindowManager mWindowManager;

    private final String mWindowTitle;

    // A reference to the {@link Window} used to hold the dream overlay.

            Context context,

            DreamOverlayLifecycleOwner lifecycleOwner,

            @Main DelayableExecutor executor,

            WindowManager windowManager,

            ViewCaptureAwareWindowManager viewCaptureAwareWindowManager,

            ComplicationComponent.Factory complicationComponentFactory,

            com.android.systemui.dreams.complication.dagger.ComplicationComponent.Factory

                    dreamComplicationComponentFactory,

        super(executor);

        mContext = context;

        mExecutor = executor;

        mWindowManager = windowManager;

        mWindowManager = viewCaptureAwareWindowManager;

        mKeyguardUpdateMonitor = keyguardUpdateMonitor;

        mScrimManager = scrimManager;

        mLowLightDreamComponent = lowLightDreamComponent;

import android.util.IndentingPrintWriter

import android.view.View

import android.view.ViewGroup

import dagger.Lazy

import java.io.PrintWriter

/** [Sequence] that yields all of the direct children of this [ViewGroup] */

        getBoundsOnScreen(bounds)

        return bounds

    }

/** Extension method to convert [dagger.Lazy] to [kotlin.Lazy] for object of any class [T]. */

fun <T> Lazy<T>.toKotlinLazy(): kotlin.Lazy<T> {

    return lazy { this.get() }

}