moveUpera कैमराUpdateFactory.newLatLngBounds क्रैश

Question

मैं नए Android Google Maps API का उपयोग कर रहा हूं।

मैं एक ऐसी गतिविधि बनाता हूं जिसमें मैपफ्रैगमेंट शामिल है। गतिविधि onResume में मैंने मार्कर को GoogleMap ऑब्जेक्ट में सेट किया है और फिर मानचित्र के लिए एक बाउंडिंग बॉक्स परिभाषित किया है जिसमें सभी मार्कर शामिल हैं।

LatLngBounds.Builder builder = new LatLngBounds.Builder(); 
while(data) { 
    LatLng latlng = getPosition(); 
    builder.include(latlng); 
} 
CameraUpdate cameraUpdate = CameraUpdateFactory 
    .newLatLngBounds(builder.build(), 10); 
map.moveCamera(cameraUpdate); 

map.moveCamera() के आह्वान के बाद ढेर के साथ दुर्घटना अपने आवेदन का कारण बनता है:

यह निम्न छद्म कोड उपयोग कर रहा है

Caused by: java.lang.IllegalStateException: 
    Map size should not be 0. Most likely, layout has not yet 

    at maps.am.r.b(Unknown Source) 
    at maps.y.q.a(Unknown Source) 
    at maps.y.au.a(Unknown Source) 
    at maps.y.ae.moveCamera(Unknown Source) 
    at com.google.android.gms.maps.internal.IGoogleMapDelegate$Stub 
     .onTransact(IGoogleMapDelegate.java:83) 
    at android.os.Binder.transact(Binder.java:310) 
    at com.google.android.gms.maps.internal.IGoogleMapDelegate$a$a 
     .moveCamera(Unknown Source) 
    at com.google.android.gms.maps.GoogleMap.moveCamera(Unknown Source) 
    at ShowMapActivity.drawMapMarkers(ShowMapActivity.java:91) 
    at ShowMapActivity.onResume(ShowMapActivity.java:58) 
    at android.app.Instrumentation 
     .callActivityOnResume(Instrumentation.java:1185) 
    at android.app.Activity.performResume(Activity.java:5182) 
    at android.app.ActivityThread 
     .performResumeActivity(ActivityThread.java:2732) 

है - newLatLngBounds() कारखाने विधि मैं का उपयोग करने के बजाय newLatLngZoom() विधि तब एक ही जाल नहीं होता है।

onResume मार्कर को GoogleMap ऑब्जेक्ट पर आकर्षित करने के लिए सबसे अच्छी जगह है या क्या मुझे मार्करों को चित्रित करना चाहिए और कहीं और कैमरा स्थिति सेट करना चाहिए?

Answer 1

ठीक है मैंने यह काम किया। documented here के रूप में कि एपीआई पूर्व-लेआउट का उपयोग नहीं किया जा सकता है।

नोट::

उपयोग करने के लिए सही एपीआई के रूप में वर्णन किया गया है केवल सरल तरीका newLatLngBounds (सीमा, गद्दी) का प्रयोग कर एक CameraUpdate अगर यह बाद कैमरा ले जाने के लिए इस्तेमाल किया जा रहा है उत्पन्न करने के लिए नक्शा लेआउट ले लिया गया है। लेआउट के दौरान, एपीआई मानचित्र की प्रदर्शन सीमाओं की गणना करता है जो पर सही ढंग से बाध्यकारी बॉक्स प्रोजेक्ट की आवश्यकता होती है। तुलनात्मक रूप से, आप कैमरे अपडेट का उपयोग कर सकते हैं अधिक जटिल विधि नई LatLngBounds (सीमा, चौड़ाई, ऊंचाई, पैडिंग) किसी भी समय, नक्शा ले जाने से पहले, क्योंकि एपीआई तर्कों से प्रदर्शन सीमाओं की गणना करता है कि आप पास करते हैं।

समस्या मैं अपनी स्क्रीन आकार की गणना और

public static CameraUpdate newLatLngBounds(
    LatLngBounds bounds, int width, int height, int padding) 

लिए चौड़ाई और ऊंचाई प्रदान की यह तो मुझे सीमांकन बॉक्स पूर्व लेआउट निर्दिष्ट करने की अनुमति दी ठीक करने के लिए।

Answer 2

आप सरल newLatLngBounds OnCameraChangeListener में विधि का उपयोग कर सकते हैं। सभी पूरी तरह से काम करेंगे और आपको स्क्रीन आकार की गणना करने की आवश्यकता नहीं है। यह घटना मानचित्र आकार गणना के बाद होती है (जैसा कि मैं समझता हूं)।

उदाहरण:

map.setOnCameraChangeListener(new OnCameraChangeListener() { 

    @Override 
    public void onCameraChange(CameraPosition arg0) { 
     // Move camera. 
     map.moveCamera(CameraUpdateFactory.newLatLngBounds(builder.build(), 10)); 
     // Remove listener to prevent position reset on camera move. 
     map.setOnCameraChangeListener(null); 
    } 
}); 

Answer 3

जोड़ना और हटाना मार्करों पूर्व लेआउट पूरा होने से किया जा सकता है, लेकिन बढ़ कैमरा नहीं कर सकते (newLatLngBounds(boundary, padding) का उपयोग कर के रूप में ओ पी के जवाब में उल्लिखित को छोड़कर)।

शायद प्रारंभिक कैमरा अपडेट करने के लिए सबसे अच्छी जगह में दिखाए गए एक शॉट OnGlobalLayoutListener का उपयोग कर रही है, उदा। मार्करडेमोएक्टिविटी में setUpMap() से निम्न अंश देखें।जावा:

// Pan to see all markers in view. 
// Cannot zoom to bounds until the map has a size. 
final View mapView = getSupportFragmentManager() 
    .findFragmentById(R.id.map).getView(); 
if (mapView.getViewTreeObserver().isAlive()) { 
    mapView.getViewTreeObserver().addOnGlobalLayoutListener(
    new OnGlobalLayoutListener() { 
     @SuppressLint("NewApi") // We check which build version we are using. 
     @Override 
     public void onGlobalLayout() { 
      LatLngBounds bounds = new LatLngBounds.Builder() 
        .include(PERTH) 
        .include(SYDNEY) 
        .include(ADELAIDE) 
        .include(BRISBANE) 
        .include(MELBOURNE) 
        .build(); 
      if (Build.VERSION.SDK_INT < Build.VERSION_CODES.JELLY_BEAN) { 
       mapView.getViewTreeObserver().removeGlobalOnLayoutListener(this); 
      } else { 
       mapView.getViewTreeObserver().removeOnGlobalLayoutListener(this); 
      } 
      mMap.moveCamera(CameraUpdateFactory.newLatLngBounds(bounds, 50)); 
     } 
    }); 
} 

Answer 4

एक और दृष्टिकोण की तरह कुछ (अपने सर्वोच्च दृश्य मान लिया जाये कि rootContainer नाम के एक FrameLayout है, भले ही यह रूप में लंबे समय से काम के रूप में आप हमेशा कोई बात नहीं यह है जो प्रकार या नाम अपने सर्वोच्च कंटेनर का चयन करेंगे) होगा:

((FrameLayout)findViewById(R.id.rootContainer)).getViewTreeObserver() 
    .addOnGlobalLayoutListener(new OnGlobalLayoutListener() { 
     public void onGlobalLayout() { 
      layoutDone = true; 
     } 
    }); 

केवल काम के लिए अपने कैमरे कार्यों को संशोधित करता है, तो layoutDonetruelayoutListener हैंडलर के लिए अतिरिक्त कार्य या तर्क तार को जोड़ने के लिए बिना अपने सभी समस्याओं का समाधान होगा।

Answer 5

समाधान है कि तुलना में आसान है ....

// Pan to see all markers in view. 
try { 
    this.gmap.moveCamera(CameraUpdateFactory.newLatLngBounds(bounds, 50)); 
} catch (IllegalStateException e) { 
    // layout not yet initialized 
    final View mapView = getFragmentManager() 
     .findFragmentById(R.id.map).getView(); 
    if (mapView.getViewTreeObserver().isAlive()) { 
     mapView.getViewTreeObserver().addOnGlobalLayoutListener(
     new OnGlobalLayoutListener() { 
      @SuppressWarnings("deprecation") 
      @SuppressLint("NewApi") 
      // We check which build version we are using. 
      @Override 
      public void onGlobalLayout() { 
       if (Build.VERSION.SDK_INT < Build.VERSION_CODES.JELLY_BEAN) { 
        mapView.getViewTreeObserver() 
         .removeGlobalOnLayoutListener(this); 
       } else { 
        mapView.getViewTreeObserver() 
         .removeOnGlobalLayoutListener(this); 
       } 
       gmap.moveCamera(CameraUpdateFactory.newLatLngBounds(bounds, 50)); 
      } 
     }); 
    } 
} 

पकड़ने IllegalStateException और इसके बजाय दृश्य पर वैश्विक श्रोता का उपयोग करें। अन्य विधियों का उपयोग करके पहले से बाध्य आकार (पूर्व-लेआउट) सेट करना मतलब है कि आपको दृश्य के आकार की गणना करना है, न कि स्क्रीन डिवाइस पर। वे केवल तभी मेल खाते हैं जब आप अपने मानचित्र के साथ पूर्ण स्क्रीन पर जाते हैं और टुकड़ों का उपयोग नहीं करते हैं।

Answer 6

ठीक है मुझे एक ही समस्या का सामना करना पड़ रहा है। मेरे पास मेरे supportmapFragment, ABS, और नेविगेशन ड्रॉवर के साथ मेरा टुकड़ा है। क्या मैंने किया था:

public void resetCamera() { 

    LatLngBounds.Builder builderOfBounds = new LatLngBounds.Builder(); 
    // Set boundaries ... 
    LatLngBounds bounds = builderOfBounds.build(); 
    CameraUpdate cu; 
    try{ 
     cu = CameraUpdateFactory.newLatLngBounds(bounds,10); 
     // This line will cause the exception first times 
     // when map is still not "inflated" 
     map.animateCamera(cu); 
     System.out.println("Set with padding"); 
    } catch(IllegalStateException e) { 
     e.printStackTrace(); 
     cu = CameraUpdateFactory.newLatLngBounds(bounds,400,400,0); 
     map.animateCamera(cu); 
     System.out.println("Set with wh"); 
    } 

    //do the rest... 
} 

और, वैसे, मैं बढ़ा-चढ़ाकर के बाद और लौटने से पहले onCreateView से resetCamera() फोन कर रहा हूँ।
यह क्या करता है अपवाद पहली बार पकड़ता है (जबकि मानचित्र "इसे आकार देने के तरीके के रूप में" आकार देता है ...) और फिर, दूसरी बार मुझे कैमरे को रीसेट करने की आवश्यकता होती है, नक्शा पहले से ही आकार में है और इसे पैडिंग के माध्यम से करता है ।

अंक documentation में विस्तार से बताया गया है, यह कहते हैं:

जब तक नक्शा इस विधि के लिए साथ इसमें लेआउट (क्रम में सही ढंग से और उचित सीमांकन बॉक्स निर्धारित करने के लिए है इस कैमरे के अद्यतन के साथ कैमरा न बदलें ज़ूम स्तर, मानचित्र का आकार होना चाहिए)। अन्यथा IllegalStateException फेंक दिया जाएगा। यह मानचित्र के लिए पर्याप्त नहीं है (यानी getMap() गैर-शून्य ऑब्जेक्ट देता है); मानचित्र युक्त दृश्य में लेआउट भी होना चाहिए जैसे कि इसके आयाम निर्धारित किए गए हैं। यदि आप नहीं हो सकते हैं, तो यह सुनिश्चित हो गया है कि यह newLatLngBounds(LatLngBounds, int, int, int) का उपयोग करें और मैन्युअल रूप से मानचित्र के आयाम प्रदान करें।

मुझे लगता है कि यह एक सुंदर सभ्य समाधान है। उम्मीद है कि यह किसी की मदद करता है।

Answer 7

स्वीकार्य उत्तर, टिप्पणियों में बताया गया है, थोड़ा हैकी। इसे कार्यान्वित करने के बाद मैंने एनालिटिक्स में IllegalStateException लॉग की उपरोक्त स्वीकार्य राशि देखी। मैंने जिस समाधान का उपयोग किया है वह OnMapLoadedCallback जोड़ना है जिसमें CameraUpdate किया जाता है। कॉलबैक GoogleMap में जोड़ा गया है। आपके मानचित्र को पूरी तरह लोड करने के बाद कैमरा अपडेट किया जाएगा।

यह नक्शा अपडेट करने से पहले मानचित्र को संक्षेप में ज़ूम आउट (0,0) दृश्य दिखाने का कारण बनता है। मुझे लगता है कि यह क्रैश होने या अनियंत्रित व्यवहार पर निर्भर होने से अधिक स्वीकार्य है।

Answer 8

ये उत्तर ठीक हैं, लेकिन मैं एक अलग दृष्टिकोण के लिए जाना चाहता हूं, एक आसान। तो विधि के बाद ही नक्शे से बाहर रखी है काम करता है, बस इसे का इंतजार:

map.setOnMapLoadedCallback(new GoogleMap.OnMapLoadedCallback() { 
    @Override 
    public void onMapLoaded() { 
     map.moveCamera(CameraUpdateFactory.newLatLngBounds(bounds, 30)); 
    } 
}); 

Answer 9

बहुत दुर्लभ मामलों में, MapView लेआउट समाप्त हो गया है, लेकिन GoogleMap लेआउट पूरा नहीं हुआ है, ViewTreeObserver.OnGlobalLayoutListener ही दुर्घटना नहीं रोक सकता । मैंने Google Play सेवाओं के पैकेज संस्करण 5084032 के साथ क्रैश देखा। यह दुर्लभ मामला मेरे MapView की दृश्यता के गतिशील परिवर्तन के कारण हो सकता है।

इस समस्या को हल करने के लिए, मैं onGlobalLayout() में GoogleMap.OnMapLoadedCallback,

if (mapView.getViewTreeObserver().isAlive()) { 
    mapView.getViewTreeObserver().addOnGlobalLayoutListener(
    new ViewTreeObserver.OnGlobalLayoutListener() { 
     @Override 
     @SuppressWarnings("deprecation") 
     public void onGlobalLayout() { 
      if (Build.VERSION.SDK_INT < Build.VERSION_CODES.JELLY_BEAN) { 
       mapView.getViewTreeObserver().removeGlobalOnLayoutListener(this); 
      } else { 
       mapView.getViewTreeObserver().removeOnGlobalLayoutListener(this); 
      } 
      try { 
       map.moveCamera(CameraUpdateFactory.newLatLngBounds(bounds, 5)); 
      } catch (IllegalStateException e) { 
       map.setOnMapLoadedCallback(new GoogleMap.OnMapLoadedCallback() { 
        @Override 
        public void onMapLoaded() { 
         Log.d(LOG_TAG, "move map camera OnMapLoadedCallback"); 
         map.moveCamera(CameraUpdateFactory 
          .newLatLngBounds(bounds, 5)); 
        } 
       }); 
      } 
     } 
    }); 
} 

Answer 10

आप संभव उपयोगकर्ता बातचीत शुरू करने के लिए के लिए प्रतीक्षा, पिछले जवाब में वर्णित के रूप OnMapLoadedCallback उपयोग करने के लिए की जरूरत है एम्बेडेड। लेकिन, यदि आपको केवल मानचित्र के लिए एक डिफ़ॉल्ट स्थान प्रदान करना है, तो उन उत्तरों में उल्लिखित समाधानों की कोई आवश्यकता नहीं है। MapFragment और MapView दोनों GoogleMapOptions को शुरू में स्वीकार कर सकते हैं जो डिफ़ॉल्ट स्थान को सही स्थान प्रदान कर सकता है। एकमात्र चाल उन्हें सीधे आपके लेआउट में शामिल नहीं करना है क्योंकि सिस्टम उन्हें विकल्पों के बिना कॉल करेगा लेकिन उन्हें गतिशील रूप से प्रारंभ करने के लिए।

उपयोग इस अपने लेआउट में:

<FrameLayout 
    android:id="@+id/map" 
    android:name="com.google.android.gms.maps.SupportMapFragment" 
    android:layout_width="match_parent" 
    android:layout_height="match_parent" /> 

और अपने onCreateView() में टुकड़ा बदल देते हैं:

GoogleMapOptions options = new GoogleMapOptions(); 
options.camera(new CameraPosition.Builder().target(location).zoom(15).build()); 
// other options calls if required 

SupportMapFragment fragment = (SupportMapFragment) getFragmentManager().findFragmentById(R.id.map); 
if (fragment == null) { 
    FragmentTransaction transaction = getFragmentManager().beginTransaction(); 
    fragment = SupportMapFragment.newInstance(options); 
    transaction.replace(R.id.map, fragment).commit(); 
    getFragmentManager().executePendingTransactions(); 
} 
if (fragment != null) 
    GoogleMap map = fragment.getMap(); 

शुरू करने के लिए तेजी से किया जा रहा है के अलावा, वहाँ हो जाएगा कोई दुनिया के नक्शे पहले से पता चला है और एक कैमरा चाल दूसरा। मानचित्र सीधे निर्दिष्ट स्थान से शुरू होगा।

Answer 11

यह मेरा तय है, बस उस स्थिति में नक्शा लोड होने तक प्रतीक्षा करें।

final int padding = getResources().getDimensionPixelSize(R.dimen.spacing);  

try { 
    mMap.animateCamera(CameraUpdateFactory.newLatLngBounds(pCameraBounds, padding)); 
} catch (IllegalStateException ise) { 

    mMap.setOnMapLoadedCallback(new GoogleMap.OnMapLoadedCallback() { 

     @Override 
     public void onMapLoaded() { 
      mMap.animateCamera(CameraUpdateFactory.newLatLngBounds(pCameraBounds, padding)); 
     } 
    }); 
} 

Answer 12

map.moveCamera(CameraUpdateFactory.newLatLngZoom(bounds.getCenter(),10)); 

उपयोग यह mee

Answer 13

के लिए काम किया है कि मैं इस पाया काम करते हैं और अन्य समाधान की तुलना में अधिक सरल होने के लिए:

private void moveMapToBounds(final CameraUpdate update) { 
    try { 
     if (movedMap) { 
      // Move map smoothly from the current position. 
      map.animateCamera(update); 
     } else { 
      // Move the map immediately to the starting position. 
      map.moveCamera(update); 
      movedMap = true; 
     } 
    } catch (IllegalStateException e) { 
     // Map may not be laid out yet. 
     getWindow().getDecorView().post(new Runnable() { 
      @Override 
      public void run() { 
       moveMapToBounds(update); 
      } 
     }); 
    } 
} 

इस कॉल की कोशिश करता है फिर बाद लेआउट समाप्त हो गया है । असीमित पाश से बचने के लिए शायद एक सुरक्षा शामिल हो सकती है।

Answer 14

स्वीकार्य उत्तर मेरे लिए काम नहीं करेगा क्योंकि मुझे अपने ऐप के विभिन्न स्थानों में एक ही कोड का उपयोग करना था।

कैमरे को बदलने की प्रतीक्षा करने के बजाय, मैंने नक्शा आकार निर्दिष्ट करने के ली के सुझाव के आधार पर एक सरल समाधान बनाया। यदि आपका नक्शा स्क्रीन का आकार है तो यह है।

// Gets screen size 
int width = getResources().getDisplayMetrics().widthPixels; 
int height = getResources().getDisplayMetrics().heightPixels; 
// Calls moveCamera passing screen size as parameters 
map.moveCamera(CameraUpdateFactory.newLatLngBounds(builder.build(), width, height, 10)); 

आशा है कि यह किसी और की मदद करेगी!

Answer 15

मैंने विभिन्न दृष्टिकोण का उपयोग किया जो Google मानचित्र एसडीके (9.6+) के हाल के संस्करणों के लिए काम करता है और onCameraIdleListener पर आधारित है। जैसा कि मैंने अब तक देखा है, यह कॉलबैक विधि onCameraIdle है जिसे हमेशा onMapReady के बाद बुलाया जाता है।तो मेरी दृष्टिकोण कोड के इस टुकड़े की तरह लग रहा है (यह Activity में डाल पर विचार):

@Override 
protected void onCreate(Bundle savedInstanceState) { 
    super.onCreate(savedInstanceState); 
    // set content view and call getMapAsync() on MapFragment 
} 

@Override 
public void onMapReady(GoogleMap googleMap) { 
    map = googleMap; 
    map.setOnCameraIdleListener(this); 
    // other initialization stuff 
} 

@Override 
public void onCameraIdle() { 
    /* 
     Here camera is ready and you can operate with it. 
     you can use 2 approaches here: 

     1. Update the map with data you need to display and then set 
     map.setOnCameraIdleListener(null) to ensure that further events 
     will not call unnecessary callback again. 

     2. Use local boolean variable which indicates that content on map 
     should be updated 
    */ 
} 

Answer 16

मैं दो कॉलबैक संयोजित करने का उपाय बना लिया है: एक ही नमूदार में onMapReady और onGlobalLayout जो केवल जब दोनों उत्सर्जित करेगा घटनाओं को ट्रिगर किया गया है।

https://gist.github.com/abhaysood/e275b3d0937f297980d14b439a8e0d4a