PawletOS/app_Settings
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge "[Settings] Code refactor for async Lifecycle listening" into tm-dev

Browse Source
This commit is contained in:
TreeHugger Robot
2022-04-22 05:50:05 +00:00
committed by Android (Google) Code Review
parent 932d5deaff 3856ac4be9
commit 49cc66afd3
2 changed files with 252 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

132
src/com/android/settings/network/helper/LifecycleCallbackConverter.java Normal file
View File

@@ -0,0 +1,132 @@
/*
* Copyright (C) 2022 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.settings.network.helper;
import androidx.annotation.AnyThread;
import androidx.annotation.NonNull;
import androidx.annotation.UiThread;
import androidx.annotation.VisibleForTesting;
import androidx.lifecycle.Lifecycle;
import com.android.settingslib.utils.ThreadUtils;
import java.util.concurrent.atomic.AtomicLong;
import java.util.function.Consumer;
/**
* A {@link LifecycleCallbackAdapter} which support carrying a result from any threads back to UI
* thread through {@link #postResult(T)}.
*
* A {@link Consumer<T>} would be invoked from UI thread for further processing on the result.
*
* Note: Result not in STARTED or RESUMED stage will be discarded silently.
* This is to align with the criteria set within
* {@link LifecycleCallbackAdapter#onStateChanged()}.
*/
@VisibleForTesting
public class LifecycleCallbackConverter<T> extends LifecycleCallbackAdapter {
private static final String TAG = "LifecycleCallbackConverter";
private final Thread mUiThread;
private final Consumer<T> mResultCallback;
/**
* A record of number of active status change.
* Even numbers (0, 2, 4, 6 ...) are inactive status.
* Odd numbers (1, 3, 5, 7 ...) are active status.
*/
private final AtomicLong mNumberOfActiveStatusChange = new AtomicLong();
/**
* Constructor
*
* @param lifecycle {@link Lifecycle} to monitor
* @param resultCallback for further processing the result
*/
@VisibleForTesting
@UiThread
public LifecycleCallbackConverter(
@NonNull Lifecycle lifecycle, @NonNull Consumer<T> resultCallback) {
super(lifecycle);
mUiThread = Thread.currentThread();
mResultCallback = resultCallback;
}
/**
* Post a result (from any thread) back to UI thread.
*
* @param result the object ready to be passed back to {@link Consumer<T>}.
*/
@AnyThread
@VisibleForTesting
public void postResult(T result) {
/**
* Since mNumberOfActiveStatusChange only increase, it is a concept of sequence number.
* Carry it when sending data in between different threads allow to verify if the data
* has arrived on time. And drop the data when expired.
*/
long currentNumberOfChange = mNumberOfActiveStatusChange.get();
if (Thread.currentThread() == mUiThread) {
dispatchExtResult(currentNumberOfChange, result); // Dispatch directly
} else {
postResultToUiThread(currentNumberOfChange, result);
}
}
@AnyThread
protected void postResultToUiThread(long numberOfStatusChange, T result) {
ThreadUtils.postOnMainThread(() -> dispatchExtResult(numberOfStatusChange, result));
}
@UiThread
protected void dispatchExtResult(long numberOfStatusChange, T result) {
/**
* For a postResult() sending in between different threads, not only create a latency
* but also enqueued into main UI thread for dispatch.
*
* To align behavior within {@link LifecycleCallbackAdapter#onStateChanged()},
* some checking on both numberOfStatusChange and {@link Lifecycle} status are required.
*/
if (isActiveStatus(numberOfStatusChange)
&& (numberOfStatusChange == mNumberOfActiveStatusChange.get())
&& getLifecycle().getCurrentState().isAtLeast(Lifecycle.State.STARTED)) {
mResultCallback.accept(result);
}
}
private static final boolean isActiveStatus(long numberOfStatusChange) {
return ((numberOfStatusChange & 1L) != 0L);
}
/* Implementation of LifecycleCallbackAdapter */
@UiThread
public boolean isCallbackActive() {
return isActiveStatus(mNumberOfActiveStatusChange.get());
}
/* Implementation of LifecycleCallbackAdapter */
@UiThread
public void setCallbackActive(boolean updatedActiveStatus) {
/**
* Make sure only increase when active status got changed.
* This is to implement the definition of mNumberOfActiveStatusChange.
*/
if (isCallbackActive() != updatedActiveStatus) {
mNumberOfActiveStatusChange.getAndIncrement();
}
}
}

120
tests/unit/src/com/android/settings/network/helper/LifecycleCallbackConverterTest.java Normal file
View File

@@ -0,0 +1,120 @@
/*
* Copyright (C) 2022 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.settings.network.helper;
import static com.google.common.truth.Truth.assertThat;
import androidx.lifecycle.Lifecycle;
import androidx.lifecycle.LifecycleOwner;
import androidx.lifecycle.LifecycleRegistry;
import androidx.test.ext.junit.runners.AndroidJUnit4;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import java.util.concurrent.Phaser;
import java.util.concurrent.atomic.AtomicReference;
import java.util.function.Consumer;
@RunWith(AndroidJUnit4.class)
public class LifecycleCallbackConverterTest implements LifecycleOwner {
private final LifecycleRegistry mRegistry = LifecycleRegistry.createUnsafe(this);
private Object mTestData;
private TestConsumer mConsumer;
private LifecycleCallbackConverter<Object> mConverter;
@Before
public void setUp() {
mTestData = new Object();
mConsumer = new TestConsumer();
mConverter = new LifecycleCallbackConverter<Object>(getLifecycle(), mConsumer);
}
public Lifecycle getLifecycle() {
return mRegistry;
}
@Test
public void converter_dropResult_whenInActive() {
mConverter.postResult(mTestData);
assertThat(mConsumer.getCallbackCount()).isEqualTo(0);
}
@Test
public void converter_callbackResult_whenActive() {
mRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE);
mRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START);
mConverter.postResult(mTestData);
assertThat(mConsumer.getCallbackCount()).isEqualTo(1);
assertThat(mConsumer.getData()).isEqualTo(mTestData);
}
@Test
public void converter_dropResult_whenBackToInActive() {
mRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE);
mRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START);
mRegistry.handleLifecycleEvent(Lifecycle.Event.ON_STOP);
mConverter.postResult(mTestData);
assertThat(mConsumer.getCallbackCount()).isEqualTo(0);
}
@Test
public void converter_passResultToUiThread_whenActive() {
mRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE);
mRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START);
final Phaser phaser = new Phaser(1);
Thread executionThread = new Thread(() -> {
mConverter.postResult(phaser);
});
executionThread.start();
phaser.awaitAdvance(0);
assertThat(mConsumer.getData()).isEqualTo(phaser);
assertThat(mConsumer.getCallbackCount()).isEqualTo(1);
}
public static class TestConsumer implements Consumer<Object> {
long mNumberOfCallback;
AtomicReference<Object> mLatestData;
public TestConsumer() {
mLatestData = new AtomicReference<Object>();
}
public void accept(Object data) {
mLatestData.set(data);
mNumberOfCallback ++;
if ((data != null) && (data instanceof Phaser)) {
((Phaser)data).arrive();
}
}
protected long getCallbackCount() {
return mNumberOfCallback;
}
protected Object getData() {
return mLatestData.get();
}
}
}