Reibungsloses Animieren eines Kamerapfads auf einer Kartenansicht

Question

Ich verwende meine MapView (neue API v2) mit einer Liste von Punkten, die zu einer Route gehören. Sie sind ziemlich nah beieinander. Mein Problem ist, wenn ich die Animationsschritte Aufruf tue

 mMapInstance.animateCamera(CameraUpdateFactory.newLatLng(mNextPosition),ms, null); 

Der Kameramann verhält sich wie eine unerschrockene Heuschrecke und Pfannen und in exaggerately, und in dem Prozess al der Schieber Cache bekommt @ ## @ # @ #!

Was ist der beste Ansatz, um einen Pfad zu animieren und ein einheitliches Scroll-Erlebnis zu erhalten? Geschwindigkeit ist kein Problem, ich würde niedrige Geschwindigkeit verwenden, ich interessiere mich für die Glätte ...

Ich werde mehr als glücklich sein, wenn ich einen Weg simulieren könnte, den ich mit dem Finger mache .. weil sich die Karte schön verhält und hat viele Kacheln im Cache. Aber jeder Versuch, die Karte programmatisch zu verschieben, ist in der fetten Animation, weißer Bildschirm, Nachladen von Fliesen ...

Vielen Dank im Voraus !!!

Answer 1

Nun, ich hoffe, jemand gibt eine bessere Antwort, aber mit den vielen Experimenten, die ich gemacht habe, konnte ich mit animateCamera keine anständige glatte Schriftrolle bekommen.

Unabhängig davon, nur die Breite/Länge der Punkte zu ändern, machte der Kameramann beeindruckende Starts und Landungen.

Ich habe begrenzten 'el-cheapo' Animation Erfolg mit der folgenden Routine hat:

private void animateTo(double lat, double lon, double zoom, double bearing, double tilt, final int milliseconds) { 

     if (mMapInstance==null) return; 
     mMapInstance.setMapType(paramMapMode); 
     mCurrentPosition=new LatLng(lat,lon); 

     // animate camera jumps too much 
     // so we set the camera instantly to the next point 

     mMapInstance.moveCamera(CameraUpdateFactory.newCameraPosition(new CameraPosition(mCurrentPosition,(float)zoom, (float)tilt, (float)bearing))); 

     // give Android a break so it can load tiles. If I start the animation 
     // without pause, no tile loading is done 

     mMap.postDelayed(new Runnable(){ 
      @Override 
      public void run() { 
       // keeping numbers small you get a nice scrolling effect 
       mMapInstance.animateCamera(CameraUpdateFactory.scrollBy(250-(float)Math.random()*500-250, 250-(float)Math.random()*500),milliseconds,null); 

      }},500); 

    } 

diese Routine mit Millisekunden-Wert in dem 10000s genannt, gehe auf einen Punkt dann eine Flyover Animation in einem zufälligen macht Richtung den verdammten Zoom ruhig halten. Da die Pixelwerte sehr klein sind, ist es wahrscheinlich alles zwischengespeichert.

Jeder mit einer besseren Lösung? Ist es vernünftig oder möglich zu versuchen, Berührungsereignisse zu injizieren, um einen "berührten" Fling zu simulieren?

Answer 2

Ich habe festgestellt, dass die Verwendung der optionalen Rückruf als ein abschließender Parameter, um eine rekursive Lösung zu manifestieren bietet eine glatte Animation. Dieser Code zoomt heran, ändert den Winkel für einen Panorama-Dreh und zoomt dann erneut hinein; es mag es jedoch nicht, wenn die Anfangsparameter und der anfängliche Rückruf identisch sind; Ich bin sicher, es gibt einen besseren Weg, um die Rekursion zu nennen, aber hoffentlich kann dies Ihnen eine Vorstellung davon, wie Sie funktionell animieren:

//initial zoom 
static final int initZoom = 8; 
//steps the zoom 
int stepZoom = 0; 
// number of steps in zoom, be careful with this number! 
int stepZoomMax = 5; 
//number of .zoom steps in a step 
int stepZoomDetent = (18 - initZoom)/stepZoomMax; 
//when topause zoom for spin 
int stepToSpin = 4; 
//steps the spin 
int stepSpin = 0; 
//number of steps in spin (factor of 360) 
int stepSpinMax = 4; 
//number of degrees in stepSpin 
int stepSpinDetent = 360/stepSpinMax; 

Intent detailIntent; 
Intent intent; 
Marker marker; 
final int mapHopDelay = 2000; 

@Override 
public void onCreate(Bundle savedInstanceState) 
{ 
    super.onCreate(savedInstanceState); 
    setContentView(R.layout.map_affirm); 
    try 
    {MapsInitializer.initialize(this);} 
    catch (GooglePlayServicesNotAvailableException impossible) 
    { /* Impossible */ Log.e(TAG, "the impossible occurred");} 
    intent = this.getIntent(); 
    latLng = new LatLng(intent.getDoubleExtra("Latitude", 0.0), intent.getDoubleExtra("Longitude", 0.0)); 
    map = ((MapFragment) getFragmentManager().findFragmentById(R.id.map)).getMap(); 
    map.animateCamera(CameraUpdateFactory.newCameraPosition(CameraPosition.builder() 
                  .target(latLng) 
                  .zoom(initZoom-1) 
                  .build()) 
         , mapHopDelay 
         , cameraAnimation 
        ); 
    marker = map.addMarker(new MarkerOptions() 
          .draggable(true) 
          .position(latLng) 
          .title("Location of Photographer")); 

} 

public CancelableCallback cameraAnimation = new CancelableCallback(){ 

    @Override 
    public void onFinish() 
    { 
     if (stepZoom < stepZoomMax && stepZoom != stepToSpin) 
     { 
      stepZoom++; 
      map.animateCamera(CameraUpdateFactory.newCameraPosition(CameraPosition.builder() 
                    .target(latLng) 
                    .zoom(initZoom + (stepZoomDetent * (stepZoom - 1))) 
                    // .bearing(40*aniStep) 
                    // .tilt(60) 
                    .build()), mapHopDelay, cameraAnimation); 

     } 
     else if (stepZoom >= stepZoomMax)// ending position hard coded for this application 
     {map.animateCamera(CameraUpdateFactory.newCameraPosition(CameraPosition.builder() 
                   .target(latLng) 
                   .zoom(18) 
                   // .bearing(0) 
                   .tilt(0) 
                   .build())); 
     } 
     else 
     { 
      if (stepSpin <= stepSpinMax) 
      { 
       stepSpin++; 
       map.animateCamera(CameraUpdateFactory.newCameraPosition(CameraPosition.builder() 
                     .target(latLng) 
                     .zoom(initZoom + stepZoomDetent * stepZoom) 
                     .bearing(stepSpinDetent * (stepSpin - 1)) 
                     .tilt(60) 
                     .build()), mapHopDelay, cameraAnimation); 
      } 
      else 
      { 
       stepZoom++; 
       map.animateCamera(CameraUpdateFactory.newCameraPosition(CameraPosition.builder() 
                     .target(latLng) 
                     .zoom(initZoom + stepZoomDetent * stepZoom) 
                     .bearing(0) 
                     .tilt(0) 
                     .build()), mapHopDelay, cameraAnimation); 
      } 
     } 
    } 

    @Override 
    public void onCancel() 
    {} 

};