Butterknife.OnClick에서 버튼을 너무 빨리 누르는 것을 방지하는 해결 방안

버튼의 떨림 방지는 두 번의 클릭 시간차를 판단하는 것이지만, Butterknife에서.OnClick에는 항상 한 무더기의 코드를 써야 하는데 사실 우리가 원하는 가장 이상적인 해결 방안은 다음과 같다.

@OnClick({R.id.record, R.id.combine})
public void onClick(View view) {
    if (AntiShake.check(view.getId())) {    //        
        return;  
    }
    switch (view.getId()) {
        case R.id.hos_detail_visit_record:
           //todo
            break;
        case R.id.combine_chart:
            //todo
    }
}

구현 방법은 다음과 같습니다.
첫 번째 유형은 NoDouble ClickListener가 두 번 클릭한 시간을 판단하는 것과 유사하다

public class OneClick {
    private String methodName;
    private static final int CLICK_DELAY_TIME = 1000;
    private long lastClickTime = 0;

    public OneClick(String methodName) {
        this.methodName = methodName;
    }

    public String getMethodName() {
        return methodName;
    }

    public boolean check() {
        long currentTime = Calendar.getInstance().getTimeInMillis();
        if (currentTime - lastClickTime > CLICK_DELAY_TIME) {
            lastClickTime = currentTime;
            return false;
        } else {
            return true;
        }
    }
}

두 번째 종류의 정적 변수는 클릭 이벤트를 저장하고 맞춤형 저장의 수량은 자동으로 삭제할 수 있는 이전의 수량을 초과한다.

public class AntiShake {

    private static LimitQueue queue = new LimitQueue<>(20);

    public static boolean check(Object o) {
        String flag;
        if(o == null) {
            flag = Thread.currentThread().getStackTrace()[2].getMethodName();
        } else {
            flag = o.toString();
        }
        for (OneClick util : queue.getArrayList()) {
            if (util.getMethodName().equals(flag)) {
                return util.check();
            }
        }
        OneClick clickUtil = new OneClick(flag);
        queue.offer(clickUtil);
        return clickUtil.check();
    }
}

세 번째 종류는 일정한 대상을 저장하는 체인표로 정의된 범위를 넘어서면 첫 번째 대상을 삭제한다

public class LimitQueue  {

    private int limitedSize;

    private LinkedList linkedList = new LinkedList<>();

    public LimitQueue(int size) {
        this.limitedSize = size;
    }

    public void offer(E e) {
        if (linkedList.size() >= limitedSize) {
            linkedList.poll();
        }
        linkedList.offer(e);
    }

    public E get(int position) {
        return linkedList.get(position);
    }

    public E getLast() {
        return linkedList.getLast();
    }

    public E getFirst() {
        return linkedList.getFirst();
    }

    public int getLimit() {
        return limitedSize;
    }

    public void setLimitedSize(int size) {
        this.limitedSize = size;
    }

    public int size() {
        return linkedList.size();
    }

    public ArrayList getArrayList() {
        ArrayList arrayList = new ArrayList<>();
        for (int i = 0; i < linkedList.size(); i ++) {
            arrayList.add(linkedList.get(i));
        }
        return arrayList;
    }

    @Override
    public String toString() {
        StringBuilder buffer = new StringBuilder();
        for (int i = 0; i < linkedList.size(); i++) {
            buffer.append(linkedList.get(i));
            buffer.append(" ");
        }
        return buffer.toString();
    }
}

사용 시 if(Antishake.check(view.getId()) 판단을 직접 추가하면 됩니다.잘못된 점이 있으면 귀중한 의견을 제시해 주십시오.