moveCamera mit CameraUpdateFactory.newLatLngBounds stürzt ab

Ich benutze die neue Android Google Maps API .

Ich erstelle eine Aktivität, die ein MapFragment enthält. In der Aktivität onResumesetze ich die Markierungen in das GoogleMap-Objekt und definiere dann einen Begrenzungsrahmen für die Karte, der alle Markierungen enthält.

Dies verwendet den folgenden Pseudocode:

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

Der Aufruf von führt dazu, map.moveCamera()dass meine Anwendung mit dem folgenden Stapel abstürzt:

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)

Wenn - anstelle der newLatLngBounds()Factory-Methode die Methode verwendet newLatLngZoom()wird, tritt nicht dieselbe Falle auf.

Ist der onResumebeste Ort, um die Markierungen auf das GoogleMap-Objekt zu zeichnen, oder sollte ich die Markierungen zeichnen und die Kameraposition woanders einstellen?

Sie können die einfache newLatLngBounds- Methode in OnCameraChangeListener verwenden . Alles wird perfekt funktionieren und Sie müssen die Bildschirmgröße nicht berechnen. Dieses Ereignis tritt nach der Berechnung der Kartengröße auf (soweit ich weiß).

Beispiel:

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

Diese Antworten sind in Ordnung, aber ich würde einen anderen Ansatz wählen, einen einfacheren. Wenn die Methode erst funktioniert, nachdem die Karte angelegt wurde, warten Sie einfach darauf:

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

OK, ich habe das herausgefunden. Wie hier dokumentiert , kann die API nicht vor dem Layout verwendet werden.

Die richtige API wird wie folgt beschrieben:

Hinweis: Verwenden Sie die einfachere Methode newLatLngBounds (Grenze, Auffüllung) nur, um ein CameraUpdate zu generieren, wenn es zum Verschieben der Kamera verwendet werden soll, nachdem die Karte einem Layout unterzogen wurde. Während des Layouts berechnet die API die Anzeigegrenzen der Karte, die zum korrekten Projizieren des Begrenzungsrahmens erforderlich sind. Im Vergleich dazu können Sie das von der komplexeren Methode newLatLngBounds (Grenze, Breite, Höhe, Auffüllung) zurückgegebene CameraUpdate jederzeit verwenden, noch bevor die Karte einem Layout unterzogen wurde, da die API die Anzeigegrenzen aus den von Ihnen übergebenen Argumenten berechnet.

Um das Problem zu beheben, habe ich meine Bildschirmgröße berechnet und die Breite und Höhe angegeben

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

Dadurch konnte ich das Begrenzungsrahmen-Vorlayout festlegen.

Die Lösung ist einfacher als das ....

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

Fangen Sie IllegalStateExceptionstattdessen den globalen Listener für die Ansicht ab und verwenden Sie ihn. Wenn Sie die gebundene Größe im Voraus (Vorlayout) mit den anderen Methoden einstellen, müssen Sie die Größe von THE VIEW und nicht des Bildschirmgeräts berechnen. Sie stimmen nur überein, wenn Sie mit Ihrer Karte im Vollbildmodus arbeiten und keine Fragmente verwenden.

Dies ist mein Fix, warten Sie einfach, bis die Karte in diesem Fall geladen ist.

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

Das Hinzufügen und Entfernen von Markierungen kann vor Abschluss des Layouts erfolgen, das Bewegen der Kamera jedoch nicht (außer newLatLngBounds(boundary, padding)wie in der Antwort des OP angegeben).

Der wahrscheinlich beste Ort, um ein erstes Kamera-Update durchzuführen, ist die Verwendung einer einmaligen Aufnahme, OnGlobalLayoutListenerwie im Beispielcode von Google gezeigt. Beispiel: Siehe folgenden Auszug setUpMap()in MarkerDemoActivity.java :

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

Die akzeptierte Antwort würde für mich nicht funktionieren, da ich an verschiedenen Stellen meiner App denselben Code verwenden musste.

Anstatt darauf zu warten, dass sich die Kamera ändert, habe ich eine einfache Lösung erstellt, die auf Lees Vorschlag basiert, die Kartengröße anzugeben. Dies ist der Fall, wenn Ihre Karte die Größe des Bildschirms hat.

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

Hoffe es hilft jemand anderem!

Die akzeptierte Antwort ist, wie in den Kommentaren ausgeführt, etwas hackig. Nach der Implementierung habe ich eine überdurchschnittliche Anzahl von IllegalStateExceptionProtokollen in Analytics festgestellt . Die Lösung, die ich verwendet habe, besteht darin, eine hinzuzufügen, OnMapLoadedCallbackin der das ausgeführt CameraUpdatewird. Der Rückruf wird dem hinzugefügt GoogleMap. Nachdem Ihre Karte vollständig geladen wurde, wird das Kamera-Update durchgeführt.

Dies führt dazu, dass auf der Karte kurz die verkleinerte Ansicht (0,0) angezeigt wird, bevor die Kamera aktualisiert wird. Ich bin der Meinung, dass dies akzeptabler ist, als Abstürze zu verursachen oder sich auf undokumentiertes Verhalten zu verlassen.

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

Verwenden Sie dies, es hat für mich funktioniert

In sehr seltenen Fällen ist das MapView-Layout fertig, aber das GoogleMap-Layout ist noch nicht fertig. ViewTreeObserver.OnGlobalLayoutListenerDer Absturz kann selbst nicht gestoppt werden. Ich habe den Absturz mit der Google Play-Dienstpaketversion 5084032 gesehen. Dieser seltene Fall kann durch die dynamische Änderung der Sichtbarkeit meiner MapView verursacht werden.

Um dieses Problem zu lösen, habe ich eingebettet GoogleMap.OnMapLoadedCallbackin onGlobalLayout():

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

Ich habe einen anderen Ansatz verwendet, der für neuere Versionen von Google Maps SDK (9.6+) funktioniert und auf onCameraIdleListener basiert . Wie ich bisher sehe, wird die Rückrufmethode onCameraIdleimmer danach aufgerufen onMapReady. Mein Ansatz sieht also wie dieser Code aus (wenn man bedenkt, dass er eingegeben wurde 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
    */
}

Ich habe eine Möglichkeit geschaffen, die beiden Rückrufe zu kombinieren: onMapReady und onGlobalLayout in einem einzigen Observable, das nur ausgegeben wird, wenn beide Ereignisse ausgelöst wurden.

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

Ok, ich stehe vor dem gleichen Problem. Ich habe mein Fragment mit meiner SupportmapFragment-, ABS- und Navigationsschublade. Was ich getan habe war:

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...
}

Und, nebenbei bemerkt , ich rufe resetCamera()aus onCreateViewnach dem Aufblasen und vor der Rückkehr.
Dies fängt die Ausnahme beim ersten Mal ab (während die Karte "eine Größe bekommt", um es auszudrücken ...) und dann, wenn ich die Kamera zurücksetzen muss, hat die Karte bereits die Größe und führt sie durch Auffüllen aus.

Problem wird in erklärt Dokumentation , heißt es:

Ändern Sie die Kamera mit diesem Kamera-Update erst, wenn die Karte einem Layout unterzogen wurde (damit diese Methode den entsprechenden Begrenzungsrahmen und die Zoomstufe korrekt bestimmt, muss die Karte eine Größe haben). Andernfalls wird ein IllegalStateExceptionWurf geworfen. Es reicht NICHT aus, dass die Karte verfügbar ist (dh getMap()ein Nicht-Null-Objekt zurückgibt). Die Ansicht mit der Karte muss ebenfalls so gestaltet worden sein, dass ihre Abmessungen bestimmt wurden. Wenn Sie nicht sicher sind, ob dies geschehen ist, verwenden Sie newLatLngBounds(LatLngBounds, int, int, int)stattdessen und geben Sie die Abmessungen der Karte manuell an.

Ich denke, es ist eine ziemlich anständige Lösung. Hoffe es hilft jemandem.

Wenn Sie auf den Start möglicher Benutzerinteraktionen warten müssen, verwenden Sie diese OnMapLoadedCallbackwie in den vorherigen Antworten beschrieben. Wenn Sie jedoch nur einen Standardspeicherort für die Karte angeben müssen, ist keine der in diesen Antworten beschriebenen Lösungen erforderlich. Beide MapFragmentund MapViewkönnen einen GoogleMapOptionsStart akzeptieren , der den Standardspeicherort in Ordnung liefern kann. Der einzige Trick besteht darin, sie nicht direkt in Ihr Layout aufzunehmen, da das System sie dann ohne die Optionen aufruft, sondern sie dynamisch initialisiert.

Verwenden Sie dies in Ihrem Layout:

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

und ersetzen Sie das Fragment in Ihrem 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();

Abgesehen davon, dass der Start schneller ist, wird zuerst keine Weltkarte angezeigt und dann wird eine Kamera bewegt. Die Karte beginnt direkt mit dem angegebenen Ort.

Ein anderer Ansatz wäre ungefähr so: (Angenommen, Ihre oberste Ansicht ist ein FrameLayout mit dem Namen rootContainer, obwohl dies funktioniert, solange Sie immer Ihren obersten Container auswählen, unabhängig davon, welchen Typ oder Namen er hat):

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

Wenn Sie Ihre Kamerafunktionen so ändern, dass sie nur funktionieren, wenn dies der Fall layoutDoneist, truewerden alle Ihre Probleme gelöst, ohne dass dem layoutListenerHandler zusätzliche Funktionen hinzugefügt oder Logik verkabelt werden müssen.

Ich fand, dass dies funktioniert und einfacher ist als die anderen Lösungen:

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

Dadurch wird der Aufruf erneut ausgeführt, nachdem das Layout ausgeführt wurde. Könnte wahrscheinlich eine Sicherheit beinhalten, um eine Endlosschleife zu vermeiden.

Warum nicht einfach so etwas verwenden:

CameraUpdate cameraUpdate = CameraUpdateFactory.newLatLngBounds(builder.build(), padding);
try {
    map.moveCamera(cameraUpdate);
} catch (Exception e) {
    int width = getResources().getDisplayMetrics().widthPixels;
    int height = getResources().getDisplayMetrics().heightPixels;
    cameraUpdate = CameraUpdateFactory.newLatLngBounds(builder.build(), width, height, padding);
    map.moveCamera(cameraUpdate);
}

Im Google Maps-Repo gibt es eine Hilfsklasse, die Sie nutzen können. Sie wartet darauf, dass sowohl das Layout als auch die Karte fertig sind, bevor Sie einen Rückruf mit GoogleMap benachrichtigen:

Die Originalquelle ist hier:

https://github.com/googlemaps/android-samples/blob/7ee737b8fd6d39c77f8b3716ba948e1ce3730e61/ApiDemos/java/app/src/main/java/com/example/mapdemo/OnMapAndViewReady

Es gibt auch eine Kotlin-Implementierung:

https://github.com/googlemaps/android-samples/blob/master/ApiDemos/kotlin/app/src/main/java/com/example/kotlindemos/OnMapAndViewReadyListener.kt

public class OnMapAndViewReadyListener implements OnGlobalLayoutListener, OnMapReadyCallback {

/** A listener that needs to wait for both the GoogleMap and the View to be initialized. */
public interface OnGlobalLayoutAndMapReadyListener {
    void onMapReady(GoogleMap googleMap);
}

private final SupportMapFragment mapFragment;
private final View mapView;
private final OnGlobalLayoutAndMapReadyListener devCallback;

private boolean isViewReady;
private boolean isMapReady;
private GoogleMap googleMap;

public OnMapAndViewReadyListener(
        SupportMapFragment mapFragment, OnGlobalLayoutAndMapReadyListener devCallback) {
    this.mapFragment = mapFragment;
    mapView = mapFragment.getView();
    this.devCallback = devCallback;
    isViewReady = false;
    isMapReady = false;
    googleMap = null;

    registerListeners();
}

private void registerListeners() {
    // View layout.
    if ((mapView.getWidth() != 0) && (mapView.getHeight() != 0)) {
        // View has already completed layout.
        isViewReady = true;
    } else {
        // Map has not undergone layout, register a View observer.
        mapView.getViewTreeObserver().addOnGlobalLayoutListener(this);
    }

    // GoogleMap. Note if the GoogleMap is already ready it will still fire the callback later.
    mapFragment.getMapAsync(this);
}

@Override
public void onMapReady(GoogleMap googleMap) {
    // NOTE: The GoogleMap API specifies the listener is removed just prior to invocation.
    this.googleMap = googleMap;
    isMapReady = true;
    fireCallbackIfReady();
}

@SuppressWarnings("deprecation")  // We use the new method when supported
@SuppressLint("NewApi")  // We check which build version we are using.
@Override
public void onGlobalLayout() {
    // Remove our listener.
    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.JELLY_BEAN) {
        mapView.getViewTreeObserver().removeGlobalOnLayoutListener(this);
    } else {
        mapView.getViewTreeObserver().removeOnGlobalLayoutListener(this);
    }
    isViewReady = true;
    fireCallbackIfReady();
}

private void fireCallbackIfReady() {
    if (isViewReady && isMapReady) {
        devCallback.onMapReady(googleMap);
    }
}
}

Wie in OnCameraChangeListener () angegeben, ist es veraltet und setOnCameraChangeListenerjetzt veraltet. Sie sollten es also durch eine von drei Methoden ersetzen:

• GoogleMap.OnCameraMoveStartedListener
• GoogleMap.OnCameraMoveListener
• GoogleMap.OnCameraIdleListener

In meinem Fall habe ich es benutzt OnCameraIdleListenerund innen entfernt, weil es bei jeder Bewegung immer wieder aufgerufen wurde.

googleMap.setOnCameraIdleListener {
    googleMap.setOnCameraIdleListener(null) // It removes the listener.
    googleMap.moveCamera(track)
    googleMap.cameraPosition
    clusterManager!!.cluster()
    // Add another listener to make ClusterManager correctly zoom clusters and markers.
    googleMap.setOnCameraIdleListener(clusterManager)
}

AKTUALISIEREN

Ich habe googleMap.setOnCameraIdleListenerin meinem Projekt entfernt, weil es manchmal nicht aufgerufen wurde, wenn eine Karte angezeigt wurde, sondern beibehalten wurde googleMap.setOnCameraIdleListener(clusterManager).

Ich hatte den gleichen Fehler beim Versuch, mMap.animateCamera aufzurufen. Ich habe es gelöst, indem ich setOnMapLoadedCallback- Rückruf in meiner onMapReady- Funktion aufgerufen habe , wie unten gezeigt

public void onMapReady(GoogleMap googleMap) {
        mMap = googleMap;

   // other codes go there

    mMap.setOnMapLoadedCallback(() -> {
            //Your code where exception occurs goes here...
            
        });
}

Dies sollte gut funktionieren.