मैपव्यू

Question

पर कैमरे के पथ को आसानी से एनिमेट करना मैं मार्ग के संबंधित बिंदुओं की सूची के साथ अपने मानचित्र दृश्य (नया एपीआई v2) का उपयोग करता हूं। वे एक साथ बहुत करीबी हैं। मेरी समस्या है, तो मुझे क्या करना एनीमेशन चरणों

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

कैमरामैन एक निडर टिड्डी की तरह बर्ताव करता है, और बाहर धूपदान और exaggerately में आह्वान करने और, है इस प्रक्रिया में अल स्लाइड कैश हो जाता है @ ## @ # @ #!

पथ को एनिमेट करने और वर्दी स्क्रॉलिंग अनुभव प्राप्त करने का सबसे अच्छा तरीका क्या है? गति कोई समस्या नहीं है, मैं कम गति का उपयोग करूंगा, मुझे चिकनीता में दिलचस्पी है ...

अगर मैं उंगली के साथ एक मार्ग अनुकरण कर सकता हूं तो मैं खुश रहूंगा .. क्योंकि नक्शा खूबसूरती से व्यवहार करता है और कैश के चारों ओर बहुत सारी टाइलें हैं। लेकिन प्रोग्राम परिणामों को प्रोग्रामेटिक रूप से बोल्ड एनीमेशन, श्वेत स्क्रीन, टाइल्स के पुनः लोड करने के परिणामस्वरूप स्थानांतरित करने का कोई प्रयास ...

अग्रिम धन्यवाद !!!

Answer 1

ठीक है, मुझे उम्मीद है कि कोई बेहतर जवाब प्रदान करेगा, लेकिन मैंने किए गए कई प्रयोगों के साथ, मैं एनिमेट कैमरे का उपयोग करके सभ्य चिकनी स्क्रॉल प्राप्त करने में असमर्थ था।

एक साथ बंद बिंदुओं के लिए केवल लैट/एलएनजी को बदलने के बावजूद, कैमरामैन प्रभावशाली टेकऑफ और लैंडिंग बना रहा।

मैं दिनचर्या निम्नलिखित के साथ सीमित 'एल cheapo' एनीमेशन सफलता मिली है:,

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); 

    } 

यह दिनचर्या, 10000s में मिलीसेकेंड मूल्य के साथ कहा जाता है एक बिंदु को जाता है तो एक यादृच्छिक में एक फ्लाईओवर एनीमेशन बनाता है लान ज़ूम tranquilo रखने की दिशा। चूंकि पिक्सेल मान बहुत छोटे होते हैं, संभावना है कि यह सब कुछ कैश किया गया है।

कोई बेहतर समाधान वाला कोई भी व्यक्ति? क्या 'स्पर्श' फ़्लिंग अनुकरण करने के लिए स्पर्श घटनाओं को इंजेक्ट करने का प्रयास करना उचित या संभव है?

Answer 2

मुझे पता चला है कि एक रिकर्सिव समाधान को प्रकट करने के लिए अंतिम पैरामीटर के रूप में वैकल्पिक कॉलबैक का उपयोग चिकनी एनीमेशन प्रदान करता है। यह कोड ज़ूम करता है, पैनोरैमिक स्पिन के लिए कोण बदलता है, फिर फिर से ज़ूम करता है; यह पसंद नहीं है, हालांकि, जब प्रारंभिक पैरामीटर और प्रारंभिक कॉलबैक समान हैं; मैं वहाँ एक बेहतर तरीका प्रत्यावर्तन कॉल करने के लिए है यकीन है, लेकिन उम्मीद है कि यह आप कैसे आप कार्यात्मक चेतन कर सकते हैं की एक विचार दे सकते हैं:

//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() 
    {} 

};