From 69a4817e3e1e368e758ff8c238deb5ee26963c04 Mon Sep 17 00:00:00 2001 From: Daniel Sandler Date: Wed, 23 Jun 2010 16:29:36 -0400 Subject: [PATCH] Immersive activity API. An Activity can declare itself to be "immersive" either by setting android:immersive="true" in AndroidManifest or by calling setImmersive(true). Immersive activities "should" not be interrupted, for example by Notifications with an associated fullScreenIntent. (In the future we may even prevent any non-system application from successfully calling startActivity() if the foreground activity is immersive.) Notifications with FLAG_HIGH_PRIORITY set will be shown to the user in some less-obtrusive way if the frontmost activity is immersive. Change-Id: I8d0c25cc4e22371c27cbf2bb6372d2c95d57b2d7 --- api/current.xml | 24 +++++++ core/java/android/app/Activity.java | 40 ++++++++++++ .../android/app/ActivityManagerNative.java | 65 +++++++++++++++++++ core/java/android/app/IActivityManager.java | 7 ++ .../server/am/ActivityManagerService.java | 29 +++++++++ .../com/android/server/am/HistoryRecord.java | 5 ++ 6 files changed, 170 insertions(+) diff --git a/api/current.xml b/api/current.xml index 628cb665ef307..37538c3d80fb2 100644 --- a/api/current.xml +++ b/api/current.xml @@ -19543,6 +19543,17 @@ visibility="public" > + + + + + + android:immersive but may be changed at runtime by + * {@link #setImmersive}. + * + * @see android.content.pm.ActivityInfo#FLAG_IMMERSIVE + */ + public boolean isImmersive() { + try { + return ActivityManagerNative.getDefault().isImmersive(mToken); + } catch (RemoteException e) { + return false; + } + } + + /** + * Adjust the current immersive mode setting. + * + * Note that changing this value will have no effect on the activity's + * {@link android.content.pm.ActivityInfo} structure; that is, if + * android:immersive is set to true + * in the application's manifest entry for this activity, the {@link + * android.content.pm.ActivityInfo#flags ActivityInfo.flags} member will + * always have its {@link android.content.pm.ActivityInfo#FLAG_IMMERSIVE + * FLAG_IMMERSIVE} bit set. + * + * @see #isImmersive + * @see android.content.pm.ActivityInfo#FLAG_IMMERSIVE + */ + public void setImmersive(boolean i) { + try { + ActivityManagerNative.getDefault().setImmersive(mToken, i); + } catch (RemoteException e) { + // pass + } + } + // ------------------ Internal API ------------------ final void setParent(Activity parent) { diff --git a/core/java/android/app/ActivityManagerNative.java b/core/java/android/app/ActivityManagerNative.java index 2c1f2dafc0275..63b2f08e28fa5 100644 --- a/core/java/android/app/ActivityManagerNative.java +++ b/core/java/android/app/ActivityManagerNative.java @@ -1268,6 +1268,31 @@ public abstract class ActivityManagerNative extends Binder implements IActivityM reply.writeNoException(); return true; } + + case IS_IMMERSIVE_TRANSACTION: { + data.enforceInterface(IActivityManager.descriptor); + IBinder token = data.readStrongBinder(); + reply.writeInt(isImmersive(token) ? 1 : 0); + reply.writeNoException(); + return true; + } + + case SET_IMMERSIVE_TRANSACTION: { + data.enforceInterface(IActivityManager.descriptor); + IBinder token = data.readStrongBinder(); + boolean imm = data.readInt() == 1; + setImmersive(token, imm); + reply.writeNoException(); + return true; + } + + case IS_TOP_ACTIVITY_IMMERSIVE_TRANSACTION: { + data.enforceInterface(IActivityManager.descriptor); + reply.writeInt(isTopActivityImmersive() ? 1 : 0); + reply.writeNoException(); + return true; + } + } return super.onTransact(code, data, reply, flags); @@ -2802,5 +2827,45 @@ class ActivityManagerProxy implements IActivityManager reply.recycle(); } + public void setImmersive(IBinder token, boolean immersive) + throws RemoteException { + Parcel data = Parcel.obtain(); + Parcel reply = Parcel.obtain(); + data.writeInterfaceToken(IActivityManager.descriptor); + data.writeStrongBinder(token); + data.writeInt(immersive ? 1 : 0); + mRemote.transact(SET_IMMERSIVE_TRANSACTION, data, reply, 0); + reply.readException(); + data.recycle(); + reply.recycle(); + } + + public boolean isImmersive(IBinder token) + throws RemoteException { + Parcel data = Parcel.obtain(); + Parcel reply = Parcel.obtain(); + data.writeInterfaceToken(IActivityManager.descriptor); + data.writeStrongBinder(token); + mRemote.transact(IS_IMMERSIVE_TRANSACTION, data, reply, 0); + boolean res = reply.readInt() == 1; + reply.readException(); + data.recycle(); + reply.recycle(); + return res; + } + + public boolean isTopActivityImmersive() + throws RemoteException { + Parcel data = Parcel.obtain(); + Parcel reply = Parcel.obtain(); + data.writeInterfaceToken(IActivityManager.descriptor); + mRemote.transact(IS_TOP_ACTIVITY_IMMERSIVE_TRANSACTION, data, reply, 0); + boolean res = reply.readInt() == 1; + reply.readException(); + data.recycle(); + reply.recycle(); + return res; + } + private IBinder mRemote; } diff --git a/core/java/android/app/IActivityManager.java b/core/java/android/app/IActivityManager.java index 542bc411acc34..3a86ead0f4a1c 100644 --- a/core/java/android/app/IActivityManager.java +++ b/core/java/android/app/IActivityManager.java @@ -311,6 +311,10 @@ public interface IActivityManager extends IInterface { public boolean isUserAMonkey() throws RemoteException; public void finishHeavyWeightApp() throws RemoteException; + + public void setImmersive(IBinder token, boolean immersive) throws RemoteException; + public boolean isImmersive(IBinder token) throws RemoteException; + public boolean isTopActivityImmersive() throws RemoteException; /* * Private non-Binder interfaces @@ -524,4 +528,7 @@ public interface IActivityManager extends IInterface { int GET_RUNNING_EXTERNAL_APPLICATIONS_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+107; int FINISH_HEAVY_WEIGHT_APP_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+108; int HANDLE_APPLICATION_STRICT_MODE_VIOLATION_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+109; + int IS_IMMERSIVE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+110; + int SET_IMMERSIVE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+111; + int IS_TOP_ACTIVITY_IMMERSIVE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+112; } diff --git a/services/java/com/android/server/am/ActivityManagerService.java b/services/java/com/android/server/am/ActivityManagerService.java index 4d18191a5ab52..d59ecdd4a5bc8 100644 --- a/services/java/com/android/server/am/ActivityManagerService.java +++ b/services/java/com/android/server/am/ActivityManagerService.java @@ -8725,6 +8725,35 @@ public final class ActivityManagerService extends ActivityManagerNative implemen } } + public void setImmersive(IBinder token, boolean immersive) { + synchronized(this) { + int index = (token != null) ? indexOfTokenLocked(token) : -1; + if (index < 0) { + throw new IllegalArgumentException(); + } + HistoryRecord r = (HistoryRecord)mHistory.get(index); + r.immersive = immersive; + } + } + + public boolean isImmersive(IBinder token) { + synchronized (this) { + int index = (token != null) ? indexOfTokenLocked(token) : -1; + if (index < 0) { + throw new IllegalArgumentException(); + } + HistoryRecord r = (HistoryRecord)mHistory.get(index); + return r.immersive; + } + } + + public boolean isTopActivityImmersive() { + synchronized (this) { + HistoryRecord r = topRunningActivityLocked(null); + return (r != null) ? r.immersive : false; + } + } + public final void enterSafeMode() { synchronized(this) { // It only makes sense to do this before the system is ready diff --git a/services/java/com/android/server/am/HistoryRecord.java b/services/java/com/android/server/am/HistoryRecord.java index dca7a99a7d5ed..fb5c8aa0f0f64 100644 --- a/services/java/com/android/server/am/HistoryRecord.java +++ b/services/java/com/android/server/am/HistoryRecord.java @@ -101,6 +101,7 @@ class HistoryRecord extends IApplicationToken.Stub { boolean idle; // has the activity gone idle? boolean hasBeenLaunched;// has this activity ever been launched? boolean frozenBeforeDestroy;// has been frozen but not yet destroyed. + boolean immersive; // immersive mode (don't interrupt if possible) String stringName; // for caching of toString(). @@ -153,6 +154,7 @@ class HistoryRecord extends IApplicationToken.Stub { pw.print(prefix); pw.print("keysPaused="); pw.print(keysPaused); pw.print(" inHistory="); pw.print(inHistory); pw.print(" persistent="); pw.print(persistent); + pw.print(" immersive="); pw.print(immersive); pw.print(" launchMode="); pw.println(launchMode); pw.print(prefix); pw.print("fullscreen="); pw.print(fullscreen); pw.print(" visible="); pw.print(visible); @@ -278,6 +280,8 @@ class HistoryRecord extends IApplicationToken.Stub { } else { isHomeActivity = false; } + + immersive = (aInfo.flags & ActivityInfo.FLAG_IMMERSIVE) != 0; } else { realActivity = null; taskAffinity = null; @@ -289,6 +293,7 @@ class HistoryRecord extends IApplicationToken.Stub { packageName = null; fullscreen = true; isHomeActivity = false; + immersive = false; } }