import java.util.regex.Pattern;
import dalvik.system.CloseGuard;
-import dalvik.system.SamplingProfiler;
final class SuperNotCalledException extends AndroidRuntimeException {
public SuperNotCalledException(String msg) {
boolean restrictedBackupMode;
Configuration config;
boolean handlingProfiling;
+ Bundle coreSettings;
public String toString() {
return "AppBindData{appInfo=" + appInfo + "}";
}
ComponentName instrumentationName, String profileFile,
Bundle instrumentationArgs, IInstrumentationWatcher instrumentationWatcher,
int debugMode, boolean isRestrictedBackupMode, Configuration config,
- Map<String, IBinder> services) {
+ Map<String, IBinder> services, Bundle coreSettings) {
if (services != null) {
// Setup the service cache in the ServiceManager
data.debugMode = debugMode;
data.restrictedBackupMode = isRestrictedBackupMode;
data.config = config;
+ data.coreSettings = coreSettings;
queueOrSendMessage(H.BIND_APPLICATION, data);
}
private void printRow(PrintWriter pw, String format, Object...objs) {
pw.println(String.format(format, objs));
}
+
+ public void setCoreSettings(Bundle settings) {
+ queueOrSendMessage(H.SET_CORE_SETTINGS, settings);
+ }
}
private final class H extends Handler {
public static final int DUMP_HEAP = 135;
public static final int DUMP_ACTIVITY = 136;
public static final int SLEEPING = 137;
+ public static final int SET_CORE_SETTINGS = 138;
String codeToString(int code) {
if (DEBUG_MESSAGES) {
switch (code) {
case DUMP_HEAP: return "DUMP_HEAP";
case DUMP_ACTIVITY: return "DUMP_ACTIVITY";
case SLEEPING: return "SLEEPING";
+ case SET_CORE_SETTINGS: return "SET_CORE_SETTINGS";
}
}
return "(unknown)";
case SLEEPING:
handleSleeping((IBinder)msg.obj, msg.arg1 != 0);
break;
+ case SET_CORE_SETTINGS:
+ handleSetCoreSettings((Bundle) msg.obj);
+ break;
}
if (DEBUG_MESSAGES) Slog.v(TAG, "<<< done: " + msg.what);
}
}
}
+ private void handleSetCoreSettings(Bundle coreSettings) {
+ if (mBoundApplication != null) {
+ synchronized (mBoundApplication) {
+ mBoundApplication.coreSettings = coreSettings;
+ }
+ }
+ }
+
private final void deliverResults(ActivityClientRecord r, List<ResultInfo> results) {
final int N = results.size();
for (int i=0; i<N; i++) {
}
}
+ public int getIntCoreSetting(String key, int defaultValue) {
+ if (mBoundApplication == null) {
+ return defaultValue;
+ }
+ synchronized (mBoundApplication) {
+ Bundle coreSettings = mBoundApplication.coreSettings;
+ if (coreSettings != null) {
+ return coreSettings.getInt(key, defaultValue);
+ } else {
+ return defaultValue;
+ }
+ }
+ }
+
public static final void main(String[] args) {
SamplingProfilerIntegration.start();
public static String getInitialPackage() {
return ActivityThread.currentPackageName();
}
-
+
/**
* Return the raw interface to the package manager.
- * @return
+ * @return The package manager.
*/
public static IPackageManager getPackageManager() {
return ActivityThread.getPackageManager();
}
+
+ /**
+ * Gets the value of an integer core setting.
+ *
+ * @param key The setting key.
+ * @param defaultValue The setting default value.
+ * @return The core settings.
+ */
+ public static int getIntCoreSetting(String key, int defaultValue) {
+ return ActivityThread.currentActivityThread().getIntCoreSetting(key, defaultValue);
+ }
}
boolean restrictedBackupMode = (data.readInt() != 0);
Configuration config = Configuration.CREATOR.createFromParcel(data);
HashMap<String, IBinder> services = data.readHashMap(null);
+ Bundle coreSettings = data.readBundle();
bindApplication(packageName, info,
providers, testName, profileName,
testArgs, testWatcher, testMode, restrictedBackupMode,
- config, services);
+ config, services, coreSettings);
return true;
}
}
return true;
}
+
+ case SET_CORE_SETTINGS: {
+ data.enforceInterface(IApplicationThread.descriptor);
+ Bundle settings = data.readBundle();
+ setCoreSettings(settings);
+ return true;
+ }
}
return super.onTransact(code, data, reply, flags);
List<ProviderInfo> providers, ComponentName testName,
String profileName, Bundle testArgs, IInstrumentationWatcher testWatcher, int debugMode,
boolean restrictedBackupMode, Configuration config,
- Map<String, IBinder> services) throws RemoteException {
+ Map<String, IBinder> services, Bundle coreSettings) throws RemoteException {
Parcel data = Parcel.obtain();
data.writeInterfaceToken(IApplicationThread.descriptor);
data.writeString(packageName);
data.writeInt(restrictedBackupMode ? 1 : 0);
config.writeToParcel(data, 0);
data.writeMap(services);
+ data.writeBundle(coreSettings);
mRemote.transact(BIND_APPLICATION_TRANSACTION, data, null,
IBinder.FLAG_ONEWAY);
data.recycle();
mRemote.transact(DUMP_ACTIVITY_TRANSACTION, data, null, 0);
data.recycle();
}
+
+ public void setCoreSettings(Bundle coreSettings) throws RemoteException {
+ Parcel data = Parcel.obtain();
+ data.writeInterfaceToken(IApplicationThread.descriptor);
+ data.writeBundle(coreSettings);
+ mRemote.transact(SET_CORE_SETTINGS, data, null, IBinder.FLAG_ONEWAY);
+ }
}
void bindApplication(String packageName, ApplicationInfo info, List<ProviderInfo> providers,
ComponentName testName, String profileName, Bundle testArguments,
IInstrumentationWatcher testWatcher, int debugMode, boolean restrictedBackupMode,
- Configuration config, Map<String, IBinder> services) throws RemoteException;
+ Configuration config, Map<String, IBinder> services,
+ Bundle coreSettings) throws RemoteException;
void scheduleExit() throws RemoteException;
void scheduleSuicide() throws RemoteException;
void requestThumbnail(IBinder token) throws RemoteException;
void scheduleCrash(String msg) throws RemoteException;
void dumpActivity(FileDescriptor fd, IBinder servicetoken, String prefix, String[] args)
throws RemoteException;
+ void setCoreSettings(Bundle coreSettings) throws RemoteException;
String descriptor = "android.app.IApplicationThread";
int DUMP_ACTIVITY_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+36;
int CLEAR_DNS_CACHE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+37;
int SET_HTTP_PROXY_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+38;
+ int SET_CORE_SETTINGS = IBinder.FIRST_CALL_TRANSACTION+39;
}
"accessibility_web_content_key_bindings";
/**
+ * The timout for considering a press to be a long press in milliseconds.
+ * @hide
+ */
+ public static final String LONG_PRESS_TIMEOUT = "long_press_timeout";
+
+ /**
* Setting to always use the default text-to-speech settings regardless
* of the application settings.
* 1 = override application settings,
package android.view;
+import android.app.AppGlobals;
import android.content.Context;
import android.content.res.Configuration;
+import android.os.Bundle;
+import android.provider.Settings;
import android.util.DisplayMetrics;
import android.util.SparseArray;
* Defines the duration in milliseconds before a press turns into
* a long press
*/
- private static final int LONG_PRESS_TIMEOUT = 500;
+ private static final int DEFAULTLONG_PRESS_TIMEOUT = 500;
/**
* Defines the duration in milliseconds a user needs to hold down the
public static int getPressedStateDuration() {
return PRESSED_STATE_DURATION;
}
-
+
/**
* @return the duration in milliseconds before a press turns into
* a long press
*/
public static int getLongPressTimeout() {
- return LONG_PRESS_TIMEOUT;
+ return AppGlobals.getIntCoreSetting(Settings.Secure.LONG_PRESS_TIMEOUT,
+ DEFAULTLONG_PRESS_TIMEOUT);
}
-
+
/**
* @return the duration in milliseconds we will wait to see if a touch event
* is a tap or a scroll. If the user does not move within this interval, it is
<integer name="def_download_manager_max_bytes_over_mobile">-1</integer>
<!-- Default for Settings.Secure.DOWNLOAD_RECOMMENDED_MAX_BYTES_OVER_MOBILE. <=0 if no limit -->
<integer name="def_download_manager_recommended_max_bytes_over_mobile">-1</integer>
+
+ <!-- Default for Settings.Secure.LONG_PRESS_TIMEOUT_MILLIS -->
+ <integer name="def_long_press_timeout_millis">500</integer>
+
</resources>
upgradeVersion = 64;
}
+ if (upgradeVersion == 64) {
+ // New setting to configure the long press timeout.
+ db.beginTransaction();
+ SQLiteStatement stmt = null;
+ try {
+ stmt = db.compileStatement("INSERT INTO secure(name,value)"
+ + " VALUES(?,?);");
+ loadIntegerSetting(stmt, Settings.Secure.LONG_PRESS_TIMEOUT,
+ R.integer.def_long_press_timeout_millis);
+ stmt.close();
+ db.setTransactionSuccessful();
+ } finally {
+ db.endTransaction();
+ if (stmt != null) stmt.close();
+ }
+ upgradeVersion = 65;
+ }
+
// *** Remember to update DATABASE_VERSION above!
if (upgradeVersion != currentVersion) {
loadSetting(stmt, Settings.Secure.DOWNLOAD_RECOMMENDED_MAX_BYTES_OVER_MOBILE,
Integer.toString(recommendedMaxBytes));
}
+
+ loadIntegerSetting(stmt, Settings.Secure.LONG_PRESS_TIMEOUT,
+ R.integer.def_long_press_timeout_millis);
} finally {
if (stmt != null) stmt.close();
}
final private SparseArray<HashMap<Uri, UriPermission>> mGrantedUriPermissions
= new SparseArray<HashMap<Uri, UriPermission>>();
+ CoreSettingsObserver mCoreSettingsObserver;
+
/**
* Thread-local storage used to carry caller permissions over through
* indirect content-provider access.
app.instrumentationClass, app.instrumentationProfileFile,
app.instrumentationArguments, app.instrumentationWatcher, testMode,
isRestrictedBackupMode || !normalMode,
- mConfiguration, getCommonServicesLocked());
+ mConfiguration, getCommonServicesLocked(),
+ mCoreSettingsObserver.getCoreSettingsLocked());
updateLruProcessLocked(app, false, true);
app.lastRequestedGc = app.lastLowMemory = SystemClock.uptimeMillis();
} catch (Exception e) {
if (providers != null) {
mSystemThread.installSystemProviders(providers);
}
+
+ mSelf.mCoreSettingsObserver = new CoreSettingsObserver(mSelf);
}
/**
public void monitor() {
synchronized (this) { }
}
+
+ public void onCoreSettingsChange(Bundle settings) {
+ for (int i = mLruProcesses.size() - 1; i >= 0; i--) {
+ ProcessRecord processRecord = mLruProcesses.get(i);
+ try {
+ if (processRecord.thread != null) {
+ processRecord.thread.setCoreSettings(settings);
+ }
+ } catch (RemoteException re) {
+ /* ignore */
+ }
+ }
+ }
}
--- /dev/null
+/*
+ * Copyright (C) 2006-2011 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.am;
+
+import android.content.Context;
+import android.database.ContentObserver;
+import android.net.Uri;
+import android.os.Bundle;
+import android.provider.Settings;
+import android.provider.Settings.SettingNotFoundException;
+import android.util.Log;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Helper class for watching a set of core settings which the framework
+ * propagates to application processes to avoid multiple lookups and potentially
+ * disk I/O operations. Note: This class assumes that all core settings reside
+ * in {@link Settings.Secure}.
+ */
+class CoreSettingsObserver extends ContentObserver {
+ private static final String LOG_TAG = CoreSettingsObserver.class.getSimpleName();
+
+ // mapping form property name to its type
+ private static final Map<String, Class<?>> sCoreSettingToTypeMap = new HashMap<
+ String, Class<?>>();
+ static {
+ sCoreSettingToTypeMap.put(Settings.Secure.LONG_PRESS_TIMEOUT, int.class);
+ // add other core settings here...
+ }
+
+ private final Bundle mCoreSettings = new Bundle();
+
+ private final ActivityManagerService mActivityManagerService;
+
+ public CoreSettingsObserver(ActivityManagerService activityManagerService) {
+ super(activityManagerService.mHandler);
+ mActivityManagerService = activityManagerService;
+ beginObserveCoreSettings();
+ populateCoreSettings(mCoreSettings);
+ }
+
+ public Bundle getCoreSettingsLocked() {
+ return (Bundle) mCoreSettings.clone();
+ }
+
+ @Override
+ public void onChange(boolean selfChange) {
+ synchronized (mActivityManagerService) {
+ populateCoreSettings(mCoreSettings);
+ mActivityManagerService.onCoreSettingsChange(mCoreSettings);
+ }
+ }
+
+ private void beginObserveCoreSettings() {
+ for (String setting : sCoreSettingToTypeMap.keySet()) {
+ Uri uri = Settings.Secure.getUriFor(setting);
+ mActivityManagerService.mContext.getContentResolver().registerContentObserver(
+ uri, false, this);
+ }
+ }
+
+ private void populateCoreSettings(Bundle snapshot) {
+ Context context = mActivityManagerService.mContext;
+ for (Map.Entry<String, Class<?>> entry : sCoreSettingToTypeMap.entrySet()) {
+ String setting = entry.getKey();
+ Class<?> type = entry.getValue();
+ try {
+ if (type == String.class) {
+ String value = Settings.Secure.getString(context.getContentResolver(),
+ setting);
+ snapshot.putString(setting, value);
+ } else if (type == int.class) {
+ int value = Settings.Secure.getInt(context.getContentResolver(),
+ setting);
+ snapshot.putInt(setting, value);
+ } else if (type == float.class) {
+ float value = Settings.Secure.getFloat(context.getContentResolver(),
+ setting);
+ snapshot.putFloat(setting, value);
+ } else if (type == long.class) {
+ long value = Settings.Secure.getLong(context.getContentResolver(),
+ setting);
+ snapshot.putLong(setting, value);
+ }
+ } catch (SettingNotFoundException snfe) {
+ Log.w(LOG_TAG, "Cannot find setting \"" + setting + "\"", snfe);
+ }
+ }
+ }
+}
OSDN Git Service
