Bring lifecycle to sysui

- Add a method to observe callbacks based on lifecycle
 - Add 2 examples of this in real code (one for a view, one for a
   fragment

Test: runtest systemui
Change-Id: I9e1e4a617a63e702602472b2079a477e373ff1e9

packages/SystemUI/src/com/android/systemui/BatteryMeterView.java

@@ -19,6 +19,8 @@ import static android.app.StatusBarManager.DISABLE2_SYSTEM_ICONS;
 import static android.app.StatusBarManager.DISABLE_NONE;
 import static android.provider.Settings.System.SHOW_BATTERY_PERCENT;
 
+import static com.android.systemui.util.SysuiLifecycle.viewAttachLifecycle;
+
 import static java.lang.annotation.RetentionPolicy.SOURCE;
 
 import android.animation.ArgbEvaluator;
@@ -166,6 +168,7 @@ public class BatteryMeterView extends LinearLayout implements
 
         setClipChildren(false);
         setClipToPadding(false);
+        Dependency.get(ConfigurationController.class).observe(viewAttachLifecycle(this), this);
     }
 
     public void setForceShowPercent(boolean show) {
@@ -289,7 +292,6 @@ public class BatteryMeterView extends LinearLayout implements
                 Settings.System.getUriFor(SHOW_BATTERY_PERCENT), false, mSettingObserver, mUser);
         updateShowPercent();
         subscribeForTunerUpdates();
-        Dependency.get(ConfigurationController.class).addCallback(this);
         mUserTracker.startTracking();
     }
 
@@ -300,7 +302,6 @@ public class BatteryMeterView extends LinearLayout implements
         mBatteryController.removeCallback(this);
         getContext().getContentResolver().unregisterContentObserver(mSettingObserver);
         unsubscribeFromTunerUpdates();
-        Dependency.get(ConfigurationController.class).removeCallback(this);
     }
 
     @Override

packages/SystemUI/src/com/android/systemui/statusbar/phone/NavigationBarFragment.java

@@ -32,7 +32,6 @@ import android.annotation.IdRes;
 import android.annotation.Nullable;
 import android.app.ActivityManager;
 import android.app.ActivityTaskManager;
-import android.app.Fragment;
 import android.app.IActivityTaskManager;
 import android.app.StatusBarManager;
 import android.content.BroadcastReceiver;
@@ -90,6 +89,7 @@ import com.android.systemui.statusbar.phone.ContextualButton.ContextButtonListen
 import com.android.systemui.statusbar.policy.AccessibilityManagerWrapper;
 import com.android.systemui.statusbar.policy.DeviceProvisionedController;
 import com.android.systemui.statusbar.policy.KeyButtonView;
+import com.android.systemui.util.LifecycleFragment;
 
 import java.io.FileDescriptor;
 import java.io.PrintWriter;
@@ -101,7 +101,7 @@ import java.util.function.Consumer;
  * Fragment containing the NavigationBarFragment. Contains logic for what happens
  * on clicks and view states of the nav bar.
  */
-public class NavigationBarFragment extends Fragment implements Callbacks {
+public class NavigationBarFragment extends LifecycleFragment implements Callbacks {
 
     public static final String TAG = "NavigationBar";
     private static final boolean DEBUG = false;
@@ -199,7 +199,7 @@ public class NavigationBarFragment extends Fragment implements Callbacks {
     public void onCreate(@Nullable Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
         mCommandQueue = SysUiServiceProvider.getComponent(getContext(), CommandQueue.class);
-        mCommandQueue.addCallback(this);
+        mCommandQueue.observe(getLifecycle(), this);
         mStatusBar = SysUiServiceProvider.getComponent(getContext(), StatusBar.class);
         mRecents = SysUiServiceProvider.getComponent(getContext(), Recents.class);
         mDivider = SysUiServiceProvider.getComponent(getContext(), Divider.class);
@@ -225,7 +225,6 @@ public class NavigationBarFragment extends Fragment implements Callbacks {
     @Override
     public void onDestroy() {
         super.onDestroy();
-        mCommandQueue.removeCallback(this);
         Dependency.get(AccessibilityManagerWrapper.class).removeCallback(
                 mAccessibilityListener);
         mContentResolver.unregisterContentObserver(mMagnificationObserver);

packages/SystemUI/src/com/android/systemui/statusbar/policy/CallbackController.java

@@ -1,8 +1,9 @@
 /*
  * Copyright (C) 2016 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
+ * 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
  *
@@ -14,7 +15,35 @@
 
 package com.android.systemui.statusbar.policy;
 
+import androidx.lifecycle.Lifecycle;
+import androidx.lifecycle.Lifecycle.Event;
+import androidx.lifecycle.LifecycleEventObserver;
+import androidx.lifecycle.LifecycleOwner;
+
 public interface CallbackController<T> {
     void addCallback(T listener);
     void removeCallback(T listener);
+
+    /**
+     * Wrapper to {@link #addCallback(Object)} when a lifecycle is in the resumed state
+     * and {@link #removeCallback(Object)} when not resumed automatically.
+     */
+    default T observe(LifecycleOwner owner, T listener) {
+        return observe(owner.getLifecycle(), listener);
+    }
+
+    /**
+     * Wrapper to {@link #addCallback(Object)} when a lifecycle is in the resumed state
+     * and {@link #removeCallback(Object)} when not resumed automatically.
+     */
+    default T observe(Lifecycle lifecycle, T listener) {
+        lifecycle.addObserver((LifecycleEventObserver) (lifecycleOwner, event) -> {
+            if (event == Event.ON_RESUME) {
+                addCallback(listener);
+            } else if (event == Event.ON_PAUSE) {
+                removeCallback(listener);
+            }
+        });
+        return listener;
+    }
 }

packages/SystemUI/src/com/android/systemui/util/LifecycleFragment.java

@@ -0,0 +1,87 @@
+/*
+ * Copyright (C) 2018 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.util;
+
+import static androidx.lifecycle.Lifecycle.Event.ON_CREATE;
+import static androidx.lifecycle.Lifecycle.Event.ON_DESTROY;
+import static androidx.lifecycle.Lifecycle.Event.ON_PAUSE;
+import static androidx.lifecycle.Lifecycle.Event.ON_RESUME;
+import static androidx.lifecycle.Lifecycle.Event.ON_START;
+import static androidx.lifecycle.Lifecycle.Event.ON_STOP;
+
+import android.annotation.CallSuper;
+import android.app.Fragment;
+import android.os.Bundle;
+
+import androidx.lifecycle.Lifecycle;
+import androidx.lifecycle.LifecycleOwner;
+import androidx.lifecycle.LifecycleRegistry;
+
+/**
+ * Version of {@link #Fragment} that is a {@link LifecycleOwner}.
+ */
+public class LifecycleFragment extends Fragment implements LifecycleOwner {
+
+    private final LifecycleRegistry mLifecycle = new LifecycleRegistry(this);
+
+    public Lifecycle getLifecycle() {
+        return mLifecycle;
+    }
+
+    @CallSuper
+    @Override
+    public void onCreate(Bundle savedInstanceState) {
+        mLifecycle.handleLifecycleEvent(ON_CREATE);
+        super.onCreate(savedInstanceState);
+    }
+
+    @CallSuper
+    @Override
+    public void onStart() {
+        mLifecycle.handleLifecycleEvent(ON_START);
+        super.onStart();
+    }
+
+    @CallSuper
+    @Override
+    public void onResume() {
+        mLifecycle.handleLifecycleEvent(ON_RESUME);
+        super.onResume();
+    }
+
+    @CallSuper
+    @Override
+    public void onPause() {
+        mLifecycle.handleLifecycleEvent(ON_PAUSE);
+        super.onPause();
+    }
+
+    @CallSuper
+    @Override
+    public void onStop() {
+        mLifecycle.handleLifecycleEvent(ON_STOP);
+        super.onStop();
+    }
+
+    @CallSuper
+    @Override
+    public void onDestroy() {
+        mLifecycle.handleLifecycleEvent(ON_DESTROY);
+        super.onDestroy();
+    }
+
+}

packages/SystemUI/src/com/android/systemui/util/SysuiLifecycle.java

@@ -0,0 +1,69 @@
+/*
+ * Copyright (C) 2018 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.util;
+
+import static androidx.lifecycle.Lifecycle.State.DESTROYED;
+import static androidx.lifecycle.Lifecycle.State.RESUMED;
+
+import android.view.View;
+import android.view.View.OnAttachStateChangeListener;
+
+import androidx.annotation.NonNull;
+import androidx.lifecycle.Lifecycle;
+import androidx.lifecycle.LifecycleOwner;
+import androidx.lifecycle.LifecycleRegistry;
+
+/**
+ * Tools for generating lifecycle from sysui objects.
+ */
+public class SysuiLifecycle {
+
+    private SysuiLifecycle() {
+    }
+
+    /**
+     * Get a lifecycle that will be put into the resumed state when the view is attached
+     * and goes to the destroyed state when the view is detached.
+     */
+    public static LifecycleOwner viewAttachLifecycle(View v) {
+        return new ViewLifecycle(v);
+    }
+
+    private static class ViewLifecycle implements LifecycleOwner, OnAttachStateChangeListener {
+        private final LifecycleRegistry mLifecycle = new LifecycleRegistry(this);
+
+        ViewLifecycle(View v) {
+            v.addOnAttachStateChangeListener(this);
+        }
+
+        @NonNull
+        @Override
+        public Lifecycle getLifecycle() {
+            return mLifecycle;
+        }
+
+        @Override
+        public void onViewAttachedToWindow(View v) {
+            mLifecycle.markState(RESUMED);
+        }
+
+        @Override
+        public void onViewDetachedFromWindow(View v) {
+            mLifecycle.markState(DESTROYED);
+        }
+    }
+}

packages/SystemUI/tests/src/com/android/systemui/statusbar/policy/CallbackControllerTest.java

@@ -0,0 +1,88 @@
+/*
+ * Copyright (C) 2018 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.statusbar.policy;
+
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+
+import android.support.test.filters.SmallTest;
+import android.testing.AndroidTestingRunner;
+import android.testing.TestableLooper.RunWithLooper;
+
+import androidx.lifecycle.Lifecycle;
+import androidx.lifecycle.Lifecycle.Event;
+import androidx.lifecycle.LifecycleEventObserver;
+import androidx.lifecycle.LifecycleOwner;
+
+import com.android.systemui.SysuiTestCase;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.ArgumentCaptor;
+
+@RunWithLooper
+@RunWith(AndroidTestingRunner.class)
+@SmallTest
+public class CallbackControllerTest extends SysuiTestCase {
+
+    @Test
+    public void testAddCallback() {
+        Lifecycle lifecycle = mock(Lifecycle.class);
+        LifecycleOwner owner = () -> lifecycle;
+        Object callback = new Object();
+        Controller controller = mock(Controller.class);
+
+        // observe and get the lifecycle observer that gets registered.
+        ArgumentCaptor<LifecycleEventObserver> observer =
+                ArgumentCaptor.forClass(LifecycleEventObserver.class);
+        controller.observe(owner, callback);
+        verify(lifecycle).addObserver(observer.capture());
+
+        // move to resume state and make sure the callback gets registered.
+        observer.getValue().onStateChanged(owner, Event.ON_RESUME);
+        verify(controller).addCallback(eq(callback));
+    }
+
+    @Test
+    public void testRemoveCallback() {
+        Lifecycle lifecycle = mock(Lifecycle.class);
+        LifecycleOwner owner = () -> lifecycle;
+        Object callback = new Object();
+        Controller controller = mock(Controller.class);
+
+        // observe and get the lifecycle observer that gets registered.
+        ArgumentCaptor<LifecycleEventObserver> observer =
+                ArgumentCaptor.forClass(LifecycleEventObserver.class);
+        controller.observe(owner, callback);
+        verify(lifecycle).addObserver(observer.capture());
+
+        // move to pause state and make sure the callback gets unregistered.
+        observer.getValue().onStateChanged(owner, Event.ON_PAUSE);
+        verify(controller).removeCallback(eq(callback));
+    }
+
+    private static class Controller implements CallbackController<Object> {
+        @Override
+        public void addCallback(Object listener) {
+        }
+
+        @Override
+        public void removeCallback(Object listener) {
+        }
+    }
+}

packages/SystemUI/tests/src/com/android/systemui/util/LifecycleFragmentTest.java

@@ -0,0 +1,129 @@
+/*
+ * Copyright (C) 2018 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.util;
+
+import static androidx.lifecycle.Lifecycle.Event.ON_CREATE;
+import static androidx.lifecycle.Lifecycle.Event.ON_DESTROY;
+import static androidx.lifecycle.Lifecycle.Event.ON_PAUSE;
+import static androidx.lifecycle.Lifecycle.Event.ON_RESUME;
+import static androidx.lifecycle.Lifecycle.Event.ON_START;
+import static androidx.lifecycle.Lifecycle.Event.ON_STOP;
+
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+
+import android.support.test.filters.SmallTest;
+import android.testing.AndroidTestingRunner;
+import android.testing.TestableLooper;
+import android.testing.TestableLooper.RunWithLooper;
+
+import androidx.lifecycle.LifecycleEventObserver;
+
+import com.android.systemui.SysuiBaseFragmentTest;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+@RunWithLooper
+@RunWith(AndroidTestingRunner.class)
+@SmallTest
+public class LifecycleFragmentTest extends SysuiBaseFragmentTest {
+
+    public LifecycleFragmentTest() {
+        super(LifecycleFragment.class);
+    }
+
+    @Test
+    public void testCreateLifecycle() {
+        LifecycleFragment fragment = (LifecycleFragment) mFragment;
+        LifecycleEventObserver observer = mock(LifecycleEventObserver.class);
+        fragment.getLifecycle().addObserver(observer);
+
+        mFragments.dispatchCreate();
+        TestableLooper.get(this).processAllMessages();
+
+        verify(observer).onStateChanged(eq(fragment), eq(ON_CREATE));
+    }
+
+    @Test
+    public void testResumeLifecycle() {
+        LifecycleFragment fragment = (LifecycleFragment) mFragment;
+        LifecycleEventObserver observer = mock(LifecycleEventObserver.class);
+        fragment.getLifecycle().addObserver(observer);
+
+        mFragments.dispatchResume();
+        TestableLooper.get(this).processAllMessages();
+
+        verify(observer).onStateChanged(eq(fragment), eq(ON_RESUME));
+    }
+
+    @Test
+    public void testStartLifecycle() {
+        LifecycleFragment fragment = (LifecycleFragment) mFragment;
+        LifecycleEventObserver observer = mock(LifecycleEventObserver.class);
+        fragment.getLifecycle().addObserver(observer);
+
+        mFragments.dispatchStart();
+        TestableLooper.get(this).processAllMessages();
+
+        verify(observer).onStateChanged(eq(fragment), eq(ON_START));
+    }
+
+    @Test
+    public void testStopLifecycle() {
+        LifecycleFragment fragment = (LifecycleFragment) mFragment;
+        LifecycleEventObserver observer = mock(LifecycleEventObserver.class);
+        fragment.getLifecycle().addObserver(observer);
+
+        mFragments.dispatchStart();
+        TestableLooper.get(this).processAllMessages();
+        mFragments.dispatchStop();
+        TestableLooper.get(this).processAllMessages();
+
+        verify(observer).onStateChanged(eq(fragment), eq(ON_STOP));
+    }
+
+    @Test
+    public void testPauseLifecycle() {
+        LifecycleFragment fragment = (LifecycleFragment) mFragment;
+        LifecycleEventObserver observer = mock(LifecycleEventObserver.class);
+        fragment.getLifecycle().addObserver(observer);
+
+        mFragments.dispatchResume();
+        TestableLooper.get(this).processAllMessages();
+        mFragments.dispatchPause();
+        TestableLooper.get(this).processAllMessages();
+
+        verify(observer).onStateChanged(eq(fragment), eq(ON_PAUSE));
+    }
+
+    @Test
+    public void testDestroyLifecycle() {
+        LifecycleFragment fragment = (LifecycleFragment) mFragment;
+        LifecycleEventObserver observer = mock(LifecycleEventObserver.class);
+        fragment.getLifecycle().addObserver(observer);
+
+        mFragments.dispatchCreate();
+        TestableLooper.get(this).processAllMessages();
+        mFragments.dispatchDestroy();
+        TestableLooper.get(this).processAllMessages();
+        mFragments = null;
+
+        verify(observer).onStateChanged(eq(fragment), eq(ON_DESTROY));
+    }
+}

packages/SystemUI/tests/src/com/android/systemui/util/SysuiLifecycleTest.java

@@ -0,0 +1,87 @@
+/*
+ * Copyright (C) 2018 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.util;
+
+import static androidx.lifecycle.Lifecycle.Event.ON_CREATE;
+import static androidx.lifecycle.Lifecycle.Event.ON_DESTROY;
+import static androidx.lifecycle.Lifecycle.Event.ON_PAUSE;
+import static androidx.lifecycle.Lifecycle.Event.ON_RESUME;
+import static androidx.lifecycle.Lifecycle.Event.ON_START;
+import static androidx.lifecycle.Lifecycle.Event.ON_STOP;
+
+import static com.android.systemui.util.SysuiLifecycle.viewAttachLifecycle;
+
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+
+import android.support.test.filters.SmallTest;
+import android.testing.AndroidTestingRunner;
+import android.testing.TestableLooper;
+import android.testing.TestableLooper.RunWithLooper;
+import android.testing.ViewUtils;
+import android.view.View;
+
+import androidx.lifecycle.LifecycleEventObserver;
+import androidx.lifecycle.LifecycleOwner;
+
+import com.android.systemui.SysuiTestCase;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+@RunWithLooper
+@RunWith(AndroidTestingRunner.class)
+@SmallTest
+public class SysuiLifecycleTest extends SysuiTestCase {
+
+    @Test
+    public void testAttach() {
+        View v = new View(mContext);
+        LifecycleEventObserver observer = mock(LifecycleEventObserver.class);
+        LifecycleOwner lifecycle = viewAttachLifecycle(v);
+        lifecycle.getLifecycle().addObserver(observer);
+
+        ViewUtils.attachView(v);
+        TestableLooper.get(this).processAllMessages();
+
+        verify(observer).onStateChanged(eq(lifecycle), eq(ON_CREATE));
+        verify(observer).onStateChanged(eq(lifecycle), eq(ON_START));
+        verify(observer).onStateChanged(eq(lifecycle), eq(ON_RESUME));
+
+        ViewUtils.detachView(v);
+        TestableLooper.get(this).processAllMessages();
+    }
+
+    @Test
+    public void testDetach() {
+        View v = new View(mContext);
+        LifecycleEventObserver observer = mock(LifecycleEventObserver.class);
+        LifecycleOwner lifecycle = viewAttachLifecycle(v);
+        lifecycle.getLifecycle().addObserver(observer);
+
+        ViewUtils.attachView(v);
+        TestableLooper.get(this).processAllMessages();
+
+        ViewUtils.detachView(v);
+        TestableLooper.get(this).processAllMessages();
+
+        verify(observer).onStateChanged(eq(lifecycle), eq(ON_PAUSE));
+        verify(observer).onStateChanged(eq(lifecycle), eq(ON_STOP));
+        verify(observer).onStateChanged(eq(lifecycle), eq(ON_DESTROY));
+    }
+}