diff options
Diffstat (limited to 'services')
29 files changed, 826 insertions, 933 deletions
diff --git a/services/java/com/android/server/SystemServer.java b/services/java/com/android/server/SystemServer.java index e091edf..7dd736d 100644 --- a/services/java/com/android/server/SystemServer.java +++ b/services/java/com/android/server/SystemServer.java @@ -47,6 +47,7 @@ import android.view.WindowManager; import com.android.internal.app.ShutdownThread; import com.android.internal.os.BinderInternal; import com.android.internal.os.SamplingProfilerIntegration; +import com.android.internal.widget.LockSettingsService; import com.android.server.accessibility.AccessibilityManagerService; import com.android.server.am.ActivityManagerService; import com.android.server.net.NetworkPolicyManagerService; @@ -220,6 +221,7 @@ class ServerThread extends Thread { factoryTest != SystemServer.FACTORY_TEST_LOW_LEVEL, !firstBoot); ServiceManager.addService(Context.WINDOW_SERVICE, wm); + ServiceManager.addService(Context.INPUT_SERVICE, wm.getInputManagerService()); ActivityManagerService.self().setWindowManager(wm); @@ -266,6 +268,7 @@ class ServerThread extends Thread { LocationManagerService location = null; CountryDetectorService countryDetector = null; TextServicesManagerService tsms = null; + LockSettingsService lockSettings = null; // Bring up services needed for UI. if (factoryTest != SystemServer.FACTORY_TEST_LOW_LEVEL) { @@ -308,6 +311,14 @@ class ServerThread extends Thread { if (factoryTest != SystemServer.FACTORY_TEST_LOW_LEVEL) { try { + Slog.i(TAG, "LockSettingsService"); + lockSettings = new LockSettingsService(context); + ServiceManager.addService("lock_settings", lockSettings); + } catch (Throwable e) { + reportWtf("starting LockSettingsService service", e); + } + + try { Slog.i(TAG, "Device Policy"); devicePolicy = new DevicePolicyManagerService(context); ServiceManager.addService(Context.DEVICE_POLICY_SERVICE, devicePolicy); @@ -661,6 +672,11 @@ class ServerThread extends Thread { } catch (Throwable e) { reportWtf("making Package Manager Service ready", e); } + try { + lockSettings.systemReady(); + } catch (Throwable e) { + reportWtf("making Lock Settings Service ready", e); + } // These are needed to propagate to the runnable below. final Context contextF = context; diff --git a/services/java/com/android/server/TelephonyRegistry.java b/services/java/com/android/server/TelephonyRegistry.java index 8c8e725..1b1638a 100644 --- a/services/java/com/android/server/TelephonyRegistry.java +++ b/services/java/com/android/server/TelephonyRegistry.java @@ -29,6 +29,7 @@ import android.telephony.CellLocation; import android.telephony.PhoneStateListener; import android.telephony.ServiceState; import android.telephony.SignalStrength; +import android.telephony.CellInfo; import android.telephony.TelephonyManager; import android.text.TextUtils; import android.util.Slog; @@ -107,6 +108,8 @@ class TelephonyRegistry extends ITelephonyRegistry.Stub { private int mOtaspMode = ServiceStateTracker.OTASP_UNKNOWN; + private CellInfo mCellInfo = null; + static final int PHONE_STATE_PERMISSION_MASK = PhoneStateListener.LISTEN_CALL_FORWARDING_INDICATOR | PhoneStateListener.LISTEN_CALL_STATE | @@ -236,6 +239,13 @@ class TelephonyRegistry extends ITelephonyRegistry.Stub { remove(r.binder); } } + if ((events & PhoneStateListener.LISTEN_CELL_INFO) != 0) { + try { + r.callback.onCellInfoChanged(new CellInfo(mCellInfo)); + } catch (RemoteException ex) { + remove(r.binder); + } + } } } } else { @@ -325,6 +335,26 @@ class TelephonyRegistry extends ITelephonyRegistry.Stub { broadcastSignalStrengthChanged(signalStrength); } + public void notifyCellInfo(CellInfo cellInfo) { + if (!checkNotifyPermission("notifyCellInfo()")) { + return; + } + + synchronized (mRecords) { + mCellInfo = cellInfo; + for (Record r : mRecords) { + if ((r.events & PhoneStateListener.LISTEN_CELL_INFO) != 0) { + try { + r.callback.onCellInfoChanged(new CellInfo(cellInfo)); + } catch (RemoteException ex) { + mRemoveList.add(r.binder); + } + } + } + handleRemoveListLocked(); + } + } + public void notifyMessageWaitingChanged(boolean mwi) { if (!checkNotifyPermission("notifyMessageWaitingChanged()")) { return; @@ -530,6 +560,7 @@ class TelephonyRegistry extends ITelephonyRegistry.Stub { pw.println(" mDataConnectionLinkProperties=" + mDataConnectionLinkProperties); pw.println(" mDataConnectionLinkCapabilities=" + mDataConnectionLinkCapabilities); pw.println(" mCellLocation=" + mCellLocation); + pw.println(" mCellInfo=" + mCellInfo); pw.println("registrations: count=" + recordCount); for (Record r : mRecords) { pw.println(" " + r.pkgForDebug + " 0x" + Integer.toHexString(r.events)); @@ -655,6 +686,12 @@ class TelephonyRegistry extends ITelephonyRegistry.Stub { } + if ((events & PhoneStateListener.LISTEN_CELL_INFO) != 0) { + mContext.enforceCallingOrSelfPermission( + android.Manifest.permission.ACCESS_COARSE_LOCATION, null); + + } + if ((events & PHONE_STATE_PERMISSION_MASK) != 0) { mContext.enforceCallingOrSelfPermission( android.Manifest.permission.READ_PHONE_STATE, null); diff --git a/services/java/com/android/server/accessibility/AccessibilityInputFilter.java b/services/java/com/android/server/accessibility/AccessibilityInputFilter.java index 769cb6a..31aa21e 100644 --- a/services/java/com/android/server/accessibility/AccessibilityInputFilter.java +++ b/services/java/com/android/server/accessibility/AccessibilityInputFilter.java @@ -16,7 +16,7 @@ package com.android.server.accessibility; -import com.android.server.wm.InputFilter; +import com.android.server.input.InputFilter; import android.content.Context; import android.util.Slog; diff --git a/services/java/com/android/server/accessibility/TouchExplorer.java b/services/java/com/android/server/accessibility/TouchExplorer.java index 41cf9a6..d07aa7a 100644 --- a/services/java/com/android/server/accessibility/TouchExplorer.java +++ b/services/java/com/android/server/accessibility/TouchExplorer.java @@ -29,7 +29,7 @@ import android.view.accessibility.AccessibilityEvent; import android.view.accessibility.AccessibilityManager; import com.android.server.accessibility.AccessibilityInputFilter.Explorer; -import com.android.server.wm.InputFilter; +import com.android.server.input.InputFilter; import java.util.Arrays; diff --git a/services/java/com/android/server/am/ActivityManagerService.java b/services/java/com/android/server/am/ActivityManagerService.java index 33250b8..2da827e 100644 --- a/services/java/com/android/server/am/ActivityManagerService.java +++ b/services/java/com/android/server/am/ActivityManagerService.java @@ -10262,6 +10262,29 @@ public final class ActivityManagerService extends ActivityManagerNative } pw.println(); pw.print("Total PSS: "); pw.print(totalPss); pw.println(" kB"); + final int[] SINGLE_LONG_FORMAT = new int[] { + Process.PROC_SPACE_TERM|Process.PROC_OUT_LONG + }; + long[] longOut = new long[1]; + Process.readProcFile("/sys/kernel/mm/ksm/pages_shared", + SINGLE_LONG_FORMAT, null, longOut, null); + long shared = longOut[0] * ProcessList.PAGE_SIZE / 1024; + longOut[0] = 0; + Process.readProcFile("/sys/kernel/mm/ksm/pages_sharing", + SINGLE_LONG_FORMAT, null, longOut, null); + long sharing = longOut[0] * ProcessList.PAGE_SIZE / 1024; + longOut[0] = 0; + Process.readProcFile("/sys/kernel/mm/ksm/pages_unshared", + SINGLE_LONG_FORMAT, null, longOut, null); + long unshared = longOut[0] * ProcessList.PAGE_SIZE / 1024; + longOut[0] = 0; + Process.readProcFile("/sys/kernel/mm/ksm/pages_volatile", + SINGLE_LONG_FORMAT, null, longOut, null); + long voltile = longOut[0] * ProcessList.PAGE_SIZE / 1024; + pw.print(" KSM: "); pw.print(sharing); pw.print(" kB saved from shared "); + pw.print(shared); pw.println(" kB"); + pw.print(" "); pw.print(unshared); pw.print(" kB unshared; "); + pw.print(voltile); pw.println(" kB volatile"); } } diff --git a/services/java/com/android/server/wm/InputApplicationHandle.java b/services/java/com/android/server/input/InputApplicationHandle.java index 1812f11..42c1052 100644 --- a/services/java/com/android/server/wm/InputApplicationHandle.java +++ b/services/java/com/android/server/input/InputApplicationHandle.java @@ -14,8 +14,7 @@ * limitations under the License. */ -package com.android.server.wm; - +package com.android.server.input; /** * Functions as a handle for an application that can receive input. @@ -30,7 +29,7 @@ public final class InputApplicationHandle { private int ptr; // The window manager's application window token. - public final AppWindowToken appWindowToken; + public final Object appWindowToken; // Application name. public String name; @@ -40,7 +39,7 @@ public final class InputApplicationHandle { private native void nativeDispose(); - public InputApplicationHandle(AppWindowToken appWindowToken) { + public InputApplicationHandle(Object appWindowToken) { this.appWindowToken = appWindowToken; } diff --git a/services/java/com/android/server/wm/InputFilter.java b/services/java/com/android/server/input/InputFilter.java index 8f0001a..2ce0a02 100644 --- a/services/java/com/android/server/wm/InputFilter.java +++ b/services/java/com/android/server/input/InputFilter.java @@ -14,7 +14,9 @@ * limitations under the License. */ -package com.android.server.wm; +package com.android.server.input; + +import com.android.server.wm.WindowManagerService; import android.os.Handler; import android.os.Looper; @@ -33,7 +35,7 @@ import android.view.WindowManagerPolicy; * system's behavior changes as follows: * <ul> * <li>Input events are first delivered to the {@link WindowManagerPolicy} - * interception methods before queueing as usual. This critical step takes care of managing + * interception methods before queuing as usual. This critical step takes care of managing * the power state of the device and handling wake keys.</li> * <li>Input events are then asynchronously delivered to the input filter's * {@link #onInputEvent(InputEvent)} method instead of being enqueued for dispatch to @@ -79,7 +81,7 @@ import android.view.WindowManagerPolicy; * {@link WindowManagerPolicy#FLAG_PASS_TO_USER} policy flag. The input filter may * sometimes receive events that do not have this flag set. It should take note of * the fact that the policy intends to drop the event, clean up its state, and - * then send appropriate cancelation events to the dispatcher if needed. + * then send appropriate cancellation events to the dispatcher if needed. * </p><p> * For example, suppose the input filter is processing a gesture and one of the touch events * it receives does not have the {@link WindowManagerPolicy#FLAG_PASS_TO_USER} flag set. @@ -89,8 +91,8 @@ import android.view.WindowManagerPolicy; * Corollary: Events that set sent to the dispatcher should usually include the * {@link WindowManagerPolicy#FLAG_PASS_TO_USER} flag. Otherwise, they will be dropped! * </p><p> - * It may be prudent to disable automatic key repeating for synthetically generated - * keys by setting the {@link WindowManagerPolicy#FLAG_DISABLE_KEY_REPEAT} policy flag. + * It may be prudent to disable automatic key repeating for synthetic key events + * by setting the {@link WindowManagerPolicy#FLAG_DISABLE_KEY_REPEAT} policy flag. * </p> */ public abstract class InputFilter { diff --git a/services/java/com/android/server/wm/InputManager.java b/services/java/com/android/server/input/InputManagerService.java index 56c3519..b8cc65e 100644 --- a/services/java/com/android/server/wm/InputManager.java +++ b/services/java/com/android/server/input/InputManagerService.java @@ -14,10 +14,12 @@ * limitations under the License. */ -package com.android.server.wm; +package com.android.server.input; import com.android.internal.util.XmlUtils; import com.android.server.Watchdog; +import com.android.server.input.InputFilter.Host; +import com.android.server.wm.WindowManagerService; import org.xmlpull.v1.XmlPullParser; @@ -25,9 +27,14 @@ import android.content.Context; import android.content.pm.PackageManager; import android.content.res.Configuration; import android.database.ContentObserver; +import android.hardware.input.IInputManager; +import android.hardware.input.InputManager; +import android.os.Binder; import android.os.Environment; +import android.os.Handler; import android.os.Looper; import android.os.MessageQueue; +import android.os.Process; import android.os.SystemProperties; import android.provider.Settings; import android.provider.Settings.SettingNotFoundException; @@ -44,6 +51,7 @@ import android.view.WindowManager; import android.view.WindowManagerPolicy; import java.io.File; +import java.io.FileDescriptor; import java.io.FileNotFoundException; import java.io.FileReader; import java.io.IOException; @@ -53,62 +61,65 @@ import java.util.ArrayList; /* * Wraps the C++ InputManager and provides its callbacks. */ -public class InputManager implements Watchdog.Monitor { +public class InputManagerService extends IInputManager.Stub implements Watchdog.Monitor { static final String TAG = "InputManager"; - - private static final boolean DEBUG = false; + static final boolean DEBUG = false; + + private static final String EXCLUDED_DEVICES_PATH = "etc/excluded-input-devices.xml"; + + // Pointer to native input manager service object. + private final int mPtr; - private final Callbacks mCallbacks; private final Context mContext; - private final WindowManagerService mWindowManagerService; - - private static native void nativeInit(Context context, - Callbacks callbacks, MessageQueue messageQueue); - private static native void nativeStart(); - private static native void nativeSetDisplaySize(int displayId, int width, int height, - int externalWidth, int externalHeight); - private static native void nativeSetDisplayOrientation(int displayId, int rotation); + private final Callbacks mCallbacks; + private final Handler mHandler; + + private static native int nativeInit(InputManagerService service, + Context context, MessageQueue messageQueue); + private static native void nativeStart(int ptr); + private static native void nativeSetDisplaySize(int ptr, int displayId, + int width, int height, int externalWidth, int externalHeight); + private static native void nativeSetDisplayOrientation(int ptr, int displayId, int rotation); - private static native int nativeGetScanCodeState(int deviceId, int sourceMask, - int scanCode); - private static native int nativeGetKeyCodeState(int deviceId, int sourceMask, - int keyCode); - private static native int nativeGetSwitchState(int deviceId, int sourceMask, - int sw); - private static native boolean nativeHasKeys(int deviceId, int sourceMask, - int[] keyCodes, boolean[] keyExists); - private static native void nativeRegisterInputChannel(InputChannel inputChannel, + private static native int nativeGetScanCodeState(int ptr, + int deviceId, int sourceMask, int scanCode); + private static native int nativeGetKeyCodeState(int ptr, + int deviceId, int sourceMask, int keyCode); + private static native int nativeGetSwitchState(int ptr, + int deviceId, int sourceMask, int sw); + private static native boolean nativeHasKeys(int ptr, + int deviceId, int sourceMask, int[] keyCodes, boolean[] keyExists); + private static native void nativeRegisterInputChannel(int ptr, InputChannel inputChannel, InputWindowHandle inputWindowHandle, boolean monitor); - private static native void nativeUnregisterInputChannel(InputChannel inputChannel); - private static native void nativeSetInputFilterEnabled(boolean enable); - private static native int nativeInjectInputEvent(InputEvent event, + private static native void nativeUnregisterInputChannel(int ptr, InputChannel inputChannel); + private static native void nativeSetInputFilterEnabled(int ptr, boolean enable); + private static native int nativeInjectInputEvent(int ptr, InputEvent event, int injectorPid, int injectorUid, int syncMode, int timeoutMillis, int policyFlags); - private static native void nativeSetInputWindows(InputWindowHandle[] windowHandles); - private static native void nativeSetInputDispatchMode(boolean enabled, boolean frozen); - private static native void nativeSetSystemUiVisibility(int visibility); - private static native void nativeSetFocusedApplication(InputApplicationHandle application); - private static native InputDevice nativeGetInputDevice(int deviceId); - private static native void nativeGetInputConfiguration(Configuration configuration); - private static native int[] nativeGetInputDeviceIds(); - private static native boolean nativeTransferTouchFocus(InputChannel fromChannel, - InputChannel toChannel); - private static native void nativeSetPointerSpeed(int speed); - private static native void nativeSetShowTouches(boolean enabled); - private static native String nativeDump(); - private static native void nativeMonitor(); - + private static native void nativeSetInputWindows(int ptr, InputWindowHandle[] windowHandles); + private static native void nativeSetInputDispatchMode(int ptr, boolean enabled, boolean frozen); + private static native void nativeSetSystemUiVisibility(int ptr, int visibility); + private static native void nativeSetFocusedApplication(int ptr, + InputApplicationHandle application); + private static native InputDevice nativeGetInputDevice(int ptr, int deviceId); + private static native void nativeGetInputConfiguration(int ptr, Configuration configuration); + private static native int[] nativeGetInputDeviceIds(int ptr); + private static native boolean nativeTransferTouchFocus(int ptr, + InputChannel fromChannel, InputChannel toChannel); + private static native void nativeSetPointerSpeed(int ptr, int speed); + private static native void nativeSetShowTouches(int ptr, boolean enabled); + private static native String nativeDump(int ptr); + private static native void nativeMonitor(int ptr); + // Input event injection constants defined in InputDispatcher.h. - static final int INPUT_EVENT_INJECTION_SUCCEEDED = 0; - static final int INPUT_EVENT_INJECTION_PERMISSION_DENIED = 1; - static final int INPUT_EVENT_INJECTION_FAILED = 2; - static final int INPUT_EVENT_INJECTION_TIMED_OUT = 3; - - // Input event injection synchronization modes defined in InputDispatcher.h - static final int INPUT_EVENT_INJECTION_SYNC_NONE = 0; - static final int INPUT_EVENT_INJECTION_SYNC_WAIT_FOR_RESULT = 1; - static final int INPUT_EVENT_INJECTION_SYNC_WAIT_FOR_FINISH = 2; - + private static final int INPUT_EVENT_INJECTION_SUCCEEDED = 0; + private static final int INPUT_EVENT_INJECTION_PERMISSION_DENIED = 1; + private static final int INPUT_EVENT_INJECTION_FAILED = 2; + private static final int INPUT_EVENT_INJECTION_TIMED_OUT = 3; + + // Maximum number of milliseconds to wait for input event injection. + private static final int INJECTION_TIMEOUT_MILLIS = 30 * 1000; + // Key states (may be returned by queries about the current state of a // particular key code, scan code or switch). @@ -129,23 +140,21 @@ public class InputManager implements Watchdog.Monitor { InputFilter mInputFilter; InputFilterHost mInputFilterHost; - public InputManager(Context context, WindowManagerService windowManagerService) { + public InputManagerService(Context context, Callbacks callbacks) { this.mContext = context; - this.mWindowManagerService = windowManagerService; - this.mCallbacks = new Callbacks(); - - Looper looper = windowManagerService.mH.getLooper(); + this.mCallbacks = callbacks; + this.mHandler = new Handler(); Slog.i(TAG, "Initializing input manager"); - nativeInit(mContext, mCallbacks, looper.getQueue()); - - // Add ourself to the Watchdog monitors. - Watchdog.getInstance().addMonitor(this); + mPtr = nativeInit(this, mContext, mHandler.getLooper().getQueue()); } public void start() { Slog.i(TAG, "Starting input manager"); - nativeStart(); + nativeStart(mPtr); + + // Add ourself to the Watchdog monitors. + Watchdog.getInstance().addMonitor(this); registerPointerSpeedSettingObserver(); registerShowTouchesSettingObserver(); @@ -164,7 +173,7 @@ public class InputManager implements Watchdog.Monitor { Slog.d(TAG, "Setting display #" + displayId + " size to " + width + "x" + height + " external size " + externalWidth + "x" + externalHeight); } - nativeSetDisplaySize(displayId, width, height, externalWidth, externalHeight); + nativeSetDisplaySize(mPtr, displayId, width, height, externalWidth, externalHeight); } public void setDisplayOrientation(int displayId, int rotation) { @@ -175,7 +184,7 @@ public class InputManager implements Watchdog.Monitor { if (DEBUG) { Slog.d(TAG, "Setting display #" + displayId + " orientation to " + rotation); } - nativeSetDisplayOrientation(displayId, rotation); + nativeSetDisplayOrientation(mPtr, displayId, rotation); } public void getInputConfiguration(Configuration config) { @@ -183,9 +192,9 @@ public class InputManager implements Watchdog.Monitor { throw new IllegalArgumentException("config must not be null."); } - nativeGetInputConfiguration(config); + nativeGetInputConfiguration(mPtr, config); } - + /** * Gets the current state of a key or button by key code. * @param deviceId The input device id, or -1 to consult all devices. @@ -196,7 +205,7 @@ public class InputManager implements Watchdog.Monitor { * @return The key state. */ public int getKeyCodeState(int deviceId, int sourceMask, int keyCode) { - return nativeGetKeyCodeState(deviceId, sourceMask, keyCode); + return nativeGetKeyCodeState(mPtr, deviceId, sourceMask, keyCode); } /** @@ -209,7 +218,7 @@ public class InputManager implements Watchdog.Monitor { * @return The key state. */ public int getScanCodeState(int deviceId, int sourceMask, int scanCode) { - return nativeGetScanCodeState(deviceId, sourceMask, scanCode); + return nativeGetScanCodeState(mPtr, deviceId, sourceMask, scanCode); } /** @@ -222,7 +231,7 @@ public class InputManager implements Watchdog.Monitor { * @return The switch state. */ public int getSwitchState(int deviceId, int sourceMask, int switchCode) { - return nativeGetSwitchState(deviceId, sourceMask, switchCode); + return nativeGetSwitchState(mPtr, deviceId, sourceMask, switchCode); } /** @@ -237,6 +246,7 @@ public class InputManager implements Watchdog.Monitor { * key codes. * @return True if the lookup was successful, false otherwise. */ + @Override public boolean hasKeys(int deviceId, int sourceMask, int[] keyCodes, boolean[] keyExists) { if (keyCodes == null) { throw new IllegalArgumentException("keyCodes must not be null."); @@ -246,7 +256,7 @@ public class InputManager implements Watchdog.Monitor { + "least as large as keyCodes."); } - return nativeHasKeys(deviceId, sourceMask, keyCodes, keyExists); + return nativeHasKeys(mPtr, deviceId, sourceMask, keyCodes, keyExists); } /** @@ -260,7 +270,7 @@ public class InputManager implements Watchdog.Monitor { } InputChannel[] inputChannels = InputChannel.openInputChannelPair(inputChannelName); - nativeRegisterInputChannel(inputChannels[0], null, true); + nativeRegisterInputChannel(mPtr, inputChannels[0], null, true); inputChannels[0].dispose(); // don't need to retain the Java object reference return inputChannels[1]; } @@ -277,7 +287,7 @@ public class InputManager implements Watchdog.Monitor { throw new IllegalArgumentException("inputChannel must not be null."); } - nativeRegisterInputChannel(inputChannel, inputWindowHandle, false); + nativeRegisterInputChannel(mPtr, inputChannel, inputWindowHandle, false); } /** @@ -289,7 +299,7 @@ public class InputManager implements Watchdog.Monitor { throw new IllegalArgumentException("inputChannel must not be null."); } - nativeUnregisterInputChannel(inputChannel); + nativeUnregisterInputChannel(mPtr, inputChannel); } /** @@ -323,47 +333,46 @@ public class InputManager implements Watchdog.Monitor { filter.install(mInputFilterHost); } - nativeSetInputFilterEnabled(filter != null); + nativeSetInputFilterEnabled(mPtr, filter != null); } } - /** - * Injects an input event into the event system on behalf of an application. - * The synchronization mode determines whether the method blocks while waiting for - * input injection to proceed. - * - * {@link #INPUT_EVENT_INJECTION_SYNC_NONE} never blocks. Injection is asynchronous and - * is assumed always to be successful. - * - * {@link #INPUT_EVENT_INJECTION_SYNC_WAIT_FOR_RESULT} waits for previous events to be - * dispatched so that the input dispatcher can determine whether input event injection will - * be permitted based on the current input focus. Does not wait for the input event to - * finish processing. - * - * {@link #INPUT_EVENT_INJECTION_SYNC_WAIT_FOR_FINISH} waits for the input event to - * be completely processed. - * - * @param event The event to inject. - * @param injectorPid The pid of the injecting application. - * @param injectorUid The uid of the injecting application. - * @param syncMode The synchronization mode. - * @param timeoutMillis The injection timeout in milliseconds. - * @return One of the INPUT_EVENT_INJECTION_XXX constants. - */ - public int injectInputEvent(InputEvent event, int injectorPid, int injectorUid, - int syncMode, int timeoutMillis) { + @Override + public boolean injectInputEvent(InputEvent event, int mode) { if (event == null) { throw new IllegalArgumentException("event must not be null"); } - if (injectorPid < 0 || injectorUid < 0) { - throw new IllegalArgumentException("injectorPid and injectorUid must not be negative."); - } - if (timeoutMillis <= 0) { - throw new IllegalArgumentException("timeoutMillis must be positive"); + if (mode != InputManager.INJECT_INPUT_EVENT_MODE_ASYNC + && mode != InputManager.INJECT_INPUT_EVENT_MODE_WAIT_FOR_FINISH + && mode != InputManager.INJECT_INPUT_EVENT_MODE_WAIT_FOR_RESULT) { + throw new IllegalArgumentException("mode is invalid"); } - return nativeInjectInputEvent(event, injectorPid, injectorUid, syncMode, timeoutMillis, - WindowManagerPolicy.FLAG_DISABLE_KEY_REPEAT); + final int pid = Binder.getCallingPid(); + final int uid = Binder.getCallingUid(); + final long ident = Binder.clearCallingIdentity(); + final int result; + try { + result = nativeInjectInputEvent(mPtr, event, pid, uid, mode, + INJECTION_TIMEOUT_MILLIS, WindowManagerPolicy.FLAG_DISABLE_KEY_REPEAT); + } finally { + Binder.restoreCallingIdentity(ident); + } + switch (result) { + case INPUT_EVENT_INJECTION_PERMISSION_DENIED: + Slog.w(TAG, "Input event injection from pid " + pid + " permission denied."); + throw new SecurityException( + "Injecting to another application requires INJECT_EVENTS permission"); + case INPUT_EVENT_INJECTION_SUCCEEDED: + return true; + case INPUT_EVENT_INJECTION_TIMED_OUT: + Slog.w(TAG, "Input event injection from pid " + pid + " timed out."); + return false; + case INPUT_EVENT_INJECTION_FAILED: + default: + Slog.w(TAG, "Input event injection from pid " + pid + " failed."); + return false; + } } /** @@ -371,32 +380,34 @@ public class InputManager implements Watchdog.Monitor { * @param id The device id. * @return The input device or null if not found. */ + @Override public InputDevice getInputDevice(int deviceId) { - return nativeGetInputDevice(deviceId); + return nativeGetInputDevice(mPtr, deviceId); } /** * Gets the ids of all input devices in the system. * @return The input device ids. */ + @Override public int[] getInputDeviceIds() { - return nativeGetInputDeviceIds(); + return nativeGetInputDeviceIds(mPtr); } public void setInputWindows(InputWindowHandle[] windowHandles) { - nativeSetInputWindows(windowHandles); + nativeSetInputWindows(mPtr, windowHandles); } public void setFocusedApplication(InputApplicationHandle application) { - nativeSetFocusedApplication(application); + nativeSetFocusedApplication(mPtr, application); } public void setInputDispatchMode(boolean enabled, boolean frozen) { - nativeSetInputDispatchMode(enabled, frozen); + nativeSetInputDispatchMode(mPtr, enabled, frozen); } public void setSystemUiVisibility(int visibility) { - nativeSetSystemUiVisibility(visibility); + nativeSetSystemUiVisibility(mPtr, visibility); } /** @@ -419,7 +430,7 @@ public class InputManager implements Watchdog.Monitor { if (toChannel == null) { throw new IllegalArgumentException("toChannel must not be null."); } - return nativeTransferTouchFocus(fromChannel, toChannel); + return nativeTransferTouchFocus(mPtr, fromChannel, toChannel); } /** @@ -427,20 +438,31 @@ public class InputManager implements Watchdog.Monitor { * @param speed The pointer speed as a value between -7 (slowest) and 7 (fastest) * where 0 is the default speed. */ - public void setPointerSpeed(int speed) { - speed = Math.min(Math.max(speed, -7), 7); - nativeSetPointerSpeed(speed); + @Override + public void tryPointerSpeed(int speed) { + if (!checkCallingPermission(android.Manifest.permission.SET_POINTER_SPEED, + "tryPointerSpeed()")) { + throw new SecurityException("Requires SET_POINTER_SPEED permission"); + } + + setPointerSpeedUnchecked(speed); } public void updatePointerSpeedFromSettings() { - int speed = getPointerSpeedSetting(0); - setPointerSpeed(speed); + int speed = getPointerSpeedSetting(); + setPointerSpeedUnchecked(speed); + } + + private void setPointerSpeedUnchecked(int speed) { + speed = Math.min(Math.max(speed, InputManager.MIN_POINTER_SPEED), + InputManager.MAX_POINTER_SPEED); + nativeSetPointerSpeed(mPtr, speed); } private void registerPointerSpeedSettingObserver() { mContext.getContentResolver().registerContentObserver( Settings.System.getUriFor(Settings.System.POINTER_SPEED), true, - new ContentObserver(mWindowManagerService.mH) { + new ContentObserver(mHandler) { @Override public void onChange(boolean selfChange) { updatePointerSpeedFromSettings(); @@ -448,8 +470,8 @@ public class InputManager implements Watchdog.Monitor { }); } - private int getPointerSpeedSetting(int defaultValue) { - int speed = defaultValue; + private int getPointerSpeedSetting() { + int speed = InputManager.DEFAULT_POINTER_SPEED; try { speed = Settings.System.getInt(mContext.getContentResolver(), Settings.System.POINTER_SPEED); @@ -460,13 +482,13 @@ public class InputManager implements Watchdog.Monitor { public void updateShowTouchesFromSettings() { int setting = getShowTouchesSetting(0); - nativeSetShowTouches(setting != 0); + nativeSetShowTouches(mPtr, setting != 0); } private void registerShowTouchesSettingObserver() { mContext.getContentResolver().registerContentObserver( Settings.System.getUriFor(Settings.System.SHOW_TOUCHES), true, - new ContentObserver(mWindowManagerService.mH) { + new ContentObserver(mHandler) { @Override public void onChange(boolean selfChange) { updateShowTouchesFromSettings(); @@ -484,200 +506,238 @@ public class InputManager implements Watchdog.Monitor { return result; } - public void dump(PrintWriter pw) { - String dumpStr = nativeDump(); + @Override + public void dump(FileDescriptor fd, PrintWriter pw, String[] args) { + if (mContext.checkCallingOrSelfPermission("android.permission.DUMP") + != PackageManager.PERMISSION_GRANTED) { + pw.println("Permission Denial: can't dump InputManager from from pid=" + + Binder.getCallingPid() + + ", uid=" + Binder.getCallingUid()); + return; + } + + pw.println("INPUT MANAGER (dumpsys input)\n"); + String dumpStr = nativeDump(mPtr); if (dumpStr != null) { pw.println(dumpStr); } } - // Called by the heartbeat to ensure locks are not held indefnitely (for deadlock detection). + private boolean checkCallingPermission(String permission, String func) { + // Quick check: if the calling permission is me, it's all okay. + if (Binder.getCallingPid() == Process.myPid()) { + return true; + } + + if (mContext.checkCallingPermission(permission) == PackageManager.PERMISSION_GRANTED) { + return true; + } + String msg = "Permission Denial: " + func + " from pid=" + + Binder.getCallingPid() + + ", uid=" + Binder.getCallingUid() + + " requires " + permission; + Slog.w(TAG, msg); + return false; + } + + // Called by the heartbeat to ensure locks are not held indefinitely (for deadlock detection). public void monitor() { synchronized (mInputFilterLock) { } - nativeMonitor(); + nativeMonitor(mPtr); } - private final class InputFilterHost implements InputFilter.Host { - private boolean mDisconnected; + // Native callback. + private void notifyConfigurationChanged(long whenNanos) { + mCallbacks.notifyConfigurationChanged(); + } - public void disconnectLocked() { - mDisconnected = true; - } + // Native callback. + private void notifyLidSwitchChanged(long whenNanos, boolean lidOpen) { + mCallbacks.notifyLidSwitchChanged(whenNanos, lidOpen); + } - public void sendInputEvent(InputEvent event, int policyFlags) { - if (event == null) { - throw new IllegalArgumentException("event must not be null"); - } + // Native callback. + private void notifyInputChannelBroken(InputWindowHandle inputWindowHandle) { + mCallbacks.notifyInputChannelBroken(inputWindowHandle); + } - synchronized (mInputFilterLock) { - if (!mDisconnected) { - nativeInjectInputEvent(event, 0, 0, INPUT_EVENT_INJECTION_SYNC_NONE, 0, - policyFlags | WindowManagerPolicy.FLAG_FILTERED); - } + // Native callback. + private long notifyANR(InputApplicationHandle inputApplicationHandle, + InputWindowHandle inputWindowHandle) { + return mCallbacks.notifyANR(inputApplicationHandle, inputWindowHandle); + } + + // Native callback. + final boolean filterInputEvent(InputEvent event, int policyFlags) { + synchronized (mInputFilterLock) { + if (mInputFilter != null) { + mInputFilter.filterInputEvent(event, policyFlags); + return false; } } + event.recycle(); + return true; } - /* - * Callbacks from native. - */ - private final class Callbacks { - static final String TAG = "InputManager-Callbacks"; - - private static final boolean DEBUG_VIRTUAL_KEYS = false; - private static final String EXCLUDED_DEVICES_PATH = "etc/excluded-input-devices.xml"; - private static final String CALIBRATION_DIR_PATH = "usr/idc/"; - - @SuppressWarnings("unused") - public void notifyConfigurationChanged(long whenNanos) { - mWindowManagerService.mInputMonitor.notifyConfigurationChanged(); - } - - @SuppressWarnings("unused") - public void notifyLidSwitchChanged(long whenNanos, boolean lidOpen) { - mWindowManagerService.mInputMonitor.notifyLidSwitchChanged(whenNanos, lidOpen); - } - - @SuppressWarnings("unused") - public void notifyInputChannelBroken(InputWindowHandle inputWindowHandle) { - mWindowManagerService.mInputMonitor.notifyInputChannelBroken(inputWindowHandle); - } - - @SuppressWarnings("unused") - public long notifyANR(InputApplicationHandle inputApplicationHandle, - InputWindowHandle inputWindowHandle) { - return mWindowManagerService.mInputMonitor.notifyANR( - inputApplicationHandle, inputWindowHandle); - } + // Native callback. + private int interceptKeyBeforeQueueing(KeyEvent event, int policyFlags, boolean isScreenOn) { + return mCallbacks.interceptKeyBeforeQueueing( + event, policyFlags, isScreenOn); + } - @SuppressWarnings("unused") - final boolean filterInputEvent(InputEvent event, int policyFlags) { - synchronized (mInputFilterLock) { - if (mInputFilter != null) { - mInputFilter.filterInputEvent(event, policyFlags); - return false; - } - } - event.recycle(); - return true; - } + // Native callback. + private int interceptMotionBeforeQueueingWhenScreenOff(int policyFlags) { + return mCallbacks.interceptMotionBeforeQueueingWhenScreenOff(policyFlags); + } - @SuppressWarnings("unused") - public int interceptKeyBeforeQueueing(KeyEvent event, int policyFlags, boolean isScreenOn) { - return mWindowManagerService.mInputMonitor.interceptKeyBeforeQueueing( - event, policyFlags, isScreenOn); - } + // Native callback. + private long interceptKeyBeforeDispatching(InputWindowHandle focus, + KeyEvent event, int policyFlags) { + return mCallbacks.interceptKeyBeforeDispatching(focus, event, policyFlags); + } - @SuppressWarnings("unused") - public int interceptMotionBeforeQueueingWhenScreenOff(int policyFlags) { - return mWindowManagerService.mInputMonitor.interceptMotionBeforeQueueingWhenScreenOff( - policyFlags); - } + // Native callback. + private KeyEvent dispatchUnhandledKey(InputWindowHandle focus, + KeyEvent event, int policyFlags) { + return mCallbacks.dispatchUnhandledKey(focus, event, policyFlags); + } - @SuppressWarnings("unused") - public long interceptKeyBeforeDispatching(InputWindowHandle focus, - KeyEvent event, int policyFlags) { - return mWindowManagerService.mInputMonitor.interceptKeyBeforeDispatching( - focus, event, policyFlags); - } - - @SuppressWarnings("unused") - public KeyEvent dispatchUnhandledKey(InputWindowHandle focus, - KeyEvent event, int policyFlags) { - return mWindowManagerService.mInputMonitor.dispatchUnhandledKey( - focus, event, policyFlags); - } - - @SuppressWarnings("unused") - public boolean checkInjectEventsPermission(int injectorPid, int injectorUid) { - return mContext.checkPermission( - android.Manifest.permission.INJECT_EVENTS, injectorPid, injectorUid) - == PackageManager.PERMISSION_GRANTED; - } + // Native callback. + private boolean checkInjectEventsPermission(int injectorPid, int injectorUid) { + return mContext.checkPermission(android.Manifest.permission.INJECT_EVENTS, + injectorPid, injectorUid) == PackageManager.PERMISSION_GRANTED; + } - @SuppressWarnings("unused") - public int getVirtualKeyQuietTimeMillis() { - return mContext.getResources().getInteger( - com.android.internal.R.integer.config_virtualKeyQuietTimeMillis); - } + // Native callback. + private int getVirtualKeyQuietTimeMillis() { + return mContext.getResources().getInteger( + com.android.internal.R.integer.config_virtualKeyQuietTimeMillis); + } - @SuppressWarnings("unused") - public String[] getExcludedDeviceNames() { - ArrayList<String> names = new ArrayList<String>(); - - // Read partner-provided list of excluded input devices - XmlPullParser parser = null; - // Environment.getRootDirectory() is a fancy way of saying ANDROID_ROOT or "/system". - File confFile = new File(Environment.getRootDirectory(), EXCLUDED_DEVICES_PATH); - FileReader confreader = null; - try { - confreader = new FileReader(confFile); - parser = Xml.newPullParser(); - parser.setInput(confreader); - XmlUtils.beginDocument(parser, "devices"); - - while (true) { - XmlUtils.nextElement(parser); - if (!"device".equals(parser.getName())) { - break; - } - String name = parser.getAttributeValue(null, "name"); - if (name != null) { - names.add(name); - } + // Native callback. + private String[] getExcludedDeviceNames() { + ArrayList<String> names = new ArrayList<String>(); + + // Read partner-provided list of excluded input devices + XmlPullParser parser = null; + // Environment.getRootDirectory() is a fancy way of saying ANDROID_ROOT or "/system". + File confFile = new File(Environment.getRootDirectory(), EXCLUDED_DEVICES_PATH); + FileReader confreader = null; + try { + confreader = new FileReader(confFile); + parser = Xml.newPullParser(); + parser.setInput(confreader); + XmlUtils.beginDocument(parser, "devices"); + + while (true) { + XmlUtils.nextElement(parser); + if (!"device".equals(parser.getName())) { + break; + } + String name = parser.getAttributeValue(null, "name"); + if (name != null) { + names.add(name); } - } catch (FileNotFoundException e) { - // It's ok if the file does not exist. - } catch (Exception e) { - Slog.e(TAG, "Exception while parsing '" + confFile.getAbsolutePath() + "'", e); - } finally { - try { if (confreader != null) confreader.close(); } catch (IOException e) { } } - - return names.toArray(new String[names.size()]); + } catch (FileNotFoundException e) { + // It's ok if the file does not exist. + } catch (Exception e) { + Slog.e(TAG, "Exception while parsing '" + confFile.getAbsolutePath() + "'", e); + } finally { + try { if (confreader != null) confreader.close(); } catch (IOException e) { } } - @SuppressWarnings("unused") - public int getKeyRepeatTimeout() { - return ViewConfiguration.getKeyRepeatTimeout(); - } + return names.toArray(new String[names.size()]); + } - @SuppressWarnings("unused") - public int getKeyRepeatDelay() { - return ViewConfiguration.getKeyRepeatDelay(); - } + // Native callback. + private int getKeyRepeatTimeout() { + return ViewConfiguration.getKeyRepeatTimeout(); + } - @SuppressWarnings("unused") - public int getHoverTapTimeout() { - return ViewConfiguration.getHoverTapTimeout(); - } + // Native callback. + private int getKeyRepeatDelay() { + return ViewConfiguration.getKeyRepeatDelay(); + } - @SuppressWarnings("unused") - public int getHoverTapSlop() { - return ViewConfiguration.getHoverTapSlop(); - } + // Native callback. + private int getHoverTapTimeout() { + return ViewConfiguration.getHoverTapTimeout(); + } - @SuppressWarnings("unused") - public int getDoubleTapTimeout() { - return ViewConfiguration.getDoubleTapTimeout(); - } + // Native callback. + private int getHoverTapSlop() { + return ViewConfiguration.getHoverTapSlop(); + } - @SuppressWarnings("unused") - public int getLongPressTimeout() { - return ViewConfiguration.getLongPressTimeout(); - } + // Native callback. + private int getDoubleTapTimeout() { + return ViewConfiguration.getDoubleTapTimeout(); + } + + // Native callback. + private int getLongPressTimeout() { + return ViewConfiguration.getLongPressTimeout(); + } - @SuppressWarnings("unused") - public int getPointerLayer() { - return mWindowManagerService.mPolicy.windowTypeToLayerLw( - WindowManager.LayoutParams.TYPE_POINTER) - * WindowManagerService.TYPE_LAYER_MULTIPLIER - + WindowManagerService.TYPE_LAYER_OFFSET; + // Native callback. + private int getPointerLayer() { + return mCallbacks.getPointerLayer(); + } + + // Native callback. + private PointerIcon getPointerIcon() { + return PointerIcon.getDefaultIcon(mContext); + } + + /** + * Callback interface implemented by the Window Manager. + */ + public interface Callbacks { + public void notifyConfigurationChanged(); + + public void notifyLidSwitchChanged(long whenNanos, boolean lidOpen); + + public void notifyInputChannelBroken(InputWindowHandle inputWindowHandle); + + public long notifyANR(InputApplicationHandle inputApplicationHandle, + InputWindowHandle inputWindowHandle); + + public int interceptKeyBeforeQueueing(KeyEvent event, int policyFlags, boolean isScreenOn); + + public int interceptMotionBeforeQueueingWhenScreenOff(int policyFlags); + + public long interceptKeyBeforeDispatching(InputWindowHandle focus, + KeyEvent event, int policyFlags); + + public KeyEvent dispatchUnhandledKey(InputWindowHandle focus, + KeyEvent event, int policyFlags); + + public int getPointerLayer(); + } + + /** + * Hosting interface for input filters to call back into the input manager. + */ + private final class InputFilterHost implements InputFilter.Host { + private boolean mDisconnected; + + public void disconnectLocked() { + mDisconnected = true; } - @SuppressWarnings("unused") - public PointerIcon getPointerIcon() { - return PointerIcon.getDefaultIcon(mContext); + public void sendInputEvent(InputEvent event, int policyFlags) { + if (event == null) { + throw new IllegalArgumentException("event must not be null"); + } + + synchronized (mInputFilterLock) { + if (!mDisconnected) { + nativeInjectInputEvent(mPtr, event, 0, 0, + InputManager.INJECT_INPUT_EVENT_MODE_ASYNC, 0, + policyFlags | WindowManagerPolicy.FLAG_FILTERED); + } + } } } } diff --git a/services/java/com/android/server/wm/InputWindowHandle.java b/services/java/com/android/server/input/InputWindowHandle.java index 264877c..03d66af 100644 --- a/services/java/com/android/server/wm/InputWindowHandle.java +++ b/services/java/com/android/server/input/InputWindowHandle.java @@ -14,11 +14,10 @@ * limitations under the License. */ -package com.android.server.wm; +package com.android.server.input; import android.graphics.Region; import android.view.InputChannel; -import android.view.WindowManagerPolicy; /** * Functions as a handle for a window that can receive input. @@ -35,7 +34,7 @@ public final class InputWindowHandle { public final InputApplicationHandle inputApplicationHandle; // The window manager's window state. - public final WindowManagerPolicy.WindowState windowState; + public final Object windowState; // The input channel associated with the window. public InputChannel inputChannel; @@ -91,7 +90,7 @@ public final class InputWindowHandle { private native void nativeDispose(); public InputWindowHandle(InputApplicationHandle inputApplicationHandle, - WindowManagerPolicy.WindowState windowState) { + Object windowState) { this.inputApplicationHandle = inputApplicationHandle; this.windowState = windowState; } diff --git a/services/java/com/android/server/net/NetworkIdentitySet.java b/services/java/com/android/server/net/NetworkIdentitySet.java index af03fb3..397f9f4 100644 --- a/services/java/com/android/server/net/NetworkIdentitySet.java +++ b/services/java/com/android/server/net/NetworkIdentitySet.java @@ -21,7 +21,6 @@ import android.net.NetworkIdentity; import java.io.DataInputStream; import java.io.DataOutputStream; import java.io.IOException; -import java.net.ProtocolException; import java.util.HashSet; /** @@ -33,48 +32,46 @@ import java.util.HashSet; public class NetworkIdentitySet extends HashSet<NetworkIdentity> { private static final int VERSION_INIT = 1; private static final int VERSION_ADD_ROAMING = 2; + private static final int VERSION_ADD_NETWORK_ID = 3; public NetworkIdentitySet() { } public NetworkIdentitySet(DataInputStream in) throws IOException { final int version = in.readInt(); - switch (version) { - case VERSION_INIT: { - final int size = in.readInt(); - for (int i = 0; i < size; i++) { - final int ignoredVersion = in.readInt(); - final int type = in.readInt(); - final int subType = in.readInt(); - final String subscriberId = readOptionalString(in); - add(new NetworkIdentity(type, subType, subscriberId, false)); - } - break; + final int size = in.readInt(); + for (int i = 0; i < size; i++) { + if (version <= VERSION_INIT) { + final int ignored = in.readInt(); } - case VERSION_ADD_ROAMING: { - final int size = in.readInt(); - for (int i = 0; i < size; i++) { - final int type = in.readInt(); - final int subType = in.readInt(); - final String subscriberId = readOptionalString(in); - final boolean roaming = in.readBoolean(); - add(new NetworkIdentity(type, subType, subscriberId, roaming)); - } - break; + final int type = in.readInt(); + final int subType = in.readInt(); + final String subscriberId = readOptionalString(in); + final String networkId; + if (version >= VERSION_ADD_NETWORK_ID) { + networkId = readOptionalString(in); + } else { + networkId = null; } - default: { - throw new ProtocolException("unexpected version: " + version); + final boolean roaming; + if (version >= VERSION_ADD_ROAMING) { + roaming = in.readBoolean(); + } else { + roaming = false; } + + add(new NetworkIdentity(type, subType, subscriberId, networkId, false)); } } public void writeToStream(DataOutputStream out) throws IOException { - out.writeInt(VERSION_ADD_ROAMING); + out.writeInt(VERSION_ADD_NETWORK_ID); out.writeInt(size()); for (NetworkIdentity ident : this) { out.writeInt(ident.getType()); out.writeInt(ident.getSubType()); writeOptionalString(out, ident.getSubscriberId()); + writeOptionalString(out, ident.getNetworkId()); out.writeBoolean(ident.getRoaming()); } } diff --git a/services/java/com/android/server/net/NetworkPolicyManagerService.java b/services/java/com/android/server/net/NetworkPolicyManagerService.java index 1f1e720..b0657a6 100644 --- a/services/java/com/android/server/net/NetworkPolicyManagerService.java +++ b/services/java/com/android/server/net/NetworkPolicyManagerService.java @@ -48,6 +48,7 @@ import static android.net.NetworkTemplate.MATCH_MOBILE_ALL; import static android.net.NetworkTemplate.MATCH_WIFI; import static android.net.NetworkTemplate.buildTemplateMobileAll; import static android.net.TrafficStats.MB_IN_BYTES; +import static android.telephony.TelephonyManager.SIM_STATE_READY; import static android.text.format.DateUtils.DAY_IN_MILLIS; import static com.android.internal.util.Preconditions.checkNotNull; import static com.android.server.NetworkManagementService.LIMIT_GLOBAL_ALERT; @@ -113,6 +114,7 @@ import android.util.Xml; import com.android.internal.R; import com.android.internal.os.AtomicFile; import com.android.internal.util.FastXmlSerializer; +import com.android.internal.util.IndentingPrintWriter; import com.android.internal.util.Objects; import com.google.android.collect.Lists; import com.google.android.collect.Maps; @@ -160,6 +162,8 @@ public class NetworkPolicyManagerService extends INetworkPolicyManager.Stub { private static final int VERSION_ADDED_TIMEZONE = 6; private static final int VERSION_ADDED_INFERRED = 7; private static final int VERSION_SWITCH_APP_ID = 8; + private static final int VERSION_ADDED_NETWORK_ID = 9; + private static final int VERSION_LATEST = VERSION_ADDED_NETWORK_ID; // @VisibleForTesting public static final int TYPE_WARNING = 0x1; @@ -175,6 +179,7 @@ public class NetworkPolicyManagerService extends INetworkPolicyManager.Stub { private static final String ATTR_RESTRICT_BACKGROUND = "restrictBackground"; private static final String ATTR_NETWORK_TEMPLATE = "networkTemplate"; private static final String ATTR_SUBSCRIBER_ID = "subscriberId"; + private static final String ATTR_NETWORK_ID = "networkId"; private static final String ATTR_CYCLE_DAY = "cycleDay"; private static final String ATTR_CYCLE_TIMEZONE = "cycleTimezone"; private static final String ATTR_WARNING_BYTES = "warningBytes"; @@ -491,6 +496,7 @@ public class NetworkPolicyManagerService extends INetworkPolicyManager.Stub { for (NetworkPolicy policy : mNetworkPolicy.values()) { // ignore policies that aren't relevant to user if (!isTemplateRelevant(policy.template)) continue; + if (!policy.hasCycle()) continue; final long start = computeLastCycleBoundary(currentTime, policy); final long end = currentTime; @@ -528,21 +534,24 @@ public class NetworkPolicyManagerService extends INetworkPolicyManager.Stub { /** * Test if given {@link NetworkTemplate} is relevant to user based on - * current device state, such as when {@link #getActiveSubscriberId()} - * matches. This is regardless of data connection status. + * current device state, such as when + * {@link TelephonyManager#getSubscriberId()} matches. This is regardless of + * data connection status. */ private boolean isTemplateRelevant(NetworkTemplate template) { + final TelephonyManager tele = TelephonyManager.from(mContext); + switch (template.getMatchRule()) { case MATCH_MOBILE_3G_LOWER: case MATCH_MOBILE_4G: case MATCH_MOBILE_ALL: - // mobile templates aren't relevant in airplane mode - if (isAirplaneModeOn(mContext)) { + // mobile templates are relevant when SIM is ready and + // subscriberId matches. + if (tele.getSimState() == SIM_STATE_READY) { + return Objects.equal(tele.getSubscriberId(), template.getSubscriberId()); + } else { return false; } - - // mobile templates are relevant when subscriberid is active - return Objects.equal(getActiveSubscriberId(), template.getSubscriberId()); } return true; } @@ -761,7 +770,7 @@ public class NetworkPolicyManagerService extends INetworkPolicyManager.Stub { final long currentTime = currentTimeMillis(); for (NetworkPolicy policy : mNetworkPolicy.values()) { // shortcut when policy has no limit - if (policy.limitBytes == LIMIT_DISABLED) { + if (policy.limitBytes == LIMIT_DISABLED || !policy.hasCycle()) { setNetworkTemplateEnabled(policy.template, true); continue; } @@ -784,13 +793,16 @@ public class NetworkPolicyManagerService extends INetworkPolicyManager.Stub { * for the given {@link NetworkTemplate}. */ private void setNetworkTemplateEnabled(NetworkTemplate template, boolean enabled) { + final TelephonyManager tele = TelephonyManager.from(mContext); + switch (template.getMatchRule()) { case MATCH_MOBILE_3G_LOWER: case MATCH_MOBILE_4G: case MATCH_MOBILE_ALL: // TODO: offer more granular control over radio states once // 4965893 is available. - if (Objects.equal(getActiveSubscriberId(), template.getSubscriberId())) { + if (tele.getSimState() == SIM_STATE_READY + && Objects.equal(tele.getSubscriberId(), template.getSubscriberId())) { setPolicyDataEnable(TYPE_MOBILE, enabled); setPolicyDataEnable(TYPE_WIMAX, enabled); } @@ -863,9 +875,15 @@ public class NetworkPolicyManagerService extends INetworkPolicyManager.Stub { for (NetworkPolicy policy : mNetworkRules.keySet()) { final String[] ifaces = mNetworkRules.get(policy); - final long start = computeLastCycleBoundary(currentTime, policy); - final long end = currentTime; - final long totalBytes = getTotalBytes(policy.template, start, end); + final long start; + final long totalBytes; + if (policy.hasCycle()) { + start = computeLastCycleBoundary(currentTime, policy); + totalBytes = getTotalBytes(policy.template, start, currentTime); + } else { + start = Long.MAX_VALUE; + totalBytes = 0; + } if (LOGD) { Slog.d(TAG, "applying policy " + policy.toString() + " to ifaces " @@ -923,9 +941,14 @@ public class NetworkPolicyManagerService extends INetworkPolicyManager.Stub { if (LOGV) Slog.v(TAG, "ensureActiveMobilePolicyLocked()"); if (mSuppressDefaultPolicy) return; - final String subscriberId = getActiveSubscriberId(); + final TelephonyManager tele = TelephonyManager.from(mContext); + + // avoid creating policy when SIM isn't ready + if (tele.getSimState() != SIM_STATE_READY) return; + + final String subscriberId = tele.getSubscriberId(); final NetworkIdentity probeIdent = new NetworkIdentity( - TYPE_MOBILE, TelephonyManager.NETWORK_TYPE_UNKNOWN, subscriberId, false); + TYPE_MOBILE, TelephonyManager.NETWORK_TYPE_UNKNOWN, subscriberId, null, false); // examine to see if any policy is defined for active mobile boolean mobileDefined = false; @@ -986,6 +1009,12 @@ public class NetworkPolicyManagerService extends INetworkPolicyManager.Stub { } else if (TAG_NETWORK_POLICY.equals(tag)) { final int networkTemplate = readIntAttribute(in, ATTR_NETWORK_TEMPLATE); final String subscriberId = in.getAttributeValue(null, ATTR_SUBSCRIBER_ID); + final String networkId; + if (version >= VERSION_ADDED_NETWORK_ID) { + networkId = in.getAttributeValue(null, ATTR_NETWORK_ID); + } else { + networkId = null; + } final int cycleDay = readIntAttribute(in, ATTR_CYCLE_DAY); final String cycleTimezone; if (version >= VERSION_ADDED_TIMEZONE) { @@ -1031,12 +1060,12 @@ public class NetworkPolicyManagerService extends INetworkPolicyManager.Stub { } final NetworkTemplate template = new NetworkTemplate( - networkTemplate, subscriberId); + networkTemplate, subscriberId, networkId); mNetworkPolicy.put(template, new NetworkPolicy(template, cycleDay, cycleTimezone, warningBytes, limitBytes, lastWarningSnooze, lastLimitSnooze, metered, inferred)); - } else if (TAG_UID_POLICY.equals(tag)) { + } else if (TAG_UID_POLICY.equals(tag) && version < VERSION_SWITCH_APP_ID) { final int uid = readIntAttribute(in, ATTR_UID); final int policy = readIntAttribute(in, ATTR_POLICY); @@ -1046,7 +1075,7 @@ public class NetworkPolicyManagerService extends INetworkPolicyManager.Stub { } else { Slog.w(TAG, "unable to apply policy to UID " + uid + "; ignoring"); } - } else if (TAG_APP_POLICY.equals(tag)) { + } else if (TAG_APP_POLICY.equals(tag) && version >= VERSION_SWITCH_APP_ID) { final int appId = readIntAttribute(in, ATTR_APP_ID); final int policy = readIntAttribute(in, ATTR_POLICY); @@ -1099,7 +1128,7 @@ public class NetworkPolicyManagerService extends INetworkPolicyManager.Stub { out.startDocument(null, true); out.startTag(null, TAG_POLICY_LIST); - writeIntAttribute(out, ATTR_VERSION, VERSION_SWITCH_APP_ID); + writeIntAttribute(out, ATTR_VERSION, VERSION_LATEST); writeBooleanAttribute(out, ATTR_RESTRICT_BACKGROUND, mRestrictBackground); // write all known network policies @@ -1112,6 +1141,10 @@ public class NetworkPolicyManagerService extends INetworkPolicyManager.Stub { if (subscriberId != null) { out.attribute(null, ATTR_SUBSCRIBER_ID, subscriberId); } + final String networkId = template.getNetworkId(); + if (networkId != null) { + out.attribute(null, ATTR_NETWORK_ID, networkId); + } writeIntAttribute(out, ATTR_CYCLE_DAY, policy.cycleDay); out.attribute(null, ATTR_CYCLE_TIMEZONE, policy.cycleTimezone); writeLongAttribute(out, ATTR_WARNING_BYTES, policy.warningBytes); @@ -1318,7 +1351,7 @@ public class NetworkPolicyManagerService extends INetworkPolicyManager.Stub { policy = findPolicyForNetworkLocked(ident); } - if (policy == null) { + if (policy == null || !policy.hasCycle()) { // missing policy means we can't derive useful quota info return null; } @@ -1340,9 +1373,11 @@ public class NetworkPolicyManagerService extends INetworkPolicyManager.Stub { } @Override - protected void dump(FileDescriptor fd, PrintWriter fout, String[] args) { + protected void dump(FileDescriptor fd, PrintWriter writer, String[] args) { mContext.enforceCallingOrSelfPermission(DUMP, TAG); + final IndentingPrintWriter fout = new IndentingPrintWriter(writer, " "); + final HashSet<String> argSet = new HashSet<String>(); for (String arg : args) { argSet.add(arg); @@ -1365,31 +1400,36 @@ public class NetworkPolicyManagerService extends INetworkPolicyManager.Stub { fout.print("Restrict background: "); fout.println(mRestrictBackground); fout.println("Network policies:"); + fout.increaseIndent(); for (NetworkPolicy policy : mNetworkPolicy.values()) { - fout.print(" "); fout.println(policy.toString()); + fout.println(policy.toString()); } + fout.decreaseIndent(); fout.println("Policy for apps:"); + fout.increaseIndent(); int size = mAppPolicy.size(); for (int i = 0; i < size; i++) { final int appId = mAppPolicy.keyAt(i); final int policy = mAppPolicy.valueAt(i); - fout.print(" appId="); + fout.print("appId="); fout.print(appId); fout.print(" policy="); dumpPolicy(fout, policy); fout.println(); } + fout.decreaseIndent(); final SparseBooleanArray knownUids = new SparseBooleanArray(); collectKeys(mUidForeground, knownUids); collectKeys(mUidRules, knownUids); fout.println("Status for known UIDs:"); + fout.increaseIndent(); size = knownUids.size(); for (int i = 0; i < size; i++) { final int uid = knownUids.keyAt(i); - fout.print(" UID="); + fout.print("UID="); fout.print(uid); fout.print(" foreground="); @@ -1410,6 +1450,7 @@ public class NetworkPolicyManagerService extends INetworkPolicyManager.Stub { fout.println(); } + fout.decreaseIndent(); } } @@ -1697,12 +1738,6 @@ public class NetworkPolicyManagerService extends INetworkPolicyManager.Stub { } } - private String getActiveSubscriberId() { - final TelephonyManager telephony = (TelephonyManager) mContext.getSystemService( - Context.TELEPHONY_SERVICE); - return telephony.getSubscriberId(); - } - private long getTotalBytes(NetworkTemplate template, long start, long end) { try { return mNetworkStats.getSummaryForNetwork(template, start, end).getTotalBytes(); diff --git a/services/java/com/android/server/net/NetworkStatsService.java b/services/java/com/android/server/net/NetworkStatsService.java index 8796afc..b847673 100644 --- a/services/java/com/android/server/net/NetworkStatsService.java +++ b/services/java/com/android/server/net/NetworkStatsService.java @@ -34,7 +34,7 @@ import static android.net.NetworkStats.SET_FOREGROUND; import static android.net.NetworkStats.TAG_NONE; import static android.net.NetworkStats.UID_ALL; import static android.net.NetworkTemplate.buildTemplateMobileAll; -import static android.net.NetworkTemplate.buildTemplateWifi; +import static android.net.NetworkTemplate.buildTemplateWifiWildcard; import static android.net.TrafficStats.MB_IN_BYTES; import static android.provider.Settings.Secure.NETSTATS_DEV_BUCKET_DURATION; import static android.provider.Settings.Secure.NETSTATS_DEV_DELETE_AGE; @@ -836,7 +836,7 @@ public class NetworkStatsService extends INetworkStatsService.Stub { trustedTime); // collect wifi sample - template = buildTemplateWifi(); + template = buildTemplateWifiWildcard(); devTotal = mDevRecorder.getTotalSinceBootLocked(template); xtTotal = new NetworkStats.Entry(); uidTotal = mUidRecorder.getTotalSinceBootLocked(template); diff --git a/services/java/com/android/server/wm/AppWindowToken.java b/services/java/com/android/server/wm/AppWindowToken.java index e3d46d8..1f8348d 100644 --- a/services/java/com/android/server/wm/AppWindowToken.java +++ b/services/java/com/android/server/wm/AppWindowToken.java @@ -18,6 +18,7 @@ package com.android.server.wm; import static android.view.WindowManager.LayoutParams.TYPE_APPLICATION_STARTING; +import com.android.server.input.InputApplicationHandle; import com.android.server.wm.WindowManagerService.H; import android.content.pm.ActivityInfo; @@ -285,4 +286,4 @@ class AppWindowToken extends WindowToken { } return stringName; } -}
\ No newline at end of file +} diff --git a/services/java/com/android/server/wm/DragState.java b/services/java/com/android/server/wm/DragState.java index a19035a..b2cf3e0 100644 --- a/services/java/com/android/server/wm/DragState.java +++ b/services/java/com/android/server/wm/DragState.java @@ -16,6 +16,8 @@ package com.android.server.wm; +import com.android.server.input.InputApplicationHandle; +import com.android.server.input.InputWindowHandle; import com.android.server.wm.WindowManagerService.DragInputEventReceiver; import com.android.server.wm.WindowManagerService.H; diff --git a/services/java/com/android/server/wm/FakeWindowImpl.java b/services/java/com/android/server/wm/FakeWindowImpl.java index 121ce18..2527f46 100644 --- a/services/java/com/android/server/wm/FakeWindowImpl.java +++ b/services/java/com/android/server/wm/FakeWindowImpl.java @@ -16,6 +16,9 @@ package com.android.server.wm; +import com.android.server.input.InputApplicationHandle; +import com.android.server.input.InputWindowHandle; + import android.os.Looper; import android.os.Process; import android.util.Slog; diff --git a/services/java/com/android/server/wm/InputMonitor.java b/services/java/com/android/server/wm/InputMonitor.java index fb74d27..c28cfa2 100644 --- a/services/java/com/android/server/wm/InputMonitor.java +++ b/services/java/com/android/server/wm/InputMonitor.java @@ -16,6 +16,10 @@ package com.android.server.wm; +import com.android.server.input.InputManagerService; +import com.android.server.input.InputApplicationHandle; +import com.android.server.input.InputWindowHandle; + import android.graphics.Rect; import android.os.RemoteException; import android.util.Log; @@ -27,7 +31,7 @@ import android.view.WindowManager; import java.util.ArrayList; import java.util.Arrays; -final class InputMonitor { +final class InputMonitor implements InputManagerService.Callbacks { private final WindowManagerService mService; // Current window with input focus for keys and other non-touch events. May be null. @@ -93,7 +97,7 @@ final class InputMonitor { } if (appWindowToken == null && inputApplicationHandle != null) { - appWindowToken = inputApplicationHandle.appWindowToken; + appWindowToken = (AppWindowToken)inputApplicationHandle.appWindowToken; if (appWindowToken != null) { Slog.i(WindowManagerService.TAG, "Input event dispatching timed out sending to application " @@ -301,7 +305,14 @@ final class InputMonitor { WindowState windowState = focus != null ? (WindowState) focus.windowState : null; return mService.mPolicy.dispatchUnhandledKey(windowState, event, policyFlags); } - + + /* Callback to get pointer layer. */ + public int getPointerLayer() { + return mService.mPolicy.windowTypeToLayerLw(WindowManager.LayoutParams.TYPE_POINTER) + * WindowManagerService.TYPE_LAYER_MULTIPLIER + + WindowManagerService.TYPE_LAYER_OFFSET; + } + /* Called when the current input focus changes. * Layer assignment is assumed to be complete by the time this is called. */ diff --git a/services/java/com/android/server/wm/WindowAnimator.java b/services/java/com/android/server/wm/WindowAnimator.java index 77f94d9..67e057e 100644 --- a/services/java/com/android/server/wm/WindowAnimator.java +++ b/services/java/com/android/server/wm/WindowAnimator.java @@ -139,7 +139,7 @@ public class WindowAnimator { final int NEAT = mService.mExitingAppTokens.size(); for (i=0; i<NEAT; i++) { - final AppWindowAnimator appAnimator = mService.mAppTokens.get(i).mAppAnimator; + final AppWindowAnimator appAnimator = mService.mExitingAppTokens.get(i).mAppAnimator; final boolean wasAnimating = appAnimator.animation != null && appAnimator.animation != WindowManagerService.sDummyAnimation; if (appAnimator.stepAnimationLocked(mCurrentTime, mInnerDw, mInnerDh)) { @@ -440,9 +440,12 @@ public class WindowAnimator { w.mWinAnimator.prepareSurfaceLocked(true); } + if (mDimParams != null) { + mDimAnimator.updateParameters(mContext.getResources(), mDimParams, mCurrentTime); + } if (mDimAnimator != null && mDimAnimator.mDimShown) { - mAnimating |= mDimAnimator.updateSurface(mService.mInnerFields.mDimming, - mCurrentTime, !mService.okToDisplay()); + mAnimating |= mDimAnimator.updateSurface(mDimParams != null, mCurrentTime, + !mService.okToDisplay()); } if (mService.mBlackFrame != null) { @@ -453,10 +456,6 @@ public class WindowAnimator { mService.mBlackFrame.clearMatrix(); } } - - if (mDimParams != null) { - mDimAnimator.updateParameters(mContext.getResources(), mDimParams, mCurrentTime); - } } catch (RuntimeException e) { Log.wtf(TAG, "Unhandled exception in Window Manager", e); } finally { diff --git a/services/java/com/android/server/wm/WindowManagerService.java b/services/java/com/android/server/wm/WindowManagerService.java index 36fad7f..716b7b1 100644 --- a/services/java/com/android/server/wm/WindowManagerService.java +++ b/services/java/com/android/server/wm/WindowManagerService.java @@ -44,6 +44,8 @@ import com.android.server.EventLogTags; import com.android.server.PowerManagerService; import com.android.server.Watchdog; import com.android.server.am.BatteryStatsService; +import com.android.server.input.InputFilter; +import com.android.server.input.InputManagerService; import android.Manifest; import android.app.ActivityManagerNative; @@ -243,10 +245,6 @@ public class WindowManagerService extends IWindowManager.Stub */ static final boolean CUSTOM_SCREEN_ROTATION = true; - // Maximum number of milliseconds to wait for input event injection. - // FIXME is this value reasonable? - private static final int INJECTION_TIMEOUT_MILLIS = 30 * 1000; - // Maximum number of milliseconds to wait for input devices to be enumerated before // proceding with safe mode detection. private static final int INPUT_DEVICES_READY_FOR_SAFE_MODE_DETECTION_TIMEOUT_MILLIS = 1000; @@ -626,7 +624,7 @@ public class WindowManagerService extends IWindowManager.Stub float mTransitionAnimationScale = 1.0f; float mAnimatorDurationScale = 1.0f; - final InputManager mInputManager; + final InputManagerService mInputManager; // Who is holding the screen on. Session mHoldingScreenOn; @@ -894,7 +892,7 @@ public class WindowManagerService extends IWindowManager.Stub "KEEP_SCREEN_ON_FLAG"); mHoldingScreenWakeLock.setReferenceCounted(false); - mInputManager = new InputManager(context, this); + mInputManager = new InputManagerService(context, mInputMonitor); mAnimator = new WindowAnimator(this, context, mPolicy); PolicyThread thr = new PolicyThread(mPolicy, this, context, pm); @@ -915,6 +913,10 @@ public class WindowManagerService extends IWindowManager.Stub Watchdog.getInstance().addMonitor(this); } + public InputManagerService getInputManagerService() { + return mInputManager; + } + @Override public boolean onTransact(int code, Parcel data, Parcel reply, int flags) throws RemoteException { @@ -4849,90 +4851,22 @@ public class WindowManagerService extends IWindowManager.Stub mAnimatorDurationScale }; } - public int getSwitchState(int sw) { - if (!checkCallingPermission(android.Manifest.permission.READ_INPUT_STATE, - "getSwitchState()")) { - throw new SecurityException("Requires READ_INPUT_STATE permission"); - } - return mInputManager.getSwitchState(-1, InputDevice.SOURCE_ANY, sw); - } - - public int getSwitchStateForDevice(int devid, int sw) { - if (!checkCallingPermission(android.Manifest.permission.READ_INPUT_STATE, - "getSwitchStateForDevice()")) { - throw new SecurityException("Requires READ_INPUT_STATE permission"); - } - return mInputManager.getSwitchState(devid, InputDevice.SOURCE_ANY, sw); - } - - public int getScancodeState(int sw) { - if (!checkCallingPermission(android.Manifest.permission.READ_INPUT_STATE, - "getScancodeState()")) { - throw new SecurityException("Requires READ_INPUT_STATE permission"); - } - return mInputManager.getScanCodeState(-1, InputDevice.SOURCE_ANY, sw); - } - - public int getScancodeStateForDevice(int devid, int sw) { - if (!checkCallingPermission(android.Manifest.permission.READ_INPUT_STATE, - "getScancodeStateForDevice()")) { - throw new SecurityException("Requires READ_INPUT_STATE permission"); - } - return mInputManager.getScanCodeState(devid, InputDevice.SOURCE_ANY, sw); - } - - public int getTrackballScancodeState(int sw) { - if (!checkCallingPermission(android.Manifest.permission.READ_INPUT_STATE, - "getTrackballScancodeState()")) { - throw new SecurityException("Requires READ_INPUT_STATE permission"); - } - return mInputManager.getScanCodeState(-1, InputDevice.SOURCE_TRACKBALL, sw); - } - - public int getDPadScancodeState(int sw) { - if (!checkCallingPermission(android.Manifest.permission.READ_INPUT_STATE, - "getDPadScancodeState()")) { - throw new SecurityException("Requires READ_INPUT_STATE permission"); - } - return mInputManager.getScanCodeState(-1, InputDevice.SOURCE_DPAD, sw); - } - - public int getKeycodeState(int sw) { - if (!checkCallingPermission(android.Manifest.permission.READ_INPUT_STATE, - "getKeycodeState()")) { - throw new SecurityException("Requires READ_INPUT_STATE permission"); - } - return mInputManager.getKeyCodeState(-1, InputDevice.SOURCE_ANY, sw); - } - - public int getKeycodeStateForDevice(int devid, int sw) { - if (!checkCallingPermission(android.Manifest.permission.READ_INPUT_STATE, - "getKeycodeStateForDevice()")) { - throw new SecurityException("Requires READ_INPUT_STATE permission"); - } - return mInputManager.getKeyCodeState(devid, InputDevice.SOURCE_ANY, sw); - } - - public int getTrackballKeycodeState(int sw) { - if (!checkCallingPermission(android.Manifest.permission.READ_INPUT_STATE, - "getTrackballKeycodeState()")) { - throw new SecurityException("Requires READ_INPUT_STATE permission"); - } - return mInputManager.getKeyCodeState(-1, InputDevice.SOURCE_TRACKBALL, sw); - } - - public int getDPadKeycodeState(int sw) { - if (!checkCallingPermission(android.Manifest.permission.READ_INPUT_STATE, - "getDPadKeycodeState()")) { - throw new SecurityException("Requires READ_INPUT_STATE permission"); + // Called by window manager policy. Not exposed externally. + @Override + public int getLidState() { + final int SW_LID = 0x00; + int sw = mInputManager.getSwitchState(-1, InputDevice.SOURCE_ANY, SW_LID); + if (sw > 0) { + return LID_OPEN; + } else if (sw == 0) { + return LID_CLOSED; + } else { + return LID_ABSENT; } - return mInputManager.getKeyCodeState(-1, InputDevice.SOURCE_DPAD, sw); - } - - public boolean hasKeys(int[] keycodes, boolean[] keyExists) { - return mInputManager.hasKeys(-1, InputDevice.SOURCE_ANY, keycodes, keyExists); } + // Called by window manager policy. Not exposed externally. + @Override public InputChannel monitorInput(String inputChannelName) { if (!checkCallingPermission(android.Manifest.permission.READ_INPUT_STATE, "monitorInput()")) { @@ -4945,14 +4879,6 @@ public class WindowManagerService extends IWindowManager.Stub mInputManager.setInputFilter(filter); } - public InputDevice getInputDevice(int deviceId) { - return mInputManager.getInputDevice(deviceId); - } - - public int[] getInputDeviceIds() { - return mInputManager.getInputDeviceIds(); - } - public void enableScreenAfterBoot() { synchronized(mWindowMap) { if (DEBUG_BOOT) { @@ -6438,164 +6364,6 @@ public class WindowManagerService extends IWindowManager.Stub sendScreenStatusToClients(); } - /** - * Injects a keystroke event into the UI. - * Even when sync is false, this method may block while waiting for current - * input events to be dispatched. - * - * @param ev A motion event describing the keystroke action. (Be sure to use - * {@link SystemClock#uptimeMillis()} as the timebase.) - * @param sync If true, wait for the event to be completed before returning to the caller. - * @return Returns true if event was dispatched, false if it was dropped for any reason - */ - public boolean injectKeyEvent(KeyEvent ev, boolean sync) { - long downTime = ev.getDownTime(); - long eventTime = ev.getEventTime(); - - int action = ev.getAction(); - int code = ev.getKeyCode(); - int repeatCount = ev.getRepeatCount(); - int metaState = ev.getMetaState(); - int deviceId = ev.getDeviceId(); - int scancode = ev.getScanCode(); - int source = ev.getSource(); - int flags = ev.getFlags(); - - if (source == InputDevice.SOURCE_UNKNOWN) { - source = InputDevice.SOURCE_KEYBOARD; - } - - if (eventTime == 0) eventTime = SystemClock.uptimeMillis(); - if (downTime == 0) downTime = eventTime; - - KeyEvent newEvent = new KeyEvent(downTime, eventTime, action, code, repeatCount, metaState, - deviceId, scancode, flags | KeyEvent.FLAG_FROM_SYSTEM, source); - - final int pid = Binder.getCallingPid(); - final int uid = Binder.getCallingUid(); - final long ident = Binder.clearCallingIdentity(); - - final int result = mInputManager.injectInputEvent(newEvent, pid, uid, - sync ? InputManager.INPUT_EVENT_INJECTION_SYNC_WAIT_FOR_FINISH - : InputManager.INPUT_EVENT_INJECTION_SYNC_WAIT_FOR_RESULT, - INJECTION_TIMEOUT_MILLIS); - - Binder.restoreCallingIdentity(ident); - return reportInjectionResult(result, pid); - } - - /** - * Inject a pointer (touch) event into the UI. - * Even when sync is false, this method may block while waiting for current - * input events to be dispatched. - * - * @param ev A motion event describing the pointer (touch) action. (As noted in - * {@link MotionEvent#obtain(long, long, int, float, float, int)}, be sure to use - * {@link SystemClock#uptimeMillis()} as the timebase.) - * @param sync If true, wait for the event to be completed before returning to the caller. - * @return Returns true if event was dispatched, false if it was dropped for any reason - */ - public boolean injectPointerEvent(MotionEvent ev, boolean sync) { - final int pid = Binder.getCallingPid(); - final int uid = Binder.getCallingUid(); - final long ident = Binder.clearCallingIdentity(); - - MotionEvent newEvent = MotionEvent.obtain(ev); - if ((newEvent.getSource() & InputDevice.SOURCE_CLASS_POINTER) == 0) { - newEvent.setSource(InputDevice.SOURCE_TOUCHSCREEN); - } - - final int result = mInputManager.injectInputEvent(newEvent, pid, uid, - sync ? InputManager.INPUT_EVENT_INJECTION_SYNC_WAIT_FOR_FINISH - : InputManager.INPUT_EVENT_INJECTION_SYNC_WAIT_FOR_RESULT, - INJECTION_TIMEOUT_MILLIS); - - Binder.restoreCallingIdentity(ident); - return reportInjectionResult(result, pid); - } - - /** - * Inject a trackball (navigation device) event into the UI. - * Even when sync is false, this method may block while waiting for current - * input events to be dispatched. - * - * @param ev A motion event describing the trackball action. (As noted in - * {@link MotionEvent#obtain(long, long, int, float, float, int)}, be sure to use - * {@link SystemClock#uptimeMillis()} as the timebase.) - * @param sync If true, wait for the event to be completed before returning to the caller. - * @return Returns true if event was dispatched, false if it was dropped for any reason - */ - public boolean injectTrackballEvent(MotionEvent ev, boolean sync) { - final int pid = Binder.getCallingPid(); - final int uid = Binder.getCallingUid(); - final long ident = Binder.clearCallingIdentity(); - - MotionEvent newEvent = MotionEvent.obtain(ev); - if ((newEvent.getSource() & InputDevice.SOURCE_CLASS_TRACKBALL) == 0) { - newEvent.setSource(InputDevice.SOURCE_TRACKBALL); - } - - final int result = mInputManager.injectInputEvent(newEvent, pid, uid, - sync ? InputManager.INPUT_EVENT_INJECTION_SYNC_WAIT_FOR_FINISH - : InputManager.INPUT_EVENT_INJECTION_SYNC_WAIT_FOR_RESULT, - INJECTION_TIMEOUT_MILLIS); - - Binder.restoreCallingIdentity(ident); - return reportInjectionResult(result, pid); - } - - /** - * Inject an input event into the UI without waiting for dispatch to commence. - * This variant is useful for fire-and-forget input event injection. It does not - * block any longer than it takes to enqueue the input event. - * - * @param ev An input event. (Be sure to set the input source correctly.) - * @return Returns true if event was dispatched, false if it was dropped for any reason - */ - public boolean injectInputEventNoWait(InputEvent ev) { - final int pid = Binder.getCallingPid(); - final int uid = Binder.getCallingUid(); - final long ident = Binder.clearCallingIdentity(); - - final int result = mInputManager.injectInputEvent(ev, pid, uid, - InputManager.INPUT_EVENT_INJECTION_SYNC_NONE, - INJECTION_TIMEOUT_MILLIS); - - Binder.restoreCallingIdentity(ident); - return reportInjectionResult(result, pid); - } - - private boolean reportInjectionResult(int result, int pid) { - switch (result) { - case InputManager.INPUT_EVENT_INJECTION_PERMISSION_DENIED: - Slog.w(TAG, "Input event injection from pid " + pid + " permission denied."); - throw new SecurityException( - "Injecting to another application requires INJECT_EVENTS permission"); - case InputManager.INPUT_EVENT_INJECTION_SUCCEEDED: - return true; - case InputManager.INPUT_EVENT_INJECTION_TIMED_OUT: - Slog.w(TAG, "Input event injection from pid " + pid + " timed out."); - return false; - case InputManager.INPUT_EVENT_INJECTION_FAILED: - default: - Slog.w(TAG, "Input event injection from pid " + pid + " failed."); - return false; - } - } - - /** - * Temporarily set the pointer speed. Does not save the new setting. - * Used by the settings application. - */ - public void setPointerSpeed(int speed) { - if (!checkCallingPermission(android.Manifest.permission.SET_POINTER_SPEED, - "setPointerSpeed()")) { - throw new SecurityException("Requires SET_POINTER_SPEED permission"); - } - - mInputManager.setPointerSpeed(speed); - } - private WindowState getFocusedWindow() { synchronized (mWindowMap) { return getFocusedWindowLocked(); @@ -6610,11 +6378,29 @@ public class WindowManagerService extends IWindowManager.Stub if (!mInputMonitor.waitForInputDevicesReady( INPUT_DEVICES_READY_FOR_SAFE_MODE_DETECTION_TIMEOUT_MILLIS)) { Slog.w(TAG, "Devices still not ready after waiting " - + INPUT_DEVICES_READY_FOR_SAFE_MODE_DETECTION_TIMEOUT_MILLIS - + " milliseconds before attempting to detect safe mode."); + + INPUT_DEVICES_READY_FOR_SAFE_MODE_DETECTION_TIMEOUT_MILLIS + + " milliseconds before attempting to detect safe mode."); + } + + final int BTN_MOUSE = 0x110; + int menuState = mInputManager.getKeyCodeState(-1, InputDevice.SOURCE_ANY, + KeyEvent.KEYCODE_MENU); + int sState = mInputManager.getKeyCodeState(-1, InputDevice.SOURCE_ANY, KeyEvent.KEYCODE_S); + int dpadState = mInputManager.getKeyCodeState(-1, InputDevice.SOURCE_DPAD, + KeyEvent.KEYCODE_DPAD_CENTER); + int trackballState = mInputManager.getScanCodeState(-1, InputDevice.SOURCE_TRACKBALL, + BTN_MOUSE); + int volumeDownState = mInputManager.getKeyCodeState(-1, InputDevice.SOURCE_ANY, + KeyEvent.KEYCODE_VOLUME_DOWN); + mSafeMode = menuState > 0 || sState > 0 || dpadState > 0 || trackballState > 0 + || volumeDownState > 0; + if (mSafeMode) { + Log.i(TAG, "SAFE MODE ENABLED (menu=" + menuState + " s=" + sState + + " dpad=" + dpadState + " trackball=" + trackballState + ")"); + } else { + Log.i(TAG, "SAFE MODE not enabled"); } - - mSafeMode = mPolicy.detectSafeMode(); + mPolicy.setSafeMode(mSafeMode); return mSafeMode; } @@ -8420,7 +8206,7 @@ public class WindowManagerService extends IWindowManager.Stub updateWallpaperVisibilityLocked(); } } - if (!mInnerFields.mDimming) { + if (!mInnerFields.mDimming && mAnimator.mDimParams != null) { mAnimator.stopDimming(); } } catch (RuntimeException e) { @@ -9281,11 +9067,6 @@ public class WindowManagerService extends IWindowManager.Stub mPolicy.lockNow(); } - void dumpInput(FileDescriptor fd, PrintWriter pw, boolean dumpAll) { - pw.println("WINDOW MANAGER INPUT (dumpsys window input)"); - mInputManager.dump(pw); - } - void dumpPolicyLocked(FileDescriptor fd, PrintWriter pw, String[] args, boolean dumpAll) { pw.println("WINDOW MANAGER POLICY STATE (dumpsys window policy)"); mPolicy.dump(" ", fd, pw, args); @@ -9675,7 +9456,6 @@ public class WindowManagerService extends IWindowManager.Stub pw.println("Window manager dump options:"); pw.println(" [-a] [-h] [cmd] ..."); pw.println(" cmd may be one of:"); - pw.println(" i[input]: input subsystem state"); pw.println(" p[policy]: policy state"); pw.println(" s[essions]: active sessions"); pw.println(" t[okens]: token list"); @@ -9696,10 +9476,7 @@ public class WindowManagerService extends IWindowManager.Stub if (opti < args.length) { String cmd = args[opti]; opti++; - if ("input".equals(cmd) || "i".equals(cmd)) { - dumpInput(fd, pw, true); - return; - } else if ("policy".equals(cmd) || "p".equals(cmd)) { + if ("policy".equals(cmd) || "p".equals(cmd)) { synchronized(mWindowMap) { dumpPolicyLocked(fd, pw, args, true); } @@ -9734,8 +9511,6 @@ public class WindowManagerService extends IWindowManager.Stub } } - dumpInput(fd, pw, dumpAll); - synchronized(mWindowMap) { if (dumpAll) { pw.println("-------------------------------------------------------------------------------"); diff --git a/services/java/com/android/server/wm/WindowState.java b/services/java/com/android/server/wm/WindowState.java index a4708d3..4de6425 100644 --- a/services/java/com/android/server/wm/WindowState.java +++ b/services/java/com/android/server/wm/WindowState.java @@ -23,6 +23,8 @@ import static android.view.WindowManager.LayoutParams.TYPE_INPUT_METHOD; import static android.view.WindowManager.LayoutParams.TYPE_INPUT_METHOD_DIALOG; import static android.view.WindowManager.LayoutParams.TYPE_WALLPAPER; +import com.android.server.input.InputWindowHandle; + import android.content.Context; import android.content.res.Configuration; import android.graphics.Matrix; diff --git a/services/jni/Android.mk b/services/jni/Android.mk index c02dd36..ac4fd15 100644 --- a/services/jni/Android.mk +++ b/services/jni/Android.mk @@ -4,9 +4,9 @@ include $(CLEAR_VARS) LOCAL_SRC_FILES:= \ com_android_server_AlarmManagerService.cpp \ com_android_server_BatteryService.cpp \ - com_android_server_InputApplicationHandle.cpp \ - com_android_server_InputManager.cpp \ - com_android_server_InputWindowHandle.cpp \ + com_android_server_input_InputApplicationHandle.cpp \ + com_android_server_input_InputManagerService.cpp \ + com_android_server_input_InputWindowHandle.cpp \ com_android_server_LightsService.cpp \ com_android_server_PowerManagerService.cpp \ com_android_server_SerialService.cpp \ diff --git a/services/jni/com_android_server_InputApplicationHandle.cpp b/services/jni/com_android_server_input_InputApplicationHandle.cpp index c76ab53..0109430 100644 --- a/services/jni/com_android_server_InputApplicationHandle.cpp +++ b/services/jni/com_android_server_input_InputApplicationHandle.cpp @@ -21,7 +21,7 @@ #include <android_runtime/AndroidRuntime.h> #include <utils/threads.h> -#include "com_android_server_InputApplicationHandle.h" +#include "com_android_server_input_InputApplicationHandle.h" namespace android { @@ -135,12 +135,12 @@ static JNINativeMethod gInputApplicationHandleMethods[] = { LOG_FATAL_IF(! var, "Unable to find field " fieldName); int register_android_server_InputApplicationHandle(JNIEnv* env) { - int res = jniRegisterNativeMethods(env, "com/android/server/wm/InputApplicationHandle", + int res = jniRegisterNativeMethods(env, "com/android/server/input/InputApplicationHandle", gInputApplicationHandleMethods, NELEM(gInputApplicationHandleMethods)); LOG_FATAL_IF(res < 0, "Unable to register native methods."); jclass clazz; - FIND_CLASS(clazz, "com/android/server/wm/InputApplicationHandle"); + FIND_CLASS(clazz, "com/android/server/input/InputApplicationHandle"); GET_FIELD_ID(gInputApplicationHandleClassInfo.ptr, clazz, "ptr", "I"); diff --git a/services/jni/com_android_server_InputApplicationHandle.h b/services/jni/com_android_server_input_InputApplicationHandle.h index 89d48c6..89d48c6 100644 --- a/services/jni/com_android_server_InputApplicationHandle.h +++ b/services/jni/com_android_server_input_InputApplicationHandle.h diff --git a/services/jni/com_android_server_InputManager.cpp b/services/jni/com_android_server_input_InputManagerService.cpp index 5c3e002..22795bf 100644 --- a/services/jni/com_android_server_InputManager.cpp +++ b/services/jni/com_android_server_input_InputManagerService.cpp @@ -46,8 +46,8 @@ #include <android/graphics/GraphicsJNI.h> #include "com_android_server_PowerManagerService.h" -#include "com_android_server_InputApplicationHandle.h" -#include "com_android_server_InputWindowHandle.h" +#include "com_android_server_input_InputApplicationHandle.h" +#include "com_android_server_input_InputWindowHandle.h" namespace android { @@ -77,7 +77,7 @@ static struct { jmethodID getLongPressTimeout; jmethodID getPointerLayer; jmethodID getPointerIcon; -} gCallbacksClassInfo; +} gServiceClassInfo; static struct { jclass clazz; @@ -166,7 +166,7 @@ protected: virtual ~NativeInputManager(); public: - NativeInputManager(jobject contextObj, jobject callbacksObj, const sp<Looper>& looper); + NativeInputManager(jobject contextObj, jobject serviceObj, const sp<Looper>& looper); inline sp<InputManager> getInputManager() const { return mInputManager; } @@ -222,7 +222,7 @@ private: sp<InputManager> mInputManager; jobject mContextObj; - jobject mCallbacksObj; + jobject mServiceObj; sp<Looper> mLooper; Mutex mLock; @@ -269,12 +269,12 @@ private: NativeInputManager::NativeInputManager(jobject contextObj, - jobject callbacksObj, const sp<Looper>& looper) : + jobject serviceObj, const sp<Looper>& looper) : mLooper(looper) { JNIEnv* env = jniEnv(); mContextObj = env->NewGlobalRef(contextObj); - mCallbacksObj = env->NewGlobalRef(callbacksObj); + mServiceObj = env->NewGlobalRef(serviceObj); { AutoMutex _l(mLock); @@ -298,7 +298,7 @@ NativeInputManager::~NativeInputManager() { JNIEnv* env = jniEnv(); env->DeleteGlobalRef(mContextObj); - env->DeleteGlobalRef(mCallbacksObj); + env->DeleteGlobalRef(mServiceObj); } void NativeInputManager::dump(String8& dump) { @@ -387,15 +387,15 @@ status_t NativeInputManager::unregisterInputChannel(JNIEnv* env, void NativeInputManager::getReaderConfiguration(InputReaderConfiguration* outConfig) { JNIEnv* env = jniEnv(); - jint virtualKeyQuietTime = env->CallIntMethod(mCallbacksObj, - gCallbacksClassInfo.getVirtualKeyQuietTimeMillis); + jint virtualKeyQuietTime = env->CallIntMethod(mServiceObj, + gServiceClassInfo.getVirtualKeyQuietTimeMillis); if (!checkAndClearExceptionFromCallback(env, "getVirtualKeyQuietTimeMillis")) { outConfig->virtualKeyQuietTime = milliseconds_to_nanoseconds(virtualKeyQuietTime); } outConfig->excludedDeviceNames.clear(); - jobjectArray excludedDeviceNames = jobjectArray(env->CallObjectMethod(mCallbacksObj, - gCallbacksClassInfo.getExcludedDeviceNames)); + jobjectArray excludedDeviceNames = jobjectArray(env->CallObjectMethod(mServiceObj, + gServiceClassInfo.getExcludedDeviceNames)); if (!checkAndClearExceptionFromCallback(env, "getExcludedDeviceNames") && excludedDeviceNames) { jsize length = env->GetArrayLength(excludedDeviceNames); for (jsize i = 0; i < length; i++) { @@ -408,14 +408,14 @@ void NativeInputManager::getReaderConfiguration(InputReaderConfiguration* outCon env->DeleteLocalRef(excludedDeviceNames); } - jint hoverTapTimeout = env->CallIntMethod(mCallbacksObj, - gCallbacksClassInfo.getHoverTapTimeout); + jint hoverTapTimeout = env->CallIntMethod(mServiceObj, + gServiceClassInfo.getHoverTapTimeout); if (!checkAndClearExceptionFromCallback(env, "getHoverTapTimeout")) { - jint doubleTapTimeout = env->CallIntMethod(mCallbacksObj, - gCallbacksClassInfo.getDoubleTapTimeout); + jint doubleTapTimeout = env->CallIntMethod(mServiceObj, + gServiceClassInfo.getDoubleTapTimeout); if (!checkAndClearExceptionFromCallback(env, "getDoubleTapTimeout")) { - jint longPressTimeout = env->CallIntMethod(mCallbacksObj, - gCallbacksClassInfo.getLongPressTimeout); + jint longPressTimeout = env->CallIntMethod(mServiceObj, + gServiceClassInfo.getLongPressTimeout); if (!checkAndClearExceptionFromCallback(env, "getLongPressTimeout")) { outConfig->pointerGestureTapInterval = milliseconds_to_nanoseconds(hoverTapTimeout); @@ -430,8 +430,8 @@ void NativeInputManager::getReaderConfiguration(InputReaderConfiguration* outCon } } - jint hoverTapSlop = env->CallIntMethod(mCallbacksObj, - gCallbacksClassInfo.getHoverTapSlop); + jint hoverTapSlop = env->CallIntMethod(mServiceObj, + gServiceClassInfo.getHoverTapSlop); if (!checkAndClearExceptionFromCallback(env, "getHoverTapSlop")) { outConfig->pointerGestureTapSlop = hoverTapSlop; } @@ -467,8 +467,8 @@ sp<PointerControllerInterface> NativeInputManager::obtainPointerController(int32 controller->setDisplayOrientation(mLocked.displayOrientation); JNIEnv* env = jniEnv(); - jobject pointerIconObj = env->CallObjectMethod(mCallbacksObj, - gCallbacksClassInfo.getPointerIcon); + jobject pointerIconObj = env->CallObjectMethod(mServiceObj, + gServiceClassInfo.getPointerIcon); if (!checkAndClearExceptionFromCallback(env, "getPointerIcon")) { PointerIcon pointerIcon; status_t status = android_view_PointerIcon_load(env, pointerIconObj, @@ -490,7 +490,7 @@ sp<PointerControllerInterface> NativeInputManager::obtainPointerController(int32 void NativeInputManager::ensureSpriteControllerLocked() { if (mLocked.spriteController == NULL) { JNIEnv* env = jniEnv(); - jint layer = env->CallIntMethod(mCallbacksObj, gCallbacksClassInfo.getPointerLayer); + jint layer = env->CallIntMethod(mServiceObj, gServiceClassInfo.getPointerLayer); if (checkAndClearExceptionFromCallback(env, "getPointerLayer")) { layer = -1; } @@ -509,7 +509,7 @@ void NativeInputManager::notifySwitch(nsecs_t when, int32_t switchCode, switch (switchCode) { case SW_LID: - env->CallVoidMethod(mCallbacksObj, gCallbacksClassInfo.notifyLidSwitchChanged, + env->CallVoidMethod(mServiceObj, gServiceClassInfo.notifyLidSwitchChanged, when, switchValue == 0); checkAndClearExceptionFromCallback(env, "notifyLidSwitchChanged"); break; @@ -523,7 +523,7 @@ void NativeInputManager::notifyConfigurationChanged(nsecs_t when) { JNIEnv* env = jniEnv(); - env->CallVoidMethod(mCallbacksObj, gCallbacksClassInfo.notifyConfigurationChanged, when); + env->CallVoidMethod(mServiceObj, gServiceClassInfo.notifyConfigurationChanged, when); checkAndClearExceptionFromCallback(env, "notifyConfigurationChanged"); } @@ -540,8 +540,8 @@ nsecs_t NativeInputManager::notifyANR(const sp<InputApplicationHandle>& inputApp jobject inputWindowHandleObj = getInputWindowHandleObjLocalRef(env, inputWindowHandle); - jlong newTimeout = env->CallLongMethod(mCallbacksObj, - gCallbacksClassInfo.notifyANR, inputApplicationHandleObj, inputWindowHandleObj); + jlong newTimeout = env->CallLongMethod(mServiceObj, + gServiceClassInfo.notifyANR, inputApplicationHandleObj, inputWindowHandleObj); if (checkAndClearExceptionFromCallback(env, "notifyANR")) { newTimeout = 0; // abort dispatch } else { @@ -563,7 +563,7 @@ void NativeInputManager::notifyInputChannelBroken(const sp<InputWindowHandle>& i jobject inputWindowHandleObj = getInputWindowHandleObjLocalRef(env, inputWindowHandle); if (inputWindowHandleObj) { - env->CallVoidMethod(mCallbacksObj, gCallbacksClassInfo.notifyInputChannelBroken, + env->CallVoidMethod(mServiceObj, gServiceClassInfo.notifyInputChannelBroken, inputWindowHandleObj); checkAndClearExceptionFromCallback(env, "notifyInputChannelBroken"); @@ -574,14 +574,14 @@ void NativeInputManager::notifyInputChannelBroken(const sp<InputWindowHandle>& i void NativeInputManager::getDispatcherConfiguration(InputDispatcherConfiguration* outConfig) { JNIEnv* env = jniEnv(); - jint keyRepeatTimeout = env->CallIntMethod(mCallbacksObj, - gCallbacksClassInfo.getKeyRepeatTimeout); + jint keyRepeatTimeout = env->CallIntMethod(mServiceObj, + gServiceClassInfo.getKeyRepeatTimeout); if (!checkAndClearExceptionFromCallback(env, "getKeyRepeatTimeout")) { outConfig->keyRepeatTimeout = milliseconds_to_nanoseconds(keyRepeatTimeout); } - jint keyRepeatDelay = env->CallIntMethod(mCallbacksObj, - gCallbacksClassInfo.getKeyRepeatDelay); + jint keyRepeatDelay = env->CallIntMethod(mServiceObj, + gServiceClassInfo.getKeyRepeatDelay); if (!checkAndClearExceptionFromCallback(env, "getKeyRepeatDelay")) { outConfig->keyRepeatDelay = milliseconds_to_nanoseconds(keyRepeatDelay); } @@ -734,7 +734,7 @@ bool NativeInputManager::filterInputEvent(const InputEvent* inputEvent, uint32_t } // The callee is responsible for recycling the event. - jboolean pass = env->CallBooleanMethod(mCallbacksObj, gCallbacksClassInfo.filterInputEvent, + jboolean pass = env->CallBooleanMethod(mServiceObj, gServiceClassInfo.filterInputEvent, inputEventObj, policyFlags); if (checkAndClearExceptionFromCallback(env, "filterInputEvent")) { pass = true; @@ -758,8 +758,8 @@ void NativeInputManager::interceptKeyBeforeQueueing(const KeyEvent* keyEvent, jobject keyEventObj = android_view_KeyEvent_fromNative(env, keyEvent); jint wmActions; if (keyEventObj) { - wmActions = env->CallIntMethod(mCallbacksObj, - gCallbacksClassInfo.interceptKeyBeforeQueueing, + wmActions = env->CallIntMethod(mServiceObj, + gServiceClassInfo.interceptKeyBeforeQueueing, keyEventObj, policyFlags, isScreenOn); if (checkAndClearExceptionFromCallback(env, "interceptKeyBeforeQueueing")) { wmActions = 0; @@ -802,8 +802,8 @@ void NativeInputManager::interceptMotionBeforeQueueing(nsecs_t when, uint32_t& p } } else { JNIEnv* env = jniEnv(); - jint wmActions = env->CallIntMethod(mCallbacksObj, - gCallbacksClassInfo.interceptMotionBeforeQueueingWhenScreenOff, + jint wmActions = env->CallIntMethod(mServiceObj, + gServiceClassInfo.interceptMotionBeforeQueueingWhenScreenOff, policyFlags); if (checkAndClearExceptionFromCallback(env, "interceptMotionBeforeQueueingWhenScreenOff")) { @@ -858,8 +858,8 @@ nsecs_t NativeInputManager::interceptKeyBeforeDispatching( jobject inputWindowHandleObj = getInputWindowHandleObjLocalRef(env, inputWindowHandle); jobject keyEventObj = android_view_KeyEvent_fromNative(env, keyEvent); if (keyEventObj) { - jlong delayMillis = env->CallLongMethod(mCallbacksObj, - gCallbacksClassInfo.interceptKeyBeforeDispatching, + jlong delayMillis = env->CallLongMethod(mServiceObj, + gServiceClassInfo.interceptKeyBeforeDispatching, inputWindowHandleObj, keyEventObj, policyFlags); bool error = checkAndClearExceptionFromCallback(env, "interceptKeyBeforeDispatching"); android_view_KeyEvent_recycle(env, keyEventObj); @@ -891,8 +891,8 @@ bool NativeInputManager::dispatchUnhandledKey(const sp<InputWindowHandle>& input jobject inputWindowHandleObj = getInputWindowHandleObjLocalRef(env, inputWindowHandle); jobject keyEventObj = android_view_KeyEvent_fromNative(env, keyEvent); if (keyEventObj) { - jobject fallbackKeyEventObj = env->CallObjectMethod(mCallbacksObj, - gCallbacksClassInfo.dispatchUnhandledKey, + jobject fallbackKeyEventObj = env->CallObjectMethod(mServiceObj, + gServiceClassInfo.dispatchUnhandledKey, inputWindowHandleObj, keyEventObj, policyFlags); if (checkAndClearExceptionFromCallback(env, "dispatchUnhandledKey")) { fallbackKeyEventObj = NULL; @@ -925,8 +925,8 @@ void NativeInputManager::pokeUserActivity(nsecs_t eventTime, int32_t eventType) bool NativeInputManager::checkInjectEventsPermissionNonReentrant( int32_t injectorPid, int32_t injectorUid) { JNIEnv* env = jniEnv(); - jboolean result = env->CallBooleanMethod(mCallbacksObj, - gCallbacksClassInfo.checkInjectEventsPermission, injectorPid, injectorUid); + jboolean result = env->CallBooleanMethod(mServiceObj, + gServiceClassInfo.checkInjectEventsPermission, injectorPid, injectorUid); if (checkAndClearExceptionFromCallback(env, "checkInjectEventsPermission")) { result = false; } @@ -947,103 +947,75 @@ void NativeInputManager::loadPointerResources(PointerResources* outResources) { // ---------------------------------------------------------------------------- -static sp<NativeInputManager> gNativeInputManager; - -static bool checkInputManagerUnitialized(JNIEnv* env) { - if (gNativeInputManager == NULL) { - ALOGE("Input manager not initialized."); - jniThrowRuntimeException(env, "Input manager not initialized."); - return true; - } - return false; -} - -static void android_server_InputManager_nativeInit(JNIEnv* env, jclass clazz, - jobject contextObj, jobject callbacksObj, jobject messageQueueObj) { - if (gNativeInputManager == NULL) { - sp<Looper> looper = android_os_MessageQueue_getLooper(env, messageQueueObj); - gNativeInputManager = new NativeInputManager(contextObj, callbacksObj, looper); - } else { - ALOGE("Input manager already initialized."); - jniThrowRuntimeException(env, "Input manager already initialized."); - } +static jint nativeInit(JNIEnv* env, jclass clazz, + jobject serviceObj, jobject contextObj, jobject messageQueueObj) { + sp<Looper> looper = android_os_MessageQueue_getLooper(env, messageQueueObj); + NativeInputManager* im = new NativeInputManager(contextObj, serviceObj, looper); + im->incStrong(serviceObj); + return reinterpret_cast<jint>(im); } -static void android_server_InputManager_nativeStart(JNIEnv* env, jclass clazz) { - if (checkInputManagerUnitialized(env)) { - return; - } +static void nativeStart(JNIEnv* env, jclass clazz, jint ptr) { + NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr); - status_t result = gNativeInputManager->getInputManager()->start(); + status_t result = im->getInputManager()->start(); if (result) { jniThrowRuntimeException(env, "Input manager could not be started."); } } -static void android_server_InputManager_nativeSetDisplaySize(JNIEnv* env, jclass clazz, +static void nativeSetDisplaySize(JNIEnv* env, jclass clazz, jint ptr, jint displayId, jint width, jint height, jint externalWidth, jint externalHeight) { - if (checkInputManagerUnitialized(env)) { - return; - } + NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr); // XXX we could get this from the SurfaceFlinger directly instead of requiring it // to be passed in like this, not sure which is better but leaving it like this // keeps the window manager in direct control of when display transitions propagate down // to the input dispatcher - gNativeInputManager->setDisplaySize(displayId, width, height, externalWidth, externalHeight); + im->setDisplaySize(displayId, width, height, externalWidth, externalHeight); } -static void android_server_InputManager_nativeSetDisplayOrientation(JNIEnv* env, jclass clazz, - jint displayId, jint orientation) { - if (checkInputManagerUnitialized(env)) { - return; - } +static void nativeSetDisplayOrientation(JNIEnv* env, jclass clazz, + jint ptr, jint displayId, jint orientation) { + NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr); - gNativeInputManager->setDisplayOrientation(displayId, orientation); + im->setDisplayOrientation(displayId, orientation); } -static jint android_server_InputManager_nativeGetScanCodeState(JNIEnv* env, jclass clazz, - jint deviceId, jint sourceMask, jint scanCode) { - if (checkInputManagerUnitialized(env)) { - return AKEY_STATE_UNKNOWN; - } +static jint nativeGetScanCodeState(JNIEnv* env, jclass clazz, + jint ptr, jint deviceId, jint sourceMask, jint scanCode) { + NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr); - return gNativeInputManager->getInputManager()->getReader()->getScanCodeState( + return im->getInputManager()->getReader()->getScanCodeState( deviceId, uint32_t(sourceMask), scanCode); } -static jint android_server_InputManager_nativeGetKeyCodeState(JNIEnv* env, jclass clazz, - jint deviceId, jint sourceMask, jint keyCode) { - if (checkInputManagerUnitialized(env)) { - return AKEY_STATE_UNKNOWN; - } +static jint nativeGetKeyCodeState(JNIEnv* env, jclass clazz, + jint ptr, jint deviceId, jint sourceMask, jint keyCode) { + NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr); - return gNativeInputManager->getInputManager()->getReader()->getKeyCodeState( + return im->getInputManager()->getReader()->getKeyCodeState( deviceId, uint32_t(sourceMask), keyCode); } -static jint android_server_InputManager_nativeGetSwitchState(JNIEnv* env, jclass clazz, - jint deviceId, jint sourceMask, jint sw) { - if (checkInputManagerUnitialized(env)) { - return AKEY_STATE_UNKNOWN; - } +static jint nativeGetSwitchState(JNIEnv* env, jclass clazz, + jint ptr, jint deviceId, jint sourceMask, jint sw) { + NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr); - return gNativeInputManager->getInputManager()->getReader()->getSwitchState( + return im->getInputManager()->getReader()->getSwitchState( deviceId, uint32_t(sourceMask), sw); } -static jboolean android_server_InputManager_nativeHasKeys(JNIEnv* env, jclass clazz, - jint deviceId, jint sourceMask, jintArray keyCodes, jbooleanArray outFlags) { - if (checkInputManagerUnitialized(env)) { - return JNI_FALSE; - } +static jboolean nativeHasKeys(JNIEnv* env, jclass clazz, + jint ptr, jint deviceId, jint sourceMask, jintArray keyCodes, jbooleanArray outFlags) { + NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr); int32_t* codes = env->GetIntArrayElements(keyCodes, NULL); uint8_t* flags = env->GetBooleanArrayElements(outFlags, NULL); jsize numCodes = env->GetArrayLength(keyCodes); jboolean result; if (numCodes == env->GetArrayLength(keyCodes)) { - result = gNativeInputManager->getInputManager()->getReader()->hasKeys( + result = im->getInputManager()->getReader()->hasKeys( deviceId, uint32_t(sourceMask), numCodes, codes, flags); } else { result = JNI_FALSE; @@ -1059,21 +1031,18 @@ static void throwInputChannelNotInitialized(JNIEnv* env) { "inputChannel is not initialized"); } -static void android_server_InputManager_handleInputChannelDisposed(JNIEnv* env, +static void handleInputChannelDisposed(JNIEnv* env, jobject inputChannelObj, const sp<InputChannel>& inputChannel, void* data) { + NativeInputManager* im = static_cast<NativeInputManager*>(data); + ALOGW("Input channel object '%s' was disposed without first being unregistered with " "the input manager!", inputChannel->getName().string()); - - if (gNativeInputManager != NULL) { - gNativeInputManager->unregisterInputChannel(env, inputChannel); - } + im->unregisterInputChannel(env, inputChannel); } -static void android_server_InputManager_nativeRegisterInputChannel(JNIEnv* env, jclass clazz, - jobject inputChannelObj, jobject inputWindowHandleObj, jboolean monitor) { - if (checkInputManagerUnitialized(env)) { - return; - } +static void nativeRegisterInputChannel(JNIEnv* env, jclass clazz, + jint ptr, jobject inputChannelObj, jobject inputWindowHandleObj, jboolean monitor) { + NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr); sp<InputChannel> inputChannel = android_view_InputChannel_getInputChannel(env, inputChannelObj); @@ -1085,7 +1054,7 @@ static void android_server_InputManager_nativeRegisterInputChannel(JNIEnv* env, sp<InputWindowHandle> inputWindowHandle = android_server_InputWindowHandle_getHandle(env, inputWindowHandleObj); - status_t status = gNativeInputManager->registerInputChannel( + status_t status = im->registerInputChannel( env, inputChannel, inputWindowHandle, monitor); if (status) { String8 message; @@ -1096,15 +1065,13 @@ static void android_server_InputManager_nativeRegisterInputChannel(JNIEnv* env, if (! monitor) { android_view_InputChannel_setDisposeCallback(env, inputChannelObj, - android_server_InputManager_handleInputChannelDisposed, NULL); + handleInputChannelDisposed, im); } } -static void android_server_InputManager_nativeUnregisterInputChannel(JNIEnv* env, jclass clazz, - jobject inputChannelObj) { - if (checkInputManagerUnitialized(env)) { - return; - } +static void nativeUnregisterInputChannel(JNIEnv* env, jclass clazz, + jint ptr, jobject inputChannelObj) { + NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr); sp<InputChannel> inputChannel = android_view_InputChannel_getInputChannel(env, inputChannelObj); @@ -1115,7 +1082,7 @@ static void android_server_InputManager_nativeUnregisterInputChannel(JNIEnv* env android_view_InputChannel_setDisposeCallback(env, inputChannelObj, NULL, NULL); - status_t status = gNativeInputManager->unregisterInputChannel(env, inputChannel); + status_t status = im->unregisterInputChannel(env, inputChannel); if (status && status != BAD_VALUE) { // ignore already unregistered channel String8 message; message.appendFormat("Failed to unregister input channel. status=%d", status); @@ -1123,21 +1090,17 @@ static void android_server_InputManager_nativeUnregisterInputChannel(JNIEnv* env } } -static void android_server_InputManager_nativeSetInputFilterEnabled(JNIEnv* env, jclass clazz, - jboolean enabled) { - if (checkInputManagerUnitialized(env)) { - return; - } +static void nativeSetInputFilterEnabled(JNIEnv* env, jclass clazz, + jint ptr, jboolean enabled) { + NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr); - gNativeInputManager->getInputManager()->getDispatcher()->setInputFilterEnabled(enabled); + im->getInputManager()->getDispatcher()->setInputFilterEnabled(enabled); } -static jint android_server_InputManager_nativeInjectInputEvent(JNIEnv* env, jclass clazz, - jobject inputEventObj, jint injectorPid, jint injectorUid, +static jint nativeInjectInputEvent(JNIEnv* env, jclass clazz, + jint ptr, jobject inputEventObj, jint injectorPid, jint injectorUid, jint syncMode, jint timeoutMillis, jint policyFlags) { - if (checkInputManagerUnitialized(env)) { - return INPUT_EVENT_INJECTION_FAILED; - } + NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr); if (env->IsInstanceOf(inputEventObj, gKeyEventClassInfo.clazz)) { KeyEvent keyEvent; @@ -1147,7 +1110,7 @@ static jint android_server_InputManager_nativeInjectInputEvent(JNIEnv* env, jcla return INPUT_EVENT_INJECTION_FAILED; } - return gNativeInputManager->getInputManager()->getDispatcher()->injectInputEvent( + return im->getInputManager()->getDispatcher()->injectInputEvent( & keyEvent, injectorPid, injectorUid, syncMode, timeoutMillis, uint32_t(policyFlags)); } else if (env->IsInstanceOf(inputEventObj, gMotionEventClassInfo.clazz)) { @@ -1157,7 +1120,7 @@ static jint android_server_InputManager_nativeInjectInputEvent(JNIEnv* env, jcla return INPUT_EVENT_INJECTION_FAILED; } - return gNativeInputManager->getInputManager()->getDispatcher()->injectInputEvent( + return im->getInputManager()->getDispatcher()->injectInputEvent( motionEvent, injectorPid, injectorUid, syncMode, timeoutMillis, uint32_t(policyFlags)); } else { @@ -1166,50 +1129,40 @@ static jint android_server_InputManager_nativeInjectInputEvent(JNIEnv* env, jcla } } -static void android_server_InputManager_nativeSetInputWindows(JNIEnv* env, jclass clazz, - jobjectArray windowHandleObjArray) { - if (checkInputManagerUnitialized(env)) { - return; - } +static void nativeSetInputWindows(JNIEnv* env, jclass clazz, + jint ptr, jobjectArray windowHandleObjArray) { + NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr); - gNativeInputManager->setInputWindows(env, windowHandleObjArray); + im->setInputWindows(env, windowHandleObjArray); } -static void android_server_InputManager_nativeSetFocusedApplication(JNIEnv* env, jclass clazz, - jobject applicationHandleObj) { - if (checkInputManagerUnitialized(env)) { - return; - } +static void nativeSetFocusedApplication(JNIEnv* env, jclass clazz, + jint ptr, jobject applicationHandleObj) { + NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr); - gNativeInputManager->setFocusedApplication(env, applicationHandleObj); + im->setFocusedApplication(env, applicationHandleObj); } -static void android_server_InputManager_nativeSetInputDispatchMode(JNIEnv* env, - jclass clazz, jboolean enabled, jboolean frozen) { - if (checkInputManagerUnitialized(env)) { - return; - } +static void nativeSetInputDispatchMode(JNIEnv* env, + jclass clazz, jint ptr, jboolean enabled, jboolean frozen) { + NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr); - gNativeInputManager->setInputDispatchMode(enabled, frozen); + im->setInputDispatchMode(enabled, frozen); } -static void android_server_InputManager_nativeSetSystemUiVisibility(JNIEnv* env, - jclass clazz, jint visibility) { - if (checkInputManagerUnitialized(env)) { - return; - } +static void nativeSetSystemUiVisibility(JNIEnv* env, + jclass clazz, jint ptr, jint visibility) { + NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr); - gNativeInputManager->setSystemUiVisibility(visibility); + im->setSystemUiVisibility(visibility); } -static jobject android_server_InputManager_nativeGetInputDevice(JNIEnv* env, - jclass clazz, jint deviceId) { - if (checkInputManagerUnitialized(env)) { - return NULL; - } +static jobject nativeGetInputDevice(JNIEnv* env, + jclass clazz, jint ptr, jint deviceId) { + NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr); InputDeviceInfo deviceInfo; - status_t status = gNativeInputManager->getInputManager()->getReader()->getInputDeviceInfo( + status_t status = im->getInputManager()->getReader()->getInputDeviceInfo( deviceId, & deviceInfo); if (status) { return NULL; @@ -1249,14 +1202,12 @@ static jobject android_server_InputManager_nativeGetInputDevice(JNIEnv* env, return deviceObj; } -static jintArray android_server_InputManager_nativeGetInputDeviceIds(JNIEnv* env, - jclass clazz) { - if (checkInputManagerUnitialized(env)) { - return NULL; - } +static jintArray nativeGetInputDeviceIds(JNIEnv* env, + jclass clazz, jint ptr) { + NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr); Vector<int> deviceIds; - gNativeInputManager->getInputManager()->getReader()->getInputDeviceIds(deviceIds); + im->getInputManager()->getReader()->getInputDeviceIds(deviceIds); jintArray deviceIdsObj = env->NewIntArray(deviceIds.size()); if (! deviceIdsObj) { @@ -1267,25 +1218,21 @@ static jintArray android_server_InputManager_nativeGetInputDeviceIds(JNIEnv* env return deviceIdsObj; } -static void android_server_InputManager_nativeGetInputConfiguration(JNIEnv* env, - jclass clazz, jobject configObj) { - if (checkInputManagerUnitialized(env)) { - return; - } +static void nativeGetInputConfiguration(JNIEnv* env, + jclass clazz, jint ptr, jobject configObj) { + NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr); InputConfiguration config; - gNativeInputManager->getInputManager()->getReader()->getInputConfiguration(& config); + im->getInputManager()->getReader()->getInputConfiguration(& config); env->SetIntField(configObj, gConfigurationClassInfo.touchscreen, config.touchScreen); env->SetIntField(configObj, gConfigurationClassInfo.keyboard, config.keyboard); env->SetIntField(configObj, gConfigurationClassInfo.navigation, config.navigation); } -static jboolean android_server_InputManager_nativeTransferTouchFocus(JNIEnv* env, - jclass clazz, jobject fromChannelObj, jobject toChannelObj) { - if (checkInputManagerUnitialized(env)) { - return false; - } +static jboolean nativeTransferTouchFocus(JNIEnv* env, + jclass clazz, jint ptr, jobject fromChannelObj, jobject toChannelObj) { + NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr); sp<InputChannel> fromChannel = android_view_InputChannel_getInputChannel(env, fromChannelObj); @@ -1296,101 +1243,93 @@ static jboolean android_server_InputManager_nativeTransferTouchFocus(JNIEnv* env return false; } - return gNativeInputManager->getInputManager()->getDispatcher()-> + return im->getInputManager()->getDispatcher()-> transferTouchFocus(fromChannel, toChannel); } -static void android_server_InputManager_nativeSetPointerSpeed(JNIEnv* env, - jclass clazz, jint speed) { - if (checkInputManagerUnitialized(env)) { - return; - } +static void nativeSetPointerSpeed(JNIEnv* env, + jclass clazz, jint ptr, jint speed) { + NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr); - gNativeInputManager->setPointerSpeed(speed); + im->setPointerSpeed(speed); } -static void android_server_InputManager_nativeSetShowTouches(JNIEnv* env, - jclass clazz, jboolean enabled) { - if (checkInputManagerUnitialized(env)) { - return; - } +static void nativeSetShowTouches(JNIEnv* env, + jclass clazz, jint ptr, jboolean enabled) { + NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr); - gNativeInputManager->setShowTouches(enabled); + im->setShowTouches(enabled); } -static jstring android_server_InputManager_nativeDump(JNIEnv* env, jclass clazz) { - if (checkInputManagerUnitialized(env)) { - return NULL; - } +static jstring nativeDump(JNIEnv* env, jclass clazz, jint ptr) { + NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr); String8 dump; - gNativeInputManager->dump(dump); + im->dump(dump); return env->NewStringUTF(dump.string()); } -static void android_server_InputManager_nativeMonitor(JNIEnv* env, jclass clazz) { - if (checkInputManagerUnitialized(env)) { - return; - } +static void nativeMonitor(JNIEnv* env, jclass clazz, jint ptr) { + NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr); - gNativeInputManager->getInputManager()->getReader()->monitor(); - gNativeInputManager->getInputManager()->getDispatcher()->monitor(); + im->getInputManager()->getReader()->monitor(); + im->getInputManager()->getDispatcher()->monitor(); } // ---------------------------------------------------------------------------- static JNINativeMethod gInputManagerMethods[] = { /* name, signature, funcPtr */ - { "nativeInit", "(Landroid/content/Context;" - "Lcom/android/server/wm/InputManager$Callbacks;Landroid/os/MessageQueue;)V", - (void*) android_server_InputManager_nativeInit }, - { "nativeStart", "()V", - (void*) android_server_InputManager_nativeStart }, - { "nativeSetDisplaySize", "(IIIII)V", - (void*) android_server_InputManager_nativeSetDisplaySize }, - { "nativeSetDisplayOrientation", "(II)V", - (void*) android_server_InputManager_nativeSetDisplayOrientation }, - { "nativeGetScanCodeState", "(III)I", - (void*) android_server_InputManager_nativeGetScanCodeState }, - { "nativeGetKeyCodeState", "(III)I", - (void*) android_server_InputManager_nativeGetKeyCodeState }, - { "nativeGetSwitchState", "(III)I", - (void*) android_server_InputManager_nativeGetSwitchState }, - { "nativeHasKeys", "(II[I[Z)Z", - (void*) android_server_InputManager_nativeHasKeys }, + { "nativeInit", + "(Lcom/android/server/input/InputManagerService;Landroid/content/Context;Landroid/os/MessageQueue;)I", + (void*) nativeInit }, + { "nativeStart", "(I)V", + (void*) nativeStart }, + { "nativeSetDisplaySize", "(IIIIII)V", + (void*) nativeSetDisplaySize }, + { "nativeSetDisplayOrientation", "(III)V", + (void*) nativeSetDisplayOrientation }, + { "nativeGetScanCodeState", "(IIII)I", + (void*) nativeGetScanCodeState }, + { "nativeGetKeyCodeState", "(IIII)I", + (void*) nativeGetKeyCodeState }, + { "nativeGetSwitchState", "(IIII)I", + (void*) nativeGetSwitchState }, + { "nativeHasKeys", "(III[I[Z)Z", + (void*) nativeHasKeys }, { "nativeRegisterInputChannel", - "(Landroid/view/InputChannel;Lcom/android/server/wm/InputWindowHandle;Z)V", - (void*) android_server_InputManager_nativeRegisterInputChannel }, - { "nativeUnregisterInputChannel", "(Landroid/view/InputChannel;)V", - (void*) android_server_InputManager_nativeUnregisterInputChannel }, - { "nativeSetInputFilterEnabled", "(Z)V", - (void*) android_server_InputManager_nativeSetInputFilterEnabled }, - { "nativeInjectInputEvent", "(Landroid/view/InputEvent;IIIII)I", - (void*) android_server_InputManager_nativeInjectInputEvent }, - { "nativeSetInputWindows", "([Lcom/android/server/wm/InputWindowHandle;)V", - (void*) android_server_InputManager_nativeSetInputWindows }, - { "nativeSetFocusedApplication", "(Lcom/android/server/wm/InputApplicationHandle;)V", - (void*) android_server_InputManager_nativeSetFocusedApplication }, - { "nativeSetInputDispatchMode", "(ZZ)V", - (void*) android_server_InputManager_nativeSetInputDispatchMode }, - { "nativeSetSystemUiVisibility", "(I)V", - (void*) android_server_InputManager_nativeSetSystemUiVisibility }, - { "nativeGetInputDevice", "(I)Landroid/view/InputDevice;", - (void*) android_server_InputManager_nativeGetInputDevice }, - { "nativeGetInputDeviceIds", "()[I", - (void*) android_server_InputManager_nativeGetInputDeviceIds }, - { "nativeGetInputConfiguration", "(Landroid/content/res/Configuration;)V", - (void*) android_server_InputManager_nativeGetInputConfiguration }, - { "nativeTransferTouchFocus", "(Landroid/view/InputChannel;Landroid/view/InputChannel;)Z", - (void*) android_server_InputManager_nativeTransferTouchFocus }, - { "nativeSetPointerSpeed", "(I)V", - (void*) android_server_InputManager_nativeSetPointerSpeed }, - { "nativeSetShowTouches", "(Z)V", - (void*) android_server_InputManager_nativeSetShowTouches }, - { "nativeDump", "()Ljava/lang/String;", - (void*) android_server_InputManager_nativeDump }, - { "nativeMonitor", "()V", - (void*) android_server_InputManager_nativeMonitor }, + "(ILandroid/view/InputChannel;Lcom/android/server/input/InputWindowHandle;Z)V", + (void*) nativeRegisterInputChannel }, + { "nativeUnregisterInputChannel", "(ILandroid/view/InputChannel;)V", + (void*) nativeUnregisterInputChannel }, + { "nativeSetInputFilterEnabled", "(IZ)V", + (void*) nativeSetInputFilterEnabled }, + { "nativeInjectInputEvent", "(ILandroid/view/InputEvent;IIIII)I", + (void*) nativeInjectInputEvent }, + { "nativeSetInputWindows", "(I[Lcom/android/server/input/InputWindowHandle;)V", + (void*) nativeSetInputWindows }, + { "nativeSetFocusedApplication", "(ILcom/android/server/input/InputApplicationHandle;)V", + (void*) nativeSetFocusedApplication }, + { "nativeSetInputDispatchMode", "(IZZ)V", + (void*) nativeSetInputDispatchMode }, + { "nativeSetSystemUiVisibility", "(II)V", + (void*) nativeSetSystemUiVisibility }, + { "nativeGetInputDevice", "(II)Landroid/view/InputDevice;", + (void*) nativeGetInputDevice }, + { "nativeGetInputDeviceIds", "(I)[I", + (void*) nativeGetInputDeviceIds }, + { "nativeGetInputConfiguration", "(ILandroid/content/res/Configuration;)V", + (void*) nativeGetInputConfiguration }, + { "nativeTransferTouchFocus", "(ILandroid/view/InputChannel;Landroid/view/InputChannel;)Z", + (void*) nativeTransferTouchFocus }, + { "nativeSetPointerSpeed", "(II)V", + (void*) nativeSetPointerSpeed }, + { "nativeSetShowTouches", "(IZ)V", + (void*) nativeSetShowTouches }, + { "nativeDump", "(I)Ljava/lang/String;", + (void*) nativeDump }, + { "nativeMonitor", "(I)V", + (void*) nativeMonitor }, }; #define FIND_CLASS(var, className) \ @@ -1406,77 +1345,77 @@ static JNINativeMethod gInputManagerMethods[] = { LOG_FATAL_IF(! var, "Unable to find field " fieldName); int register_android_server_InputManager(JNIEnv* env) { - int res = jniRegisterNativeMethods(env, "com/android/server/wm/InputManager", + int res = jniRegisterNativeMethods(env, "com/android/server/input/InputManagerService", gInputManagerMethods, NELEM(gInputManagerMethods)); LOG_FATAL_IF(res < 0, "Unable to register native methods."); // Callbacks jclass clazz; - FIND_CLASS(clazz, "com/android/server/wm/InputManager$Callbacks"); + FIND_CLASS(clazz, "com/android/server/input/InputManagerService"); - GET_METHOD_ID(gCallbacksClassInfo.notifyConfigurationChanged, clazz, + GET_METHOD_ID(gServiceClassInfo.notifyConfigurationChanged, clazz, "notifyConfigurationChanged", "(J)V"); - GET_METHOD_ID(gCallbacksClassInfo.notifyLidSwitchChanged, clazz, + GET_METHOD_ID(gServiceClassInfo.notifyLidSwitchChanged, clazz, "notifyLidSwitchChanged", "(JZ)V"); - GET_METHOD_ID(gCallbacksClassInfo.notifyInputChannelBroken, clazz, - "notifyInputChannelBroken", "(Lcom/android/server/wm/InputWindowHandle;)V"); + GET_METHOD_ID(gServiceClassInfo.notifyInputChannelBroken, clazz, + "notifyInputChannelBroken", "(Lcom/android/server/input/InputWindowHandle;)V"); - GET_METHOD_ID(gCallbacksClassInfo.notifyANR, clazz, + GET_METHOD_ID(gServiceClassInfo.notifyANR, clazz, "notifyANR", - "(Lcom/android/server/wm/InputApplicationHandle;Lcom/android/server/wm/InputWindowHandle;)J"); + "(Lcom/android/server/input/InputApplicationHandle;Lcom/android/server/input/InputWindowHandle;)J"); - GET_METHOD_ID(gCallbacksClassInfo.filterInputEvent, clazz, + GET_METHOD_ID(gServiceClassInfo.filterInputEvent, clazz, "filterInputEvent", "(Landroid/view/InputEvent;I)Z"); - GET_METHOD_ID(gCallbacksClassInfo.interceptKeyBeforeQueueing, clazz, + GET_METHOD_ID(gServiceClassInfo.interceptKeyBeforeQueueing, clazz, "interceptKeyBeforeQueueing", "(Landroid/view/KeyEvent;IZ)I"); - GET_METHOD_ID(gCallbacksClassInfo.interceptMotionBeforeQueueingWhenScreenOff, + GET_METHOD_ID(gServiceClassInfo.interceptMotionBeforeQueueingWhenScreenOff, clazz, "interceptMotionBeforeQueueingWhenScreenOff", "(I)I"); - GET_METHOD_ID(gCallbacksClassInfo.interceptKeyBeforeDispatching, clazz, + GET_METHOD_ID(gServiceClassInfo.interceptKeyBeforeDispatching, clazz, "interceptKeyBeforeDispatching", - "(Lcom/android/server/wm/InputWindowHandle;Landroid/view/KeyEvent;I)J"); + "(Lcom/android/server/input/InputWindowHandle;Landroid/view/KeyEvent;I)J"); - GET_METHOD_ID(gCallbacksClassInfo.dispatchUnhandledKey, clazz, + GET_METHOD_ID(gServiceClassInfo.dispatchUnhandledKey, clazz, "dispatchUnhandledKey", - "(Lcom/android/server/wm/InputWindowHandle;Landroid/view/KeyEvent;I)Landroid/view/KeyEvent;"); + "(Lcom/android/server/input/InputWindowHandle;Landroid/view/KeyEvent;I)Landroid/view/KeyEvent;"); - GET_METHOD_ID(gCallbacksClassInfo.checkInjectEventsPermission, clazz, + GET_METHOD_ID(gServiceClassInfo.checkInjectEventsPermission, clazz, "checkInjectEventsPermission", "(II)Z"); - GET_METHOD_ID(gCallbacksClassInfo.getVirtualKeyQuietTimeMillis, clazz, + GET_METHOD_ID(gServiceClassInfo.getVirtualKeyQuietTimeMillis, clazz, "getVirtualKeyQuietTimeMillis", "()I"); - GET_METHOD_ID(gCallbacksClassInfo.getExcludedDeviceNames, clazz, + GET_METHOD_ID(gServiceClassInfo.getExcludedDeviceNames, clazz, "getExcludedDeviceNames", "()[Ljava/lang/String;"); - GET_METHOD_ID(gCallbacksClassInfo.getKeyRepeatTimeout, clazz, + GET_METHOD_ID(gServiceClassInfo.getKeyRepeatTimeout, clazz, "getKeyRepeatTimeout", "()I"); - GET_METHOD_ID(gCallbacksClassInfo.getKeyRepeatDelay, clazz, + GET_METHOD_ID(gServiceClassInfo.getKeyRepeatDelay, clazz, "getKeyRepeatDelay", "()I"); - GET_METHOD_ID(gCallbacksClassInfo.getHoverTapTimeout, clazz, + GET_METHOD_ID(gServiceClassInfo.getHoverTapTimeout, clazz, "getHoverTapTimeout", "()I"); - GET_METHOD_ID(gCallbacksClassInfo.getHoverTapSlop, clazz, + GET_METHOD_ID(gServiceClassInfo.getHoverTapSlop, clazz, "getHoverTapSlop", "()I"); - GET_METHOD_ID(gCallbacksClassInfo.getDoubleTapTimeout, clazz, + GET_METHOD_ID(gServiceClassInfo.getDoubleTapTimeout, clazz, "getDoubleTapTimeout", "()I"); - GET_METHOD_ID(gCallbacksClassInfo.getLongPressTimeout, clazz, + GET_METHOD_ID(gServiceClassInfo.getLongPressTimeout, clazz, "getLongPressTimeout", "()I"); - GET_METHOD_ID(gCallbacksClassInfo.getPointerLayer, clazz, + GET_METHOD_ID(gServiceClassInfo.getPointerLayer, clazz, "getPointerLayer", "()I"); - GET_METHOD_ID(gCallbacksClassInfo.getPointerIcon, clazz, + GET_METHOD_ID(gServiceClassInfo.getPointerIcon, clazz, "getPointerIcon", "()Landroid/view/PointerIcon;"); // KeyEvent @@ -1484,7 +1423,6 @@ int register_android_server_InputManager(JNIEnv* env) { FIND_CLASS(gKeyEventClassInfo.clazz, "android/view/KeyEvent"); gKeyEventClassInfo.clazz = jclass(env->NewGlobalRef(gKeyEventClassInfo.clazz)); - // MotionEvent FIND_CLASS(gMotionEventClassInfo.clazz, "android/view/MotionEvent"); diff --git a/services/jni/com_android_server_InputWindowHandle.cpp b/services/jni/com_android_server_input_InputWindowHandle.cpp index 0607eee..01fb781 100644 --- a/services/jni/com_android_server_InputWindowHandle.cpp +++ b/services/jni/com_android_server_input_InputWindowHandle.cpp @@ -24,8 +24,8 @@ #include <android_view_InputChannel.h> #include <android/graphics/Region.h> -#include "com_android_server_InputWindowHandle.h" -#include "com_android_server_InputApplicationHandle.h" +#include "com_android_server_input_InputWindowHandle.h" +#include "com_android_server_input_InputApplicationHandle.h" namespace android { @@ -218,19 +218,19 @@ static JNINativeMethod gInputWindowHandleMethods[] = { LOG_FATAL_IF(! var, "Unable to find field " fieldName); int register_android_server_InputWindowHandle(JNIEnv* env) { - int res = jniRegisterNativeMethods(env, "com/android/server/wm/InputWindowHandle", + int res = jniRegisterNativeMethods(env, "com/android/server/input/InputWindowHandle", gInputWindowHandleMethods, NELEM(gInputWindowHandleMethods)); LOG_FATAL_IF(res < 0, "Unable to register native methods."); jclass clazz; - FIND_CLASS(clazz, "com/android/server/wm/InputWindowHandle"); + FIND_CLASS(clazz, "com/android/server/input/InputWindowHandle"); GET_FIELD_ID(gInputWindowHandleClassInfo.ptr, clazz, "ptr", "I"); GET_FIELD_ID(gInputWindowHandleClassInfo.inputApplicationHandle, clazz, - "inputApplicationHandle", "Lcom/android/server/wm/InputApplicationHandle;"); + "inputApplicationHandle", "Lcom/android/server/input/InputApplicationHandle;"); GET_FIELD_ID(gInputWindowHandleClassInfo.inputChannel, clazz, "inputChannel", "Landroid/view/InputChannel;"); diff --git a/services/jni/com_android_server_InputWindowHandle.h b/services/jni/com_android_server_input_InputWindowHandle.h index 2cfa17d3..2cfa17d3 100644 --- a/services/jni/com_android_server_InputWindowHandle.h +++ b/services/jni/com_android_server_input_InputWindowHandle.h diff --git a/services/tests/servicestests/AndroidManifest.xml b/services/tests/servicestests/AndroidManifest.xml index 60be35a..cc3c328 100644 --- a/services/tests/servicestests/AndroidManifest.xml +++ b/services/tests/servicestests/AndroidManifest.xml @@ -32,6 +32,7 @@ <uses-permission android:name="android.permission.READ_NETWORK_USAGE_HISTORY" /> <uses-permission android:name="android.permission.MODIFY_NETWORK_ACCOUNTING" /> <uses-permission android:name="android.permission.CONNECTIVITY_INTERNAL" /> + <uses-permission android:name="android.permission.ACCESS_WIFI_STATE" /> <application> <uses-library android:name="android.test.runner" /> diff --git a/services/tests/servicestests/src/com/android/server/NetworkPolicyManagerServiceTest.java b/services/tests/servicestests/src/com/android/server/NetworkPolicyManagerServiceTest.java index 88ee867..1773e33 100644 --- a/services/tests/servicestests/src/com/android/server/NetworkPolicyManagerServiceTest.java +++ b/services/tests/servicestests/src/com/android/server/NetworkPolicyManagerServiceTest.java @@ -70,6 +70,7 @@ import android.os.Binder; import android.os.INetworkManagementService; import android.os.IPowerManager; import android.os.MessageQueue.IdleHandler; +import android.os.SystemClock; import android.os.UserId; import android.test.AndroidTestCase; import android.test.mock.MockPackageManager; diff --git a/services/tests/servicestests/src/com/android/server/NetworkStatsServiceTest.java b/services/tests/servicestests/src/com/android/server/NetworkStatsServiceTest.java index daf2018..103d8e1 100644 --- a/services/tests/servicestests/src/com/android/server/NetworkStatsServiceTest.java +++ b/services/tests/servicestests/src/com/android/server/NetworkStatsServiceTest.java @@ -84,7 +84,7 @@ import libcore.io.IoUtils; */ @LargeTest public class NetworkStatsServiceTest extends AndroidTestCase { - private static final String TAG = "NetworkStatsServiceTest"; + private static final String TAG = "NetworkStatsServiceTest"; private static final String TEST_IFACE = "test0"; private static final String TEST_IFACE2 = "test1"; diff --git a/services/tests/servicestests/src/com/android/server/net/NetworkStatsCollectionTest.java b/services/tests/servicestests/src/com/android/server/net/NetworkStatsCollectionTest.java index 7f05f56..e40f166 100644 --- a/services/tests/servicestests/src/com/android/server/net/NetworkStatsCollectionTest.java +++ b/services/tests/servicestests/src/com/android/server/net/NetworkStatsCollectionTest.java @@ -20,8 +20,6 @@ import static android.net.NetworkTemplate.buildTemplateMobileAll; import static android.text.format.DateUtils.MINUTE_IN_MILLIS; import android.content.res.Resources; -import android.net.ConnectivityManager; -import android.net.NetworkIdentity; import android.net.NetworkStats; import android.net.NetworkTemplate; import android.test.AndroidTestCase; @@ -145,12 +143,6 @@ public class NetworkStatsCollectionTest extends AndroidTestCase { } } - public static NetworkIdentitySet buildWifiIdent() { - final NetworkIdentitySet set = new NetworkIdentitySet(); - set.add(new NetworkIdentity(ConnectivityManager.TYPE_WIFI, 0, null, false)); - return set; - } - private static void assertSummaryTotal(NetworkStatsCollection collection, NetworkTemplate template, long rxBytes, long rxPackets, long txBytes, long txPackets) { final NetworkStats.Entry entry = collection.getSummary( |