Android P之监听Process Activity TaskStack状态变化

短命女 2023-08-17 16:01 158阅读 0赞

安卓系统提供了监听Process，Activity和Stack的状态变化的API，但是是Hide类型，并不能提供给非系统应用使用。

但是，在系统应用中，还是可以使用的。

import android.app.TaskStackListener;
    import android.app.ActivityManager;
    import android.app.ActivityManager.StackInfo;
    import android.app.IActivityManager;
    import android.app.IProcessObserver;
    import android.util.SparseArray;
    import java.util.Objects;
    
    public class SystemActivityMonitoringService{ 
    	private static Context mContext;
        private static IActivityManager mAm;
        private static ProcessObserver mProcessObserver;
        private static TaskListener mTaskListener;
    
    	public SystemActivityMonitoringService(Context context) { 
    	        mContext = context;
    	        
    	        mProcessObserver = new ProcessObserver();
    	        mTaskListener = new TaskListener();
    	        mAm = ActivityManager.getService();
    	        // Monitoring both listeners are necessary as there are cases where one listener cannot
    	        // monitor activity change.
    	        try { 
    	            mAm.registerProcessObserver(mProcessObserver);
    	            mAm.registerTaskStackListener(mTaskListener);
    	        } catch (Exception e) { 
    	            Log.e(TAG, "cannot register activity monitoring", e);
    	            throw new RuntimeException(e);
    	        } 
    	}
    
        /** * Container to hold info on top task in an Activity stack */
        public static class TopTaskInfoContainer { 
            public final ComponentName topActivity;
            public final int taskId;
            public final StackInfo stackInfo;
    
            private TopTaskInfoContainer(ComponentName topActivity, int taskId, StackInfo stackInfo) { 
                this.topActivity = topActivity;
                this.taskId = taskId;
                this.stackInfo = stackInfo;
            }
    
            public boolean isMatching(TopTaskInfoContainer taskInfo) { 
                return taskInfo != null
                        && Objects.equals(this.topActivity, taskInfo.topActivity)
                        && this.taskId == taskInfo.taskId
                        && this.stackInfo.userId == taskInfo.stackInfo.userId;
            }
    
            @Override
            public String toString() { 
                return String.format(
                        "TaskInfoContainer [topActivity=%s, taskId=%d, stackId=%d, userId=%d",
                        topActivity, taskId, stackInfo.stackId, stackInfo.userId);
            }
        }
    	
        /** K: stack id, V: top task */
        private final SparseArray<TopTaskInfoContainer> mTopTasks = new SparseArray<>();
    
        private void updateTasks() { 
            List<StackInfo> infos;
            try { 
                infos = mAm.getAllStackInfos();
            } catch (Exception e) { 
                Log.e(TAG, "cannot getTasks", e);
                return;
            }
            int focusedStackId = -1;
            try { 
                // TODO(b/66955160): Someone on the Auto-team should probably re-work the code in the
                // synchronized block below based on this new API.
                final StackInfo focusedStackInfo = mAm.getFocusedStackInfo();
                if (focusedStackInfo != null) { 
                    focusedStackId = focusedStackInfo.stackId;
                }
            } catch (Exception e) { 
                Log.e(TAG, "cannot getFocusedStackId", e);
                return;
            }
    
            synchronized (this) { 
                for (StackInfo info : infos) { 
                    int stackId = info.stackId;
                    if (info.taskNames.length == 0 || !info.visible) {  // empty stack or not shown
                        mTopTasks.remove(stackId);
                        continue;
                    }
                    TopTaskInfoContainer newTopTaskInfo = new TopTaskInfoContainer(
                            info.topActivity, info.taskIds[info.taskIds.length - 1], info);
    
                    TopTaskInfoContainer currentTopTaskInfo = mTopTasks.get(stackId);
    
                    // if a new task is added to stack or focused stack changes, should notify
                    if (currentTopTaskInfo == null ||
                            !currentTopTaskInfo.isMatching(newTopTaskInfo) ||
                            (focusedStackId == stackId)) { 
                        mTopTasks.put(stackId, newTopTaskInfo);
                        Log.i(TAG, "New top task: " + newTopTaskInfo);
                    }
                }
            }
        }
    
        private class ProcessObserver extends IProcessObserver.Stub { 
            @Override
            public void onForegroundActivitiesChanged(int pid, int uid, boolean foregroundActivities) { 
                    Log.i(TAG,
                            String.format("onForegroundActivitiesChanged uid %d pid %d fg %b",
                        uid, pid, foregroundActivities));
            }
    
            @Override
            public void onProcessDied(int pid, int uid) { 
                Log.i(TAG, "onTaskStackChanged");
            }
        }
    
        private class TaskListener extends TaskStackListener { 
            @Override
            public void onTaskStackChanged() { 
                    Log.i(TAG, "onTaskStackChanged");
    			updateTasks();
            }
        }
    }

AndroidManifest.xml中加入权限：

<uses-permission android:name="android.permission.SET_ACTIVITY_WATCHER"/>
    <uses-permission android:name="android.permission.MANAGE_ACTIVITY_STACKS"/>