Primer paso de la investigacion. Se aportan el .apk, las carpetas con el apk extraido y el apk descompilado. El archivo API_DOCUMENTATION.md es un archivo donde se anotaran los descubrimientos del funcionamiento de la API, y los .py son scripts para probar la funcionalidad de la API con los métodos que vayamos encontrando. Finalmente, los archivos .js son scripts de Frida para extraer informacion de la APP durante la ejecucion.

apk_decompiled/sources/com/google/android/gms/maps/GoogleMap.java

@@ -0,0 +1,855 @@
+package com.google.android.gms.maps;
+
+import android.graphics.Bitmap;
+import android.location.Location;
+import android.os.RemoteException;
+import android.view.View;
+import com.google.android.gms.common.internal.Preconditions;
+import com.google.android.gms.dynamic.ObjectWrapper;
+import com.google.android.gms.maps.internal.IGoogleMapDelegate;
+import com.google.android.gms.maps.model.AdvancedMarker;
+import com.google.android.gms.maps.model.AdvancedMarkerOptions;
+import com.google.android.gms.maps.model.CameraPosition;
+import com.google.android.gms.maps.model.Circle;
+import com.google.android.gms.maps.model.CircleOptions;
+import com.google.android.gms.maps.model.GroundOverlay;
+import com.google.android.gms.maps.model.GroundOverlayOptions;
+import com.google.android.gms.maps.model.IndoorBuilding;
+import com.google.android.gms.maps.model.LatLng;
+import com.google.android.gms.maps.model.LatLngBounds;
+import com.google.android.gms.maps.model.MapCapabilities;
+import com.google.android.gms.maps.model.MapStyleOptions;
+import com.google.android.gms.maps.model.Marker;
+import com.google.android.gms.maps.model.MarkerOptions;
+import com.google.android.gms.maps.model.PointOfInterest;
+import com.google.android.gms.maps.model.Polygon;
+import com.google.android.gms.maps.model.PolygonOptions;
+import com.google.android.gms.maps.model.Polyline;
+import com.google.android.gms.maps.model.PolylineOptions;
+import com.google.android.gms.maps.model.RuntimeRemoteException;
+import com.google.android.gms.maps.model.TileOverlay;
+import com.google.android.gms.maps.model.TileOverlayOptions;
+import java.util.HashMap;
+import java.util.Map;
+
+/* loaded from: classes3.dex */
+public class GoogleMap {
+    public static final String DEMO_MAP_ID = "demo_map_id";
+    public static final int MAP_TYPE_HYBRID = 4;
+    public static final int MAP_TYPE_NONE = 0;
+    public static final int MAP_TYPE_NORMAL = 1;
+    public static final int MAP_TYPE_SATELLITE = 2;
+    public static final int MAP_TYPE_TERRAIN = 3;
+    private final IGoogleMapDelegate zza;
+    private MapCapabilities zzb;
+    private final Map zzc = new HashMap();
+    private final Map zzd = new HashMap();
+    private UiSettings zze;
+
+    /* loaded from: classes3.dex */
+    public interface CancelableCallback {
+        void onCancel();
+
+        void onFinish();
+    }
+
+    /* loaded from: classes3.dex */
+    public interface InfoWindowAdapter {
+        View getInfoContents(Marker marker);
+
+        View getInfoWindow(Marker marker);
+    }
+
+    @Deprecated
+    /* loaded from: classes3.dex */
+    public interface OnCameraChangeListener {
+        void onCameraChange(CameraPosition cameraPosition);
+    }
+
+    /* loaded from: classes3.dex */
+    public interface OnCameraIdleListener {
+        void onCameraIdle();
+    }
+
+    /* loaded from: classes3.dex */
+    public interface OnCameraMoveCanceledListener {
+        void onCameraMoveCanceled();
+    }
+
+    /* loaded from: classes3.dex */
+    public interface OnCameraMoveListener {
+        void onCameraMove();
+    }
+
+    /* loaded from: classes3.dex */
+    public interface OnCameraMoveStartedListener {
+        public static final int REASON_API_ANIMATION = 2;
+        public static final int REASON_DEVELOPER_ANIMATION = 3;
+        public static final int REASON_GESTURE = 1;
+
+        void onCameraMoveStarted(int i);
+    }
+
+    /* loaded from: classes3.dex */
+    public interface OnCircleClickListener {
+        void onCircleClick(Circle circle);
+    }
+
+    /* loaded from: classes3.dex */
+    public interface OnGroundOverlayClickListener {
+        void onGroundOverlayClick(GroundOverlay groundOverlay);
+    }
+
+    /* loaded from: classes3.dex */
+    public interface OnIndoorStateChangeListener {
+        void onIndoorBuildingFocused();
+
+        void onIndoorLevelActivated(IndoorBuilding indoorBuilding);
+    }
+
+    /* loaded from: classes3.dex */
+    public interface OnInfoWindowClickListener {
+        void onInfoWindowClick(Marker marker);
+    }
+
+    /* loaded from: classes3.dex */
+    public interface OnInfoWindowCloseListener {
+        void onInfoWindowClose(Marker marker);
+    }
+
+    /* loaded from: classes3.dex */
+    public interface OnInfoWindowLongClickListener {
+        void onInfoWindowLongClick(Marker marker);
+    }
+
+    /* loaded from: classes3.dex */
+    public interface OnMapCapabilitiesChangedListener {
+        void onMapCapabilitiesChanged(MapCapabilities mapCapabilities);
+    }
+
+    /* loaded from: classes3.dex */
+    public interface OnMapClickListener {
+        void onMapClick(LatLng latLng);
+    }
+
+    /* loaded from: classes3.dex */
+    public interface OnMapLoadedCallback {
+        void onMapLoaded();
+    }
+
+    /* loaded from: classes3.dex */
+    public interface OnMapLongClickListener {
+        void onMapLongClick(LatLng latLng);
+    }
+
+    /* loaded from: classes3.dex */
+    public interface OnMarkerClickListener {
+        boolean onMarkerClick(Marker marker);
+    }
+
+    /* loaded from: classes3.dex */
+    public interface OnMarkerDragListener {
+        void onMarkerDrag(Marker marker);
+
+        void onMarkerDragEnd(Marker marker);
+
+        void onMarkerDragStart(Marker marker);
+    }
+
+    /* loaded from: classes3.dex */
+    public interface OnMyLocationButtonClickListener {
+        boolean onMyLocationButtonClick();
+    }
+
+    @Deprecated
+    /* loaded from: classes3.dex */
+    public interface OnMyLocationChangeListener {
+        void onMyLocationChange(Location location);
+    }
+
+    /* loaded from: classes3.dex */
+    public interface OnMyLocationClickListener {
+        void onMyLocationClick(Location location);
+    }
+
+    /* loaded from: classes3.dex */
+    public interface OnPoiClickListener {
+        void onPoiClick(PointOfInterest pointOfInterest);
+    }
+
+    /* loaded from: classes3.dex */
+    public interface OnPolygonClickListener {
+        void onPolygonClick(Polygon polygon);
+    }
+
+    /* loaded from: classes3.dex */
+    public interface OnPolylineClickListener {
+        void onPolylineClick(Polyline polyline);
+    }
+
+    /* loaded from: classes3.dex */
+    public interface SnapshotReadyCallback {
+        void onSnapshotReady(Bitmap bitmap);
+    }
+
+    public GoogleMap(IGoogleMapDelegate iGoogleMapDelegate) {
+        this.zza = (IGoogleMapDelegate) Preconditions.checkNotNull(iGoogleMapDelegate);
+    }
+
+    public final Circle addCircle(CircleOptions circleOptions) {
+        try {
+            Preconditions.checkNotNull(circleOptions, "CircleOptions must not be null.");
+            return new Circle(this.zza.addCircle(circleOptions));
+        } catch (RemoteException e4) {
+            throw new RuntimeRemoteException(e4);
+        }
+    }
+
+    public final GroundOverlay addGroundOverlay(GroundOverlayOptions groundOverlayOptions) {
+        try {
+            Preconditions.checkNotNull(groundOverlayOptions, "GroundOverlayOptions must not be null.");
+            com.google.android.gms.internal.maps.zzr addGroundOverlay = this.zza.addGroundOverlay(groundOverlayOptions);
+            if (addGroundOverlay != null) {
+                return new GroundOverlay(addGroundOverlay);
+            }
+            return null;
+        } catch (RemoteException e4) {
+            throw new RuntimeRemoteException(e4);
+        }
+    }
+
+    public final Marker addMarker(MarkerOptions markerOptions) {
+        if (markerOptions instanceof AdvancedMarkerOptions) {
+            markerOptions.zzf(1);
+        }
+        try {
+            Preconditions.checkNotNull(markerOptions, "MarkerOptions must not be null.");
+            com.google.android.gms.internal.maps.zzad addMarker = this.zza.addMarker(markerOptions);
+            if (addMarker != null) {
+                return markerOptions.zzb() == 1 ? new AdvancedMarker(addMarker) : new Marker(addMarker);
+            }
+            return null;
+        } catch (RemoteException e4) {
+            throw new RuntimeRemoteException(e4);
+        }
+    }
+
+    public final void addOnMapCapabilitiesChangedListener(OnMapCapabilitiesChangedListener onMapCapabilitiesChangedListener) {
+        try {
+            zzs zzsVar = new zzs(this, onMapCapabilitiesChangedListener);
+            this.zzc.put(onMapCapabilitiesChangedListener, zzsVar);
+            this.zza.addOnMapCapabilitiesChangedListener(zzsVar);
+        } catch (RemoteException e4) {
+            throw new RuntimeRemoteException(e4);
+        }
+    }
+
+    public final Polygon addPolygon(PolygonOptions polygonOptions) {
+        try {
+            Preconditions.checkNotNull(polygonOptions, "PolygonOptions must not be null");
+            return new Polygon(this.zza.addPolygon(polygonOptions));
+        } catch (RemoteException e4) {
+            throw new RuntimeRemoteException(e4);
+        }
+    }
+
+    public final Polyline addPolyline(PolylineOptions polylineOptions) {
+        try {
+            Preconditions.checkNotNull(polylineOptions, "PolylineOptions must not be null");
+            return new Polyline(this.zza.addPolyline(polylineOptions));
+        } catch (RemoteException e4) {
+            throw new RuntimeRemoteException(e4);
+        }
+    }
+
+    public final TileOverlay addTileOverlay(TileOverlayOptions tileOverlayOptions) {
+        try {
+            Preconditions.checkNotNull(tileOverlayOptions, "TileOverlayOptions must not be null.");
+            com.google.android.gms.internal.maps.zzam addTileOverlay = this.zza.addTileOverlay(tileOverlayOptions);
+            if (addTileOverlay != null) {
+                return new TileOverlay(addTileOverlay);
+            }
+            return null;
+        } catch (RemoteException e4) {
+            throw new RuntimeRemoteException(e4);
+        }
+    }
+
+    public final void animateCamera(CameraUpdate cameraUpdate) {
+        try {
+            Preconditions.checkNotNull(cameraUpdate, "CameraUpdate must not be null.");
+            this.zza.animateCamera(cameraUpdate.zza());
+        } catch (RemoteException e4) {
+            throw new RuntimeRemoteException(e4);
+        }
+    }
+
+    public final void clear() {
+        try {
+            this.zza.clear();
+        } catch (RemoteException e4) {
+            throw new RuntimeRemoteException(e4);
+        }
+    }
+
+    public final CameraPosition getCameraPosition() {
+        try {
+            return this.zza.getCameraPosition();
+        } catch (RemoteException e4) {
+            throw new RuntimeRemoteException(e4);
+        }
+    }
+
+    public IndoorBuilding getFocusedBuilding() {
+        try {
+            com.google.android.gms.internal.maps.zzu focusedBuilding = this.zza.getFocusedBuilding();
+            if (focusedBuilding != null) {
+                return new IndoorBuilding(focusedBuilding);
+            }
+            return null;
+        } catch (RemoteException e4) {
+            throw new RuntimeRemoteException(e4);
+        }
+    }
+
+    public MapCapabilities getMapCapabilities() {
+        if (this.zzb == null) {
+            try {
+                this.zzb = new MapCapabilities(this.zza.getMapCapabilities());
+            } catch (RemoteException e4) {
+                throw new RuntimeRemoteException(e4);
+            }
+        }
+        return this.zzb;
+    }
+
+    public final int getMapType() {
+        try {
+            return this.zza.getMapType();
+        } catch (RemoteException e4) {
+            throw new RuntimeRemoteException(e4);
+        }
+    }
+
+    public final float getMaxZoomLevel() {
+        try {
+            return this.zza.getMaxZoomLevel();
+        } catch (RemoteException e4) {
+            throw new RuntimeRemoteException(e4);
+        }
+    }
+
+    public final float getMinZoomLevel() {
+        try {
+            return this.zza.getMinZoomLevel();
+        } catch (RemoteException e4) {
+            throw new RuntimeRemoteException(e4);
+        }
+    }
+
+    @Deprecated
+    public final Location getMyLocation() {
+        try {
+            return this.zza.getMyLocation();
+        } catch (RemoteException e4) {
+            throw new RuntimeRemoteException(e4);
+        }
+    }
+
+    public final Projection getProjection() {
+        try {
+            return new Projection(this.zza.getProjection());
+        } catch (RemoteException e4) {
+            throw new RuntimeRemoteException(e4);
+        }
+    }
+
+    public final UiSettings getUiSettings() {
+        try {
+            if (this.zze == null) {
+                this.zze = new UiSettings(this.zza.getUiSettings());
+            }
+            return this.zze;
+        } catch (RemoteException e4) {
+            throw new RuntimeRemoteException(e4);
+        }
+    }
+
+    public final boolean isBuildingsEnabled() {
+        try {
+            return this.zza.isBuildingsEnabled();
+        } catch (RemoteException e4) {
+            throw new RuntimeRemoteException(e4);
+        }
+    }
+
+    public final boolean isIndoorEnabled() {
+        try {
+            return this.zza.isIndoorEnabled();
+        } catch (RemoteException e4) {
+            throw new RuntimeRemoteException(e4);
+        }
+    }
+
+    public final boolean isMyLocationEnabled() {
+        try {
+            return this.zza.isMyLocationEnabled();
+        } catch (RemoteException e4) {
+            throw new RuntimeRemoteException(e4);
+        }
+    }
+
+    public final boolean isTrafficEnabled() {
+        try {
+            return this.zza.isTrafficEnabled();
+        } catch (RemoteException e4) {
+            throw new RuntimeRemoteException(e4);
+        }
+    }
+
+    public final void moveCamera(CameraUpdate cameraUpdate) {
+        try {
+            Preconditions.checkNotNull(cameraUpdate, "CameraUpdate must not be null.");
+            this.zza.moveCamera(cameraUpdate.zza());
+        } catch (RemoteException e4) {
+            throw new RuntimeRemoteException(e4);
+        }
+    }
+
+    public final void removeOnMapCapabilitiesChangedListener(OnMapCapabilitiesChangedListener onMapCapabilitiesChangedListener) {
+        try {
+            if (this.zzc.containsKey(onMapCapabilitiesChangedListener)) {
+                this.zza.removeOnMapCapabilitiesChangedListener((com.google.android.gms.maps.internal.zzal) this.zzc.get(onMapCapabilitiesChangedListener));
+                this.zzc.remove(onMapCapabilitiesChangedListener);
+            }
+        } catch (RemoteException e4) {
+            throw new RuntimeRemoteException(e4);
+        }
+    }
+
+    public void resetMinMaxZoomPreference() {
+        try {
+            this.zza.resetMinMaxZoomPreference();
+        } catch (RemoteException e4) {
+            throw new RuntimeRemoteException(e4);
+        }
+    }
+
+    public final void setBuildingsEnabled(boolean z3) {
+        try {
+            this.zza.setBuildingsEnabled(z3);
+        } catch (RemoteException e4) {
+            throw new RuntimeRemoteException(e4);
+        }
+    }
+
+    public final void setContentDescription(String str) {
+        try {
+            this.zza.setContentDescription(str);
+        } catch (RemoteException e4) {
+            throw new RuntimeRemoteException(e4);
+        }
+    }
+
+    public final boolean setIndoorEnabled(boolean z3) {
+        try {
+            return this.zza.setIndoorEnabled(z3);
+        } catch (RemoteException e4) {
+            throw new RuntimeRemoteException(e4);
+        }
+    }
+
+    public final void setInfoWindowAdapter(InfoWindowAdapter infoWindowAdapter) {
+        try {
+            if (infoWindowAdapter == null) {
+                this.zza.setInfoWindowAdapter(null);
+            } else {
+                this.zza.setInfoWindowAdapter(new zzf(this, infoWindowAdapter));
+            }
+        } catch (RemoteException e4) {
+            throw new RuntimeRemoteException(e4);
+        }
+    }
+
+    public void setLatLngBoundsForCameraTarget(LatLngBounds latLngBounds) {
+        try {
+            this.zza.setLatLngBoundsForCameraTarget(latLngBounds);
+        } catch (RemoteException e4) {
+            throw new RuntimeRemoteException(e4);
+        }
+    }
+
+    public final void setLocationSource(LocationSource locationSource) {
+        try {
+            if (locationSource == null) {
+                this.zza.setLocationSource(null);
+            } else {
+                this.zza.setLocationSource(new zzt(this, locationSource));
+            }
+        } catch (RemoteException e4) {
+            throw new RuntimeRemoteException(e4);
+        }
+    }
+
+    public boolean setMapStyle(MapStyleOptions mapStyleOptions) {
+        try {
+            return this.zza.setMapStyle(mapStyleOptions);
+        } catch (RemoteException e4) {
+            throw new RuntimeRemoteException(e4);
+        }
+    }
+
+    public final void setMapType(int i) {
+        try {
+            this.zza.setMapType(i);
+        } catch (RemoteException e4) {
+            throw new RuntimeRemoteException(e4);
+        }
+    }
+
+    public void setMaxZoomPreference(float f2) {
+        try {
+            this.zza.setMaxZoomPreference(f2);
+        } catch (RemoteException e4) {
+            throw new RuntimeRemoteException(e4);
+        }
+    }
+
+    public void setMinZoomPreference(float f2) {
+        try {
+            this.zza.setMinZoomPreference(f2);
+        } catch (RemoteException e4) {
+            throw new RuntimeRemoteException(e4);
+        }
+    }
+
+    public final void setMyLocationEnabled(boolean z3) {
+        try {
+            this.zza.setMyLocationEnabled(z3);
+        } catch (RemoteException e4) {
+            throw new RuntimeRemoteException(e4);
+        }
+    }
+
+    @Deprecated
+    public final void setOnCameraChangeListener(OnCameraChangeListener onCameraChangeListener) {
+        try {
+            if (onCameraChangeListener == null) {
+                this.zza.setOnCameraChangeListener(null);
+            } else {
+                this.zza.setOnCameraChangeListener(new zzu(this, onCameraChangeListener));
+            }
+        } catch (RemoteException e4) {
+            throw new RuntimeRemoteException(e4);
+        }
+    }
+
+    public final void setOnCameraIdleListener(OnCameraIdleListener onCameraIdleListener) {
+        try {
+            if (onCameraIdleListener == null) {
+                this.zza.setOnCameraIdleListener(null);
+            } else {
+                this.zza.setOnCameraIdleListener(new zzy(this, onCameraIdleListener));
+            }
+        } catch (RemoteException e4) {
+            throw new RuntimeRemoteException(e4);
+        }
+    }
+
+    public final void setOnCameraMoveCanceledListener(OnCameraMoveCanceledListener onCameraMoveCanceledListener) {
+        try {
+            if (onCameraMoveCanceledListener == null) {
+                this.zza.setOnCameraMoveCanceledListener(null);
+            } else {
+                this.zza.setOnCameraMoveCanceledListener(new zzx(this, onCameraMoveCanceledListener));
+            }
+        } catch (RemoteException e4) {
+            throw new RuntimeRemoteException(e4);
+        }
+    }
+
+    public final void setOnCameraMoveListener(OnCameraMoveListener onCameraMoveListener) {
+        try {
+            if (onCameraMoveListener == null) {
+                this.zza.setOnCameraMoveListener(null);
+            } else {
+                this.zza.setOnCameraMoveListener(new zzw(this, onCameraMoveListener));
+            }
+        } catch (RemoteException e4) {
+            throw new RuntimeRemoteException(e4);
+        }
+    }
+
+    public final void setOnCameraMoveStartedListener(OnCameraMoveStartedListener onCameraMoveStartedListener) {
+        try {
+            if (onCameraMoveStartedListener == null) {
+                this.zza.setOnCameraMoveStartedListener(null);
+            } else {
+                this.zza.setOnCameraMoveStartedListener(new zzv(this, onCameraMoveStartedListener));
+            }
+        } catch (RemoteException e4) {
+            throw new RuntimeRemoteException(e4);
+        }
+    }
+
+    public final void setOnCircleClickListener(OnCircleClickListener onCircleClickListener) {
+        try {
+            if (onCircleClickListener == null) {
+                this.zza.setOnCircleClickListener(null);
+            } else {
+                this.zza.setOnCircleClickListener(new zzn(this, onCircleClickListener));
+            }
+        } catch (RemoteException e4) {
+            throw new RuntimeRemoteException(e4);
+        }
+    }
+
+    public final void setOnGroundOverlayClickListener(OnGroundOverlayClickListener onGroundOverlayClickListener) {
+        try {
+            if (onGroundOverlayClickListener == null) {
+                this.zza.setOnGroundOverlayClickListener(null);
+            } else {
+                this.zza.setOnGroundOverlayClickListener(new zzm(this, onGroundOverlayClickListener));
+            }
+        } catch (RemoteException e4) {
+            throw new RuntimeRemoteException(e4);
+        }
+    }
+
+    public final void setOnIndoorStateChangeListener(OnIndoorStateChangeListener onIndoorStateChangeListener) {
+        try {
+            if (onIndoorStateChangeListener == null) {
+                this.zza.setOnIndoorStateChangeListener(null);
+            } else {
+                this.zza.setOnIndoorStateChangeListener(new zzk(this, onIndoorStateChangeListener));
+            }
+        } catch (RemoteException e4) {
+            throw new RuntimeRemoteException(e4);
+        }
+    }
+
+    public final void setOnInfoWindowClickListener(OnInfoWindowClickListener onInfoWindowClickListener) {
+        try {
+            if (onInfoWindowClickListener == null) {
+                this.zza.setOnInfoWindowClickListener(null);
+            } else {
+                this.zza.setOnInfoWindowClickListener(new zzc(this, onInfoWindowClickListener));
+            }
+        } catch (RemoteException e4) {
+            throw new RuntimeRemoteException(e4);
+        }
+    }
+
+    public final void setOnInfoWindowCloseListener(OnInfoWindowCloseListener onInfoWindowCloseListener) {
+        try {
+            if (onInfoWindowCloseListener == null) {
+                this.zza.setOnInfoWindowCloseListener(null);
+            } else {
+                this.zza.setOnInfoWindowCloseListener(new zze(this, onInfoWindowCloseListener));
+            }
+        } catch (RemoteException e4) {
+            throw new RuntimeRemoteException(e4);
+        }
+    }
+
+    public final void setOnInfoWindowLongClickListener(OnInfoWindowLongClickListener onInfoWindowLongClickListener) {
+        try {
+            if (onInfoWindowLongClickListener == null) {
+                this.zza.setOnInfoWindowLongClickListener(null);
+            } else {
+                this.zza.setOnInfoWindowLongClickListener(new zzd(this, onInfoWindowLongClickListener));
+            }
+        } catch (RemoteException e4) {
+            throw new RuntimeRemoteException(e4);
+        }
+    }
+
+    public final void setOnMapClickListener(OnMapClickListener onMapClickListener) {
+        try {
+            if (onMapClickListener == null) {
+                this.zza.setOnMapClickListener(null);
+            } else {
+                this.zza.setOnMapClickListener(new zzz(this, onMapClickListener));
+            }
+        } catch (RemoteException e4) {
+            throw new RuntimeRemoteException(e4);
+        }
+    }
+
+    public void setOnMapLoadedCallback(OnMapLoadedCallback onMapLoadedCallback) {
+        try {
+            if (onMapLoadedCallback == null) {
+                this.zza.setOnMapLoadedCallback(null);
+            } else {
+                this.zza.setOnMapLoadedCallback(new zzj(this, onMapLoadedCallback));
+            }
+        } catch (RemoteException e4) {
+            throw new RuntimeRemoteException(e4);
+        }
+    }
+
+    public final void setOnMapLongClickListener(OnMapLongClickListener onMapLongClickListener) {
+        try {
+            if (onMapLongClickListener == null) {
+                this.zza.setOnMapLongClickListener(null);
+            } else {
+                this.zza.setOnMapLongClickListener(new zzaa(this, onMapLongClickListener));
+            }
+        } catch (RemoteException e4) {
+            throw new RuntimeRemoteException(e4);
+        }
+    }
+
+    public final void setOnMarkerClickListener(OnMarkerClickListener onMarkerClickListener) {
+        try {
+            if (onMarkerClickListener == null) {
+                this.zza.setOnMarkerClickListener(null);
+            } else {
+                this.zza.setOnMarkerClickListener(new zza(this, onMarkerClickListener));
+            }
+        } catch (RemoteException e4) {
+            throw new RuntimeRemoteException(e4);
+        }
+    }
+
+    public final void setOnMarkerDragListener(OnMarkerDragListener onMarkerDragListener) {
+        try {
+            if (onMarkerDragListener == null) {
+                this.zza.setOnMarkerDragListener(null);
+            } else {
+                this.zza.setOnMarkerDragListener(new zzb(this, onMarkerDragListener));
+            }
+        } catch (RemoteException e4) {
+            throw new RuntimeRemoteException(e4);
+        }
+    }
+
+    public final void setOnMyLocationButtonClickListener(OnMyLocationButtonClickListener onMyLocationButtonClickListener) {
+        try {
+            if (onMyLocationButtonClickListener == null) {
+                this.zza.setOnMyLocationButtonClickListener(null);
+            } else {
+                this.zza.setOnMyLocationButtonClickListener(new zzh(this, onMyLocationButtonClickListener));
+            }
+        } catch (RemoteException e4) {
+            throw new RuntimeRemoteException(e4);
+        }
+    }
+
+    @Deprecated
+    public final void setOnMyLocationChangeListener(OnMyLocationChangeListener onMyLocationChangeListener) {
+        try {
+            if (onMyLocationChangeListener == null) {
+                this.zza.setOnMyLocationChangeListener(null);
+            } else {
+                this.zza.setOnMyLocationChangeListener(new zzg(this, onMyLocationChangeListener));
+            }
+        } catch (RemoteException e4) {
+            throw new RuntimeRemoteException(e4);
+        }
+    }
+
+    public final void setOnMyLocationClickListener(OnMyLocationClickListener onMyLocationClickListener) {
+        try {
+            if (onMyLocationClickListener == null) {
+                this.zza.setOnMyLocationClickListener(null);
+            } else {
+                this.zza.setOnMyLocationClickListener(new zzi(this, onMyLocationClickListener));
+            }
+        } catch (RemoteException e4) {
+            throw new RuntimeRemoteException(e4);
+        }
+    }
+
+    public final void setOnPoiClickListener(OnPoiClickListener onPoiClickListener) {
+        try {
+            if (onPoiClickListener == null) {
+                this.zza.setOnPoiClickListener(null);
+            } else {
+                this.zza.setOnPoiClickListener(new zzr(this, onPoiClickListener));
+            }
+        } catch (RemoteException e4) {
+            throw new RuntimeRemoteException(e4);
+        }
+    }
+
+    public final void setOnPolygonClickListener(OnPolygonClickListener onPolygonClickListener) {
+        try {
+            if (onPolygonClickListener == null) {
+                this.zza.setOnPolygonClickListener(null);
+            } else {
+                this.zza.setOnPolygonClickListener(new zzo(this, onPolygonClickListener));
+            }
+        } catch (RemoteException e4) {
+            throw new RuntimeRemoteException(e4);
+        }
+    }
+
+    public final void setOnPolylineClickListener(OnPolylineClickListener onPolylineClickListener) {
+        try {
+            if (onPolylineClickListener == null) {
+                this.zza.setOnPolylineClickListener(null);
+            } else {
+                this.zza.setOnPolylineClickListener(new zzp(this, onPolylineClickListener));
+            }
+        } catch (RemoteException e4) {
+            throw new RuntimeRemoteException(e4);
+        }
+    }
+
+    public final void setPadding(int i, int i4, int i5, int i6) {
+        try {
+            this.zza.setPadding(i, i4, i5, i6);
+        } catch (RemoteException e4) {
+            throw new RuntimeRemoteException(e4);
+        }
+    }
+
+    public final void setTrafficEnabled(boolean z3) {
+        try {
+            this.zza.setTrafficEnabled(z3);
+        } catch (RemoteException e4) {
+            throw new RuntimeRemoteException(e4);
+        }
+    }
+
+    public final void snapshot(SnapshotReadyCallback snapshotReadyCallback) {
+        Preconditions.checkNotNull(snapshotReadyCallback, "Callback must not be null.");
+        snapshot(snapshotReadyCallback, null);
+    }
+
+    public final void stopAnimation() {
+        try {
+            this.zza.stopAnimation();
+        } catch (RemoteException e4) {
+            throw new RuntimeRemoteException(e4);
+        }
+    }
+
+    public final void snapshot(SnapshotReadyCallback snapshotReadyCallback, Bitmap bitmap) {
+        Preconditions.checkNotNull(snapshotReadyCallback, "Callback must not be null.");
+        try {
+            this.zza.snapshot(new zzq(this, snapshotReadyCallback), (ObjectWrapper) (bitmap != null ? ObjectWrapper.wrap(bitmap) : null));
+        } catch (RemoteException e4) {
+            throw new RuntimeRemoteException(e4);
+        }
+    }
+
+    public final void animateCamera(CameraUpdate cameraUpdate, int i, CancelableCallback cancelableCallback) {
+        try {
+            Preconditions.checkNotNull(cameraUpdate, "CameraUpdate must not be null.");
+            this.zza.animateCameraWithDurationAndCallback(cameraUpdate.zza(), i, cancelableCallback == null ? null : new zzab(cancelableCallback));
+        } catch (RemoteException e4) {
+            throw new RuntimeRemoteException(e4);
+        }
+    }
+
+    public final void animateCamera(CameraUpdate cameraUpdate, CancelableCallback cancelableCallback) {
+        try {
+            Preconditions.checkNotNull(cameraUpdate, "CameraUpdate must not be null.");
+            this.zza.animateCameraWithCallback(cameraUpdate.zza(), cancelableCallback == null ? null : new zzab(cancelableCallback));
+        } catch (RemoteException e4) {
+            throw new RuntimeRemoteException(e4);
+        }
+    }
+}