This article mainly shares with you how to listen to click click events globally and do some general processing or intercepting. The usage scenario may be specific global anti-fast repeated clicks, or general point-based analysis and reporting, user behavior monitoring, etc. The following will monitor the global click operations in four different ideas and implementation methods, and explain them one by one from simple to complex.
Method 1: Adapt the listening interface, reserve the global processing interface and use it as the base class for all listeners
Abstracting the public base class listening object, an interception mechanism and general click processing can be reserved. The brief code is as follows:
public abstract class CustClickListener implements {
@Override
public void onClick(View view) {
if(!interceptViewClick(view)){
onViewClick(view);
}
}
protected boolean interceptViewClick(View view){
//TODO: Here you can do this general processing such as pointing, or interception, etc. return false;
}
protected abstract void onViewClick(View view);
}
One way to use anonymous objects as public listeners
CustClickListener mClickListener = new CustClickListener() {
@Override
protected void onViewClick(View view) {
(, (), Toast.LENGTH_SHORT).show();
}
};
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
(savedInstanceState);
setContentView(.activity_login);
findViewById().setOnClickListener(mClickListener);
}
This method is relatively simple and has no compatibility issues, but requires the use of base class-based listener objects from beginning to end, which is relatively restrictive to developers. This usage agreement was applied to new projects at the beginning. The workload of refactoring old code is relatively high, and there is nothing you can do if you connect to a third-party ink cartridge module.
Method 2: Reflection agent, timely change the beam and column, developer has no perception, and does general processing in the adapter packaging.
The following are the proxy interface and the built-in listening adapter. The global listening interface needs to implement IProxyClickListener and set it to the built-in adapter WrapClickListener.
public interface IProxyClickListener {
boolean onProxyClick(WrapClickListener wrap, View v);
class WrapClickListener implements {
IProxyClickListener mProxyListener;
mBaseListener;
public WrapClickListener( l, IProxyClickListener proxyListener) {
mBaseListener = l;
mProxyListener = proxyListener;
}
@Override
public void onClick(View v) {
boolean handled = mProxyListener == null ? false : (, v);
if (!handled && mBaseListener != null) {
(v);
}
}
}
}
We need to select an opportunity to act as a hook for all view with listeners. This opportunity can add a view change listening to the root view of the Activity (of course, you can also select the time to distribute the DOWN event in the Activity):
().addOnGlobalLayoutListener(new () {
@Override
public void onGlobalLayout() {
hookViews(rootView, 0)
}
});
Note: In order to facilitate anonymous registration, the above must be registered in reverse when the Activity exits.
Before performing proxying, you must reflect and obtain the Method and Field objects related to the View listener as follows:
public void init() {
if (sHookMethod == null) {
try {
Class viewClass = ("");
if (viewClass != null) {
sHookMethod = ("getListenerInfo");
if (sHookMethod != null) {
(true);
}
}
} catch (Exception e) {
reportError(e, "init");
}
}
if (sHookField == null) {
try {
Class listenerInfoClass = ("$ListenerInfo");
if (listenerInfoClass != null) {
sHookField = ("mOnClickListener");
if (sHookField != null) {
(true);
}
}
} catch (Exception e) {
reportError(e, "init");
}
}
}
Only by ensuring that sHookMethod and sHookField are successfully obtained can we proceed to the next step of recursively setting up the listening agent to replace the pillars. The following is the specific process of implementing recursive setting of proxy listening. where mInnerClickProxy is the proxy interface for global processing of click events passed outside.
private void hookViews(View view, int recycledContainerDeep) {
if (() == ) {
boolean forceHook = recycledContainerDeep == 1;
if (view instanceof ViewGroup) {
boolean existAncestorRecycle = recycledContainerDeep > 0;
ViewGroup p = (ViewGroup) view;
if (!(p instanceof AbsListView || p instanceof RecyclerView) || existAncestorRecycle) {
hookClickListener(view, recycledContainerDeep, forceHook);
if (existAncestorRecycle) {
recycledContainerDeep++;
}
} else {
recycledContainerDeep = 1;
}
int childCount = ();
for (int i = 0; i < childCount; i++) {
View child = (i);
hookViews(child, recycledContainerDeep);
}
} else {
hookClickListener(view, recycledContainerDeep, forceHook);
}
}
}
private void hookClickListener(View view, int recycledContainerDeep, boolean forceHook) {
boolean needHook = forceHook;
if (!needHook) {
needHook = ();
if (needHook && recycledContainerDeep == 0) {
needHook = (mPrivateTagKey) == null;
}
}
if (needHook) {
try {
Object getListenerInfo = (view);
baseClickListener = getListenerInfo == null ? null : () (getListenerInfo);//Get the set listener if ((baseClickListener != null && !(baseClickListener instanceof ))) {
(getListenerInfo, new (baseClickListener, mInnerClickProxy));
(mPrivateTagKey, recycledContainerDeep);
}
} catch (Exception e) {
reportError(e,"hook");
}
}
}
The above depth is preferred to recursively set up and listen from the root view of the Activity. Only the original view itself has clicked event listener. After successful setting, a tag flag will be set to the operational View to indicate that the proxy has been set to avoid repeated settings every time. This tag has a certain meaning, recording the number of levels of the view relative to possible recyclable containers. Because for direct child Views like AbsListView or RecyclerView, the proxy needs to be forced to be rebinded, because their reuse mechanism may be re-set to listen.
This method implementation is slightly more complicated, but the implementation effect is relatively good, and the hook proxy that listens to the developer without perception. The reflection efficiency can also be accepted at a relatively fast speed without any effect. Valid for any view with a listener set. However, the Item click of AbsListView is invalid because its click event is not implemented through onClick, unless it is not used to bind the click event by itself.
Method 3: Capture click events through AccessibilityDelegate.
When analyzing the source code of the View, the method is called when processing the callback of the click event, and the sendAccessibilityEvent is called internally. This method has a managed interface mAccessibilityDelegate that can handle all AccessibilityEvents externally. Just as the settings of this managed interface are also open setAccessibilityDelegate, such as the following key snippet of the View source code.
public boolean performClick() {
final boolean result;
final ListenerInfo li = mListenerInfo;
if (li != null && != null) {
playSoundEffect();
(this);
result = true;
} else {
result = false;
}
sendAccessibilityEvent(AccessibilityEvent.TYPE_VIEW_CLICKED);
return result;
}
public void sendAccessibilityEvent(int eventType) {
if (mAccessibilityDelegate != null) {
(this, eventType);
} else {
sendAccessibilityEventInternal(eventType);
}
}
public void setAccessibilityDelegate(@Nullable AccessibilityDelegate delegate) {
mAccessibilityDelegate = delegate;
}
Based on this principle, we can register our own AccessibilityDelegate for all Views at a certain time to listen to system behavior events. The brief implementation code is as follows.
public class ViewClickTracker extends {
boolean mInstalled = false;
WeakReference<View> mRootView = null;
mOnGlobalLayoutListener = null;
public ViewClickTracker(View rootView) {
if (rootView != null && () != null) {
mRootView = new WeakReference(rootView);
mOnGlobalLayoutListener = new () {
@Override
public void onGlobalLayout() {
View root = mRootView == null ? null : ();
boolean install = ;
if (root != null && () != null && ().isAlive()) {
try {
installAccessibilityDelegate(root);
if (!mInstalled) {
mInstalled = true;
}
} catch (Exception e) {
();
}
} else {
destroyInner(false);
}
}
};
().addOnGlobalLayoutListener(mOnGlobalLayoutListener);
}
}
private void installAccessibilityDelegate(View view) {
if (view != null) {
();
if (view instanceof ViewGroup) {
ViewGroup parent = (ViewGroup) view;
int count = ();
for (int i = 0; i < count; i++) {
View child = (i);
if (() != ) {
installAccessibilityDelegate(child);
}
}
}
}
}
@Override
public void sendAccessibilityEvent(View host, int eventType) {
(host, eventType);
if (AccessibilityEvent.TYPE_VIEW_CLICKED == eventType && host != null) {
//TODO handles common click events here, and host is the corresponding clicked View. }
}
}
The above implementation is quite clever. After monitoring the change of the global view tree on the window, it recursively installs AccessibilityDelegate to all Views. After testing, most manufacturers' models and versions are OK, but some models cannot successfully capture and monitor click events, so they are not recommended.
Method 4: By analyzing the dispatchTouchEvent event of the Activity and finding the target View accepted by the event.
This method looks a bit incredible at first, but after a series of touch screen events, one component will consume it. Check the key source code of ViewGroup as follows:
// First touch target in the linked list of touch targets.
private TouchTarget mFirstTouchTarget;
public boolean dispatchTouchEvent(MotionEvent ev) {
......
if (newTouchTarget == null && childrenCount != 0) {
for (int i = childrenCount - 1; i >= 0; i--) {
if (dispatchTransformedTouchEvent(ev, false, child, idBitsToAssign)) {
newTouchTarget = addTouchTarget(child, idBitsToAssign);
alreadyDispatchedToNewTouchTarget = true;
break;
}
}
}
......
// Dispatch to touch targets.
if (mFirstTouchTarget == null) {
// No touch targets so treat this as an ordinary view.
handled = dispatchTransformedTouchEvent(ev, canceled, null, TouchTarget.ALL_POINTER_IDS);
} else {
// Dispatch to touch targets, excluding the new touch target if we already
// dispatched to it. Cancel touch targets if necessary.
TouchTarget predecessor = null;
TouchTarget target = mFirstTouchTarget;
while (target != null) {
final TouchTarget next = ;
if (alreadyDispatchedToNewTouchTarget && target == newTouchTarget) {
handled = true;
} else {
final boolean cancelChild = resetCancelNextUpFlag() || intercepted;
......
if (cancelChild) {
if (predecessor == null) {
mFirstTouchTarget = next;
} else {
= next;
}
();
target = next;
continue;
}
}
predecessor = target;
target = next;
}
}
}
Here we find that the direct child Views that are willing to accept the touch event will be added to the chain object mFirstTouchTarget, and the next one is almost always null after the chain is adjusted. This gives us a breakthrough. You can get the direct child View of the currently accepted event from , and then search recursively until null is performed. We even found the recipient of the final touch event. The best time to find this should be in ACTION_UP or ACTION_CANCEL .
Through the above principles, we can obtain the target view of a series of Touch events that will be finally processed, and then we can judge whether it is a possible click action based on the pressing position, release position and offset deviation we recorded. In order to strengthen the judgment of whether it is a real click event, you can further analyze whether the target view has a click listener installed (the principle can be used to refer to Method 2 mentioned above. The following timings for obtaining and analyzing events are performed in the Activity dispatchTouchEvent method.
After recording down and up events, the following is the click judgment that implements the implementation to determine whether it is possible.
//whether it could be a click action
public boolean isClickPossible(float slop) {
if (mCancel || mDownId == -1 || mUpId == -1 || mDownTime == 0 || mUpTime == 0) {
return false;
} else {
return (mDownX - mUpX) < slop && (mDownY - mUpY) < slop;
}
}
Find the target View immediately after the up event. First, make sure to reflect the mFirstTouchTarge related preparations.
private boolean ensureTargetField() {
if (sTouchTargetField == null) {
try {
Class viewClass = ("");
if (viewClass != null) {
sTouchTargetField = ("mFirstTouchTarget");
(true);
}
} catch (Exception e) {
();
}
try {
if (sTouchTargetField != null) {
sTouchTargetChildField = ().getDeclaredField("child");
(true);
}
} catch (Exception e) {
();
}
}
return sTouchTargetField != null && sTouchTargetChildField != null;
}
Then recursively search the target View from the Activity DecorView.
// find the target view who is interest in the touch event. null if not find
private View findTargetView() {
View nextTarget, target = null;
if (ensureTargetField() && mRootView != null) {
nextTarget = findTargetView(mRootView);
do {
target = nextTarget;
nextTarget = null;
if (target instanceof ViewGroup) {
nextTarget = findTargetView((ViewGroup) target);
}
} while (nextTarget != null);
}
return target;
}
//reflect to find the TouchTarget child view,null if not found .
private View findTargetView(ViewGroup parent) {
try {
Object target = (parent);
if (target != null) {
Object view = (target);
if (view instanceof View) {
return (View) view;
}
}
} catch (Exception e) {
();
}
return null;
}
In the above methods, all view with click function can be listened correctly. However, it may be considered a click event that does not listen to click events. To filter out this part, you can analyze whether the target View has a click listener installed. I won’t post more code here. The principle and code have been discussed in Method 2.
The above four methods have their own advantages and disadvantages, and are relatively fast in efficiency. The comprehensive comparison is more accurate in Method 2. The three and four methods are used as references, which are of learning significance. In particular, the four methods have a wide range of application prospects. The target view of all gestures can be found.
This article tells a monitoring point for user behavior monitoring that I have recently studied. For more specific behavior monitoring, please refer to the projectInteractionHook Development is still underway.
The above is all the content of this article. I hope it will be helpful to everyone's study and I hope everyone will support me more.