/*
|
* Copyright (C) 2017 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.server.pm;
|
|
import android.annotation.NonNull;
|
import android.annotation.Nullable;
|
import android.content.pm.ShortcutInfo;
|
import android.graphics.Bitmap;
|
import android.graphics.Bitmap.CompressFormat;
|
import android.graphics.drawable.Icon;
|
import android.os.StrictMode;
|
import android.os.StrictMode.ThreadPolicy;
|
import android.os.SystemClock;
|
import android.util.Log;
|
import android.util.Slog;
|
|
import com.android.internal.annotations.GuardedBy;
|
import com.android.internal.util.Preconditions;
|
import com.android.server.pm.ShortcutService.FileOutputStreamWithPath;
|
|
import libcore.io.IoUtils;
|
|
import java.io.ByteArrayOutputStream;
|
import java.io.File;
|
import java.io.IOException;
|
import java.io.PrintWriter;
|
import java.util.Deque;
|
import java.util.concurrent.CountDownLatch;
|
import java.util.concurrent.Executor;
|
import java.util.concurrent.LinkedBlockingDeque;
|
import java.util.concurrent.LinkedBlockingQueue;
|
import java.util.concurrent.ThreadPoolExecutor;
|
import java.util.concurrent.TimeUnit;
|
|
/**
|
* Class to save shortcut bitmaps on a worker thread.
|
*
|
* The methods with the "Locked" prefix must be called with the service lock held.
|
*/
|
public class ShortcutBitmapSaver {
|
private static final String TAG = ShortcutService.TAG;
|
private static final boolean DEBUG = ShortcutService.DEBUG;
|
|
private static final boolean ADD_DELAY_BEFORE_SAVE_FOR_TEST = false; // DO NOT submit with true.
|
private static final long SAVE_DELAY_MS_FOR_TEST = 1000; // DO NOT submit with true.
|
|
/**
|
* Before saving shortcuts.xml, and returning icons to the launcher, we wait for all pending
|
* saves to finish. However if it takes more than this long, we just give up and proceed.
|
*/
|
private final long SAVE_WAIT_TIMEOUT_MS = 30 * 1000;
|
|
private final ShortcutService mService;
|
|
/**
|
* Bitmaps are saved on this thread.
|
*
|
* Note: Just before saving shortcuts into the XML, we need to wait on all pending saves to
|
* finish, and we need to do it with the service lock held, which would still block incoming
|
* binder calls, meaning saving bitmaps *will* still actually block API calls too, which is
|
* not ideal but fixing it would be tricky, so this is still a known issue on the current
|
* version.
|
*
|
* In order to reduce the conflict, we use an own thread for this purpose, rather than
|
* reusing existing background threads, and also to avoid possible deadlocks.
|
*/
|
private final Executor mExecutor = new ThreadPoolExecutor(0, 1, 60L, TimeUnit.SECONDS,
|
new LinkedBlockingQueue<>());
|
|
/** Represents a bitmap to save. */
|
private static class PendingItem {
|
/** Hosting shortcut. */
|
public final ShortcutInfo shortcut;
|
|
/** Compressed bitmap data. */
|
public final byte[] bytes;
|
|
/** Instantiated time, only for dogfooding. */
|
private final long mInstantiatedUptimeMillis; // Only for dumpsys.
|
|
private PendingItem(ShortcutInfo shortcut, byte[] bytes) {
|
this.shortcut = shortcut;
|
this.bytes = bytes;
|
mInstantiatedUptimeMillis = SystemClock.uptimeMillis();
|
}
|
|
@Override
|
public String toString() {
|
return "PendingItem{size=" + bytes.length
|
+ " age=" + (SystemClock.uptimeMillis() - mInstantiatedUptimeMillis) + "ms"
|
+ " shortcut=" + shortcut.toInsecureString()
|
+ "}";
|
}
|
}
|
|
@GuardedBy("mPendingItems")
|
private final Deque<PendingItem> mPendingItems = new LinkedBlockingDeque<>();
|
|
public ShortcutBitmapSaver(ShortcutService service) {
|
mService = service;
|
// mLock = lock;
|
}
|
|
public boolean waitForAllSavesLocked() {
|
final CountDownLatch latch = new CountDownLatch(1);
|
|
mExecutor.execute(() -> latch.countDown());
|
|
try {
|
if (latch.await(SAVE_WAIT_TIMEOUT_MS, TimeUnit.MILLISECONDS)) {
|
return true;
|
}
|
mService.wtf("Timed out waiting on saving bitmaps.");
|
} catch (InterruptedException e) {
|
Slog.w(TAG, "interrupted");
|
}
|
return false;
|
}
|
|
/**
|
* Wait for all pending saves to finish, and then return the given shortcut's bitmap path.
|
*/
|
@Nullable
|
public String getBitmapPathMayWaitLocked(ShortcutInfo shortcut) {
|
final boolean success = waitForAllSavesLocked();
|
if (success && shortcut.hasIconFile()) {
|
return shortcut.getBitmapPath();
|
} else {
|
return null;
|
}
|
}
|
|
public void removeIcon(ShortcutInfo shortcut) {
|
// Do not remove the actual bitmap file yet, because if the device crashes before saving
|
// the XML we'd lose the icon. We just remove all dangling files after saving the XML.
|
shortcut.setIconResourceId(0);
|
shortcut.setIconResName(null);
|
shortcut.setBitmapPath(null);
|
shortcut.clearFlags(ShortcutInfo.FLAG_HAS_ICON_FILE |
|
ShortcutInfo.FLAG_ADAPTIVE_BITMAP | ShortcutInfo.FLAG_HAS_ICON_RES |
|
ShortcutInfo.FLAG_ICON_FILE_PENDING_SAVE);
|
}
|
|
public void saveBitmapLocked(ShortcutInfo shortcut,
|
int maxDimension, CompressFormat format, int quality) {
|
final Icon icon = shortcut.getIcon();
|
Preconditions.checkNotNull(icon);
|
|
final Bitmap original = icon.getBitmap();
|
if (original == null) {
|
Log.e(TAG, "Missing icon: " + shortcut);
|
return;
|
}
|
|
// Compress it and enqueue to the requests.
|
final byte[] bytes;
|
final StrictMode.ThreadPolicy oldPolicy = StrictMode.getThreadPolicy();
|
try {
|
// compress() triggers a slow call, but in this case it's needed to save RAM and also
|
// the target bitmap is of an icon size, so let's just permit it.
|
StrictMode.setThreadPolicy(new ThreadPolicy.Builder(oldPolicy)
|
.permitCustomSlowCalls()
|
.build());
|
final Bitmap shrunk = mService.shrinkBitmap(original, maxDimension);
|
try {
|
try (final ByteArrayOutputStream out = new ByteArrayOutputStream(64 * 1024)) {
|
if (!shrunk.compress(format, quality, out)) {
|
Slog.wtf(ShortcutService.TAG, "Unable to compress bitmap");
|
}
|
out.flush();
|
bytes = out.toByteArray();
|
out.close();
|
}
|
} finally {
|
if (shrunk != original) {
|
shrunk.recycle();
|
}
|
}
|
} catch (IOException | RuntimeException | OutOfMemoryError e) {
|
Slog.wtf(ShortcutService.TAG, "Unable to write bitmap to file", e);
|
return;
|
} finally {
|
StrictMode.setThreadPolicy(oldPolicy);
|
}
|
|
shortcut.addFlags(
|
ShortcutInfo.FLAG_HAS_ICON_FILE | ShortcutInfo.FLAG_ICON_FILE_PENDING_SAVE);
|
|
if (icon.getType() == Icon.TYPE_ADAPTIVE_BITMAP) {
|
shortcut.addFlags(ShortcutInfo.FLAG_ADAPTIVE_BITMAP);
|
}
|
|
// Enqueue a pending save.
|
final PendingItem item = new PendingItem(shortcut, bytes);
|
synchronized (mPendingItems) {
|
mPendingItems.add(item);
|
}
|
|
if (DEBUG) {
|
Slog.d(TAG, "Scheduling to save: " + item);
|
}
|
|
mExecutor.execute(mRunnable);
|
}
|
|
private final Runnable mRunnable = () -> {
|
// Process all pending items.
|
while (processPendingItems()) {
|
}
|
};
|
|
/**
|
* Takes a {@link PendingItem} from {@link #mPendingItems} and process it.
|
*
|
* Must be called {@link #mExecutor}.
|
*
|
* @return true if it processed an item, false if the queue is empty.
|
*/
|
private boolean processPendingItems() {
|
if (ADD_DELAY_BEFORE_SAVE_FOR_TEST) {
|
Slog.w(TAG, "*** ARTIFICIAL SLEEP ***");
|
try {
|
Thread.sleep(SAVE_DELAY_MS_FOR_TEST);
|
} catch (InterruptedException e) {
|
}
|
}
|
|
// NOTE:
|
// Ideally we should be holding the service lock when accessing shortcut instances,
|
// but that could cause a deadlock so we don't do it.
|
//
|
// Instead, waitForAllSavesLocked() uses a latch to make sure changes made on this
|
// thread is visible on the caller thread.
|
|
ShortcutInfo shortcut = null;
|
try {
|
final PendingItem item;
|
|
synchronized (mPendingItems) {
|
if (mPendingItems.size() == 0) {
|
return false;
|
}
|
item = mPendingItems.pop();
|
}
|
|
shortcut = item.shortcut;
|
|
// See if the shortcut is still relevant. (It might have been removed already.)
|
if (!shortcut.isIconPendingSave()) {
|
return true;
|
}
|
|
if (DEBUG) {
|
Slog.d(TAG, "Saving bitmap: " + item);
|
}
|
|
File file = null;
|
try {
|
final FileOutputStreamWithPath out = mService.openIconFileForWrite(
|
shortcut.getUserId(), shortcut);
|
file = out.getFile();
|
|
try {
|
out.write(item.bytes);
|
} finally {
|
IoUtils.closeQuietly(out);
|
}
|
|
shortcut.setBitmapPath(file.getAbsolutePath());
|
|
} catch (IOException | RuntimeException e) {
|
Slog.e(ShortcutService.TAG, "Unable to write bitmap to file", e);
|
|
if (file != null && file.exists()) {
|
file.delete();
|
}
|
return true;
|
}
|
} finally {
|
if (DEBUG) {
|
Slog.d(TAG, "Saved bitmap.");
|
}
|
if (shortcut != null) {
|
if (shortcut.getBitmapPath() == null) {
|
removeIcon(shortcut);
|
}
|
|
// Whatever happened, remove this flag.
|
shortcut.clearFlags(ShortcutInfo.FLAG_ICON_FILE_PENDING_SAVE);
|
}
|
}
|
return true;
|
}
|
|
public void dumpLocked(@NonNull PrintWriter pw, @NonNull String prefix) {
|
synchronized (mPendingItems) {
|
final int N = mPendingItems.size();
|
pw.print(prefix);
|
pw.println("Pending saves: Num=" + N + " Executor=" + mExecutor);
|
|
for (PendingItem item : mPendingItems) {
|
pw.print(prefix);
|
pw.print(" ");
|
pw.println(item);
|
}
|
}
|
}
|
}
|
