import com.mapbox.mapboxsdk.camera.CameraUpdateFactory; //导入依赖的package包/类
@Override
public void onMapReady(final MapboxMap mapboxMap) {
  LocationEngine locationEngine = new LostLocationEngine(this);
  locationLayerPlugin = new LocationLayerPlugin(mapView, mapboxMap, locationEngine);
  locationLayerPlugin.setLocationLayerEnabled(LocationLayerMode.COMPASS);
  locationLayerPlugin.addCompassListener(new CompassListener() {
    @Override
    public void onCompassChanged(float userHeading) {
      CameraPosition cameraPosition = new CameraPosition.Builder().bearing(userHeading).build();
      mapboxMap.easeCamera(CameraUpdateFactory.newCameraPosition(cameraPosition));
    }

    @Override
    public void onCompassAccuracyChange(int compassStatus) {
      System.out.println(compassStatus);
    }
  });
}
 

import com.mapbox.mapboxsdk.camera.CameraUpdateFactory; //导入依赖的package包/类
private void updateMainMarker() {
    if (mMap != null && mPlace != null && mPlace.hasLocation()) {
        LatLng placeLocation = new LatLng(mPlace.getLocation().getLatitude(), mPlace.getLocation().getLongitude());
        if (mMainMarker == null) {
            mMainMarker = mMap.addMarker(new MarkerOptions()
                    .position(placeLocation)
                    .title(mPlace.getName()));
        } else {
            mMainMarker.setTitle(mPlace.getName() + "-updated");
            mMainMarker.setPosition(placeLocation);
            mMap.updateMarker(mMainMarker);
        }
        CameraUpdate cameraUpdate = CameraUpdateFactory.newLatLngZoom(placeLocation, MapFragment.DEFAULT_ZOOMLEVEL);
        mMap.moveCamera(cameraUpdate);
    }
}
 

import com.mapbox.mapboxsdk.camera.CameraUpdateFactory; //导入依赖的package包/类
public void recenterMap() {
    final Location l = gps.getLocation();

    // This shouldn't normally happen, but does on the Android emulator.
    // It only occurs if recenterMap is called before we receive our first
    // gps ping. We normally receive a ping within a second or two of app
    // launch, but *not* if the emulator only pings on demand.
    if( l == null )
        return;

    mapView.getMapAsync(new OnMapReadyCallback() {
        @Override
        public void onMapReady(MapboxMap mapboxMap) {
            // We'll maintain zoom level and tilt, just want to change position
            CameraPosition old = mapboxMap.getCameraPosition();
            CameraPosition pos = new CameraPosition.Builder()
                    .target(new LatLng(l.getLatitude(), l.getLongitude()))
                    .zoom(old.zoom)
                    .tilt(old.tilt)
                    .build();
            mapboxMap.moveCamera(CameraUpdateFactory.newCameraPosition(pos));
        }
    });
}
 

import com.mapbox.mapboxsdk.camera.CameraUpdateFactory; //导入依赖的package包/类
public void recenterCamera(View view) {
    mapView.getMapAsync(new OnMapReadyCallback() {
        @Override
        public void onMapReady(MapboxMap mapboxMap) {
            Location loc = gps.getLocation();
            if( loc == null )
                return;
            CameraPosition position = new CameraPosition.Builder()
                    .target(new LatLng(loc.getLatitude(), loc.getLongitude()))
                    .zoom(17)
                    .bearing(0)
                    .build();
            mapboxMap.animateCamera(CameraUpdateFactory.newCameraPosition(position), 3000);
        }
    });
}
 

import com.mapbox.mapboxsdk.camera.CameraUpdateFactory; //导入依赖的package包/类
@Override
public void onMyLocationChange(@Nullable Location location) {
    LatLng pos = new LatLng(location.getLatitude(), location.getLongitude());
    if (mLine != null) {
        mMap.removePolyline(mLine);
        mMap.animateCamera(CameraUpdateFactory.newLatLng(pos));
    } else {
        //zoom first time
        mMap.animateCamera(CameraUpdateFactory.newLatLngZoom(new LatLng(location.getLatitude(), location.getLongitude()), 15));
    }


    mLine = mMap.addPolyline(new PolylineOptions()
            .add(pos)
            .add(mKaabePos)
            .color(Color.parseColor("#3bb2d0"))
            .width(3));


}
 

import com.mapbox.mapboxsdk.camera.CameraUpdateFactory; //导入依赖的package包/类
@Override
public void onAnimationUpdate(ValueAnimator valueAnimator) {
    float animatedValue = (Float) valueAnimator.getAnimatedValue();
    int pixelToMove = (int) ((animatedValue - previousStep) * totalDist / 100);

    if (previousStep == 0) {
        Animation animation = new AlphaAnimation(0.0f, 1.0f);
        animation.setDuration(100);
        animation.setFillAfter(true);
        handImageView.startAnimation(animation);
    }
    if (animatedValue > STEPS_CENTER_ANIMATION / 2) {
        pixelToMove = -pixelToMove;
    }

    mapboxMap.moveCamera(CameraUpdateFactory.scrollBy(pixelToMove, 0));

    float left = handImageView.getX() + pixelToMove;
    handImageView.setX(left);


    previousStep = animatedValue;
}
 

import com.mapbox.mapboxsdk.camera.CameraUpdateFactory; //导入依赖的package包/类
@Override
public void onMapClick(@NonNull LatLng point) {

  // Toast instructing user to tap on the map
  Toast.makeText(
    AnimateMapCameraActivity.this,
    getString(R.string.tap_on_map_instruction),
    Toast.LENGTH_LONG
  ).show();

  CameraPosition position = new CameraPosition.Builder()
    .target(new LatLng(51.50550, -0.07520)) // Sets the new camera position
    .zoom(17) // Sets the zoom
    .bearing(180) // Rotate the camera
    .tilt(30) // Set the camera tilt
    .build(); // Creates a CameraPosition from the builder

  mapboxMap.animateCamera(CameraUpdateFactory
    .newCameraPosition(position), 7000);
}
 

import com.mapbox.mapboxsdk.camera.CameraUpdateFactory; //导入依赖的package包/类
@Override
public void onSensorChanged(SensorEvent event) {
  if (event.sensor.getType() == Sensor.TYPE_ACCELEROMETER) {
    gravityArray = event.values;
  }
  if (event.sensor.getType() == Sensor.TYPE_MAGNETIC_FIELD) {
    magneticArray = event.values;
  }
  if (gravityArray != null && magneticArray != null) {
    boolean success = SensorManager.getRotationMatrix(rotationMatrix, inclinationMatrix, gravityArray, magneticArray);
    if (success) {
      if (mapboxMap != null) {
        int mapCameraAnimationMillisecondsSpeed = 100;
        mapboxMap.animateCamera(CameraUpdateFactory
          .newCameraPosition(createNewCameraPosition()), mapCameraAnimationMillisecondsSpeed
        );
      }
    }
  }
}
 

import com.mapbox.mapboxsdk.camera.CameraUpdateFactory; //导入依赖的package包/类
@Override
protected void onCreate(Bundle savedInstanceState) {
  super.onCreate(savedInstanceState);

  // Mapbox access token is configured here. This needs to be called either in your application
  // object or in the same activity which contains the mapview.
  Mapbox.getInstance(this, getString(R.string.access_token));

  // This contains the MapView in XML and needs to be called after the access token is configured.
  setContentView(R.layout.activity_marker_clusters_plugin);

  mapView = (MapView) findViewById(R.id.mapView);
  mapView.onCreate(savedInstanceState);
  mapView.getMapAsync(new OnMapReadyCallback() {
    @Override
    public void onMapReady(MapboxMap mapboxMap) {
      MarkerClustersPluginActivity.this.mapboxMap = mapboxMap;
      mapboxMap.animateCamera(CameraUpdateFactory.newLatLngZoom(new LatLng(48.865539, 2.348603), 10.8),2800);

      // Initializing the cluster plugin
      clusterManagerPlugin = new ClusterManagerPlugin<>(MarkerClustersPluginActivity.this, mapboxMap);
      initCameraListener();
    }
  });
}
 

import com.mapbox.mapboxsdk.camera.CameraUpdateFactory; //导入依赖的package包/类
@Override
public void onMapMoved(final CameraPosition mainMapCameraPosition) {

  cameraPositionForFragmentMap = new CameraPosition.Builder()
    .target(mainMapCameraPosition.target)
    .zoom(mainMapCameraPosition.zoom - ZOOM_DISTANCE_BETWEEN_MAIN_AND_FRAGMENT_MAPS)
    .bearing(mainMapCameraPosition.bearing)
    .tilt(mainMapCameraPosition.tilt)
    .build();

  fragmentMap.getMapAsync(new OnMapReadyCallback() {
    @Override
    public void onMapReady(final MapboxMap mapInFragment) {
      mapInFragment.moveCamera(CameraUpdateFactory.newCameraPosition(cameraPositionForFragmentMap));
    }
  });
}
 

import com.mapbox.mapboxsdk.camera.CameraUpdateFactory; //导入依赖的package包/类
/**
 * Enables tracking and moves the camera to the last known location update
 * from the {@link ProgressChangeListener}.
 *
 * @since 0.6.0
 */
public void resetCameraPosition() {
  this.trackingEnabled = true;
  if (currentCameraPosition != null) {
    mapboxMap.easeCamera(CameraUpdateFactory.newCameraPosition(currentCameraPosition), 750, true);
  }
}
 

import com.mapbox.mapboxsdk.camera.CameraUpdateFactory; //导入依赖的package包/类
/**
 * Will animate the {@link MapboxMap} to the given {@link CameraPosition}
 * with a 2 second duration.
 * <p>
 * If a user interacts with the {@link MapboxMap} while the animation is in progress,
 * the animation will be cancelled.  So it's important to add the {@link ProgressChangeListener}
 * in both onCancel() and onFinish() scenarios.
 *
 * @param position to which the camera should animate
 */
private void animateCameraToPosition(CameraPosition position) {
  mapboxMap.animateCamera(CameraUpdateFactory.newCameraPosition(position), 2000,
    new MapboxMap.CancelableCallback() {
      @Override
      public void onCancel() {
        navigation.addProgressChangeListener(NavigationCamera.this);
      }

      @Override
      public void onFinish() {
        navigation.addProgressChangeListener(NavigationCamera.this);
      }
    });
}
 

import com.mapbox.mapboxsdk.camera.CameraUpdateFactory; //导入依赖的package包/类
@Override
public void onProgressChange(Location location, RouteProgress routeProgress) {
  if (tracking) {
    locationLayerPlugin.forceLocationUpdate(location);
    CameraPosition cameraPosition = new CameraPosition.Builder()
      .zoom(15)
      .target(new LatLng(location.getLatitude(), location.getLongitude()))
      .bearing(location.getBearing())
      .build();
    mapboxMap.animateCamera(CameraUpdateFactory.newCameraPosition(cameraPosition), 2000);
  }
}
 

import com.mapbox.mapboxsdk.camera.CameraUpdateFactory; //导入依赖的package包/类
private void newOrigin() {
  if (mapboxMap != null) {
    LatLng latLng = Utils.getRandomLatLng(new double[] {-77.1825, 38.7825, -76.9790, 39.0157});
    ((MockLocationEngine) locationEngine).setLastLocation(
      Point.fromLngLat(latLng.getLongitude(), latLng.getLatitude())
    );
    mapboxMap.moveCamera(CameraUpdateFactory.newLatLngZoom(latLng, 12));
    mapboxMap.setMyLocationEnabled(true);
    mapboxMap.getTrackingSettings().setMyLocationTrackingMode(MyLocationTracking.TRACKING_FOLLOW);
  }
}
 

import com.mapbox.mapboxsdk.camera.CameraUpdateFactory; //导入依赖的package包/类
@Override
public void onLocationChanged(Location location) {
    mCurrentLocation = location;

    mMapboxMap.moveCamera(CameraUpdateFactory.newLatLng(
            new LatLng(location.getLatitude(), location.getLongitude())
    ));
}
 

import com.mapbox.mapboxsdk.camera.CameraUpdateFactory; //导入依赖的package包/类
@Override
public void onMapReady(MapboxMap mapboxMap) {
  this.mapboxMap = mapboxMap;
  geoJsonPlugin = new GeoJsonPluginBuilder()
    .withContext(this)
    .withMap(mapboxMap)
    .withOnLoadingURL(this)
    .withOnLoadingFileAssets(this)
    .withOnLoadingFilePath(this)
    .withMarkerClickListener(this)
    .withRandomFillColor()
    .build();
  mapboxMap.moveCamera(CameraUpdateFactory.newLatLngZoom(new LatLng(32.6546, 51.6680), 7));

}
 

import com.mapbox.mapboxsdk.camera.CameraUpdateFactory; //导入依赖的package包/类
protected void startDemo() {
  mapboxMap.moveCamera(CameraUpdateFactory.newLatLngZoom(new LatLng(51.503186, -0.126446), 10));

  mClusterManagerPlugin = new ClusterManagerPlugin<>(this, mapboxMap);
  mapboxMap.setOnCameraIdleListener(mClusterManagerPlugin);

  try {
    readItems();
  } catch (JSONException exception) {
    Toast.makeText(this, "Problem reading list of markers.", Toast.LENGTH_LONG).show();
  }
}
 

import com.mapbox.mapboxsdk.camera.CameraUpdateFactory; //导入依赖的package包/类
private void setupUI(final OfflineTilePyramidRegionDefinition definition) {
  // update map
  mapView.getMapAsync(new OnMapReadyCallback() {
    @Override
    public void onMapReady(MapboxMap mapboxMap) {
      // correct style
      mapboxMap.setStyle(definition.getStyleURL());

      // position map on top of offline region
      CameraPosition cameraPosition = OfflineUtils.getCameraPosition(definition);
      mapboxMap.moveCamera(CameraUpdateFactory.newCameraPosition(cameraPosition));

      // restrict camera movement
      mapboxMap.setMinZoomPreference(definition.getMinZoom());
      mapboxMap.setMaxZoomPreference(definition.getMaxZoom());
      mapboxMap.setLatLngBoundsForCameraTarget(definition.getBounds());
    }
  });

  // update textview data
  nameView.setText(OfflineUtils.convertRegionName(offlineRegion.getMetadata()));
  styleView.setText(definition.getStyleURL());
  latLngBoundsView.setText(definition.getBounds().toString());
  minZoomView.setText(String.valueOf(definition.getMinZoom()));
  maxZoomView.setText(String.valueOf(definition.getMaxZoom()));
  offlineRegion.getStatus(offlineRegionStatusCallback);
}
 

import com.mapbox.mapboxsdk.camera.CameraUpdateFactory; //导入依赖的package包/类
private void moveToLocation(double latitude, double longitude, double zoomLevel) {
    if (mMap != null) {
        LatLng latLng = new LatLng(latitude, longitude);
        CameraUpdate update = CameraUpdateFactory.newLatLngZoom(latLng, zoomLevel);
        mMap.moveCamera(update);
    }
}
 

import com.mapbox.mapboxsdk.camera.CameraUpdateFactory; //导入依赖的package包/类
private void updateMap(double latitude, double longitude, boolean isOrigin) {
    if (routePolyLine != null) {
        map.removePolyline(routePolyLine);
    }
    if (!isOrigin) {
        if (markerDestination != null) {
            map.removeMarker(markerDestination);
        }
        markerDestination = map.addMarker(new MarkerOptions()
                .position(new LatLng(latitude, longitude)).title(getString(R.string.destination)));
        destination = Position.fromCoordinates(longitude, latitude);
        map.updateMarker(markerDestination);
    } else {
        if (markerOrigin != null) {
            map.removeMarker(markerOrigin);
        }
        markerOrigin = map.addMarker(new MarkerOptions()
                .position(new LatLng(latitude, longitude)).title(getString(R.string.origin)));
        origin = Position.fromCoordinates(longitude, latitude);
        map.updateMarker(markerOrigin);
    }

    CameraPosition cameraPosition = new CameraPosition.Builder()
            .target(new LatLng(latitude, longitude))
            .zoom(15)
            .build();
    map.animateCamera(CameraUpdateFactory.newCameraPosition(cameraPosition), 5000, null);
}