mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-10-31 14:15:30 +00:00
234 lines
9.1 KiB
Java
234 lines
9.1 KiB
Java
/* -*- Mode: Java; c-basic-offset: 4; tab-width: 20; indent-tabs-mode: nil; -*-
|
|
* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
package org.mozilla.gecko;
|
|
|
|
import org.mozilla.gecko.db.BrowserDB;
|
|
import org.mozilla.gecko.db.BrowserContract;
|
|
|
|
import android.content.BroadcastReceiver;
|
|
import android.content.ComponentCallbacks2;
|
|
import android.content.Context;
|
|
import android.content.Intent;
|
|
import android.content.IntentFilter;
|
|
import android.os.Build;
|
|
import android.os.Debug;
|
|
import android.util.Log;
|
|
|
|
/**
|
|
* This is a utility class to keep track of how much memory and disk-space pressure
|
|
* the system is under. It receives input from GeckoActivity via the onLowMemory() and
|
|
* onTrimMemory() functions, and also listens for some system intents related to
|
|
* disk-space notifications. Internally it will track how much memory and disk pressure
|
|
* the system is under, and perform various actions to help alleviate the pressure.
|
|
*
|
|
* Note that since there is no notification for when the system has lots of free memory
|
|
* again, this class also assumes that, over time, the system will free up memory. This
|
|
* assumption is implemented using a timer that slowly lowers the internal memory
|
|
* pressure state if no new low-memory notifications are received.
|
|
*
|
|
* Synchronization note: MemoryMonitor contains an inner class PressureDecrementer. Both
|
|
* of these classes may be accessed from various threads, and have both been designed to
|
|
* be thread-safe. In terms of lock ordering, code holding the PressureDecrementer lock
|
|
* is allowed to pick up the MemoryMonitor lock, but not vice-versa.
|
|
*/
|
|
class MemoryMonitor extends BroadcastReceiver {
|
|
private static final String LOGTAG = "GeckoMemoryMonitor";
|
|
private static final String ACTION_MEMORY_DUMP = "org.mozilla.gecko.MEMORY_DUMP";
|
|
private static final String ACTION_FORCE_PRESSURE = "org.mozilla.gecko.FORCE_MEMORY_PRESSURE";
|
|
|
|
private static final int MEMORY_PRESSURE_NONE = 0;
|
|
private static final int MEMORY_PRESSURE_CLEANUP = 1;
|
|
private static final int MEMORY_PRESSURE_LOW = 2;
|
|
private static final int MEMORY_PRESSURE_MEDIUM = 3;
|
|
private static final int MEMORY_PRESSURE_HIGH = 4;
|
|
|
|
private static MemoryMonitor sInstance = new MemoryMonitor();
|
|
|
|
static MemoryMonitor getInstance() {
|
|
return sInstance;
|
|
}
|
|
|
|
private final PressureDecrementer mPressureDecrementer;
|
|
private int mMemoryPressure;
|
|
private boolean mStoragePressure;
|
|
|
|
private MemoryMonitor() {
|
|
mPressureDecrementer = new PressureDecrementer();
|
|
mMemoryPressure = MEMORY_PRESSURE_NONE;
|
|
mStoragePressure = false;
|
|
}
|
|
|
|
public void init(Context context) {
|
|
IntentFilter filter = new IntentFilter();
|
|
filter.addAction(Intent.ACTION_DEVICE_STORAGE_LOW);
|
|
filter.addAction(Intent.ACTION_DEVICE_STORAGE_OK);
|
|
filter.addAction(ACTION_MEMORY_DUMP);
|
|
filter.addAction(ACTION_FORCE_PRESSURE);
|
|
context.getApplicationContext().registerReceiver(this, filter);
|
|
}
|
|
|
|
public void onLowMemory() {
|
|
Log.d(LOGTAG, "onLowMemory() notification received");
|
|
increaseMemoryPressure(MEMORY_PRESSURE_HIGH);
|
|
}
|
|
|
|
public void onTrimMemory(int level) {
|
|
Log.d(LOGTAG, "onTrimMemory() notification received with level " + level);
|
|
if (Build.VERSION.SDK_INT < 14) {
|
|
// this won't even get called pre-ICS
|
|
return;
|
|
}
|
|
|
|
if (level >= ComponentCallbacks2.TRIM_MEMORY_COMPLETE) {
|
|
increaseMemoryPressure(MEMORY_PRESSURE_HIGH);
|
|
} else if (level >= ComponentCallbacks2.TRIM_MEMORY_MODERATE) {
|
|
increaseMemoryPressure(MEMORY_PRESSURE_MEDIUM);
|
|
} else if (level >= ComponentCallbacks2.TRIM_MEMORY_UI_HIDDEN) {
|
|
// includes TRIM_MEMORY_BACKGROUND
|
|
increaseMemoryPressure(MEMORY_PRESSURE_CLEANUP);
|
|
} else {
|
|
if (Build.VERSION.SDK_INT < 16) {
|
|
// in SDK 14 and 15 we don't have these extra fine-grained levels so
|
|
// just default to low (we already know it's < TRIM_MEMORY_UI_HIDDEN)
|
|
increaseMemoryPressure(MEMORY_PRESSURE_LOW);
|
|
} else if (level >= ComponentCallbacks2.TRIM_MEMORY_RUNNING_CRITICAL) {
|
|
increaseMemoryPressure(MEMORY_PRESSURE_HIGH);
|
|
} else if (level >= ComponentCallbacks2.TRIM_MEMORY_RUNNING_LOW) {
|
|
increaseMemoryPressure(MEMORY_PRESSURE_MEDIUM);
|
|
} else {
|
|
increaseMemoryPressure(MEMORY_PRESSURE_LOW);
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void onReceive(Context context, Intent intent) {
|
|
if (Intent.ACTION_DEVICE_STORAGE_LOW.equals(intent.getAction())) {
|
|
Log.d(LOGTAG, "Device storage is low");
|
|
mStoragePressure = true;
|
|
GeckoAppShell.getHandler().post(new StorageReducer(context));
|
|
} else if (Intent.ACTION_DEVICE_STORAGE_OK.equals(intent.getAction())) {
|
|
Log.d(LOGTAG, "Device storage is ok");
|
|
mStoragePressure = false;
|
|
} else if (ACTION_MEMORY_DUMP.equals(intent.getAction())) {
|
|
String label = intent.getStringExtra("label");
|
|
if (label == null) {
|
|
label = "default";
|
|
}
|
|
GeckoAppShell.sendEventToGecko(GeckoEvent.createBroadcastEvent("Memory:Dump", label));
|
|
} else if (ACTION_FORCE_PRESSURE.equals(intent.getAction())) {
|
|
increaseMemoryPressure(MEMORY_PRESSURE_HIGH);
|
|
}
|
|
}
|
|
|
|
private void increaseMemoryPressure(int level) {
|
|
int oldLevel;
|
|
synchronized (this) {
|
|
// bump up our level if we're not already higher
|
|
if (mMemoryPressure > level) {
|
|
return;
|
|
}
|
|
oldLevel = mMemoryPressure;
|
|
mMemoryPressure = level;
|
|
}
|
|
|
|
// since we don't get notifications for when memory pressure is off,
|
|
// we schedule our own timer to slowly back off the memory pressure level.
|
|
// note that this will reset the time to next decrement if the decrementer
|
|
// is already running, which is the desired behaviour because we just got
|
|
// a new low-mem notification.
|
|
mPressureDecrementer.start();
|
|
|
|
if (oldLevel == level) {
|
|
// if we're not going to a higher level we probably don't
|
|
// need to run another round of the same memory reductions
|
|
// we did on the last memory pressure increase.
|
|
return;
|
|
}
|
|
|
|
// TODO hook in memory-reduction stuff for different levels here
|
|
if (level >= MEMORY_PRESSURE_MEDIUM) {
|
|
if (GeckoApp.checkLaunchState(GeckoApp.LaunchState.GeckoRunning)) {
|
|
GeckoAppShell.onLowMemory();
|
|
}
|
|
ScreenshotHandler.disableScreenshot(false);
|
|
GeckoAppShell.geckoEventSync();
|
|
Favicons.getInstance().clearMemCache();
|
|
}
|
|
}
|
|
|
|
private boolean decreaseMemoryPressure() {
|
|
int newLevel;
|
|
synchronized (this) {
|
|
if (mMemoryPressure <= 0) {
|
|
return false;
|
|
}
|
|
|
|
newLevel = --mMemoryPressure;
|
|
}
|
|
Log.d(LOGTAG, "Decreased memory pressure to " + newLevel);
|
|
|
|
if (newLevel == MEMORY_PRESSURE_NONE) {
|
|
ScreenshotHandler.enableScreenshot(false);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
class PressureDecrementer implements Runnable {
|
|
private static final int DECREMENT_DELAY = 5 * 60 * 1000; // 5 minutes
|
|
|
|
private boolean mPosted;
|
|
|
|
synchronized void start() {
|
|
if (mPosted) {
|
|
// cancel the old one before scheduling a new one
|
|
GeckoAppShell.getHandler().removeCallbacks(this);
|
|
}
|
|
GeckoAppShell.getHandler().postDelayed(this, DECREMENT_DELAY);
|
|
mPosted = true;
|
|
}
|
|
|
|
@Override
|
|
public synchronized void run() {
|
|
if (!decreaseMemoryPressure()) {
|
|
// done decrementing, bail out
|
|
mPosted = false;
|
|
return;
|
|
}
|
|
|
|
// need to keep decrementing
|
|
GeckoAppShell.getHandler().postDelayed(this, DECREMENT_DELAY);
|
|
}
|
|
}
|
|
|
|
class StorageReducer implements Runnable {
|
|
private final Context mContext;
|
|
public StorageReducer(final Context context) {
|
|
this.mContext = context;
|
|
}
|
|
|
|
@Override
|
|
public void run() {
|
|
// this might get run right on startup, if so wait 10 seconds and try again
|
|
if (!GeckoApp.checkLaunchState(GeckoApp.LaunchState.GeckoRunning)) {
|
|
GeckoAppShell.getHandler().postDelayed(this, 10000);
|
|
return;
|
|
}
|
|
|
|
if (!mStoragePressure) {
|
|
// pressure is off, so we can abort
|
|
return;
|
|
}
|
|
|
|
BrowserDB.expireHistory(mContext.getContentResolver(),
|
|
BrowserContract.ExpirePriority.AGGRESSIVE);
|
|
BrowserDB.removeThumbnails(Tabs.getInstance().getContentResolver());
|
|
// TODO: drop or shrink disk caches
|
|
}
|
|
}
|
|
}
|