Android 判断view 是否在屏幕中展示出来(打点真实展现)

        这篇文章主要介绍如何判断 view在屏幕中已经展现,主要可用于打点,视频播放等

        前段时间,PM提出一个打点需求.要求当某个模块/view 在用户可见的时候 打点,否则不打.   之前的打点都是在服务端数据返回,view被加载的时候就已经打上了,但是很多时候,这些模块view只是被实例化了,并没有真的被用户看到.尤其是在 listview 或 recyclerview 的header里面 . 

        其实觉得这个需求很扯淡.但是确实很重要,毕竟精准的数据关系到 产品的走向.

        刚开始想用view的一些API方法来实现.如:onWindowFocusChanged  onWindowVisibilityChanged 等等,但遗憾的是,这些方法都达不到要求. 比如在listview/recyclerview的header里面,在 header被加载出来时,header里面的全部view都已经被实例化.

      刚开始比较急,第一个想到的是算高度,根据某个view的高度,父布局滑动的高度,来计算是否在屏幕内, 但是这样会产生大量"恶心"代码,而且一旦这个"真实展现"要给大量view打的话,  非常非常多的计算代码都会出来.

     后来看到一些视频软件,比如 QQ看点,迅雷App .一个视频列表,滑动到一个视频的时候,就自动播放,上一个视频就暂停.灵感就来了,它一定是监测到了这个视频view 被滑到了屏幕中间, 或者比上一个视频view 显示的区域大.

     那么就找到了 getLocalVisibleRect(Rect r) 没错,就是这个问题的主角了. 进去看下 它调用的是

public boolean getGlobalVisibleRect(Rect r, Point globalOffset) {
    int width = mRight - mLeft;
    int height = mBottom - mTop;
    if (width > 0 && height > 0) {
        r.set(0, 0, width, height);
        if (globalOffset != null) {
            globalOffset.set(-mScrollX, -mScrollY);
        }
        return mParent == null || mParent.getChildVisibleRect(this, r, globalOffset);
    }
    return false;
}

可以看到,这个方法如果返回true.则证明view可见,并且rect对象就是这个view的可见部分.

直接贴出判断方法.

private boolean isVisible(View v) {
    return v.getLocalVisibleRect(new Rect());
}

这样来看是不是就简单多了呢.至此,这个问题的主要解决方法就完成了.

但是 我们对每一个view都这么判断着实麻烦.下面也贴出封装的真实展现的监听类吧.

public class BaseRealVisibleUtil implements RealVisibleInterface {

    private HashMap<WeakReference<View>, OnRealVisibleListener> mTotalViewHashMap = new HashMap<>();
    private HashMap<WeakReference<View>, OnRealVisibleListener> mHaveVisibleViewHashMap = new HashMap<>();

    private HashMap<WeakReference<View>, ArrayList<Integer>> mTotalParentViewHashMap = new HashMap<>();

    @Override
    public void registerView(View v, OnRealVisibleListener listener) {
        if (listener != null) {
            mTotalViewHashMap.put(new WeakReference<View>(v), listener);
        }
    }

    /**
     * 尽量保证 注册的view 在每次页面刷新的时候 不会被重新添加, 否则map会越来越大.
     * @param view
     * @param listener
     */
    @Override
    public void registerParentView(View view, OnRealVisibleListener listener) {
        if (listener != null) {
            view.setTag(listener);
            mTotalParentViewHashMap.put(new WeakReference<View>(view), new ArrayList<Integer>());
        }
    }

    @Override
    public void calculateRealVisible() {
        Iterator iterator = mTotalViewHashMap.entrySet().iterator();
        // 下面这个写法  在遍历的时候若要对map 删除 要使用 Iterator.remove() 否则会出现ConcurrentModificationException  ;
        while (iterator.hasNext()) {
            Map.Entry<WeakReference<View>, OnRealVisibleListener> entry = (Map.Entry<WeakReference<View>, OnRealVisibleListener>) iterator.next();
            View view = entry.getKey().get();
            if (view != null) {
                if (isVisible(view)) {
                    if (view.getTag() != null && view.getTag() instanceof Integer) {
                        entry.getValue().onRealVisible((Integer) view.getTag());
                    } else {
                        entry.getValue().onRealVisible(-1); // 正常view 不需要这个参数
                    }
                    mHaveVisibleViewHashMap.put(entry.getKey(), entry.getValue());
                    iterator.remove();
                }
            } else {
                iterator.remove();
            }
        }

        for (Map.Entry<WeakReference<View>, ArrayList<Integer>> entry : mTotalParentViewHashMap.entrySet()) {
            View view = entry.getKey().get();
            if (view == null) continue;

            if (view instanceof ListView) {
                calculateListView((ListView) view, entry);
            } else if (view instanceof RecyclerView) {
                calculateRecyclerView((RecyclerView) view, entry);
            } else if (view instanceof LinearLayout) {
                calculateLinearLayout((LinearLayout) view, entry);
            }
        }
    }

    private void calculateListView(ListView listView, Map.Entry<WeakReference<View>, ArrayList<Integer>> entry) {
        OnRealVisibleListener listener = (OnRealVisibleListener) listView.getTag();
        int firstVisible = listView.getFirstVisiblePosition();
        for (int i = 0; i < listView.getChildCount(); i++) {
            if (isVisible(listView) && isVisible(listView.getChildAt(i))) {
                if (!entry.getValue().contains(i + firstVisible)) {
                    if (listView.getHeaderViewsCount() > 0) { // 证明有headerview 那么第0个是headerview, 减去
                        if (i > 0) {
                            listener.onRealVisible(i + firstVisible - 1);
                        }
                    } else { // footview 的时候可能有数组越界  所以外面调用的时候一定要加判断
                        listener.onRealVisible(i + firstVisible);
                    }
                    entry.getValue().add(i + firstVisible);
                }
            }
        }
    }

    private void calculateRecyclerView(RecyclerView recyclerView, Map.Entry<WeakReference<View>, ArrayList<Integer>> entry) {
        OnRealVisibleListener listener = (OnRealVisibleListener) recyclerView.getTag();
        LinearLayoutManager layoutManager = null;
        if (recyclerView.getLayoutManager() instanceof LinearLayoutManager) {
            layoutManager = (LinearLayoutManager) recyclerView.getLayoutManager();
        }
        if (layoutManager == null) return;
        int firstItemPosition = layoutManager.findFirstVisibleItemPosition();
        for (int i = 0; i < layoutManager.getChildCount(); i++) {
            if (isVisible(recyclerView) && isVisible(layoutManager.getChildAt(i))) {
                if (!entry.getValue().contains(i + firstItemPosition)) {
                    listener.onRealVisible(i + firstItemPosition);
                    entry.getValue().add(i + firstItemPosition);
                }
            }
        }
    }

    private void calculateLinearLayout(LinearLayout layout, Map.Entry<WeakReference<View>, ArrayList<Integer>> entry) {
        OnRealVisibleListener listener = (OnRealVisibleListener) layout.getTag();
        for (int i = 0; i < layout.getChildCount(); i++) {
            if (isVisible(layout) && isVisible(layout.getChildAt(i))) {
                if (!entry.getValue().contains(i)) {
                    listener.onRealVisible(i);
                    entry.getValue().add(i);
                }
            }
        }
    }

    @Override
    public void clearRealVisibleTag() {
        mTotalViewHashMap.putAll(mHaveVisibleViewHashMap);
        for (Map.Entry<WeakReference<View>, ArrayList<Integer>> entry : mTotalParentViewHashMap.entrySet()) {
            entry.getValue().clear();
        }
    }

    /**
     * 在屏幕中是否展现
     * @param v
     * @return
     */
    private boolean isVisible(View v) {
        return v.getLocalVisibleRect(new Rect());
    }

    public void release() {
        mTotalViewHashMap.clear();
        mHaveVisibleViewHashMap.clear();
        mTotalParentViewHashMap.clear();
    }
}


接口类:

public interface RealVisibleInterface {
    void registerView(View v, OnRealVisibleListener listener);

    /**
     * 注册组合view  比如ListView LinearLayout RecyclerView 等
     * 需要计算其子item的展现
     * 注意LinearLayout 只能计算其子一级 不能子2级 3级
     * @param view
     * @param listener
     */
    void registerParentView(View  view, OnRealVisibleListener listener);

    void calculateRealVisible();

    /**
     * 清除打点
     */
    void clearRealVisibleTag();

    interface OnRealVisibleListener {
        void onRealVisible(int position);
    }
}

使用就比较简单了:

XxxRealVisibleUtils 继承上面的类,并实现一个单例方法即可.

XxxRealVisibleUtils.getSingleInstance().registerView(mView, new RealVisibleInterface.OnRealVisibleListener() {
            @Override
            public void onRealVisible(int position) {
             // position 对于有子view的有用,如果注册的是单个view 这个position忽略
            }
        });

上面封装的这个类,可以计算listview  recyclerview  linearlayout的某一项是否展示, 不过linearlayout只能计算其1级子view,2级子view是计算不出来的,暂时没往深了写.  

      在计算列表view的时候 ,比如calculateRecyclerView(RecyclerView recyclerView, Map.Entry<WeakReference<View>, ArrayList<Integer>> entry) ,传入ArrayList<Integer>> entry ,这个list 主要是记录已经打点过的item,避免重复打点.  比如,PM可能要求,当用户停止滑动的时候,开始打点.每次PV 只打一次;当onResume后,在重新打.  所以就需要这个list来记录.  当需要重新计算的时候,可以看到这个list 会被清空.  当然如果不需要这个功能的话,更简单些,可以对上面的类稍加修改即可.

     当时封装这个类的时候,也废了点功夫,所以贴了出来,给有需要的小伙伴吧