zoukankan      html  css  js  c++  java
  • ActivityTaskView

    新版使用方法

    Github地址:https://github.com/rome753/ActivityTaskView

    1. 安装ActivityTaskView release app,启动并给予悬浮窗权限
      https://github.com/rome753/ActivityTaskView/releases
      或者从 Google Play下载安装。

    2. 在你开发的App中加入如下类https://github.com/rome753/ActivityTaskView/blob/master/app/src/main/java/cc/rome753/demo/ActivityTaskHelper.java

    3. 在你开发的App的Application的onCreate()中加入代码

        @Override
        public void onCreate() {
            super.onCreate();
    
            if(BuildConfig.DEBUG) {
                ActivityTaskHelper.init(this);
            }
        }
    
    1. 启动你的App,在ActivityTaskView的悬浮窗中能看到App中所有Activity和Fragment的生命周期。

    LaunchMode分析

    有了这个工具,分析Activity的LaunchMode就很直观了,一图胜千言。

    standard mode

    标准模式,启动直接加到栈顶,销毁后移除。


     
    s.gif

    singletop mode

    栈顶唯一,如果栈顶存在就不会重复启动,保证栈顶不会有两个相同的Activtiy


     
    s-to.gif

    singletask mode

    栈内唯一,如果栈内存在,再次启动时会自动把它上面的其他Activity全部清除(调用onDestroy)


     
    s-ta.gif

    singleinstance mode

    独占一栈,启动时会建立新栈切换过去,如果启动了普通Activity又会切换回原来的共享栈(新栈仍然存在,会在栈内唯一的Activity结束时关闭)


     
    s-in.gif

    技术实现

    Activity是安卓开发中最重要的元素,因为APP绝大部分使用都是操作它。某个应用的Activity都是放在一个或多个任务栈中,有两种方法可以查看任务栈和栈中的活动。

    1. ADB命令

    adb shell dumpsys activity activities

    该方法可以获得手机中所有活动的详细数据,然而要从中找到你想分析的活动有点麻烦,而且必须连着电脑。

    1. 使用ActivityManager
    ActivityManager am = (ActivityManager)getSystemService(Context.ACTIVITY_SERVICE);
    List<RunningTaskInfo> runningTaskInfoList =  am.getRunningTasks(10);
    for (RunningTaskInfo runningTaskInfo : runningTaskInfoList) {
        log("id: " + runningTaskInfo.id);
        log("description: " + runningTaskInfo.description);
        log("number of activities: " + runningTaskInfo.numActivities);
        log("topActivity: " + runningTaskInfo.topActivity);
        log("baseActivity: " + runningTaskInfo.baseActivity.toString());
    }
    

    该方法只能获取到任务栈的栈顶和栈底的活动,操作起来也麻烦。

    总之,目前还没有一种方法能直观地观察Activity任务栈和Activity中的Fragment,像下图这样:


     
    overview.gif

    原理

    Android4.0以后Application支持ActivityLifecycleCallbacksFragmentLifecycleCallbacks的生命周期回调。

    ActivityLifecycleCallbacks

    application.registerActivityLifecycleCallbacks(new Application.ActivityLifecycleCallbacks() {
                @Override
                public void onActivityCreated(Activity activity, Bundle savedInstanceState) {
                }
    
                @Override
                public void onActivityStarted(Activity activity) {
                }
    
                @Override
                public void onActivityResumed(Activity activity) {
                }
    
                @Override
                public void onActivityPaused(Activity activity) {
                }
    
                @Override
                public void onActivityStopped(Activity activity) {
                }
    
                @Override
                public void onActivitySaveInstanceState(Activity activity, Bundle outState) {
                }
    
                @Override
                public void onActivityDestroyed(Activity activity) {
                }
            });
    

    在Application中注册这个回调,就能监听到所有Activity的生命周期了,再也不用往一个个Activity的生命周期方法里面加log了,在这个回调里统一搞定。

    有了回调监听,就可以从APP启动开始,管理建立的每一个Activity,而Activity的getTaskId()方法可以获取到这个Activity属于哪个任务栈。

    Activity和任务栈都有了,后面只是想个方法展示的问题。

    FragmentLifecycleCallbacks

    private class FragmentLifecycleImpl extends FragmentManager.FragmentLifecycleCallbacks{
    
            @Override
            public void onFragmentPreAttached(FragmentManager fm, Fragment f, Context context) {
            }
    
            @Override
            public void onFragmentAttached(FragmentManager fm, Fragment f, Context context) {
            }
    
            @Override
            public void onFragmentCreated(FragmentManager fm, Fragment f, Bundle savedInstanceState) {
            }
    
            @Override
            public void onFragmentActivityCreated(FragmentManager fm, Fragment f, Bundle savedInstanceState) {
            }
    
            @Override
            public void onFragmentViewCreated(FragmentManager fm, Fragment f, View v, Bundle savedInstanceState) {
            }
    
            @Override
            public void onFragmentStarted(FragmentManager fm, Fragment f) {
                handleFragment(f);
            }
    
            @Override
            public void onFragmentResumed(FragmentManager fm, Fragment f) {
            }
    
            @Override
            public void onFragmentPaused(FragmentManager fm, Fragment f) {
            }
    
            @Override
            public void onFragmentStopped(FragmentManager fm, Fragment f) {
            }
    
            @Override
            public void onFragmentSaveInstanceState(FragmentManager fm, Fragment f, Bundle outState) {
            }
    
            @Override
            public void onFragmentViewDestroyed(FragmentManager fm, Fragment f) {
            }
    
            @Override
            public void onFragmentDestroyed(FragmentManager fm, Fragment f) {
            }
    
            @Override
            public void onFragmentDetached(FragmentManager fm, Fragment f) {
            }
        }
    

    同理,在Activity启动时可以给它注册FragmentLifecycleCallbacks来监听Activity中Fragment的变化。不同于Activity在Task中是线性的数据结构,Fragment在Activity中是树状的:一个Activity中可以有多个Fragment,每个Fragment又可以有自己的子Fragment。因此本地需要维护一个树FTree。

    FTree.java

    public class FTree {
    
        private String tab1 = "" + 'u2502';            // |
        private String tab2 = "" + 'u2514' + 'u2500'; // |_
        private String tab3 = "" + 'u251c' + 'u2500'; // |-
    
        private Node root;
    
        public FTree() {
            root = new Node("");
        }
    
        public void add(List<String> list, String lifecycle) {
            lifeMap.put(list.get(0), lifecycle);
            Node node = root;
            while (!list.isEmpty()) {
                String s = list.remove(list.size() - 1);
                if (!node.children.containsKey(s)) {
                    Node newNode = new Node(s);
                    node.children.put(s, newNode);
    
                }
                node = node.children.get(s);
            }
        }
    
        public void remove(List<String> list) {
            if (list.isEmpty()) return;
            lifeMap.remove(list.get(0));
            Node node = root;
            while (list.size() > 1) {
                String s = list.remove(list.size() - 1);
                if (node.children.containsKey(s)) {
                    node = node.children.get(s);
                } else return;
            }
            String last = list.get(list.size() - 1);
            node.children.remove(last);
        }
    
        public List<String> convertToList(){
            List<String> res = new ArrayList<>();
            convert(res, root, "", true);
            return res;
        }
    
        private void convert(List<String> res, Node node, String pre, boolean end){
            if(node != root){
                String s = pre + (end ? tab2 : tab3) + node.name;
                res.add(s);
            }
            int i = 0;
            for(Map.Entry<String, Node> entry : node.children.entrySet()){
                i++;
                boolean subEnd = i == node.children.size();
                String subPre = pre + (node == root ? "" : (end ? "        " : tab1 + "   "));
                convert(res, entry.getValue(), subPre, subEnd);
            }
        }
    
        private static class Node {
    
            String name;
            HashMap<String, Node> children;
    
            Node(String name) {
                this.name = name;
                this.children = new HashMap<>();
            }
        }
    
        public String getLifecycle(String name) {
            return lifeMap.get(name);
        }
    
        private HashMap<String, String> lifeMap = new HashMap<>();
        public void updateLifecycle(String key, String value) {
            lifeMap.put(key, value);
        }
    }
    

    其中子Fragment前面加上制表符号,展示到UI时便于Textview文本对齐。

    悬浮窗

    要在开发中直观、动态地展示任务栈,同时不能影响当前页面,使用悬浮窗是最好的方法。

    WindowManager windowManager = (WindowManager)app.getSystemService(Context.WINDOW_SERVICE);
    WindowManager.LayoutParams params = new WindowManager.LayoutParams();
    params.type = WindowManager.LayoutParams.TYPE_PHONE;
    params.format = PixelFormat.RGBA_8888;
    params.flags = WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE;
    params.width = WindowManager.LayoutParams.WRAP_CONTENT;
    params.height = WindowManager.LayoutParams.WRAP_CONTENT;
    params.gravity = Gravity.START | Gravity.TOP;
    params.x = 0;
    params.y = app.getResources().getDisplayMetrics().heightPixels;
    windowManager.addView(activityTaskView, params);
    
    

    添加悬浮窗用这个方法就可以了,加上悬浮窗权限。

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

    悬浮窗加上触摸移动,自动贴边,点击切换最小化和长按回到主界面。

    
        float mInnerX;
        float mInnerY;
        long downTime;
    
        @Override
            public boolean onTouchEvent(MotionEvent event) {
            switch (event.getAction()) {
                case MotionEvent.ACTION_DOWN:
                    downTime = System.currentTimeMillis();
                    mInnerX = event.getX();
                    mInnerY = event.getY();
                    postDelayed(this, 300);
                    break;
                case MotionEvent.ACTION_MOVE:
                    float x = event.getRawX();
                    float y = event.getRawY();
                    WindowManager.LayoutParams params = (WindowManager.LayoutParams) getLayoutParams();
                    params.x = (int) (x - mInnerX);
                    params.y = (int) (y - mInnerY - mStatusHeight);
                    updateLayout(params);
    
                    if(Math.abs(event.getX() - mInnerX) > 20
                            || Math.abs(event.getY() - mInnerY) > 20) {
                        removeCallbacks(this);
                    }
                    break;
                case MotionEvent.ACTION_UP:
                    removeCallbacks(this);
                    if(System.currentTimeMillis() - downTime < 100
                            && Math.abs(event.getX() - mInnerX) < 20
                            && Math.abs(event.getY() - mInnerY) < 20) {
                        doClick();
                    }
                    moveToBorder();
                    break;
    
            }
            return true;
        }
    
        private void doClick() {
            boolean visible = mTaskView.getVisibility() == VISIBLE;
            mTaskView.setVisibility(visible ? GONE : VISIBLE);
            mTinyView.setVisibility(!visible ? GONE : VISIBLE);
        }
    
        private void doLongClick() {
            Intent intent = new Intent(getContext().getApplicationContext(), MainActivity.class);
            intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
            getContext().getApplicationContext().startActivity(intent);
        }
    
        private void updateLayout(WindowManager.LayoutParams params){
            WindowManager windowManager = (WindowManager) getContext().getSystemService(Context.WINDOW_SERVICE);
            if(windowManager != null) {
                windowManager.updateViewLayout(this, params);
            }
        }
    
        private void moveToBorder() {
            WindowManager.LayoutParams p = (WindowManager.LayoutParams) getLayoutParams();
            Log.d("chao", "x " + p.x + " " + ((mScreenWidth - getWidth()) / 2));
    
            if(p.x <= (mScreenWidth - getWidth()) / 2) { // move left
                p.x = 0;
            } else { // move right
                p.x = mScreenWidth;
            }
            updateLayout(p);
        }
    
    

    ActivityTaskView的视图

     
    overview.png

    视图分为三层:
    最外层是ActivityTask活动栈,它是从Activity中取得的。不同的App自然是不同的栈(包名不同),一个App也可以有多个栈(包名相同,hashcode不同);
    中间层是活动栈中的Activity,在每个栈中是线性排列的;
    最内层是Acitivity中的Fragment,一个Activity中可以有多个Fragment,一个Fragment中也可以有多个子Fragment,因此用一个简单的树来显示。

    正常情况下,能准确地表示当前APP的活动栈和Fragment。除了APP被异常杀死,此时不会有生命周期回调,悬浮窗也不会刷新。

    延时消息队列

    很多时候Activity的生命周期转换太快,比如从onStart到onPause,或从一个Activity的onPause到另一个Activity的onResume,如果实时把这些变化反映到ActivityTaskView上,就很难看清中间的变化过程。因此在新版本中添加了一个延时消息队列,思路如下:
    生命周期产生时,先将对应的信息添加到一个Queue队列中,用一个Handler从队列中取消息,如果本次取消息距上一次取消息的间隔时间小于规定DELAY,那么就等待一段时间重新取。满足时间间隔才把生命周期反映到界面上。

        private static class QueueHandler extends Handler {
    
            private Queue<LifecycleInfo> queue;
            private long lastTime;
    
            QueueHandler() {
                super(Looper.getMainLooper());
                lastTime = 0;
                queue = new LinkedList<>();
            }
    
            void send(LifecycleInfo info) {
                queue.add(info);
                sendEmptyMessage(0);
            }
    
            @Override
            public void handleMessage(Message msg) {
                if (System.currentTimeMillis() - lastTime < interval) {
                    sendEmptyMessageDelayed(0, interval / 5);
                } else {
                    lastTime = System.currentTimeMillis();
                    LifecycleInfo info = queue.poll();
                    if (info != null && activityTaskView != null) {
                        if (info.fragments != null) {
                            if (info.lifecycle.contains("PreAttach")) {
                                activityTaskView.addF(info);
                            } else if (info.lifecycle.contains("Detach")) {
                                activityTaskView.removeF(info);
                            } else {
                                activityTaskView.updateF(info);
                            }
                        } else {
                            if (info.lifecycle.contains("Create")) {
                                activityTaskView.add(info);
                            } else if (info.lifecycle.contains("Destroy")) {
                                activityTaskView.remove(info);
                            } else {
                                activityTaskView.update(info);
                            }
                        }
                    }
                }
            }
    
        }
    

    广播解耦

    如果每个App观察生命周期都要加依赖库、申请悬浮窗权限会很麻烦,对于一个App来说,最主要的是暴露它的生命周期,悬浮窗展示完全可以统一交给另一个App处理,这样对被观察App耦合最小。

    基于这样的思路,将原来的ActivityTaskView依赖库打包成独立的App,它负责接收其他App的生命周期,展示到自己的悬浮窗上。这就涉及到两个App之间的跨进程通信了,这个需求中只需要单向通信,使用广播是最方便的。被观察App注册生命周期监听,并发送广播给ActivityTaskView,ActivityTaskView接收和解析广播,然后刷新悬浮窗UI。

    现在在手机中装了ActivityTaskView的前提下,你开发的App不用添加依赖库,也不用申请悬浮窗权限,实际上只要加一个发送广播的方法,就能观察它的生命周期了。

    View缓存池

    加入Fragment之后,由于每个Fragment就有13个生命周期,生命周期刷新变得非常频繁,每次刷新重建视图会重复创建很多View,非常影响ActivityTaskView的性能和耗电。考虑到视图中主要都是Textview,刷新时它们仅仅是颜色文本等属性有一些变化,没必要重新创建,因此可以使用一个缓存池把它们缓存起来。视图销毁时将它们保存到ViewPool中,视图重建时再从ViewPool中取出来使用。

    ViewPool.java

    public class ViewPool extends Observable {
    
        LinkedList<ATextView> pool = new LinkedList<>();
        HashMap<String,FragmentTaskView> map = new HashMap<>();
    
        private static ViewPool factory = new ViewPool();
        public static ViewPool get() {
            return factory;
        }
    
        public void recycle(ViewGroup viewGroup) {
            if(viewGroup != null) {
                for(int i = 0; i < viewGroup.getChildCount(); i++) {
                    View view = viewGroup.getChildAt(i);
                    if(view instanceof ATextView) {
                        AUtils.removeParent(view);
                        view.setTag(null);
                        pool.add((ATextView) view);
                    } else if(view instanceof FragmentTaskView) {
                        // don't recycle
                    } else if(view instanceof ViewGroup) {
                        recycle((ViewGroup) view);
                    }
                }
            }
        }
    
        public ATextView getOne(Context context) {
            ATextView view;notifyObservers();
            if(pool.isEmpty()) {
                view = new ATextView(context);
                addObserver(view);
            } else {
                view = pool.remove();
            }
            return view;
        }
    
        public void notifyLifecycleChange(LifecycleInfo info) {
            setChanged();
            notifyObservers(info);
        }
    
    
        public FragmentTaskView getF(String activity) {
            return map.get(activity);
        }
    
        public FragmentTaskView addF(Context context, String activity) {
            FragmentTaskView view = new FragmentTaskView(context);
            map.put(activity, view);
            return view;
        }
    
        public void removeF(String activity) {
            map.remove(activity);
        }
    
        public void clearF() {
            map.clear();
        }
    }
    
    
     
     



    作者:rome753
    链接:https://www.jianshu.com/p/c34483bb5c0f
    来源:简书
    著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。

  • 相关阅读:
    java—连连看-实现封装
    java—连连看GUI
    连连看--产生随机数
    勇者斗恶龙
    在ctex环境下利用Metapost作图
    [leetcode] Binary Tree Postorder Traversal
    [leetcode] Binary Tree Maximum Path Sum
    [leetcode] Binary Tree Level Order Traversal II
    [leetcode] Binary Tree Level Order Traversal
    [leetcode] Binary Tree Inorder Traversal
  • 原文地址:https://www.cnblogs.com/liumin-txgt/p/13268071.html
Copyright © 2011-2022 走看看