Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 5242fe62 authored by Matt Pietal's avatar Matt Pietal
Browse files

Remove Clock Migration Flag: 4/N 

Removing dead code.

Bug: 301502635
Test: atest SystemUITests
Flag: EXEMPT bugfix
Change-Id: I0d1e4e4988b1d8a70c93f29312bd27bf03e9c340
parent 950a47ab

packages/SystemUI/multivalentTests/src/com/android/keyguard/KeyguardClockSwitchControllerBaseTest.java

deleted100644 → 0
+0 −227
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2023 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.keyguard;



import static android.view.View.INVISIBLE;



import static org.mockito.ArgumentMatchers.any;

import static org.mockito.Mockito.atLeast;

import static org.mockito.Mockito.mock;

import static org.mockito.Mockito.verify;

import static org.mockito.Mockito.when;



import android.content.res.Resources;

import android.view.View;

import android.view.ViewGroup;

import android.widget.FrameLayout;

import android.widget.LinearLayout;

import android.widget.RelativeLayout;



import com.android.systemui.SysuiTestCase;

import com.android.systemui.dump.DumpManager;

import com.android.systemui.flags.FakeFeatureFlags;

import com.android.systemui.keyguard.KeyguardUnlockAnimationController;

import com.android.systemui.keyguard.domain.interactor.KeyguardClockInteractor;

import com.android.systemui.keyguard.domain.interactor.KeyguardInteractorFactory;

import com.android.systemui.keyguard.ui.view.InWindowLauncherUnlockAnimationManager;

import com.android.systemui.log.LogBuffer;

import com.android.systemui.plugins.clocks.ClockAnimations;

import com.android.systemui.plugins.clocks.ClockController;

import com.android.systemui.plugins.clocks.ClockEvents;

import com.android.systemui.plugins.clocks.ClockFaceConfig;

import com.android.systemui.plugins.clocks.ClockFaceController;

import com.android.systemui.plugins.clocks.ClockFaceEvents;

import com.android.systemui.plugins.clocks.ClockTickRate;

import com.android.systemui.plugins.statusbar.StatusBarStateController;

import com.android.systemui.res.R;

import com.android.systemui.shared.clocks.AnimatableClockView;

import com.android.systemui.shared.clocks.ClockRegistry;

import com.android.systemui.statusbar.StatusBarState;

import com.android.systemui.statusbar.lockscreen.LockscreenSmartspaceController;

import com.android.systemui.statusbar.notification.icon.ui.viewbinder.NotificationIconContainerAlwaysOnDisplayViewBinder;

import com.android.systemui.statusbar.phone.NotificationIconContainer;

import com.android.systemui.util.concurrency.FakeExecutor;

import com.android.systemui.util.settings.SecureSettings;

import com.android.systemui.util.time.FakeSystemClock;



import org.junit.Before;

import org.mockito.ArgumentCaptor;

import org.mockito.Captor;

import org.mockito.Mock;

import org.mockito.MockitoAnnotations;



public class KeyguardClockSwitchControllerBaseTest extends SysuiTestCase {



    @Mock

    protected KeyguardClockSwitch mView;

    @Mock

    protected StatusBarStateController mStatusBarStateController;

    @Mock

    protected ClockRegistry mClockRegistry;

    @Mock

    KeyguardSliceViewController mKeyguardSliceViewController;

    @Mock

    LockscreenSmartspaceController mSmartspaceController;



    @Mock

    Resources mResources;

    @Mock

    KeyguardUnlockAnimationController mKeyguardUnlockAnimationController;

    @Mock

    protected ClockController mClockController;

    @Mock

    protected ClockFaceController mLargeClockController;

    @Mock

    protected ClockFaceController mSmallClockController;

    @Mock

    protected ClockAnimations mClockAnimations;

    @Mock

    protected ClockEvents mClockEvents;

    @Mock

    protected ClockFaceEvents mClockFaceEvents;

    @Mock

    DumpManager mDumpManager;

    @Mock

    ClockEventController mClockEventController;



    @Mock

    protected NotificationIconContainer mNotificationIcons;

    @Mock

    protected AnimatableClockView mSmallClockView;

    @Mock

    protected AnimatableClockView mLargeClockView;

    @Mock

    protected FrameLayout mSmallClockFrame;

    @Mock

    protected FrameLayout mLargeClockFrame;

    @Mock

    protected SecureSettings mSecureSettings;

    @Mock

    protected LogBuffer mLogBuffer;



    @Mock

    protected KeyguardClockInteractor mKeyguardClockInteractor;



    protected final View mFakeDateView = (View) (new ViewGroup(mContext) {

        @Override

        protected void onLayout(boolean changed, int l, int t, int r, int b) {}

    });

    protected final View mFakeWeatherView = new View(mContext);

    protected final View mFakeSmartspaceView = new View(mContext);



    protected KeyguardClockSwitchController mController;

    protected View mSliceView;

    protected LinearLayout mStatusArea;

    protected FakeExecutor mExecutor;

    protected FakeFeatureFlags mFakeFeatureFlags;

    @Captor protected ArgumentCaptor<View.OnAttachStateChangeListener> mAttachCaptor =

            ArgumentCaptor.forClass(View.OnAttachStateChangeListener.class);



    @Before

    public void setup() {

        MockitoAnnotations.initMocks(this);



        mFakeDateView.setTag(R.id.tag_smartspace_view, new Object());

        mFakeWeatherView.setTag(R.id.tag_smartspace_view, new Object());

        mFakeSmartspaceView.setTag(R.id.tag_smartspace_view, new Object());



        when(mView.findViewById(R.id.left_aligned_notification_icon_container))

                .thenReturn(mNotificationIcons);

        when(mNotificationIcons.getLayoutParams()).thenReturn(

                mock(RelativeLayout.LayoutParams.class));

        when(mView.getContext()).thenReturn(getContext());

        when(mView.getResources()).thenReturn(mResources);

        when(mResources.getDimensionPixelSize(R.dimen.keyguard_clock_top_margin))

                .thenReturn(100);

        when(mResources.getDimensionPixelSize(com.android.systemui.customization.R.dimen.keyguard_large_clock_top_margin))

                .thenReturn(-200);

        when(mResources.getInteger(com.android.internal.R.integer.config_doublelineClockDefault))

                .thenReturn(1);

        when(mResources.getInteger(R.integer.keyguard_date_weather_view_invisibility))

                .thenReturn(INVISIBLE);



        when(mView

                .findViewById(com.android.systemui.customization.R.id.lockscreen_clock_view_large))

                .thenReturn(mLargeClockFrame);

        when(mView

                .findViewById(com.android.systemui.customization.R.id.lockscreen_clock_view))

                .thenReturn(mSmallClockFrame);

        when(mSmallClockView.getContext()).thenReturn(getContext());

        when(mLargeClockView.getContext()).thenReturn(getContext());



        when(mView.isAttachedToWindow()).thenReturn(true);

        when(mSmartspaceController.buildAndConnectDateView(any())).thenReturn(mFakeDateView);

        when(mSmartspaceController.buildAndConnectWeatherView(any())).thenReturn(mFakeWeatherView);

        when(mSmartspaceController.buildAndConnectView(any())).thenReturn(mFakeSmartspaceView);

        mExecutor = new FakeExecutor(new FakeSystemClock());

        mFakeFeatureFlags = new FakeFeatureFlags();

        mController = new KeyguardClockSwitchController(

                mView,

                mStatusBarStateController,

                mClockRegistry,

                mKeyguardSliceViewController,

                mSmartspaceController,

                mock(NotificationIconContainerAlwaysOnDisplayViewBinder.class),

                mKeyguardUnlockAnimationController,

                mSecureSettings,

                mExecutor,

                mExecutor,

                mDumpManager,

                mClockEventController,

                mLogBuffer,

                KeyguardInteractorFactory.create(mFakeFeatureFlags).getKeyguardInteractor(),

                mKeyguardClockInteractor,

                mock(InWindowLauncherUnlockAnimationManager.class)

        );



        when(mStatusBarStateController.getState()).thenReturn(StatusBarState.SHADE);

        when(mLargeClockController.getView()).thenReturn(mLargeClockView);

        when(mSmallClockController.getView()).thenReturn(mSmallClockView);

        when(mClockController.getLargeClock()).thenReturn(mLargeClockController);

        when(mClockController.getSmallClock()).thenReturn(mSmallClockController);

        when(mClockController.getEvents()).thenReturn(mClockEvents);

        when(mSmallClockController.getEvents()).thenReturn(mClockFaceEvents);

        when(mLargeClockController.getEvents()).thenReturn(mClockFaceEvents);

        when(mLargeClockController.getAnimations()).thenReturn(mClockAnimations);

        when(mSmallClockController.getAnimations()).thenReturn(mClockAnimations);

        when(mClockRegistry.createCurrentClock()).thenReturn(mClockController);

        when(mClockEventController.getClock()).thenReturn(mClockController);

        when(mSmallClockController.getConfig())

                .thenReturn(new ClockFaceConfig(ClockTickRate.PER_MINUTE, false, false, false));

        when(mLargeClockController.getConfig())

                .thenReturn(new ClockFaceConfig(ClockTickRate.PER_MINUTE, false, false, false));



        mSliceView = new View(getContext());

        when(mView.findViewById(R.id.keyguard_slice_view)).thenReturn(mSliceView);

        mStatusArea = new LinearLayout(getContext());

        when(mView.findViewById(R.id.keyguard_status_area)).thenReturn(mStatusArea);

    }



    private void removeView(View v) {

        ViewGroup group = ((ViewGroup) v.getParent());

        if (group != null) {

            group.removeView(v);

        }

    }



    protected void init() {

        mController.init();



        verify(mView, atLeast(1)).addOnAttachStateChangeListener(mAttachCaptor.capture());

        mAttachCaptor.getValue().onViewAttachedToWindow(mView);

    }

}

packages/SystemUI/multivalentTests/src/com/android/keyguard/KeyguardClockSwitchControllerTest.java

deleted100644 → 0
+0 −278
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2020 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.keyguard;



import static org.junit.Assert.assertEquals;

import static org.junit.Assert.assertNull;

import static org.mockito.ArgumentMatchers.any;

import static org.mockito.ArgumentMatchers.anyBoolean;

import static org.mockito.ArgumentMatchers.eq;

import static org.mockito.Mockito.never;

import static org.mockito.Mockito.reset;

import static org.mockito.Mockito.times;

import static org.mockito.Mockito.verify;

import static org.mockito.Mockito.when;



import android.database.ContentObserver;

import android.os.UserHandle;

import android.platform.test.annotations.DisableFlags;

import android.provider.Settings;

import android.view.View;



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

import androidx.test.filters.SmallTest;



import com.android.systemui.Flags;

import com.android.systemui.plugins.clocks.ClockFaceConfig;

import com.android.systemui.plugins.clocks.ClockTickRate;

import com.android.systemui.shared.clocks.ClockRegistry;

import com.android.systemui.statusbar.StatusBarState;



import org.junit.Test;

import org.junit.runner.RunWith;

import org.mockito.ArgumentCaptor;

import org.mockito.verification.VerificationMode;



@SmallTest

@RunWith(AndroidJUnit4.class)

@DisableFlags(Flags.FLAG_MIGRATE_CLOCKS_TO_BLUEPRINT)

public class KeyguardClockSwitchControllerTest extends KeyguardClockSwitchControllerBaseTest {

    @Test

    public void testInit_viewAlreadyAttached() {

        mController.init();



        verifyAttachment(times(1));

    }



    @Test

    public void testInit_viewNotYetAttached() {

        ArgumentCaptor<View.OnAttachStateChangeListener> listenerArgumentCaptor =

                ArgumentCaptor.forClass(View.OnAttachStateChangeListener.class);



        when(mView.isAttachedToWindow()).thenReturn(false);

        mController.init();

        verify(mView).addOnAttachStateChangeListener(listenerArgumentCaptor.capture());



        verifyAttachment(never());



        listenerArgumentCaptor.getValue().onViewAttachedToWindow(mView);



        verifyAttachment(times(1));

    }



    @Test

    public void testInitSubControllers() {

        mController.init();

        verify(mKeyguardSliceViewController).init();

    }



    @Test

    public void testInit_viewDetached() {

        ArgumentCaptor<View.OnAttachStateChangeListener> listenerArgumentCaptor =

                ArgumentCaptor.forClass(View.OnAttachStateChangeListener.class);

        mController.init();

        verify(mView).addOnAttachStateChangeListener(listenerArgumentCaptor.capture());



        verifyAttachment(times(1));



        listenerArgumentCaptor.getValue().onViewDetachedFromWindow(mView);

        verify(mClockEventController).unregisterListeners();

    }



    @Test

    public void testPluginPassesStatusBarState() {

        ArgumentCaptor<ClockRegistry.ClockChangeListener> listenerArgumentCaptor =

                ArgumentCaptor.forClass(ClockRegistry.ClockChangeListener.class);



        mController.init();

        verify(mClockRegistry).registerClockChangeListener(listenerArgumentCaptor.capture());



        listenerArgumentCaptor.getValue().onCurrentClockChanged();

        verify(mView, times(2)).setClock(mClockController, StatusBarState.SHADE);

        verify(mClockEventController, times(2)).setClock(mClockController);

    }



    @Test

    public void testSmartspaceEnabledRemovesKeyguardStatusArea() {

        when(mSmartspaceController.isEnabled()).thenReturn(true);

        mController.init();



        assertEquals(View.GONE, mSliceView.getVisibility());

    }



    @Test

    public void onLocaleListChangedRebuildsSmartspaceView() {

        when(mSmartspaceController.isEnabled()).thenReturn(true);

        mController.init();



        mController.onLocaleListChanged();

        // Should be called once on initial setup, then once again for locale change

        verify(mSmartspaceController, times(2)).buildAndConnectView(mView);

    }



    @Test

    public void onLocaleListChanged_rebuildsSmartspaceViews_whenDecouplingEnabled() {

        when(mSmartspaceController.isEnabled()).thenReturn(true);

        when(mSmartspaceController.isDateWeatherDecoupled()).thenReturn(true);

        mController.init();



        mController.onLocaleListChanged();

        // Should be called once on initial setup, then once again for locale change

        verify(mSmartspaceController, times(2)).buildAndConnectDateView(mView);

        verify(mSmartspaceController, times(2)).buildAndConnectWeatherView(mView);

        verify(mSmartspaceController, times(2)).buildAndConnectView(mView);

    }



    @Test

    public void testSmartspaceDisabledShowsKeyguardStatusArea() {

        when(mSmartspaceController.isEnabled()).thenReturn(false);

        mController.init();



        assertEquals(View.VISIBLE, mSliceView.getVisibility());

    }



    @Test

    public void testRefresh() {

        mController.refresh();



        verify(mSmartspaceController).requestSmartspaceUpdate();

    }



    @Test

    public void testChangeToDoubleLineClockSetsSmallClock() {

        when(mSecureSettings.getIntForUser(Settings.Secure.LOCKSCREEN_USE_DOUBLE_LINE_CLOCK, 1,

                UserHandle.USER_CURRENT))

                .thenReturn(0);

        ArgumentCaptor<ContentObserver> observerCaptor =

                ArgumentCaptor.forClass(ContentObserver.class);

        mController.init();

        mExecutor.runAllReady();

        verify(mSecureSettings).registerContentObserverForUserSync(

                eq(Settings.Secure.LOCKSCREEN_USE_DOUBLE_LINE_CLOCK),

                    anyBoolean(), observerCaptor.capture(), eq(UserHandle.USER_ALL));

        ContentObserver observer = observerCaptor.getValue();

        mExecutor.runAllReady();



        // When a settings change has occurred to the small clock, make sure the view is adjusted

        reset(mView);

        when(mView.getResources()).thenReturn(mResources);

        observer.onChange(true);

        mExecutor.runAllReady();

        verify(mView).switchToClock(KeyguardClockSwitch.SMALL, /* animate */ true);

    }



    @Test

    public void testGetClock_ForwardsToClock() {

        assertEquals(mClockController, mController.getClock());

    }



    @Test

    public void testGetLargeClockBottom_returnsExpectedValue() {

        when(mLargeClockFrame.getVisibility()).thenReturn(View.VISIBLE);

        when(mLargeClockFrame.getHeight()).thenReturn(100);

        when(mSmallClockFrame.getHeight()).thenReturn(50);

        when(mLargeClockView.getHeight()).thenReturn(40);

        when(mSmallClockView.getHeight()).thenReturn(20);

        mController.init();



        assertEquals(170, mController.getClockBottom(1000));

    }



    @Test

    public void testGetSmallLargeClockBottom_returnsExpectedValue() {

        when(mLargeClockFrame.getVisibility()).thenReturn(View.GONE);

        when(mLargeClockFrame.getHeight()).thenReturn(100);

        when(mSmallClockFrame.getHeight()).thenReturn(50);

        when(mLargeClockView.getHeight()).thenReturn(40);

        when(mSmallClockView.getHeight()).thenReturn(20);

        mController.init();



        assertEquals(1120, mController.getClockBottom(1000));

    }



    @Test

    public void testGetClockBottom_nullClock_returnsZero() {

        when(mClockEventController.getClock()).thenReturn(null);

        assertEquals(0, mController.getClockBottom(10));

    }



    @Test

    public void testChangeLockscreenWeatherEnabledSetsWeatherViewVisible() {

        when(mSmartspaceController.isWeatherEnabled()).thenReturn(true);

        ArgumentCaptor<ContentObserver> observerCaptor =

                ArgumentCaptor.forClass(ContentObserver.class);

        mController.init();

        mExecutor.runAllReady();

        verify(mSecureSettings).registerContentObserverForUserSync(

                eq(Settings.Secure.LOCK_SCREEN_WEATHER_ENABLED), anyBoolean(),

                    observerCaptor.capture(), eq(UserHandle.USER_ALL));

        ContentObserver observer = observerCaptor.getValue();

        mExecutor.runAllReady();

        // When a settings change has occurred, check that view is visible.

        observer.onChange(true);

        mExecutor.runAllReady();

        assertEquals(View.VISIBLE, mFakeWeatherView.getVisibility());

    }



    @Test

    public void testChangeClockDateWeatherEnabled_SetsDateWeatherViewVisibility() {

        ArgumentCaptor<ClockRegistry.ClockChangeListener> listenerArgumentCaptor =

                ArgumentCaptor.forClass(ClockRegistry.ClockChangeListener.class);

        when(mSmartspaceController.isEnabled()).thenReturn(true);

        when(mSmartspaceController.isDateWeatherDecoupled()).thenReturn(true);

        when(mSmartspaceController.isWeatherEnabled()).thenReturn(true);

        mController.init();

        mExecutor.runAllReady();

        assertEquals(View.VISIBLE, mFakeDateView.getVisibility());



        when(mSmallClockController.getConfig())

                .thenReturn(new ClockFaceConfig(ClockTickRate.PER_MINUTE, true, false, true));

        when(mLargeClockController.getConfig())

                .thenReturn(new ClockFaceConfig(ClockTickRate.PER_MINUTE, true, false, true));

        verify(mClockRegistry).registerClockChangeListener(listenerArgumentCaptor.capture());

        listenerArgumentCaptor.getValue().onCurrentClockChanged();



        mExecutor.runAllReady();

        assertEquals(View.INVISIBLE, mFakeDateView.getVisibility());

    }



    @Test

    public void testGetClock_nullClock_returnsNull() {

        when(mClockEventController.getClock()).thenReturn(null);

        assertNull(mController.getClock());

    }



    private void verifyAttachment(VerificationMode times) {

        verify(mClockRegistry, times).registerClockChangeListener(

                any(ClockRegistry.ClockChangeListener.class));

        verify(mClockEventController, times).registerListeners(mView);

    }



    @Test

    public void testSplitShadeEnabledSetToSmartspaceController() {

        mController.setSplitShadeEnabled(true);

        verify(mSmartspaceController, times(1)).setSplitShadeEnabled(true);

        verify(mSmartspaceController, times(0)).setSplitShadeEnabled(false);

    }



    @Test

    public void testSplitShadeDisabledSetToSmartspaceController() {

        mController.setSplitShadeEnabled(false);

        verify(mSmartspaceController, times(1)).setSplitShadeEnabled(false);

        verify(mSmartspaceController, times(0)).setSplitShadeEnabled(true);

    }

}

packages/SystemUI/multivalentTests/src/com/android/keyguard/KeyguardClockSwitchTest.java

deleted100644 → 0
+0 −273

File deleted.

Preview size limit exceeded, changes collapsed.

packages/SystemUI/src/com/android/keyguard/KeyguardClockSwitchController.java

+0 −20
Original line number Diff line number Diff line
@@ -55,7 +55,6 @@ import com.android.systemui.shared.regionsampling.RegionSampler; 
import com.android.systemui.statusbar.lockscreen.LockscreenSmartspaceController;

import com.android.systemui.statusbar.notification.AnimatableProperty;

import com.android.systemui.statusbar.notification.PropertyAnimator;

import com.android.systemui.statusbar.notification.icon.ui.viewbinder.NotificationIconContainerAlwaysOnDisplayViewBinder;

import com.android.systemui.statusbar.notification.stack.AnimationProperties;

import com.android.systemui.statusbar.phone.NotificationIconContainer;

import com.android.systemui.util.ViewController;
@@ -85,7 +84,6 @@ public class KeyguardClockSwitchController extends ViewController<KeyguardClockS 
    private final DumpManager mDumpManager;

    private final ClockEventController mClockEventController;

    private final LogBuffer mLogBuffer;

    private final NotificationIconContainerAlwaysOnDisplayViewBinder mNicViewBinder;

    private FrameLayout mSmallClockFrame; // top aligned clock

    private FrameLayout mLargeClockFrame; // centered clock
@@ -147,7 +145,6 @@ public class KeyguardClockSwitchController extends ViewController<KeyguardClockS 
            ClockRegistry clockRegistry,

            KeyguardSliceViewController keyguardSliceViewController,

            LockscreenSmartspaceController smartspaceController,

            NotificationIconContainerAlwaysOnDisplayViewBinder nicViewBinder,

            KeyguardUnlockAnimationController keyguardUnlockAnimationController,

            SecureSettings secureSettings,

            @Main DelayableExecutor uiExecutor,
@@ -163,7 +160,6 @@ public class KeyguardClockSwitchController extends ViewController<KeyguardClockS 
        mClockRegistry = clockRegistry;

        mKeyguardSliceViewController = keyguardSliceViewController;

        mSmartspaceController = smartspaceController;

        mNicViewBinder = nicViewBinder;

        mSecureSettings = secureSettings;

        mUiExecutor = uiExecutor;

        mBgExecutor = bgExecutor;
@@ -277,7 +273,6 @@ public class KeyguardClockSwitchController extends ViewController<KeyguardClockS 
            hideSliceViewAndNotificationIconContainer();

            return;

        }

        updateAodIcons();

        mStatusArea = mView.findViewById(R.id.keyguard_status_area);



        mBgExecutor.execute(() -> {
@@ -569,21 +564,6 @@ public class KeyguardClockSwitchController extends ViewController<KeyguardClockS 
        return mLargeClockFrame.getVisibility() != View.VISIBLE;

    }



    private void updateAodIcons() {

        if (!MigrateClocksToBlueprint.isEnabled()) {

            NotificationIconContainer nic = (NotificationIconContainer)

                    mView.findViewById(

                            com.android.systemui.res.R.id.left_aligned_notification_icon_container);

            if (mAodIconsBindHandle != null) {

                mAodIconsBindHandle.dispose();

            }

            if (nic != null) {

                mAodIconsBindHandle = mNicViewBinder.bindWhileAttached(nic);

                mAodIconContainer = nic;

            }

        }

    }



    private void setClock(ClockController clock) {

        if (MigrateClocksToBlueprint.isEnabled()) {

            return;

packages/SystemUI/src/com/android/systemui/keyguard/ui/binder/KeyguardClockViewBinder.kt

+0 −7

File changed.

Preview size limit exceeded, changes collapsed.