Java tutorial
/* * Copyright (C) 2014 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package com.android.tools.lint.checks; import static com.android.SdkConstants.ANDROID_VIEW_VIEW; import com.android.annotations.NonNull; import com.android.annotations.Nullable; import com.android.tools.lint.detector.api.Category; import com.android.tools.lint.detector.api.ClassContext; import com.android.tools.lint.detector.api.Detector; import com.android.tools.lint.detector.api.Implementation; import com.android.tools.lint.detector.api.Issue; import com.android.tools.lint.detector.api.Scope; import com.android.tools.lint.detector.api.Severity; import com.android.tools.lint.detector.api.Speed; import org.objectweb.asm.Opcodes; import org.objectweb.asm.tree.AbstractInsnNode; import org.objectweb.asm.tree.ClassNode; import org.objectweb.asm.tree.InsnList; import org.objectweb.asm.tree.MethodInsnNode; import org.objectweb.asm.tree.MethodNode; import java.util.List; import java.util.ListIterator; /** * Checks that views that override View#onTouchEvent also implement View#performClick * and call performClick when click detection occurs. */ public class ClickableViewAccessibilityDetector extends Detector implements Detector.ClassScanner { public static final Issue ISSUE = Issue.create("ClickableViewAccessibility", //$NON-NLS-1$ "Accessibility in Custom Views", "If a `View` that overrides `onTouchEvent` or uses an `OnTouchListener` does not also " + "implement `performClick` and call it when clicks are detected, the `View` " + "may not handle accessibility actions properly. Logic handling the click " + "actions should ideally be placed in `View#performClick` as some " + "accessibility services invoke `performClick` when a click action " + "should occur.", Category.A11Y, 6, Severity.WARNING, new Implementation(ClickableViewAccessibilityDetector.class, Scope.CLASS_FILE_SCOPE)); private static final String ON_TOUCH_EVENT = "onTouchEvent"; //$NON-NLS-1$ private static final String ON_TOUCH_EVENT_SIG = "(Landroid/view/MotionEvent;)Z"; //$NON-NLS-1$ private static final String PERFORM_CLICK = "performClick"; //$NON-NLS-1$ private static final String PERFORM_CLICK_SIG = "()Z"; //$NON-NLS-1$ private static final String SET_ON_TOUCH_LISTENER = "setOnTouchListener"; //$NON-NLS-1$ private static final String SET_ON_TOUCH_LISTENER_SIG = "(Landroid/view/View$OnTouchListener;)V"; //$NON-NLS-1$ private static final String ON_TOUCH = "onTouch"; //$NON-NLS-1$ private static final String ON_TOUCH_SIG = "(Landroid/view/View;Landroid/view/MotionEvent;)Z"; //$NON-NLS-1$ private static final String ON_TOUCH_LISTENER = "android/view/View$OnTouchListener"; //$NON-NLS-1$ /** Constructs a new {@link ClickableViewAccessibilityDetector} */ public ClickableViewAccessibilityDetector() { } @NonNull @Override public Speed getSpeed() { return Speed.FAST; } // ---- Implements ClassScanner ---- @Override public void checkClass(@NonNull ClassContext context, @NonNull ClassNode classNode) { scanForAndCheckSetOnTouchListenerCalls(context, classNode); // Ignore abstract classes. if ((classNode.access & Opcodes.ACC_ABSTRACT) != 0) { return; } if (context.getDriver().isSubclassOf(classNode, ANDROID_VIEW_VIEW)) { checkView(context, classNode); } if (implementsOnTouchListener(classNode)) { checkOnTouchListener(context, classNode); } } @SuppressWarnings("unchecked") // ASM API public static void scanForAndCheckSetOnTouchListenerCalls(ClassContext context, ClassNode classNode) { List<MethodNode> methods = classNode.methods; for (MethodNode methodNode : methods) { ListIterator<AbstractInsnNode> iterator = methodNode.instructions.iterator(); while (iterator.hasNext()) { AbstractInsnNode abstractInsnNode = iterator.next(); if (abstractInsnNode.getType() == AbstractInsnNode.METHOD_INSN) { MethodInsnNode methodInsnNode = (MethodInsnNode) abstractInsnNode; if (methodInsnNode.name.equals(SET_ON_TOUCH_LISTENER) && methodInsnNode.desc.equals(SET_ON_TOUCH_LISTENER_SIG)) { checkSetOnTouchListenerCall(context, methodNode, methodInsnNode); } } } } } @SuppressWarnings("unchecked") // ASM API public static void checkSetOnTouchListenerCall(@NonNull ClassContext context, @NonNull MethodNode method, @NonNull MethodInsnNode call) { String owner = call.owner; // Ignore the call if it was called on a non-view. ClassNode ownerClass = context.getDriver().findClass(context, owner, 0); if (ownerClass == null || !context.getDriver().isSubclassOf(ownerClass, ANDROID_VIEW_VIEW)) { return; } MethodNode performClick = findMethod(ownerClass.methods, PERFORM_CLICK, PERFORM_CLICK_SIG); //noinspection VariableNotUsedInsideIf if (performClick == null) { String message = String.format("Custom view `%1$s` has `setOnTouchListener` called on it but does not " + "override `performClick`", ownerClass.name); context.report(ISSUE, method, call, context.getLocation(call), message); } } @SuppressWarnings("unchecked") // ASM API private static void checkOnTouchListener(ClassContext context, ClassNode classNode) { MethodNode onTouchNode = findMethod(classNode.methods, ON_TOUCH, ON_TOUCH_SIG); if (onTouchNode != null) { AbstractInsnNode performClickInsnNode = findMethodCallInstruction(onTouchNode.instructions, ANDROID_VIEW_VIEW, PERFORM_CLICK, PERFORM_CLICK_SIG); if (performClickInsnNode == null) { String message = String.format( "`%1$s#onTouch` should call `View#performClick` when a click is detected", classNode.name); context.report(ISSUE, onTouchNode, null, context.getLocation(onTouchNode, classNode), message); } } } @SuppressWarnings("unchecked") // ASM API private static void checkView(ClassContext context, ClassNode classNode) { MethodNode onTouchEvent = findMethod(classNode.methods, ON_TOUCH_EVENT, ON_TOUCH_EVENT_SIG); MethodNode performClick = findMethod(classNode.methods, PERFORM_CLICK, PERFORM_CLICK_SIG); // Check if we override onTouchEvent. if (onTouchEvent != null) { // Ensure that we also override performClick. //noinspection VariableNotUsedInsideIf if (performClick == null) { String message = String.format("Custom view `%1$s` overrides `onTouchEvent` but not `performClick`", classNode.name); context.report(ISSUE, onTouchEvent, null, context.getLocation(onTouchEvent, classNode), message); } else { // If we override performClick, ensure that it is called inside onTouchEvent. AbstractInsnNode performClickInOnTouchEventInsnNode = findMethodCallInstruction( onTouchEvent.instructions, classNode.name, PERFORM_CLICK, PERFORM_CLICK_SIG); if (performClickInOnTouchEventInsnNode == null) { String message = String.format( "`%1$s#onTouchEvent` should call `%1$s#performClick` when a click is detected", classNode.name); context.report(ISSUE, onTouchEvent, null, context.getLocation(onTouchEvent, classNode), message); } } } // Ensure that, if performClick is implemented, performClick calls super.performClick. if (performClick != null) { AbstractInsnNode superPerformClickInPerformClickInsnNode = findMethodCallInstruction( performClick.instructions, classNode.superName, PERFORM_CLICK, PERFORM_CLICK_SIG); if (superPerformClickInPerformClickInsnNode == null) { String message = String.format("`%1$s#performClick` should call `super#performClick`", classNode.name); context.report(ISSUE, performClick, null, context.getLocation(performClick, classNode), message); } } } @Nullable private static MethodNode findMethod(@NonNull List<MethodNode> methods, @NonNull String name, @NonNull String desc) { for (MethodNode method : methods) { if (name.equals(method.name) && desc.equals(method.desc)) { return method; } } return null; } @SuppressWarnings("unchecked") // ASM API @Nullable private static AbstractInsnNode findMethodCallInstruction(@NonNull InsnList instructions, @NonNull String owner, @NonNull String name, @NonNull String desc) { ListIterator<AbstractInsnNode> iterator = instructions.iterator(); while (iterator.hasNext()) { AbstractInsnNode insnNode = iterator.next(); if (insnNode.getType() == AbstractInsnNode.METHOD_INSN) { MethodInsnNode methodInsnNode = (MethodInsnNode) insnNode; if ((methodInsnNode.owner.equals(owner)) && (methodInsnNode.name.equals(name)) && (methodInsnNode.desc.equals(desc))) { return methodInsnNode; } } } return null; } private static boolean implementsOnTouchListener(ClassNode classNode) { return (classNode.interfaces != null) && (classNode.interfaces.contains(ON_TOUCH_LISTENER)); } }