This fixes an issue where, in fast E2E tests, the test can complete before initPool is completed. This results in the ViewPool continuing to create TaskViews and therefore TaskThumbnailViews after RecentsDeps is destroyed. Doing this causes a crash. Stopping the ViewPool.initPool thread before destroying RecentsDeps fixes this. Bug: 390156722 Flag: com.android.launcher3.enable_refactor_task_thumbnail Test: fast E2E tests in presubmit e.g. AllAppsImageTest Change-Id: I0f8801ca75cda383df8ed96077cf1b7178771cb6
142 lines
4.2 KiB
Java
142 lines
4.2 KiB
Java
/*
|
|
* Copyright (C) 2019 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.launcher3.util;
|
|
|
|
import android.content.Context;
|
|
import android.os.Handler;
|
|
import android.util.Log;
|
|
import android.view.LayoutInflater;
|
|
import android.view.View;
|
|
import android.view.ViewGroup;
|
|
|
|
import androidx.annotation.AnyThread;
|
|
import androidx.annotation.Nullable;
|
|
import androidx.annotation.UiThread;
|
|
import androidx.annotation.VisibleForTesting;
|
|
|
|
import com.android.launcher3.util.ViewPool.Reusable;
|
|
|
|
/**
|
|
* Utility class to maintain a pool of reusable views.
|
|
* During initialization, views are inflated on the background thread.
|
|
*/
|
|
public class ViewPool<T extends View & Reusable> {
|
|
private static final String TAG = ViewPool.class.getSimpleName();
|
|
|
|
private final Object[] mPool;
|
|
|
|
private final LayoutInflater mInflater;
|
|
private final ViewGroup mParent;
|
|
private final int mLayoutId;
|
|
|
|
private int mCurrentSize = 0;
|
|
|
|
@Nullable
|
|
private Thread mViewPoolInitThread;
|
|
|
|
public ViewPool(Context context, @Nullable ViewGroup parent,
|
|
int layoutId, int maxSize, int initialSize) {
|
|
this(LayoutInflater.from(context).cloneInContext(context),
|
|
parent, layoutId, maxSize, initialSize);
|
|
}
|
|
|
|
@VisibleForTesting
|
|
ViewPool(LayoutInflater inflater, @Nullable ViewGroup parent,
|
|
int layoutId, int maxSize, int initialSize) {
|
|
mLayoutId = layoutId;
|
|
mParent = parent;
|
|
mInflater = inflater;
|
|
mPool = new Object[maxSize];
|
|
|
|
if (initialSize > 0) {
|
|
initPool(initialSize);
|
|
}
|
|
}
|
|
|
|
@UiThread
|
|
private void initPool(int initialSize) {
|
|
Preconditions.assertUIThread();
|
|
Handler handler = new Handler();
|
|
|
|
// LayoutInflater is not thread safe as it maintains a global variable 'mConstructorArgs'.
|
|
// Create a different copy to use on the background thread.
|
|
LayoutInflater inflater = mInflater.cloneInContext(mInflater.getContext());
|
|
|
|
// Inflate views on a non looper thread. This allows us to catch errors like calling
|
|
// "new Handler()" in constructor easily.
|
|
mViewPoolInitThread = new Thread(() -> {
|
|
for (int i = 0; i < initialSize; i++) {
|
|
T view = inflateNewView(inflater);
|
|
handler.post(() -> addToPool(view));
|
|
}
|
|
Log.d(TAG, "initPool complete");
|
|
mViewPoolInitThread = null;
|
|
}, "ViewPool-init");
|
|
mViewPoolInitThread.start();
|
|
}
|
|
|
|
@UiThread
|
|
public void recycle(T view) {
|
|
Preconditions.assertUIThread();
|
|
view.onRecycle();
|
|
addToPool(view);
|
|
}
|
|
|
|
@UiThread
|
|
private void addToPool(T view) {
|
|
Preconditions.assertUIThread();
|
|
if (mCurrentSize >= mPool.length) {
|
|
// pool is full
|
|
return;
|
|
}
|
|
|
|
mPool[mCurrentSize] = view;
|
|
mCurrentSize++;
|
|
}
|
|
|
|
@UiThread
|
|
public T getView() {
|
|
Preconditions.assertUIThread();
|
|
if (mCurrentSize > 0) {
|
|
mCurrentSize--;
|
|
return (T) mPool[mCurrentSize];
|
|
}
|
|
return inflateNewView(mInflater);
|
|
}
|
|
|
|
@AnyThread
|
|
private T inflateNewView(LayoutInflater inflater) {
|
|
return (T) inflater.inflate(mLayoutId, mParent, false);
|
|
}
|
|
|
|
public void killOngoingInitializations() throws InterruptedException {
|
|
if (mViewPoolInitThread != null) {
|
|
mViewPoolInitThread.join();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Interface to indicate that a view is reusable
|
|
*/
|
|
public interface Reusable {
|
|
|
|
/**
|
|
* Called when a view is recycled / added back to the pool
|
|
*/
|
|
void onRecycle();
|
|
}
|
|
}
|