用于 Android 触摸事件的特定领域语言：第 2 部分：构造和内部工作原理

目录

• 引言
• 领域特定语言的构建
  • 写下你的句子
  • 方法化你的句子
  • 创建上下文
  • 实现动作和条件
• 实现领域特定语言
  • TouchGesture
  • TouchEvent
• 结论

引言

在 第一部分中，我向您展示了如何使用DSL。本篇文章将更深入地解释我是如何得出DSL的各个类以及它们是如何实现的。

这是两部分系列文章的第二部分

1. 用于 Android 触摸事件的特定领域语言：第 1 部分：DSL 的描述和用法
2. 用于 Android 触摸事件的特定领域语言：第 2 部分：构造和内部工作原理

领域特定语言的构建

澄清一下：这不仅仅是领域特定语言，它更具体地说是一个 流畅接口。

好了，说清楚了这些，我们开始吧

写下你的句子

方法化你的句子

touchdown().andnext().move().andnext().touchup()

touchdown().do(action)

touchdown.if(condition).do(trueAction).else().do(falseAction)

创建上下文

public interface INextGestureAfterCreate {
    IActionAfterGestureOrConditional<INextGestureAfterTouchDown> TouchDown();
}

public interface INextGestureAfterTouchDown {
    IActionAfterGestureOrConditional<INextGestureAfterMove> Move();
    IActionAfterGestureOrConditional<INextGestureAfterMove> CanMove();
}

public interface INextGestureAfterMove {
    IActionAfterGestureOrConditional<INextGestureAfterTouchUp> TouchUp();
}

public interface INextGestureAfterTouchUp {
    IActionAfterGestureOrConditional<INextGestureAfterTouchDown> TouchDown();
}
                        
public interface IActionAfterGestureOrConditional<NextGesture> {
    INextGestureOrConditional<NextGesture> Do1(IGestureAction action);
    INextGestureOrConditional<NextGesture> Do1(IGestureAction action1, IGestureAction action2);
    INextGestureOrConditional<NextGesture> Do1(IGestureAction action1, 
                IGestureAction action2, IGestureAction action3);
    IAfterConditional<NextGesture> If(IGestureCondition condition);
}

public interface INextGestureOrConditional<NextGesture> {
    NextGesture AndNext();
    IAfterConditional<NextGesture> AndIf();
}

public interface IAfterConditional<NextGesture> {
    NextGesture AndNext();
    public IAfterConditionalContinuation<NextGesture> Do2(IGestureAction action);
    public IAfterConditionalContinuation<NextGesture> Do2(IGestureAction action1, IGestureAction action2);
    public IAfterConditionalContinuation<NextGesture> Do2(IGestureAction action1, 
           IGestureAction action2, IGestureAction action3);
    public IAfterConditionalContinuation<NextGesture> Do2(IGestureAction action1, 
           IGestureAction action2, IGestureAction action3, IGestureAction action4);

}

public interface IAfterConditionalContinuation<NextGesture> {
    NextGesture AndNext();
    IActionAfterGestureOrConditionalContinuation<NextGesture> Else();
}

public interface IActionAfterGestureOrConditionalContinuation<NextGesture>  {
    public INextGestureOrConditional<NextGesture> Do3(IGestureAction action);
    public INextGestureOrConditional<NextGesture> Do3(IGestureAction action1, IGestureAction action2);
    public INextGestureOrConditional<NextGesture> Do3(IGestureAction action1, 
           IGestureAction action2, IGestureAction action3);
    public IAfterConditional<NextGesture> If(IGestureCondition condition);
}

实现动作和条件

实现领域特定语言

TouchGesture

public class TouchGesture implements IResetable  {

    public TouchGesture(String id) 
    {
        this.id = id;
    }
    
    public String getId()
    {
        return id;
    }
    
    public void addEvent(TouchEvent event)
    {
        TouchEventExecution eventExecution = new TouchEventExecution();
        eventExecution.touchEvent = event;
        eventExecution.isExecuted = false;
        eventList.add(eventExecution);
    }
    
    public TouchEvent getEvent(int index)
    {
        return eventList.get(index).touchEvent;
    }
    
    public int size()
    {
        return eventList.size();
    }
    
    public void reset()
    {        
        for(IResetable resetable:resetableList)
        {
            resetable.reset();
        }
        
        if(onResetAction != null)
        {
            onResetAction.executeAction(null, this);
        }
        
        isValid = true;
        index = 0;
        context = new Hashtable<String, Object>();
    }
    
    public void invalidate()
    {
        isValid = false;
    }
    
    public boolean isValid()
    {
        return ((index < eventList.size()) && isValid);
    }
    
    public TouchEvent current()
    {
        return eventList.get(index).touchEvent;
    }
    
    public boolean isCurrentExecuted()
    {
        return eventList.get(index).isExecuted;
    }
    
    public void currentIsExecuted()
    {
        eventList.get(index).isExecuted = true;
    }
    
    public void moveNext()
    {
        index++;
    }
    
    public boolean isCompleted()
    {
        if(!isValid)
            return false;
        
        return (index >= eventList.size());
    }
    
    public void setAllEventsProcessed()
    {
        index = eventList.size();
    }

    private String id;
    private List<TouchEventExecution> eventList = new ArrayList<TouchEventExecution>();    
    private List<IResetable> resetableList = new ArrayList<IResetable>();    
    private boolean isValid = true;
    private int index = 0;
    
    private class TouchEventExecution
    {
        TouchEvent touchEvent;
        boolean isExecuted;
    }
}    

TouchEvent

public class TouchEvent {
    public static final int TOUCH_DOWN = 1;
    public static final int TOUCH_MOVE = 2;
    public static final int TOUCH_UP = 3;
    
    public int event;
    public boolean isOptional = false;
    public ArrayList<IfThenClause> conditionList = new ArrayList<IfThenClause>();
}

public class GestureBuilder<V> {
    
    public GestureBuilder(V view)
    {
        this.view = view;
    }
    
    public INextGestureAfterCreate Create(TouchGesture gesture)
    {
        return new NextGestureAfterCreate(gesture);
    }

    V view;
}

正如本系列 第一部分所述，手势通常是一个触摸事件序列。所以我们想要做的是首先检查这个序列是否正确，其次是这个序列的条件是否正确。

为了检查序列，我们使用手势定义本身，并维护一个指向我们序列中位置的指针。如果当前事件与我们的预期不符，我们将整个序列作废。如果它与我们的预期相符，我们 then 检查条件，并根据结果执行动作。

但是如果我们作废了一个序列，那么我们什么时候才能重新启用它？假设你有三个手势：在控件的特定区域单击，无论何处长按，以及从任何地方开始的拖动。现在，假设我们触摸屏幕，但**不在**特定区域。因此，我们的单击手势立即作废。其他手势仍然可能。因此，当下一个事件到来时，单击手势将无法再评估。只有当所有手势都无效，或者一个有效的手势完成时，它才能被重新评估。当这些中的任何一个发生时，我们将重新启用所有手势。

所有这些都导致了以下TouchHandler类

public class TouchHandler {
    
    public static String TouchHandlerId = "TOUCH_HANDLER";
    
    public static String LastActionPos = "LAST_ACTION_POSITION";
    
    public static String ActionDownPos = "ACTION_DOWN_POSITION";
    public static String ActionDownTime = "ACTION_DOWN_TIME";
    
    public static String ActionMovePos = "ACTION_MOVE_POSITION";
    public static String ActionMoveTime = "ACTION_MOVE_TIME";
    
    public static String ActionUpPos = "ACTION_UP_POSITION";
    public static String ActionUpTime = "ACTION_UP_TIME";
    
    public TouchHandler()
    {
        handler = new Handler();
    }
    
    public void addGesture(TouchGesture gesture)
    {
        gesture.addContext(TouchHandlerId, this);
        gestureList.add(gesture);
    }
    
    public static String getEventId(String dataKey, int index)
    {
        return dataKey + "_" + ((Integer)index).toString();
    }
    
    public void tryReset()
    {
        boolean canReset = true;

        for(TouchGesture eventOrder : gestureList)
        {
            // This can not be done if any gesture is valid but not yet completed
            if(eventOrder.isValid() && !eventOrder.isCompleted())
                canReset = false;
        }
        
        if(canReset)
        {
            for(TouchGesture eventOrder : gestureList)
            {
                eventOrder.reset();
                eventOrder.addContext(TouchHandlerId, this);
                
                touchDownCounter = 0;
                touchUpCounter = 0;
            }
        }
    }

    public void onTouchEvent(MotionEvent androidMotion)   {
        lastMotionEvent = new GestureEvent(androidMotion);
        
        int action = androidMotion.getActionMasked();
        
        GestureEvent motion = new GestureEvent(androidMotion);
          
        switch (action) {
        case MotionEvent.ACTION_DOWN:
        case MotionEvent.ACTION_POINTER_DOWN:
            // We have a touchdown event
            touchDownCounter++;
            for(TouchGesture eventOrder : gestureList)
            {
                // Store some data we can query in our actions and conditions
                if(eventOrder.contextExists(LastActionPos))
                {
                    eventOrder.setContext(LastActionPos, motion.getPosition());
                }
                else
                {
                    eventOrder.addContext(LastActionPos, motion.getPosition());
                }
                eventOrder.addContext(TouchHandler.getEventId(ActionDownPos, touchDownCounter), motion.getPosition());
                eventOrder.addContext(TouchHandler.getEventId(ActionDownTime, touchDownCounter), motion.getTime());
                // If the sequence is still valid and we expect a touchdown event, then process it
                if(eventOrder.isValid() && eventOrder.current().event == TouchEvent.TOUCH_DOWN)
                {
                    for(IfThenClause condition: eventOrder.current().conditionList)
                    {
                        // Execute the condition
                        condition.Execute(motion, eventOrder);
                        // Check if our gesture is still valid.
                        //    It is possible that the condition invalidated the gesture.
                        //    If this happened, there is no need to check any further conditions
                        if(!eventOrder.isValid())
                        {
                            break;
                        }
                    }
                    
                    // Signal this part of the sequence as executed
                    eventOrder.currentIsExecuted();
                    // and move the sequence pointer forward
                    eventOrder.moveNext();
                }
            }

            break;
        case MotionEvent.ACTION_MOVE:
            // We have a move event
            for(TouchGesture eventOrder : gestureList)
            {
                // Store some data we can query in our actions and conditions
                if(eventOrder.contextExists(LastActionPos))
                {
                    eventOrder.setContext(LastActionPos, motion.getPosition());
                }
                else
                {
                    eventOrder.addContext(LastActionPos, motion.getPosition());
                }
                
                boolean isValid = false;
                // If the sequence is still valid and we expect a move event, then process it
                if(eventOrder.isValid() && eventOrder.current().event == TouchEvent.TOUCH_MOVE)
                {
                    isValid = true;
                    for(IfThenClause condition: eventOrder.current().conditionList)
                    {
                        condition.Execute(motion, eventOrder);
                        if(!eventOrder.isValid())
                        {
                            break;
                        }
                    }

                    eventOrder.currentIsExecuted();
                    // Do not move to the next event because there will most likely be a series
                    //    of these move-events and otherwise only one would be accepted
                    //eventOrder.moveNext();
                }

                if(!isValid)
                    eventOrder.invalidate();
            }

            break;
        case MotionEvent.ACTION_UP:
        case MotionEvent.ACTION_POINTER_UP:
            touchUpCounter++;
            for(TouchGesture eventOrder : gestureList)
            {
                // Store some data we can query in our actions and conditions
                if(eventOrder.contextExists(LastActionPos))
                {
                    eventOrder.setContext(LastActionPos, motion.getPosition());
                }
                else
                {
                    eventOrder.addContext(LastActionPos, motion.getPosition());
                }
                eventOrder.addContext(TouchHandler.getEventId(ActionUpPos, touchUpCounter), motion.getPosition());
                eventOrder.addContext(TouchHandler.getEventId(ActionUpTime, touchUpCounter), motion.getTime());
                
                // If the sequence is still valid and we expect a move event
                //    which is not optional and is not executed yet
                // Then our sequence is no longer valid
                if(eventOrder.isValid() && (eventOrder.current().event == TouchEvent.TOUCH_MOVE) 
                        && !eventOrder.current().isOptional && !eventOrder.isCurrentExecuted())
                {
                    eventOrder.invalidate();
                }
                // If the sequence is still valid and we expect a move event
                //    which is optional and is executed yet
                // Then move forward in the sequence
                if(eventOrder.isValid() && (eventOrder.current().event == TouchEvent.TOUCH_MOVE) 
                        && (eventOrder.current().isOptional || eventOrder.isCurrentExecuted()))
                {
                    eventOrder.moveNext();
                }
                
                // If the sequence is still valid and we expect a touchup event, then process it
                if(eventOrder.isValid() && eventOrder.current().event == TouchEvent.TOUCH_UP)
                {
                    for(IfThenClause condition: eventOrder.current().conditionList)
                    {
                        condition.Execute(motion, eventOrder);
                        if(!eventOrder.isValid())
                        {
                            break;
                        }
                    }
                    
                    eventOrder.currentIsExecuted();
                    eventOrder.moveNext();
                }
            }

            break;
        }
        
        // Try resetting all the gestures
        tryReset();

    }
    
    private List<TouchGesture< gestureList = new ArrayList<TouchGesture>();
    private GestureEvent lastMotionEvent;
    
    private int touchDownCounter = 0;
    private int touchUpCounter = 0;
}

结论