这篇文章主要介绍如何判断 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() ,传入ArrayList<Integer>> entry ,这个list 主要是记录已经打点过的item,避免重复打点. 比如,PM可能要求,当用户停止滑动的时候,开始打点.每次PV 只打一次;当onResume后,在重新打. 所以就需要这个list来记录. 当需要重新计算的时候,可以看到这个list 会被清空. 当然如果不需要这个功能的话,更简单些,可以对上面的类稍加修改即可.
当时封装这个类的时候,也废了点功夫,所以贴了出来,给有需要的小伙伴吧
网友评论