Android中的事件分发机制

时间:2021-6-12 作者:qvyue

Android中的事件分发机制

在Android开发中,事件的分发机制是一块比较重要的知识体系,了解并熟悉Android中的事件分发机制有助于分析各种点击滑动失效问题,同时也能更好的去扩展控件的事件功能和开发自定义控件。这篇博客主要就是分析Android中的事件分发。

首先,来一张图说明Android中事件是怎样从Activity怎样一步一步传递到View的

Android中的事件分发机制
Android事件分发机制图解.png

针对上图需要说明几点:

  1. 对于图中的dispatchTouchEvent()方法,走return true/false线路时,表示是开发者重写的该方法;走super时,表示是开发者没有重写,或者是重写时调用super.dispatchTouchEvent()方法,表示是调用父类的处理方式;
  2. 图中的事件分发流程只是针对DOWN(按下)事件,MOVE(移动)和UP(抬起)事件在后面做分析;

针对上图做一个简单的分析:

  1. 从图中可以看到,事件的分发过程可以简单的分为三层,Activity层、ViewGroup层和View层,在Activity和View层当中与事件相关的方法主要是dispatchTouchEvent()方法和onTouchEvent()方法,而在ViewGroup中还多了一个onInterceptTouchevent()方法,表示事件拦截的方法;
  2. Activity获取到事件之后,如果开发者重写了Activity中的dispatchTouchEvent()方法并返回了true或false,事件就会被消费,否则就会调用系统的处理方式,走super,也就是走到了ViewGroup的dispatchTouchEvent()方法,至于为什么会从Activity的dispatchTouchEvent()走到ViewGroup中的方法,后面会有分析;
  3. 事件到了ViewGroup组件上,同样,如果开发者重写了ViewGroup的dispatchTouchEvent()方法并返回了true,事件就会被消费;如果返回的false,那么事件就会直接返回给Activity的onTouchEvent()方法,让Activity的onTouchEvent()方法来处理;如果开发者没有重写,就会走super,那么就会调用ViewGroup的onInterceptTouchevent()方法(这个方法表示事件拦截的方法,返回true表示拦截事件,返回false表示不拦截事件,系统默认是返回false,不拦截事件);
  4. 到了ViewGroup的onInterceptTouchevent()方法,如果开发者重写了ViewGroup的onInterceptTouchevent()方法并返回true,那么就会调用ViewGroup的onTouchEvent()方法,让ViewGroup的onTouchEvent()方法来处理事件;
  5. 在ViewGroup的onTouchEvent()方法中如果返回true,表示消费事件,返回false,表示不处理事件,事件将会传递到Activity的onTouchEvent()方法处理;如果在ViewGroup的onInterceptTouchevent()方法中返回false,不拦截事件,那么事件就会传递到View中;
  6. 事件到了View中,View就会调用自己的dispatchTouchEvent()方法,同样,如果开发者重写了dispatchTouchEvent()方法并返回了true,事件就会被消费;如果返回的false,那么事件就会直接返回给ViewGroup的onTouchEvent()方法,让ViewGroup的onTouchEvent()方法来处理;
  7. 如果开发者在View中没有重写dispatchTouchEvent()方法,就会走super,系统会调用View的onTouchEvent()方法处理事件,如果在onTouchEvent()方法中返回了true,表示消费了事件,如果返回了false,那么事件就会返回到上一层,也就是ViewGroup的onTouchEvent()方法,让ViewGroup中的onTouchEvent()方法处理事件。

在上面的说明中,不仅说到了事件从Activity分发到View的过程,其实,事件在ViewGroup和View中的分发传递过程也已经说完了,下面这用两张更加直观的表示出了ViewGroup和View的事件分发过程

Android中的事件分发机制
ViewGroups事件分发过程图解.png

Android中的事件分发机制
View事件分发过程图解.png

对于这两张图就不做更多的说明了,在图中已经表示的非常清楚了。同时在对第一张图片进行说明的部分也已经涉及到了。

下面对于Android中DOWN事件的分发过程做一个简单的总结:

  1. 对于ViewGroup和View的disatchTouchEvent()和onTouchEvent()方法,return true表示处理事件,事件终结;return false表示不处理事件,让事件回传到上一层的onTouchEvent()方法中,也就是父控件中的onTouchEvent()方法中;
  2. 对于Activity的disatchTouchEvent()方法,如果没有重写,就会通过调用ViewGroup的disatchTouchEvent()方法开始分发事件,如果重写了,那么不管返回true还是false都会消费事件,不在将事件往下分发;
  3. 对于dispatchTouchEvent()方法,如果开发者不重写,就会走系统中的默认实现,在ViewGroup中会调用ViewGroup的onInterceptTouchEvent()方法,而在View中会直接把事件分发给View的onTouchEvent()方法处理;
  4. 对于ViewGroup而言,如果ViewGroup要自己处理事件,需要重写onInterceptTouchEvent()方法并且返回true,这样才会终止事件的传递,并调用ViewGroup的onTouchEvent()方法处理事件,否则调用系统onInterceptTouchEvent()方法,系统默认的返回值是false,不处理事件将事件传递下去;
  5. 对于View而言,在View中是没有onInterceptTouchEvent()方法的,因为他没有孩子控件,不需要拦截,系统在dispatchTouchEvent()方法中默认会把事件分发给View的onTouchEvent()方法处理;
  6. 在Android中,最开始获取到事件的是Activity,然后由Activity的dispatchTouchEvent()方法开始分发事件;
  7. 如果一个事件由Activity开始下发,但是所有的控件都不处理事件,最终就会回到Activity的onTouchEvent()方法,如果Activity也不消费事件,那么这个事件就丢失了。

上面说到了DOWN事件的分发、传递以及处理过程。

下面就的说一下MOVE和UP事件的传递过程:

在Android的事件中,最重要也是最复杂的一个事件就是DOWN事件,对于MOVE和UP事件,如果一个控件不能处理DOWN事件,那么在MOVW和UP的时候Android系统是不会将事件分发给这个控件的,也就是说,如果一个控件处理不了DOWN事件,那么他就接收不到了MOVE和UP事件了,更别说处理;相反,如果一个控件能处理DOWN事件,那么系统就会把MOVE和UP事件也交给他处理。下面这张表示了DOWN事件和MOVE、UP事件的一个传递过程:

Android中的事件分发机制
Android中事件传递过程.png

在上图中,事件由容器控件ViewGroup1传递下来,如果是DOWN事件,那么就会按照上面所说的过程一步一步传递,从容器控件ViewGroup1中传递到容器控件ViewGroup2在到View中,然后View也不消费事件,又回传到容器控件ViewGroup2中,容器控件ViewGroup2的onTouchEvent()方法消费了事件,DOWN事件终结;但是如果再次从容器控件ViewGroup1分发下拉了MONE或者UP事件时,容器控件ViewGroup2就会直接将事件交给自己的onTouchEvent()方法处理,而不会将事件在次向DWON事件一样传递给View了。

到这里,Android中的事件分发就基本上说完了。只是在这里还有2点要简单的进行说明一下:

  1. 在第一张图中有2个方法(dispatchTouchEvent()方法和onTouchEvent()方法)都可以消费事件,

    1. 如果一个DOWN事件是在某个控件的dispatchTouchEvent()方法中消费掉的,那么MOVE和UP事件传到这里就会终止,不会再往下传了;
    2. 如果一个DOWN事件是在某个控件的onTouchEvent()方法中消费的,那么MOVE和UP事件就依然会被传递到该控件的onTouchEvent()方法中处理。
  2. Android中的控件还有一个setOnTouchListener()方法

     view.setOnTouchListener(new View.OnTouchListener() {
         @Override
         public boolean onTouch(View v, MotionEvent event) {
             return false;
         }
     });
    

需要注意:

  1. onTouch()方法优越于onTouchEvent()方法先执行;
  2. 如果onTouch()返回true,那么就不会执行onTouchEvent()方法。

从源码的角度来了解一下Android下的事件分发机制

同时也回答上文中留下的一个问题:Activity在做事件分发时为什么会调用ViewGroup中的dispatchTouchEvent()方法?

首先看到Activity中的dispatchTouchEvent()方法源码:

public boolean dispatchTouchEvent(MotionEvent ev) {
    // 如果是ACTION_DOWN事件会走这个语句,onUserInteraction()这个方法在系统中是空实现
    if (ev.getAction() == MotionEvent.ACTION_DOWN) {
        onUserInteraction();
    }
    
    /**
     * 主要看一下这行代码
     * getWindow()表示获取Window的子类PhoneWindow对象
     * 也就是说调用PhoneWindow中的superDispatchTouchEvent(ev)方法,判断是否有控件处理事件
     */
    if (getWindow().superDispatchTouchEvent(ev)) {
        return true;
    }

    // 如果没有控件能处理事件,就走这一行代码,调用Activity的onTouchEvent()方法处理事件
    return onTouchEvent(ev);
}

接着进入到PhoneWindow中的,查看superDispatchTouchEvent(ev)这个方法:

@Override
public boolean superDispatchTouchEvent(MotionEvent event) {
    return mDecor.superDispatchTouchEvent(event);
}

在PhoneWindow类的superDispatchTouchEvent(ev)方法中,直接调用了mDecor对象的superDispatchTouchEvent(ev)方法,mDecore其实就是继承至FrameLayout的DecorView的对象。在《Activity的组成》这篇博客中贴出了DecorView类的定义源码。

接着查看类中的superDispatchTouchEvent(ev)这个方法:

public boolean superDispatchTouchEvent(MotionEvent event) {
    return super.dispatchTouchEvent(event);
}

只有一句代码,super.dispatchTouchEvent(event),调用父类的dispatchTouchEvent(event)方法,也就是FrameLayout的dispatchTouchEvent(event)方法,查看FrameLayout类会发现FrameLayout并没有重写dispatchTouchEvent(event)方法,那么就是使用的ViewGroup中的dispatchTouchEvent(event)方法。

到这里也就完全说明了Activity在做事件分发时调用的是ViewGroup中的dispatchTouchEvent()方法。

查看ViewGroup中的dispatchTouchEvent()方法:

@Override
public boolean dispatchTouchEvent(MotionEvent ev) {
    ...
    boolean handled = false;
    // 过滤触摸安全策略,如果是false(窗口或控件被遮住了时),直接跳出触摸事件
    // 如果应该分发事件(调用onTouch()或onTouchEvdent()方法),则返回True;如果应该删除事件,则返回false
    if (onFilterTouchEventForSecurity(ev)) {
        ...
        /**
         * 如果是DOWN事件就先将mFirstTouchTarget设置为null,
         * 然后在resetTouchState()方法中重置状态
         */
        if (actionMasked == MotionEvent.ACTION_DOWN) {
            cancelAndClearTouchTargets(ev);
            resetTouchState();
        }
         
        // 定义变量intercepted标记ViewGroup是否拦截Touch事件的传递.
        final boolean intercepted;
        // 事件为ACTION_DOWN或者mFirstTouchTarget不为null(有控件消费touch事件)
        if (actionMasked == MotionEvent.ACTION_DOWN || mFirstTouchTarget != null) {
            //判断disallowIntercept(禁止拦截)标志位
            final boolean disallowIntercept = (mGroupFlags & FLAG_DISALLOW_INTERCEPT) != 0;
            //当没有禁止拦截时
            if (!disallowIntercept) {
                // 调用onInterceptTouchEvent(ev)方法,并将返回值赋给intercepted
                intercepted = onInterceptTouchEvent(ev);
                ev.setAction(action);
            } else {
                 //当禁止拦截时,指定intercepted = false,表示不拦截事件
                intercepted = false;
            }
        } else {
            //当事件不是ACTION_DOWN并且mFirstTouchTarget为null(没有控件消费touch事件)时
            //设置 intercepted = true,表示ViewGroup执行Touch事件拦截的操作。
            intercepted = true;
        }
        ...
         
        // 事件分发
        final boolean split = (mGroupFlags & FLAG_SPLIT_MOTION_EVENTS) != 0;
        TouchTarget newTouchTarget = null;
        boolean alreadyDispatchedToNewTouchTarget = false;
        //不是ACTION_CANCEL事件并且intercepted为false(ViewGroup不拦截事件onInterceptTouchEvent()方法返回false)
        if (!canceled && !intercepted) {
            //处理ACTION_DOWN事件
            if (actionMasked == MotionEvent.ACTION_DOWN
                || (split && actionMasked == MotionEvent.ACTION_POINTER_DOWN)
                || actionMasked == MotionEvent.ACTION_HOVER_MOVE) {
                final int actionIndex = ev.getActionIndex(); 
                final int idBitsToAssign = split ? 1 = 0; i--) {
                        final int childIndex = customOrder ? getChildDrawingOrder(childrenCount, i) : i;
                        final View child = children[childIndex];
                        if (!canViewReceivePointerEvents(child) || !isTransformedTouchPointInView(x, y, child, null)) {
                            continue;
                        }

                        newTouchTarget = getTouchTarget(child);
                        if (newTouchTarget != null) {
                            // 找到消费Touch事件的孩子控件,跳出循环,并用newTouchTarget表示孩子控件
                            newTouchTarget.pointerIdBits |= idBitsToAssign;
                            break;
                        }
                        resetCancelNextUpFlag(child);
                        // 没有跳出循环,走到这一步,就会调用dispatchTransformedTouchEvent()方法,将事件传给孩子控件做递归处理,第三个参数不为null
                        if (dispatchTransformedTouchEvent(ev, false, child, idBitsToAssign)) {
                           ...
                        }
                    }
                }
                 
                /**
                 * 如果在循环中没有孩子控件消费事件并且之前的mFirstTouchTarget不为空
                 */
                if (newTouchTarget == null && mFirstTouchTarget != null) {
                    // 将mFirstTouchTarget的赋给newTouchTarget
                    newTouchTarget = mFirstTouchTarget;
                    while (newTouchTarget.next != null) {
                        newTouchTarget = newTouchTarget.next;
                    }
                    // newTouchTarget指向了最初的TouchTarget
                    newTouchTarget.pointerIdBits |= idBitsToAssign;
                }
            }
        }
         
        /**
         * 分发Touch事件至目标控件(target),以上过程主要针对ACTION_DOWN,
         * 如果不是(上一步中判断intercepted变量),比如ACTION_MOVE和ACTION_UP,就是从此处开始执行
         */
        if (mFirstTouchTarget == null) {
            /**
             * mFirstTouchTarget为null表示Touch事件未被消费或Touch事件被拦截了,
             * 则调用ViewGroup的dispatchTransformedTouchEvent()方法,递归处理,第三个参数为null
             */
            handled = dispatchTransformedTouchEvent(ev, canceled, null,TouchTarget.ALL_POINTER_IDS);
        } else {
            /**
             * mFirstTouchTarget不为null表示找到了可以消费Touch事件的子View
             * 并且MOVE或UP事件可以传递到该子View
             */
            TouchTarget predecessor = null;
            // 将找到的可以消费事件的mFirstTouchTarget赋给目标控件(target)
            TouchTarget target = mFirstTouchTarget;
            while (target != null) {
                final TouchTarget next = target.next;
                // 如果已经分发到新的控件并且消费事件的目标控件就是新的控件
                if (alreadyDispatchedToNewTouchTarget && target == newTouchTarget) {
                    handled = true;
                } else {
                    final boolean cancelChild = resetCancelNextUpFlag(target.child) || intercepted;
                    // 否则调用dispatchTransformedTouchEvent()方法进行递归处理,第三个参数不为null
                    if (dispatchTransformedTouchEvent(ev, cancelChild, target.child, target.pointerIdBits)) {
                        handled = true;
                    }
                   ...
                }
                predecessor = target;
                target = next;
            }
        }

        /**
         * 如果是ACTION_UP和ACTION_CANCEL事件,还原状态
         */
        if (canceled|| actionMasked == MotionEvent.ACTION_UP
                    || actionMasked == MotionEvent.ACTION_HOVER_MOVE) {
            resetTouchState();
        } else if (split && actionMasked == MotionEvent.ACTION_POINTER_UP) {
            ...
        }
    }
    ...
    return handled;
}

我们可以看到在上面的方法中,调用的onInterceptTouchEvent()判断是否需要拦截事件。

查看ViewGroup中的dispatchTransformedTouchEvent()方法:

private boolean dispatchTransformedTouchEvent(MotionEvent event, boolean cancel,
            View child, int desiredPointerIdBits) {
    final boolean handled;
    ...
        if (child == null) {
            // 如果孩子控件为空,就调用View的dispatchTouchEvent()方法,在View的dispatchTouchEvent()方法中会调用onTouchEvent()方法
            handled = super.dispatchTouchEvent(event);
        } else {
            // 如果孩子控件不为空,就调用孩子控件的dispatchTouchEvent()方法
            // 在此处孩子控件也还有可能是ViewGroup,所以就是继续调用ViewGroup的dispatchTouchEvent()方法
            handled = child.dispatchTouchEvent(event);
        }
        event.setAction(oldAction);
        return handled;
    }

   ...
    transformedEvent.recycle();
    return handled;
}

查看ViewGroup中onInterceptTouchEvent()方法:

public boolean onInterceptTouchEvent(MotionEvent ev) {
    return false;
}

在ViewGroup中,没有重写onTouchEvent()方法,所以调用的是View中的onTouchEvent()方法。

在View类中,首先看一下View中的dispatchTouchEvent()方法:

public boolean dispatchTouchEvent(MotionEvent event) {
    // If the event should be handled by accessibility focus first.
    if (event.isTargetAccessibilityFocus()) {
        // We don't have focus or no virtual descendant has it, do not handle the event.
        if (!isAccessibilityFocusedViewOrHost()) {
            return false;
        }
        // We have focus and got the event, then use normal event dispatch.
        event.setTargetAccessibilityFocus(false);
    }

    boolean result = false;

    if (mInputEventConsistencyVerifier != null) {
        mInputEventConsistencyVerifier.onTouchEvent(event, 0);
    }

    // 如果是DOWN事件,重置状态
    final int actionMasked = event.getActionMasked();
    if (actionMasked == MotionEvent.ACTION_DOWN) {
        stopNestedScroll();
    }

    // 过滤触摸安全策略,如果是false(窗口或控件被遮住了时),直接跳出触摸事件
    // 如果应该分发事件(调用onTouch()或onTouchEvdent()方法),则返回True;如果应该删除事件,则返回false
    if (onFilterTouchEventForSecurity(event)) {
        ListenerInfo li = mListenerInfo;
        if (li != null && li.mOnTouchListener != null
                && (mViewFlags & ENABLED_MASK) == ENABLED
                && li.mOnTouchListener.onTouch(this, event)) {
            // 当前控件是可用(enabled)的并且View调用了setOnTouchListener()方法且返回了true,那么就设置result为true
            result = true;
        }
        
        // result为false,表示没有调用setOnTouchListener()方法或该方法返回false,那么就调用
        // View的onTouchEvent()方法
        if (!result && onTouchEvent(event)) {
            result = true;
        }
    }

    if (!result && mInputEventConsistencyVerifier != null) {
        mInputEventConsistencyVerifier.onUnhandledEvent(event, 0);
    }

    // 如果是UP事件或CANCEL事件或者是DOWN事件但是该控件不能消费事件时,重置状态
    if (actionMasked == MotionEvent.ACTION_UP ||
            actionMasked == MotionEvent.ACTION_CANCEL ||
            (actionMasked == MotionEvent.ACTION_DOWN && !result)) {
        stopNestedScroll();
    }
    return result;
}

最后查看View的onTouchEvent()方法:

public boolean onTouchEvent(MotionEvent event) {
    final float x = event.getX();
    final float y = event.getY();
    final int viewFlags = mViewFlags;
    final int action = event.getAction();

    // 判断是否有单击或长按事件
    final boolean clickable = ((viewFlags & CLICKABLE) == CLICKABLE
            || (viewFlags & LONG_CLICKABLE) == LONG_CLICKABLE)
            || (viewFlags & CONTEXT_CLICKABLE) == CONTEXT_CLICKABLE;

    if ((viewFlags & ENABLED_MASK) == DISABLED) {
        if (action == MotionEvent.ACTION_UP && (mPrivateFlags & PFLAG_PRESSED) != 0) {
            setPressed(false);
        }
        mPrivateFlags3 &= ~PFLAG3_FINGER_DOWN;
        // 控件disabled 了,他还能消耗触摸事件,只是不相应她了
        return clickable;
    }
    // 如果有代理,调用代理的方法
    if (mTouchDelegate != null) {
        if (mTouchDelegate.onTouchEvent(event)) {
            return true;
        }
    }
    // 对点击事件的具体处理,只要有点击事件,那么onTouchEvent()方法就返回了 true
    if (clickable || (viewFlags & TOOLTIP) == TOOLTIP) {
        switch (action) {
            case MotionEvent.ACTION_UP:
                // ...

                    // mHasPerformedLongPress 表示长按事件的返回值,如果长按事件的的回调方法返回了true,那么在同一事件序列中,点击事件就不会调用了(否则会同时相应长按事件和点击事件)
                    if (!mHasPerformedLongPress && !mIgnoreNextUpEvent) {
                        // This is a tap, so remove the longpress check
                        removeLongPressCallback();

                        // Only perform take click actions if we were in the pressed state
                        if (!focusTaken) {
                            // Use a Runnable and post this rather than calling
                            // performClick directly. This lets other visual state
                            // of the view update before click actions start.
                            if (mPerformClick == null) {
                                mPerformClick = new PerformClick(); 
                            }
                            if (!post(mPerformClick)) {
                                performClickInternal(); // 会调用 performClick()方法处理单击事件
                            }
                        }
                    }

                    if (mUnsetPressedState == null) {
                        mUnsetPressedState = new UnsetPressedState();
                    }

                    if (prepressed) {
                        postDelayed(mUnsetPressedState,
                                ViewConfiguration.getPressedStateDuration());
                    } else if (!post(mUnsetPressedState)) {
                        // If the post failed, unpress right now
                        mUnsetPressedState.run();
                    }

                    removeTapCallback();
                }
                mIgnoreNextUpEvent = false;
                break;

            case MotionEvent.ACTION_DOWN:
                if (event.getSource() == InputDevice.SOURCE_TOUCHSCREEN) {
                    mPrivateFlags3 |= PFLAG3_FINGER_DOWN;
                }
                mHasPerformedLongPress = false;

                if (!clickable) {
                    checkForLongClick(0, x, y);
                    break;
                }

                if (performButtonActionOnTouchDown(event)) {
                    break;
                }

                // Walk up the hierarchy to determine if we're inside a scrolling container.
                boolean isInScrollingContainer = isInScrollingContainer();

                // 根据是否在滚动容器中,使用不同方式调用长按事件的回调
                if (isInScrollingContainer) {
                    mPrivateFlags |= PFLAG_PREPRESSED;
                    if (mPendingCheckForTap == null) {
                        mPendingCheckForTap = new CheckForTap(); // 最终调用长按事件回调
                    }
                    mPendingCheckForTap.x = event.getX();
                    mPendingCheckForTap.y = event.getY();
                    postDelayed(mPendingCheckForTap, ViewConfiguration.getTapTimeout());
                } else {
                    // Not inside a scrolling container, so show the feedback right away
                    setPressed(true, x, y);
                    checkForLongClick(0, x, y); // 最终调用长按事件回调
                }
                break;

            case MotionEvent.ACTION_CANCEL:
                // ...
                break;
        }

        // 只要有点击事件,那么onTouchEvent()方法就返回了 true
        return true;
    }

    return false;
}

从上面的代码来看,只要View的 CLICLABLE和LONG_CLICKABLE有一个为true,那么onTouchEvent()方法就会返回true,而且不管该View是否为DISABLE状态,其他情况返回false。true表示该控件可以消费事件,false表示该控件不能消费事件。现在,在回过头来看一下第一张图,是不是更加的清晰了呢。

最后,对于View 的 CLICKABLE 和 LONG_CLICKABLE默认值,LONG_CLICKABLE默认值为false,但是对于CLICKABLE就要根据具体的View来看了,确切的说是可点击的View的CLICKABLE值为true,如Button,不可点击的View的CLICKABLE值为false,比如TextView,但是当我们调用了View的 setOnClickListener(@Nullable OnClickListener l) 方法或者 setOnLongClickListener(@Nullable OnLongClickListener l) 方法就会将对应的值改为true。

public void setOnClickListener(@Nullable OnClickListener l) {
    if (!isClickable()) {
        setClickable(true);
    }
    getListenerInfo().mOnClickListener = l;
}

public void setOnLongClickListener(@Nullable OnLongClickListener l) {
    if (!isLongClickable()) {
        setLongClickable(true);
    }
    getListenerInfo().mOnLongClickListener = l;
}
声明:本文内容由互联网用户自发贡献自行上传,本网站不拥有所有权,未作人工编辑处理,也不承担相关法律责任。如果您发现有涉嫌版权的内容,欢迎发送邮件至:qvyue@qq.com 进行举报,并提供相关证据,工作人员会在5个工作日内联系你,一经查实,本站将立刻删除涉嫌侵权内容。