scaleGestureDetector.getScaleFactor() всегда возвращает 1.0 в Android 6.0

Question

Я использую ScaleGestureDetector, чтобы обнаружить щепотку и ущипнуть действия, , получив масштабный коэффициент, если он меньше, чем тот, который затем уменьшает масштаб и наоборот.

Но проблема в том, что на Android 6.0 коэффициент масштабирования всегда равен 1.0, что делает невозможным отличить щепотку от щепотки.

Заранее благодарим за любую помощь.

import android.content.Context; 
import android.os.Handler; 
import android.support.v4.view.GestureDetectorCompat; 
import android.support.v4.view.MotionEventCompat; 
import android.util.Log; 
import android.view.GestureDetector; 
import android.view.MotionEvent; 
import android.view.ScaleGestureDetector; 
import android.view.VelocityTracker; 
import android.widget.FrameLayout; 

public class TouchableWrapper extends FrameLayout 
{ 
    private GestureDetectorCompat mGestureDetector; 
    private ScaleGestureDetector mScaleGestureDetector; 
    private VelocityTracker mVelocityTracker; 
    private boolean acceptEvents=true; 
    ScaleGestureDetector temp; 


private final GestureDetector.SimpleOnGestureListener mGestureListener = new GestureDetector.SimpleOnGestureListener() 
{ 

    @Override 
    public boolean onDoubleTap(MotionEvent e) 
    { 
     EventBus_Singleton.getInstance().post(new EventBus_Poster(Constants.MAP_DOUBLE_TOUCHED)); 
     return true; 
    } 

    @Override 
    public boolean onDoubleTapEvent(MotionEvent e) { 
     return super.onDoubleTapEvent(e); 
    } 



}; 

private final ScaleGestureDetector.OnScaleGestureListener mScaleGestureListener = new ScaleGestureDetector.SimpleOnScaleGestureListener() 
{ 
    /** 
    * This is the active focal point in terms of the viewport. Could be a local 
    * variable but kept here to minimize per-frame allocations. 
    */ 

    float startingSpan; 
    float startFocusX; 
    float startFocusY; 

    @Override 
    public boolean onScaleBegin(ScaleGestureDetector scaleGestureDetector) 
    { 

     temp=scaleGestureDetector; 
     startingSpan = scaleGestureDetector.getCurrentSpan(); 
     startFocusX = scaleGestureDetector.getFocusX(); 
     startFocusY = scaleGestureDetector.getFocusY(); 

     return true; 
    } 

    @Override 
    public boolean onScale(ScaleGestureDetector scaleGestureDetector) 
    { 
     super.onScale(scaleGestureDetector); 

     float scale = scaleGestureDetector.getScaleFactor(); 
     //mVelocityTracker.computeCurrentVelocity(1000); 



     if(acceptEvents) 
     { 

      Log.e("scaleGestureDetector.getCurrentSpan()", scaleGestureDetector.getCurrentSpan()+""); 
      Log.e("startingSpan", startingSpan+""); 
      Log.e("onScale",scale+""); 

      if (scale <= 1.0) 
      { 
       acceptEvents = false; 
       EventBus_Singleton.getInstance().post(new EventBus_Poster(Constants.MAP_ZOOMED_OUT)); 
      } 
      else 
      { 
       acceptEvents = false; 
       EventBus_Singleton.getInstance().post(new EventBus_Poster(Constants.MAP_ZOOMED_IN)); 
      } 
     } 

     return true; 
    } 
}; 

public TouchableWrapper(Context context) 
{ 
    super(context); 
    mScaleGestureDetector = new ScaleGestureDetector(context, mScaleGestureListener); 
    mGestureDetector = new GestureDetectorCompat(context, mGestureListener); 
    mVelocityTracker = VelocityTracker.obtain(); 
} 

@Override 
public boolean onInterceptTouchEvent(MotionEvent ev) 
{ 
    mGestureDetector.onTouchEvent(ev); 
    //Log.e("Motion Event pointer count",ev.getPointerCount()+""); 


    int action = MotionEventCompat.getActionMasked(ev); 

    switch (action) 
    { 
     case (MotionEvent.ACTION_DOWN): 
      Log.e("MotionEvent", "Action was DOWN"); 
      break; 
     case (MotionEvent.ACTION_MOVE): 
      //Log.e("MotionEvent", "Action was MOVE"); 
      /*if(acceptEvents) 
      { 
       if(MotionEventCompat.getPointerCount(ev)==2) 
       { 

        x1=MotionEventCompat.getX(ev,0); 
        x2=MotionEventCompat.getX(ev,1); 
        y1=MotionEventCompat.getY(ev,0); 
        y2=MotionEventCompat.getY(ev,1); 


        if(differenceX==0||differenceY==0) 
        { 
         differenceX=Math.abs(x1-x2); 
         differenceY=Math.abs(y1-y2); 
        } 
        else 
        { 
         differenceXPrime=Math.abs(x1-x2); 
         differenceYPrime=Math.abs(y1-y2); 


         if (differenceXPrime-differenceX>100 || differenceYPrime-differenceY>100) 
         { 
          Log.e("Zoomed out","differenceX:"+differenceX+"   differenceXPrime:"+differenceXPrime+"   differenceY:"+differenceY+"   differenceYPrime:"+differenceYPrime); 
          differenceX=0; 
          differenceY=0; 
          acceptEvents=false; 
          EventBus_Singleton.getInstance().post(new EventBus_Poster(Constants.MAP_ZOOMED_IN)); 

         } 
         else if(differenceX-differenceXPrime>100 || differenceY-differenceYPrime>100) 
         { 
          Log.e("Zoomed in","differenceX:"+differenceX+"   differenceXPrime:"+differenceXPrime+"   differenceY:"+differenceY+"   differenceYPrime:"+differenceYPrime); 
          differenceX=0; 
          differenceY=0; 
          acceptEvents=false; 
          EventBus_Singleton.getInstance().post(new EventBus_Poster(Constants.MAP_ZOOMED_OUT)); 
         } 
        } 
       } 
      }*/ 

      break; 
     case (MotionEvent.ACTION_UP): 
      new Handler().postDelayed(new Runnable() { 
       @Override 
       public void run() { 
        EventBus_Singleton.getInstance().post(new EventBus_Poster(Constants.ENABLE_MAP_GESTURE)); 
        acceptEvents=true; 
       } 
      },300); 

      Log.e("MotionEvent", "Action was UP"); 
      break; 
     case (MotionEvent.ACTION_POINTER_UP): 
      Log.e("MotionEvent", "Action was POINTER UP"); 
      break; 
     case (MotionEvent.ACTION_POINTER_DOWN): 
      EventBus_Singleton.getInstance().post(new EventBus_Poster(Constants.DISABLE_MAP_GESTURE)); 
      Log.e("MotionEvent", "Action was POINTER DOWN"); 
      break; 
     case (MotionEvent.ACTION_CANCEL): 
      Log.e("MotionEvent", "Action was CANCEL"); 
      break; 
     case (MotionEvent.ACTION_OUTSIDE): 
      Log.e("MotionEvent", "Movement occurred outside bounds of current screen element"); 
      break; 
    } 
    mVelocityTracker.addMovement(ev); 
    mScaleGestureDetector.onTouchEvent(ev); 
    return super.onInterceptTouchEvent(ev); 
} 

} 

Answer 1

Я думаю, что onInterceptTouchEvent не вызвал. Вам нужно переопределить onTouchEvent в классе TouchableWrapper так:

@Override 
public boolean onTouchEvent(MotionEvent event) { 
    mScaleGestureDetector.onTouchEvent(event); 
    return true; 
} 

Answer 2

Я думаю, что проблема в том, что когда вы делаете щепотку жест медленно, этот класс отбрасывает малые приращения промежутка между пальцами. Это беспокоит только большие различия в пролете.

Если вы медленно зажаты, он зарегистрирует несколько различных событий перемещения касания, каждый из которых имеет промежуток (между пальцами), только немного отличающийся от предыдущего события. Он считает, что продолжительность не изменится, таким образом, масштабный коэффициент равен 1.

Если зажать быстро, он будет регистрировать больший срок, чем последнее событие, и даст вам фактор, отличный от 1.

В моем Решение Я настраиваю класс. Я сам вычисляю масштабный коэффициент. Масштабный коэффициент равен 1, если вы не зажимаете. Затем, когда вы начинаете зажимать, коэффициент масштабирования рассчитывается из , начинающегося жестящего зажима и не от предыдущий событие касания.

Поэтому я делаю подкласс ScaleGestureDetector, и в нем я переопределяю onTouchEvent(). В нем я отслеживаю оба пальца, и если оба движутся, я измеряю начальный интервал и сохраняю его. Я переопределяю getScaleFactor(), и коэффициент рассчитывается на основе текущего диапазона по сравнению с начальным интервалом. Когда какой-либо из пальцев удален, масштабирование завершено; коэффициент возвращается к 1.