diff options
76 files changed, 1856 insertions, 1367 deletions
diff --git a/api/current.txt b/api/current.txt index 14952772778e..ff88b100f113 100644 --- a/api/current.txt +++ b/api/current.txt @@ -377,6 +377,8 @@ package android { field public static final int colorActivatedHighlight = 16843664; // 0x1010390 field public static final int colorBackground = 16842801; // 0x1010031 field public static final int colorBackgroundCacheHint = 16843435; // 0x10102ab + field public static final int colorFilterColor = 16843767; // 0x10103f7 + field public static final int colorFilterMode = 16843768; // 0x10103f8 field public static final int colorFocusedHighlight = 16843663; // 0x101038f field public static final int colorForeground = 16842800; // 0x1010030 field public static final int colorForegroundInverse = 16843270; // 0x1010206 @@ -11555,7 +11557,10 @@ package android.hardware.usb { method public int getDeviceSubclass(); method public android.hardware.usb.UsbInterface getInterface(int); method public int getInterfaceCount(); + method public java.lang.String getManufacturerName(); method public int getProductId(); + method public java.lang.String getProductName(); + method public java.lang.String getSerialNumber(); method public int getVendorId(); method public void writeToParcel(android.os.Parcel, int); field public static final android.os.Parcelable.Creator CREATOR; diff --git a/cmds/am/src/com/android/commands/am/Am.java b/cmds/am/src/com/android/commands/am/Am.java index 7adf5ec69767..89e15d25dd62 100644 --- a/cmds/am/src/com/android/commands/am/Am.java +++ b/cmds/am/src/com/android/commands/am/Am.java @@ -109,7 +109,7 @@ public class Am extends BaseCommand { " am to-intent-uri [INTENT]\n" + " am switch-user <USER_ID>\n" + " am stop-user <USER_ID>\n" + - " am stack create <TASK_ID> <DISPLAY_ID>\n" + + " am stack start <DISPLAY_ID> <INTENT>\n" + " am stack movetask <TASK_ID> <STACK_ID> [true|false]\n" + " am stack resize <STACK_ID> <LEFT,TOP,RIGHT,BOTTOM>\n" + " am stack list\n" + @@ -207,7 +207,7 @@ public class Am extends BaseCommand { "am stop-user: stop execution of USER_ID, not allowing it to run any\n" + " code until a later explicit switch to it.\n" + "\n" + - "am stack create: create a new stack containing <TASK_ID> which must exist\n" + + "am stack start: start a new activity on <DISPLAY_ID> using <INTENT>.\n" + "\n" + "am stack movetask: move <TASK_ID> from its current stack to the top (true) or" + " bottom (false) of <STACK_ID>.\n" + @@ -1541,8 +1541,8 @@ public class Am extends BaseCommand { private void runStack() throws Exception { String op = nextArgRequired(); - if (op.equals("create")) { - runStackCreate(); + if (op.equals("start")) { + runStackStart(); } else if (op.equals("movetask")) { runStackMoveTask(); } else if (op.equals("resize")) { @@ -1557,19 +1557,16 @@ public class Am extends BaseCommand { } } - private void runStackCreate() throws Exception { - String taskIdStr = nextArgRequired(); - int taskId = Integer.valueOf(taskIdStr); + private void runStackStart() throws Exception { String displayIdStr = nextArgRequired(); int displayId = Integer.valueOf(displayIdStr); + Intent intent = makeIntent(UserHandle.USER_CURRENT); try { IBinder homeActivityToken = mAm.getHomeActivityToken(); IActivityContainer container = mAm.createActivityContainer(homeActivityToken, null); - final int stackId = container.getStackId(); - System.out.println("createStack returned new stackId=" + stackId + "\n"); container.attachToDisplay(displayId); - mAm.moveTaskToStack(taskId, stackId, true); + container.startActivity(intent); } catch (RemoteException e) { } } diff --git a/core/java/android/app/ActivityManagerNative.java b/core/java/android/app/ActivityManagerNative.java index 0f38095a0b34..3bc2ee60c10a 100644 --- a/core/java/android/app/ActivityManagerNative.java +++ b/core/java/android/app/ActivityManagerNative.java @@ -2031,6 +2031,15 @@ public abstract class ActivityManagerNative extends Binder implements IActivityM return true; } + case GET_ACTIVITY_CONTAINER_TRANSACTION: { + data.enforceInterface(IActivityManager.descriptor); + IBinder activityToken = data.readStrongBinder(); + IActivityContainer activityContainer = getEnclosingActivityContainer(activityToken); + reply.writeNoException(); + reply.writeStrongBinder(activityContainer.asBinder()); + return true; + } + case GET_HOME_ACTIVITY_TOKEN_TRANSACTION: { data.enforceInterface(IActivityManager.descriptor); IBinder homeActivityToken = getHomeActivityToken(); @@ -4668,6 +4677,21 @@ class ActivityManagerProxy implements IActivityManager return res; } + public IActivityContainer getEnclosingActivityContainer(IBinder activityToken) + throws RemoteException { + Parcel data = Parcel.obtain(); + Parcel reply = Parcel.obtain(); + data.writeInterfaceToken(IActivityManager.descriptor); + data.writeStrongBinder(activityToken); + mRemote.transact(GET_ACTIVITY_CONTAINER_TRANSACTION, data, reply, 0); + reply.readException(); + IActivityContainer res = + IActivityContainer.Stub.asInterface(reply.readStrongBinder()); + data.recycle(); + reply.recycle(); + return res; + } + public IBinder getHomeActivityToken() throws RemoteException { Parcel data = Parcel.obtain(); Parcel reply = Parcel.obtain(); diff --git a/core/java/android/app/ActivityThread.java b/core/java/android/app/ActivityThread.java index 3725cd44aa69..94ebff97d496 100644 --- a/core/java/android/app/ActivityThread.java +++ b/core/java/android/app/ActivityThread.java @@ -2229,15 +2229,26 @@ public final class ActivityThread { ContextImpl appContext = new ContextImpl(); appContext.init(r.packageInfo, r.token, this); appContext.setOuterContext(activity); + Context baseContext = appContext; + + final DisplayManagerGlobal dm = DisplayManagerGlobal.getInstance(); + try { + IActivityContainer container = + ActivityManagerNative.getDefault().getEnclosingActivityContainer(r.token); + final int displayId = container.getDisplayId(); + if (displayId > Display.DEFAULT_DISPLAY) { + Display display = dm.getRealDisplay(displayId, r.token); + baseContext = appContext.createDisplayContext(display); + } + } catch (RemoteException e) { + } // For debugging purposes, if the activity's package name contains the value of // the "debug.use-second-display" system property as a substring, then show // its content on a secondary display if there is one. - Context baseContext = appContext; String pkgName = SystemProperties.get("debug.second-display.pkg"); if (pkgName != null && !pkgName.isEmpty() && r.packageInfo.mPackageName.contains(pkgName)) { - DisplayManagerGlobal dm = DisplayManagerGlobal.getInstance(); for (int displayId : dm.getDisplayIds()) { if (displayId != Display.DEFAULT_DISPLAY) { Display display = dm.getRealDisplay(displayId, r.token); diff --git a/core/java/android/app/IActivityContainer.aidl b/core/java/android/app/IActivityContainer.aidl index 2883d25ddd7d..2d8d18f0c328 100644 --- a/core/java/android/app/IActivityContainer.aidl +++ b/core/java/android/app/IActivityContainer.aidl @@ -23,7 +23,7 @@ import android.os.IBinder; /** @hide */ interface IActivityContainer { void attachToDisplay(int displayId); - int getStackId(); + int getDisplayId(); void detachFromDisplay(); - void startActivity(in Intent intent); + int startActivity(in Intent intent); } diff --git a/core/java/android/app/IActivityManager.java b/core/java/android/app/IActivityManager.java index 4be194597b6f..3ed3f7bdf20e 100644 --- a/core/java/android/app/IActivityManager.java +++ b/core/java/android/app/IActivityManager.java @@ -410,6 +410,9 @@ public interface IActivityManager extends IInterface { public IActivityContainer createActivityContainer(IBinder parentActivityToken, IActivityContainerCallback callback) throws RemoteException; + public IActivityContainer getEnclosingActivityContainer(IBinder activityToken) + throws RemoteException; + public IBinder getHomeActivityToken() throws RemoteException; /* @@ -699,4 +702,5 @@ public interface IActivityManager extends IInterface { int GET_PERSISTED_URI_PERMISSIONS_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+181; int APP_NOT_RESPONDING_VIA_PROVIDER_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+182; int GET_HOME_ACTIVITY_TOKEN_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+183; + int GET_ACTIVITY_CONTAINER_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+184; } diff --git a/core/java/android/app/NativeActivity.java b/core/java/android/app/NativeActivity.java index 4ca37476db6a..2e05edb2e7d9 100644 --- a/core/java/android/app/NativeActivity.java +++ b/core/java/android/app/NativeActivity.java @@ -76,7 +76,7 @@ public class NativeActivity extends Activity implements SurfaceHolder.Callback2, private NativeContentView mNativeContentView; private InputMethodManager mIMM; - private int mNativeHandle; + private long mNativeHandle; private InputQueue mCurInputQueue; private SurfaceHolder mCurSurfaceHolder; @@ -91,27 +91,26 @@ public class NativeActivity extends Activity implements SurfaceHolder.Callback2, private boolean mDestroyed; - private native int loadNativeCode(String path, String funcname, MessageQueue queue, + private native long loadNativeCode(String path, String funcname, MessageQueue queue, String internalDataPath, String obbPath, String externalDataPath, int sdkVersion, AssetManager assetMgr, byte[] savedState); - private native void unloadNativeCode(int handle); - - private native void onStartNative(int handle); - private native void onResumeNative(int handle); - private native byte[] onSaveInstanceStateNative(int handle); - private native void onPauseNative(int handle); - private native void onStopNative(int handle); - private native void onConfigurationChangedNative(int handle); - private native void onLowMemoryNative(int handle); - private native void onWindowFocusChangedNative(int handle, boolean focused); - private native void onSurfaceCreatedNative(int handle, Surface surface); - private native void onSurfaceChangedNative(int handle, Surface surface, + private native void unloadNativeCode(long handle); + private native void onStartNative(long handle); + private native void onResumeNative(long handle); + private native byte[] onSaveInstanceStateNative(long handle); + private native void onPauseNative(long handle); + private native void onStopNative(long handle); + private native void onConfigurationChangedNative(long handle); + private native void onLowMemoryNative(long handle); + private native void onWindowFocusChangedNative(long handle, boolean focused); + private native void onSurfaceCreatedNative(long handle, Surface surface); + private native void onSurfaceChangedNative(long handle, Surface surface, int format, int width, int height); - private native void onSurfaceRedrawNeededNative(int handle, Surface surface); - private native void onSurfaceDestroyedNative(int handle); - private native void onInputQueueCreatedNative(int handle, int queuePtr); - private native void onInputQueueDestroyedNative(int handle, int queuePtr); - private native void onContentRectChangedNative(int handle, int x, int y, int w, int h); + private native void onSurfaceRedrawNeededNative(long handle, Surface surface); + private native void onSurfaceDestroyedNative(long handle); + private native void onInputQueueCreatedNative(long handle, long queuePtr); + private native void onInputQueueDestroyedNative(long handle, long queuePtr); + private native void onContentRectChangedNative(long handle, int x, int y, int w, int h); static class NativeContentView extends View { NativeActivity mActivity; diff --git a/core/java/android/app/backup/BackupDataInput.java b/core/java/android/app/backup/BackupDataInput.java index 43b920a9b180..03205fb05d52 100644 --- a/core/java/android/app/backup/BackupDataInput.java +++ b/core/java/android/app/backup/BackupDataInput.java @@ -59,7 +59,7 @@ import java.io.IOException; * }</pre> */ public class BackupDataInput { - int mBackupReader; + long mBackupReader; private EntityHeader mHeader = new EntityHeader(); private boolean mHeaderReady; @@ -185,10 +185,10 @@ public class BackupDataInput { } } - private native static int ctor(FileDescriptor fd); - private native static void dtor(int mBackupReader); + private native static long ctor(FileDescriptor fd); + private native static void dtor(long mBackupReader); - private native int readNextHeader_native(int mBackupReader, EntityHeader entity); - private native int readEntityData_native(int mBackupReader, byte[] data, int offset, int size); - private native int skipEntityData_native(int mBackupReader); + private native int readNextHeader_native(long mBackupReader, EntityHeader entity); + private native int readEntityData_native(long mBackupReader, byte[] data, int offset, int size); + private native int skipEntityData_native(long mBackupReader); } diff --git a/core/java/android/app/backup/BackupDataOutput.java b/core/java/android/app/backup/BackupDataOutput.java index 22668b6533ab..3a070b602c12 100644 --- a/core/java/android/app/backup/BackupDataOutput.java +++ b/core/java/android/app/backup/BackupDataOutput.java @@ -62,7 +62,7 @@ import java.io.IOException; * @see BackupAgent */ public class BackupDataOutput { - int mBackupWriter; + long mBackupWriter; /** @hide */ public BackupDataOutput(FileDescriptor fd) { @@ -121,11 +121,11 @@ public class BackupDataOutput { } } - private native static int ctor(FileDescriptor fd); - private native static void dtor(int mBackupWriter); + private native static long ctor(FileDescriptor fd); + private native static void dtor(long mBackupWriter); - private native static int writeEntityHeader_native(int mBackupWriter, String key, int dataSize); - private native static int writeEntityData_native(int mBackupWriter, byte[] data, int size); - private native static void setKeyPrefix_native(int mBackupWriter, String keyPrefix); + private native static int writeEntityHeader_native(long mBackupWriter, String key, int dataSize); + private native static int writeEntityData_native(long mBackupWriter, byte[] data, int size); + private native static void setKeyPrefix_native(long mBackupWriter, String keyPrefix); } diff --git a/core/java/android/app/backup/FileBackupHelperBase.java b/core/java/android/app/backup/FileBackupHelperBase.java index 887a2e69374c..4ed5197aa6b4 100644 --- a/core/java/android/app/backup/FileBackupHelperBase.java +++ b/core/java/android/app/backup/FileBackupHelperBase.java @@ -29,7 +29,7 @@ import java.io.FileDescriptor; class FileBackupHelperBase { private static final String TAG = "FileBackupHelperBase"; - int mPtr; + long mPtr; Context mContext; boolean mExceptionLogged; @@ -115,14 +115,13 @@ class FileBackupHelperBase { return false; } - private static native int ctor(); - private static native void dtor(int ptr); + private static native long ctor(); + private static native void dtor(long ptr); native private static int performBackup_native(FileDescriptor oldState, - int data, FileDescriptor newState, String[] files, String[] keys); - - private static native int writeFile_native(int ptr, String filename, int backupReader); - private static native int writeSnapshot_native(int ptr, FileDescriptor fd); + long data, FileDescriptor newState, String[] files, String[] keys); + private static native int writeFile_native(long ptr, String filename, long backupReader); + private static native int writeSnapshot_native(long ptr, FileDescriptor fd); } diff --git a/core/java/android/database/CursorWindow.java b/core/java/android/database/CursorWindow.java index f1f30175c588..197e3ff3eda7 100644 --- a/core/java/android/database/CursorWindow.java +++ b/core/java/android/database/CursorWindow.java @@ -27,6 +27,7 @@ import android.os.Parcelable; import android.os.Process; import android.util.Log; import android.util.SparseIntArray; +import android.util.LongSparseArray; /** * A buffer containing multiple cursor rows. @@ -52,40 +53,40 @@ public class CursorWindow extends SQLiteClosable implements Parcelable { * The native CursorWindow object pointer. (FOR INTERNAL USE ONLY) * @hide */ - public int mWindowPtr; + public long mWindowPtr; private int mStartPos; private final String mName; private final CloseGuard mCloseGuard = CloseGuard.get(); - private static native int nativeCreate(String name, int cursorWindowSize); - private static native int nativeCreateFromParcel(Parcel parcel); - private static native void nativeDispose(int windowPtr); - private static native void nativeWriteToParcel(int windowPtr, Parcel parcel); + private static native long nativeCreate(String name, int cursorWindowSize); + private static native long nativeCreateFromParcel(Parcel parcel); + private static native void nativeDispose(long windowPtr); + private static native void nativeWriteToParcel(long windowPtr, Parcel parcel); - private static native void nativeClear(int windowPtr); + private static native void nativeClear(long windowPtr); - private static native int nativeGetNumRows(int windowPtr); - private static native boolean nativeSetNumColumns(int windowPtr, int columnNum); - private static native boolean nativeAllocRow(int windowPtr); - private static native void nativeFreeLastRow(int windowPtr); + private static native int nativeGetNumRows(long windowPtr); + private static native boolean nativeSetNumColumns(long windowPtr, int columnNum); + private static native boolean nativeAllocRow(long windowPtr); + private static native void nativeFreeLastRow(long windowPtr); - private static native int nativeGetType(int windowPtr, int row, int column); - private static native byte[] nativeGetBlob(int windowPtr, int row, int column); - private static native String nativeGetString(int windowPtr, int row, int column); - private static native long nativeGetLong(int windowPtr, int row, int column); - private static native double nativeGetDouble(int windowPtr, int row, int column); - private static native void nativeCopyStringToBuffer(int windowPtr, int row, int column, + private static native int nativeGetType(long windowPtr, int row, int column); + private static native byte[] nativeGetBlob(long windowPtr, int row, int column); + private static native String nativeGetString(long windowPtr, int row, int column); + private static native long nativeGetLong(long windowPtr, int row, int column); + private static native double nativeGetDouble(long windowPtr, int row, int column); + private static native void nativeCopyStringToBuffer(long windowPtr, int row, int column, CharArrayBuffer buffer); - private static native boolean nativePutBlob(int windowPtr, byte[] value, int row, int column); - private static native boolean nativePutString(int windowPtr, String value, int row, int column); - private static native boolean nativePutLong(int windowPtr, long value, int row, int column); - private static native boolean nativePutDouble(int windowPtr, double value, int row, int column); - private static native boolean nativePutNull(int windowPtr, int row, int column); + private static native boolean nativePutBlob(long windowPtr, byte[] value, int row, int column); + private static native boolean nativePutString(long windowPtr, String value, int row, int column); + private static native boolean nativePutLong(long windowPtr, long value, int row, int column); + private static native boolean nativePutDouble(long windowPtr, double value, int row, int column); + private static native boolean nativePutNull(long windowPtr, int row, int column); - private static native String nativeGetName(int windowPtr); + private static native String nativeGetName(long windowPtr); /** * Creates a new empty cursor window and gives it a name. @@ -713,9 +714,9 @@ public class CursorWindow extends SQLiteClosable implements Parcelable { dispose(); } - private static final SparseIntArray sWindowToPidMap = new SparseIntArray(); + private static final LongSparseArray<Integer> sWindowToPidMap = new LongSparseArray<Integer>(); - private void recordNewWindow(int pid, int window) { + private void recordNewWindow(int pid, long window) { synchronized (sWindowToPidMap) { sWindowToPidMap.put(window, pid); if (Log.isLoggable(STATS_TAG, Log.VERBOSE)) { @@ -724,7 +725,7 @@ public class CursorWindow extends SQLiteClosable implements Parcelable { } } - private void recordClosingOfWindow(int window) { + private void recordClosingOfWindow(long window) { synchronized (sWindowToPidMap) { if (sWindowToPidMap.size() == 0) { // this means we are not in the ContentProvider. @@ -771,6 +772,6 @@ public class CursorWindow extends SQLiteClosable implements Parcelable { @Override public String toString() { - return getName() + " {" + Integer.toHexString(mWindowPtr) + "}"; + return getName() + " {" + Long.toHexString(mWindowPtr) + "}"; } } diff --git a/core/java/android/database/sqlite/SQLiteConnection.java b/core/java/android/database/sqlite/SQLiteConnection.java index 725a1ff6c9c0..24a7d3327664 100644 --- a/core/java/android/database/sqlite/SQLiteConnection.java +++ b/core/java/android/database/sqlite/SQLiteConnection.java @@ -107,7 +107,7 @@ public final class SQLiteConnection implements CancellationSignal.OnCancelListen private final OperationLog mRecentOperations = new OperationLog(); // The native SQLiteConnection pointer. (FOR INTERNAL USE ONLY) - private int mConnectionPtr; + private long mConnectionPtr; private boolean mOnlyAllowReadOnlyOperations; @@ -117,45 +117,45 @@ public final class SQLiteConnection implements CancellationSignal.OnCancelListen // we can ensure that we detach the signal at the right time. private int mCancellationSignalAttachCount; - private static native int nativeOpen(String path, int openFlags, String label, + private static native long nativeOpen(String path, int openFlags, String label, boolean enableTrace, boolean enableProfile); - private static native void nativeClose(int connectionPtr); - private static native void nativeRegisterCustomFunction(int connectionPtr, + private static native void nativeClose(long connectionPtr); + private static native void nativeRegisterCustomFunction(long connectionPtr, SQLiteCustomFunction function); - private static native void nativeRegisterLocalizedCollators(int connectionPtr, String locale); - private static native int nativePrepareStatement(int connectionPtr, String sql); - private static native void nativeFinalizeStatement(int connectionPtr, int statementPtr); - private static native int nativeGetParameterCount(int connectionPtr, int statementPtr); - private static native boolean nativeIsReadOnly(int connectionPtr, int statementPtr); - private static native int nativeGetColumnCount(int connectionPtr, int statementPtr); - private static native String nativeGetColumnName(int connectionPtr, int statementPtr, + private static native void nativeRegisterLocalizedCollators(long connectionPtr, String locale); + private static native long nativePrepareStatement(long connectionPtr, String sql); + private static native void nativeFinalizeStatement(long connectionPtr, long statementPtr); + private static native int nativeGetParameterCount(long connectionPtr, long statementPtr); + private static native boolean nativeIsReadOnly(long connectionPtr, long statementPtr); + private static native int nativeGetColumnCount(long connectionPtr, long statementPtr); + private static native String nativeGetColumnName(long connectionPtr, long statementPtr, int index); - private static native void nativeBindNull(int connectionPtr, int statementPtr, + private static native void nativeBindNull(long connectionPtr, long statementPtr, int index); - private static native void nativeBindLong(int connectionPtr, int statementPtr, + private static native void nativeBindLong(long connectionPtr, long statementPtr, int index, long value); - private static native void nativeBindDouble(int connectionPtr, int statementPtr, + private static native void nativeBindDouble(long connectionPtr, long statementPtr, int index, double value); - private static native void nativeBindString(int connectionPtr, int statementPtr, + private static native void nativeBindString(long connectionPtr, long statementPtr, int index, String value); - private static native void nativeBindBlob(int connectionPtr, int statementPtr, + private static native void nativeBindBlob(long connectionPtr, long statementPtr, int index, byte[] value); private static native void nativeResetStatementAndClearBindings( - int connectionPtr, int statementPtr); - private static native void nativeExecute(int connectionPtr, int statementPtr); - private static native long nativeExecuteForLong(int connectionPtr, int statementPtr); - private static native String nativeExecuteForString(int connectionPtr, int statementPtr); + long connectionPtr, long statementPtr); + private static native void nativeExecute(long connectionPtr, long statementPtr); + private static native long nativeExecuteForLong(long connectionPtr, long statementPtr); + private static native String nativeExecuteForString(long connectionPtr, long statementPtr); private static native int nativeExecuteForBlobFileDescriptor( - int connectionPtr, int statementPtr); - private static native int nativeExecuteForChangedRowCount(int connectionPtr, int statementPtr); + long connectionPtr, long statementPtr); + private static native int nativeExecuteForChangedRowCount(long connectionPtr, long statementPtr); private static native long nativeExecuteForLastInsertedRowId( - int connectionPtr, int statementPtr); + long connectionPtr, long statementPtr); private static native long nativeExecuteForCursorWindow( - int connectionPtr, int statementPtr, int windowPtr, + long connectionPtr, long statementPtr, long windowPtr, int startPos, int requiredPos, boolean countAllRows); - private static native int nativeGetDbLookaside(int connectionPtr); - private static native void nativeCancel(int connectionPtr); - private static native void nativeResetCancel(int connectionPtr, boolean cancelable); + private static native int nativeGetDbLookaside(long connectionPtr); + private static native void nativeCancel(long connectionPtr); + private static native void nativeResetCancel(long connectionPtr, boolean cancelable); private SQLiteConnection(SQLiteConnectionPool pool, SQLiteDatabaseConfiguration configuration, @@ -886,7 +886,7 @@ public final class SQLiteConnection implements CancellationSignal.OnCancelListen skipCache = true; } - final int statementPtr = nativePrepareStatement(mConnectionPtr, sql); + final long statementPtr = nativePrepareStatement(mConnectionPtr, sql); try { final int numParameters = nativeGetParameterCount(mConnectionPtr, statementPtr); final int type = DatabaseUtils.getSqlStatementType(sql); @@ -987,7 +987,7 @@ public final class SQLiteConnection implements CancellationSignal.OnCancelListen return; } - final int statementPtr = statement.mStatementPtr; + final long statementPtr = statement.mStatementPtr; for (int i = 0; i < count; i++) { final Object arg = bindArgs[i]; switch (DatabaseUtils.getTypeOfObject(arg)) { @@ -1072,7 +1072,7 @@ public final class SQLiteConnection implements CancellationSignal.OnCancelListen void dumpUnsafe(Printer printer, boolean verbose) { printer.println("Connection #" + mConnectionId + ":"); if (verbose) { - printer.println(" connectionPtr: 0x" + Integer.toHexString(mConnectionPtr)); + printer.println(" connectionPtr: 0x" + Long.toHexString(mConnectionPtr)); } printer.println(" isPrimaryConnection: " + mIsPrimaryConnection); printer.println(" onlyAllowReadOnlyOperations: " + mOnlyAllowReadOnlyOperations); @@ -1178,7 +1178,7 @@ public final class SQLiteConnection implements CancellationSignal.OnCancelListen return "SQLiteConnection: " + mConfiguration.path + " (" + mConnectionId + ")"; } - private PreparedStatement obtainPreparedStatement(String sql, int statementPtr, + private PreparedStatement obtainPreparedStatement(String sql, long statementPtr, int numParameters, int type, boolean readOnly) { PreparedStatement statement = mPreparedStatementPool; if (statement != null) { @@ -1225,7 +1225,7 @@ public final class SQLiteConnection implements CancellationSignal.OnCancelListen // The native sqlite3_stmt object pointer. // Lifetime is managed explicitly by the connection. - public int mStatementPtr; + public long mStatementPtr; // The number of parameters that the prepared statement has. public int mNumParameters; @@ -1271,7 +1271,7 @@ public final class SQLiteConnection implements CancellationSignal.OnCancelListen if (statement.mInCache) { // might be false due to a race with entryRemoved String sql = entry.getKey(); printer.println(" " + i + ": statementPtr=0x" - + Integer.toHexString(statement.mStatementPtr) + + Long.toHexString(statement.mStatementPtr) + ", numParameters=" + statement.mNumParameters + ", type=" + statement.mType + ", readOnly=" + statement.mReadOnly diff --git a/core/java/android/hardware/Camera.java b/core/java/android/hardware/Camera.java index 9913e33916ab..6e2a099c1000 100644 --- a/core/java/android/hardware/Camera.java +++ b/core/java/android/hardware/Camera.java @@ -150,7 +150,7 @@ public class Camera { private static final int CAMERA_MSG_PREVIEW_METADATA = 0x400; private static final int CAMERA_MSG_FOCUS_MOVE = 0x800; - private int mNativeContext; // accessed by native methods + private long mNativeContext; // accessed by native methods private EventHandler mEventHandler; private ShutterCallback mShutterCallback; private PictureCallback mRawImageCallback; diff --git a/core/java/android/hardware/SystemSensorManager.java b/core/java/android/hardware/SystemSensorManager.java index 50fdb4170c60..8684a042fdc9 100644 --- a/core/java/android/hardware/SystemSensorManager.java +++ b/core/java/android/hardware/SystemSensorManager.java @@ -222,14 +222,14 @@ public class SystemSensorManager extends SensorManager { * the queues and the listeners. */ private static abstract class BaseEventQueue { - private native int nativeInitBaseEventQueue(BaseEventQueue eventQ, MessageQueue msgQ, + private native long nativeInitBaseEventQueue(BaseEventQueue eventQ, MessageQueue msgQ, float[] scratch); - private static native int nativeEnableSensor(int eventQ, int handle, int rateUs, + private static native int nativeEnableSensor(long eventQ, int handle, int rateUs, int maxBatchReportLatencyUs, int reservedFlags); - private static native int nativeDisableSensor(int eventQ, int handle); - private static native void nativeDestroySensorEventQueue(int eventQ); - private static native int nativeFlushSensor(int eventQ); - private int nSensorEventQueue; + private static native int nativeDisableSensor(long eventQ, int handle); + private static native void nativeDestroySensorEventQueue(long eventQ); + private static native int nativeFlushSensor(long eventQ); + private long nSensorEventQueue; private final SparseBooleanArray mActiveSensors = new SparseBooleanArray(); protected final SparseIntArray mSensorAccuracies = new SparseIntArray(); protected final SparseBooleanArray mFirstEvent = new SparseBooleanArray(); diff --git a/core/java/android/hardware/usb/UsbDevice.java b/core/java/android/hardware/usb/UsbDevice.java index ae6118c43a0b..b0ba9c193ecf 100644 --- a/core/java/android/hardware/usb/UsbDevice.java +++ b/core/java/android/hardware/usb/UsbDevice.java @@ -42,6 +42,9 @@ public class UsbDevice implements Parcelable { private static final String TAG = "UsbDevice"; private final String mName; + private final String mManufacturerName; + private final String mProductName; + private final String mSerialNumber; private final int mVendorId; private final int mProductId; private final int mClass; @@ -54,13 +57,18 @@ public class UsbDevice implements Parcelable { * @hide */ public UsbDevice(String name, int vendorId, int productId, - int Class, int subClass, int protocol, Parcelable[] interfaces) { + int Class, int subClass, int protocol, + String manufacturerName, String productName, String serialNumber, + Parcelable[] interfaces) { mName = name; mVendorId = vendorId; mProductId = productId; mClass = Class; mSubclass = subClass; mProtocol = protocol; + mManufacturerName = manufacturerName; + mProductName = productName; + mSerialNumber = serialNumber; mInterfaces = interfaces; } @@ -76,6 +84,33 @@ public class UsbDevice implements Parcelable { } /** + * Returns the manufacturer name of the device. + * + * @return the manufacturer name + */ + public String getManufacturerName() { + return mManufacturerName; + } + + /** + * Returns the product name of the device. + * + * @return the product name + */ + public String getProductName() { + return mProductName; + } + + /** + * Returns the serial number of the device. + * + * @return the serial number name + */ + public String getSerialNumber() { + return mSerialNumber; + } + + /** * Returns a unique integer ID for the device. * This is a convenience for clients that want to use an integer to represent * the device, rather than the device name. @@ -172,7 +207,8 @@ public class UsbDevice implements Parcelable { return "UsbDevice[mName=" + mName + ",mVendorId=" + mVendorId + ",mProductId=" + mProductId + ",mClass=" + mClass + ",mSubclass=" + mSubclass + ",mProtocol=" + mProtocol + - ",mInterfaces=" + mInterfaces + "]"; + ",mManufacturerName=" + mManufacturerName + ",mProductName=" + mProductName + + ",mSerialNumber=" + mSerialNumber + ",mInterfaces=" + mInterfaces + "]"; } public static final Parcelable.Creator<UsbDevice> CREATOR = @@ -184,8 +220,12 @@ public class UsbDevice implements Parcelable { int clasz = in.readInt(); int subClass = in.readInt(); int protocol = in.readInt(); + String manufacturerName = in.readString(); + String productName = in.readString(); + String serialNumber = in.readString(); Parcelable[] interfaces = in.readParcelableArray(UsbInterface.class.getClassLoader()); - return new UsbDevice(name, vendorId, productId, clasz, subClass, protocol, interfaces); + return new UsbDevice(name, vendorId, productId, clasz, subClass, protocol, + manufacturerName, productName, serialNumber, interfaces); } public UsbDevice[] newArray(int size) { @@ -204,6 +244,9 @@ public class UsbDevice implements Parcelable { parcel.writeInt(mClass); parcel.writeInt(mSubclass); parcel.writeInt(mProtocol); + parcel.writeString(mManufacturerName); + parcel.writeString(mProductName); + parcel.writeString(mSerialNumber); parcel.writeParcelableArray(mInterfaces, 0); } diff --git a/core/java/android/hardware/usb/UsbDeviceConnection.java b/core/java/android/hardware/usb/UsbDeviceConnection.java index b2034b2636c9..389475fca6c9 100644 --- a/core/java/android/hardware/usb/UsbDeviceConnection.java +++ b/core/java/android/hardware/usb/UsbDeviceConnection.java @@ -32,7 +32,7 @@ public class UsbDeviceConnection { private final UsbDevice mDevice; // used by the JNI code - private int mNativeContext; + private long mNativeContext; /** * UsbDevice should only be instantiated by UsbService implementation diff --git a/core/java/android/hardware/usb/UsbRequest.java b/core/java/android/hardware/usb/UsbRequest.java index 36467158d4c9..ce660846c1c9 100644 --- a/core/java/android/hardware/usb/UsbRequest.java +++ b/core/java/android/hardware/usb/UsbRequest.java @@ -37,7 +37,7 @@ public class UsbRequest { private static final String TAG = "UsbRequest"; // used by the JNI code - private int mNativeContext; + private long mNativeContext; private UsbEndpoint mEndpoint; diff --git a/core/java/android/view/LayoutInflater.java b/core/java/android/view/LayoutInflater.java index aa43bad85a36..ed758504855e 100644 --- a/core/java/android/view/LayoutInflater.java +++ b/core/java/android/view/LayoutInflater.java @@ -91,6 +91,8 @@ public abstract class LayoutInflater { private static final String TAG_1995 = "blink"; private static final String TAG_REQUEST_FOCUS = "requestFocus"; + private static final String ATTR_THEME = "theme"; + /** * Hook to allow clients of the LayoutInflater to restrict the set of Views that are allowed * to be inflated. @@ -459,15 +461,10 @@ public abstract class LayoutInflater { + "ViewGroup root and attachToRoot=true"); } - rInflate(parser, root, attrs, false); + rInflate(parser, root, attrs, false, false); } else { // Temp is the root view that was found in the xml - View temp; - if (TAG_1995.equals(name)) { - temp = new BlinkLayout(mContext, attrs); - } else { - temp = createViewFromTag(root, name, attrs); - } + final View temp = createViewFromTag(root, name, attrs, false); ViewGroup.LayoutParams params = null; @@ -489,7 +486,7 @@ public abstract class LayoutInflater { System.out.println("-----> start inflating children"); } // Inflate all children under temp - rInflate(parser, temp, attrs, true); + rInflate(parser, temp, attrs, true, true); if (DEBUG) { System.out.println("-----> done inflating children"); } @@ -669,31 +666,66 @@ public abstract class LayoutInflater { return onCreateView(name, attrs); } - /* - * default visibility so the BridgeInflater can override it. + /** + * Creates a view from a tag name using the supplied attribute set. + * <p> + * If {@code inheritContext} is true and the parent is non-null, the view + * will be inflated in parent view's context. If the view specifies a + * <theme> attribute, the inflation context will be wrapped with the + * specified theme. + * <p> + * Note: Default visibility so the BridgeInflater can override it. */ - View createViewFromTag(View parent, String name, AttributeSet attrs) { + View createViewFromTag(View parent, String name, AttributeSet attrs, boolean inheritContext) { if (name.equals("view")) { name = attrs.getAttributeValue(null, "class"); } + Context viewContext; + if (parent != null && inheritContext) { + viewContext = parent.getContext(); + } else { + viewContext = mContext; + } + + // Apply a theme wrapper, if requested. + final int themeResId = attrs.getAttributeResourceValue(null, ATTR_THEME, 0); + if (themeResId != 0) { + viewContext = new ContextThemeWrapper(viewContext, themeResId); + } + + if (name.equals(TAG_1995)) { + // Let's party like it's 1995! + return new BlinkLayout(viewContext, attrs); + } + if (DEBUG) System.out.println("******** Creating view: " + name); try { View view; - if (mFactory2 != null) view = mFactory2.onCreateView(parent, name, mContext, attrs); - else if (mFactory != null) view = mFactory.onCreateView(name, mContext, attrs); - else view = null; + if (mFactory2 != null) { + view = mFactory2.onCreateView(parent, name, viewContext, attrs); + } else if (mFactory != null) { + view = mFactory.onCreateView(name, viewContext, attrs); + } else { + view = null; + } if (view == null && mPrivateFactory != null) { - view = mPrivateFactory.onCreateView(parent, name, mContext, attrs); + view = mPrivateFactory.onCreateView(parent, name, viewContext, attrs); } - + if (view == null) { - if (-1 == name.indexOf('.')) { - view = onCreateView(parent, name, attrs); - } else { - view = createView(name, null, attrs); + final Object lastContext = mConstructorArgs[0]; + mConstructorArgs[0] = viewContext; + try { + if (-1 == name.indexOf('.')) { + view = onCreateView(parent, name, attrs); + } else { + view = createView(name, null, attrs); + } + } finally { + mConstructorArgs[0] = lastContext; } } @@ -720,9 +752,14 @@ public abstract class LayoutInflater { /** * Recursive method used to descend down the xml hierarchy and instantiate * views, instantiate their children, and then call onFinishInflate(). + * + * @param inheritContext Whether the root view should be inflated in its + * parent's context. This should be true when called inflating + * child views recursively, or false otherwise. */ void rInflate(XmlPullParser parser, View parent, final AttributeSet attrs, - boolean finishInflate) throws XmlPullParserException, IOException { + boolean finishInflate, boolean inheritContext) throws XmlPullParserException, + IOException { final int depth = parser.getDepth(); int type; @@ -742,20 +779,14 @@ public abstract class LayoutInflater { if (parser.getDepth() == 0) { throw new InflateException("<include /> cannot be the root element"); } - parseInclude(parser, parent, attrs); + parseInclude(parser, parent, attrs, inheritContext); } else if (TAG_MERGE.equals(name)) { throw new InflateException("<merge /> must be the root element"); - } else if (TAG_1995.equals(name)) { - final View view = new BlinkLayout(mContext, attrs); - final ViewGroup viewGroup = (ViewGroup) parent; - final ViewGroup.LayoutParams params = viewGroup.generateLayoutParams(attrs); - rInflate(parser, view, attrs, true); - viewGroup.addView(view, params); } else { - final View view = createViewFromTag(parent, name, attrs); + final View view = createViewFromTag(parent, name, attrs, inheritContext); final ViewGroup viewGroup = (ViewGroup) parent; final ViewGroup.LayoutParams params = viewGroup.generateLayoutParams(attrs); - rInflate(parser, view, attrs, true); + rInflate(parser, view, attrs, true, true); viewGroup.addView(view, params); } } @@ -774,9 +805,8 @@ public abstract class LayoutInflater { } } - private void parseInclude(XmlPullParser parser, View parent, AttributeSet attrs) - throws XmlPullParserException, IOException { - + private void parseInclude(XmlPullParser parser, View parent, AttributeSet attrs, + boolean inheritContext) throws XmlPullParserException, IOException { int type; if (parent instanceof ViewGroup) { @@ -811,9 +841,10 @@ public abstract class LayoutInflater { if (TAG_MERGE.equals(childName)) { // Inflate all children. - rInflate(childParser, parent, childAttrs, false); + rInflate(childParser, parent, childAttrs, false, inheritContext); } else { - final View view = createViewFromTag(parent, childName, childAttrs); + final View view = createViewFromTag(parent, childName, childAttrs, + inheritContext); final ViewGroup group = (ViewGroup) parent; // We try to load the layout params set in the <include /> tag. If @@ -836,7 +867,7 @@ public abstract class LayoutInflater { } // Inflate all children. - rInflate(childParser, view, childAttrs, true); + rInflate(childParser, view, childAttrs, true, true); // Attempt to override the included layout's android:id with the // one set on the <include /> tag itself. diff --git a/core/java/android/view/RemoteGLRenderer.java b/core/java/android/view/RemoteGLRenderer.java index 6195fcb243e0..0862458831b2 100644 --- a/core/java/android/view/RemoteGLRenderer.java +++ b/core/java/android/view/RemoteGLRenderer.java @@ -16,40 +16,11 @@ package android.view; -import static javax.microedition.khronos.egl.EGL10.EGL_ALPHA_SIZE; -import static javax.microedition.khronos.egl.EGL10.EGL_BAD_NATIVE_WINDOW; -import static javax.microedition.khronos.egl.EGL10.EGL_BLUE_SIZE; -import static javax.microedition.khronos.egl.EGL10.EGL_CONFIG_CAVEAT; -import static javax.microedition.khronos.egl.EGL10.EGL_DEFAULT_DISPLAY; -import static javax.microedition.khronos.egl.EGL10.EGL_DEPTH_SIZE; -import static javax.microedition.khronos.egl.EGL10.EGL_DRAW; -import static javax.microedition.khronos.egl.EGL10.EGL_GREEN_SIZE; -import static javax.microedition.khronos.egl.EGL10.EGL_HEIGHT; -import static javax.microedition.khronos.egl.EGL10.EGL_NONE; -import static javax.microedition.khronos.egl.EGL10.EGL_NO_CONTEXT; -import static javax.microedition.khronos.egl.EGL10.EGL_NO_DISPLAY; -import static javax.microedition.khronos.egl.EGL10.EGL_NO_SURFACE; -import static javax.microedition.khronos.egl.EGL10.EGL_RED_SIZE; -import static javax.microedition.khronos.egl.EGL10.EGL_RENDERABLE_TYPE; -import static javax.microedition.khronos.egl.EGL10.EGL_SAMPLES; -import static javax.microedition.khronos.egl.EGL10.EGL_SAMPLE_BUFFERS; -import static javax.microedition.khronos.egl.EGL10.EGL_STENCIL_SIZE; -import static javax.microedition.khronos.egl.EGL10.EGL_SUCCESS; -import static javax.microedition.khronos.egl.EGL10.EGL_SURFACE_TYPE; -import static javax.microedition.khronos.egl.EGL10.EGL_WIDTH; -import static javax.microedition.khronos.egl.EGL10.EGL_WINDOW_BIT; - -import android.content.ComponentCallbacks2; import android.graphics.Color; import android.graphics.Paint; import android.graphics.Rect; import android.graphics.SurfaceTexture; -import android.opengl.EGL14; -import android.opengl.GLUtils; -import android.opengl.ManagedEGLContext; -import android.os.Handler; import android.os.IBinder; -import android.os.Looper; import android.os.RemoteException; import android.os.ServiceManager; import android.os.SystemProperties; @@ -58,19 +29,9 @@ import android.util.DisplayMetrics; import android.util.Log; import android.view.Surface.OutOfResourcesException; -import com.google.android.gles_jni.EGLImpl; - import java.io.PrintWriter; import java.util.concurrent.locks.ReentrantLock; -import javax.microedition.khronos.egl.EGL10; -import javax.microedition.khronos.egl.EGL11; -import javax.microedition.khronos.egl.EGLConfig; -import javax.microedition.khronos.egl.EGLContext; -import javax.microedition.khronos.egl.EGLDisplay; -import javax.microedition.khronos.egl.EGLSurface; -import javax.microedition.khronos.opengles.GL; - /** * Hardware renderer using OpenGL that's used as the remote endpoint * of ThreadedRenderer @@ -119,21 +80,8 @@ public class RemoteGLRenderer extends HardwareRenderer { private static final int OVERDRAW_TYPE_COUNT = 1; private static final int GL_VERSION = 2; - static EGL10 sEgl; - static EGLDisplay sEglDisplay; - static EGLConfig sEglConfig; - static final Object[] sEglLock = new Object[0]; int mWidth = -1, mHeight = -1; - static final ThreadLocal<ManagedEGLContext> sEglContextStorage - = new ThreadLocal<ManagedEGLContext>(); - - EGLContext mEglContext; - Thread mEglThread; - - EGLSurface mEglSurface; - - GL mGl; HardwareCanvas mCanvas; String mName; @@ -141,17 +89,8 @@ public class RemoteGLRenderer extends HardwareRenderer { long mFrameCount; Paint mDebugPaint; - static boolean sDirtyRegions; - static final boolean sDirtyRegionsRequested; - static { - String dirtyProperty = SystemProperties.get(RENDER_DIRTY_REGIONS_PROPERTY, "true"); - //noinspection PointlessBooleanExpression,ConstantConditions - sDirtyRegions = "true".equalsIgnoreCase(dirtyProperty); - sDirtyRegionsRequested = sDirtyRegions; - } - boolean mDirtyRegionsEnabled; - boolean mUpdateDirtyRegions; + boolean mSurfaceUpdated; boolean mProfileEnabled; int mProfileVisualizerType = -1; @@ -170,8 +109,6 @@ public class RemoteGLRenderer extends HardwareRenderer { final boolean mTranslucent; - private boolean mDestroyed; - private final Rect mRedrawClip = new Rect(); private final int[] mSurfaceSize = new int[2]; @@ -183,84 +120,12 @@ public class RemoteGLRenderer extends HardwareRenderer { private DisplayMetrics mDisplayMetrics; private ThreadedRenderer mOwningRenderer; - - private static EGLSurface sPbuffer; - private static final Object[] sPbufferLock = new Object[0]; - - private static class GLRendererEglContext extends ManagedEGLContext { - final Handler mHandler = new Handler(); - - public GLRendererEglContext(EGLContext context) { - super(context); - } - - @Override - public void onTerminate(final EGLContext eglContext) { - // Make sure we do this on the correct thread. - if (mHandler.getLooper() != Looper.myLooper()) { - mHandler.post(new Runnable() { - @Override - public void run() { - onTerminate(eglContext); - } - }); - return; - } - - synchronized (sEglLock) { - if (sEgl == null) return; - - if (EGLImpl.getInitCount(sEglDisplay) == 1) { - usePbufferSurface(eglContext); - GLES20Canvas.terminateCaches(); - - sEgl.eglDestroyContext(sEglDisplay, eglContext); - sEglContextStorage.set(null); - sEglContextStorage.remove(); - - sEgl.eglDestroySurface(sEglDisplay, sPbuffer); - sEgl.eglMakeCurrent(sEglDisplay, EGL_NO_SURFACE, - EGL_NO_SURFACE, EGL_NO_CONTEXT); - - sEgl.eglReleaseThread(); - sEgl.eglTerminate(sEglDisplay); - - sEgl = null; - sEglDisplay = null; - sEglConfig = null; - sPbuffer = null; - } - } - } - } + private long mNativeCanvasContext; HardwareCanvas createCanvas() { return mGlCanvas = new GLES20Canvas(mTranslucent); } - ManagedEGLContext createManagedContext(EGLContext eglContext) { - return new GLRendererEglContext(mEglContext); - } - - int[] getConfig(boolean dirtyRegions) { - //noinspection PointlessBooleanExpression,ConstantConditions - final int stencilSize = GLES20Canvas.getStencilSize(); - final int swapBehavior = dirtyRegions ? EGL14.EGL_SWAP_BEHAVIOR_PRESERVED_BIT : 0; - - return new int[] { - EGL_RENDERABLE_TYPE, EGL14.EGL_OPENGL_ES2_BIT, - EGL_RED_SIZE, 8, - EGL_GREEN_SIZE, 8, - EGL_BLUE_SIZE, 8, - EGL_ALPHA_SIZE, 8, - EGL_DEPTH_SIZE, 0, - EGL_CONFIG_CAVEAT, EGL_NONE, - EGL_STENCIL_SIZE, stencilSize, - EGL_SURFACE_TYPE, EGL_WINDOW_BIT | swapBehavior, - EGL_NONE - }; - } - void initCaches() { if (GLES20Canvas.initCaches()) { // Caches were (re)initialized, rebind atlas @@ -295,7 +160,7 @@ public class RemoteGLRenderer extends HardwareRenderer { } boolean canDraw() { - return mGl != null && mCanvas != null && mGlCanvas != null; + return mCanvas != null && mGlCanvas != null; } int onPreDraw(Rect dirty) { @@ -458,17 +323,11 @@ public class RemoteGLRenderer extends HardwareRenderer { if (full && mCanvas != null) { mCanvas = null; } - - if (!isEnabled() || mDestroyed) { - setEnabled(false); - return; + if (mNativeCanvasContext != 0) { + destroyContext(mNativeCanvasContext); + mNativeCanvasContext = 0; } - - destroySurface(); setEnabled(false); - - mDestroyed = true; - mGl = null; } finally { if (full && mGlCanvas != null) { mGlCanvas = null; @@ -524,21 +383,13 @@ public class RemoteGLRenderer extends HardwareRenderer { boolean needsContext = !isEnabled() || checkRenderContext() == SURFACE_STATE_ERROR; if (needsContext) { - GLRendererEglContext managedContext = - (GLRendererEglContext) sEglContextStorage.get(); - if (managedContext == null) return false; - usePbufferSurface(managedContext.getContext()); - } - - try { - action.run(); - } finally { - if (needsContext) { - sEgl.eglMakeCurrent(sEglDisplay, EGL_NO_SURFACE, - EGL_NO_SURFACE, EGL_NO_CONTEXT); + if (!usePBufferSurface()) { + return false; } } + action.run(); + return true; } @@ -600,44 +451,6 @@ public class RemoteGLRenderer extends HardwareRenderer { } } - static void startTrimMemory(int level) { - if (sEgl == null || sEglConfig == null) return; - - GLRendererEglContext managedContext = - (GLRendererEglContext) sEglContextStorage.get(); - // We do not have OpenGL objects - if (managedContext == null) { - return; - } else { - usePbufferSurface(managedContext.getContext()); - } - - if (level >= ComponentCallbacks2.TRIM_MEMORY_COMPLETE) { - GLES20Canvas.flushCaches(GLES20Canvas.FLUSH_CACHES_FULL); - } else if (level >= ComponentCallbacks2.TRIM_MEMORY_UI_HIDDEN) { - GLES20Canvas.flushCaches(GLES20Canvas.FLUSH_CACHES_MODERATE); - } - } - - static void endTrimMemory() { - if (sEgl != null && sEglDisplay != null) { - sEgl.eglMakeCurrent(sEglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT); - } - } - - private static void usePbufferSurface(EGLContext eglContext) { - synchronized (sPbufferLock) { - // Create a temporary 1x1 pbuffer so we have a context - // to clear our OpenGL objects - if (sPbuffer == null) { - sPbuffer = sEgl.eglCreatePbufferSurface(sEglDisplay, sEglConfig, new int[] { - EGL_WIDTH, 1, EGL_HEIGHT, 1, EGL_NONE - }); - } - } - sEgl.eglMakeCurrent(sEglDisplay, sPbuffer, sPbuffer, eglContext); - } - RemoteGLRenderer(ThreadedRenderer owningRenderer, boolean translucent) { mOwningRenderer = owningRenderer; mTranslucent = translucent; @@ -771,62 +584,31 @@ public class RemoteGLRenderer extends HardwareRenderer { return mDirtyRegionsEnabled; } - /** - * Checks for OpenGL errors. If an error has occured, {@link #destroy(boolean)} - * is invoked and the requested flag is turned off. The error code is - * also logged as a warning. - */ - void checkEglErrors() { - if (isEnabled()) { - checkEglErrorsForced(); - } - } - - private void checkEglErrorsForced() { - int error = sEgl.eglGetError(); - if (error != EGL_SUCCESS) { - // something bad has happened revert to - // normal rendering. - Log.w(LOG_TAG, "EGL error: " + GLUtils.getEGLErrorString(error)); - fallback(error != EGL11.EGL_CONTEXT_LOST); - } - } - - private void fallback(boolean fallback) { + private void triggerSoftwareFallback() { destroy(true); - if (fallback) { - // we'll try again if it was context lost - setRequested(false); - Log.w(LOG_TAG, "Mountain View, we've had a problem here. " - + "Switching back to software rendering."); - } + // we'll try again if it was context lost + setRequested(false); + Log.w(LOG_TAG, "Mountain View, we've had a problem here. " + + "Switching back to software rendering."); } @Override boolean initialize(Surface surface) throws OutOfResourcesException { if (isRequested() && !isEnabled()) { - boolean contextCreated = initializeEgl(); - mGl = createEglSurface(surface); - mDestroyed = false; - - if (mGl != null) { - int err = sEgl.eglGetError(); - if (err != EGL_SUCCESS) { - destroy(true); - setRequested(false); - } else { - if (mCanvas == null) { - mCanvas = createCanvas(); - mCanvas.setName(mName); - } - setEnabled(true); + mNativeCanvasContext = createContext(); + boolean surfaceCreated = createEglSurface(surface); - if (contextCreated) { - initAtlas(); - } + if (surfaceCreated) { + if (mCanvas == null) { + mCanvas = createCanvas(); + mCanvas.setName(mName); } - - return mCanvas != null; + setEnabled(true); + initAtlas(); + return true; + } else { + destroy(true); + setRequested(false); } } return false; @@ -839,251 +621,30 @@ public class RemoteGLRenderer extends HardwareRenderer { } } - boolean initializeEgl() { - synchronized (sEglLock) { - if (sEgl == null && sEglConfig == null) { - sEgl = (EGL10) EGLContext.getEGL(); - - // Get to the default display. - sEglDisplay = sEgl.eglGetDisplay(EGL_DEFAULT_DISPLAY); - - if (sEglDisplay == EGL_NO_DISPLAY) { - throw new RuntimeException("eglGetDisplay failed " - + GLUtils.getEGLErrorString(sEgl.eglGetError())); - } - - // We can now initialize EGL for that display - int[] version = new int[2]; - if (!sEgl.eglInitialize(sEglDisplay, version)) { - throw new RuntimeException("eglInitialize failed " + - GLUtils.getEGLErrorString(sEgl.eglGetError())); - } - - checkEglErrorsForced(); - - sEglConfig = loadEglConfig(); - } - } - - ManagedEGLContext managedContext = sEglContextStorage.get(); - mEglContext = managedContext != null ? managedContext.getContext() : null; - mEglThread = Thread.currentThread(); - - if (mEglContext == null) { - mEglContext = createContext(sEgl, sEglDisplay, sEglConfig); - sEglContextStorage.set(createManagedContext(mEglContext)); - return true; - } - - return false; - } - - private EGLConfig loadEglConfig() { - EGLConfig eglConfig = chooseEglConfig(); - if (eglConfig == null) { - // We tried to use EGL_SWAP_BEHAVIOR_PRESERVED_BIT, try again without - if (sDirtyRegions) { - sDirtyRegions = false; - eglConfig = chooseEglConfig(); - if (eglConfig == null) { - throw new RuntimeException("eglConfig not initialized"); - } - } else { - throw new RuntimeException("eglConfig not initialized"); - } - } - return eglConfig; - } - - private EGLConfig chooseEglConfig() { - EGLConfig[] configs = new EGLConfig[1]; - int[] configsCount = new int[1]; - int[] configSpec = getConfig(sDirtyRegions); - - // Debug - final String debug = SystemProperties.get(PRINT_CONFIG_PROPERTY, ""); - if ("all".equalsIgnoreCase(debug)) { - sEgl.eglChooseConfig(sEglDisplay, configSpec, null, 0, configsCount); - - EGLConfig[] debugConfigs = new EGLConfig[configsCount[0]]; - sEgl.eglChooseConfig(sEglDisplay, configSpec, debugConfigs, - configsCount[0], configsCount); - - for (EGLConfig config : debugConfigs) { - printConfig(config); - } - } - - if (!sEgl.eglChooseConfig(sEglDisplay, configSpec, configs, 1, configsCount)) { - throw new IllegalArgumentException("eglChooseConfig failed " + - GLUtils.getEGLErrorString(sEgl.eglGetError())); - } else if (configsCount[0] > 0) { - if ("choice".equalsIgnoreCase(debug)) { - printConfig(configs[0]); - } - return configs[0]; - } - - return null; - } - - private static void printConfig(EGLConfig config) { - int[] value = new int[1]; - - Log.d(LOG_TAG, "EGL configuration " + config + ":"); - - sEgl.eglGetConfigAttrib(sEglDisplay, config, EGL_RED_SIZE, value); - Log.d(LOG_TAG, " RED_SIZE = " + value[0]); - - sEgl.eglGetConfigAttrib(sEglDisplay, config, EGL_GREEN_SIZE, value); - Log.d(LOG_TAG, " GREEN_SIZE = " + value[0]); - - sEgl.eglGetConfigAttrib(sEglDisplay, config, EGL_BLUE_SIZE, value); - Log.d(LOG_TAG, " BLUE_SIZE = " + value[0]); - - sEgl.eglGetConfigAttrib(sEglDisplay, config, EGL_ALPHA_SIZE, value); - Log.d(LOG_TAG, " ALPHA_SIZE = " + value[0]); - - sEgl.eglGetConfigAttrib(sEglDisplay, config, EGL_DEPTH_SIZE, value); - Log.d(LOG_TAG, " DEPTH_SIZE = " + value[0]); - - sEgl.eglGetConfigAttrib(sEglDisplay, config, EGL_STENCIL_SIZE, value); - Log.d(LOG_TAG, " STENCIL_SIZE = " + value[0]); - - sEgl.eglGetConfigAttrib(sEglDisplay, config, EGL_SAMPLE_BUFFERS, value); - Log.d(LOG_TAG, " SAMPLE_BUFFERS = " + value[0]); - - sEgl.eglGetConfigAttrib(sEglDisplay, config, EGL_SAMPLES, value); - Log.d(LOG_TAG, " SAMPLES = " + value[0]); - - sEgl.eglGetConfigAttrib(sEglDisplay, config, EGL_SURFACE_TYPE, value); - Log.d(LOG_TAG, " SURFACE_TYPE = 0x" + Integer.toHexString(value[0])); - - sEgl.eglGetConfigAttrib(sEglDisplay, config, EGL_CONFIG_CAVEAT, value); - Log.d(LOG_TAG, " CONFIG_CAVEAT = 0x" + Integer.toHexString(value[0])); - } - - GL createEglSurface(Surface surface) throws OutOfResourcesException { - // Check preconditions. - if (sEgl == null) { - throw new RuntimeException("egl not initialized"); - } - if (sEglDisplay == null) { - throw new RuntimeException("eglDisplay not initialized"); - } - if (sEglConfig == null) { - throw new RuntimeException("eglConfig not initialized"); - } - if (Thread.currentThread() != mEglThread) { - throw new IllegalStateException("HardwareRenderer cannot be used " - + "from multiple threads"); - } - - // In case we need to destroy an existing surface - destroySurface(); - + boolean createEglSurface(Surface surface) throws OutOfResourcesException { // Create an EGL surface we can render into. - if (!createSurface(surface)) { - return null; + if (!setSurface(mNativeCanvasContext, surface)) { + return false; } + makeCurrent(mNativeCanvasContext); + mSurfaceUpdated = true; initCaches(); - - return mEglContext.getGL(); - } - - private void enableDirtyRegions() { - // If mDirtyRegions is set, this means we have an EGL configuration - // with EGL_SWAP_BEHAVIOR_PRESERVED_BIT set - if (sDirtyRegions) { - if (!(mDirtyRegionsEnabled = GLRenderer.preserveBackBuffer())) { - Log.w(LOG_TAG, "Backbuffer cannot be preserved"); - } - } else if (sDirtyRegionsRequested) { - // If mDirtyRegions is not set, our EGL configuration does not - // have EGL_SWAP_BEHAVIOR_PRESERVED_BIT; however, the default - // swap behavior might be EGL_BUFFER_PRESERVED, which means we - // want to set mDirtyRegions. We try to do this only if dirty - // regions were initially requested as part of the device - // configuration (see RENDER_DIRTY_REGIONS) - mDirtyRegionsEnabled = GLRenderer.isBackBufferPreserved(); - } - } - - EGLContext createContext(EGL10 egl, EGLDisplay eglDisplay, EGLConfig eglConfig) { - final int[] attribs = { EGL14.EGL_CONTEXT_CLIENT_VERSION, GL_VERSION, EGL_NONE }; - - EGLContext context = egl.eglCreateContext(eglDisplay, eglConfig, EGL_NO_CONTEXT, - attribs); - if (context == null || context == EGL_NO_CONTEXT) { - //noinspection ConstantConditions - throw new IllegalStateException( - "Could not create an EGL context. eglCreateContext failed with error: " + - GLUtils.getEGLErrorString(sEgl.eglGetError())); - } - - return context; - } - - void destroySurface() { - if (mEglSurface != null && mEglSurface != EGL_NO_SURFACE) { - if (mEglSurface.equals(sEgl.eglGetCurrentSurface(EGL_DRAW))) { - sEgl.eglMakeCurrent(sEglDisplay, - EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT); - } - sEgl.eglDestroySurface(sEglDisplay, mEglSurface); - mEglSurface = null; - } + return true; } @Override void invalidate(Surface surface) { - // Cancels any existing buffer to ensure we'll get a buffer - // of the right size before we call eglSwapBuffers - sEgl.eglMakeCurrent(sEglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT); - - if (mEglSurface != null && mEglSurface != EGL_NO_SURFACE) { - sEgl.eglDestroySurface(sEglDisplay, mEglSurface); - mEglSurface = null; - setEnabled(false); - } + setSurface(mNativeCanvasContext, null); + setEnabled(false); if (surface.isValid()) { - if (!createSurface(surface)) { - return; - } - - mUpdateDirtyRegions = true; - - if (mCanvas != null) { + if (createEglSurface(surface) && mCanvas != null) { setEnabled(true); } } } - private boolean createSurface(Surface surface) { - mEglSurface = sEgl.eglCreateWindowSurface(sEglDisplay, sEglConfig, surface, null); - - if (mEglSurface == null || mEglSurface == EGL_NO_SURFACE) { - int error = sEgl.eglGetError(); - if (error == EGL_BAD_NATIVE_WINDOW) { - Log.e(LOG_TAG, "createWindowSurface returned EGL_BAD_NATIVE_WINDOW."); - return false; - } - throw new RuntimeException("createWindowSurface failed " - + GLUtils.getEGLErrorString(error)); - } - - if (!sEgl.eglMakeCurrent(sEglDisplay, mEglSurface, mEglSurface, mEglContext)) { - throw new IllegalStateException("eglMakeCurrent failed " + - GLUtils.getEGLErrorString(sEgl.eglGetError())); - } - - enableDirtyRegions(); - - return true; - } - @Override boolean validate() { return checkRenderContext() != SURFACE_STATE_ERROR; @@ -1153,8 +714,7 @@ public class RemoteGLRenderer extends HardwareRenderer { dirty = null; } - // We are already on the correct thread - final int surfaceState = checkRenderContextUnsafe(); + final int surfaceState = checkRenderContext(); if (surfaceState != SURFACE_STATE_ERROR) { HardwareCanvas canvas = mCanvas; @@ -1328,15 +888,16 @@ public class RemoteGLRenderer extends HardwareRenderer { eglSwapBuffersStartTime = System.nanoTime(); } - sEgl.eglSwapBuffers(sEglDisplay, mEglSurface); + if (!swapBuffers(mNativeCanvasContext)) { + triggerSoftwareFallback(); + } + mSurfaceUpdated = false; if (mProfileEnabled) { long now = System.nanoTime(); float total = (now - eglSwapBuffersStartTime) * 0.000001f; mProfileData[mProfileCurrentFrame + 2] = total; } - - checkEglErrors(); } } @@ -1408,42 +969,11 @@ public class RemoteGLRenderer extends HardwareRenderer { * @see #checkRenderContextUnsafe() */ int checkRenderContext() { - if (mEglThread != Thread.currentThread()) { - throw new IllegalStateException("Hardware acceleration can only be used with a " + - "single UI thread.\nOriginal thread: " + mEglThread + "\n" + - "Current thread: " + Thread.currentThread()); + if (!makeCurrent(mNativeCanvasContext)) { + triggerSoftwareFallback(); + return SURFACE_STATE_ERROR; } - - return checkRenderContextUnsafe(); - } - - /** - * Ensures the current EGL context and surface are the ones we expect. - * This method does not check the current thread. - * - * @return {@link #SURFACE_STATE_ERROR} if the correct EGL context cannot be made current, - * {@link #SURFACE_STATE_UPDATED} if the EGL context was changed or - * {@link #SURFACE_STATE_SUCCESS} if the EGL context was the correct one - * - * @see #checkRenderContext() - */ - private int checkRenderContextUnsafe() { - if (!mEglSurface.equals(sEgl.eglGetCurrentSurface(EGL_DRAW)) || - !mEglContext.equals(sEgl.eglGetCurrentContext())) { - if (!sEgl.eglMakeCurrent(sEglDisplay, mEglSurface, mEglSurface, mEglContext)) { - Log.e(LOG_TAG, "eglMakeCurrent failed " + - GLUtils.getEGLErrorString(sEgl.eglGetError())); - fallback(true); - return SURFACE_STATE_ERROR; - } else { - if (mUpdateDirtyRegions) { - enableDirtyRegions(); - mUpdateDirtyRegions = false; - } - return SURFACE_STATE_UPDATED; - } - } - return SURFACE_STATE_SUCCESS; + return mSurfaceUpdated ? SURFACE_STATE_UPDATED : SURFACE_STATE_SUCCESS; } private static int dpToPx(int dp, float density) { @@ -1535,4 +1065,11 @@ public class RemoteGLRenderer extends HardwareRenderer { if (mGraphType == GRAPH_TYPE_LINES) paint.setStrokeWidth(mThresholdStroke); } } + + static native long createContext(); + static native boolean usePBufferSurface(); + static native boolean setSurface(long nativeCanvasContext, Surface surface); + static native boolean swapBuffers(long nativeCanvasContext); + static native boolean makeCurrent(long nativeCanvasContext); + static native void destroyContext(long nativeCanvasContext); } diff --git a/core/jni/Android.mk b/core/jni/Android.mk index f26374a4d667..e88db54e4b70 100644 --- a/core/jni/Android.mk +++ b/core/jni/Android.mk @@ -58,6 +58,7 @@ LOCAL_SRC_FILES:= \ android_view_GLRenderer.cpp \ android_view_GLES20Canvas.cpp \ android_view_ThreadedRenderer.cpp \ + android_view_RemoteGLRenderer.cpp \ android_view_MotionEvent.cpp \ android_view_PointerIcon.cpp \ android_view_VelocityTracker.cpp \ diff --git a/core/jni/AndroidRuntime.cpp b/core/jni/AndroidRuntime.cpp index 89d75dc03f92..011db5e561f4 100644 --- a/core/jni/AndroidRuntime.cpp +++ b/core/jni/AndroidRuntime.cpp @@ -124,6 +124,7 @@ extern int register_android_view_GraphicBuffer(JNIEnv* env); extern int register_android_view_GLES20Canvas(JNIEnv* env); extern int register_android_view_GLRenderer(JNIEnv* env); extern int register_android_view_ThreadedRenderer(JNIEnv* env); +extern int register_android_view_RemoteGLRenderer(JNIEnv* env); extern int register_android_view_Surface(JNIEnv* env); extern int register_android_view_SurfaceControl(JNIEnv* env); extern int register_android_view_SurfaceSession(JNIEnv* env); @@ -1129,6 +1130,7 @@ static const RegJNIRec gRegJNI[] = { REG_JNI(register_android_view_GLES20Canvas), REG_JNI(register_android_view_GLRenderer), REG_JNI(register_android_view_ThreadedRenderer), + REG_JNI(register_android_view_RemoteGLRenderer), REG_JNI(register_android_view_Surface), REG_JNI(register_android_view_SurfaceControl), REG_JNI(register_android_view_SurfaceSession), diff --git a/core/jni/android_app_NativeActivity.cpp b/core/jni/android_app_NativeActivity.cpp index 54180065796f..9c44093904fb 100644 --- a/core/jni/android_app_NativeActivity.cpp +++ b/core/jni/android_app_NativeActivity.cpp @@ -241,10 +241,10 @@ static int mainWorkCallback(int fd, int events, void* data) { // ------------------------------------------------------------------------ -static jint +static jlong loadNativeCode_native(JNIEnv* env, jobject clazz, jstring path, jstring funcName, jobject messageQueue, jstring internalDataDir, jstring obbDir, - jstring externalDataDir, int sdkVersion, + jstring externalDataDir, jint sdkVersion, jobject jAssetMgr, jbyteArray savedState) { LOG_TRACE("loadNativeCode_native"); @@ -338,11 +338,11 @@ loadNativeCode_native(JNIEnv* env, jobject clazz, jstring path, jstring funcName } } - return (jint)code; + return (jlong)code; } static void -unloadNativeCode_native(JNIEnv* env, jobject clazz, jint handle) +unloadNativeCode_native(JNIEnv* env, jobject clazz, jlong handle) { LOG_TRACE("unloadNativeCode_native"); if (handle != 0) { @@ -352,7 +352,7 @@ unloadNativeCode_native(JNIEnv* env, jobject clazz, jint handle) } static void -onStart_native(JNIEnv* env, jobject clazz, jint handle) +onStart_native(JNIEnv* env, jobject clazz, jlong handle) { LOG_TRACE("onStart_native"); if (handle != 0) { @@ -364,7 +364,7 @@ onStart_native(JNIEnv* env, jobject clazz, jint handle) } static void -onResume_native(JNIEnv* env, jobject clazz, jint handle) +onResume_native(JNIEnv* env, jobject clazz, jlong handle) { LOG_TRACE("onResume_native"); if (handle != 0) { @@ -376,7 +376,7 @@ onResume_native(JNIEnv* env, jobject clazz, jint handle) } static jbyteArray -onSaveInstanceState_native(JNIEnv* env, jobject clazz, jint handle) +onSaveInstanceState_native(JNIEnv* env, jobject clazz, jlong handle) { LOG_TRACE("onSaveInstanceState_native"); @@ -403,7 +403,7 @@ onSaveInstanceState_native(JNIEnv* env, jobject clazz, jint handle) } static void -onPause_native(JNIEnv* env, jobject clazz, jint handle) +onPause_native(JNIEnv* env, jobject clazz, jlong handle) { LOG_TRACE("onPause_native"); if (handle != 0) { @@ -415,7 +415,7 @@ onPause_native(JNIEnv* env, jobject clazz, jint handle) } static void -onStop_native(JNIEnv* env, jobject clazz, jint handle) +onStop_native(JNIEnv* env, jobject clazz, jlong handle) { LOG_TRACE("onStop_native"); if (handle != 0) { @@ -427,7 +427,7 @@ onStop_native(JNIEnv* env, jobject clazz, jint handle) } static void -onConfigurationChanged_native(JNIEnv* env, jobject clazz, jint handle) +onConfigurationChanged_native(JNIEnv* env, jobject clazz, jlong handle) { LOG_TRACE("onConfigurationChanged_native"); if (handle != 0) { @@ -439,7 +439,7 @@ onConfigurationChanged_native(JNIEnv* env, jobject clazz, jint handle) } static void -onLowMemory_native(JNIEnv* env, jobject clazz, jint handle) +onLowMemory_native(JNIEnv* env, jobject clazz, jlong handle) { LOG_TRACE("onLowMemory_native"); if (handle != 0) { @@ -451,7 +451,7 @@ onLowMemory_native(JNIEnv* env, jobject clazz, jint handle) } static void -onWindowFocusChanged_native(JNIEnv* env, jobject clazz, jint handle, jboolean focused) +onWindowFocusChanged_native(JNIEnv* env, jobject clazz, jlong handle, jboolean focused) { LOG_TRACE("onWindowFocusChanged_native"); if (handle != 0) { @@ -463,7 +463,7 @@ onWindowFocusChanged_native(JNIEnv* env, jobject clazz, jint handle, jboolean fo } static void -onSurfaceCreated_native(JNIEnv* env, jobject clazz, jint handle, jobject surface) +onSurfaceCreated_native(JNIEnv* env, jobject clazz, jlong handle, jobject surface) { LOG_TRACE("onSurfaceCreated_native"); if (handle != 0) { @@ -483,7 +483,7 @@ static int32_t getWindowProp(ANativeWindow* window, int what) { } static void -onSurfaceChanged_native(JNIEnv* env, jobject clazz, jint handle, jobject surface, +onSurfaceChanged_native(JNIEnv* env, jobject clazz, jlong handle, jobject surface, jint format, jint width, jint height) { LOG_TRACE("onSurfaceChanged_native"); @@ -524,7 +524,7 @@ onSurfaceChanged_native(JNIEnv* env, jobject clazz, jint handle, jobject surface } static void -onSurfaceRedrawNeeded_native(JNIEnv* env, jobject clazz, jint handle) +onSurfaceRedrawNeeded_native(JNIEnv* env, jobject clazz, jlong handle) { LOG_TRACE("onSurfaceRedrawNeeded_native"); if (handle != 0) { @@ -536,7 +536,7 @@ onSurfaceRedrawNeeded_native(JNIEnv* env, jobject clazz, jint handle) } static void -onSurfaceDestroyed_native(JNIEnv* env, jobject clazz, jint handle, jobject surface) +onSurfaceDestroyed_native(JNIEnv* env, jobject clazz, jlong handle, jobject surface) { LOG_TRACE("onSurfaceDestroyed_native"); if (handle != 0) { @@ -550,7 +550,7 @@ onSurfaceDestroyed_native(JNIEnv* env, jobject clazz, jint handle, jobject surfa } static void -onInputQueueCreated_native(JNIEnv* env, jobject clazz, jint handle, jint queuePtr) +onInputQueueCreated_native(JNIEnv* env, jobject clazz, jlong handle, jlong queuePtr) { LOG_TRACE("onInputChannelCreated_native"); if (handle != 0) { @@ -563,7 +563,7 @@ onInputQueueCreated_native(JNIEnv* env, jobject clazz, jint handle, jint queuePt } static void -onInputQueueDestroyed_native(JNIEnv* env, jobject clazz, jint handle, jint queuePtr) +onInputQueueDestroyed_native(JNIEnv* env, jobject clazz, jlong handle, jlong queuePtr) { LOG_TRACE("onInputChannelDestroyed_native"); if (handle != 0) { @@ -576,7 +576,7 @@ onInputQueueDestroyed_native(JNIEnv* env, jobject clazz, jint handle, jint queue } static void -onContentRectChanged_native(JNIEnv* env, jobject clazz, jint handle, +onContentRectChanged_native(JNIEnv* env, jobject clazz, jlong handle, jint x, jint y, jint w, jint h) { LOG_TRACE("onContentRectChanged_native"); @@ -594,26 +594,26 @@ onContentRectChanged_native(JNIEnv* env, jobject clazz, jint handle, } static const JNINativeMethod g_methods[] = { - { "loadNativeCode", "(Ljava/lang/String;Ljava/lang/String;Landroid/os/MessageQueue;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;ILandroid/content/res/AssetManager;[B)I", + { "loadNativeCode", "(Ljava/lang/String;Ljava/lang/String;Landroid/os/MessageQueue;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;ILandroid/content/res/AssetManager;[B)J", (void*)loadNativeCode_native }, - { "unloadNativeCode", "(I)V", (void*)unloadNativeCode_native }, - { "onStartNative", "(I)V", (void*)onStart_native }, - { "onResumeNative", "(I)V", (void*)onResume_native }, - { "onSaveInstanceStateNative", "(I)[B", (void*)onSaveInstanceState_native }, - { "onPauseNative", "(I)V", (void*)onPause_native }, - { "onStopNative", "(I)V", (void*)onStop_native }, - { "onConfigurationChangedNative", "(I)V", (void*)onConfigurationChanged_native }, - { "onLowMemoryNative", "(I)V", (void*)onLowMemory_native }, - { "onWindowFocusChangedNative", "(IZ)V", (void*)onWindowFocusChanged_native }, - { "onSurfaceCreatedNative", "(ILandroid/view/Surface;)V", (void*)onSurfaceCreated_native }, - { "onSurfaceChangedNative", "(ILandroid/view/Surface;III)V", (void*)onSurfaceChanged_native }, - { "onSurfaceRedrawNeededNative", "(ILandroid/view/Surface;)V", (void*)onSurfaceRedrawNeeded_native }, - { "onSurfaceDestroyedNative", "(I)V", (void*)onSurfaceDestroyed_native }, - { "onInputQueueCreatedNative", "(II)V", + { "unloadNativeCode", "(J)V", (void*)unloadNativeCode_native }, + { "onStartNative", "(J)V", (void*)onStart_native }, + { "onResumeNative", "(J)V", (void*)onResume_native }, + { "onSaveInstanceStateNative", "(J)[B", (void*)onSaveInstanceState_native }, + { "onPauseNative", "(J)V", (void*)onPause_native }, + { "onStopNative", "(J)V", (void*)onStop_native }, + { "onConfigurationChangedNative", "(J)V", (void*)onConfigurationChanged_native }, + { "onLowMemoryNative", "(J)V", (void*)onLowMemory_native }, + { "onWindowFocusChangedNative", "(JZ)V", (void*)onWindowFocusChanged_native }, + { "onSurfaceCreatedNative", "(JLandroid/view/Surface;)V", (void*)onSurfaceCreated_native }, + { "onSurfaceChangedNative", "(JLandroid/view/Surface;III)V", (void*)onSurfaceChanged_native }, + { "onSurfaceRedrawNeededNative", "(JLandroid/view/Surface;)V", (void*)onSurfaceRedrawNeeded_native }, + { "onSurfaceDestroyedNative", "(J)V", (void*)onSurfaceDestroyed_native }, + { "onInputQueueCreatedNative", "(JJ)V", (void*)onInputQueueCreated_native }, - { "onInputQueueDestroyedNative", "(II)V", + { "onInputQueueDestroyedNative", "(JJ)V", (void*)onInputQueueDestroyed_native }, - { "onContentRectChangedNative", "(IIIII)V", (void*)onContentRectChanged_native }, + { "onContentRectChangedNative", "(JIIII)V", (void*)onContentRectChanged_native }, }; static const char* const kNativeActivityPathName = "android/app/NativeActivity"; diff --git a/core/jni/android_app_backup_FullBackup.cpp b/core/jni/android_app_backup_FullBackup.cpp index 2ca645a6ee03..3cfaa82a55e4 100644 --- a/core/jni/android_app_backup_FullBackup.cpp +++ b/core/jni/android_app_backup_FullBackup.cpp @@ -70,7 +70,7 @@ static struct { * path: absolute path to the file to be saved * dataOutput: the BackupDataOutput object that we're saving into */ -static int backupToTar(JNIEnv* env, jobject clazz, jstring packageNameObj, +static jint backupToTar(JNIEnv* env, jobject clazz, jstring packageNameObj, jstring domainObj, jstring linkdomain, jstring rootpathObj, jstring pathObj, jobject dataOutputObj) { int ret; @@ -92,22 +92,22 @@ static int backupToTar(JNIEnv* env, jobject clazz, jstring packageNameObj, if (packagenamechars) env->ReleaseStringUTFChars(packageNameObj, packagenamechars); // Extract the data output fd - BackupDataWriter* writer = (BackupDataWriter*) env->GetIntField(dataOutputObj, + BackupDataWriter* writer = (BackupDataWriter*) env->GetLongField(dataOutputObj, sBackupDataOutput.mBackupWriter); // Validate if (!writer) { ALOGE("No output stream provided [%s]", path.string()); - return -1; + return (jint) -1; } if (path.length() < rootpath.length()) { ALOGE("file path [%s] shorter than root path [%s]", path.string(), rootpath.string()); - return -1; + return (jint) -1; } - return write_tarfile(packageName, domain, rootpath, path, writer); + return (jint) write_tarfile(packageName, domain, rootpath, path, writer); } static const JNINativeMethod g_methods[] = { @@ -121,7 +121,7 @@ int register_android_app_backup_FullBackup(JNIEnv* env) jclass clazz = env->FindClass("android/app/backup/BackupDataOutput"); LOG_FATAL_IF(clazz == NULL, "Unable to find class android.app.backup.BackupDataOutput"); - sBackupDataOutput.mBackupWriter = env->GetFieldID(clazz, "mBackupWriter", "I"); + sBackupDataOutput.mBackupWriter = env->GetFieldID(clazz, "mBackupWriter", "J"); LOG_FATAL_IF(sBackupDataOutput.mBackupwriter == NULL, "Unable to find mBackupWriter field in android.app.backup.BackupDataOutput"); diff --git a/core/jni/android_backup_BackupDataInput.cpp b/core/jni/android_backup_BackupDataInput.cpp index 25b0007fa15f..90763b0c4561 100644 --- a/core/jni/android_backup_BackupDataInput.cpp +++ b/core/jni/android_backup_BackupDataInput.cpp @@ -29,25 +29,25 @@ namespace android static jfieldID s_keyField = 0; static jfieldID s_dataSizeField = 0; -static int +static jlong ctor_native(JNIEnv* env, jobject clazz, jobject fileDescriptor) { int fd = jniGetFDFromFileDescriptor(env, fileDescriptor); if (fd == -1) { - return NULL; + return (jlong)NULL; } - return (int)new BackupDataReader(fd); + return (jlong)new BackupDataReader(fd); } static void -dtor_native(JNIEnv* env, jobject clazz, int r) +dtor_native(JNIEnv* env, jobject clazz, jlong r) { delete (BackupDataReader*)r; } static jint -readNextHeader_native(JNIEnv* env, jobject clazz, int r, jobject entity) +readNextHeader_native(JNIEnv* env, jobject clazz, jlong r, jobject entity) { int err; bool done; @@ -89,7 +89,7 @@ readNextHeader_native(JNIEnv* env, jobject clazz, int r, jobject entity) } static jint -readEntityData_native(JNIEnv* env, jobject clazz, int r, jbyteArray data, int offset, int size) +readEntityData_native(JNIEnv* env, jobject clazz, jlong r, jbyteArray data, jint offset, jint size) { int err; BackupDataReader* reader = (BackupDataReader*)r; @@ -112,7 +112,7 @@ readEntityData_native(JNIEnv* env, jobject clazz, int r, jbyteArray data, int of } static jint -skipEntityData_native(JNIEnv* env, jobject clazz, int r) +skipEntityData_native(JNIEnv* env, jobject clazz, jlong r) { int err; BackupDataReader* reader = (BackupDataReader*)r; @@ -123,12 +123,12 @@ skipEntityData_native(JNIEnv* env, jobject clazz, int r) } static const JNINativeMethod g_methods[] = { - { "ctor", "(Ljava/io/FileDescriptor;)I", (void*)ctor_native }, - { "dtor", "(I)V", (void*)dtor_native }, - { "readNextHeader_native", "(ILandroid/app/backup/BackupDataInput$EntityHeader;)I", + { "ctor", "(Ljava/io/FileDescriptor;)J", (void*)ctor_native }, + { "dtor", "(J)V", (void*)dtor_native }, + { "readNextHeader_native", "(JLandroid/app/backup/BackupDataInput$EntityHeader;)I", (void*)readNextHeader_native }, - { "readEntityData_native", "(I[BII)I", (void*)readEntityData_native }, - { "skipEntityData_native", "(I)I", (void*)skipEntityData_native }, + { "readEntityData_native", "(J[BII)I", (void*)readEntityData_native }, + { "skipEntityData_native", "(J)I", (void*)skipEntityData_native }, }; int register_android_backup_BackupDataInput(JNIEnv* env) diff --git a/core/jni/android_backup_BackupDataOutput.cpp b/core/jni/android_backup_BackupDataOutput.cpp index e8f0fb85e29b..8244e1bfdbf1 100644 --- a/core/jni/android_backup_BackupDataOutput.cpp +++ b/core/jni/android_backup_BackupDataOutput.cpp @@ -25,25 +25,25 @@ namespace android { -static int +static jlong ctor_native(JNIEnv* env, jobject clazz, jobject fileDescriptor) { int fd = jniGetFDFromFileDescriptor(env, fileDescriptor); if (fd == -1) { - return NULL; + return (jlong)NULL; } - return (int)new BackupDataWriter(fd); + return (jlong)new BackupDataWriter(fd); } static void -dtor_native(JNIEnv* env, jobject clazz, int w) +dtor_native(JNIEnv* env, jobject clazz, jlong w) { delete (BackupDataWriter*)w; } static jint -writeEntityHeader_native(JNIEnv* env, jobject clazz, int w, jstring key, int dataSize) +writeEntityHeader_native(JNIEnv* env, jobject clazz, jlong w, jstring key, jint dataSize) { int err; BackupDataWriter* writer = (BackupDataWriter*)w; @@ -56,11 +56,11 @@ writeEntityHeader_native(JNIEnv* env, jobject clazz, int w, jstring key, int dat env->ReleaseStringUTFChars(key, keyUTF); - return err; + return (jint)err; } static jint -writeEntityData_native(JNIEnv* env, jobject clazz, int w, jbyteArray data, int size) +writeEntityData_native(JNIEnv* env, jobject clazz, jlong w, jbyteArray data, jint size) { int err; BackupDataWriter* writer = (BackupDataWriter*)w; @@ -79,11 +79,11 @@ writeEntityData_native(JNIEnv* env, jobject clazz, int w, jbyteArray data, int s env->ReleaseByteArrayElements(data, dataBytes, JNI_ABORT); - return err; + return (jint)err; } static void -setKeyPrefix_native(JNIEnv* env, jobject clazz, int w, jstring keyPrefixObj) +setKeyPrefix_native(JNIEnv* env, jobject clazz, jlong w, jstring keyPrefixObj) { int err; BackupDataWriter* writer = (BackupDataWriter*)w; @@ -97,11 +97,11 @@ setKeyPrefix_native(JNIEnv* env, jobject clazz, int w, jstring keyPrefixObj) } static const JNINativeMethod g_methods[] = { - { "ctor", "(Ljava/io/FileDescriptor;)I", (void*)ctor_native }, - { "dtor", "(I)V", (void*)dtor_native }, - { "writeEntityHeader_native", "(ILjava/lang/String;I)I", (void*)writeEntityHeader_native }, - { "writeEntityData_native", "(I[BI)I", (void*)writeEntityData_native }, - { "setKeyPrefix_native", "(ILjava/lang/String;)V", (void*)setKeyPrefix_native }, + { "ctor", "(Ljava/io/FileDescriptor;)J", (void*)ctor_native }, + { "dtor", "(J)V", (void*)dtor_native }, + { "writeEntityHeader_native", "(JLjava/lang/String;I)I", (void*)writeEntityHeader_native }, + { "writeEntityData_native", "(J[BI)I", (void*)writeEntityData_native }, + { "setKeyPrefix_native", "(JLjava/lang/String;)V", (void*)setKeyPrefix_native }, }; int register_android_backup_BackupDataOutput(JNIEnv* env) diff --git a/core/jni/android_backup_BackupHelperDispatcher.cpp b/core/jni/android_backup_BackupHelperDispatcher.cpp index 3e366778a721..a8b7d440dcd2 100644 --- a/core/jni/android_backup_BackupHelperDispatcher.cpp +++ b/core/jni/android_backup_BackupHelperDispatcher.cpp @@ -40,7 +40,7 @@ struct chunk_header_v1 { static jfieldID s_chunkSizeField = 0; static jfieldID s_keyPrefixField = 0; -static int +static jint readHeader_native(JNIEnv* env, jobject clazz, jobject headerObj, jobject fdObj) { chunk_header_v1 flattenedHeader; @@ -52,7 +52,7 @@ readHeader_native(JNIEnv* env, jobject clazz, jobject headerObj, jobject fdObj) amt = read(fd, &flattenedHeader.headerSize, sizeof(flattenedHeader.headerSize)); if (amt != sizeof(flattenedHeader.headerSize)) { - return -1; + return (jint) -1; } int remainingHeader = flattenedHeader.headerSize - sizeof(flattenedHeader.headerSize); @@ -62,7 +62,7 @@ readHeader_native(JNIEnv* env, jobject clazz, jobject headerObj, jobject fdObj) if (remainingHeader > 0) { lseek(fd, remainingHeader, SEEK_CUR); // >0 means skip this chunk - return 1; + return (jint) 1; } } @@ -70,7 +70,7 @@ readHeader_native(JNIEnv* env, jobject clazz, jobject headerObj, jobject fdObj) sizeof(chunk_header_v1)-sizeof(flattenedHeader.headerSize)); if (amt <= 0) { ALOGW("Failed reading chunk header"); - return -1; + return (jint) -1; } remainingHeader -= sizeof(chunk_header_v1)-sizeof(flattenedHeader.headerSize); @@ -80,7 +80,7 @@ readHeader_native(JNIEnv* env, jobject clazz, jobject headerObj, jobject fdObj) if (remainingHeader > 0) { lseek(fd, remainingHeader, SEEK_CUR); // >0 means skip this chunk - return 1; + return (jint) 1; } } @@ -96,13 +96,13 @@ readHeader_native(JNIEnv* env, jobject clazz, jobject headerObj, jobject fdObj) remainingHeader < flattenedHeader.nameLength) { ALOGW("Malformed V1 header remainingHeader=%d dataSize=%d nameLength=%d", remainingHeader, flattenedHeader.dataSize, flattenedHeader.nameLength); - return -1; + return (jint) -1; } buf = keyPrefix.lockBuffer(flattenedHeader.nameLength); if (buf == NULL) { ALOGW("unable to allocate %d bytes", flattenedHeader.nameLength); - return -1; + return (jint) -1; } amt = read(fd, buf, flattenedHeader.nameLength); @@ -119,17 +119,17 @@ readHeader_native(JNIEnv* env, jobject clazz, jobject headerObj, jobject fdObj) env->SetIntField(headerObj, s_chunkSizeField, flattenedHeader.dataSize); env->SetObjectField(headerObj, s_keyPrefixField, env->NewStringUTF(keyPrefix.string())); - return 0; + return (jint) 0; } -static int +static jint skipChunk_native(JNIEnv* env, jobject clazz, jobject fdObj, jint bytesToSkip) { int fd = jniGetFDFromFileDescriptor(env, fdObj); lseek(fd, bytesToSkip, SEEK_CUR); - return 0; + return (jint) 0; } static int @@ -139,7 +139,7 @@ padding_len(int len) return len == 0 ? len : 4 - len; } -static int +static jint allocateHeader_native(JNIEnv* env, jobject clazz, jobject headerObj, jobject fdObj) { int pos; @@ -161,10 +161,10 @@ allocateHeader_native(JNIEnv* env, jobject clazz, jobject headerObj, jobject fdO lseek(fd, headerSize, SEEK_CUR); - return pos; + return (jint) pos; } -static int +static jint writeHeader_native(JNIEnv* env, jobject clazz, jobject headerObj, jobject fdObj, jint pos) { int err; @@ -188,26 +188,26 @@ writeHeader_native(JNIEnv* env, jobject clazz, jobject headerObj, jobject fdObj, lseek(fd, pos, SEEK_SET); err = write(fd, &header, sizeof(chunk_header_v1)); if (err != sizeof(chunk_header_v1)) { - return errno; + return (jint) errno; } buf = env->GetStringUTFChars(nameObj, NULL); err = write(fd, buf, header.nameLength); env->ReleaseStringUTFChars(nameObj, buf); if (err != header.nameLength) { - return errno; + return (jint) errno; } if (namePadding != 0) { int zero = 0; err = write(fd, &zero, namePadding); if (err != namePadding) { - return errno; + return (jint) errno; } } lseek(fd, prevPos, SEEK_SET); - return 0; + return (jint) 0; } static const JNINativeMethod g_methods[] = { diff --git a/core/jni/android_backup_FileBackupHelperBase.cpp b/core/jni/android_backup_FileBackupHelperBase.cpp index bb3a751ae8e6..66e3e9db3483 100644 --- a/core/jni/android_backup_FileBackupHelperBase.cpp +++ b/core/jni/android_backup_FileBackupHelperBase.cpp @@ -25,20 +25,20 @@ namespace android { -static int +static jlong ctor(JNIEnv* env, jobject clazz) { - return (int)new RestoreHelperBase(); + return (jlong)new RestoreHelperBase(); } static void -dtor(JNIEnv* env, jobject clazz, jint ptr) +dtor(JNIEnv* env, jobject clazz, jlong ptr) { delete (RestoreHelperBase*)ptr; } -static int -performBackup_native(JNIEnv* env, jobject clazz, jobject oldState, int data, +static jint +performBackup_native(JNIEnv* env, jobject clazz, jobject oldState, jlong data, jobject newState, jobjectArray files, jobjectArray keys) { int err; @@ -72,12 +72,12 @@ performBackup_native(JNIEnv* env, jobject clazz, jobject oldState, int data, } free(keysUTF); - return err; + return (jint) err; } -static int -writeFile_native(JNIEnv* env, jobject clazz, jint ptr, jstring filenameObj, int backupReaderPtr) +static jint +writeFile_native(JNIEnv* env, jobject clazz, jlong ptr, jstring filenameObj, jlong backupReaderPtr) { int err; RestoreHelperBase* restore = (RestoreHelperBase*)ptr; @@ -90,11 +90,11 @@ writeFile_native(JNIEnv* env, jobject clazz, jint ptr, jstring filenameObj, int env->ReleaseStringUTFChars(filenameObj, filename); - return err; + return (jint) err; } -static int -writeSnapshot_native(JNIEnv* env, jobject clazz, jint ptr, jobject fileDescriptor) +static jint +writeSnapshot_native(JNIEnv* env, jobject clazz, jlong ptr, jobject fileDescriptor) { int err; @@ -103,17 +103,17 @@ writeSnapshot_native(JNIEnv* env, jobject clazz, jint ptr, jobject fileDescripto err = restore->WriteSnapshot(fd); - return err; + return (jint) err; } static const JNINativeMethod g_methods[] = { - { "ctor", "()I", (void*)ctor }, - { "dtor", "(I)V", (void*)dtor }, + { "ctor", "()J", (void*)ctor }, + { "dtor", "(J)V", (void*)dtor }, { "performBackup_native", - "(Ljava/io/FileDescriptor;ILjava/io/FileDescriptor;[Ljava/lang/String;[Ljava/lang/String;)I", + "(Ljava/io/FileDescriptor;JLjava/io/FileDescriptor;[Ljava/lang/String;[Ljava/lang/String;)I", (void*)performBackup_native }, - { "writeFile_native", "(ILjava/lang/String;I)I", (void*)writeFile_native }, - { "writeSnapshot_native", "(ILjava/io/FileDescriptor;)I", (void*)writeSnapshot_native }, + { "writeFile_native", "(JLjava/lang/String;J)I", (void*)writeFile_native }, + { "writeSnapshot_native", "(JLjava/io/FileDescriptor;)I", (void*)writeSnapshot_native }, }; int register_android_backup_FileBackupHelperBase(JNIEnv* env) diff --git a/core/jni/android_database_CursorWindow.cpp b/core/jni/android_database_CursorWindow.cpp index ea02f537c0e7..67f387920f57 100644 --- a/core/jni/android_database_CursorWindow.cpp +++ b/core/jni/android_database_CursorWindow.cpp @@ -58,7 +58,7 @@ static void throwUnknownTypeException(JNIEnv * env, jint type) { jniThrowException(env, "java/lang/IllegalStateException", msg.string()); } -static jint nativeCreate(JNIEnv* env, jclass clazz, jstring nameObj, jint cursorWindowSize) { +static jlong nativeCreate(JNIEnv* env, jclass clazz, jstring nameObj, jint cursorWindowSize) { String8 name; const char* nameStr = env->GetStringUTFChars(nameObj, NULL); name.setTo(nameStr); @@ -73,10 +73,10 @@ static jint nativeCreate(JNIEnv* env, jclass clazz, jstring nameObj, jint cursor } LOG_WINDOW("nativeInitializeEmpty: window = %p", window); - return reinterpret_cast<jint>(window); + return reinterpret_cast<jlong>(window); } -static jint nativeCreateFromParcel(JNIEnv* env, jclass clazz, jobject parcelObj) { +static jlong nativeCreateFromParcel(JNIEnv* env, jclass clazz, jobject parcelObj) { Parcel* parcel = parcelForJavaObject(env, parcelObj); CursorWindow* window; @@ -88,10 +88,10 @@ static jint nativeCreateFromParcel(JNIEnv* env, jclass clazz, jobject parcelObj) LOG_WINDOW("nativeInitializeFromBinder: numRows = %d, numColumns = %d, window = %p", window->getNumRows(), window->getNumColumns(), window); - return reinterpret_cast<jint>(window); + return reinterpret_cast<jlong>(window); } -static void nativeDispose(JNIEnv* env, jclass clazz, jint windowPtr) { +static void nativeDispose(JNIEnv* env, jclass clazz, jlong windowPtr) { CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr); if (window) { LOG_WINDOW("Closing window %p", window); @@ -99,12 +99,12 @@ static void nativeDispose(JNIEnv* env, jclass clazz, jint windowPtr) { } } -static jstring nativeGetName(JNIEnv* env, jclass clazz, jint windowPtr) { +static jstring nativeGetName(JNIEnv* env, jclass clazz, jlong windowPtr) { CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr); return env->NewStringUTF(window->name().string()); } -static void nativeWriteToParcel(JNIEnv * env, jclass clazz, jint windowPtr, +static void nativeWriteToParcel(JNIEnv * env, jclass clazz, jlong windowPtr, jobject parcelObj) { CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr); Parcel* parcel = parcelForJavaObject(env, parcelObj); @@ -117,7 +117,7 @@ static void nativeWriteToParcel(JNIEnv * env, jclass clazz, jint windowPtr, } } -static void nativeClear(JNIEnv * env, jclass clazz, jint windowPtr) { +static void nativeClear(JNIEnv * env, jclass clazz, jlong windowPtr) { CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr); LOG_WINDOW("Clearing window %p", window); status_t status = window->clear(); @@ -126,30 +126,30 @@ static void nativeClear(JNIEnv * env, jclass clazz, jint windowPtr) { } } -static jint nativeGetNumRows(JNIEnv* env, jclass clazz, jint windowPtr) { +static jint nativeGetNumRows(JNIEnv* env, jclass clazz, jlong windowPtr) { CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr); return window->getNumRows(); } -static jboolean nativeSetNumColumns(JNIEnv* env, jclass clazz, jint windowPtr, +static jboolean nativeSetNumColumns(JNIEnv* env, jclass clazz, jlong windowPtr, jint columnNum) { CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr); status_t status = window->setNumColumns(columnNum); return status == OK; } -static jboolean nativeAllocRow(JNIEnv* env, jclass clazz, jint windowPtr) { +static jboolean nativeAllocRow(JNIEnv* env, jclass clazz, jlong windowPtr) { CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr); status_t status = window->allocRow(); return status == OK; } -static void nativeFreeLastRow(JNIEnv* env, jclass clazz, jint windowPtr) { +static void nativeFreeLastRow(JNIEnv* env, jclass clazz, jlong windowPtr) { CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr); window->freeLastRow(); } -static jint nativeGetType(JNIEnv* env, jclass clazz, jint windowPtr, +static jint nativeGetType(JNIEnv* env, jclass clazz, jlong windowPtr, jint row, jint column) { CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr); LOG_WINDOW("returning column type affinity for %d,%d from %p", row, column, window); @@ -164,7 +164,7 @@ static jint nativeGetType(JNIEnv* env, jclass clazz, jint windowPtr, return window->getFieldSlotType(fieldSlot); } -static jbyteArray nativeGetBlob(JNIEnv* env, jclass clazz, jint windowPtr, +static jbyteArray nativeGetBlob(JNIEnv* env, jclass clazz, jlong windowPtr, jint row, jint column) { CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr); LOG_WINDOW("Getting blob for %d,%d from %p", row, column, window); @@ -199,7 +199,7 @@ static jbyteArray nativeGetBlob(JNIEnv* env, jclass clazz, jint windowPtr, return NULL; } -static jstring nativeGetString(JNIEnv* env, jclass clazz, jint windowPtr, +static jstring nativeGetString(JNIEnv* env, jclass clazz, jlong windowPtr, jint row, jint column) { CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr); LOG_WINDOW("Getting string for %d,%d from %p", row, column, window); @@ -291,7 +291,7 @@ static void clearCharArrayBuffer(JNIEnv* env, jobject bufferObj) { } } -static void nativeCopyStringToBuffer(JNIEnv* env, jclass clazz, jint windowPtr, +static void nativeCopyStringToBuffer(JNIEnv* env, jclass clazz, jlong windowPtr, jint row, jint column, jobject bufferObj) { CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr); LOG_WINDOW("Copying string for %d,%d from %p", row, column, window); @@ -330,7 +330,7 @@ static void nativeCopyStringToBuffer(JNIEnv* env, jclass clazz, jint windowPtr, } } -static jlong nativeGetLong(JNIEnv* env, jclass clazz, jint windowPtr, +static jlong nativeGetLong(JNIEnv* env, jclass clazz, jlong windowPtr, jint row, jint column) { CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr); LOG_WINDOW("Getting long for %d,%d from %p", row, column, window); @@ -361,7 +361,7 @@ static jlong nativeGetLong(JNIEnv* env, jclass clazz, jint windowPtr, } } -static jdouble nativeGetDouble(JNIEnv* env, jclass clazz, jint windowPtr, +static jdouble nativeGetDouble(JNIEnv* env, jclass clazz, jlong windowPtr, jint row, jint column) { CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr); LOG_WINDOW("Getting double for %d,%d from %p", row, column, window); @@ -392,7 +392,7 @@ static jdouble nativeGetDouble(JNIEnv* env, jclass clazz, jint windowPtr, } } -static jboolean nativePutBlob(JNIEnv* env, jclass clazz, jint windowPtr, +static jboolean nativePutBlob(JNIEnv* env, jclass clazz, jlong windowPtr, jbyteArray valueObj, jint row, jint column) { CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr); jsize len = env->GetArrayLength(valueObj); @@ -410,7 +410,7 @@ static jboolean nativePutBlob(JNIEnv* env, jclass clazz, jint windowPtr, return true; } -static jboolean nativePutString(JNIEnv* env, jclass clazz, jint windowPtr, +static jboolean nativePutString(JNIEnv* env, jclass clazz, jlong windowPtr, jstring valueObj, jint row, jint column) { CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr); @@ -432,7 +432,7 @@ static jboolean nativePutString(JNIEnv* env, jclass clazz, jint windowPtr, return true; } -static jboolean nativePutLong(JNIEnv* env, jclass clazz, jint windowPtr, +static jboolean nativePutLong(JNIEnv* env, jclass clazz, jlong windowPtr, jlong value, jint row, jint column) { CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr); status_t status = window->putLong(row, column, value); @@ -446,7 +446,7 @@ static jboolean nativePutLong(JNIEnv* env, jclass clazz, jint windowPtr, return true; } -static jboolean nativePutDouble(JNIEnv* env, jclass clazz, jint windowPtr, +static jboolean nativePutDouble(JNIEnv* env, jclass clazz, jlong windowPtr, jdouble value, jint row, jint column) { CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr); status_t status = window->putDouble(row, column, value); @@ -460,7 +460,7 @@ static jboolean nativePutDouble(JNIEnv* env, jclass clazz, jint windowPtr, return true; } -static jboolean nativePutNull(JNIEnv* env, jclass clazz, jint windowPtr, +static jboolean nativePutNull(JNIEnv* env, jclass clazz, jlong windowPtr, jint row, jint column) { CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr); status_t status = window->putNull(row, column); @@ -477,47 +477,47 @@ static jboolean nativePutNull(JNIEnv* env, jclass clazz, jint windowPtr, static JNINativeMethod sMethods[] = { /* name, signature, funcPtr */ - { "nativeCreate", "(Ljava/lang/String;I)I", + { "nativeCreate", "(Ljava/lang/String;I)J", (void*)nativeCreate }, - { "nativeCreateFromParcel", "(Landroid/os/Parcel;)I", + { "nativeCreateFromParcel", "(Landroid/os/Parcel;)J", (void*)nativeCreateFromParcel }, - { "nativeDispose", "(I)V", + { "nativeDispose", "(J)V", (void*)nativeDispose }, - { "nativeWriteToParcel", "(ILandroid/os/Parcel;)V", + { "nativeWriteToParcel", "(JLandroid/os/Parcel;)V", (void*)nativeWriteToParcel }, - { "nativeGetName", "(I)Ljava/lang/String;", + { "nativeGetName", "(J)Ljava/lang/String;", (void*)nativeGetName }, - { "nativeClear", "(I)V", + { "nativeClear", "(J)V", (void*)nativeClear }, - { "nativeGetNumRows", "(I)I", + { "nativeGetNumRows", "(J)I", (void*)nativeGetNumRows }, - { "nativeSetNumColumns", "(II)Z", + { "nativeSetNumColumns", "(JI)Z", (void*)nativeSetNumColumns }, - { "nativeAllocRow", "(I)Z", + { "nativeAllocRow", "(J)Z", (void*)nativeAllocRow }, - { "nativeFreeLastRow", "(I)V", + { "nativeFreeLastRow", "(J)V", (void*)nativeFreeLastRow }, - { "nativeGetType", "(III)I", + { "nativeGetType", "(JII)I", (void*)nativeGetType }, - { "nativeGetBlob", "(III)[B", + { "nativeGetBlob", "(JII)[B", (void*)nativeGetBlob }, - { "nativeGetString", "(III)Ljava/lang/String;", + { "nativeGetString", "(JII)Ljava/lang/String;", (void*)nativeGetString }, - { "nativeGetLong", "(III)J", + { "nativeGetLong", "(JII)J", (void*)nativeGetLong }, - { "nativeGetDouble", "(III)D", + { "nativeGetDouble", "(JII)D", (void*)nativeGetDouble }, - { "nativeCopyStringToBuffer", "(IIILandroid/database/CharArrayBuffer;)V", + { "nativeCopyStringToBuffer", "(JIILandroid/database/CharArrayBuffer;)V", (void*)nativeCopyStringToBuffer }, - { "nativePutBlob", "(I[BII)Z", + { "nativePutBlob", "(J[BII)Z", (void*)nativePutBlob }, - { "nativePutString", "(ILjava/lang/String;II)Z", + { "nativePutString", "(JLjava/lang/String;II)Z", (void*)nativePutString }, - { "nativePutLong", "(IJII)Z", + { "nativePutLong", "(JJII)Z", (void*)nativePutLong }, - { "nativePutDouble", "(IDII)Z", + { "nativePutDouble", "(JDII)Z", (void*)nativePutDouble }, - { "nativePutNull", "(III)Z", + { "nativePutNull", "(JII)Z", (void*)nativePutNull }, }; diff --git a/core/jni/android_database_SQLiteConnection.cpp b/core/jni/android_database_SQLiteConnection.cpp index 6e496fd2281c..ae5643207d8c 100644 --- a/core/jni/android_database_SQLiteConnection.cpp +++ b/core/jni/android_database_SQLiteConnection.cpp @@ -109,7 +109,7 @@ static int sqliteProgressHandlerCallback(void* data) { } -static jint nativeOpen(JNIEnv* env, jclass clazz, jstring pathStr, jint openFlags, +static jlong nativeOpen(JNIEnv* env, jclass clazz, jstring pathStr, jint openFlags, jstring labelStr, jboolean enableTrace, jboolean enableProfile) { int sqliteFlags; if (openFlags & SQLiteConnection::CREATE_IF_NECESSARY) { @@ -170,10 +170,10 @@ static jint nativeOpen(JNIEnv* env, jclass clazz, jstring pathStr, jint openFlag } ALOGV("Opened connection %p with label '%s'", db, label.string()); - return reinterpret_cast<jint>(connection); + return reinterpret_cast<jlong>(connection); } -static void nativeClose(JNIEnv* env, jclass clazz, jint connectionPtr) { +static void nativeClose(JNIEnv* env, jclass clazz, jlong connectionPtr) { SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr); if (connection) { @@ -243,7 +243,7 @@ static void sqliteCustomFunctionDestructor(void* data) { env->DeleteGlobalRef(functionObjGlobal); } -static void nativeRegisterCustomFunction(JNIEnv* env, jclass clazz, jint connectionPtr, +static void nativeRegisterCustomFunction(JNIEnv* env, jclass clazz, jlong connectionPtr, jobject functionObj) { SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr); @@ -267,7 +267,7 @@ static void nativeRegisterCustomFunction(JNIEnv* env, jclass clazz, jint connect } } -static void nativeRegisterLocalizedCollators(JNIEnv* env, jclass clazz, jint connectionPtr, +static void nativeRegisterLocalizedCollators(JNIEnv* env, jclass clazz, jlong connectionPtr, jstring localeStr) { SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr); @@ -280,7 +280,7 @@ static void nativeRegisterLocalizedCollators(JNIEnv* env, jclass clazz, jint con } } -static jint nativePrepareStatement(JNIEnv* env, jclass clazz, jint connectionPtr, +static jlong nativePrepareStatement(JNIEnv* env, jclass clazz, jlong connectionPtr, jstring sqlString) { SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr); @@ -308,11 +308,11 @@ static jint nativePrepareStatement(JNIEnv* env, jclass clazz, jint connectionPtr } ALOGV("Prepared statement %p on connection %p", statement, connection->db); - return reinterpret_cast<jint>(statement); + return reinterpret_cast<jlong>(statement); } -static void nativeFinalizeStatement(JNIEnv* env, jclass clazz, jint connectionPtr, - jint statementPtr) { +static void nativeFinalizeStatement(JNIEnv* env, jclass clazz, jlong connectionPtr, + jlong statementPtr) { SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr); sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr); @@ -323,32 +323,32 @@ static void nativeFinalizeStatement(JNIEnv* env, jclass clazz, jint connectionPt sqlite3_finalize(statement); } -static jint nativeGetParameterCount(JNIEnv* env, jclass clazz, jint connectionPtr, - jint statementPtr) { +static jint nativeGetParameterCount(JNIEnv* env, jclass clazz, jlong connectionPtr, + jlong statementPtr) { SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr); sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr); return sqlite3_bind_parameter_count(statement); } -static jboolean nativeIsReadOnly(JNIEnv* env, jclass clazz, jint connectionPtr, - jint statementPtr) { +static jboolean nativeIsReadOnly(JNIEnv* env, jclass clazz, jlong connectionPtr, + jlong statementPtr) { SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr); sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr); return sqlite3_stmt_readonly(statement) != 0; } -static jint nativeGetColumnCount(JNIEnv* env, jclass clazz, jint connectionPtr, - jint statementPtr) { +static jint nativeGetColumnCount(JNIEnv* env, jclass clazz, jlong connectionPtr, + jlong statementPtr) { SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr); sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr); return sqlite3_column_count(statement); } -static jstring nativeGetColumnName(JNIEnv* env, jclass clazz, jint connectionPtr, - jint statementPtr, jint index) { +static jstring nativeGetColumnName(JNIEnv* env, jclass clazz, jlong connectionPtr, + jlong statementPtr, jint index) { SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr); sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr); @@ -363,8 +363,8 @@ static jstring nativeGetColumnName(JNIEnv* env, jclass clazz, jint connectionPtr return NULL; } -static void nativeBindNull(JNIEnv* env, jclass clazz, jint connectionPtr, - jint statementPtr, jint index) { +static void nativeBindNull(JNIEnv* env, jclass clazz, jlong connectionPtr, + jlong statementPtr, jint index) { SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr); sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr); @@ -374,8 +374,8 @@ static void nativeBindNull(JNIEnv* env, jclass clazz, jint connectionPtr, } } -static void nativeBindLong(JNIEnv* env, jclass clazz, jint connectionPtr, - jint statementPtr, jint index, jlong value) { +static void nativeBindLong(JNIEnv* env, jclass clazz, jlong connectionPtr, + jlong statementPtr, jint index, jlong value) { SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr); sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr); @@ -385,8 +385,8 @@ static void nativeBindLong(JNIEnv* env, jclass clazz, jint connectionPtr, } } -static void nativeBindDouble(JNIEnv* env, jclass clazz, jint connectionPtr, - jint statementPtr, jint index, jdouble value) { +static void nativeBindDouble(JNIEnv* env, jclass clazz, jlong connectionPtr, + jlong statementPtr, jint index, jdouble value) { SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr); sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr); @@ -396,8 +396,8 @@ static void nativeBindDouble(JNIEnv* env, jclass clazz, jint connectionPtr, } } -static void nativeBindString(JNIEnv* env, jclass clazz, jint connectionPtr, - jint statementPtr, jint index, jstring valueString) { +static void nativeBindString(JNIEnv* env, jclass clazz, jlong connectionPtr, + jlong statementPtr, jint index, jstring valueString) { SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr); sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr); @@ -411,8 +411,8 @@ static void nativeBindString(JNIEnv* env, jclass clazz, jint connectionPtr, } } -static void nativeBindBlob(JNIEnv* env, jclass clazz, jint connectionPtr, - jint statementPtr, jint index, jbyteArray valueArray) { +static void nativeBindBlob(JNIEnv* env, jclass clazz, jlong connectionPtr, + jlong statementPtr, jint index, jbyteArray valueArray) { SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr); sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr); @@ -425,8 +425,8 @@ static void nativeBindBlob(JNIEnv* env, jclass clazz, jint connectionPtr, } } -static void nativeResetStatementAndClearBindings(JNIEnv* env, jclass clazz, jint connectionPtr, - jint statementPtr) { +static void nativeResetStatementAndClearBindings(JNIEnv* env, jclass clazz, jlong connectionPtr, + jlong statementPtr) { SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr); sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr); @@ -450,8 +450,8 @@ static int executeNonQuery(JNIEnv* env, SQLiteConnection* connection, sqlite3_st return err; } -static void nativeExecute(JNIEnv* env, jclass clazz, jint connectionPtr, - jint statementPtr) { +static void nativeExecute(JNIEnv* env, jclass clazz, jlong connectionPtr, + jlong statementPtr) { SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr); sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr); @@ -459,7 +459,7 @@ static void nativeExecute(JNIEnv* env, jclass clazz, jint connectionPtr, } static jint nativeExecuteForChangedRowCount(JNIEnv* env, jclass clazz, - jint connectionPtr, jint statementPtr) { + jlong connectionPtr, jlong statementPtr) { SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr); sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr); @@ -468,7 +468,7 @@ static jint nativeExecuteForChangedRowCount(JNIEnv* env, jclass clazz, } static jlong nativeExecuteForLastInsertedRowId(JNIEnv* env, jclass clazz, - jint connectionPtr, jint statementPtr) { + jlong connectionPtr, jlong statementPtr) { SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr); sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr); @@ -486,7 +486,7 @@ static int executeOneRowQuery(JNIEnv* env, SQLiteConnection* connection, sqlite3 } static jlong nativeExecuteForLong(JNIEnv* env, jclass clazz, - jint connectionPtr, jint statementPtr) { + jlong connectionPtr, jlong statementPtr) { SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr); sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr); @@ -498,7 +498,7 @@ static jlong nativeExecuteForLong(JNIEnv* env, jclass clazz, } static jstring nativeExecuteForString(JNIEnv* env, jclass clazz, - jint connectionPtr, jint statementPtr) { + jlong connectionPtr, jlong statementPtr) { SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr); sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr); @@ -548,7 +548,7 @@ static int createAshmemRegionWithData(JNIEnv* env, const void* data, size_t leng } static jint nativeExecuteForBlobFileDescriptor(JNIEnv* env, jclass clazz, - jint connectionPtr, jint statementPtr) { + jlong connectionPtr, jlong statementPtr) { SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr); sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr); @@ -665,7 +665,7 @@ static CopyRowResult copyRow(JNIEnv* env, CursorWindow* window, } static jlong nativeExecuteForCursorWindow(JNIEnv* env, jclass clazz, - jint connectionPtr, jint statementPtr, jint windowPtr, + jlong connectionPtr, jlong statementPtr, jlong windowPtr, jint startPos, jint requiredPos, jboolean countAllRows) { SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr); sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr); @@ -760,7 +760,7 @@ static jlong nativeExecuteForCursorWindow(JNIEnv* env, jclass clazz, return result; } -static jint nativeGetDbLookaside(JNIEnv* env, jobject clazz, jint connectionPtr) { +static jint nativeGetDbLookaside(JNIEnv* env, jobject clazz, jlong connectionPtr) { SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr); int cur = -1; @@ -769,12 +769,12 @@ static jint nativeGetDbLookaside(JNIEnv* env, jobject clazz, jint connectionPtr) return cur; } -static void nativeCancel(JNIEnv* env, jobject clazz, jint connectionPtr) { +static void nativeCancel(JNIEnv* env, jobject clazz, jlong connectionPtr) { SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr); connection->canceled = true; } -static void nativeResetCancel(JNIEnv* env, jobject clazz, jint connectionPtr, +static void nativeResetCancel(JNIEnv* env, jobject clazz, jlong connectionPtr, jboolean cancelable) { SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr); connection->canceled = false; @@ -791,57 +791,57 @@ static void nativeResetCancel(JNIEnv* env, jobject clazz, jint connectionPtr, static JNINativeMethod sMethods[] = { /* name, signature, funcPtr */ - { "nativeOpen", "(Ljava/lang/String;ILjava/lang/String;ZZ)I", + { "nativeOpen", "(Ljava/lang/String;ILjava/lang/String;ZZ)J", (void*)nativeOpen }, - { "nativeClose", "(I)V", + { "nativeClose", "(J)V", (void*)nativeClose }, - { "nativeRegisterCustomFunction", "(ILandroid/database/sqlite/SQLiteCustomFunction;)V", + { "nativeRegisterCustomFunction", "(JLandroid/database/sqlite/SQLiteCustomFunction;)V", (void*)nativeRegisterCustomFunction }, - { "nativeRegisterLocalizedCollators", "(ILjava/lang/String;)V", + { "nativeRegisterLocalizedCollators", "(JLjava/lang/String;)V", (void*)nativeRegisterLocalizedCollators }, - { "nativePrepareStatement", "(ILjava/lang/String;)I", + { "nativePrepareStatement", "(JLjava/lang/String;)J", (void*)nativePrepareStatement }, - { "nativeFinalizeStatement", "(II)V", + { "nativeFinalizeStatement", "(JJ)V", (void*)nativeFinalizeStatement }, - { "nativeGetParameterCount", "(II)I", + { "nativeGetParameterCount", "(JJ)I", (void*)nativeGetParameterCount }, - { "nativeIsReadOnly", "(II)Z", + { "nativeIsReadOnly", "(JJ)Z", (void*)nativeIsReadOnly }, - { "nativeGetColumnCount", "(II)I", + { "nativeGetColumnCount", "(JJ)I", (void*)nativeGetColumnCount }, - { "nativeGetColumnName", "(III)Ljava/lang/String;", + { "nativeGetColumnName", "(JJI)Ljava/lang/String;", (void*)nativeGetColumnName }, - { "nativeBindNull", "(III)V", + { "nativeBindNull", "(JJI)V", (void*)nativeBindNull }, - { "nativeBindLong", "(IIIJ)V", + { "nativeBindLong", "(JJIJ)V", (void*)nativeBindLong }, - { "nativeBindDouble", "(IIID)V", + { "nativeBindDouble", "(JJID)V", (void*)nativeBindDouble }, - { "nativeBindString", "(IIILjava/lang/String;)V", + { "nativeBindString", "(JJILjava/lang/String;)V", (void*)nativeBindString }, - { "nativeBindBlob", "(III[B)V", + { "nativeBindBlob", "(JJI[B)V", (void*)nativeBindBlob }, - { "nativeResetStatementAndClearBindings", "(II)V", + { "nativeResetStatementAndClearBindings", "(JJ)V", (void*)nativeResetStatementAndClearBindings }, - { "nativeExecute", "(II)V", + { "nativeExecute", "(JJ)V", (void*)nativeExecute }, - { "nativeExecuteForLong", "(II)J", + { "nativeExecuteForLong", "(JJ)J", (void*)nativeExecuteForLong }, - { "nativeExecuteForString", "(II)Ljava/lang/String;", + { "nativeExecuteForString", "(JJ)Ljava/lang/String;", (void*)nativeExecuteForString }, - { "nativeExecuteForBlobFileDescriptor", "(II)I", + { "nativeExecuteForBlobFileDescriptor", "(JJ)I", (void*)nativeExecuteForBlobFileDescriptor }, - { "nativeExecuteForChangedRowCount", "(II)I", + { "nativeExecuteForChangedRowCount", "(JJ)I", (void*)nativeExecuteForChangedRowCount }, - { "nativeExecuteForLastInsertedRowId", "(II)J", + { "nativeExecuteForLastInsertedRowId", "(JJ)J", (void*)nativeExecuteForLastInsertedRowId }, - { "nativeExecuteForCursorWindow", "(IIIIIZ)J", + { "nativeExecuteForCursorWindow", "(JJJIIZ)J", (void*)nativeExecuteForCursorWindow }, - { "nativeGetDbLookaside", "(I)I", + { "nativeGetDbLookaside", "(J)I", (void*)nativeGetDbLookaside }, - { "nativeCancel", "(I)V", + { "nativeCancel", "(J)V", (void*)nativeCancel }, - { "nativeResetCancel", "(IZ)V", + { "nativeResetCancel", "(JZ)V", (void*)nativeResetCancel }, }; diff --git a/core/jni/android_hardware_Camera.cpp b/core/jni/android_hardware_Camera.cpp index 09d8d0f3de2b..58b61baa4318 100644 --- a/core/jni/android_hardware_Camera.cpp +++ b/core/jni/android_hardware_Camera.cpp @@ -113,7 +113,7 @@ sp<Camera> get_native_camera(JNIEnv *env, jobject thiz, JNICameraContext** pCont { sp<Camera> camera; Mutex::Autolock _l(sLock); - JNICameraContext* context = reinterpret_cast<JNICameraContext*>(env->GetIntField(thiz, fields.context)); + JNICameraContext* context = reinterpret_cast<JNICameraContext*>(env->GetLongField(thiz, fields.context)); if (context != NULL) { camera = context->getCamera(); } @@ -500,7 +500,7 @@ static void android_hardware_Camera_native_setup(JNIEnv *env, jobject thiz, camera->setListener(context); // save context in opaque field - env->SetIntField(thiz, fields.context, (int)context.get()); + env->SetLongField(thiz, fields.context, (jlong)context.get()); } // disconnect from camera service @@ -515,10 +515,10 @@ static void android_hardware_Camera_release(JNIEnv *env, jobject thiz) sp<Camera> camera; { Mutex::Autolock _l(sLock); - context = reinterpret_cast<JNICameraContext*>(env->GetIntField(thiz, fields.context)); + context = reinterpret_cast<JNICameraContext*>(env->GetLongField(thiz, fields.context)); // Make sure we do not attempt to callback on a deleted Java object. - env->SetIntField(thiz, fields.context, 0); + env->SetLongField(thiz, fields.context, 0); } // clean up if release has not been called before @@ -627,13 +627,13 @@ static void android_hardware_Camera_stopPreview(JNIEnv *env, jobject thiz) c->stopPreview(); } -static bool android_hardware_Camera_previewEnabled(JNIEnv *env, jobject thiz) +static jboolean android_hardware_Camera_previewEnabled(JNIEnv *env, jobject thiz) { ALOGV("previewEnabled"); sp<Camera> c = get_native_camera(env, thiz, NULL); - if (c == 0) return false; + if (c == 0) return JNI_FALSE; - return c->previewEnabled(); + return c->previewEnabled() ? JNI_TRUE : JNI_FALSE; } static void android_hardware_Camera_setHasPreviewCallback(JNIEnv *env, jobject thiz, jboolean installed, jboolean manualBuffer) @@ -651,10 +651,10 @@ static void android_hardware_Camera_setHasPreviewCallback(JNIEnv *env, jobject t context->setCallbackMode(env, installed, manualBuffer); } -static void android_hardware_Camera_addCallbackBuffer(JNIEnv *env, jobject thiz, jbyteArray bytes, int msgType) { +static void android_hardware_Camera_addCallbackBuffer(JNIEnv *env, jobject thiz, jbyteArray bytes, jint msgType) { ALOGV("addCallbackBuffer: 0x%x", msgType); - JNICameraContext* context = reinterpret_cast<JNICameraContext*>(env->GetIntField(thiz, fields.context)); + JNICameraContext* context = reinterpret_cast<JNICameraContext*>(env->GetLongField(thiz, fields.context)); if (context != NULL) { context->addCallbackBuffer(env, bytes, msgType); @@ -685,7 +685,7 @@ static void android_hardware_Camera_cancelAutoFocus(JNIEnv *env, jobject thiz) } } -static void android_hardware_Camera_takePicture(JNIEnv *env, jobject thiz, int msgType) +static void android_hardware_Camera_takePicture(JNIEnv *env, jobject thiz, jint msgType) { ALOGV("takePicture"); JNICameraContext* context; @@ -999,7 +999,7 @@ static int find_fields(JNIEnv *env, field *fields, int count) int register_android_hardware_Camera(JNIEnv *env) { field fields_to_find[] = { - { "android/hardware/Camera", "mNativeContext", "I", &fields.context }, + { "android/hardware/Camera", "mNativeContext", "J", &fields.context }, { "android/hardware/Camera$CameraInfo", "facing", "I", &fields.facing }, { "android/hardware/Camera$CameraInfo", "orientation", "I", &fields.orientation }, { "android/hardware/Camera$CameraInfo", "canDisableShutterSound", "Z", diff --git a/core/jni/android_hardware_SensorManager.cpp b/core/jni/android_hardware_SensorManager.cpp index 793d1bf93a99..24e0b0a5b9a4 100644 --- a/core/jni/android_hardware_SensorManager.cpp +++ b/core/jni/android_hardware_SensorManager.cpp @@ -187,7 +187,7 @@ private: } }; -static jint nativeInitSensorEventQueue(JNIEnv *env, jclass clazz, jobject eventQ, jobject msgQ, jfloatArray scratch) { +static jlong nativeInitSensorEventQueue(JNIEnv *env, jclass clazz, jobject eventQ, jobject msgQ, jfloatArray scratch) { SensorManager& mgr(SensorManager::getInstance()); sp<SensorEventQueue> queue(mgr.createEventQueue()); @@ -199,28 +199,28 @@ static jint nativeInitSensorEventQueue(JNIEnv *env, jclass clazz, jobject eventQ sp<Receiver> receiver = new Receiver(queue, messageQueue, eventQ, scratch); receiver->incStrong((void*)nativeInitSensorEventQueue); - return jint(receiver.get()); + return jlong(receiver.get()); } -static jint nativeEnableSensor(JNIEnv *env, jclass clazz, jint eventQ, jint handle, jint rate_us, +static jint nativeEnableSensor(JNIEnv *env, jclass clazz, jlong eventQ, jint handle, jint rate_us, jint maxBatchReportLatency, jint reservedFlags) { sp<Receiver> receiver(reinterpret_cast<Receiver *>(eventQ)); return receiver->getSensorEventQueue()->enableSensor(handle, rate_us, maxBatchReportLatency, reservedFlags); } -static jint nativeDisableSensor(JNIEnv *env, jclass clazz, jint eventQ, jint handle) { +static jint nativeDisableSensor(JNIEnv *env, jclass clazz, jlong eventQ, jint handle) { sp<Receiver> receiver(reinterpret_cast<Receiver *>(eventQ)); return receiver->getSensorEventQueue()->disableSensor(handle); } -static void nativeDestroySensorEventQueue(JNIEnv *env, jclass clazz, jint eventQ, jint handle) { +static void nativeDestroySensorEventQueue(JNIEnv *env, jclass clazz, jlong eventQ, jint handle) { sp<Receiver> receiver(reinterpret_cast<Receiver *>(eventQ)); receiver->destroy(); receiver->decStrong((void*)nativeInitSensorEventQueue); } -static jint nativeFlushSensor(JNIEnv *env, jclass clazz, jint eventQ) { +static jint nativeFlushSensor(JNIEnv *env, jclass clazz, jlong eventQ) { sp<Receiver> receiver(reinterpret_cast<Receiver *>(eventQ)); return receiver->getSensorEventQueue()->flush(); } @@ -239,23 +239,23 @@ static JNINativeMethod gSystemSensorManagerMethods[] = { static JNINativeMethod gBaseEventQueueMethods[] = { {"nativeInitBaseEventQueue", - "(Landroid/hardware/SystemSensorManager$BaseEventQueue;Landroid/os/MessageQueue;[F)I", + "(Landroid/hardware/SystemSensorManager$BaseEventQueue;Landroid/os/MessageQueue;[F)J", (void*)nativeInitSensorEventQueue }, {"nativeEnableSensor", - "(IIIII)I", + "(JIIII)I", (void*)nativeEnableSensor }, {"nativeDisableSensor", - "(II)I", + "(JI)I", (void*)nativeDisableSensor }, {"nativeDestroySensorEventQueue", - "(I)V", + "(J)V", (void*)nativeDestroySensorEventQueue }, {"nativeFlushSensor", - "(I)I", + "(J)I", (void*)nativeFlushSensor }, }; diff --git a/core/jni/android_hardware_UsbDeviceConnection.cpp b/core/jni/android_hardware_UsbDeviceConnection.cpp index cea5bbf92656..c10b963f578f 100644 --- a/core/jni/android_hardware_UsbDeviceConnection.cpp +++ b/core/jni/android_hardware_UsbDeviceConnection.cpp @@ -35,7 +35,7 @@ static jfieldID field_context; struct usb_device* get_device_from_object(JNIEnv* env, jobject connection) { - return (struct usb_device*)env->GetIntField(connection, field_context); + return (struct usb_device*)env->GetLongField(connection, field_context); } static jboolean @@ -46,19 +46,19 @@ android_hardware_UsbDeviceConnection_open(JNIEnv *env, jobject thiz, jstring dev // duplicate the file descriptor, since ParcelFileDescriptor will eventually close its copy fd = dup(fd); if (fd < 0) - return false; + return JNI_FALSE; const char *deviceNameStr = env->GetStringUTFChars(deviceName, NULL); struct usb_device* device = usb_device_new(deviceNameStr, fd); if (device) { - env->SetIntField(thiz, field_context, (int)device); + env->SetLongField(thiz, field_context, (jlong)device); } else { ALOGE("usb_device_open failed for %s", deviceNameStr); close(fd); } env->ReleaseStringUTFChars(deviceName, deviceNameStr); - return (device != NULL); + return (device != NULL) ? JNI_TRUE : JNI_FALSE; } static void @@ -68,7 +68,7 @@ android_hardware_UsbDeviceConnection_close(JNIEnv *env, jobject thiz) struct usb_device* device = get_device_from_object(env, thiz); if (device) { usb_device_close(device); - env->SetIntField(thiz, field_context, 0); + env->SetLongField(thiz, field_context, 0); } } @@ -106,12 +106,12 @@ android_hardware_UsbDeviceConnection_get_desc(JNIEnv *env, jobject thiz) static jboolean android_hardware_UsbDeviceConnection_claim_interface(JNIEnv *env, jobject thiz, - int interfaceID, jboolean force) + jint interfaceID, jboolean force) { struct usb_device* device = get_device_from_object(env, thiz); if (!device) { ALOGE("device is closed in native_claim_interface"); - return -1; + return JNI_FALSE; } int ret = usb_device_claim_interface(device, interfaceID); @@ -120,11 +120,11 @@ android_hardware_UsbDeviceConnection_claim_interface(JNIEnv *env, jobject thiz, usb_device_connect_kernel_driver(device, interfaceID, false); ret = usb_device_claim_interface(device, interfaceID); } - return ret == 0; + return (ret == 0) ? JNI_TRUE : JNI_FALSE; } static jint -android_hardware_UsbDeviceConnection_release_interface(JNIEnv *env, jobject thiz, int interfaceID) +android_hardware_UsbDeviceConnection_release_interface(JNIEnv *env, jobject thiz, jint interfaceID) { struct usb_device* device = get_device_from_object(env, thiz); if (!device) { @@ -246,7 +246,7 @@ int register_android_hardware_UsbDeviceConnection(JNIEnv *env) ALOGE("Can't find android/hardware/usb/UsbDeviceConnection"); return -1; } - field_context = env->GetFieldID(clazz, "mNativeContext", "I"); + field_context = env->GetFieldID(clazz, "mNativeContext", "J"); if (field_context == NULL) { ALOGE("Can't find UsbDeviceConnection.mNativeContext"); return -1; diff --git a/core/jni/android_hardware_UsbRequest.cpp b/core/jni/android_hardware_UsbRequest.cpp index 32d5135055ae..01eaec48e663 100644 --- a/core/jni/android_hardware_UsbRequest.cpp +++ b/core/jni/android_hardware_UsbRequest.cpp @@ -32,7 +32,7 @@ static jfieldID field_context; struct usb_request* get_request_from_object(JNIEnv* env, jobject java_request) { - return (struct usb_request*)env->GetIntField(java_request, field_context); + return (struct usb_request*)env->GetLongField(java_request, field_context); } // in android_hardware_UsbDeviceConnection.cpp @@ -61,7 +61,7 @@ android_hardware_UsbRequest_init(JNIEnv *env, jobject thiz, jobject java_device, struct usb_request* request = usb_request_new(device, &desc); if (request) - env->SetIntField(thiz, field_context, (int)request); + env->SetLongField(thiz, field_context, (jlong)request); return (request != NULL); } @@ -72,7 +72,7 @@ android_hardware_UsbRequest_close(JNIEnv *env, jobject thiz) struct usb_request* request = get_request_from_object(env, thiz); if (request) { usb_request_free(request); - env->SetIntField(thiz, field_context, 0); + env->SetLongField(thiz, field_context, 0); } } @@ -114,14 +114,14 @@ android_hardware_UsbRequest_queue_array(JNIEnv *env, jobject thiz, } } -static int +static jint android_hardware_UsbRequest_dequeue_array(JNIEnv *env, jobject thiz, jbyteArray buffer, jint length, jboolean out) { struct usb_request* request = get_request_from_object(env, thiz); if (!request) { ALOGE("request is closed in native_dequeue"); - return -1; + return (jint) -1; } if (buffer && length && request->buffer && !out) { @@ -130,7 +130,7 @@ android_hardware_UsbRequest_dequeue_array(JNIEnv *env, jobject thiz, } free(request->buffer); env->DeleteGlobalRef((jobject)request->client_data); - return request->actual_length; + return (jint) request->actual_length; } static jboolean @@ -164,17 +164,17 @@ android_hardware_UsbRequest_queue_direct(JNIEnv *env, jobject thiz, } } -static int +static jint android_hardware_UsbRequest_dequeue_direct(JNIEnv *env, jobject thiz) { struct usb_request* request = get_request_from_object(env, thiz); if (!request) { ALOGE("request is closed in native_dequeue"); - return -1; + return (jint) -1; } // all we need to do is delete our global ref env->DeleteGlobalRef((jobject)request->client_data); - return request->actual_length; + return (jint) request->actual_length; } static jboolean @@ -207,7 +207,7 @@ int register_android_hardware_UsbRequest(JNIEnv *env) ALOGE("Can't find android/hardware/usb/UsbRequest"); return -1; } - field_context = env->GetFieldID(clazz, "mNativeContext", "I"); + field_context = env->GetFieldID(clazz, "mNativeContext", "J"); if (field_context == NULL) { ALOGE("Can't find UsbRequest.mNativeContext"); return -1; diff --git a/core/jni/android_media_AudioSystem.cpp b/core/jni/android_media_AudioSystem.cpp index 7d99464d0bbb..f6f7030ffe67 100644 --- a/core/jni/android_media_AudioSystem.cpp +++ b/core/jni/android_media_AudioSystem.cpp @@ -100,7 +100,7 @@ android_media_AudioSystem_setParameters(JNIEnv *env, jobject thiz, jstring keyVa c_keyValuePairs8 = String8(c_keyValuePairs, env->GetStringLength(keyValuePairs)); env->ReleaseStringCritical(keyValuePairs, c_keyValuePairs); } - int status = check_AudioSystem_Command(AudioSystem::setParameters(0, c_keyValuePairs8)); + int status = check_AudioSystem_Command(AudioSystem::setParameters(c_keyValuePairs8)); return status; } @@ -113,7 +113,7 @@ android_media_AudioSystem_getParameters(JNIEnv *env, jobject thiz, jstring keys) c_keys8 = String8(c_keys, env->GetStringLength(keys)); env->ReleaseStringCritical(keys, c_keys); } - return env->NewStringUTF(AudioSystem::getParameters(0, c_keys8).string()); + return env->NewStringUTF(AudioSystem::getParameters(c_keys8).string()); } static void diff --git a/core/jni/android_view_RemoteGLRenderer.cpp b/core/jni/android_view_RemoteGLRenderer.cpp new file mode 100644 index 000000000000..96a203b9ef8e --- /dev/null +++ b/core/jni/android_view_RemoteGLRenderer.cpp @@ -0,0 +1,99 @@ +/* + * Copyright (C) 2014 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#define LOG_TAG "RemoteGLRenderer" + +#include "jni.h" +#include <nativehelper/JNIHelp.h> + +#include <utils/StrongPointer.h> +#include <android_runtime/android_view_Surface.h> +#include <android_runtime/AndroidRuntime.h> +#include <renderthread/CanvasContext.h> +#include <system/window.h> + +namespace android { + +#ifdef USE_OPENGL_RENDERER + +#define CHECK_CONTEXT(c) if (!c) ALOGE("Null context passed to %s!", __func__ ) + +namespace RT = android::uirenderer::renderthread; + +static jlong android_view_RemoteGLRenderer_createContext(JNIEnv* env, jobject clazz) { + RT::CanvasContext* context = new RT::CanvasContext(); + return reinterpret_cast<jlong>(context); +} + +static jboolean android_view_RemoteGLRenderer_usePBufferSurface(JNIEnv* env, jobject clazz) { + return RT::CanvasContext::useGlobalPBufferSurface(); +} + +static jboolean android_view_RemoteGLRenderer_setSurface(JNIEnv* env, jobject clazz, + jlong jcontextptr, jobject jsurface) { + RT::CanvasContext* context = reinterpret_cast<RT::CanvasContext*>(jcontextptr); + CHECK_CONTEXT(context); + sp<ANativeWindow> window; + if (jsurface) { + window = android_view_Surface_getNativeWindow(env, jsurface); + } + return context->setSurface(window.get()); +} + +static jboolean android_view_RemoteGLRenderer_swapBuffers(JNIEnv* env, jobject clazz, + jlong jcontextptr) { + RT::CanvasContext* context = reinterpret_cast<RT::CanvasContext*>(jcontextptr); + CHECK_CONTEXT(context); + return context->swapBuffers(); +} + +static jboolean android_view_RemoteGLRenderer_makeCurrent(JNIEnv* env, jobject clazz, + jlong jcontextptr) { + RT::CanvasContext* context = reinterpret_cast<RT::CanvasContext*>(jcontextptr); + CHECK_CONTEXT(context); + return context->makeCurrent(); +} + +static void android_view_RemoteGLRenderer_destroyContext(JNIEnv* env, jobject clazz, + jlong jcontextptr) { + RT::CanvasContext* context = reinterpret_cast<RT::CanvasContext*>(jcontextptr); + CHECK_CONTEXT(context); + delete context; +} +#endif + +// ---------------------------------------------------------------------------- +// JNI Glue +// ---------------------------------------------------------------------------- + +const char* const kClassPathName = "android/view/RemoteGLRenderer"; + +static JNINativeMethod gMethods[] = { +#ifdef USE_OPENGL_RENDERER + { "createContext", "()J", (void*) android_view_RemoteGLRenderer_createContext }, + { "usePBufferSurface", "()Z", (void*) android_view_RemoteGLRenderer_usePBufferSurface }, + { "setSurface", "(JLandroid/view/Surface;)Z", (void*) android_view_RemoteGLRenderer_setSurface }, + { "swapBuffers", "(J)Z", (void*) android_view_RemoteGLRenderer_swapBuffers }, + { "makeCurrent", "(J)Z", (void*) android_view_RemoteGLRenderer_makeCurrent }, + { "destroyContext", "(J)V", (void*) android_view_RemoteGLRenderer_destroyContext }, +#endif +}; + +int register_android_view_RemoteGLRenderer(JNIEnv* env) { + return AndroidRuntime::registerNativeMethods(env, kClassPathName, gMethods, NELEM(gMethods)); +} + +}; // namespace android diff --git a/core/jni/android_view_ThreadedRenderer.cpp b/core/jni/android_view_ThreadedRenderer.cpp index 8bb6cb4ca314..8d77e3615dba 100644 --- a/core/jni/android_view_ThreadedRenderer.cpp +++ b/core/jni/android_view_ThreadedRenderer.cpp @@ -14,7 +14,7 @@ * limitations under the License. */ -#define LOG_TAG "GLRenderer" +#define LOG_TAG "ThreadedRenderer" #include "jni.h" #include <nativehelper/JNIHelp.h> diff --git a/core/res/res/values-mcc302-mnc510/config.xml b/core/res/res/values-mcc302-mnc510/config.xml deleted file mode 100644 index 706570c0bd6b..000000000000 --- a/core/res/res/values-mcc302-mnc510/config.xml +++ /dev/null @@ -1,25 +0,0 @@ -<?xml version="1.0" encoding="utf-8"?> -<!-- -/* -** Copyright 2013, The Android Open Source Project -** -** Licensed under the Apache License, Version 2.0 (the "License"); -** you may not use this file except in compliance with the License. -** You may obtain a copy of the License at -** -** http://www.apache.org/licenses/LICENSE-2.0 -** -** Unless required by applicable law or agreed to in writing, software -** distributed under the License is distributed on an "AS IS" BASIS, -** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -** See the License for the specific language governing permissions and -** limitations under the License. -*/ ---> - -<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2"> - <!-- Don't use roaming icon for considered operators --> - <string-array translatable="false" name="config_operatorConsideredNonRoaming"> - <item>302</item> - </string-array> -</resources> diff --git a/core/res/res/values-mcc404-mnc85/config.xml b/core/res/res/values-mcc404/config.xml index fd780abbf7dd..a106b0ae2cec 100644 --- a/core/res/res/values-mcc404-mnc85/config.xml +++ b/core/res/res/values-mcc404/config.xml @@ -20,6 +20,7 @@ <resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2"> <!-- Show roaming icon though same named operators. --> <string-array translatable="false" name="config_sameNamedOperatorConsideredRoaming"> - <item>40483</item> + <item>404</item> + <item>405</item> </string-array> </resources> diff --git a/core/res/res/values-mcc302-mnc500/config.xml b/core/res/res/values-mcc405/config.xml index 706570c0bd6b..a106b0ae2cec 100644 --- a/core/res/res/values-mcc302-mnc500/config.xml +++ b/core/res/res/values-mcc405/config.xml @@ -18,8 +18,9 @@ --> <resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2"> - <!-- Don't use roaming icon for considered operators --> - <string-array translatable="false" name="config_operatorConsideredNonRoaming"> - <item>302</item> + <!-- Show roaming icon though same named operators. --> + <string-array translatable="false" name="config_sameNamedOperatorConsideredRoaming"> + <item>404</item> + <item>405</item> </string-array> </resources> diff --git a/core/res/res/values-mcc404-mnc17/config.xml b/core/res/res/values-mcc520/config.xml index 685d0121931d..b2f3efa891ac 100644 --- a/core/res/res/values-mcc404-mnc17/config.xml +++ b/core/res/res/values-mcc520/config.xml @@ -20,6 +20,6 @@ <resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2"> <!-- Show roaming icon though same named operators. --> <string-array translatable="false" name="config_sameNamedOperatorConsideredRoaming"> - <item>40491</item> + <item>520</item> </string-array> </resources> diff --git a/core/res/res/values/attrs.xml b/core/res/res/values/attrs.xml index 0f812f1efe9c..c603418c0f0a 100644 --- a/core/res/res/values/attrs.xml +++ b/core/res/res/values/attrs.xml @@ -4060,6 +4060,19 @@ RTL (right-to-left). See {@link android.graphics.drawable.Drawable#setAutoMirrored}. --> <attr name="autoMirrored" format="boolean" /> + <!-- If set, specifies the color to apply to the drawable as a color filter. By + default, no color filter is applied. --> + <attr name="colorFilterColor" format="color" /> + <!-- When a color filter color is set, specifies its Porter-Duff blending mode. + The default value is multiply. --> + <attr name="colorFilterMode"> + <!-- [Sa * Da, Sc * Dc] --> + <enum name="multiply" value="14" /> + <!-- [Sa + Da - Sa * Da, Sc + Dc - Sc * Dc] --> + <enum name="screen" value="15" /> + <!-- [Da, Sc * Da + (1 - Sa) * Dc] --> + <enum name="src_atop" value="9" /> + </attr> </declare-styleable> <!-- Drawable used to render several states. Each state is represented by @@ -4344,6 +4357,8 @@ <!-- Indicates if the drawable needs to be mirrored when its layout direction is RTL (right-to-left). --> <attr name="autoMirrored" /> + <attr name="colorFilterColor" /> + <attr name="colorFilterMode" /> </declare-styleable> <!-- Drawable used to draw 9-patches. --> @@ -4357,6 +4372,8 @@ <!-- Indicates if the drawable needs to be mirrored when its layout direction is RTL (right-to-left). --> <attr name="autoMirrored" /> + <attr name="colorFilterColor" /> + <attr name="colorFilterMode" /> </declare-styleable> <!-- Drawable used to draw a single color. --> diff --git a/core/res/res/values/public.xml b/core/res/res/values/public.xml index a0d84c9feed5..9a9b71acbb55 100644 --- a/core/res/res/values/public.xml +++ b/core/res/res/values/public.xml @@ -2097,6 +2097,8 @@ <public type="attr" name="windowContentTransitions" /> <public type="attr" name="windowContentTransitionManager" /> <public type="attr" name="translationZ" /> + <public type="attr" name="colorFilterColor" /> + <public type="attr" name="colorFilterMode" /> <public type="style" name="Widget.Holo.FragmentBreadCrumbs" /> <public type="style" name="Widget.Holo.Light.FragmentBreadCrumbs" /> diff --git a/graphics/java/android/graphics/drawable/BitmapDrawable.java b/graphics/java/android/graphics/drawable/BitmapDrawable.java index 98e3386e7f15..936055889d45 100644 --- a/graphics/java/android/graphics/drawable/BitmapDrawable.java +++ b/graphics/java/android/graphics/drawable/BitmapDrawable.java @@ -26,6 +26,8 @@ import android.graphics.ColorFilter; import android.graphics.Matrix; import android.graphics.Paint; import android.graphics.PixelFormat; +import android.graphics.PorterDuff; +import android.graphics.PorterDuff.Mode; import android.graphics.Rect; import android.graphics.Shader; import android.graphics.Xfermode; @@ -33,6 +35,7 @@ import android.util.AttributeSet; import android.util.DisplayMetrics; import android.util.LayoutDirection; import android.view.Gravity; + import org.xmlpull.v1.XmlPullParser; import org.xmlpull.v1.XmlPullParserException; @@ -579,6 +582,18 @@ public class BitmapDrawable extends Drawable { setAutoMirrored(a.getBoolean(com.android.internal.R.styleable.BitmapDrawable_autoMirrored, false)); + if (a.hasValue(com.android.internal.R.styleable.BitmapDrawable_colorFilterColor)) { + final int colorFilterColor = a.getColor( + com.android.internal.R.styleable.BitmapDrawable_colorFilterColor, 0); + final int modeValue = a.getInt( + com.android.internal.R.styleable.BitmapDrawable_colorFilterMode, + Mode.MULTIPLY.ordinal()); + final Mode mode = Drawable.parseColorFilterMode(modeValue); + if (mode != null) { + setColorFilter(colorFilterColor, mode); + } + } + final Paint paint = mBitmapState.mPaint; paint.setAntiAlias(a.getBoolean(com.android.internal.R.styleable.BitmapDrawable_antialias, paint.isAntiAlias())); @@ -647,7 +662,7 @@ public class BitmapDrawable extends Drawable { } BitmapState(BitmapState bitmapState) { - this(bitmapState.mBitmap); + mBitmap = bitmapState.mBitmap; mChangingConfigurations = bitmapState.mChangingConfigurations; mGravity = bitmapState.mGravity; mTileModeX = bitmapState.mTileModeX; diff --git a/graphics/java/android/graphics/drawable/Drawable.java b/graphics/java/android/graphics/drawable/Drawable.java index 630add7099d7..b8365aab655c 100644 --- a/graphics/java/android/graphics/drawable/Drawable.java +++ b/graphics/java/android/graphics/drawable/Drawable.java @@ -83,7 +83,7 @@ import java.util.Arrays; * through the {@link Callback} interface. All clients should support this * interface (via {@link #setCallback}) so that animations will work. A * simple way to do this is through the system facilities such as - * {@link android.view.View#setBackgroundDrawable(Drawable)} and + * {@link android.view.View#setBackground(Drawable)} and * {@link android.widget.ImageView}. * </ul> * @@ -438,9 +438,9 @@ public abstract class Drawable { } /** - * Specify an optional colorFilter for the drawable. Pass null to remove - * any filters. - */ + * Specify an optional color filter for the drawable. Pass null to remove + * any existing color filter. + */ public abstract void setColorFilter(ColorFilter cf); /** @@ -453,13 +453,16 @@ public abstract class Drawable { } /** - * Specify a color and porterduff mode to be the colorfilter for this + * Specify a color and Porter-Duff mode to be the color filter for this * drawable. */ public void setColorFilter(int color, PorterDuff.Mode mode) { setColorFilter(new PorterDuffColorFilter(color, mode)); } + /** + * Removes the color filter for this drawable. + */ public void clearColorFilter() { setColorFilter(null); } @@ -1089,7 +1092,7 @@ public abstract class Drawable { /** * Return a {@link ConstantState} instance that holds the shared state of this Drawable. - *q + * * @return The ConstantState associated to that Drawable. * @see ConstantState * @see Drawable#mutate() @@ -1107,5 +1110,17 @@ public abstract class Drawable { return new BitmapDrawable(res, bm); } + + /** + * Parses a {@link android.graphics.PorterDuff.Mode} from a colorFilterMode + * attribute's enum value. + */ + static PorterDuff.Mode parseColorFilterMode(int value) { + final PorterDuff.Mode[] modes = PorterDuff.Mode.values(); + if (value >= 0 && value < modes.length) { + return modes[value]; + } + return null; + } } diff --git a/graphics/java/android/graphics/drawable/DrawableContainer.java b/graphics/java/android/graphics/drawable/DrawableContainer.java index aac78766514e..a1e0772856ce 100644 --- a/graphics/java/android/graphics/drawable/DrawableContainer.java +++ b/graphics/java/android/graphics/drawable/DrawableContainer.java @@ -49,7 +49,6 @@ public class DrawableContainer extends Drawable implements Drawable.Callback { private DrawableContainerState mDrawableContainerState; private Drawable mCurrDrawable; private int mAlpha = 0xFF; - private ColorFilter mColorFilter; private int mCurIndex = -1; private boolean mMutated; @@ -147,8 +146,8 @@ public class DrawableContainer extends Drawable implements Drawable.Callback { @Override public void setColorFilter(ColorFilter cf) { - if (mColorFilter != cf) { - mColorFilter = cf; + if (mDrawableContainerState.mColorFilter != cf) { + mDrawableContainerState.mColorFilter = cf; if (mCurrDrawable != null) { mCurrDrawable.mutate().setColorFilter(cf); } @@ -359,7 +358,7 @@ public class DrawableContainer extends Drawable implements Drawable.Callback { } d.setVisible(isVisible(), true); d.setDither(mDrawableContainerState.mDither); - d.setColorFilter(mColorFilter); + d.setColorFilter(mDrawableContainerState.mColorFilter); d.setState(getState()); d.setLevel(getLevel()); d.setBounds(getBounds()); @@ -507,6 +506,8 @@ public class DrawableContainer extends Drawable implements Drawable.Callback { boolean mAutoMirrored; + ColorFilter mColorFilter; + DrawableContainerState(DrawableContainerState orig, DrawableContainer owner, Resources res) { mOwner = owner; @@ -527,6 +528,7 @@ public class DrawableContainer extends Drawable implements Drawable.Callback { mEnterFadeDuration = orig.mEnterFadeDuration; mExitFadeDuration = orig.mExitFadeDuration; mAutoMirrored = orig.mAutoMirrored; + mColorFilter = orig.mColorFilter; // Cloning the following values may require creating futures. mConstantPadding = orig.getConstantPadding(); diff --git a/graphics/java/android/graphics/drawable/NinePatchDrawable.java b/graphics/java/android/graphics/drawable/NinePatchDrawable.java index 9c57a2cec25c..515d3c1e10d0 100644 --- a/graphics/java/android/graphics/drawable/NinePatchDrawable.java +++ b/graphics/java/android/graphics/drawable/NinePatchDrawable.java @@ -26,12 +26,15 @@ import android.graphics.Insets; import android.graphics.NinePatch; import android.graphics.Paint; import android.graphics.PixelFormat; +import android.graphics.PorterDuffColorFilter; import android.graphics.Rect; import android.graphics.Region; +import android.graphics.PorterDuff.Mode; import android.util.AttributeSet; import android.util.DisplayMetrics; import android.util.LayoutDirection; import android.util.TypedValue; + import org.xmlpull.v1.XmlPullParser; import org.xmlpull.v1.XmlPullParserException; @@ -133,6 +136,9 @@ public class NinePatchDrawable extends Drawable { // lazy allocation of a paint setDither(state.mDither); } + if (state.mColorFilter != null) { + setColorFilter(state.mColorFilter); + } setAutoMirrored(state.mAutoMirrored); if (mNinePatch != null) { computeBitmapSize(); @@ -366,9 +372,25 @@ public class NinePatchDrawable extends Drawable { final boolean automirrored = a.getBoolean( com.android.internal.R.styleable.NinePatchDrawable_autoMirrored, false); + final NinePatchState ninePatchState = new NinePatchState( + new NinePatch(bitmap, bitmap.getNinePatchChunk()), padding, opticalInsets, dither, + automirrored); + + if (a.hasValue(com.android.internal.R.styleable.NinePatchDrawable_colorFilterColor)) { + final int colorFilterColor = a.getColor( + com.android.internal.R.styleable.NinePatchDrawable_colorFilterColor, 0); + final int modeValue = a.getInt( + com.android.internal.R.styleable.NinePatchDrawable_colorFilterMode, + Mode.MULTIPLY.ordinal()); + final Mode mode = Drawable.parseColorFilterMode(modeValue); + if (mode != null) { + // This will be applied to the paint by setNinePatchState(). + ninePatchState.mColorFilter = new PorterDuffColorFilter(colorFilterColor, mode); + } + } + + setNinePatchState(ninePatchState, r); - setNinePatchState(new NinePatchState(new NinePatch(bitmap, bitmap.getNinePatchChunk()), - padding, opticalInsets, dither, automirrored), r); mNinePatchState.mTargetDensity = mTargetDensity; a.recycle(); @@ -447,6 +469,7 @@ public class NinePatchDrawable extends Drawable { int mChangingConfigurations; int mTargetDensity = DisplayMetrics.DENSITY_DEFAULT; boolean mAutoMirrored; + ColorFilter mColorFilter; NinePatchState(NinePatch ninePatch, Rect padding) { this(ninePatch, padding, new Rect(), DEFAULT_DITHER, false); @@ -477,6 +500,7 @@ public class NinePatchDrawable extends Drawable { mChangingConfigurations = state.mChangingConfigurations; mTargetDensity = state.mTargetDensity; mAutoMirrored = state.mAutoMirrored; + mColorFilter = state.mColorFilter; } @Override diff --git a/libs/hwui/Android.mk b/libs/hwui/Android.mk index 4f0d15a15361..05163c879349 100644 --- a/libs/hwui/Android.mk +++ b/libs/hwui/Android.mk @@ -50,6 +50,7 @@ ifeq ($(USE_OPENGL_RENDERER),true) # RenderThread stuff LOCAL_SRC_FILES += \ + renderthread/CanvasContext.cpp \ renderthread/RenderTask.cpp \ renderthread/RenderThread.cpp diff --git a/libs/hwui/Stencil.cpp b/libs/hwui/Stencil.cpp index 276452377415..8ce57db9003c 100644 --- a/libs/hwui/Stencil.cpp +++ b/libs/hwui/Stencil.cpp @@ -35,7 +35,7 @@ namespace uirenderer { Stencil::Stencil(): mState(kDisabled) { } -uint32_t Stencil::getStencilSize() { +uint8_t Stencil::getStencilSize() { return STENCIL_BUFFER_SIZE; } diff --git a/libs/hwui/Stencil.h b/libs/hwui/Stencil.h index 83ad6681a7f8..c5e5186866d2 100644 --- a/libs/hwui/Stencil.h +++ b/libs/hwui/Stencil.h @@ -40,7 +40,7 @@ public: * Returns the desired size for the stencil buffer. If the returned value * is 0, then no stencil buffer is required. */ - ANDROID_API static uint32_t getStencilSize(); + ANDROID_API static uint8_t getStencilSize(); /** * Returns the smallest stencil format accepted by render buffers. diff --git a/libs/hwui/renderthread/CanvasContext.cpp b/libs/hwui/renderthread/CanvasContext.cpp new file mode 100644 index 000000000000..ffb8a324b649 --- /dev/null +++ b/libs/hwui/renderthread/CanvasContext.cpp @@ -0,0 +1,326 @@ +/* + * Copyright (C) 2014 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#define LOG_TAG "CanvasContext" + +#include "CanvasContext.h" + +#include <cutils/properties.h> +#include <strings.h> + +#include "../Caches.h" +#include "../Stencil.h" + +#define PROPERTY_RENDER_DIRTY_REGIONS "debug.hwui.render_dirty_regions" +#define GLES_VERSION 2 + +namespace android { +namespace uirenderer { +namespace renderthread { + +#define ERROR_CASE(x) case x: return #x; +static const char* egl_error_str(EGLint error) { + switch (error) { + ERROR_CASE(EGL_SUCCESS) + ERROR_CASE(EGL_NOT_INITIALIZED) + ERROR_CASE(EGL_BAD_ACCESS) + ERROR_CASE(EGL_BAD_ALLOC) + ERROR_CASE(EGL_BAD_ATTRIBUTE) + ERROR_CASE(EGL_BAD_CONFIG) + ERROR_CASE(EGL_BAD_CONTEXT) + ERROR_CASE(EGL_BAD_CURRENT_SURFACE) + ERROR_CASE(EGL_BAD_DISPLAY) + ERROR_CASE(EGL_BAD_MATCH) + ERROR_CASE(EGL_BAD_NATIVE_PIXMAP) + ERROR_CASE(EGL_BAD_NATIVE_WINDOW) + ERROR_CASE(EGL_BAD_PARAMETER) + ERROR_CASE(EGL_BAD_SURFACE) + ERROR_CASE(EGL_CONTEXT_LOST) + default: + return "Unknown error"; + } +} +static const char* egl_error_str() { + return egl_error_str(eglGetError()); +} + +static bool load_dirty_regions_property() { + char buf[PROPERTY_VALUE_MAX]; + int len = property_get(PROPERTY_RENDER_DIRTY_REGIONS, buf, "true"); + return !strncasecmp("true", buf, len); +} + +// This class contains the shared global EGL objects, such as EGLDisplay +// and EGLConfig, which are re-used by CanvasContext +class GlobalContext { +public: + static GlobalContext* get(); + + // Returns true if EGL was initialized, + // false if it was already initialized + bool initialize(); + + bool usePBufferSurface(); + EGLSurface createSurface(EGLNativeWindowType window); + void destroySurface(EGLSurface surface); + + void destroy(); + + bool isCurrent(EGLSurface surface) { return mCurrentSurface == surface; } + bool makeCurrent(EGLSurface surface); + bool swapBuffers(EGLSurface surface); + + bool enableDirtyRegions(EGLSurface surface); + +private: + GlobalContext(); + // GlobalContext is never destroyed, method is purposely not implemented + ~GlobalContext(); + + bool loadConfig(); + bool createContext(); + + static GlobalContext* sContext; + + EGLDisplay mEglDisplay; + EGLConfig mEglConfig; + EGLContext mEglContext; + EGLSurface mPBufferSurface; + + const bool mRequestDirtyRegions; + bool mCanSetDirtyRegions; + + EGLSurface mCurrentSurface; +}; + +GlobalContext* GlobalContext::sContext = 0; + +GlobalContext* GlobalContext::get() { + if (!sContext) { + sContext = new GlobalContext(); + } + return sContext; +} + +GlobalContext::GlobalContext() + : mEglDisplay(EGL_NO_DISPLAY) + , mEglConfig(0) + , mEglContext(EGL_NO_CONTEXT) + , mPBufferSurface(EGL_NO_SURFACE) + , mRequestDirtyRegions(load_dirty_regions_property()) + , mCurrentSurface(EGL_NO_SURFACE) { + mCanSetDirtyRegions = mRequestDirtyRegions; + ALOGD("Render dirty regions requested: %s", mRequestDirtyRegions ? "true" : "false"); +} + +bool GlobalContext::initialize() { + if (mEglDisplay != EGL_NO_DISPLAY) return false; + + mEglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY); + if (mEglDisplay == EGL_NO_DISPLAY) { + ALOGE("Failed to get EGL_DEFAULT_DISPLAY! err=%s", egl_error_str()); + return false; + } + + EGLint major, minor; + if (eglInitialize(mEglDisplay, &major, &minor) == EGL_FALSE) { + ALOGE("Failed to initialize display %p! err=%s", mEglDisplay, egl_error_str()); + return false; + } + ALOGI("Initialized EGL, version %d.%d", (int)major, (int)minor); + + if (!loadConfig()) { + return false; + } + if (!createContext()) { + return false; + } + + return true; +} + +bool GlobalContext::loadConfig() { + EGLint swapBehavior = mCanSetDirtyRegions ? EGL_SWAP_BEHAVIOR_PRESERVED_BIT : 0; + EGLint attribs[] = { + EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT, + EGL_RED_SIZE, 8, + EGL_GREEN_SIZE, 8, + EGL_BLUE_SIZE, 8, + EGL_ALPHA_SIZE, 8, + EGL_DEPTH_SIZE, 0, + EGL_CONFIG_CAVEAT, EGL_NONE, + EGL_STENCIL_SIZE, Stencil::getStencilSize(), + EGL_SURFACE_TYPE, EGL_WINDOW_BIT | swapBehavior, + EGL_NONE + }; + + EGLint num_configs = 1; + if (!eglChooseConfig(mEglDisplay, attribs, &mEglConfig, num_configs, &num_configs) + || num_configs != 1) { + // Failed to get a valid config + if (mCanSetDirtyRegions) { + ALOGW("Failed to choose config with EGL_SWAP_BEHAVIOR_PRESERVED, retrying without..."); + // Try again without dirty regions enabled + mCanSetDirtyRegions = false; + loadConfig(); + } else { + ALOGE("Failed to choose config, error = %s", egl_error_str()); + return false; + } + } + return true; +} + +bool GlobalContext::createContext() { + EGLint attribs[] = { EGL_CONTEXT_CLIENT_VERSION, GLES_VERSION, EGL_NONE }; + mEglContext = eglCreateContext(mEglDisplay, mEglConfig, EGL_NO_CONTEXT, attribs); + if (mEglContext == EGL_NO_CONTEXT) { + ALOGE("Failed to create context, error = %s", egl_error_str()); + return false; + } + return true; +} + +bool GlobalContext::usePBufferSurface() { + if (mEglDisplay == EGL_NO_DISPLAY) return false; + + if (mPBufferSurface == EGL_NO_SURFACE) { + EGLint attribs[] = { EGL_WIDTH, 1, EGL_HEIGHT, 1, EGL_NONE }; + mPBufferSurface = eglCreatePbufferSurface(mEglDisplay, mEglConfig, attribs); + } + return makeCurrent(mPBufferSurface); +} + +EGLSurface GlobalContext::createSurface(EGLNativeWindowType window) { + initialize(); + return eglCreateWindowSurface(mEglDisplay, mEglConfig, window, NULL); +} + +void GlobalContext::destroySurface(EGLSurface surface) { + if (isCurrent(surface)) { + makeCurrent(EGL_NO_SURFACE); + } + if (!eglDestroySurface(mEglDisplay, surface)) { + ALOGW("Failed to destroy surface %p, error=%s", (void*)surface, egl_error_str()); + } +} + +void GlobalContext::destroy() { + if (mEglDisplay == EGL_NO_DISPLAY) return; + + usePBufferSurface(); + if (Caches::hasInstance()) { + Caches::getInstance().terminate(); + } + + eglDestroyContext(mEglDisplay, mEglContext); + eglDestroySurface(mEglDisplay, mPBufferSurface); + eglMakeCurrent(mEglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT); + eglTerminate(mEglDisplay); + eglReleaseThread(); + + mEglDisplay = EGL_NO_DISPLAY; + mEglContext = EGL_NO_CONTEXT; + mPBufferSurface = EGL_NO_SURFACE; + mCurrentSurface = EGL_NO_SURFACE; +} + +bool GlobalContext::makeCurrent(EGLSurface surface) { + if (isCurrent(surface)) return true; + + if (surface == EGL_NO_SURFACE) { + // If we are setting EGL_NO_SURFACE we don't care about any of the potential + // return errors, which would only happen if mEglDisplay had already been + // destroyed in which case the current context is already NO_CONTEXT + eglMakeCurrent(mEglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT); + } else if (!eglMakeCurrent(mEglDisplay, surface, surface, mEglContext)) { + ALOGE("Failed to make current on surface %p, error=%s", (void*)surface, egl_error_str()); + return false; + } + mCurrentSurface = surface; + return true; +} + +bool GlobalContext::swapBuffers(EGLSurface surface) { + if (!eglSwapBuffers(mEglDisplay, surface)) { + ALOGW("eglSwapBuffers failed on surface %p, error=%s", (void*)surface, egl_error_str()); + return false; + } + return true; +} + +bool GlobalContext::enableDirtyRegions(EGLSurface surface) { + if (!mRequestDirtyRegions) return false; + + if (mCanSetDirtyRegions) { + if (!eglSurfaceAttrib(mEglDisplay, surface, EGL_SWAP_BEHAVIOR, EGL_BUFFER_PRESERVED)) { + ALOGW("Failed to set EGL_SWAP_BEHAVIOR on surface %p, error=%s", + (void*) surface, egl_error_str()); + return false; + } + return true; + } + // Perhaps it is already enabled? + EGLint value; + if (!eglQuerySurface(mEglDisplay, surface, EGL_SWAP_BEHAVIOR, &value)) { + ALOGW("Failed to query EGL_SWAP_BEHAVIOR on surface %p, error=%p", + (void*) surface, egl_error_str()); + return false; + } + return value == EGL_BUFFER_PRESERVED; +} + +CanvasContext::CanvasContext() + : mEglSurface(EGL_NO_SURFACE) + , mDirtyRegionsEnabled(false) { + mGlobalContext = GlobalContext::get(); +} + +CanvasContext::~CanvasContext() { + setSurface(NULL); +} + +bool CanvasContext::setSurface(EGLNativeWindowType window) { + if (mEglSurface != EGL_NO_SURFACE) { + mGlobalContext->destroySurface(mEglSurface); + mEglSurface = EGL_NO_SURFACE; + } + + if (window) { + mEglSurface = mGlobalContext->createSurface(window); + } + + if (mEglSurface != EGL_NO_SURFACE) { + mDirtyRegionsEnabled = mGlobalContext->enableDirtyRegions(mEglSurface); + } + return !window || mEglSurface != EGL_NO_SURFACE; +} + +bool CanvasContext::swapBuffers() { + return mGlobalContext->swapBuffers(mEglSurface); +} + +bool CanvasContext::makeCurrent() { + return mGlobalContext->makeCurrent(mEglSurface); +} + +bool CanvasContext::useGlobalPBufferSurface() { + return GlobalContext::get()->usePBufferSurface(); +} + +} /* namespace renderthread */ +} /* namespace uirenderer */ +} /* namespace android */ diff --git a/libs/hwui/renderthread/CanvasContext.h b/libs/hwui/renderthread/CanvasContext.h new file mode 100644 index 000000000000..77ae7375c9ee --- /dev/null +++ b/libs/hwui/renderthread/CanvasContext.h @@ -0,0 +1,52 @@ +/* + * Copyright (C) 2014 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef CANVASCONTEXT_H_ +#define CANVASCONTEXT_H_ + +#include <cutils/compiler.h> +#include <EGL/egl.h> + +namespace android { +namespace uirenderer { +namespace renderthread { + +class GlobalContext; + +// This per-renderer class manages the bridge between the global EGL context +// and the render surface. +class CanvasContext { +public: + ANDROID_API CanvasContext(); + ANDROID_API ~CanvasContext(); + + ANDROID_API bool setSurface(EGLNativeWindowType window); + ANDROID_API bool swapBuffers(); + ANDROID_API bool makeCurrent(); + + ANDROID_API static bool useGlobalPBufferSurface(); + +private: + + GlobalContext* mGlobalContext; + EGLSurface mEglSurface; + bool mDirtyRegionsEnabled; +}; + +} /* namespace renderthread */ +} /* namespace uirenderer */ +} /* namespace android */ +#endif /* CANVASCONTEXT_H_ */ diff --git a/packages/SettingsProvider/res/values/defaults.xml b/packages/SettingsProvider/res/values/defaults.xml index a1d8f22d48a9..28f50bc5a92c 100644 --- a/packages/SettingsProvider/res/values/defaults.xml +++ b/packages/SettingsProvider/res/values/defaults.xml @@ -173,4 +173,10 @@ 0 means no timeout; battery sounds will always play >0 is milliseconds of screen-off time after which battery sounds will not play --> <integer name="def_low_battery_sound_timeout">0</integer> + + <!-- Initial value for the Settings.Secure.IMMERSIVE_MODE_CONFIRMATIONS setting, + which is a comma separated list of packages that no longer need confirmation + for immersive mode. + Override to disable immersive mode confirmation for certain packages. --> + <string name="def_immersive_mode_confirmations" translatable="false"></string> </resources> diff --git a/packages/SettingsProvider/src/com/android/providers/settings/DatabaseHelper.java b/packages/SettingsProvider/src/com/android/providers/settings/DatabaseHelper.java index b71796e3ba11..e3a369155906 100644 --- a/packages/SettingsProvider/src/com/android/providers/settings/DatabaseHelper.java +++ b/packages/SettingsProvider/src/com/android/providers/settings/DatabaseHelper.java @@ -2111,6 +2111,10 @@ public class DatabaseHelper extends SQLiteOpenHelper { loadBooleanSetting(stmt, Settings.Secure.USER_SETUP_COMPLETE, R.bool.def_user_setup_complete); + + loadStringSetting(stmt, Settings.Secure.IMMERSIVE_MODE_CONFIRMATIONS, + R.string.def_immersive_mode_confirmations); + } finally { if (stmt != null) stmt.close(); } diff --git a/packages/SystemUI/res/values/colors.xml b/packages/SystemUI/res/values/colors.xml index 3a35de5cf3b0..9301618ecf77 100644 --- a/packages/SystemUI/res/values/colors.xml +++ b/packages/SystemUI/res/values/colors.xml @@ -34,7 +34,7 @@ <color name="notification_panel_scrim_color">#B0000000</color> <color name="batterymeter_frame_color">#66FFFFFF</color><!-- 40% white --> <color name="batterymeter_charge_color">#FFFFFFFF</color> - <color name="batterymeter_bolt_color">#B2000000</color><!-- 70% black --> + <color name="batterymeter_bolt_color">#FFFFFFFF</color> <color name="status_bar_clock_color">#FFFFFFFF</color> <drawable name="notification_item_background_color">#ff111111</drawable> <drawable name="notification_item_background_color_pressed">#ff454545</drawable> diff --git a/packages/SystemUI/src/com/android/systemui/BatteryMeterView.java b/packages/SystemUI/src/com/android/systemui/BatteryMeterView.java index 1c64fb4c0259..5579e1935729 100755 --- a/packages/SystemUI/src/com/android/systemui/BatteryMeterView.java +++ b/packages/SystemUI/src/com/android/systemui/BatteryMeterView.java @@ -39,20 +39,20 @@ public class BatteryMeterView extends View implements DemoMode { public static final String TAG = BatteryMeterView.class.getSimpleName(); public static final String ACTION_LEVEL_TEST = "com.android.systemui.BATTERY_LEVEL_TEST"; - public static final boolean ENABLE_PERCENT = true; - public static final boolean SINGLE_DIGIT_PERCENT = false; - public static final boolean SHOW_100_PERCENT = false; + private static final boolean ENABLE_PERCENT = true; + private static final boolean SINGLE_DIGIT_PERCENT = false; + private static final boolean SHOW_100_PERCENT = false; - public static final int FULL = 96; - public static final int EMPTY = 4; + private static final int FULL = 96; + private static final int EMPTY = 4; - public static final float SUBPIXEL = 0.4f; // inset rects for softer edges + private static final float SUBPIXEL = 0.4f; // inset rects for softer edges + private static final float BOLT_LEVEL_THRESHOLD = 0.3f; // opaque bolt below this fraction - int[] mColors; + private final int[] mColors; boolean mShowPercent = true; - Paint mFramePaint, mBatteryPaint, mWarningTextPaint, mTextPaint, mBoltPaint; - int mButtonHeight; + private final Paint mFramePaint, mBatteryPaint, mWarningTextPaint, mTextPaint, mBoltPaint; private float mTextHeight, mWarningTextHeight; private int mHeight; @@ -64,9 +64,11 @@ public class BatteryMeterView extends View implements DemoMode { private final RectF mFrame = new RectF(); private final RectF mButtonFrame = new RectF(); - private final RectF mClipFrame = new RectF(); private final RectF mBoltFrame = new RectF(); + private final Path mShapePath = new Path(); + private final Path mClipPath = new Path(); + private class BatteryTracker extends BroadcastReceiver { public static final int UNKNOWN_LEVEL = -1; @@ -188,7 +190,9 @@ public class BatteryMeterView extends View implements DemoMode { colors.recycle(); mShowPercent = ENABLE_PERCENT && 0 != Settings.System.getInt( context.getContentResolver(), "status_bar_show_battery_percent", 0); - + if (mShowPercent) { + setLayerType(View.LAYER_TYPE_SOFTWARE, null); + } mWarningString = context.getString(R.string.battery_meter_very_low_overlay_symbol); mFramePaint = new Paint(Paint.ANTI_ALIAS_FLAG); @@ -196,7 +200,6 @@ public class BatteryMeterView extends View implements DemoMode { mFramePaint.setDither(true); mFramePaint.setStrokeWidth(0); mFramePaint.setStyle(Paint.Style.FILL_AND_STROKE); - mFramePaint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.DST_ATOP)); mBatteryPaint = new Paint(Paint.ANTI_ALIAS_FLAG); mBatteryPaint.setDither(true); @@ -204,8 +207,7 @@ public class BatteryMeterView extends View implements DemoMode { mBatteryPaint.setStyle(Paint.Style.FILL_AND_STROKE); mTextPaint = new Paint(Paint.ANTI_ALIAS_FLAG); - mTextPaint.setColor(0xFFFFFFFF); - Typeface font = Typeface.create("sans-serif-condensed", Typeface.NORMAL); + Typeface font = Typeface.create("sans-serif-condensed", Typeface.BOLD); mTextPaint.setTypeface(font); mTextPaint.setTextAlign(Paint.Align.CENTER); @@ -217,11 +219,9 @@ public class BatteryMeterView extends View implements DemoMode { mChargeColor = getResources().getColor(R.color.batterymeter_charge_color); - mBoltPaint = new Paint(); - mBoltPaint.setAntiAlias(true); + mBoltPaint = new Paint(Paint.ANTI_ALIAS_FLAG); mBoltPaint.setColor(res.getColor(R.color.batterymeter_bolt_color)); mBoltPoints = loadBoltPoints(res); - setLayerType(View.LAYER_TYPE_SOFTWARE, null); } private static float[] loadBoltPoints(Resources res) { @@ -269,36 +269,34 @@ public class BatteryMeterView extends View implements DemoMode { final int pl = getPaddingLeft(); final int pr = getPaddingRight(); final int pb = getPaddingBottom(); - int height = mHeight - pt - pb; - int width = mWidth - pl - pr; + final int height = mHeight - pt - pb; + final int width = mWidth - pl - pr; - mButtonHeight = (int) (height * 0.12f); + final int buttonHeight = (int) (height * 0.12f); mFrame.set(0, 0, width, height); mFrame.offset(pl, pt); + // button-frame: area above the battery body mButtonFrame.set( mFrame.left + width * 0.25f, mFrame.top, mFrame.right - width * 0.25f, - mFrame.top + mButtonHeight + 5 /*cover frame border of intersecting area*/); + mFrame.top + buttonHeight); mButtonFrame.top += SUBPIXEL; mButtonFrame.left += SUBPIXEL; mButtonFrame.right -= SUBPIXEL; - mFrame.top += mButtonHeight; + // frame: battery body area + mFrame.top += buttonHeight; mFrame.left += SUBPIXEL; mFrame.top += SUBPIXEL; mFrame.right -= SUBPIXEL; mFrame.bottom -= SUBPIXEL; - // first, draw the battery shape - c.drawRect(mFrame, mFramePaint); - - // fill 'er up - final int color = tracker.plugged ? mChargeColor : getColorForLevel(level); - mBatteryPaint.setColor(color); + // set the battery charging color + mBatteryPaint.setColor(tracker.plugged ? mChargeColor : getColorForLevel(level)); if (level >= FULL) { drawFrac = 1f; @@ -306,18 +304,23 @@ public class BatteryMeterView extends View implements DemoMode { drawFrac = 0f; } - c.drawRect(mButtonFrame, drawFrac == 1f ? mBatteryPaint : mFramePaint); - - mClipFrame.set(mFrame); - mClipFrame.top += (mFrame.height() * (1f - drawFrac)); - - c.save(Canvas.CLIP_SAVE_FLAG); - c.clipRect(mClipFrame); - c.drawRect(mFrame, mBatteryPaint); - c.restore(); + final float levelTop = drawFrac == 1f ? mButtonFrame.top + : (mFrame.top + (mFrame.height() * (1f - drawFrac))); + + // define the battery shape + mShapePath.reset(); + mShapePath.moveTo(mButtonFrame.left, mButtonFrame.top); + mShapePath.lineTo(mButtonFrame.right, mButtonFrame.top); + mShapePath.lineTo(mButtonFrame.right, mFrame.top); + mShapePath.lineTo(mFrame.right, mFrame.top); + mShapePath.lineTo(mFrame.right, mFrame.bottom); + mShapePath.lineTo(mFrame.left, mFrame.bottom); + mShapePath.lineTo(mFrame.left, mFrame.top); + mShapePath.lineTo(mButtonFrame.left, mFrame.top); + mShapePath.lineTo(mButtonFrame.left, mButtonFrame.top); if (tracker.plugged) { - // draw the bolt + // define the bolt shape final float bl = mFrame.left + mFrame.width() / 4.5f; final float bt = mFrame.top + mFrame.height() / 6f; final float br = mFrame.right - mFrame.width() / 7f; @@ -338,24 +341,58 @@ public class BatteryMeterView extends View implements DemoMode { mBoltFrame.left + mBoltPoints[0] * mBoltFrame.width(), mBoltFrame.top + mBoltPoints[1] * mBoltFrame.height()); } - c.drawPath(mBoltPath, mBoltPaint); - } else if (level <= EMPTY) { - final float x = mWidth * 0.5f; - final float y = (mHeight + mWarningTextHeight) * 0.48f; - c.drawText(mWarningString, x, y, mWarningTextPaint); - } else if (mShowPercent && !(tracker.level == 100 && !SHOW_100_PERCENT)) { - mTextPaint.setTextSize(height * - (SINGLE_DIGIT_PERCENT ? 0.75f - : (tracker.level == 100 ? 0.38f : 0.5f))); - mTextHeight = -mTextPaint.getFontMetrics().ascent; - - final String str = String.valueOf(SINGLE_DIGIT_PERCENT ? (level/10) : level); - final float x = mWidth * 0.5f; - final float y = (mHeight + mTextHeight) * 0.47f; - c.drawText(str, - x, - y, - mTextPaint); + + float boltPct = (mBoltFrame.bottom - levelTop) / (mBoltFrame.bottom - mBoltFrame.top); + boltPct = Math.min(Math.max(boltPct, 0), 1); + if (boltPct <= BOLT_LEVEL_THRESHOLD) { + // draw the bolt if opaque + c.drawPath(mBoltPath, mBoltPaint); + } else { + // otherwise cut the bolt out of the overall shape + mShapePath.op(mBoltPath, Path.Op.DIFFERENCE); + } + } + + // draw the battery shape background + c.drawPath(mShapePath, mFramePaint); + + // draw the battery shape, clipped to charging level + mFrame.top = levelTop; + mClipPath.reset(); + mClipPath.addRect(mFrame, Path.Direction.CCW); + mShapePath.op(mClipPath, Path.Op.INTERSECT); + c.drawPath(mShapePath, mBatteryPaint); + + if (!tracker.plugged) { + if (level <= EMPTY) { + // draw the warning text + final float x = mWidth * 0.5f; + final float y = (mHeight + mWarningTextHeight) * 0.48f; + c.drawText(mWarningString, x, y, mWarningTextPaint); + } else if (mShowPercent && !(tracker.level == 100 && !SHOW_100_PERCENT)) { + // draw the percentage text + mTextPaint.setColor(getColorForLevel(level)); + mTextPaint.setTextSize(height * + (SINGLE_DIGIT_PERCENT ? 0.75f + : (tracker.level == 100 ? 0.38f : 0.5f))); + mTextHeight = -mTextPaint.getFontMetrics().ascent; + + final String str = String.valueOf(SINGLE_DIGIT_PERCENT ? (level/10) : level); + final float x = mWidth * 0.5f; + final float y = (mHeight + mTextHeight) * 0.47f; + + boolean opaque = levelTop > y; + if (opaque) { + mTextPaint.setXfermode(null); + } else { + mTextPaint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.DST_OUT)); + } + + c.drawText(str, + x, + y, + mTextPaint); + } } } diff --git a/services/core/java/com/android/server/am/ActivityManagerService.java b/services/core/java/com/android/server/am/ActivityManagerService.java index a7cd64ef5fbe..dd536488c169 100644 --- a/services/core/java/com/android/server/am/ActivityManagerService.java +++ b/services/core/java/com/android/server/am/ActivityManagerService.java @@ -2948,7 +2948,7 @@ public final class ActivityManagerService extends ActivityManagerNative intent.setComponent(new ComponentName( ri.activityInfo.packageName, ri.activityInfo.name)); mStackSupervisor.startActivityLocked(null, intent, null, ri.activityInfo, - null, null, 0, 0, 0, null, 0, null, false, null); + null, null, 0, 0, 0, null, 0, null, false, null, null); } } } @@ -3106,7 +3106,7 @@ public final class ActivityManagerService extends ActivityManagerNative // TODO: Switch to user app stacks here. return mStackSupervisor.startActivityMayWait(caller, -1, callingPackage, intent, resolvedType, resultTo, resultWho, requestCode, startFlags, profileFile, profileFd, - null, null, options, userId); + null, null, options, userId, null); } @Override @@ -3121,7 +3121,7 @@ public final class ActivityManagerService extends ActivityManagerNative // TODO: Switch to user app stacks here. mStackSupervisor.startActivityMayWait(caller, -1, callingPackage, intent, resolvedType, resultTo, resultWho, requestCode, startFlags, profileFile, profileFd, - res, null, options, UserHandle.getCallingUserId()); + res, null, options, UserHandle.getCallingUserId(), null); return res; } @@ -3136,7 +3136,7 @@ public final class ActivityManagerService extends ActivityManagerNative // TODO: Switch to user app stacks here. int ret = mStackSupervisor.startActivityMayWait(caller, -1, callingPackage, intent, resolvedType, resultTo, resultWho, requestCode, startFlags, - null, null, null, config, options, userId); + null, null, null, config, options, userId, null); return ret; } @@ -3267,7 +3267,7 @@ public final class ActivityManagerService extends ActivityManagerNative int res = mStackSupervisor.startActivityLocked(r.app.thread, intent, r.resolvedType, aInfo, resultTo != null ? resultTo.appToken : null, resultWho, requestCode, -1, r.launchedFromUid, r.launchedFromPackage, 0, - options, false, null); + options, false, null, null); Binder.restoreCallingIdentity(origId); r.finishing = wasFinishing; @@ -3288,7 +3288,7 @@ public final class ActivityManagerService extends ActivityManagerNative // TODO: Switch to user app stacks here. int ret = mStackSupervisor.startActivityMayWait(null, uid, callingPackage, intent, resolvedType, resultTo, resultWho, requestCode, startFlags, - null, null, null, null, options, userId); + null, null, null, null, options, userId, null); return ret; } @@ -7126,6 +7126,18 @@ public final class ActivityManagerService extends ActivityManagerNative } @Override + public IActivityContainer getEnclosingActivityContainer(IBinder activityToken) + throws RemoteException { + synchronized (this) { + ActivityStack stack = ActivityRecord.getStackLocked(activityToken); + if (stack != null) { + return stack.mActivityContainer; + } + return null; + } + } + + @Override public void moveTaskToStack(int taskId, int stackId, boolean toTop) { enforceCallingPermission(android.Manifest.permission.MANAGE_ACTIVITY_STACKS, "moveTaskToStack()"); diff --git a/services/core/java/com/android/server/am/ActivityRecord.java b/services/core/java/com/android/server/am/ActivityRecord.java index 83176fcfa1e9..4e9770028d84 100644 --- a/services/core/java/com/android/server/am/ActivityRecord.java +++ b/services/core/java/com/android/server/am/ActivityRecord.java @@ -146,6 +146,7 @@ final class ActivityRecord { private boolean inHistory; // are we in the history stack? final ActivityStackSupervisor mStackSupervisor; boolean mStartingWindowShown = false; + ActivityContainer mInitialActivityContainer; void dump(PrintWriter pw, String prefix) { final long now = SystemClock.uptimeMillis(); @@ -350,7 +351,8 @@ final class ActivityRecord { int _launchedFromUid, String _launchedFromPackage, Intent _intent, String _resolvedType, ActivityInfo aInfo, Configuration _configuration, ActivityRecord _resultTo, String _resultWho, int _reqCode, - boolean _componentSpecified, ActivityStackSupervisor supervisor) { + boolean _componentSpecified, ActivityStackSupervisor supervisor, + ActivityContainer container) { service = _service; appToken = new Token(this); info = aInfo; @@ -381,6 +383,7 @@ final class ActivityRecord { idle = false; hasBeenLaunched = false; mStackSupervisor = supervisor; + mInitialActivityContainer = container; // This starts out true, since the initial state of an activity // is that we have everything, and we shouldn't never consider it diff --git a/services/core/java/com/android/server/am/ActivityStack.java b/services/core/java/com/android/server/am/ActivityStack.java index b75c0f100cb7..125621a20a9c 100644 --- a/services/core/java/com/android/server/am/ActivityStack.java +++ b/services/core/java/com/android/server/am/ActivityStack.java @@ -228,8 +228,11 @@ final class ActivityStack { int mCurrentUser; final int mStackId; - final ActivityContainer mActivityContainer; + /** The other stacks, in order, on the attached display. Updated at attach/detach time. */ + ArrayList<ActivityStack> mStacks; + /** The attached Display's unique identifier, or -1 if detached */ + int mDisplayId; /** Run all ActivityStacks through this */ final ActivityStackSupervisor mStackSupervisor; @@ -448,11 +451,23 @@ final class ActivityStack { return mStackId == HOME_STACK_ID; } - ArrayList<ActivityStack> getStacksLocked() { - if (mActivityContainer.isAttached()) { - return mActivityContainer.mActivityDisplayInfo.stacks; + final boolean isOnHomeDisplay() { + return isAttached() && + mActivityContainer.mActivityDisplay.mDisplayId == Display.DEFAULT_DISPLAY; + } + + final void moveToFront() { + if (isAttached()) { + mStacks.remove(this); + mStacks.add(this); + if (isOnHomeDisplay()) { + mStackSupervisor.moveHomeStack(isHomeStack()); + } } - return null; + } + + final boolean isAttached() { + return mStacks != null; } /** @@ -1282,7 +1297,8 @@ final class ActivityStack { ActivityOptions.abort(options); if (DEBUG_STATES) Slog.d(TAG, "resumeTopActivityLocked: No more activities go home"); if (DEBUG_STACK) mStackSupervisor.validateTopActivitiesLocked(); - return mStackSupervisor.resumeHomeActivity(prev); + // Only resume home if on home display + return isOnHomeDisplay() && mStackSupervisor.resumeHomeActivity(prev); } next.delayedResume = false; @@ -1312,8 +1328,10 @@ final class ActivityStack { final int taskNdx = mTaskHistory.indexOf(prevTask) + 1; mTaskHistory.get(taskNdx).mOnTopOfHome = true; } else { - if (DEBUG_STATES) Slog.d(TAG, "resumeTopActivityLocked: Launching home next"); - return mStackSupervisor.resumeHomeActivity(prev); + if (DEBUG_STATES && isOnHomeDisplay()) Slog.d(TAG, + "resumeTopActivityLocked: Launching home next"); + // Only resume home if on home display + return isOnHomeDisplay() && mStackSupervisor.resumeHomeActivity(prev); } } @@ -1681,10 +1699,14 @@ final class ActivityStack { private void insertTaskAtTop(TaskRecord task) { // If this is being moved to the top by another activity or being launched from the home // activity, set mOnTopOfHome accordingly. - ActivityStack lastStack = mStackSupervisor.getLastStack(); - final boolean fromHome = lastStack == null ? true : lastStack.isHomeStack(); - if (!isHomeStack() && (fromHome || topTask() != task)) { - task.mOnTopOfHome = fromHome; + if (isOnHomeDisplay()) { + ActivityStack lastStack = mStackSupervisor.getLastStack(); + final boolean fromHome = lastStack.isHomeStack(); + if (!isHomeStack() && (fromHome || topTask() != task)) { + task.mOnTopOfHome = fromHome; + } + } else { + task.mOnTopOfHome = false; } mTaskHistory.remove(task); @@ -2611,7 +2633,7 @@ final class ActivityStack { int res = mStackSupervisor.startActivityLocked(srec.app.thread, destIntent, null, aInfo, parent.appToken, null, 0, -1, parent.launchedFromUid, parent.launchedFromPackage, - 0, null, true, null); + 0, null, true, null, null); foundParentInTask = res == ActivityManager.START_SUCCESS; } catch (RemoteException e) { foundParentInTask = false; @@ -3063,7 +3085,7 @@ final class ActivityStack { return; } - mStackSupervisor.moveHomeStack(isHomeStack()); + moveToFront(); // Shift all activities with this task up to the top // of the stack, keeping them in the same internal order. @@ -3172,7 +3194,7 @@ final class ActivityStack { } final TaskRecord task = mResumedActivity != null ? mResumedActivity.task : null; - if (task == tr && task.mOnTopOfHome || numTasks <= 1) { + if (task == tr && tr.mOnTopOfHome || numTasks <= 1 && isOnHomeDisplay()) { tr.mOnTopOfHome = false; return mStackSupervisor.resumeHomeActivity(null); } diff --git a/services/core/java/com/android/server/am/ActivityStackSupervisor.java b/services/core/java/com/android/server/am/ActivityStackSupervisor.java index ebcbdc54e238..1e0be233ee19 100644 --- a/services/core/java/com/android/server/am/ActivityStackSupervisor.java +++ b/services/core/java/com/android/server/am/ActivityStackSupervisor.java @@ -145,17 +145,16 @@ public final class ActivityStackSupervisor implements DisplayListener { /** The current user */ private int mCurrentUser; - /** The stack containing the launcher app */ + /** The stack containing the launcher app. Assumed to always be attached to + * Display.DEFAULT_DISPLAY. */ private ActivityStack mHomeStack; - /** The non-home stack currently receiving input or launching the next activity. If home is - * in front then mHomeStack overrides mFocusedStack. - * DO NOT ACCESS DIRECTLY - It may be null, use getFocusedStack() */ + /** The stack currently receiving input or launching the next activity. */ private ActivityStack mFocusedStack; /** If this is the same as mFocusedStack then the activity on the top of the focused stack has * been resumed. If stacks are changing position this will hold the old stack until the new - * stack becomes resumed after which it will be set to the new stack. */ + * stack becomes resumed after which it will be set to mFocusedStack. */ private ActivityStack mLastFocusedStack; /** List of activities that are waiting for a new activity to become visible before completing @@ -217,7 +216,7 @@ public final class ActivityStackSupervisor implements DisplayListener { SparseArray<ActivityContainer> mActivityContainers = new SparseArray<ActivityContainer>(); /** Mapping from displayId to display current state */ - SparseArray<ActivityDisplayInfo> mDisplayInfos = new SparseArray<ActivityDisplayInfo>(); + SparseArray<ActivityDisplay> mActivityDisplays = new SparseArray<ActivityDisplay>(); public ActivityStackSupervisor(ActivityManagerService service) { mService = service; @@ -243,8 +242,8 @@ public final class ActivityStackSupervisor implements DisplayListener { Display[] displays = mDisplayManager.getDisplays(); for (int displayNdx = displays.length - 1; displayNdx >= 0; --displayNdx) { final int displayId = displays[displayNdx].getDisplayId(); - ActivityDisplayInfo info = new ActivityDisplayInfo(displayId); - mDisplayInfos.put(displayId, info); + ActivityDisplay activityDisplay = new ActivityDisplay(displayId); + mActivityDisplays.put(displayId, activityDisplay); } createStackOnDisplay(null, HOME_STACK_ID, Display.DEFAULT_DISPLAY); @@ -271,7 +270,7 @@ public final class ActivityStackSupervisor implements DisplayListener { // TODO: Split into two methods isFrontStack for any visible stack and isFrontmostStack for the // top of all visible stacks. boolean isFrontStack(ActivityStack stack) { - ArrayList<ActivityStack> stacks = stack.getStacksLocked(); + ArrayList<ActivityStack> stacks = stack.mStacks; if (stacks != null && !stacks.isEmpty()) { return stack == stacks.get(stacks.size() - 1); } @@ -279,7 +278,7 @@ public final class ActivityStackSupervisor implements DisplayListener { } void moveHomeStack(boolean toFront) { - ArrayList<ActivityStack> stacks = mHomeStack.getStacksLocked(); + ArrayList<ActivityStack> stacks = mHomeStack.mStacks; int topNdx = stacks.size() - 1; if (topNdx <= 0) { return; @@ -320,9 +319,9 @@ public final class ActivityStackSupervisor implements DisplayListener { } TaskRecord anyTaskForIdLocked(int id) { - int numDisplays = mDisplayInfos.size(); + int numDisplays = mActivityDisplays.size(); for (int displayNdx = 0; displayNdx < numDisplays; ++displayNdx) { - ArrayList<ActivityStack> stacks = mDisplayInfos.valueAt(displayNdx).stacks; + ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks; for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) { ActivityStack stack = stacks.get(stackNdx); TaskRecord task = stack.taskForIdLocked(id); @@ -335,9 +334,9 @@ public final class ActivityStackSupervisor implements DisplayListener { } ActivityRecord isInAnyStackLocked(IBinder token) { - int numDisplays = mDisplayInfos.size(); + int numDisplays = mActivityDisplays.size(); for (int displayNdx = 0; displayNdx < numDisplays; ++displayNdx) { - ArrayList<ActivityStack> stacks = mDisplayInfos.valueAt(displayNdx).stacks; + ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks; for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) { final ActivityRecord r = stacks.get(stackNdx).isInStackLocked(token); if (r != null) { @@ -371,7 +370,9 @@ public final class ActivityStackSupervisor implements DisplayListener { final int stackId = stack.mStackId; final int nextStackId = mWindowManager.removeStack(stackId); // TODO: Perhaps we need to let the ActivityManager determine the next focus... - mFocusedStack = getStack(nextStackId); + if (stack.isOnHomeDisplay()) { + mFocusedStack = getStack(nextStackId); + } } } @@ -393,8 +394,8 @@ public final class ActivityStackSupervisor implements DisplayListener { boolean attachApplicationLocked(ProcessRecord app) throws Exception { final String processName = app.processName; boolean didSomething = false; - for (int displayNdx = mDisplayInfos.size() - 1; displayNdx >= 0; --displayNdx) { - ArrayList<ActivityStack> stacks = mDisplayInfos.valueAt(displayNdx).stacks; + for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) { + ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks; for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) { final ActivityStack stack = stacks.get(stackNdx); if (!isFrontStack(stack)) { @@ -424,8 +425,8 @@ public final class ActivityStackSupervisor implements DisplayListener { } boolean allResumedActivitiesIdle() { - for (int displayNdx = mDisplayInfos.size() - 1; displayNdx >= 0; --displayNdx) { - ArrayList<ActivityStack> stacks = mDisplayInfos.valueAt(displayNdx).stacks; + for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) { + ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks; for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) { final ActivityStack stack = stacks.get(stackNdx); if (!isFrontStack(stack)) { @@ -441,8 +442,8 @@ public final class ActivityStackSupervisor implements DisplayListener { } boolean allResumedActivitiesComplete() { - for (int displayNdx = mDisplayInfos.size() - 1; displayNdx >= 0; --displayNdx) { - ArrayList<ActivityStack> stacks = mDisplayInfos.valueAt(displayNdx).stacks; + for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) { + ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks; for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) { final ActivityStack stack = stacks.get(stackNdx); if (isFrontStack(stack)) { @@ -462,8 +463,8 @@ public final class ActivityStackSupervisor implements DisplayListener { } boolean allResumedActivitiesVisible() { - for (int displayNdx = mDisplayInfos.size() - 1; displayNdx >= 0; --displayNdx) { - ArrayList<ActivityStack> stacks = mDisplayInfos.valueAt(displayNdx).stacks; + for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) { + ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks; for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) { final ActivityStack stack = stacks.get(stackNdx); final ActivityRecord r = stack.mResumedActivity; @@ -482,8 +483,8 @@ public final class ActivityStackSupervisor implements DisplayListener { */ boolean pauseBackStacks(boolean userLeaving) { boolean someActivityPaused = false; - for (int displayNdx = mDisplayInfos.size() - 1; displayNdx >= 0; --displayNdx) { - ArrayList<ActivityStack> stacks = mDisplayInfos.valueAt(displayNdx).stacks; + for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) { + ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks; for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) { final ActivityStack stack = stacks.get(stackNdx); if (!isFrontStack(stack) && stack.mResumedActivity != null) { @@ -499,8 +500,8 @@ public final class ActivityStackSupervisor implements DisplayListener { boolean allPausedActivitiesComplete() { boolean pausing = true; - for (int displayNdx = mDisplayInfos.size() - 1; displayNdx >= 0; --displayNdx) { - ArrayList<ActivityStack> stacks = mDisplayInfos.valueAt(displayNdx).stacks; + for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) { + ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks; for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) { final ActivityStack stack = stacks.get(stackNdx); final ActivityRecord r = stack.mPausingActivity; @@ -555,7 +556,7 @@ public final class ActivityStackSupervisor implements DisplayListener { } // Return to the home stack. - final ArrayList<ActivityStack> stacks = mHomeStack.getStacksLocked(); + final ArrayList<ActivityStack> stacks = mHomeStack.mStacks; for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) { final ActivityStack stack = stacks.get(stackNdx); if (stack != focusedStack && isFrontStack(stack)) { @@ -575,9 +576,9 @@ public final class ActivityStackSupervisor implements DisplayListener { // Gather all of the running tasks for each stack into runningTaskLists. ArrayList<ArrayList<RunningTaskInfo>> runningTaskLists = new ArrayList<ArrayList<RunningTaskInfo>>(); - final int numDisplays = mDisplayInfos.size(); + final int numDisplays = mActivityDisplays.size(); for (int displayNdx = 0; displayNdx < numDisplays; ++displayNdx) { - ArrayList<ActivityStack> stacks = mDisplayInfos.valueAt(displayNdx).stacks; + ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks; for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) { final ActivityStack stack = stacks.get(stackNdx); ArrayList<RunningTaskInfo> stackTaskList = new ArrayList<RunningTaskInfo>(); @@ -666,14 +667,14 @@ public final class ActivityStackSupervisor implements DisplayListener { void startHomeActivity(Intent intent, ActivityInfo aInfo) { moveHomeToTop(); startActivityLocked(null, intent, null, aInfo, null, null, 0, 0, 0, null, 0, - null, false, null); + null, false, null, null); } final int startActivityMayWait(IApplicationThread caller, int callingUid, String callingPackage, Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode, int startFlags, String profileFile, ParcelFileDescriptor profileFd, WaitResult outResult, Configuration config, - Bundle options, int userId) { + Bundle options, int userId, IActivityContainer iContainer) { // Refuse possible leaked file descriptors if (intent != null && intent.hasFileDescriptors()) { throw new IllegalArgumentException("File descriptors passed in Intent"); @@ -687,6 +688,7 @@ public final class ActivityStackSupervisor implements DisplayListener { ActivityInfo aInfo = resolveActivity(intent, resolvedType, startFlags, profileFile, profileFd, userId); + ActivityContainer container = (ActivityContainer)iContainer; synchronized (mService) { int callingPid; if (callingUid >= 0) { @@ -698,7 +700,12 @@ public final class ActivityStackSupervisor implements DisplayListener { callingPid = callingUid = -1; } - final ActivityStack stack = getFocusedStack(); + final ActivityStack stack; + if (container == null || container.mStack.isOnHomeDisplay()) { + stack = getFocusedStack(); + } else { + stack = container.mStack; + } stack.mConfigWillChange = config != null && mService.mConfiguration.diff(config) != 0; if (DEBUG_CONFIGURATION) Slog.v(TAG, @@ -774,9 +781,9 @@ public final class ActivityStackSupervisor implements DisplayListener { } } - int res = startActivityLocked(caller, intent, resolvedType, - aInfo, resultTo, resultWho, requestCode, callingPid, callingUid, - callingPackage, startFlags, options, componentSpecified, null); + int res = startActivityLocked(caller, intent, resolvedType, aInfo, resultTo, resultWho, + requestCode, callingPid, callingUid, callingPackage, startFlags, options, + componentSpecified, null, container); if (stack.mConfigWillChange) { // If the caller also wants to switch to a new configuration, @@ -891,7 +898,7 @@ public final class ActivityStackSupervisor implements DisplayListener { } int res = startActivityLocked(caller, intent, resolvedTypes[i], aInfo, resultTo, null, -1, callingPid, callingUid, callingPackage, - 0, theseOptions, componentSpecified, outActivity); + 0, theseOptions, componentSpecified, outActivity, null); if (res < 0) { return res; } @@ -1116,7 +1123,7 @@ public final class ActivityStackSupervisor implements DisplayListener { Intent intent, String resolvedType, ActivityInfo aInfo, IBinder resultTo, String resultWho, int requestCode, int callingPid, int callingUid, String callingPackage, int startFlags, Bundle options, - boolean componentSpecified, ActivityRecord[] outActivity) { + boolean componentSpecified, ActivityRecord[] outActivity, ActivityContainer container) { int err = ActivityManager.START_SUCCESS; ProcessRecord callerApp = null; @@ -1251,8 +1258,8 @@ public final class ActivityStackSupervisor implements DisplayListener { } ActivityRecord r = new ActivityRecord(mService, callerApp, callingUid, callingPackage, - intent, resolvedType, aInfo, mService.mConfiguration, - resultRecord, resultWho, requestCode, componentSpecified, this); + intent, resolvedType, aInfo, mService.mConfiguration, resultRecord, resultWho, + requestCode, componentSpecified, this, container); if (outActivity != null) { outActivity[0] = r; } @@ -1300,34 +1307,40 @@ public final class ActivityStackSupervisor implements DisplayListener { if (r.isApplicationActivity() || (task != null && task.isApplicationTask())) { if (task != null) { final ActivityStack taskStack = task.stack; - if (mFocusedStack != taskStack) { - if (DEBUG_FOCUS || DEBUG_STACK) Slog.d(TAG, - "adjustStackFocus: Setting focused stack to r=" + r + " task=" + task); - mFocusedStack = taskStack; - } else { - if (DEBUG_FOCUS || DEBUG_STACK) Slog.d(TAG, - "adjustStackFocus: Focused stack already=" + mFocusedStack); + if (taskStack.isOnHomeDisplay()) { + if (mFocusedStack != taskStack) { + if (DEBUG_FOCUS || DEBUG_STACK) Slog.d(TAG, "adjustStackFocus: Setting " + + "focused stack to r=" + r + " task=" + task); + mFocusedStack = taskStack; + } else { + if (DEBUG_FOCUS || DEBUG_STACK) Slog.d(TAG, + "adjustStackFocus: Focused stack already=" + mFocusedStack); + } } return taskStack; } + final ActivityContainer container = r.mInitialActivityContainer; + if (container != null) { + // The first time put it on the desired stack, after this put on task stack. + r.mInitialActivityContainer = null; + return container.mStack; + } + if (mFocusedStack != mHomeStack) { if (DEBUG_FOCUS || DEBUG_STACK) Slog.d(TAG, "adjustStackFocus: Have a focused stack=" + mFocusedStack); return mFocusedStack; } - int numDisplays = mDisplayInfos.size(); - for (int displayNdx = 0; displayNdx < numDisplays; ++displayNdx) { - ArrayList<ActivityStack> stacks = mDisplayInfos.valueAt(displayNdx).stacks; - for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) { - ActivityStack stack = stacks.get(stackNdx); - if (!stack.isHomeStack()) { - if (DEBUG_FOCUS || DEBUG_STACK) Slog.d(TAG, - "adjustStackFocus: Setting focused stack=" + stack); - mFocusedStack = stack; - return mFocusedStack; - } + final ArrayList<ActivityStack> homeDisplayStacks = mHomeStack.mStacks; + for (int stackNdx = homeDisplayStacks.size() - 1; stackNdx >= 0; --stackNdx) { + final ActivityStack stack = homeDisplayStacks.get(stackNdx); + if (!stack.isHomeStack()) { + if (DEBUG_FOCUS || DEBUG_STACK) Slog.d(TAG, + "adjustStackFocus: Setting focused stack=" + stack); + mFocusedStack = stack; + return mFocusedStack; } } @@ -1472,7 +1485,7 @@ public final class ActivityStackSupervisor implements DisplayListener { targetStack.mLastPausedActivity = null; if (DEBUG_TASKS) Slog.d(TAG, "Bring to front target: " + targetStack + " from " + intentActivity); - moveHomeStack(targetStack.isHomeStack()); + targetStack.moveToFront(); if (intentActivity.task.intent == null) { // This task was started because of movement of // the activity based on affinity... now that we @@ -1691,7 +1704,7 @@ public final class ActivityStackSupervisor implements DisplayListener { if (r.resultTo == null && !addingToTask && (launchFlags&Intent.FLAG_ACTIVITY_NEW_TASK) != 0) { targetStack = adjustStackFocus(r); - moveHomeStack(targetStack.isHomeStack()); + targetStack.moveToFront(); if (reuseTask == null) { r.setTask(targetStack.createTaskRecord(getNextTaskId(), newTaskInfo != null ? newTaskInfo : r.info, @@ -1709,13 +1722,13 @@ public final class ActivityStackSupervisor implements DisplayListener { == (Intent.FLAG_ACTIVITY_NEW_TASK|Intent.FLAG_ACTIVITY_TASK_ON_HOME)) { // Caller wants to appear on home activity, so before starting // their own activity we will bring home to the front. - r.task.mOnTopOfHome = true; + r.task.mOnTopOfHome = r.task.stack.isOnHomeDisplay(); } } } else if (sourceRecord != null) { TaskRecord sourceTask = sourceRecord.task; targetStack = sourceTask.stack; - moveHomeStack(targetStack.isHomeStack()); + targetStack.moveToFront(); if (!addingToTask && (launchFlags&Intent.FLAG_ACTIVITY_CLEAR_TOP) != 0) { // In this case, we are adding the activity to an existing @@ -1769,7 +1782,7 @@ public final class ActivityStackSupervisor implements DisplayListener { // of a new task... just put it in the top task, though these days // this case should never happen. targetStack = adjustStackFocus(r); - moveHomeStack(targetStack.isHomeStack()); + targetStack.moveToFront(); ActivityRecord prev = targetStack.topActivity(); r.setTask(prev != null ? prev.task : targetStack.createTaskRecord(getNextTaskId(), r.info, intent, true), @@ -1961,8 +1974,8 @@ public final class ActivityStackSupervisor implements DisplayListener { boolean handleAppDiedLocked(ProcessRecord app) { boolean hasVisibleActivities = false; - for (int displayNdx = mDisplayInfos.size() - 1; displayNdx >= 0; --displayNdx) { - final ArrayList<ActivityStack> stacks = mDisplayInfos.valueAt(displayNdx).stacks; + for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) { + final ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks; for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) { hasVisibleActivities |= stacks.get(stackNdx).handleAppDiedLocked(app); } @@ -1971,8 +1984,8 @@ public final class ActivityStackSupervisor implements DisplayListener { } void closeSystemDialogsLocked() { - for (int displayNdx = mDisplayInfos.size() - 1; displayNdx >= 0; --displayNdx) { - final ArrayList<ActivityStack> stacks = mDisplayInfos.valueAt(displayNdx).stacks; + for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) { + final ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks; for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) { stacks.get(stackNdx).closeSystemDialogsLocked(); } @@ -1988,8 +2001,8 @@ public final class ActivityStackSupervisor implements DisplayListener { */ boolean forceStopPackageLocked(String name, boolean doit, boolean evenPersistent, int userId) { boolean didSomething = false; - for (int displayNdx = mDisplayInfos.size() - 1; displayNdx >= 0; --displayNdx) { - final ArrayList<ActivityStack> stacks = mDisplayInfos.valueAt(displayNdx).stacks; + for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) { + final ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks; final int numStacks = stacks.size(); for (int stackNdx = 0; stackNdx < numStacks; ++stackNdx) { final ActivityStack stack = stacks.get(stackNdx); @@ -2010,8 +2023,8 @@ public final class ActivityStackSupervisor implements DisplayListener { // we don't blow away the previous app if this activity is being // hosted by the process that is actually still the foreground. ProcessRecord fgApp = null; - for (int displayNdx = mDisplayInfos.size() - 1; displayNdx >= 0; --displayNdx) { - final ArrayList<ActivityStack> stacks = mDisplayInfos.valueAt(displayNdx).stacks; + for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) { + final ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks; for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) { final ActivityStack stack = stacks.get(stackNdx); if (isFrontStack(stack)) { @@ -2045,8 +2058,8 @@ public final class ActivityStackSupervisor implements DisplayListener { targetStack = getFocusedStack(); } boolean result = false; - for (int displayNdx = mDisplayInfos.size() - 1; displayNdx >= 0; --displayNdx) { - final ArrayList<ActivityStack> stacks = mDisplayInfos.valueAt(displayNdx).stacks; + for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) { + final ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks; for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) { final ActivityStack stack = stacks.get(stackNdx); if (isFrontStack(stack)) { @@ -2062,8 +2075,8 @@ public final class ActivityStackSupervisor implements DisplayListener { } void finishTopRunningActivityLocked(ProcessRecord app) { - for (int displayNdx = mDisplayInfos.size() - 1; displayNdx >= 0; --displayNdx) { - final ArrayList<ActivityStack> stacks = mDisplayInfos.valueAt(displayNdx).stacks; + for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) { + final ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks; final int numStacks = stacks.size(); for (int stackNdx = 0; stackNdx < numStacks; ++stackNdx) { final ActivityStack stack = stacks.get(stackNdx); @@ -2073,8 +2086,8 @@ public final class ActivityStackSupervisor implements DisplayListener { } void findTaskToMoveToFrontLocked(int taskId, int flags, Bundle options) { - for (int displayNdx = mDisplayInfos.size() - 1; displayNdx >= 0; --displayNdx) { - final ArrayList<ActivityStack> stacks = mDisplayInfos.valueAt(displayNdx).stacks; + for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) { + final ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks; for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) { if (stacks.get(stackNdx).findTaskToMoveToFrontLocked(taskId, flags, options)) { if (DEBUG_STACK) Slog.d(TAG, "findTaskToMoveToFront: moved to front of stack=" @@ -2095,8 +2108,8 @@ public final class ActivityStackSupervisor implements DisplayListener { ArrayList<ActivityStack> getStacks() { ArrayList<ActivityStack> allStacks = new ArrayList<ActivityStack>(); - for (int displayNdx = mDisplayInfos.size() - 1; displayNdx >= 0; --displayNdx) { - allStacks.addAll(mDisplayInfos.valueAt(displayNdx).stacks); + for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) { + allStacks.addAll(mActivityDisplays.valueAt(displayNdx).mStacks); } return allStacks; } @@ -2135,14 +2148,14 @@ public final class ActivityStackSupervisor implements DisplayListener { } private int createStackOnDisplay(ActivityRecord parentActivity, int stackId, int displayId) { - ActivityDisplayInfo displayInfo = mDisplayInfos.get(displayId); - if (displayInfo == null) { + ActivityDisplay activityDisplay = mActivityDisplays.get(displayId); + if (activityDisplay == null) { return -1; } ActivityContainer activityContainer = createActivityContainer(parentActivity, stackId, null); - activityContainer.attachToDisplayLocked(displayInfo); + activityContainer.attachToDisplayLocked(activityDisplay); return stackId; } @@ -2176,8 +2189,8 @@ public final class ActivityStackSupervisor implements DisplayListener { ActivityRecord findTaskLocked(ActivityRecord r) { if (DEBUG_TASKS) Slog.d(TAG, "Looking for task of " + r); - for (int displayNdx = mDisplayInfos.size() - 1; displayNdx >= 0; --displayNdx) { - final ArrayList<ActivityStack> stacks = mDisplayInfos.valueAt(displayNdx).stacks; + for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) { + final ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks; for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) { final ActivityStack stack = stacks.get(stackNdx); if (!r.isApplicationActivity() && !stack.isHomeStack()) { @@ -2195,8 +2208,8 @@ public final class ActivityStackSupervisor implements DisplayListener { } ActivityRecord findActivityLocked(Intent intent, ActivityInfo info) { - for (int displayNdx = mDisplayInfos.size() - 1; displayNdx >= 0; --displayNdx) { - final ArrayList<ActivityStack> stacks = mDisplayInfos.valueAt(displayNdx).stacks; + for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) { + final ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks; for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) { final ActivityRecord ar = stacks.get(stackNdx).findActivityLocked(intent, info); if (ar != null) { @@ -2229,8 +2242,8 @@ public final class ActivityStackSupervisor implements DisplayListener { final long endTime = System.currentTimeMillis() + timeout; while (true) { boolean cantShutdown = false; - for (int displayNdx = mDisplayInfos.size() - 1; displayNdx >= 0; --displayNdx) { - final ArrayList<ActivityStack> stacks = mDisplayInfos.valueAt(displayNdx).stacks; + for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) { + final ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks; for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) { cantShutdown |= stacks.get(stackNdx).checkReadyForSleepLocked(); } @@ -2264,8 +2277,8 @@ public final class ActivityStackSupervisor implements DisplayListener { if (mGoingToSleep.isHeld()) { mGoingToSleep.release(); } - for (int displayNdx = mDisplayInfos.size() - 1; displayNdx >= 0; --displayNdx) { - final ArrayList<ActivityStack> stacks = mDisplayInfos.valueAt(displayNdx).stacks; + for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) { + final ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks; for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) { final ActivityStack stack = stacks.get(stackNdx); stack.awakeFromSleepingLocked(); @@ -2290,8 +2303,8 @@ public final class ActivityStackSupervisor implements DisplayListener { if (!mSleepTimeout) { boolean dontSleep = false; - for (int displayNdx = mDisplayInfos.size() - 1; displayNdx >= 0; --displayNdx) { - final ArrayList<ActivityStack> stacks = mDisplayInfos.valueAt(displayNdx).stacks; + for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) { + final ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks; for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) { dontSleep |= stacks.get(stackNdx).checkReadyForSleepLocked(); } @@ -2317,8 +2330,8 @@ public final class ActivityStackSupervisor implements DisplayListener { } } - for (int displayNdx = mDisplayInfos.size() - 1; displayNdx >= 0; --displayNdx) { - final ArrayList<ActivityStack> stacks = mDisplayInfos.valueAt(displayNdx).stacks; + for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) { + final ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks; for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) { stacks.get(stackNdx).goToSleep(); } @@ -2348,8 +2361,8 @@ public final class ActivityStackSupervisor implements DisplayListener { } void handleAppCrashLocked(ProcessRecord app) { - for (int displayNdx = mDisplayInfos.size() - 1; displayNdx >= 0; --displayNdx) { - final ArrayList<ActivityStack> stacks = mDisplayInfos.valueAt(displayNdx).stacks; + for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) { + final ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks; final int numStacks = stacks.size(); for (int stackNdx = 0; stackNdx < numStacks; ++stackNdx) { final ActivityStack stack = stacks.get(stackNdx); @@ -2361,8 +2374,8 @@ public final class ActivityStackSupervisor implements DisplayListener { void ensureActivitiesVisibleLocked(ActivityRecord starting, int configChanges) { // First the front stacks. In case any are not fullscreen and are in front of home. boolean showHomeBehindStack = false; - for (int displayNdx = mDisplayInfos.size() - 1; displayNdx >= 0; --displayNdx) { - final ArrayList<ActivityStack> stacks = mDisplayInfos.valueAt(displayNdx).stacks; + for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) { + final ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks; final int topStackNdx = stacks.size() - 1; for (int stackNdx = topStackNdx; stackNdx >= 0; --stackNdx) { final ActivityStack stack = stacks.get(stackNdx); @@ -2380,8 +2393,8 @@ public final class ActivityStackSupervisor implements DisplayListener { } void scheduleDestroyAllActivities(ProcessRecord app, String reason) { - for (int displayNdx = mDisplayInfos.size() - 1; displayNdx >= 0; --displayNdx) { - final ArrayList<ActivityStack> stacks = mDisplayInfos.valueAt(displayNdx).stacks; + for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) { + final ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks; final int numStacks = stacks.size(); for (int stackNdx = 0; stackNdx < numStacks; ++stackNdx) { final ActivityStack stack = stacks.get(stackNdx); @@ -2396,10 +2409,12 @@ public final class ActivityStackSupervisor implements DisplayListener { mCurrentUser = userId; mStartingUsers.add(uss); - for (int displayNdx = mDisplayInfos.size() - 1; displayNdx >= 0; --displayNdx) { - final ArrayList<ActivityStack> stacks = mDisplayInfos.valueAt(displayNdx).stacks; + for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) { + final ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks; for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) { - stacks.get(stackNdx).switchUserLocked(userId); + final ActivityStack stack = stacks.get(stackNdx); + stack.switchUserLocked(userId); + mWindowManager.moveTaskToTop(stack.topTask().taskId); } } @@ -2408,8 +2423,13 @@ public final class ActivityStackSupervisor implements DisplayListener { stack = mHomeStack; } final boolean homeInFront = stack.isHomeStack(); - moveHomeStack(homeInFront); - mWindowManager.moveTaskToTop(stack.topTask().taskId); + if (stack.isOnHomeDisplay()) { + moveHomeStack(homeInFront); + mWindowManager.moveTaskToTop(stack.topTask().taskId); + } else { + // Stack was moved to another display while user was swapped out. + resumeHomeActivity(null); + } return homeInFront; } @@ -2522,10 +2542,10 @@ public final class ActivityStackSupervisor implements DisplayListener { boolean dumpClient, String dumpPackage) { boolean printed = false; boolean needSep = false; - for (int displayNdx = 0; displayNdx < mDisplayInfos.size(); ++displayNdx) { - ActivityDisplayInfo info = mDisplayInfos.valueAt(displayNdx); - pw.print("Display #"); pw.println(info.mDisplayId); - ArrayList<ActivityStack> stacks = info.stacks; + for (int displayNdx = 0; displayNdx < mActivityDisplays.size(); ++displayNdx) { + ActivityDisplay activityDisplay = mActivityDisplays.valueAt(displayNdx); + pw.print("Display #"); pw.println(activityDisplay.mDisplayId); + ArrayList<ActivityStack> stacks = activityDisplay.mStacks; final int numStacks = stacks.size(); for (int stackNdx = 0; stackNdx < numStacks; ++stackNdx) { final ActivityStack stack = stacks.get(stackNdx); @@ -2710,21 +2730,21 @@ public final class ActivityStackSupervisor implements DisplayListener { public void handleDisplayAddedLocked(int displayId) { synchronized (mService) { - ActivityDisplayInfo info = new ActivityDisplayInfo(displayId); - mDisplayInfos.put(displayId, info); + ActivityDisplay activityDisplay = new ActivityDisplay(displayId); + mActivityDisplays.put(displayId, activityDisplay); } mWindowManager.onDisplayAdded(displayId); } public void handleDisplayRemovedLocked(int displayId) { synchronized (mService) { - ActivityDisplayInfo info = mDisplayInfos.get(displayId); - if (info != null) { - ArrayList<ActivityStack> stacks = info.stacks; + ActivityDisplay activityDisplay = mActivityDisplays.get(displayId); + if (activityDisplay != null) { + ArrayList<ActivityStack> stacks = activityDisplay.mStacks; for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) { - info.detachActivities(stacks.get(stackNdx)); + activityDisplay.detachActivitiesLocked(stacks.get(stackNdx)); } - mDisplayInfos.remove(displayId); + mActivityDisplays.remove(displayId); } } mWindowManager.onDisplayRemoved(displayId); @@ -2732,8 +2752,8 @@ public final class ActivityStackSupervisor implements DisplayListener { public void handleDisplayChangedLocked(int displayId) { synchronized (mService) { - ActivityDisplayInfo info = mDisplayInfos.get(displayId); - if (info != null) { + ActivityDisplay activityDisplay = mActivityDisplays.get(displayId); + if (activityDisplay != null) { // TODO: Update the bounds. } } @@ -2773,8 +2793,8 @@ public final class ActivityStackSupervisor implements DisplayListener { ArrayList<StackInfo> getAllStackInfosLocked() { ArrayList<StackInfo> list = new ArrayList<StackInfo>(); - for (int displayNdx = 0; displayNdx < mDisplayInfos.size(); ++displayNdx) { - ArrayList<ActivityStack> stacks = mDisplayInfos.valueAt(displayNdx).stacks; + for (int displayNdx = 0; displayNdx < mActivityDisplays.size(); ++displayNdx) { + ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks; for (int ndx = stacks.size() - 1; ndx >= 0; --ndx) { list.add(getStackInfo(stacks.get(ndx))); } @@ -2865,7 +2885,7 @@ public final class ActivityStackSupervisor implements DisplayListener { final ActivityRecord mParentActivity; /** Display this ActivityStack is currently on. Null if not attached to a Display. */ - ActivityDisplayInfo mActivityDisplayInfo; + ActivityDisplay mActivityDisplay; ActivityContainer(ActivityRecord parentActivity, int stackId, IActivityContainerCallback callback) { @@ -2877,32 +2897,40 @@ public final class ActivityStackSupervisor implements DisplayListener { } } - void attachToDisplayLocked(ActivityDisplayInfo displayInfo) { - mActivityDisplayInfo = displayInfo; - displayInfo.attachActivities(mStack); - mWindowManager.createStack(mStackId, displayInfo.mDisplayId); + void attachToDisplayLocked(ActivityDisplay activityDisplay) { + mActivityDisplay = activityDisplay; + mStack.mDisplayId = activityDisplay.mDisplayId; + mStack.mStacks = activityDisplay.mStacks; + + activityDisplay.attachActivities(mStack); + mWindowManager.createStack(mStackId, activityDisplay.mDisplayId); } @Override public void attachToDisplay(int displayId) throws RemoteException { synchronized (mService) { - ActivityDisplayInfo displayInfo = mDisplayInfos.get(displayId); - if (displayInfo == null) { + ActivityDisplay activityDisplay = mActivityDisplays.get(displayId); + if (activityDisplay == null) { return; } - attachToDisplayLocked(displayInfo); + attachToDisplayLocked(activityDisplay); } } @Override - public int getStackId() throws RemoteException { - return mStack.mStackId; + public int getDisplayId() throws RemoteException { + if (mActivityDisplay != null) { + return mActivityDisplay.mDisplayId; + } + return -1; } void detachLocked() { - if (mActivityDisplayInfo != null) { - mActivityDisplayInfo.detachActivities(mStack); - mActivityDisplayInfo = null; + if (mActivityDisplay != null) { + mActivityDisplay.detachActivitiesLocked(mStack); + mActivityDisplay = null; + mStack.mDisplayId = -1; + mStack.mStacks = null; } } @@ -2914,8 +2942,18 @@ public final class ActivityStackSupervisor implements DisplayListener { } @Override - public void startActivity(Intent intent) throws RemoteException { - + public final int startActivity(Intent intent) { + mService.enforceNotIsolatedCaller("ActivityContainer"); + int userId = mService.handleIncomingUser(Binder.getCallingPid(), + Binder.getCallingUid(), mCurrentUser, false, true, "ActivityContainer", null); + // TODO: Switch to user app stacks here. + String mimeType = intent.getType(); + if (mimeType == null && intent.getData() != null + && "content".equals(intent.getData().getScheme())) { + mimeType = mService.getProviderMimeType(intent.getData(), userId); + } + return startActivityMayWait(null, -1, null, intent, mimeType, null, null, 0, 0, null, + null, null, null, null, userId, this); } @Override @@ -2928,12 +2966,12 @@ public final class ActivityStackSupervisor implements DisplayListener { } boolean isAttached() { - return mActivityDisplayInfo != null; + return mActivityDisplay != null; } void getBounds(Point outBounds) { - if (mActivityDisplayInfo != null) { - mActivityDisplayInfo.getBounds(outBounds); + if (mActivityDisplay != null) { + mActivityDisplay.getBounds(outBounds); } else { outBounds.set(0, 0); } @@ -2942,7 +2980,7 @@ public final class ActivityStackSupervisor implements DisplayListener { /** Exactly one of these classes per Display in the system. Capable of holding zero or more * attached {@link ActivityStack}s */ - final class ActivityDisplayInfo { + final class ActivityDisplay { /** Actual Display this object tracks. */ final int mDisplayId; final Display mDisplay; @@ -2950,20 +2988,24 @@ public final class ActivityStackSupervisor implements DisplayListener { /** All of the stacks on this display. Order matters, topmost stack is in front of all other * stacks, bottommost behind. Accessed directly by ActivityManager package classes */ - final ArrayList<ActivityStack> stacks = new ArrayList<ActivityStack>(); + final ArrayList<ActivityStack> mStacks = new ArrayList<ActivityStack>(); - ActivityDisplayInfo(int displayId) { + ActivityDisplay(int displayId) { mDisplayId = displayId; mDisplay = mDisplayManager.getDisplay(displayId); mDisplay.getDisplayInfo(mDisplayInfo); } void attachActivities(ActivityStack stack) { - stacks.add(stack); + if (DEBUG_STACK) Slog.v(TAG, "attachActivities: attaching " + stack + " to displayId=" + + mDisplayId); + mStacks.add(stack); } - void detachActivities(ActivityStack stack) { - stacks.remove(stack); + void detachActivitiesLocked(ActivityStack stack) { + if (DEBUG_STACK) Slog.v(TAG, "attachActivities: detaching " + stack + + " from displayId=" + mDisplayId); + mStacks.remove(stack); } void getBounds(Point bounds) { diff --git a/services/core/java/com/android/server/am/TaskRecord.java b/services/core/java/com/android/server/am/TaskRecord.java index 9105103ac632..9740812e654c 100644 --- a/services/core/java/com/android/server/am/TaskRecord.java +++ b/services/core/java/com/android/server/am/TaskRecord.java @@ -60,7 +60,8 @@ final class TaskRecord extends ThumbnailHolder { /** Takes on same set of values as ActivityRecord.mActivityType */ private int mTaskType; - /** Launch the home activity when leaving this task. */ + /** Launch the home activity when leaving this task. Will be false for tasks that are not on + * Display.DEFAULT_DISPLAY. */ boolean mOnTopOfHome = false; TaskRecord(int _taskId, ActivityInfo info, Intent _intent) { diff --git a/services/core/java/com/android/server/input/InputApplicationHandle.java b/services/core/java/com/android/server/input/InputApplicationHandle.java index 42c10526bcec..3cf7edcd6b2e 100644 --- a/services/core/java/com/android/server/input/InputApplicationHandle.java +++ b/services/core/java/com/android/server/input/InputApplicationHandle.java @@ -26,7 +26,7 @@ public final class InputApplicationHandle { // Pointer to the native input application handle. // This field is lazily initialized via JNI. @SuppressWarnings("unused") - private int ptr; + private long ptr; // The window manager's application window token. public final Object appWindowToken; diff --git a/services/core/java/com/android/server/input/InputManagerService.java b/services/core/java/com/android/server/input/InputManagerService.java index c3c22f63c2b5..825a31d1b586 100644 --- a/services/core/java/com/android/server/input/InputManagerService.java +++ b/services/core/java/com/android/server/input/InputManagerService.java @@ -108,7 +108,7 @@ public class InputManagerService extends IInputManager.Stub private static final int MSG_RELOAD_DEVICE_ALIASES = 5; // Pointer to native input manager service object. - private final int mPtr; + private final long mPtr; private final Context mContext; private final InputManagerHandler mHandler; @@ -147,46 +147,46 @@ public class InputManagerService extends IInputManager.Stub IInputFilter mInputFilter; // guarded by mInputFilterLock InputFilterHost mInputFilterHost; // guarded by mInputFilterLock - private static native int nativeInit(InputManagerService service, + private static native long nativeInit(InputManagerService service, Context context, MessageQueue messageQueue); - private static native void nativeStart(int ptr); - private static native void nativeSetDisplayViewport(int ptr, boolean external, + private static native void nativeStart(long ptr); + private static native void nativeSetDisplayViewport(long ptr, boolean external, int displayId, int rotation, int logicalLeft, int logicalTop, int logicalRight, int logicalBottom, int physicalLeft, int physicalTop, int physicalRight, int physicalBottom, int deviceWidth, int deviceHeight); - private static native int nativeGetScanCodeState(int ptr, + private static native int nativeGetScanCodeState(long ptr, int deviceId, int sourceMask, int scanCode); - private static native int nativeGetKeyCodeState(int ptr, + private static native int nativeGetKeyCodeState(long ptr, int deviceId, int sourceMask, int keyCode); - private static native int nativeGetSwitchState(int ptr, + private static native int nativeGetSwitchState(long ptr, int deviceId, int sourceMask, int sw); - private static native boolean nativeHasKeys(int ptr, + private static native boolean nativeHasKeys(long ptr, int deviceId, int sourceMask, int[] keyCodes, boolean[] keyExists); - private static native void nativeRegisterInputChannel(int ptr, InputChannel inputChannel, + private static native void nativeRegisterInputChannel(long ptr, InputChannel inputChannel, InputWindowHandle inputWindowHandle, boolean monitor); - 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, + private static native void nativeUnregisterInputChannel(long ptr, InputChannel inputChannel); + private static native void nativeSetInputFilterEnabled(long ptr, boolean enable); + private static native int nativeInjectInputEvent(long ptr, InputEvent event, int injectorPid, int injectorUid, int syncMode, int timeoutMillis, int policyFlags); - 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, + private static native void nativeSetInputWindows(long ptr, InputWindowHandle[] windowHandles); + private static native void nativeSetInputDispatchMode(long ptr, boolean enabled, boolean frozen); + private static native void nativeSetSystemUiVisibility(long ptr, int visibility); + private static native void nativeSetFocusedApplication(long ptr, InputApplicationHandle application); - private static native boolean nativeTransferTouchFocus(int ptr, + private static native boolean nativeTransferTouchFocus(long 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 void nativeVibrate(int ptr, int deviceId, long[] pattern, + private static native void nativeSetPointerSpeed(long ptr, int speed); + private static native void nativeSetShowTouches(long ptr, boolean enabled); + private static native void nativeVibrate(long ptr, int deviceId, long[] pattern, int repeat, int token); - private static native void nativeCancelVibrate(int ptr, int deviceId, int token); - private static native void nativeReloadKeyboardLayouts(int ptr); - private static native void nativeReloadDeviceAliases(int ptr); - private static native String nativeDump(int ptr); - private static native void nativeMonitor(int ptr); + private static native void nativeCancelVibrate(long ptr, int deviceId, int token); + private static native void nativeReloadKeyboardLayouts(long ptr); + private static native void nativeReloadDeviceAliases(long ptr); + private static native String nativeDump(long ptr); + private static native void nativeMonitor(long ptr); // Input event injection constants defined in InputDispatcher.h. private static final int INPUT_EVENT_INJECTION_SUCCEEDED = 0; diff --git a/services/core/java/com/android/server/input/InputWindowHandle.java b/services/core/java/com/android/server/input/InputWindowHandle.java index 9eb9a3342f21..9a70f38ceac7 100644 --- a/services/core/java/com/android/server/input/InputWindowHandle.java +++ b/services/core/java/com/android/server/input/InputWindowHandle.java @@ -28,7 +28,7 @@ public final class InputWindowHandle { // Pointer to the native input window handle. // This field is lazily initialized via JNI. @SuppressWarnings("unused") - private int ptr; + private long ptr; // The input application handle. public final InputApplicationHandle inputApplicationHandle; diff --git a/services/core/java/com/android/server/lights/LightsService.java b/services/core/java/com/android/server/lights/LightsService.java index d81478500a9f..62dc0901bb45 100644 --- a/services/core/java/com/android/server/lights/LightsService.java +++ b/services/core/java/com/android/server/lights/LightsService.java @@ -195,11 +195,11 @@ public class LightsService extends SystemService { } }; - private static native int init_native(); - private static native void finalize_native(int ptr); + private static native long init_native(); + private static native void finalize_native(long ptr); - static native void setLight_native(int ptr, int light, int color, int mode, + static native void setLight_native(long ptr, int light, int color, int mode, int onMS, int offMS, int brightnessMode); - int mNativePointer; + private long mNativePointer; } diff --git a/services/core/java/com/android/server/pm/PackageManagerService.java b/services/core/java/com/android/server/pm/PackageManagerService.java index d241f6fb5bb9..9a26deee2af2 100755 --- a/services/core/java/com/android/server/pm/PackageManagerService.java +++ b/services/core/java/com/android/server/pm/PackageManagerService.java @@ -4997,8 +4997,9 @@ public class PackageManagerService extends IPackageManager.Stub { // discard the previous declaration and consider the system's to be // canonical. if (isSystemApp(p.owner)) { - Slog.i(TAG, "New decl " + p.owner + " of permission " - + p.info.name + " is system"); + String msg = "New decl " + p.owner + " of permission " + + p.info.name + " is system"; + reportSettingsProblem(Log.WARN, msg); bp.sourcePackage = null; } } diff --git a/services/core/java/com/android/server/usb/UsbHostManager.java b/services/core/java/com/android/server/usb/UsbHostManager.java index 10272f270f2a..dfaad0bcece9 100644 --- a/services/core/java/com/android/server/usb/UsbHostManager.java +++ b/services/core/java/com/android/server/usb/UsbHostManager.java @@ -96,6 +96,7 @@ public class UsbHostManager { /* Called from JNI in monitorUsbHostBus() to report new USB devices */ private void usbDeviceAdded(String deviceName, int vendorID, int productID, int deviceClass, int deviceSubclass, int deviceProtocol, + String manufacturerName, String productName, String serialNumber, /* array of quintuples containing id, class, subclass, protocol and number of endpoints for each interface */ int[] interfaceValues, @@ -151,7 +152,8 @@ public class UsbHostManager { } UsbDevice device = new UsbDevice(deviceName, vendorID, productID, - deviceClass, deviceSubclass, deviceProtocol, interfaces); + deviceClass, deviceSubclass, deviceProtocol, + manufacturerName, productName, serialNumber, interfaces); mDevices.put(deviceName, device); getCurrentSettings().deviceAttached(device); } diff --git a/services/core/java/com/android/server/usb/UsbSettingsManager.java b/services/core/java/com/android/server/usb/UsbSettingsManager.java index 9b5b31279ee0..ff4857ba1be8 100644 --- a/services/core/java/com/android/server/usb/UsbSettingsManager.java +++ b/services/core/java/com/android/server/usb/UsbSettingsManager.java @@ -108,13 +108,23 @@ class UsbSettingsManager { public final int mSubclass; // USB device protocol (or -1 for unspecified) public final int mProtocol; - - public DeviceFilter(int vid, int pid, int clasz, int subclass, int protocol) { + // USB device manufacturer name string (or null for unspecified) + public final String mManufacturerName; + // USB device product name string (or null for unspecified) + public final String mProductName; + // USB device serial number string (or null for unspecified) + public final String mSerialNumber; + + public DeviceFilter(int vid, int pid, int clasz, int subclass, int protocol, + String manufacturer, String product, String serialnum) { mVendorId = vid; mProductId = pid; mClass = clasz; mSubclass = subclass; mProtocol = protocol; + mManufacturerName = manufacturer; + mProductName = product; + mSerialNumber = serialnum; } public DeviceFilter(UsbDevice device) { @@ -123,6 +133,9 @@ class UsbSettingsManager { mClass = device.getDeviceClass(); mSubclass = device.getDeviceSubclass(); mProtocol = device.getDeviceProtocol(); + mManufacturerName = device.getManufacturerName(); + mProductName = device.getProductName(); + mSerialNumber = device.getSerialNumber(); } public static DeviceFilter read(XmlPullParser parser) @@ -132,27 +145,52 @@ class UsbSettingsManager { int deviceClass = -1; int deviceSubclass = -1; int deviceProtocol = -1; + String manufacturerName = null; + String productName = null; + String serialNumber = null; int count = parser.getAttributeCount(); for (int i = 0; i < count; i++) { String name = parser.getAttributeName(i); - // All attribute values are ints - int value = Integer.parseInt(parser.getAttributeValue(i)); - - if ("vendor-id".equals(name)) { - vendorId = value; - } else if ("product-id".equals(name)) { - productId = value; - } else if ("class".equals(name)) { - deviceClass = value; - } else if ("subclass".equals(name)) { - deviceSubclass = value; - } else if ("protocol".equals(name)) { - deviceProtocol = value; + String value = parser.getAttributeValue(i); + // Attribute values are ints or strings + if ("manufacturer-name".equals(name)) { + manufacturerName = value; + } else if ("product-name".equals(name)) { + productName = value; + } else if ("serial-number".equals(name)) { + serialNumber = value; + } else { + int intValue = -1; + int radix = 10; + if (value != null && value.length() > 2 && value.charAt(0) == '0' && + (value.charAt(1) == 'x' || value.charAt(1) == 'X')) { + // allow hex values starting with 0x or 0X + radix = 16; + value = value.substring(2); + } + try { + intValue = Integer.parseInt(value, radix); + } catch (NumberFormatException e) { + Slog.e(TAG, "invalid number for field " + name, e); + continue; + } + if ("vendor-id".equals(name)) { + vendorId = intValue; + } else if ("product-id".equals(name)) { + productId = intValue; + } else if ("class".equals(name)) { + deviceClass = intValue; + } else if ("subclass".equals(name)) { + deviceSubclass = intValue; + } else if ("protocol".equals(name)) { + deviceProtocol = intValue; + } } } return new DeviceFilter(vendorId, productId, - deviceClass, deviceSubclass, deviceProtocol); + deviceClass, deviceSubclass, deviceProtocol, + manufacturerName, productName, serialNumber); } public void write(XmlSerializer serializer) throws IOException { @@ -172,6 +210,15 @@ class UsbSettingsManager { if (mProtocol != -1) { serializer.attribute(null, "protocol", Integer.toString(mProtocol)); } + if (mManufacturerName != null) { + serializer.attribute(null, "manufacturer-name", mManufacturerName); + } + if (mProductName != null) { + serializer.attribute(null, "product-name", mProductName); + } + if (mSerialNumber != null) { + serializer.attribute(null, "serial-number", mSerialNumber); + } serializer.endTag(null, "usb-device"); } @@ -184,6 +231,15 @@ class UsbSettingsManager { public boolean matches(UsbDevice device) { if (mVendorId != -1 && device.getVendorId() != mVendorId) return false; if (mProductId != -1 && device.getProductId() != mProductId) return false; + if (mManufacturerName != null && device.getManufacturerName() == null) return false; + if (mProductName != null && device.getProductName() == null) return false; + if (mSerialNumber != null && device.getSerialNumber() == null) return false; + if (mManufacturerName != null && device.getManufacturerName() != null && + !mManufacturerName.equals(device.getManufacturerName())) return false; + if (mProductName != null && device.getProductName() != null && + !mProductName.equals(device.getProductName())) return false; + if (mSerialNumber != null && device.getSerialNumber() != null && + !mSerialNumber.equals(device.getSerialNumber())) return false; // check device class/subclass/protocol if (matches(device.getDeviceClass(), device.getDeviceSubclass(), @@ -203,6 +259,15 @@ class UsbSettingsManager { public boolean matches(DeviceFilter f) { if (mVendorId != -1 && f.mVendorId != mVendorId) return false; if (mProductId != -1 && f.mProductId != mProductId) return false; + if (f.mManufacturerName != null && mManufacturerName == null) return false; + if (f.mProductName != null && mProductName == null) return false; + if (f.mSerialNumber != null && mSerialNumber == null) return false; + if (mManufacturerName != null && f.mManufacturerName != null && + !mManufacturerName.equals(f.mManufacturerName)) return false; + if (mProductName != null && f.mProductName != null && + !mProductName.equals(f.mProductName)) return false; + if (mSerialNumber != null && f.mSerialNumber != null && + !mSerialNumber.equals(f.mSerialNumber)) return false; // check device class/subclass/protocol return matches(f.mClass, f.mSubclass, f.mProtocol); @@ -217,19 +282,67 @@ class UsbSettingsManager { } if (obj instanceof DeviceFilter) { DeviceFilter filter = (DeviceFilter)obj; - return (filter.mVendorId == mVendorId && - filter.mProductId == mProductId && - filter.mClass == mClass && - filter.mSubclass == mSubclass && - filter.mProtocol == mProtocol); + + if (filter.mVendorId != mVendorId || + filter.mProductId != mProductId || + filter.mClass != mClass || + filter.mSubclass != mSubclass || + filter.mProtocol != mProtocol) { + return(false); + } + if ((filter.mManufacturerName != null && + mManufacturerName == null) || + (filter.mManufacturerName == null && + mManufacturerName != null) || + (filter.mProductName != null && + mProductName == null) || + (filter.mProductName == null && + mProductName != null) || + (filter.mSerialNumber != null && + mSerialNumber == null) || + (filter.mSerialNumber == null && + mSerialNumber != null)) { + return(false); + } + if ((filter.mManufacturerName != null && + mManufacturerName != null && + !mManufacturerName.equals(filter.mManufacturerName)) || + (filter.mProductName != null && + mProductName != null && + !mProductName.equals(filter.mProductName)) || + (filter.mSerialNumber != null && + mSerialNumber != null && + !mSerialNumber.equals(filter.mSerialNumber))) { + return(false); + } + return(true); } if (obj instanceof UsbDevice) { UsbDevice device = (UsbDevice)obj; - return (device.getVendorId() == mVendorId && - device.getProductId() == mProductId && - device.getDeviceClass() == mClass && - device.getDeviceSubclass() == mSubclass && - device.getDeviceProtocol() == mProtocol); + if (device.getVendorId() != mVendorId || + device.getProductId() != mProductId || + device.getDeviceClass() != mClass || + device.getDeviceSubclass() != mSubclass || + device.getDeviceProtocol() != mProtocol) { + return(false); + } + if ((mManufacturerName != null && device.getManufacturerName() == null) || + (mManufacturerName == null && device.getManufacturerName() != null) || + (mProductName != null && device.getProductName() == null) || + (mProductName == null && device.getProductName() != null) || + (mSerialNumber != null && device.getSerialNumber() == null) || + (mSerialNumber == null && device.getSerialNumber() != null)) { + return(false); + } + if ((device.getManufacturerName() != null && + !mManufacturerName.equals(device.getManufacturerName())) || + (device.getProductName() != null && + !mProductName.equals(device.getProductName())) || + (device.getSerialNumber() != null && + !mSerialNumber.equals(device.getSerialNumber()))) { + return(false); + } + return true; } return false; } @@ -244,7 +357,9 @@ class UsbSettingsManager { public String toString() { return "DeviceFilter[mVendorId=" + mVendorId + ",mProductId=" + mProductId + ",mClass=" + mClass + ",mSubclass=" + mSubclass + - ",mProtocol=" + mProtocol + "]"; + ",mProtocol=" + mProtocol + ",mManufacturerName=" + mManufacturerName + + ",mProductName=" + mProductName + ",mSerialNumber=" + mSerialNumber + + "]"; } } diff --git a/services/core/java/com/android/server/wm/DisplayContent.java b/services/core/java/com/android/server/wm/DisplayContent.java index 40643774c14d..0a070c1402ee 100644 --- a/services/core/java/com/android/server/wm/DisplayContent.java +++ b/services/core/java/com/android/server/wm/DisplayContent.java @@ -191,6 +191,9 @@ class DisplayContent { } TaskStack getHomeStack() { + if (mHomeStack == null) { + Slog.e(TAG, "getHomeStack: Returning null from this=" + this); + } return mHomeStack; } @@ -430,4 +433,9 @@ class DisplayContent { } pw.println(); } + + @Override + public String toString() { + return "Display " + mDisplayId + " info=" + mDisplayInfo + " stacks=" + mStacks; + } } diff --git a/services/core/java/com/android/server/wm/WindowManagerService.java b/services/core/java/com/android/server/wm/WindowManagerService.java index 8b863e159831..b71fc1996e26 100644 --- a/services/core/java/com/android/server/wm/WindowManagerService.java +++ b/services/core/java/com/android/server/wm/WindowManagerService.java @@ -4781,11 +4781,13 @@ public class WindowManagerService extends IWindowManager.Stub final TaskStack stack = task.mStack; final DisplayContent displayContent = task.getDisplayContent(); displayContent.moveStack(stack, true); - final TaskStack homeStack = displayContent.getHomeStack(); - if (homeStack != stack) { - // When a non-home stack moves to the top, the home stack moves to the - // bottom. - displayContent.moveStack(homeStack, false); + if (displayContent.isDefaultDisplay) { + final TaskStack homeStack = displayContent.getHomeStack(); + if (homeStack != stack) { + // When a non-home stack moves to the top, the home stack moves to the + // bottom. + displayContent.moveStack(homeStack, false); + } } stack.moveTaskToTop(task); } @@ -8981,6 +8983,10 @@ public class WindowManagerService extends IWindowManager.Stub final int N = windows.size(); for (i=N-1; i>=0; i--) { WindowState w = windows.get(i); + final TaskStack stack = w.getStack(); + if (stack == null) { + continue; + } final boolean obscuredChanged = w.mObscured != mInnerFields.mObscured; @@ -8990,7 +8996,7 @@ public class WindowManagerService extends IWindowManager.Stub handleNotObscuredLocked(w, currentTime, innerDw, innerDh); } - if (!w.getStack().testDimmingTag()) { + if (!stack.testDimmingTag()) { handleFlagDimBehind(w, innerDw, innerDh); } diff --git a/services/core/java/com/android/server/wm/WindowState.java b/services/core/java/com/android/server/wm/WindowState.java index e6c1e98b0547..77a36b81f6e6 100644 --- a/services/core/java/com/android/server/wm/WindowState.java +++ b/services/core/java/com/android/server/wm/WindowState.java @@ -717,7 +717,12 @@ final class WindowState implements WindowManagerPolicy.WindowState { if (wtoken != null) { Task task = mService.mTaskIdToTask.get(wtoken.groupId); if (task != null) { - return task.mStack; + if (task.mStack != null) { + return task.mStack; + } + Slog.e(TAG, "getStack: mStack null for task=" + task); + } else { + Slog.e(TAG, "getStack: couldn't find taskId=" + wtoken.groupId); } } return mDisplayContent.getHomeStack(); diff --git a/services/core/jni/com_android_server_UsbHostManager.cpp b/services/core/jni/com_android_server_UsbHostManager.cpp index 639790b7de19..f1fa6cf07f60 100644 --- a/services/core/jni/com_android_server_UsbHostManager.cpp +++ b/services/core/jni/com_android_server_UsbHostManager.cpp @@ -73,6 +73,9 @@ static int usb_device_added(const char *devname, void* client_data) { uint8_t deviceClass = deviceDesc->bDeviceClass; uint8_t deviceSubClass = deviceDesc->bDeviceSubClass; uint8_t protocol = deviceDesc->bDeviceProtocol; + char *manufacturer = usb_device_get_manufacturer_name(device); + char *product = usb_device_get_product_name(device); + char *serial = usb_device_get_serial(device); usb_descriptor_iter_init(device, &iter); @@ -109,12 +112,19 @@ static int usb_device_added(const char *devname, void* client_data) { env->SetIntArrayRegion(endpointArray, 0, length, endpointValues.array()); jstring deviceName = env->NewStringUTF(devname); + jstring manufacturerName = env->NewStringUTF(manufacturer); + jstring productName = env->NewStringUTF(product); + jstring serialNumber = env->NewStringUTF(serial); env->CallVoidMethod(thiz, method_usbDeviceAdded, deviceName, vendorId, productId, deviceClass, - deviceSubClass, protocol, interfaceArray, endpointArray); + deviceSubClass, protocol, manufacturerName, + productName, serialNumber, interfaceArray, endpointArray); env->DeleteLocalRef(interfaceArray); env->DeleteLocalRef(endpointArray); + env->DeleteLocalRef(serialNumber); + env->DeleteLocalRef(productName); + env->DeleteLocalRef(manufacturerName); env->DeleteLocalRef(deviceName); checkAndClearExceptionFromCallback(env, __FUNCTION__); @@ -179,7 +189,7 @@ int register_android_server_UsbHostManager(JNIEnv *env) ALOGE("Can't find com/android/server/usb/UsbHostManager"); return -1; } - method_usbDeviceAdded = env->GetMethodID(clazz, "usbDeviceAdded", "(Ljava/lang/String;IIIII[I[I)V"); + method_usbDeviceAdded = env->GetMethodID(clazz, "usbDeviceAdded", "(Ljava/lang/String;IIIIILjava/lang/String;Ljava/lang/String;Ljava/lang/String;[I[I)V"); if (method_usbDeviceAdded == NULL) { ALOGE("Can't find usbDeviceAdded"); return -1; diff --git a/services/core/jni/com_android_server_input_InputApplicationHandle.cpp b/services/core/jni/com_android_server_input_InputApplicationHandle.cpp index b9681ab76cd1..f943d168e7d6 100644 --- a/services/core/jni/com_android_server_input_InputApplicationHandle.cpp +++ b/services/core/jni/com_android_server_input_InputApplicationHandle.cpp @@ -90,7 +90,7 @@ sp<InputApplicationHandle> android_server_InputApplicationHandle_getHandle( AutoMutex _l(gHandleMutex); - int ptr = env->GetIntField(inputApplicationHandleObj, gInputApplicationHandleClassInfo.ptr); + jlong ptr = env->GetLongField(inputApplicationHandleObj, gInputApplicationHandleClassInfo.ptr); NativeInputApplicationHandle* handle; if (ptr) { handle = reinterpret_cast<NativeInputApplicationHandle*>(ptr); @@ -98,8 +98,8 @@ sp<InputApplicationHandle> android_server_InputApplicationHandle_getHandle( jweak objWeak = env->NewWeakGlobalRef(inputApplicationHandleObj); handle = new NativeInputApplicationHandle(objWeak); handle->incStrong((void*)android_server_InputApplicationHandle_getHandle); - env->SetIntField(inputApplicationHandleObj, gInputApplicationHandleClassInfo.ptr, - reinterpret_cast<int>(handle)); + env->SetLongField(inputApplicationHandleObj, gInputApplicationHandleClassInfo.ptr, + reinterpret_cast<jlong>(handle)); } return handle; } @@ -110,9 +110,9 @@ sp<InputApplicationHandle> android_server_InputApplicationHandle_getHandle( static void android_server_InputApplicationHandle_nativeDispose(JNIEnv* env, jobject obj) { AutoMutex _l(gHandleMutex); - int ptr = env->GetIntField(obj, gInputApplicationHandleClassInfo.ptr); + jlong ptr = env->GetLongField(obj, gInputApplicationHandleClassInfo.ptr); if (ptr) { - env->SetIntField(obj, gInputApplicationHandleClassInfo.ptr, 0); + env->SetLongField(obj, gInputApplicationHandleClassInfo.ptr, 0); NativeInputApplicationHandle* handle = reinterpret_cast<NativeInputApplicationHandle*>(ptr); handle->decStrong((void*)android_server_InputApplicationHandle_getHandle); @@ -143,7 +143,7 @@ int register_android_server_InputApplicationHandle(JNIEnv* env) { FIND_CLASS(clazz, "com/android/server/input/InputApplicationHandle"); GET_FIELD_ID(gInputApplicationHandleClassInfo.ptr, clazz, - "ptr", "I"); + "ptr", "J"); GET_FIELD_ID(gInputApplicationHandleClassInfo.name, clazz, "name", "Ljava/lang/String;"); diff --git a/services/core/jni/com_android_server_input_InputManagerService.cpp b/services/core/jni/com_android_server_input_InputManagerService.cpp index 12a1c7a0bdac..43fbe9d96ac7 100644 --- a/services/core/jni/com_android_server_input_InputManagerService.cpp +++ b/services/core/jni/com_android_server_input_InputManagerService.cpp @@ -986,7 +986,7 @@ void NativeInputManager::loadPointerResources(PointerResources* outResources) { // ---------------------------------------------------------------------------- -static jint nativeInit(JNIEnv* env, jclass clazz, +static jlong nativeInit(JNIEnv* env, jclass clazz, jobject serviceObj, jobject contextObj, jobject messageQueueObj) { sp<MessageQueue> messageQueue = android_os_MessageQueue_getMessageQueue(env, messageQueueObj); if (messageQueue == NULL) { @@ -997,10 +997,10 @@ static jint nativeInit(JNIEnv* env, jclass clazz, NativeInputManager* im = new NativeInputManager(contextObj, serviceObj, messageQueue->getLooper()); im->incStrong(0); - return reinterpret_cast<jint>(im); + return reinterpret_cast<jlong>(im); } -static void nativeStart(JNIEnv* env, jclass clazz, jint ptr) { +static void nativeStart(JNIEnv* env, jclass clazz, jlong ptr) { NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr); status_t result = im->getInputManager()->start(); @@ -1009,7 +1009,7 @@ static void nativeStart(JNIEnv* env, jclass clazz, jint ptr) { } } -static void nativeSetDisplayViewport(JNIEnv* env, jclass clazz, jint ptr, jboolean external, +static void nativeSetDisplayViewport(JNIEnv* env, jclass clazz, jlong ptr, jboolean external, jint displayId, jint orientation, jint logicalLeft, jint logicalTop, jint logicalRight, jint logicalBottom, jint physicalLeft, jint physicalTop, jint physicalRight, jint physicalBottom, @@ -1033,31 +1033,31 @@ static void nativeSetDisplayViewport(JNIEnv* env, jclass clazz, jint ptr, jboole } static jint nativeGetScanCodeState(JNIEnv* env, jclass clazz, - jint ptr, jint deviceId, jint sourceMask, jint scanCode) { + jlong ptr, jint deviceId, jint sourceMask, jint scanCode) { NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr); - return im->getInputManager()->getReader()->getScanCodeState( + return (jint) im->getInputManager()->getReader()->getScanCodeState( deviceId, uint32_t(sourceMask), scanCode); } static jint nativeGetKeyCodeState(JNIEnv* env, jclass clazz, - jint ptr, jint deviceId, jint sourceMask, jint keyCode) { + jlong ptr, jint deviceId, jint sourceMask, jint keyCode) { NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr); - return im->getInputManager()->getReader()->getKeyCodeState( + return (jint) im->getInputManager()->getReader()->getKeyCodeState( deviceId, uint32_t(sourceMask), keyCode); } static jint nativeGetSwitchState(JNIEnv* env, jclass clazz, - jint ptr, jint deviceId, jint sourceMask, jint sw) { + jlong ptr, jint deviceId, jint sourceMask, jint sw) { NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr); - return im->getInputManager()->getReader()->getSwitchState( + return (jint) im->getInputManager()->getReader()->getSwitchState( deviceId, uint32_t(sourceMask), sw); } static jboolean nativeHasKeys(JNIEnv* env, jclass clazz, - jint ptr, jint deviceId, jint sourceMask, jintArray keyCodes, jbooleanArray outFlags) { + jlong ptr, jint deviceId, jint sourceMask, jintArray keyCodes, jbooleanArray outFlags) { NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr); int32_t* codes = env->GetIntArrayElements(keyCodes, NULL); @@ -1065,8 +1065,12 @@ static jboolean nativeHasKeys(JNIEnv* env, jclass clazz, jsize numCodes = env->GetArrayLength(keyCodes); jboolean result; if (numCodes == env->GetArrayLength(keyCodes)) { - result = im->getInputManager()->getReader()->hasKeys( - deviceId, uint32_t(sourceMask), numCodes, codes, flags); + if (im->getInputManager()->getReader()->hasKeys( + deviceId, uint32_t(sourceMask), numCodes, codes, flags)) { + result = JNI_TRUE; + } else { + result = JNI_FALSE; + } } else { result = JNI_FALSE; } @@ -1091,7 +1095,7 @@ static void handleInputChannelDisposed(JNIEnv* env, } static void nativeRegisterInputChannel(JNIEnv* env, jclass clazz, - jint ptr, jobject inputChannelObj, jobject inputWindowHandleObj, jboolean monitor) { + jlong ptr, jobject inputChannelObj, jobject inputWindowHandleObj, jboolean monitor) { NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr); sp<InputChannel> inputChannel = android_view_InputChannel_getInputChannel(env, @@ -1120,7 +1124,7 @@ static void nativeRegisterInputChannel(JNIEnv* env, jclass clazz, } static void nativeUnregisterInputChannel(JNIEnv* env, jclass clazz, - jint ptr, jobject inputChannelObj) { + jlong ptr, jobject inputChannelObj) { NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr); sp<InputChannel> inputChannel = android_view_InputChannel_getInputChannel(env, @@ -1141,14 +1145,14 @@ static void nativeUnregisterInputChannel(JNIEnv* env, jclass clazz, } static void nativeSetInputFilterEnabled(JNIEnv* env, jclass clazz, - jint ptr, jboolean enabled) { + jlong ptr, jboolean enabled) { NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr); im->getInputManager()->getDispatcher()->setInputFilterEnabled(enabled); } static jint nativeInjectInputEvent(JNIEnv* env, jclass clazz, - jint ptr, jobject inputEventObj, jint injectorPid, jint injectorUid, + jlong ptr, jobject inputEventObj, jint injectorPid, jint injectorUid, jint syncMode, jint timeoutMillis, jint policyFlags) { NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr); @@ -1160,7 +1164,7 @@ static jint nativeInjectInputEvent(JNIEnv* env, jclass clazz, return INPUT_EVENT_INJECTION_FAILED; } - return im->getInputManager()->getDispatcher()->injectInputEvent( + return (jint) im->getInputManager()->getDispatcher()->injectInputEvent( & keyEvent, injectorPid, injectorUid, syncMode, timeoutMillis, uint32_t(policyFlags)); } else if (env->IsInstanceOf(inputEventObj, gMotionEventClassInfo.clazz)) { @@ -1170,7 +1174,7 @@ static jint nativeInjectInputEvent(JNIEnv* env, jclass clazz, return INPUT_EVENT_INJECTION_FAILED; } - return im->getInputManager()->getDispatcher()->injectInputEvent( + return (jint) im->getInputManager()->getDispatcher()->injectInputEvent( motionEvent, injectorPid, injectorUid, syncMode, timeoutMillis, uint32_t(policyFlags)); } else { @@ -1180,35 +1184,35 @@ static jint nativeInjectInputEvent(JNIEnv* env, jclass clazz, } static void nativeSetInputWindows(JNIEnv* env, jclass clazz, - jint ptr, jobjectArray windowHandleObjArray) { + jlong ptr, jobjectArray windowHandleObjArray) { NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr); im->setInputWindows(env, windowHandleObjArray); } static void nativeSetFocusedApplication(JNIEnv* env, jclass clazz, - jint ptr, jobject applicationHandleObj) { + jlong ptr, jobject applicationHandleObj) { NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr); im->setFocusedApplication(env, applicationHandleObj); } static void nativeSetInputDispatchMode(JNIEnv* env, - jclass clazz, jint ptr, jboolean enabled, jboolean frozen) { + jclass clazz, jlong ptr, jboolean enabled, jboolean frozen) { NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr); im->setInputDispatchMode(enabled, frozen); } static void nativeSetSystemUiVisibility(JNIEnv* env, - jclass clazz, jint ptr, jint visibility) { + jclass clazz, jlong ptr, jint visibility) { NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr); im->setSystemUiVisibility(visibility); } static jboolean nativeTransferTouchFocus(JNIEnv* env, - jclass clazz, jint ptr, jobject fromChannelObj, jobject toChannelObj) { + jclass clazz, jlong ptr, jobject fromChannelObj, jobject toChannelObj) { NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr); sp<InputChannel> fromChannel = @@ -1217,29 +1221,33 @@ static jboolean nativeTransferTouchFocus(JNIEnv* env, android_view_InputChannel_getInputChannel(env, toChannelObj); if (fromChannel == NULL || toChannel == NULL) { - return false; + return JNI_FALSE; } - return im->getInputManager()->getDispatcher()-> - transferTouchFocus(fromChannel, toChannel); + if (im->getInputManager()->getDispatcher()-> + transferTouchFocus(fromChannel, toChannel)) { + return JNI_TRUE; + } else { + return JNI_FALSE; + } } static void nativeSetPointerSpeed(JNIEnv* env, - jclass clazz, jint ptr, jint speed) { + jclass clazz, jlong ptr, jint speed) { NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr); im->setPointerSpeed(speed); } static void nativeSetShowTouches(JNIEnv* env, - jclass clazz, jint ptr, jboolean enabled) { + jclass clazz, jlong ptr, jboolean enabled) { NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr); im->setShowTouches(enabled); } static void nativeVibrate(JNIEnv* env, - jclass clazz, jint ptr, jint deviceId, jlongArray patternObj, + jclass clazz, jlong ptr, jint deviceId, jlongArray patternObj, jint repeat, jint token) { NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr); @@ -1256,7 +1264,7 @@ static void nativeVibrate(JNIEnv* env, nsecs_t pattern[patternSize]; for (size_t i = 0; i < patternSize; i++) { pattern[i] = max(jlong(0), min(patternMillis[i], - MAX_VIBRATE_PATTERN_DELAY_NSECS / 1000000LL)) * 1000000LL; + (jlong)(MAX_VIBRATE_PATTERN_DELAY_NSECS / 1000000LL))) * 1000000LL; } env->ReleasePrimitiveArrayCritical(patternObj, patternMillis, JNI_ABORT); @@ -1264,14 +1272,14 @@ static void nativeVibrate(JNIEnv* env, } static void nativeCancelVibrate(JNIEnv* env, - jclass clazz, jint ptr, jint deviceId, jint token) { + jclass clazz, jlong ptr, jint deviceId, jint token) { NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr); im->getInputManager()->getReader()->cancelVibrate(deviceId, token); } static void nativeReloadKeyboardLayouts(JNIEnv* env, - jclass clazz, jint ptr) { + jclass clazz, jlong ptr) { NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr); im->getInputManager()->getReader()->requestRefreshConfiguration( @@ -1279,14 +1287,14 @@ static void nativeReloadKeyboardLayouts(JNIEnv* env, } static void nativeReloadDeviceAliases(JNIEnv* env, - jclass clazz, jint ptr) { + jclass clazz, jlong ptr) { NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr); im->getInputManager()->getReader()->requestRefreshConfiguration( InputReaderConfiguration::CHANGE_DEVICE_ALIAS); } -static jstring nativeDump(JNIEnv* env, jclass clazz, jint ptr) { +static jstring nativeDump(JNIEnv* env, jclass clazz, jlong ptr) { NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr); String8 dump; @@ -1294,7 +1302,7 @@ static jstring nativeDump(JNIEnv* env, jclass clazz, jint ptr) { return env->NewStringUTF(dump.string()); } -static void nativeMonitor(JNIEnv* env, jclass clazz, jint ptr) { +static void nativeMonitor(JNIEnv* env, jclass clazz, jlong ptr) { NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr); im->getInputManager()->getReader()->monitor(); @@ -1306,54 +1314,54 @@ static void nativeMonitor(JNIEnv* env, jclass clazz, jint ptr) { static JNINativeMethod gInputManagerMethods[] = { /* name, signature, funcPtr */ { "nativeInit", - "(Lcom/android/server/input/InputManagerService;Landroid/content/Context;Landroid/os/MessageQueue;)I", + "(Lcom/android/server/input/InputManagerService;Landroid/content/Context;Landroid/os/MessageQueue;)J", (void*) nativeInit }, - { "nativeStart", "(I)V", + { "nativeStart", "(J)V", (void*) nativeStart }, - { "nativeSetDisplayViewport", "(IZIIIIIIIIIIII)V", + { "nativeSetDisplayViewport", "(JZIIIIIIIIIIII)V", (void*) nativeSetDisplayViewport }, - { "nativeGetScanCodeState", "(IIII)I", + { "nativeGetScanCodeState", "(JIII)I", (void*) nativeGetScanCodeState }, - { "nativeGetKeyCodeState", "(IIII)I", + { "nativeGetKeyCodeState", "(JIII)I", (void*) nativeGetKeyCodeState }, - { "nativeGetSwitchState", "(IIII)I", + { "nativeGetSwitchState", "(JIII)I", (void*) nativeGetSwitchState }, - { "nativeHasKeys", "(III[I[Z)Z", + { "nativeHasKeys", "(JII[I[Z)Z", (void*) nativeHasKeys }, { "nativeRegisterInputChannel", - "(ILandroid/view/InputChannel;Lcom/android/server/input/InputWindowHandle;Z)V", + "(JLandroid/view/InputChannel;Lcom/android/server/input/InputWindowHandle;Z)V", (void*) nativeRegisterInputChannel }, - { "nativeUnregisterInputChannel", "(ILandroid/view/InputChannel;)V", + { "nativeUnregisterInputChannel", "(JLandroid/view/InputChannel;)V", (void*) nativeUnregisterInputChannel }, - { "nativeSetInputFilterEnabled", "(IZ)V", + { "nativeSetInputFilterEnabled", "(JZ)V", (void*) nativeSetInputFilterEnabled }, - { "nativeInjectInputEvent", "(ILandroid/view/InputEvent;IIIII)I", + { "nativeInjectInputEvent", "(JLandroid/view/InputEvent;IIIII)I", (void*) nativeInjectInputEvent }, - { "nativeSetInputWindows", "(I[Lcom/android/server/input/InputWindowHandle;)V", + { "nativeSetInputWindows", "(J[Lcom/android/server/input/InputWindowHandle;)V", (void*) nativeSetInputWindows }, - { "nativeSetFocusedApplication", "(ILcom/android/server/input/InputApplicationHandle;)V", + { "nativeSetFocusedApplication", "(JLcom/android/server/input/InputApplicationHandle;)V", (void*) nativeSetFocusedApplication }, - { "nativeSetInputDispatchMode", "(IZZ)V", + { "nativeSetInputDispatchMode", "(JZZ)V", (void*) nativeSetInputDispatchMode }, - { "nativeSetSystemUiVisibility", "(II)V", + { "nativeSetSystemUiVisibility", "(JI)V", (void*) nativeSetSystemUiVisibility }, - { "nativeTransferTouchFocus", "(ILandroid/view/InputChannel;Landroid/view/InputChannel;)Z", + { "nativeTransferTouchFocus", "(JLandroid/view/InputChannel;Landroid/view/InputChannel;)Z", (void*) nativeTransferTouchFocus }, - { "nativeSetPointerSpeed", "(II)V", + { "nativeSetPointerSpeed", "(JI)V", (void*) nativeSetPointerSpeed }, - { "nativeSetShowTouches", "(IZ)V", + { "nativeSetShowTouches", "(JZ)V", (void*) nativeSetShowTouches }, - { "nativeVibrate", "(II[JII)V", + { "nativeVibrate", "(JI[JII)V", (void*) nativeVibrate }, - { "nativeCancelVibrate", "(III)V", + { "nativeCancelVibrate", "(JII)V", (void*) nativeCancelVibrate }, - { "nativeReloadKeyboardLayouts", "(I)V", + { "nativeReloadKeyboardLayouts", "(J)V", (void*) nativeReloadKeyboardLayouts }, - { "nativeReloadDeviceAliases", "(I)V", + { "nativeReloadDeviceAliases", "(J)V", (void*) nativeReloadDeviceAliases }, - { "nativeDump", "(I)Ljava/lang/String;", + { "nativeDump", "(J)Ljava/lang/String;", (void*) nativeDump }, - { "nativeMonitor", "(I)V", + { "nativeMonitor", "(J)V", (void*) nativeMonitor }, }; diff --git a/services/core/jni/com_android_server_input_InputWindowHandle.cpp b/services/core/jni/com_android_server_input_InputWindowHandle.cpp index 82e3dad58c13..b80183c73b80 100644 --- a/services/core/jni/com_android_server_input_InputWindowHandle.cpp +++ b/services/core/jni/com_android_server_input_InputWindowHandle.cpp @@ -173,7 +173,7 @@ sp<NativeInputWindowHandle> android_server_InputWindowHandle_getHandle( AutoMutex _l(gHandleMutex); - int ptr = env->GetIntField(inputWindowHandleObj, gInputWindowHandleClassInfo.ptr); + jlong ptr = env->GetLongField(inputWindowHandleObj, gInputWindowHandleClassInfo.ptr); NativeInputWindowHandle* handle; if (ptr) { handle = reinterpret_cast<NativeInputWindowHandle*>(ptr); @@ -187,8 +187,8 @@ sp<NativeInputWindowHandle> android_server_InputWindowHandle_getHandle( jweak objWeak = env->NewWeakGlobalRef(inputWindowHandleObj); handle = new NativeInputWindowHandle(inputApplicationHandle, objWeak); handle->incStrong((void*)android_server_InputWindowHandle_getHandle); - env->SetIntField(inputWindowHandleObj, gInputWindowHandleClassInfo.ptr, - reinterpret_cast<int>(handle)); + env->SetLongField(inputWindowHandleObj, gInputWindowHandleClassInfo.ptr, + reinterpret_cast<jlong>(handle)); } return handle; } @@ -199,9 +199,9 @@ sp<NativeInputWindowHandle> android_server_InputWindowHandle_getHandle( static void android_server_InputWindowHandle_nativeDispose(JNIEnv* env, jobject obj) { AutoMutex _l(gHandleMutex); - int ptr = env->GetIntField(obj, gInputWindowHandleClassInfo.ptr); + jlong ptr = env->GetLongField(obj, gInputWindowHandleClassInfo.ptr); if (ptr) { - env->SetIntField(obj, gInputWindowHandleClassInfo.ptr, 0); + env->SetLongField(obj, gInputWindowHandleClassInfo.ptr, 0); NativeInputWindowHandle* handle = reinterpret_cast<NativeInputWindowHandle*>(ptr); handle->decStrong((void*)android_server_InputWindowHandle_getHandle); @@ -232,7 +232,7 @@ int register_android_server_InputWindowHandle(JNIEnv* env) { FIND_CLASS(clazz, "com/android/server/input/InputWindowHandle"); GET_FIELD_ID(gInputWindowHandleClassInfo.ptr, clazz, - "ptr", "I"); + "ptr", "J"); GET_FIELD_ID(gInputWindowHandleClassInfo.inputApplicationHandle, clazz, diff --git a/services/core/jni/com_android_server_lights_LightsService.cpp b/services/core/jni/com_android_server_lights_LightsService.cpp index ea03cfa1b147..d51e044c4dbe 100644 --- a/services/core/jni/com_android_server_lights_LightsService.cpp +++ b/services/core/jni/com_android_server_lights_LightsService.cpp @@ -60,7 +60,7 @@ static light_device_t* get_device(hw_module_t* module, char const* name) } } -static jint init_native(JNIEnv *env, jobject clazz) +static jlong init_native(JNIEnv *env, jobject clazz) { int err; hw_module_t* module; @@ -90,10 +90,10 @@ static jint init_native(JNIEnv *env, jobject clazz) memset(devices, 0, sizeof(Devices)); } - return (jint)devices; + return (jlong)devices; } -static void finalize_native(JNIEnv *env, jobject clazz, int ptr) +static void finalize_native(JNIEnv *env, jobject clazz, jlong ptr) { Devices* devices = (Devices*)ptr; if (devices == NULL) { @@ -103,8 +103,8 @@ static void finalize_native(JNIEnv *env, jobject clazz, int ptr) free(devices); } -static void setLight_native(JNIEnv *env, jobject clazz, int ptr, - int light, int colorARGB, int flashMode, int onMS, int offMS, int brightnessMode) +static void setLight_native(JNIEnv *env, jobject clazz, jlong ptr, + jint light, jint colorARGB, jint flashMode, jint onMS, jint offMS, jint brightnessMode) { Devices* devices = (Devices*)ptr; light_state_t state; @@ -127,9 +127,9 @@ static void setLight_native(JNIEnv *env, jobject clazz, int ptr, } static JNINativeMethod method_table[] = { - { "init_native", "()I", (void*)init_native }, - { "finalize_native", "(I)V", (void*)finalize_native }, - { "setLight_native", "(IIIIIII)V", (void*)setLight_native }, + { "init_native", "()J", (void*)init_native }, + { "finalize_native", "(J)V", (void*)finalize_native }, + { "setLight_native", "(JIIIIII)V", (void*)setLight_native }, }; int register_android_server_LightsService(JNIEnv *env) diff --git a/services/core/jni/com_android_server_location_GpsLocationProvider.cpp b/services/core/jni/com_android_server_location_GpsLocationProvider.cpp index aec254b181d4..e9ba116c26bf 100644 --- a/services/core/jni/com_android_server_location_GpsLocationProvider.cpp +++ b/services/core/jni/com_android_server_location_GpsLocationProvider.cpp @@ -387,7 +387,11 @@ static void android_location_GpsLocationProvider_class_init_native(JNIEnv* env, } static jboolean android_location_GpsLocationProvider_is_supported(JNIEnv* env, jclass clazz) { - return (sGpsInterface != NULL); + if (sGpsInterface != NULL) { + return JNI_TRUE; + } else { + return JNI_FALSE; + } } static jboolean android_location_GpsLocationProvider_init(JNIEnv* env, jobject obj) @@ -398,7 +402,7 @@ static jboolean android_location_GpsLocationProvider_init(JNIEnv* env, jobject o // fail if the main interface fails to initialize if (!sGpsInterface || sGpsInterface->init(&sGpsCallbacks) != 0) - return false; + return JNI_FALSE; // if XTRA initialization fails we will disable it by sGpsXtraInterface to NULL, // but continue to allow the rest of the GPS interface to work. @@ -413,7 +417,7 @@ static jboolean android_location_GpsLocationProvider_init(JNIEnv* env, jobject o if (sGpsGeofencingInterface) sGpsGeofencingInterface->init(&sGpsGeofenceCallbacks); - return true; + return JNI_TRUE; } static void android_location_GpsLocationProvider_cleanup(JNIEnv* env, jobject obj) @@ -425,27 +429,42 @@ static void android_location_GpsLocationProvider_cleanup(JNIEnv* env, jobject ob static jboolean android_location_GpsLocationProvider_set_position_mode(JNIEnv* env, jobject obj, jint mode, jint recurrence, jint min_interval, jint preferred_accuracy, jint preferred_time) { - if (sGpsInterface) - return (sGpsInterface->set_position_mode(mode, recurrence, min_interval, preferred_accuracy, - preferred_time) == 0); + if (sGpsInterface) { + if (sGpsInterface->set_position_mode(mode, recurrence, min_interval, preferred_accuracy, + preferred_time) == 0) { + return JNI_TRUE; + } else { + return JNI_FALSE; + } + } else - return false; + return JNI_FALSE; } static jboolean android_location_GpsLocationProvider_start(JNIEnv* env, jobject obj) { - if (sGpsInterface) - return (sGpsInterface->start() == 0); + if (sGpsInterface) { + if (sGpsInterface->start() == 0) { + return JNI_TRUE; + } else { + return JNI_FALSE; + } + } else - return false; + return JNI_FALSE; } static jboolean android_location_GpsLocationProvider_stop(JNIEnv* env, jobject obj) { - if (sGpsInterface) - return (sGpsInterface->stop() == 0); + if (sGpsInterface) { + if (sGpsInterface->stop() == 0) { + return JNI_TRUE; + } else { + return JNI_FALSE; + } + } else - return false; + return JNI_FALSE; } static void android_location_GpsLocationProvider_delete_aiding_data(JNIEnv* env, jobject obj, jint flags) @@ -482,7 +501,7 @@ static jint android_location_GpsLocationProvider_read_sv_status(JNIEnv* env, job env->ReleaseFloatArrayElements(elevArray, elev, 0); env->ReleaseFloatArrayElements(azumArray, azim, 0); env->ReleaseIntArrayElements(maskArray, mask, 0); - return num_svs; + return (jint) num_svs; } static void android_location_GpsLocationProvider_agps_set_reference_location_cellid(JNIEnv* env, @@ -552,7 +571,7 @@ static jint android_location_GpsLocationProvider_read_nmea(JNIEnv* env, jobject length = buffer_size; memcpy(nmea, sNmeaString, length); env->ReleasePrimitiveArrayCritical(nmeaArray, nmea, JNI_ABORT); - return length; + return (jint) length; } static void android_location_GpsLocationProvider_inject_time(JNIEnv* env, jobject obj, @@ -571,7 +590,11 @@ static void android_location_GpsLocationProvider_inject_location(JNIEnv* env, jo static jboolean android_location_GpsLocationProvider_supports_xtra(JNIEnv* env, jobject obj) { - return (sGpsXtraInterface != NULL); + if (sGpsXtraInterface != NULL) { + return JNI_TRUE; + } else { + return JNI_FALSE; + } } static void android_location_GpsLocationProvider_inject_xtra_data(JNIEnv* env, jobject obj, @@ -658,7 +681,7 @@ static jstring android_location_GpsLocationProvider_get_internal_state(JNIEnv* e } static void android_location_GpsLocationProvider_update_network_state(JNIEnv* env, jobject obj, - jboolean connected, int type, jboolean roaming, jboolean available, jstring extraInfo, jstring apn) + jboolean connected, jint type, jboolean roaming, jboolean available, jstring extraInfo, jstring apn) { if (sAGpsRilInterface && sAGpsRilInterface->update_network_state) { |