Files
Flexera-Launcher/src/com/android/launcher3/util/ViewPool.java
T
Uwais Ashraf 6322c00b70 Add kill switch for ViewPool.initPool.
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
2025-01-21 08:06:23 +00:00

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();
}
}