Merge "Global app standby flag" (77dadd93) · Commits · e / os / android_frameworks_base

core/java/android/provider/Settings.java

+12 −2

Original line number	Original line	Diff line number	Diff line
	@@ -9587,9 +9587,10 @@ public final class Settings {
	/**		/**
	* App standby (app idle) specific settings.		* App standby (app idle) specific settings.
	* This is encoded as a key=value list, separated by commas. Ex:		* This is encoded as a key=value list, separated by commas. Ex:
	*		* <p>
	* "idle_duration=5000,parole_interval=4500"		* "idle_duration=5000,parole_interval=4500"
	*		* <p>
			* All durations are in millis.
	* The following keys are supported:		* The following keys are supported:
	*		*
	* <pre>		* <pre>
	@@ -9738,6 +9739,15 @@ public final class Settings {
	*/		*/
	public static final String TEXT_CLASSIFIER_CONSTANTS = "text_classifier_constants";		public static final String TEXT_CLASSIFIER_CONSTANTS = "text_classifier_constants";

			/**
			* Whether or not App Standby feature is enabled. This controls throttling of apps
			* based on usage patterns and predictions.
			* Type: int (0 for false, 1 for true)
			* Default: 1
			* @hide
			*/
			public static final java.lang.String APP_STANDBY_ENABLED = "app_standby_enabled";

	/**		/**
	* Get the key that retrieves a bluetooth headset's priority.		* Get the key that retrieves a bluetooth headset's priority.
	* @hide		* @hide

core/tests/coretests/src/android/provider/SettingsBackupTest.java

+1 −0

Original line number	Original line	Diff line number	Diff line
	@@ -106,6 +106,7 @@ public class SettingsBackupTest {
	Settings.Global.APN_DB_UPDATE_CONTENT_URL,		Settings.Global.APN_DB_UPDATE_CONTENT_URL,
	Settings.Global.APN_DB_UPDATE_METADATA_URL,		Settings.Global.APN_DB_UPDATE_METADATA_URL,
	Settings.Global.APP_IDLE_CONSTANTS,		Settings.Global.APP_IDLE_CONSTANTS,
			Settings.Global.APP_STANDBY_ENABLED,
	Settings.Global.ASSISTED_GPS_ENABLED,		Settings.Global.ASSISTED_GPS_ENABLED,
	Settings.Global.AUDIO_SAFE_VOLUME_STATE,		Settings.Global.AUDIO_SAFE_VOLUME_STATE,
	Settings.Global.BATTERY_DISCHARGE_DURATION_THRESHOLD,		Settings.Global.BATTERY_DISCHARGE_DURATION_THRESHOLD,

services/usage/java/com/android/server/usage/AppIdleHistory.java

+29 −18

Original line number	Original line	Diff line number	Diff line
	@@ -16,6 +16,15 @@

	package com.android.server.usage;		package com.android.server.usage;

			import static android.app.usage.UsageStatsManager.REASON_DEFAULT;
			import static android.app.usage.UsageStatsManager.REASON_FORCED;
			import static android.app.usage.UsageStatsManager.REASON_PREDICTED;
			import static android.app.usage.UsageStatsManager.REASON_USAGE;
			import static android.app.usage.UsageStatsManager.STANDBY_BUCKET_ACTIVE;
			import static android.app.usage.UsageStatsManager.STANDBY_BUCKET_NEVER;
			import static android.app.usage.UsageStatsManager.STANDBY_BUCKET_RARE;
			import static android.app.usage.UsageStatsManager.STANDBY_BUCKET_WORKING_SET;

	import android.app.usage.UsageStatsManager;		import android.app.usage.UsageStatsManager;
	import android.os.SystemClock;		import android.os.SystemClock;
	import android.util.ArrayMap;		import android.util.ArrayMap;
	@@ -197,14 +206,14 @@ public class AppIdleHistory {
	+ (elapsedRealtime - mElapsedSnapshot);		+ (elapsedRealtime - mElapsedSnapshot);
	appUsageHistory.lastUsedScreenTime = getScreenOnTime(elapsedRealtime);		appUsageHistory.lastUsedScreenTime = getScreenOnTime(elapsedRealtime);
	appUsageHistory.recent[HISTORY_SIZE - 1] = FLAG_LAST_STATE \| FLAG_PARTIAL_ACTIVE;		appUsageHistory.recent[HISTORY_SIZE - 1] = FLAG_LAST_STATE \| FLAG_PARTIAL_ACTIVE;
	if (appUsageHistory.currentBucket > UsageStatsManager.STANDBY_BUCKET_ACTIVE) {		if (appUsageHistory.currentBucket > STANDBY_BUCKET_ACTIVE) {
	appUsageHistory.currentBucket = UsageStatsManager.STANDBY_BUCKET_ACTIVE;		appUsageHistory.currentBucket = STANDBY_BUCKET_ACTIVE;
	if (DEBUG) {		if (DEBUG) {
	Slog.d(TAG, "Moved " + packageName + " to bucket=" + appUsageHistory.currentBucket		Slog.d(TAG, "Moved " + packageName + " to bucket=" + appUsageHistory.currentBucket
	+ ", reason=" + appUsageHistory.bucketingReason);		+ ", reason=" + appUsageHistory.bucketingReason);
	}		}
	}		}
	appUsageHistory.bucketingReason = UsageStatsManager.REASON_USAGE;		appUsageHistory.bucketingReason = REASON_USAGE;

	return appUsageHistory.currentBucket;		return appUsageHistory.currentBucket;
	}		}
	@@ -213,15 +222,15 @@ public class AppIdleHistory {
	ArrayMap<String, AppUsageHistory> userHistory = getUserHistory(userId);		ArrayMap<String, AppUsageHistory> userHistory = getUserHistory(userId);
	AppUsageHistory appUsageHistory = getPackageHistory(userHistory, packageName,		AppUsageHistory appUsageHistory = getPackageHistory(userHistory, packageName,
	elapsedRealtime, true);		elapsedRealtime, true);
	if (appUsageHistory.currentBucket > UsageStatsManager.STANDBY_BUCKET_WORKING_SET) {		if (appUsageHistory.currentBucket > STANDBY_BUCKET_WORKING_SET) {
	appUsageHistory.currentBucket = UsageStatsManager.STANDBY_BUCKET_WORKING_SET;		appUsageHistory.currentBucket = STANDBY_BUCKET_WORKING_SET;
	if (DEBUG) {		if (DEBUG) {
	Slog.d(TAG, "Moved " + packageName + " to bucket=" + appUsageHistory.currentBucket		Slog.d(TAG, "Moved " + packageName + " to bucket=" + appUsageHistory.currentBucket
	+ ", reason=" + appUsageHistory.bucketingReason);		+ ", reason=" + appUsageHistory.bucketingReason);
	}		}
	}		}
	// TODO: Should this be a different reason for partial usage?		// TODO: Should this be a different reason for partial usage?
	appUsageHistory.bucketingReason = UsageStatsManager.REASON_USAGE;		appUsageHistory.bucketingReason = REASON_USAGE;

	return appUsageHistory.currentBucket;		return appUsageHistory.currentBucket;
	}		}
	@@ -279,8 +288,8 @@ public class AppIdleHistory {
	appUsageHistory.lastUsedElapsedTime = getElapsedTime(elapsedRealtime);		appUsageHistory.lastUsedElapsedTime = getElapsedTime(elapsedRealtime);
	appUsageHistory.lastUsedScreenTime = getScreenOnTime(elapsedRealtime);		appUsageHistory.lastUsedScreenTime = getScreenOnTime(elapsedRealtime);
	appUsageHistory.lastPredictedTime = getElapsedTime(0);		appUsageHistory.lastPredictedTime = getElapsedTime(0);
	appUsageHistory.currentBucket = UsageStatsManager.STANDBY_BUCKET_NEVER;		appUsageHistory.currentBucket = STANDBY_BUCKET_NEVER;
	appUsageHistory.bucketingReason = UsageStatsManager.REASON_DEFAULT;		appUsageHistory.bucketingReason = REASON_DEFAULT;
	appUsageHistory.lastInformedBucket = -1;		appUsageHistory.lastInformedBucket = -1;
	userHistory.put(packageName, appUsageHistory);		userHistory.put(packageName, appUsageHistory);
	}		}
	@@ -298,7 +307,7 @@ public class AppIdleHistory {
	if (appUsageHistory == null) {		if (appUsageHistory == null) {
	return false; // Default to not idle		return false; // Default to not idle
	} else {		} else {
	return appUsageHistory.currentBucket >= UsageStatsManager.STANDBY_BUCKET_RARE;		return appUsageHistory.currentBucket >= STANDBY_BUCKET_RARE;
	// Whether or not it's passed will now be externally calculated and the		// Whether or not it's passed will now be externally calculated and the
	// bucket will be pushed to the history using setAppStandbyBucket()		// bucket will be pushed to the history using setAppStandbyBucket()
	//return hasPassedThresholds(appUsageHistory, elapsedRealtime);		//return hasPassedThresholds(appUsageHistory, elapsedRealtime);
	@@ -320,7 +329,7 @@ public class AppIdleHistory {
	getPackageHistory(userHistory, packageName, elapsedRealtime, true);		getPackageHistory(userHistory, packageName, elapsedRealtime, true);
	appUsageHistory.currentBucket = bucket;		appUsageHistory.currentBucket = bucket;
	appUsageHistory.bucketingReason = reason;		appUsageHistory.bucketingReason = reason;
	if (reason.startsWith(UsageStatsManager.REASON_PREDICTED)) {		if (reason.startsWith(REASON_PREDICTED)) {
	appUsageHistory.lastPredictedTime = getElapsedTime(elapsedRealtime);		appUsageHistory.lastPredictedTime = getElapsedTime(elapsedRealtime);
	}		}
	if (DEBUG) {		if (DEBUG) {
	@@ -336,12 +345,14 @@ public class AppIdleHistory {
	return appUsageHistory.currentBucket;		return appUsageHistory.currentBucket;
	}		}

	public Map<String, Integer> getAppStandbyBuckets(int userId, long elapsedRealtime) {		public Map<String, Integer> getAppStandbyBuckets(int userId, long elapsedRealtime,
			boolean appIdleEnabled) {
	ArrayMap<String, AppUsageHistory> userHistory = getUserHistory(userId);		ArrayMap<String, AppUsageHistory> userHistory = getUserHistory(userId);
	int size = userHistory.size();		int size = userHistory.size();
	HashMap<String, Integer> buckets = new HashMap<>(size);		HashMap<String, Integer> buckets = new HashMap<>(size);
	for (int i = 0; i < size; i++) {		for (int i = 0; i < size; i++) {
	buckets.put(userHistory.keyAt(i), userHistory.valueAt(i).currentBucket);		buckets.put(userHistory.keyAt(i),
			appIdleEnabled ? userHistory.valueAt(i).currentBucket : STANDBY_BUCKET_ACTIVE);
	}		}
	return buckets;		return buckets;
	}		}
	@@ -363,12 +374,12 @@ public class AppIdleHistory {
	AppUsageHistory appUsageHistory = getPackageHistory(userHistory, packageName,		AppUsageHistory appUsageHistory = getPackageHistory(userHistory, packageName,
	elapsedRealtime, true);		elapsedRealtime, true);
	if (idle) {		if (idle) {
	appUsageHistory.currentBucket = UsageStatsManager.STANDBY_BUCKET_RARE;		appUsageHistory.currentBucket = STANDBY_BUCKET_RARE;
	appUsageHistory.bucketingReason = UsageStatsManager.REASON_FORCED;		appUsageHistory.bucketingReason = REASON_FORCED;
	} else {		} else {
	appUsageHistory.currentBucket = UsageStatsManager.STANDBY_BUCKET_ACTIVE;		appUsageHistory.currentBucket = STANDBY_BUCKET_ACTIVE;
	// This is to pretend that the app was just used, don't freeze the state anymore.		// This is to pretend that the app was just used, don't freeze the state anymore.
	appUsageHistory.bucketingReason = UsageStatsManager.REASON_USAGE;		appUsageHistory.bucketingReason = REASON_USAGE;
	}		}
	return appUsageHistory.currentBucket;		return appUsageHistory.currentBucket;
	}		}
	@@ -471,12 +482,12 @@ public class AppIdleHistory {
	String currentBucketString = parser.getAttributeValue(null,		String currentBucketString = parser.getAttributeValue(null,
	ATTR_CURRENT_BUCKET);		ATTR_CURRENT_BUCKET);
	appUsageHistory.currentBucket = currentBucketString == null		appUsageHistory.currentBucket = currentBucketString == null
	? UsageStatsManager.STANDBY_BUCKET_ACTIVE		? STANDBY_BUCKET_ACTIVE
	: Integer.parseInt(currentBucketString);		: Integer.parseInt(currentBucketString);
	appUsageHistory.bucketingReason =		appUsageHistory.bucketingReason =
	parser.getAttributeValue(null, ATTR_BUCKETING_REASON);		parser.getAttributeValue(null, ATTR_BUCKETING_REASON);
	if (appUsageHistory.bucketingReason == null) {		if (appUsageHistory.bucketingReason == null) {
	appUsageHistory.bucketingReason = UsageStatsManager.REASON_DEFAULT;		appUsageHistory.bucketingReason = REASON_DEFAULT;
	}		}
	appUsageHistory.lastInformedBucket = -1;		appUsageHistory.lastInformedBucket = -1;
	userHistory.put(packageName, appUsageHistory);		userHistory.put(packageName, appUsageHistory);

services/usage/java/com/android/server/usage/AppStandbyController.java

+52 −23

Original line number	Original line	Diff line number	Diff line
	@@ -162,12 +162,14 @@ public class AppStandbyController {
	long[] mAppStandbyScreenThresholds = SCREEN_TIME_THRESHOLDS;		long[] mAppStandbyScreenThresholds = SCREEN_TIME_THRESHOLDS;
	long[] mAppStandbyElapsedThresholds = ELAPSED_TIME_THRESHOLDS;		long[] mAppStandbyElapsedThresholds = ELAPSED_TIME_THRESHOLDS;

	boolean mAppIdleEnabled;		volatile boolean mAppIdleEnabled;
	boolean mAppIdleTempParoled;		boolean mAppIdleTempParoled;
	boolean mCharging;		boolean mCharging;
	private long mLastAppIdleParoledTime;		private long mLastAppIdleParoledTime;
	private boolean mSystemServicesReady = false;		private boolean mSystemServicesReady = false;

			private final DeviceStateReceiver mDeviceStateReceiver;

	private volatile boolean mPendingOneTimeCheckIdleStates;		private volatile boolean mPendingOneTimeCheckIdleStates;

	private final AppStandbyHandler mHandler;		private final AppStandbyHandler mHandler;
	@@ -178,7 +180,7 @@ public class AppStandbyController {
	private AppWidgetManager mAppWidgetManager;		private AppWidgetManager mAppWidgetManager;
	private PowerManager mPowerManager;		private PowerManager mPowerManager;
	private PackageManager mPackageManager;		private PackageManager mPackageManager;
	private Injector mInjector;		Injector mInjector;


	AppStandbyController(Context context, Looper looper) {		AppStandbyController(Context context, Looper looper) {
	@@ -190,14 +192,13 @@ public class AppStandbyController {
	mContext = mInjector.getContext();		mContext = mInjector.getContext();
	mHandler = new AppStandbyHandler(mInjector.getLooper());		mHandler = new AppStandbyHandler(mInjector.getLooper());
	mPackageManager = mContext.getPackageManager();		mPackageManager = mContext.getPackageManager();
	mAppIdleEnabled = mInjector.isAppIdleEnabled();		mDeviceStateReceiver = new DeviceStateReceiver();

	if (mAppIdleEnabled) {
	IntentFilter deviceStates = new IntentFilter(Intent.ACTION_BATTERY_CHANGED);		IntentFilter deviceStates = new IntentFilter(Intent.ACTION_BATTERY_CHANGED);
	deviceStates.addAction(BatteryManager.ACTION_DISCHARGING);		deviceStates.addAction(BatteryManager.ACTION_DISCHARGING);
	deviceStates.addAction(PowerManager.ACTION_DEVICE_IDLE_MODE_CHANGED);		deviceStates.addAction(PowerManager.ACTION_DEVICE_IDLE_MODE_CHANGED);
	mContext.registerReceiver(new DeviceStateReceiver(), deviceStates);		mContext.registerReceiver(mDeviceStateReceiver, deviceStates);
	}
	synchronized (mAppIdleLock) {		synchronized (mAppIdleLock) {
	mAppIdleHistory = new AppIdleHistory(mInjector.getDataSystemDirectory(),		mAppIdleHistory = new AppIdleHistory(mInjector.getDataSystemDirectory(),
	mInjector.elapsedRealtime());		mInjector.elapsedRealtime());
	@@ -213,9 +214,14 @@ public class AppStandbyController {
	null, mHandler);		null, mHandler);
	}		}

			void setAppIdleEnabled(boolean enabled) {
			mAppIdleEnabled = enabled;
			}

	public void onBootPhase(int phase) {		public void onBootPhase(int phase) {
	mInjector.onBootPhase(phase);		mInjector.onBootPhase(phase);
	if (phase == PHASE_SYSTEM_SERVICES_READY) {		if (phase == PHASE_SYSTEM_SERVICES_READY) {
			setAppIdleEnabled(mInjector.isAppIdleEnabled());
	// Observe changes to the threshold		// Observe changes to the threshold
	SettingsObserver settingsObserver = new SettingsObserver(mHandler);		SettingsObserver settingsObserver = new SettingsObserver(mHandler);
	settingsObserver.registerObserver();		settingsObserver.registerObserver();
	@@ -240,6 +246,8 @@ public class AppStandbyController {
	}		}

	void reportContentProviderUsage(String authority, String providerPkgName, int userId) {		void reportContentProviderUsage(String authority, String providerPkgName, int userId) {
			if (!mAppIdleEnabled) return;

	// Get sync adapters for the authority		// Get sync adapters for the authority
	String[] packages = ContentResolver.getSyncAdapterPackagesForAuthorityAsUser(		String[] packages = ContentResolver.getSyncAdapterPackagesForAuthorityAsUser(
	authority, userId);		authority, userId);
	@@ -295,6 +303,7 @@ public class AppStandbyController {
	}		}

	boolean isParoledOrCharging() {		boolean isParoledOrCharging() {
			if (!mAppIdleEnabled) return true;
	synchronized (mAppIdleLock) {		synchronized (mAppIdleLock) {
	return mAppIdleTempParoled \|\| mCharging;		return mAppIdleTempParoled \|\| mCharging;
	}		}
	@@ -520,6 +529,7 @@ public class AppStandbyController {
	}		}

	void reportEvent(UsageEvents.Event event, long elapsedRealtime, int userId) {		void reportEvent(UsageEvents.Event event, long elapsedRealtime, int userId) {
			if (!mAppIdleEnabled) return;
	synchronized (mAppIdleLock) {		synchronized (mAppIdleLock) {
	// TODO: Ideally this should call isAppIdleFiltered() to avoid calling back		// TODO: Ideally this should call isAppIdleFiltered() to avoid calling back
	// about apps that are on some kind of whitelist anyway.		// about apps that are on some kind of whitelist anyway.
	@@ -559,6 +569,8 @@ public class AppStandbyController {
	* required.		* required.
	*/		*/
	void forceIdleState(String packageName, int userId, boolean idle) {		void forceIdleState(String packageName, int userId, boolean idle) {
			if (!mAppIdleEnabled) return;

	final int appId = getAppId(packageName);		final int appId = getAppId(packageName);
	if (appId < 0) return;		if (appId < 0) return;
	final long elapsedRealtime = mInjector.elapsedRealtime();		final long elapsedRealtime = mInjector.elapsedRealtime();
	@@ -763,7 +775,7 @@ public class AppStandbyController {
	}		}

	void setAppIdleAsync(String packageName, boolean idle, int userId) {		void setAppIdleAsync(String packageName, boolean idle, int userId) {
	if (packageName == null) return;		if (packageName == null \|\| !mAppIdleEnabled) return;

	mHandler.obtainMessage(MSG_FORCE_IDLE_STATE, userId, idle ? 1 : 0, packageName)		mHandler.obtainMessage(MSG_FORCE_IDLE_STATE, userId, idle ? 1 : 0, packageName)
	.sendToTarget();		.sendToTarget();
	@@ -771,8 +783,8 @@ public class AppStandbyController {

	@StandbyBuckets public int getAppStandbyBucket(String packageName, int userId,		@StandbyBuckets public int getAppStandbyBucket(String packageName, int userId,
	long elapsedRealtime, boolean shouldObfuscateInstantApps) {		long elapsedRealtime, boolean shouldObfuscateInstantApps) {
	if (shouldObfuscateInstantApps &&		if (!mAppIdleEnabled \|\| (shouldObfuscateInstantApps
	mInjector.isPackageEphemeral(userId, packageName)) {		&& mInjector.isPackageEphemeral(userId, packageName))) {
	return STANDBY_BUCKET_ACTIVE;		return STANDBY_BUCKET_ACTIVE;
	}		}

	@@ -783,7 +795,7 @@ public class AppStandbyController {

	public Map<String, Integer> getAppStandbyBuckets(int userId, long elapsedRealtime) {		public Map<String, Integer> getAppStandbyBuckets(int userId, long elapsedRealtime) {
	synchronized (mAppIdleLock) {		synchronized (mAppIdleLock) {
	return mAppIdleHistory.getAppStandbyBuckets(userId, elapsedRealtime);		return mAppIdleHistory.getAppStandbyBuckets(userId, elapsedRealtime, mAppIdleEnabled);
	}		}
	}		}

	@@ -1058,8 +1070,11 @@ public class AppStandbyController {
	}		}

	boolean isAppIdleEnabled() {		boolean isAppIdleEnabled() {
	return mContext.getResources().getBoolean(		final boolean buildFlag = mContext.getResources().getBoolean(
	com.android.internal.R.bool.config_enableAutoPowerModes);		com.android.internal.R.bool.config_enableAutoPowerModes);
			final boolean runtimeFlag = Settings.Global.getInt(mContext.getContentResolver(),
			Settings.Global.APP_STANDBY_ENABLED, 1) == 1;
			return buildFlag && runtimeFlag;
	}		}

	boolean isCharging() {		boolean isCharging() {
	@@ -1130,7 +1145,7 @@ public class AppStandbyController {
	break;		break;

	case MSG_CHECK_IDLE_STATES:		case MSG_CHECK_IDLE_STATES:
	if (checkIdleStates(msg.arg1)) {		if (checkIdleStates(msg.arg1) && mAppIdleEnabled) {
	mHandler.sendMessageDelayed(mHandler.obtainMessage(		mHandler.sendMessageDelayed(mHandler.obtainMessage(
	MSG_CHECK_IDLE_STATES, msg.arg1, 0),		MSG_CHECK_IDLE_STATES, msg.arg1, 0),
	mCheckIdleIntervalMillis);		mCheckIdleIntervalMillis);
	@@ -1229,6 +1244,8 @@ public class AppStandbyController {
	void registerObserver() {		void registerObserver() {
	mContext.getContentResolver().registerContentObserver(Settings.Global.getUriFor(		mContext.getContentResolver().registerContentObserver(Settings.Global.getUriFor(
	Settings.Global.APP_IDLE_CONSTANTS), false, this);		Settings.Global.APP_IDLE_CONSTANTS), false, this);
			mContext.getContentResolver().registerContentObserver(Settings.Global.getUriFor(
			Settings.Global.APP_STANDBY_ENABLED), false, this);
	}		}

	@Override		@Override
	@@ -1238,7 +1255,17 @@ public class AppStandbyController {
	}		}

	void updateSettings() {		void updateSettings() {
	synchronized (mAppIdleLock) {		if (DEBUG) {
			Slog.d(TAG,
			"appidle=" + Settings.Global.getString(mContext.getContentResolver(),
			Settings.Global.APP_STANDBY_ENABLED));
			Slog.d(TAG, "appidleconstants=" + Settings.Global.getString(
			mContext.getContentResolver(),
			Settings.Global.APP_IDLE_CONSTANTS));
			}
			// Check if app_idle_enabled has changed
			setAppIdleEnabled(mInjector.isAppIdleEnabled());

	// Look at global settings for this.		// Look at global settings for this.
	// TODO: Maybe apply different thresholds for different users.		// TODO: Maybe apply different thresholds for different users.
	try {		try {
	@@ -1248,6 +1275,8 @@ public class AppStandbyController {
	// fallthrough, mParser is empty and all defaults will be returned.		// fallthrough, mParser is empty and all defaults will be returned.
	}		}

			synchronized (mAppIdleLock) {

	// Default: 24 hours between paroles		// Default: 24 hours between paroles
	mAppIdleParoleIntervalMillis = mParser.getLong(KEY_PAROLE_INTERVAL,		mAppIdleParoleIntervalMillis = mParser.getLong(KEY_PAROLE_INTERVAL,
	COMPRESS_TIME ? ONE_MINUTE * 10 : 24 * 60 * ONE_MINUTE);		COMPRESS_TIME ? ONE_MINUTE * 10 : 24 * 60 * ONE_MINUTE);