diff --git a/build.xml b/build.xml index 46b9e04..98bf833 100644 --- a/build.xml +++ b/build.xml @@ -136,6 +136,7 @@ + diff --git a/src/strictmode-lib-test/AndroidManifest.xml b/src/strictmode-lib-test/AndroidManifest.xml index f37bcf8..64bb391 100644 --- a/src/strictmode-lib-test/AndroidManifest.xml +++ b/src/strictmode-lib-test/AndroidManifest.xml @@ -4,7 +4,7 @@ android:versionCode="1" android:versionName="dev" > - + @@ -13,4 +13,4 @@ - \ No newline at end of file + diff --git a/src/strictmode-lib/.classpath b/src/strictmode-lib/.classpath index ea7172f..575b511 100644 --- a/src/strictmode-lib/.classpath +++ b/src/strictmode-lib/.classpath @@ -2,8 +2,8 @@ - - + + diff --git a/src/strictmode-lib/AndroidManifest.xml b/src/strictmode-lib/AndroidManifest.xml index 940eee6..0fd5708 100644 --- a/src/strictmode-lib/AndroidManifest.xml +++ b/src/strictmode-lib/AndroidManifest.xml @@ -4,6 +4,6 @@ android:versionCode="1" android:versionName="dev" > - + - \ No newline at end of file + diff --git a/src/strictmode-lib/android-prebuilt/r18/.classpath b/src/strictmode-lib/android-prebuilt/r18/.classpath new file mode 100644 index 0000000..3136625 --- /dev/null +++ b/src/strictmode-lib/android-prebuilt/r18/.classpath @@ -0,0 +1,9 @@ + + + + + + + + + diff --git a/src/strictmode-lib/android-prebuilt/r18/.project b/src/strictmode-lib/android-prebuilt/r18/.project new file mode 100644 index 0000000..adaa01c --- /dev/null +++ b/src/strictmode-lib/android-prebuilt/r18/.project @@ -0,0 +1,33 @@ + + + rbm-strictmode-lib-android-r17 + + + + + + com.android.ide.eclipse.adt.ResourceManagerBuilder + + + + + com.android.ide.eclipse.adt.PreCompilerBuilder + + + + + org.eclipse.jdt.core.javabuilder + + + + + com.android.ide.eclipse.adt.ApkBuilder + + + + + + com.android.ide.eclipse.adt.AndroidNature + org.eclipse.jdt.core.javanature + + diff --git a/src/strictmode-lib/android-prebuilt/r18/AndroidManifest.xml b/src/strictmode-lib/android-prebuilt/r18/AndroidManifest.xml new file mode 100644 index 0000000..7f70f94 --- /dev/null +++ b/src/strictmode-lib/android-prebuilt/r18/AndroidManifest.xml @@ -0,0 +1,9 @@ + + + + + + diff --git a/src/strictmode-lib/android-prebuilt/r18/build.xml b/src/strictmode-lib/android-prebuilt/r18/build.xml new file mode 100644 index 0000000..b193a67 --- /dev/null +++ b/src/strictmode-lib/android-prebuilt/r18/build.xml @@ -0,0 +1,8 @@ + + + + + + + + \ No newline at end of file diff --git a/src/strictmode-lib/android-prebuilt/r18/info b/src/strictmode-lib/android-prebuilt/r18/info new file mode 100644 index 0000000..eb26169 --- /dev/null +++ b/src/strictmode-lib/android-prebuilt/r18/info @@ -0,0 +1,2 @@ +tag: android-4.3 +api level: 18 diff --git a/src/strictmode-lib/android-prebuilt/r18/ivy.xml b/src/strictmode-lib/android-prebuilt/r18/ivy.xml new file mode 100644 index 0000000..90b0c61 --- /dev/null +++ b/src/strictmode-lib/android-prebuilt/r18/ivy.xml @@ -0,0 +1,3 @@ + + + diff --git a/src/strictmode-lib/android-prebuilt/r18/prebuilt/IActivityManager.java b/src/strictmode-lib/android-prebuilt/r18/prebuilt/IActivityManager.java new file mode 100644 index 0000000..8fc1c86 --- /dev/null +++ b/src/strictmode-lib/android-prebuilt/r18/prebuilt/IActivityManager.java @@ -0,0 +1,624 @@ +/* + * Copyright (C) 2006 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package android.app; + +import android.content.ComponentName; +import android.content.ContentProviderNative; +import android.content.IContentProvider; +import android.content.IIntentReceiver; +import android.content.IIntentSender; +import android.content.Intent; +import android.content.IntentFilter; +import android.content.IntentSender; +import android.content.pm.ApplicationInfo; +import android.content.pm.ConfigurationInfo; +import android.content.pm.IPackageDataObserver; +import android.content.pm.ProviderInfo; +import android.content.pm.UserInfo; +import android.content.res.Configuration; +import android.graphics.Bitmap; +import android.net.Uri; +import android.os.Bundle; +import android.os.Debug; +import android.os.IBinder; +import android.os.IInterface; +import android.os.Parcel; +import android.os.ParcelFileDescriptor; +import android.os.Parcelable; +import android.os.RemoteException; +import android.os.StrictMode; + +import java.util.List; + +/** + * System private API for talking with the activity manager service. This + * provides calls from the application back to the activity manager. + * + * {@hide} + */ +public interface IActivityManager extends IInterface { + public int startActivity(IApplicationThread caller, + Intent intent, String resolvedType, IBinder resultTo, String resultWho, + int requestCode, int flags, String profileFile, + ParcelFileDescriptor profileFd, Bundle options) throws RemoteException; + public int startActivityAsUser(IApplicationThread caller, + Intent intent, String resolvedType, IBinder resultTo, String resultWho, + int requestCode, int flags, String profileFile, + ParcelFileDescriptor profileFd, Bundle options, int userId) throws RemoteException; + public WaitResult startActivityAndWait(IApplicationThread caller, + Intent intent, String resolvedType, IBinder resultTo, String resultWho, + int requestCode, int flags, String profileFile, + ParcelFileDescriptor profileFd, Bundle options, int userId) throws RemoteException; + public int startActivityWithConfig(IApplicationThread caller, + Intent intent, String resolvedType, IBinder resultTo, String resultWho, + int requestCode, int startFlags, Configuration newConfig, + Bundle options, int userId) throws RemoteException; + public int startActivityIntentSender(IApplicationThread caller, + IntentSender intent, Intent fillInIntent, String resolvedType, + IBinder resultTo, String resultWho, int requestCode, + int flagsMask, int flagsValues, Bundle options) throws RemoteException; + public boolean startNextMatchingActivity(IBinder callingActivity, + Intent intent, Bundle options) throws RemoteException; + public boolean finishActivity(IBinder token, int code, Intent data) + throws RemoteException; + public void finishSubActivity(IBinder token, String resultWho, int requestCode) throws RemoteException; + public boolean finishActivityAffinity(IBinder token) throws RemoteException; + public boolean willActivityBeVisible(IBinder token) throws RemoteException; + public Intent registerReceiver(IApplicationThread caller, String callerPackage, + IIntentReceiver receiver, IntentFilter filter, + String requiredPermission, int userId) throws RemoteException; + public void unregisterReceiver(IIntentReceiver receiver) throws RemoteException; + public int broadcastIntent(IApplicationThread caller, Intent intent, + String resolvedType, IIntentReceiver resultTo, int resultCode, + String resultData, Bundle map, String requiredPermission, + boolean serialized, boolean sticky, int userId) throws RemoteException; + public void unbroadcastIntent(IApplicationThread caller, Intent intent, int userId) throws RemoteException; + public void finishReceiver(IBinder who, int resultCode, String resultData, Bundle map, boolean abortBroadcast) throws RemoteException; + public void attachApplication(IApplicationThread app) throws RemoteException; + public void activityResumed(IBinder token) throws RemoteException; + public void activityIdle(IBinder token, Configuration config, + boolean stopProfiling) throws RemoteException; + public void activityPaused(IBinder token) throws RemoteException; + public void activityStopped(IBinder token, Bundle state, + Bitmap thumbnail, CharSequence description) throws RemoteException; + public void activitySlept(IBinder token) throws RemoteException; + public void activityDestroyed(IBinder token) throws RemoteException; + public String getCallingPackage(IBinder token) throws RemoteException; + public ComponentName getCallingActivity(IBinder token) throws RemoteException; + public List getTasks(int maxNum, int flags, + IThumbnailReceiver receiver) throws RemoteException; + public List getRecentTasks(int maxNum, + int flags, int userId) throws RemoteException; + public ActivityManager.TaskThumbnails getTaskThumbnails(int taskId) throws RemoteException; + public Bitmap getTaskTopThumbnail(int taskId) throws RemoteException; + public List getServices(int maxNum, int flags) throws RemoteException; + public List getProcessesInErrorState() + throws RemoteException; + public void moveTaskToFront(int task, int flags, Bundle options) throws RemoteException; + public void moveTaskToBack(int task) throws RemoteException; + public boolean moveActivityTaskToBack(IBinder token, boolean nonRoot) throws RemoteException; + public void moveTaskBackwards(int task) throws RemoteException; + public int getTaskForActivity(IBinder token, boolean onlyRoot) throws RemoteException; + /* oneway */ + public void reportThumbnail(IBinder token, + Bitmap thumbnail, CharSequence description) throws RemoteException; + public ContentProviderHolder getContentProvider(IApplicationThread caller, + String name, int userId, boolean stable) throws RemoteException; + public ContentProviderHolder getContentProviderExternal(String name, int userId, IBinder token) + throws RemoteException; + public void removeContentProvider(IBinder connection, boolean stable) throws RemoteException; + public void removeContentProviderExternal(String name, IBinder token) throws RemoteException; + public void publishContentProviders(IApplicationThread caller, + List providers) throws RemoteException; + public boolean refContentProvider(IBinder connection, int stableDelta, int unstableDelta) + throws RemoteException; + public void unstableProviderDied(IBinder connection) throws RemoteException; + public PendingIntent getRunningServiceControlPanel(ComponentName service) + throws RemoteException; + public ComponentName startService(IApplicationThread caller, Intent service, + String resolvedType, int userId) throws RemoteException; + public int stopService(IApplicationThread caller, Intent service, + String resolvedType, int userId) throws RemoteException; + public boolean stopServiceToken(ComponentName className, IBinder token, + int startId) throws RemoteException; + public void setServiceForeground(ComponentName className, IBinder token, + int id, Notification notification, boolean keepNotification) throws RemoteException; + public int bindService(IApplicationThread caller, IBinder token, + Intent service, String resolvedType, + IServiceConnection connection, int flags, int userId) throws RemoteException; + public boolean unbindService(IServiceConnection connection) throws RemoteException; + public void publishService(IBinder token, + Intent intent, IBinder service) throws RemoteException; + public void unbindFinished(IBinder token, Intent service, + boolean doRebind) throws RemoteException; + /* oneway */ + public void serviceDoneExecuting(IBinder token, int type, int startId, + int res) throws RemoteException; + public IBinder peekService(Intent service, String resolvedType) throws RemoteException; + + public boolean bindBackupAgent(ApplicationInfo appInfo, int backupRestoreMode) + throws RemoteException; + public void clearPendingBackup() throws RemoteException; + public void backupAgentCreated(String packageName, IBinder agent) throws RemoteException; + public void unbindBackupAgent(ApplicationInfo appInfo) throws RemoteException; + public void killApplicationProcess(String processName, int uid) throws RemoteException; + + public boolean startInstrumentation(ComponentName className, String profileFile, + int flags, Bundle arguments, IInstrumentationWatcher watcher, int userId) + throws RemoteException; + public void finishInstrumentation(IApplicationThread target, + int resultCode, Bundle results) throws RemoteException; + + public Configuration getConfiguration() throws RemoteException; + public void updateConfiguration(Configuration values) throws RemoteException; + public void setRequestedOrientation(IBinder token, + int requestedOrientation) throws RemoteException; + public int getRequestedOrientation(IBinder token) throws RemoteException; + + public ComponentName getActivityClassForToken(IBinder token) throws RemoteException; + public String getPackageForToken(IBinder token) throws RemoteException; + + public IIntentSender getIntentSender(int type, + String packageName, IBinder token, String resultWho, + int requestCode, Intent[] intents, String[] resolvedTypes, + int flags, Bundle options, int userId) throws RemoteException; + public void cancelIntentSender(IIntentSender sender) throws RemoteException; + public boolean clearApplicationUserData(final String packageName, + final IPackageDataObserver observer, int userId) throws RemoteException; + public String getPackageForIntentSender(IIntentSender sender) throws RemoteException; + public int getUidForIntentSender(IIntentSender sender) throws RemoteException; + + public int handleIncomingUser(int callingPid, int callingUid, int userId, boolean allowAll, + boolean requireFull, String name, String callerPackage) throws RemoteException; + + public void setProcessLimit(int max) throws RemoteException; + public int getProcessLimit() throws RemoteException; + + public void setProcessForeground(IBinder token, int pid, + boolean isForeground) throws RemoteException; + + public int checkPermission(String permission, int pid, int uid) + throws RemoteException; + + public int checkUriPermission(Uri uri, int pid, int uid, int mode) + throws RemoteException; + public void grantUriPermission(IApplicationThread caller, String targetPkg, + Uri uri, int mode) throws RemoteException; + public void revokeUriPermission(IApplicationThread caller, Uri uri, + int mode) throws RemoteException; + + public void showWaitingForDebugger(IApplicationThread who, boolean waiting) + throws RemoteException; + + public void getMemoryInfo(ActivityManager.MemoryInfo outInfo) throws RemoteException; + + public void killBackgroundProcesses(final String packageName, int userId) + throws RemoteException; + public void killAllBackgroundProcesses() throws RemoteException; + public void forceStopPackage(final String packageName, int userId) throws RemoteException; + + // Note: probably don't want to allow applications access to these. + public void goingToSleep() throws RemoteException; + public void wakingUp() throws RemoteException; + public void setLockScreenShown(boolean shown) throws RemoteException; + + public void unhandledBack() throws RemoteException; + public ParcelFileDescriptor openContentUri(Uri uri) throws RemoteException; + public void setDebugApp( + String packageName, boolean waitForDebugger, boolean persistent) + throws RemoteException; + public void setAlwaysFinish(boolean enabled) throws RemoteException; + public void setActivityController(IActivityController watcher) + throws RemoteException; + + public void enterSafeMode() throws RemoteException; + + public void noteWakeupAlarm(IIntentSender sender) throws RemoteException; + + public boolean killPids(int[] pids, String reason, boolean secure) throws RemoteException; + public boolean killProcessesBelowForeground(String reason) throws RemoteException; + + // Special low-level communication with activity manager. + public void startRunning(String pkg, String cls, String action, + String data) throws RemoteException; + public void handleApplicationCrash(IBinder app, + ApplicationErrorReport.CrashInfo crashInfo) throws RemoteException; + public boolean handleApplicationWtf(IBinder app, String tag, + ApplicationErrorReport.CrashInfo crashInfo) throws RemoteException; + + // A StrictMode violation to be handled. The violationMask is a + // subset of the original StrictMode policy bitmask, with only the + // bit violated and penalty bits to be executed by the + // ActivityManagerService remaining set. + public void handleApplicationStrictModeViolation(IBinder app, int violationMask, + StrictMode.ViolationInfo crashInfo) throws RemoteException; + + /* + * This will deliver the specified signal to all the persistent processes. Currently only + * SIGUSR1 is delivered. All others are ignored. + */ + public void signalPersistentProcesses(int signal) throws RemoteException; + // Retrieve running application processes in the system + public List getRunningAppProcesses() + throws RemoteException; + // Retrieve info of applications installed on external media that are currently + // running. + public List getRunningExternalApplications() + throws RemoteException; + // Get memory information about the calling process. + public void getMyMemoryState(ActivityManager.RunningAppProcessInfo outInfo) + throws RemoteException; + // Get device configuration + public ConfigurationInfo getDeviceConfigurationInfo() throws RemoteException; + + // Turn on/off profiling in a particular process. + public boolean profileControl(String process, int userId, boolean start, + String path, ParcelFileDescriptor fd, int profileType) throws RemoteException; + + public boolean shutdown(int timeout) throws RemoteException; + + public void stopAppSwitches() throws RemoteException; + public void resumeAppSwitches() throws RemoteException; + + public void killApplicationWithAppId(String pkg, int appid) throws RemoteException; + + public void closeSystemDialogs(String reason) throws RemoteException; + + public Debug.MemoryInfo[] getProcessMemoryInfo(int[] pids) + throws RemoteException; + + public void overridePendingTransition(IBinder token, String packageName, + int enterAnim, int exitAnim) throws RemoteException; + + 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; + + public void crashApplication(int uid, int initialPid, String packageName, + String message) throws RemoteException; + + public String getProviderMimeType(Uri uri, int userId) throws RemoteException; + + public IBinder newUriPermissionOwner(String name) throws RemoteException; + public void grantUriPermissionFromOwner(IBinder owner, int fromUid, String targetPkg, + Uri uri, int mode) throws RemoteException; + public void revokeUriPermissionFromOwner(IBinder owner, Uri uri, + int mode) throws RemoteException; + + public int checkGrantUriPermission(int callingUid, String targetPkg, + Uri uri, int modeFlags) throws RemoteException; + + // Cause the specified process to dump the specified heap. + public boolean dumpHeap(String process, int userId, boolean managed, String path, + ParcelFileDescriptor fd) throws RemoteException; + + public int startActivities(IApplicationThread caller, + Intent[] intents, String[] resolvedTypes, IBinder resultTo, + Bundle options, int userId) throws RemoteException; + + public int getFrontActivityScreenCompatMode() throws RemoteException; + public void setFrontActivityScreenCompatMode(int mode) throws RemoteException; + public int getPackageScreenCompatMode(String packageName) throws RemoteException; + public void setPackageScreenCompatMode(String packageName, int mode) + throws RemoteException; + public boolean getPackageAskScreenCompat(String packageName) throws RemoteException; + public void setPackageAskScreenCompat(String packageName, boolean ask) + throws RemoteException; + + // Multi-user APIs + public boolean switchUser(int userid) throws RemoteException; + public int stopUser(int userid, IStopUserCallback callback) throws RemoteException; + public UserInfo getCurrentUser() throws RemoteException; + public boolean isUserRunning(int userid, boolean orStopping) throws RemoteException; + public int[] getRunningUserIds() throws RemoteException; + + public boolean removeSubTask(int taskId, int subTaskIndex) throws RemoteException; + + public boolean removeTask(int taskId, int flags) throws RemoteException; + + public void registerProcessObserver(IProcessObserver observer) throws RemoteException; + public void unregisterProcessObserver(IProcessObserver observer) throws RemoteException; + + public boolean isIntentSenderTargetedToPackage(IIntentSender sender) throws RemoteException; + + public boolean isIntentSenderAnActivity(IIntentSender sender) throws RemoteException; + + public void updatePersistentConfiguration(Configuration values) throws RemoteException; + + public long[] getProcessPss(int[] pids) throws RemoteException; + + public void showBootMessage(CharSequence msg, boolean always) throws RemoteException; + + public void dismissKeyguardOnNextActivity() throws RemoteException; + + public boolean targetTaskAffinityMatchesActivity(IBinder token, String destAffinity) + throws RemoteException; + + public boolean navigateUpTo(IBinder token, Intent target, int resultCode, Intent resultData) + throws RemoteException; + + // This is not public because you need to be very careful in how you + // manage your activity to make sure it is always the uid you expect. + public int getLaunchedFromUid(IBinder activityToken) throws RemoteException; + + public void registerUserSwitchObserver(IUserSwitchObserver observer) throws RemoteException; + public void unregisterUserSwitchObserver(IUserSwitchObserver observer) throws RemoteException; + + public void requestBugReport() throws RemoteException; + + public long inputDispatchingTimedOut(int pid, boolean aboveSystem) throws RemoteException; + + /* + * Private non-Binder interfaces + */ + /* package */ boolean testIsSystemReady(); + + /** Information you can retrieve about a particular application. */ + public static class ContentProviderHolder implements Parcelable { + public final ProviderInfo info; + public IContentProvider provider; + public IBinder connection; + public boolean noReleaseNeeded; + + public ContentProviderHolder(ProviderInfo _info) { + info = _info; + } + + public int describeContents() { + return 0; + } + + public void writeToParcel(Parcel dest, int flags) { + info.writeToParcel(dest, 0); + if (provider != null) { + dest.writeStrongBinder(provider.asBinder()); + } else { + dest.writeStrongBinder(null); + } + dest.writeStrongBinder(connection); + dest.writeInt(noReleaseNeeded ? 1:0); + } + + public static final Parcelable.Creator CREATOR + = new Parcelable.Creator() { + public ContentProviderHolder createFromParcel(Parcel source) { + return new ContentProviderHolder(source); + } + + public ContentProviderHolder[] newArray(int size) { + return new ContentProviderHolder[size]; + } + }; + + private ContentProviderHolder(Parcel source) { + info = ProviderInfo.CREATOR.createFromParcel(source); + provider = ContentProviderNative.asInterface( + source.readStrongBinder()); + connection = source.readStrongBinder(); + noReleaseNeeded = source.readInt() != 0; + } + } + + /** Information returned after waiting for an activity start. */ + public static class WaitResult implements Parcelable { + public int result; + public boolean timeout; + public ComponentName who; + public long thisTime; + public long totalTime; + + public WaitResult() { + } + + public int describeContents() { + return 0; + } + + public void writeToParcel(Parcel dest, int flags) { + dest.writeInt(result); + dest.writeInt(timeout ? 1 : 0); + ComponentName.writeToParcel(who, dest); + dest.writeLong(thisTime); + dest.writeLong(totalTime); + } + + public static final Parcelable.Creator CREATOR + = new Parcelable.Creator() { + public WaitResult createFromParcel(Parcel source) { + return new WaitResult(source); + } + + public WaitResult[] newArray(int size) { + return new WaitResult[size]; + } + }; + + private WaitResult(Parcel source) { + result = source.readInt(); + timeout = source.readInt() != 0; + who = ComponentName.readFromParcel(source); + thisTime = source.readLong(); + totalTime = source.readLong(); + } + }; + + String descriptor = "android.app.IActivityManager"; + + // Please keep these transaction codes the same -- they are also + // sent by C++ code. + int START_RUNNING_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION; + int HANDLE_APPLICATION_CRASH_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+1; + int START_ACTIVITY_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+2; + int UNHANDLED_BACK_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+3; + int OPEN_CONTENT_URI_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+4; + + // Remaining non-native transaction codes. + int FINISH_ACTIVITY_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+10; + int REGISTER_RECEIVER_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+11; + int UNREGISTER_RECEIVER_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+12; + int BROADCAST_INTENT_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+13; + int UNBROADCAST_INTENT_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+14; + int FINISH_RECEIVER_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+15; + int ATTACH_APPLICATION_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+16; + int ACTIVITY_IDLE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+17; + int ACTIVITY_PAUSED_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+18; + int ACTIVITY_STOPPED_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+19; + int GET_CALLING_PACKAGE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+20; + int GET_CALLING_ACTIVITY_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+21; + int GET_TASKS_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+22; + int MOVE_TASK_TO_FRONT_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+23; + int MOVE_TASK_TO_BACK_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+24; + int MOVE_TASK_BACKWARDS_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+25; + int GET_TASK_FOR_ACTIVITY_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+26; + int REPORT_THUMBNAIL_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+27; + int GET_CONTENT_PROVIDER_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+28; + int PUBLISH_CONTENT_PROVIDERS_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+29; + int REF_CONTENT_PROVIDER_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+30; + int FINISH_SUB_ACTIVITY_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+31; + int GET_RUNNING_SERVICE_CONTROL_PANEL_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+32; + int START_SERVICE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+33; + int STOP_SERVICE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+34; + int BIND_SERVICE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+35; + int UNBIND_SERVICE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+36; + int PUBLISH_SERVICE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+37; + int ACTIVITY_RESUMED_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+38; + int GOING_TO_SLEEP_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+39; + int WAKING_UP_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+40; + int SET_DEBUG_APP_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+41; + int SET_ALWAYS_FINISH_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+42; + int START_INSTRUMENTATION_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+43; + int FINISH_INSTRUMENTATION_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+44; + int GET_CONFIGURATION_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+45; + int UPDATE_CONFIGURATION_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+46; + int STOP_SERVICE_TOKEN_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+47; + int GET_ACTIVITY_CLASS_FOR_TOKEN_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+48; + int GET_PACKAGE_FOR_TOKEN_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+49; + int SET_PROCESS_LIMIT_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+50; + int GET_PROCESS_LIMIT_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+51; + int CHECK_PERMISSION_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+52; + int CHECK_URI_PERMISSION_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+53; + int GRANT_URI_PERMISSION_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+54; + int REVOKE_URI_PERMISSION_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+55; + int SET_ACTIVITY_CONTROLLER_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+56; + int SHOW_WAITING_FOR_DEBUGGER_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+57; + int SIGNAL_PERSISTENT_PROCESSES_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+58; + int GET_RECENT_TASKS_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+59; + int SERVICE_DONE_EXECUTING_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+60; + int ACTIVITY_DESTROYED_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+61; + int GET_INTENT_SENDER_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+62; + int CANCEL_INTENT_SENDER_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+63; + int GET_PACKAGE_FOR_INTENT_SENDER_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+64; + int ENTER_SAFE_MODE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+65; + int START_NEXT_MATCHING_ACTIVITY_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+66; + int NOTE_WAKEUP_ALARM_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+67; + int REMOVE_CONTENT_PROVIDER_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+68; + int SET_REQUESTED_ORIENTATION_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+69; + int GET_REQUESTED_ORIENTATION_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+70; + int UNBIND_FINISHED_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+71; + int SET_PROCESS_FOREGROUND_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+72; + int SET_SERVICE_FOREGROUND_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+73; + int MOVE_ACTIVITY_TASK_TO_BACK_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+74; + int GET_MEMORY_INFO_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+75; + int GET_PROCESSES_IN_ERROR_STATE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+76; + int CLEAR_APP_DATA_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+77; + int FORCE_STOP_PACKAGE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+78; + int KILL_PIDS_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+79; + int GET_SERVICES_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+80; + int GET_TASK_THUMBNAILS_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+81; + int GET_RUNNING_APP_PROCESSES_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+82; + int GET_DEVICE_CONFIGURATION_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+83; + int PEEK_SERVICE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+84; + int PROFILE_CONTROL_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+85; + int SHUTDOWN_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+86; + int STOP_APP_SWITCHES_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+87; + int RESUME_APP_SWITCHES_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+88; + int START_BACKUP_AGENT_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+89; + int BACKUP_AGENT_CREATED_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+90; + int UNBIND_BACKUP_AGENT_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+91; + int GET_UID_FOR_INTENT_SENDER_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+92; + int HANDLE_INCOMING_USER_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+93; + int GET_TASK_TOP_THUMBNAIL_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+94; + int KILL_APPLICATION_WITH_APPID_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+95; + int CLOSE_SYSTEM_DIALOGS_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+96; + int GET_PROCESS_MEMORY_INFO_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+97; + int KILL_APPLICATION_PROCESS_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+98; + int START_ACTIVITY_INTENT_SENDER_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+99; + int OVERRIDE_PENDING_TRANSITION_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+100; + int HANDLE_APPLICATION_WTF_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+101; + int KILL_BACKGROUND_PROCESSES_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+102; + int IS_USER_A_MONKEY_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+103; + int START_ACTIVITY_AND_WAIT_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+104; + int WILL_ACTIVITY_BE_VISIBLE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+105; + int START_ACTIVITY_WITH_CONFIG_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+106; + 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; + int CRASH_APPLICATION_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+113; + int GET_PROVIDER_MIME_TYPE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+114; + int NEW_URI_PERMISSION_OWNER_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+115; + int GRANT_URI_PERMISSION_FROM_OWNER_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+116; + int REVOKE_URI_PERMISSION_FROM_OWNER_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+117; + int CHECK_GRANT_URI_PERMISSION_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+118; + int DUMP_HEAP_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+119; + int START_ACTIVITIES_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+120; + int IS_USER_RUNNING_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+121; + int ACTIVITY_SLEPT_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+122; + int GET_FRONT_ACTIVITY_SCREEN_COMPAT_MODE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+123; + int SET_FRONT_ACTIVITY_SCREEN_COMPAT_MODE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+124; + int GET_PACKAGE_SCREEN_COMPAT_MODE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+125; + int SET_PACKAGE_SCREEN_COMPAT_MODE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+126; + int GET_PACKAGE_ASK_SCREEN_COMPAT_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+127; + int SET_PACKAGE_ASK_SCREEN_COMPAT_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+128; + int SWITCH_USER_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+129; + int REMOVE_SUB_TASK_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+130; + int REMOVE_TASK_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+131; + int REGISTER_PROCESS_OBSERVER_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+132; + int UNREGISTER_PROCESS_OBSERVER_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+133; + int IS_INTENT_SENDER_TARGETED_TO_PACKAGE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+134; + int UPDATE_PERSISTENT_CONFIGURATION_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+135; + int GET_PROCESS_PSS_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+136; + int SHOW_BOOT_MESSAGE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+137; + int DISMISS_KEYGUARD_ON_NEXT_ACTIVITY_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+138; + int KILL_ALL_BACKGROUND_PROCESSES_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+139; + int GET_CONTENT_PROVIDER_EXTERNAL_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+140; + int REMOVE_CONTENT_PROVIDER_EXTERNAL_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+141; + int GET_MY_MEMORY_STATE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+142; + int KILL_PROCESSES_BELOW_FOREGROUND_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+143; + int GET_CURRENT_USER_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+144; + int TARGET_TASK_AFFINITY_MATCHES_ACTIVITY_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+145; + int NAVIGATE_UP_TO_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+146; + int SET_LOCK_SCREEN_SHOWN_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+147; + int FINISH_ACTIVITY_AFFINITY_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+148; + int GET_LAUNCHED_FROM_UID_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+149; + int UNSTABLE_PROVIDER_DIED_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+150; + int IS_INTENT_SENDER_AN_ACTIVITY_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+151; + int START_ACTIVITY_AS_USER_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+152; + int STOP_USER_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+153; + int REGISTER_USER_SWITCH_OBSERVER_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+154; + int UNREGISTER_USER_SWITCH_OBSERVER_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+155; + int GET_RUNNING_USER_IDS_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+156; + int REQUEST_BUG_REPORT_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+157; + int INPUT_DISPATCHING_TIMED_OUT_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+158; + int CLEAR_PENDING_BACKUP_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+159; +} diff --git a/src/strictmode-lib/android-prebuilt/r18/prebuilt/core.jar b/src/strictmode-lib/android-prebuilt/r18/prebuilt/core.jar new file mode 100644 index 0000000..acdf3db Binary files /dev/null and b/src/strictmode-lib/android-prebuilt/r18/prebuilt/core.jar differ diff --git a/src/strictmode-lib/android-prebuilt/r18/prebuilt/framework.jar b/src/strictmode-lib/android-prebuilt/r18/prebuilt/framework.jar new file mode 100644 index 0000000..58eeab7 Binary files /dev/null and b/src/strictmode-lib/android-prebuilt/r18/prebuilt/framework.jar differ diff --git a/src/strictmode-lib/android-prebuilt/r18/project.properties b/src/strictmode-lib/android-prebuilt/r18/project.properties new file mode 100644 index 0000000..5d37054 --- /dev/null +++ b/src/strictmode-lib/android-prebuilt/r18/project.properties @@ -0,0 +1,7 @@ +project.name=com.robomorphine.strictmode.lib.prebuilt.r18 +project.type=lib + +android.library=true +target=android-18 + +android.library.reference.1=../common diff --git a/src/strictmode-lib/android-prebuilt/r18/src/android/app/IActivityManagerProxyR18.java b/src/strictmode-lib/android-prebuilt/r18/src/android/app/IActivityManagerProxyR18.java new file mode 100644 index 0000000..c5f3c5e --- /dev/null +++ b/src/strictmode-lib/android-prebuilt/r18/src/android/app/IActivityManagerProxyR18.java @@ -0,0 +1,789 @@ +package android.app; + +import com.robomorphine.strictmode.DataProxy; + +import android.app.ActivityManager.MemoryInfo; +import android.app.ActivityManager.ProcessErrorStateInfo; +import android.app.ActivityManager.RecentTaskInfo; +import android.app.ActivityManager.RunningAppProcessInfo; +import android.app.ActivityManager.TaskThumbnails; +import android.app.ApplicationErrorReport.CrashInfo; +import android.content.ComponentName; +import android.content.IIntentReceiver; +import android.content.IIntentSender; +import android.content.Intent; +import android.content.IntentFilter; +import android.content.IntentSender; +import android.content.pm.ApplicationInfo; +import android.content.pm.ConfigurationInfo; +import android.content.pm.IPackageDataObserver; +import android.content.pm.UserInfo; +import android.content.res.Configuration; +import android.graphics.Bitmap; +import android.net.Uri; +import android.os.Bundle; +import android.os.IBinder; +import android.os.ParcelFileDescriptor; +import android.os.RemoteException; +import android.os.StrictMode.ViolationInfo; + +import java.util.List; + +@SuppressWarnings("all") +public class IActivityManagerProxyR18 implements IActivityManager { + + private final IActivityManager mTo; + private final DataProxy mViolationProxy; + + public IActivityManagerProxyR18(IActivityManager manager, DataProxy violationProxy) { + mTo = manager; + mViolationProxy = violationProxy; + } + + public void handleApplicationStrictModeViolation(IBinder binder, int mask, ViolationInfo info) + throws RemoteException { + mTo.handleApplicationStrictModeViolation(binder, mask, mViolationProxy.handle(info)); + } + + public void activityDestroyed(IBinder arg0) throws RemoteException { + mTo.activityDestroyed(arg0); + } + + public void activityIdle(IBinder arg0, Configuration arg1, boolean arg2) + throws RemoteException { + mTo.activityIdle(arg0, arg1, arg2); + } + + public void activityPaused(IBinder arg0) throws RemoteException { + mTo.activityPaused(arg0); + } + + public void activityResumed(IBinder arg0) throws RemoteException { + mTo.activityResumed(arg0); + } + + public void activitySlept(IBinder arg0) throws RemoteException { + mTo.activitySlept(arg0); + } + + public void activityStopped(IBinder arg0, Bundle arg1, Bitmap arg2, + CharSequence arg3) throws RemoteException { + mTo.activityStopped(arg0, arg1, arg2, arg3); + } + + public IBinder asBinder() { + return mTo.asBinder(); + } + + public void attachApplication(IApplicationThread arg0) + throws RemoteException { + mTo.attachApplication(arg0); + } + + public void backupAgentCreated(String arg0, IBinder arg1) + throws RemoteException { + mTo.backupAgentCreated(arg0, arg1); + } + + public boolean bindBackupAgent(ApplicationInfo arg0, int arg1) + throws RemoteException { + return mTo.bindBackupAgent(arg0, arg1); + } + + public int bindService(IApplicationThread arg0, IBinder arg1, Intent arg2, + String arg3, IServiceConnection arg4, int arg5, int arg6) + throws RemoteException { + return mTo.bindService(arg0, arg1, arg2, arg3, arg4, arg5, arg6); + } + + public int broadcastIntent(IApplicationThread arg0, Intent arg1, + String arg2, IIntentReceiver arg3, int arg4, String arg5, + Bundle arg6, String arg7, boolean arg8, boolean arg9, int arg10) + throws RemoteException { + return mTo.broadcastIntent(arg0, arg1, arg2, arg3, arg4, arg5, arg6, + arg7, arg8, arg9, arg10); + } + + public void cancelIntentSender(IIntentSender arg0) throws RemoteException { + mTo.cancelIntentSender(arg0); + } + + public int checkGrantUriPermission(int arg0, String arg1, Uri arg2, int arg3) + throws RemoteException { + return mTo.checkGrantUriPermission(arg0, arg1, arg2, arg3); + } + + public int checkPermission(String arg0, int arg1, int arg2) + throws RemoteException { + return mTo.checkPermission(arg0, arg1, arg2); + } + + public int checkUriPermission(Uri arg0, int arg1, int arg2, int arg3) + throws RemoteException { + return mTo.checkUriPermission(arg0, arg1, arg2, arg3); + } + + public boolean clearApplicationUserData(String arg0, + IPackageDataObserver arg1, int arg2) throws RemoteException { + return mTo.clearApplicationUserData(arg0, arg1, arg2); + } + + public void clearPendingBackup() throws RemoteException { + mTo.clearPendingBackup(); + } + + public void closeSystemDialogs(String arg0) throws RemoteException { + mTo.closeSystemDialogs(arg0); + } + + public void crashApplication(int arg0, int arg1, String arg2, String arg3) + throws RemoteException { + mTo.crashApplication(arg0, arg1, arg2, arg3); + } + + public void dismissKeyguardOnNextActivity() throws RemoteException { + mTo.dismissKeyguardOnNextActivity(); + } + + public boolean dumpHeap(String arg0, int arg1, boolean arg2, String arg3, + ParcelFileDescriptor arg4) throws RemoteException { + return mTo.dumpHeap(arg0, arg1, arg2, arg3, arg4); + } + + public void enterSafeMode() throws RemoteException { + mTo.enterSafeMode(); + } + + public boolean finishActivity(IBinder arg0, int arg1, Intent arg2) + throws RemoteException { + return mTo.finishActivity(arg0, arg1, arg2); + } + + public boolean finishActivityAffinity(IBinder arg0) throws RemoteException { + return mTo.finishActivityAffinity(arg0); + } + + public void finishHeavyWeightApp() throws RemoteException { + mTo.finishHeavyWeightApp(); + } + + public void finishInstrumentation(IApplicationThread arg0, int arg1, + Bundle arg2) throws RemoteException { + mTo.finishInstrumentation(arg0, arg1, arg2); + } + + public void finishReceiver(IBinder arg0, int arg1, String arg2, + Bundle arg3, boolean arg4) throws RemoteException { + mTo.finishReceiver(arg0, arg1, arg2, arg3, arg4); + } + + public void finishSubActivity(IBinder arg0, String arg1, int arg2) + throws RemoteException { + mTo.finishSubActivity(arg0, arg1, arg2); + } + + public void forceStopPackage(String arg0, int arg1) throws RemoteException { + mTo.forceStopPackage(arg0, arg1); + } + + public ComponentName getActivityClassForToken(IBinder arg0) + throws RemoteException { + return mTo.getActivityClassForToken(arg0); + } + + public ComponentName getCallingActivity(IBinder arg0) + throws RemoteException { + return mTo.getCallingActivity(arg0); + } + + public String getCallingPackage(IBinder arg0) throws RemoteException { + return mTo.getCallingPackage(arg0); + } + + public Configuration getConfiguration() throws RemoteException { + return mTo.getConfiguration(); + } + + public ContentProviderHolder getContentProvider(IApplicationThread arg0, + String arg1, int arg2, boolean arg3) throws RemoteException { + return mTo.getContentProvider(arg0, arg1, arg2, arg3); + } + + public ContentProviderHolder getContentProviderExternal(String arg0, + int arg1, IBinder arg2) throws RemoteException { + return mTo.getContentProviderExternal(arg0, arg1, arg2); + } + + public UserInfo getCurrentUser() throws RemoteException { + return mTo.getCurrentUser(); + } + + public ConfigurationInfo getDeviceConfigurationInfo() + throws RemoteException { + return mTo.getDeviceConfigurationInfo(); + } + + public int getFrontActivityScreenCompatMode() throws RemoteException { + return mTo.getFrontActivityScreenCompatMode(); + } + + public IIntentSender getIntentSender(int arg0, String arg1, IBinder arg2, + String arg3, int arg4, Intent[] arg5, String[] arg6, int arg7, + Bundle arg8, int arg9) throws RemoteException { + return mTo.getIntentSender(arg0, arg1, arg2, arg3, arg4, arg5, arg6, + arg7, arg8, arg9); + } + + public int getLaunchedFromUid(IBinder arg0) throws RemoteException { + return mTo.getLaunchedFromUid(arg0); + } + + public void getMemoryInfo(MemoryInfo arg0) throws RemoteException { + mTo.getMemoryInfo(arg0); + } + + public void getMyMemoryState(RunningAppProcessInfo arg0) + throws RemoteException { + mTo.getMyMemoryState(arg0); + } + + public boolean getPackageAskScreenCompat(String arg0) + throws RemoteException { + return mTo.getPackageAskScreenCompat(arg0); + } + + public String getPackageForIntentSender(IIntentSender arg0) + throws RemoteException { + return mTo.getPackageForIntentSender(arg0); + } + + public String getPackageForToken(IBinder arg0) throws RemoteException { + return mTo.getPackageForToken(arg0); + } + + public int getPackageScreenCompatMode(String arg0) throws RemoteException { + return mTo.getPackageScreenCompatMode(arg0); + } + + public int getProcessLimit() throws RemoteException { + return mTo.getProcessLimit(); + } + + public android.os.Debug.MemoryInfo[] getProcessMemoryInfo(int[] arg0) + throws RemoteException { + return mTo.getProcessMemoryInfo(arg0); + } + + public long[] getProcessPss(int[] arg0) throws RemoteException { + return mTo.getProcessPss(arg0); + } + + public List getProcessesInErrorState() + throws RemoteException { + return mTo.getProcessesInErrorState(); + } + + public String getProviderMimeType(Uri arg0, int arg1) + throws RemoteException { + return mTo.getProviderMimeType(arg0, arg1); + } + + public List getRecentTasks(int arg0, int arg1, int arg2) + throws RemoteException { + return mTo.getRecentTasks(arg0, arg1, arg2); + } + + public int getRequestedOrientation(IBinder arg0) throws RemoteException { + return mTo.getRequestedOrientation(arg0); + } + + public List getRunningAppProcesses() + throws RemoteException { + return mTo.getRunningAppProcesses(); + } + + public List getRunningExternalApplications() + throws RemoteException { + return mTo.getRunningExternalApplications(); + } + + public PendingIntent getRunningServiceControlPanel(ComponentName arg0) + throws RemoteException { + return mTo.getRunningServiceControlPanel(arg0); + } + + public int[] getRunningUserIds() throws RemoteException { + return mTo.getRunningUserIds(); + } + + public List getServices(int arg0, int arg1) throws RemoteException { + return mTo.getServices(arg0, arg1); + } + + public int getTaskForActivity(IBinder arg0, boolean arg1) + throws RemoteException { + return mTo.getTaskForActivity(arg0, arg1); + } + + public TaskThumbnails getTaskThumbnails(int arg0) throws RemoteException { + return mTo.getTaskThumbnails(arg0); + } + + public Bitmap getTaskTopThumbnail(int arg0) throws RemoteException { + return mTo.getTaskTopThumbnail(arg0); + } + + public List getTasks(int arg0, int arg1, IThumbnailReceiver arg2) + throws RemoteException { + return mTo.getTasks(arg0, arg1, arg2); + } + + public int getUidForIntentSender(IIntentSender arg0) throws RemoteException { + return mTo.getUidForIntentSender(arg0); + } + + public void goingToSleep() throws RemoteException { + mTo.goingToSleep(); + } + + public void grantUriPermission(IApplicationThread arg0, String arg1, + Uri arg2, int arg3) throws RemoteException { + mTo.grantUriPermission(arg0, arg1, arg2, arg3); + } + + public void grantUriPermissionFromOwner(IBinder arg0, int arg1, + String arg2, Uri arg3, int arg4) throws RemoteException { + mTo.grantUriPermissionFromOwner(arg0, arg1, arg2, arg3, arg4); + } + + public void handleApplicationCrash(IBinder arg0, CrashInfo arg1) + throws RemoteException { + mTo.handleApplicationCrash(arg0, arg1); + } + + public boolean handleApplicationWtf(IBinder arg0, String arg1, + CrashInfo arg2) throws RemoteException { + return mTo.handleApplicationWtf(arg0, arg1, arg2); + } + + public int handleIncomingUser(int arg0, int arg1, int arg2, boolean arg3, + boolean arg4, String arg5, String arg6) throws RemoteException { + return mTo.handleIncomingUser(arg0, arg1, arg2, arg3, arg4, arg5, arg6); + } + + public long inputDispatchingTimedOut(int arg0, boolean arg1) + throws RemoteException { + return mTo.inputDispatchingTimedOut(arg0, arg1); + } + + public boolean isImmersive(IBinder arg0) throws RemoteException { + return mTo.isImmersive(arg0); + } + + public boolean isIntentSenderAnActivity(IIntentSender arg0) + throws RemoteException { + return mTo.isIntentSenderAnActivity(arg0); + } + + public boolean isIntentSenderTargetedToPackage(IIntentSender arg0) + throws RemoteException { + return mTo.isIntentSenderTargetedToPackage(arg0); + } + + public boolean isTopActivityImmersive() throws RemoteException { + return mTo.isTopActivityImmersive(); + } + + public boolean isUserAMonkey() throws RemoteException { + return mTo.isUserAMonkey(); + } + + public boolean isUserRunning(int arg0, boolean arg1) throws RemoteException { + return mTo.isUserRunning(arg0, arg1); + } + + public void killAllBackgroundProcesses() throws RemoteException { + mTo.killAllBackgroundProcesses(); + } + + public void killApplicationProcess(String arg0, int arg1) + throws RemoteException { + mTo.killApplicationProcess(arg0, arg1); + } + + public void killApplicationWithAppId(String arg0, int arg1) + throws RemoteException { + mTo.killApplicationWithAppId(arg0, arg1); + } + + public void killBackgroundProcesses(String arg0, int arg1) + throws RemoteException { + mTo.killBackgroundProcesses(arg0, arg1); + } + + public boolean killPids(int[] arg0, String arg1, boolean arg2) + throws RemoteException { + return mTo.killPids(arg0, arg1, arg2); + } + + public boolean killProcessesBelowForeground(String arg0) + throws RemoteException { + return mTo.killProcessesBelowForeground(arg0); + } + + public boolean moveActivityTaskToBack(IBinder arg0, boolean arg1) + throws RemoteException { + return mTo.moveActivityTaskToBack(arg0, arg1); + } + + public void moveTaskBackwards(int arg0) throws RemoteException { + mTo.moveTaskBackwards(arg0); + } + + public void moveTaskToBack(int arg0) throws RemoteException { + mTo.moveTaskToBack(arg0); + } + + public void moveTaskToFront(int arg0, int arg1, Bundle arg2) + throws RemoteException { + mTo.moveTaskToFront(arg0, arg1, arg2); + } + + public boolean navigateUpTo(IBinder arg0, Intent arg1, int arg2, Intent arg3) + throws RemoteException { + return mTo.navigateUpTo(arg0, arg1, arg2, arg3); + } + + public IBinder newUriPermissionOwner(String arg0) throws RemoteException { + return mTo.newUriPermissionOwner(arg0); + } + + public void noteWakeupAlarm(IIntentSender arg0) throws RemoteException { + mTo.noteWakeupAlarm(arg0); + } + + public ParcelFileDescriptor openContentUri(Uri arg0) throws RemoteException { + return mTo.openContentUri(arg0); + } + + public void overridePendingTransition(IBinder arg0, String arg1, int arg2, + int arg3) throws RemoteException { + mTo.overridePendingTransition(arg0, arg1, arg2, arg3); + } + + public IBinder peekService(Intent arg0, String arg1) throws RemoteException { + return mTo.peekService(arg0, arg1); + } + + public boolean profileControl(String arg0, int arg1, boolean arg2, + String arg3, ParcelFileDescriptor arg4, int arg5) + throws RemoteException { + return mTo.profileControl(arg0, arg1, arg2, arg3, arg4, arg5); + } + + public void publishContentProviders(IApplicationThread arg0, + List arg1) throws RemoteException { + mTo.publishContentProviders(arg0, arg1); + } + + public void publishService(IBinder arg0, Intent arg1, IBinder arg2) + throws RemoteException { + mTo.publishService(arg0, arg1, arg2); + } + + public boolean refContentProvider(IBinder arg0, int arg1, int arg2) + throws RemoteException { + return mTo.refContentProvider(arg0, arg1, arg2); + } + + public void registerProcessObserver(IProcessObserver arg0) + throws RemoteException { + mTo.registerProcessObserver(arg0); + } + + public Intent registerReceiver(IApplicationThread arg0, String arg1, + IIntentReceiver arg2, IntentFilter arg3, String arg4, int arg5) + throws RemoteException { + return mTo.registerReceiver(arg0, arg1, arg2, arg3, arg4, arg5); + } + + public void registerUserSwitchObserver(IUserSwitchObserver arg0) + throws RemoteException { + mTo.registerUserSwitchObserver(arg0); + } + + public void removeContentProvider(IBinder arg0, boolean arg1) + throws RemoteException { + mTo.removeContentProvider(arg0, arg1); + } + + public void removeContentProviderExternal(String arg0, IBinder arg1) + throws RemoteException { + mTo.removeContentProviderExternal(arg0, arg1); + } + + public boolean removeSubTask(int arg0, int arg1) throws RemoteException { + return mTo.removeSubTask(arg0, arg1); + } + + public boolean removeTask(int arg0, int arg1) throws RemoteException { + return mTo.removeTask(arg0, arg1); + } + + public void reportThumbnail(IBinder arg0, Bitmap arg1, CharSequence arg2) + throws RemoteException { + mTo.reportThumbnail(arg0, arg1, arg2); + } + + public void requestBugReport() throws RemoteException { + mTo.requestBugReport(); + } + + public void resumeAppSwitches() throws RemoteException { + mTo.resumeAppSwitches(); + } + + public void revokeUriPermission(IApplicationThread arg0, Uri arg1, int arg2) + throws RemoteException { + mTo.revokeUriPermission(arg0, arg1, arg2); + } + + public void revokeUriPermissionFromOwner(IBinder arg0, Uri arg1, int arg2) + throws RemoteException { + mTo.revokeUriPermissionFromOwner(arg0, arg1, arg2); + } + + public void serviceDoneExecuting(IBinder arg0, int arg1, int arg2, int arg3) + throws RemoteException { + mTo.serviceDoneExecuting(arg0, arg1, arg2, arg3); + } + + public void setActivityController(IActivityController arg0) + throws RemoteException { + mTo.setActivityController(arg0); + } + + public void setAlwaysFinish(boolean arg0) throws RemoteException { + mTo.setAlwaysFinish(arg0); + } + + public void setDebugApp(String arg0, boolean arg1, boolean arg2) + throws RemoteException { + mTo.setDebugApp(arg0, arg1, arg2); + } + + public void setFrontActivityScreenCompatMode(int arg0) + throws RemoteException { + mTo.setFrontActivityScreenCompatMode(arg0); + } + + public void setImmersive(IBinder arg0, boolean arg1) throws RemoteException { + mTo.setImmersive(arg0, arg1); + } + + public void setLockScreenShown(boolean arg0) throws RemoteException { + mTo.setLockScreenShown(arg0); + } + + public void setPackageAskScreenCompat(String arg0, boolean arg1) + throws RemoteException { + mTo.setPackageAskScreenCompat(arg0, arg1); + } + + public void setPackageScreenCompatMode(String arg0, int arg1) + throws RemoteException { + mTo.setPackageScreenCompatMode(arg0, arg1); + } + + public void setProcessForeground(IBinder arg0, int arg1, boolean arg2) + throws RemoteException { + mTo.setProcessForeground(arg0, arg1, arg2); + } + + public void setProcessLimit(int arg0) throws RemoteException { + mTo.setProcessLimit(arg0); + } + + public void setRequestedOrientation(IBinder arg0, int arg1) + throws RemoteException { + mTo.setRequestedOrientation(arg0, arg1); + } + + public void setServiceForeground(ComponentName arg0, IBinder arg1, + int arg2, Notification arg3, boolean arg4) throws RemoteException { + mTo.setServiceForeground(arg0, arg1, arg2, arg3, arg4); + } + + public void showBootMessage(CharSequence arg0, boolean arg1) + throws RemoteException { + mTo.showBootMessage(arg0, arg1); + } + + public void showWaitingForDebugger(IApplicationThread arg0, boolean arg1) + throws RemoteException { + mTo.showWaitingForDebugger(arg0, arg1); + } + + public boolean shutdown(int arg0) throws RemoteException { + return mTo.shutdown(arg0); + } + + public void signalPersistentProcesses(int arg0) throws RemoteException { + mTo.signalPersistentProcesses(arg0); + } + + public int startActivities(IApplicationThread arg0, Intent[] arg1, + String[] arg2, IBinder arg3, Bundle arg4, int arg5) + throws RemoteException { + return mTo.startActivities(arg0, arg1, arg2, arg3, arg4, arg5); + } + + public int startActivity(IApplicationThread arg0, Intent arg1, String arg2, + IBinder arg3, String arg4, int arg5, int arg6, String arg7, + ParcelFileDescriptor arg8, Bundle arg9) throws RemoteException { + return mTo.startActivity(arg0, arg1, arg2, arg3, arg4, arg5, arg6, + arg7, arg8, arg9); + } + + public WaitResult startActivityAndWait(IApplicationThread arg0, + Intent arg1, String arg2, IBinder arg3, String arg4, int arg5, + int arg6, String arg7, ParcelFileDescriptor arg8, Bundle arg9, + int arg10) throws RemoteException { + return mTo.startActivityAndWait(arg0, arg1, arg2, arg3, arg4, arg5, + arg6, arg7, arg8, arg9, arg10); + } + + public int startActivityAsUser(IApplicationThread arg0, Intent arg1, + String arg2, IBinder arg3, String arg4, int arg5, int arg6, + String arg7, ParcelFileDescriptor arg8, Bundle arg9, int arg10) + throws RemoteException { + return mTo.startActivityAsUser(arg0, arg1, arg2, arg3, arg4, arg5, + arg6, arg7, arg8, arg9, arg10); + } + + public int startActivityIntentSender(IApplicationThread arg0, + IntentSender arg1, Intent arg2, String arg3, IBinder arg4, + String arg5, int arg6, int arg7, int arg8, Bundle arg9) + throws RemoteException { + return mTo.startActivityIntentSender(arg0, arg1, arg2, arg3, arg4, + arg5, arg6, arg7, arg8, arg9); + } + + public int startActivityWithConfig(IApplicationThread arg0, Intent arg1, + String arg2, IBinder arg3, String arg4, int arg5, int arg6, + Configuration arg7, Bundle arg8, int arg9) throws RemoteException { + return mTo.startActivityWithConfig(arg0, arg1, arg2, arg3, arg4, arg5, + arg6, arg7, arg8, arg9); + } + + public boolean startInstrumentation(ComponentName arg0, String arg1, + int arg2, Bundle arg3, IInstrumentationWatcher arg4, int arg5) + throws RemoteException { + return mTo.startInstrumentation(arg0, arg1, arg2, arg3, arg4, arg5); + } + + public boolean startNextMatchingActivity(IBinder arg0, Intent arg1, + Bundle arg2) throws RemoteException { + return mTo.startNextMatchingActivity(arg0, arg1, arg2); + } + + public void startRunning(String arg0, String arg1, String arg2, String arg3) + throws RemoteException { + mTo.startRunning(arg0, arg1, arg2, arg3); + } + + public ComponentName startService(IApplicationThread arg0, Intent arg1, + String arg2, int arg3) throws RemoteException { + return mTo.startService(arg0, arg1, arg2, arg3); + } + + public void stopAppSwitches() throws RemoteException { + mTo.stopAppSwitches(); + } + + public int stopService(IApplicationThread arg0, Intent arg1, String arg2, + int arg3) throws RemoteException { + return mTo.stopService(arg0, arg1, arg2, arg3); + } + + public boolean stopServiceToken(ComponentName arg0, IBinder arg1, int arg2) + throws RemoteException { + return mTo.stopServiceToken(arg0, arg1, arg2); + } + + public int stopUser(int arg0, IStopUserCallback arg1) + throws RemoteException { + return mTo.stopUser(arg0, arg1); + } + + public boolean switchUser(int arg0) throws RemoteException { + return mTo.switchUser(arg0); + } + + public boolean targetTaskAffinityMatchesActivity(IBinder arg0, String arg1) + throws RemoteException { + return mTo.targetTaskAffinityMatchesActivity(arg0, arg1); + } + + public boolean testIsSystemReady() { + return mTo.testIsSystemReady(); + } + + public void unbindBackupAgent(ApplicationInfo arg0) throws RemoteException { + mTo.unbindBackupAgent(arg0); + } + + public void unbindFinished(IBinder arg0, Intent arg1, boolean arg2) + throws RemoteException { + mTo.unbindFinished(arg0, arg1, arg2); + } + + public boolean unbindService(IServiceConnection arg0) + throws RemoteException { + return mTo.unbindService(arg0); + } + + public void unbroadcastIntent(IApplicationThread arg0, Intent arg1, int arg2) + throws RemoteException { + mTo.unbroadcastIntent(arg0, arg1, arg2); + } + + public void unhandledBack() throws RemoteException { + mTo.unhandledBack(); + } + + public void unregisterProcessObserver(IProcessObserver arg0) + throws RemoteException { + mTo.unregisterProcessObserver(arg0); + } + + public void unregisterReceiver(IIntentReceiver arg0) throws RemoteException { + mTo.unregisterReceiver(arg0); + } + + public void unregisterUserSwitchObserver(IUserSwitchObserver arg0) + throws RemoteException { + mTo.unregisterUserSwitchObserver(arg0); + } + + public void unstableProviderDied(IBinder arg0) throws RemoteException { + mTo.unstableProviderDied(arg0); + } + + public void updateConfiguration(Configuration arg0) throws RemoteException { + mTo.updateConfiguration(arg0); + } + + public void updatePersistentConfiguration(Configuration arg0) + throws RemoteException { + mTo.updatePersistentConfiguration(arg0); + } + + public void wakingUp() throws RemoteException { + mTo.wakingUp(); + } + + public boolean willActivityBeVisible(IBinder arg0) throws RemoteException { + return mTo.willActivityBeVisible(arg0); + } +} diff --git a/src/strictmode-lib/build.xml b/src/strictmode-lib/build.xml index 36c3859..3fff5e7 100644 --- a/src/strictmode-lib/build.xml +++ b/src/strictmode-lib/build.xml @@ -6,7 +6,7 @@ Changing bootclasspath to use non-stripped core and framework files - + @@ -14,4 +14,4 @@ ${toString:project.target.class.path} - \ No newline at end of file + diff --git a/src/strictmode-lib/project.properties b/src/strictmode-lib/project.properties index f03f91a..cb0280f 100644 --- a/src/strictmode-lib/project.properties +++ b/src/strictmode-lib/project.properties @@ -2,7 +2,7 @@ project.name=com.robomorphine.strictmode.lib project.type=lib android.library=true -target=android-17 +target=android-18 android.library.reference.1=android-prebuilt/r09 android.library.reference.2=android-prebuilt/r11 @@ -12,3 +12,4 @@ android.library.reference.5=android-prebuilt/r14 android.library.reference.6=android-prebuilt/r15 android.library.reference.7=android-prebuilt/r16 android.library.reference.8=android-prebuilt/r17 +android.library.reference.8=android-prebuilt/r18 diff --git a/src/strictmode-lib/src/com/robomorphine/strictmode/ActivityManagerProxifier.java b/src/strictmode-lib/src/com/robomorphine/strictmode/ActivityManagerProxifier.java index 06542eb..c712985 100644 --- a/src/strictmode-lib/src/com/robomorphine/strictmode/ActivityManagerProxifier.java +++ b/src/strictmode-lib/src/com/robomorphine/strictmode/ActivityManagerProxifier.java @@ -12,6 +12,7 @@ import android.app.IActivityManagerProxyR15; import android.app.IActivityManagerProxyR16; import android.app.IActivityManagerProxyR17; +import android.app.IActivityManagerProxyR18; import android.os.Build; import android.os.StrictMode.ViolationInfo; import android.util.Log; @@ -79,6 +80,7 @@ private static DataProxy createDataProxy() throws PlatformNotSupp case 15: case 16: case 17: + case 18: dataProxy = new ViolationInfoProxyR11(); break; default: @@ -109,6 +111,8 @@ private static IActivityManager createActivityManagerProxy(IActivityManager mana return new IActivityManagerProxyR16(manager, dataProxy); case 17: return new IActivityManagerProxyR17(manager, dataProxy); + case 18: + return new IActivityManagerProxyR18(manager, dataProxy); default: throw new PlatformNotSupportedException("IActivityManagerProxy"); }