Android 将用户位置定义为起始点映射框

我目前正在尝试使用mapbox导航

我所做的：

• 定义点列表
• 计算优化行程
• 使用位置引擎获取用户位置
• 在导航ui参数上传递优化的路线

我的问题是：如何将起点定义为定位引擎

你知道怎么做吗

我的代码：

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

    // Initialize list of Position objects and add the origin Position to the list


    mFusedLocationClient = LocationServices.getFusedLocationProviderClient(this);

    if (ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED && ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
        // TODO: Consider calling
        //    ActivityCompat#requestPermissions
        // here to request the missing permissions, and then overriding
        //   public void onRequestPermissionsResult(int requestCode, String[] permissions,
        //                                          int[] grantResults)
        // to handle the case where the user grants the permission. See the documentation
        // for ActivityCompat#requestPermissions for more details.
        return;
    }


    mFusedLocationClient.getLastLocation()
            .addOnSuccessListener(this, new OnSuccessListener<Location>() {
                @Override
                public void onSuccess(Location location) {
                    // Got last known location. In some rare situations this can be null.
                    if (location != null) {
                       location.getLatitude();
                       location.getLongitude();

                    }
                }
            });


    // Setup the MapView
    mapView = (MapView) findViewById(R.id.mapView);
    mapView.onCreate(savedInstanceState);
    mapView.getMapAsync(new OnMapReadyCallback() {


        @Override
        public void onMapReady(MapboxMap mapboxMap) {
            map = mapboxMap;
            // Add origin and destination to the map

            getOptimizedRoute(stops);
            enableLocationPlugin();
            button = findViewById(R.id.startButton);
            button.setOnClickListener(new View.OnClickListener() {
                public void onClick(View v) {

                    // Pass in your Amazon Polly pool id for speech synthesis using Amazon Polly
                    // Set to null to use the default Android speech synthesizer
                    String awsPoolId = null;

                    boolean simulateRoute = true;

                    NavigationLauncher.startNavigation(OptimizationRound.this, optimizedRoute, null, false);

                    DirectionsRoute  op=optimizedRoute;

                    Log.i("te","d"+op);


                }
            });
        }
    });
}



private boolean alreadyTwelveMarkersOnMap() {
    if (stops.size() == 12) {
        return true;
    } else {
        return false;
    }
}




private void addDestinationMarker() {
    map.addMarker(new MarkerOptions()
            .position(new LatLng(48.85661, 2.3522199999999884))
            .title("ajout d'un marker"));



    map.addMarker(new MarkerOptions()
            .position(new LatLng(48.863837885793835, 2.3865522753906134))
            .title("ajout d'un marker"));


}

private void addPointToStopsList() {
    List tripStops = new ArrayList<>();
    tripStops.add(Position.fromCoordinates(2.3522199999999884, 48.85661));
    tripStops.add(Position.fromCoordinates(2.3865522753906134, 48.863837885793835));
    ;


}


private DirectionsRoute getOptimizedRoute(List<Position> coordinates) {
    addDestinationMarker();
    List tripStops = new ArrayList<>();


    tripStops.add(Position.fromCoordinates(2.3522199999999884, 48.85661));
    tripStops.add(Position.fromCoordinates(2.3865522753906134, 48.863837885793835));


    optimizedClient = new MapboxOptimizedTrips.Builder()
            .setSource(FIRST)
            .setDestination(ANY)
            .setCoordinates(tripStops)
            .setOverview(DirectionsCriteria.OVERVIEW_FULL)
            .setProfile(DirectionsCriteria.PROFILE_DRIVING)
            .setAccessToken(Mapbox.getAccessToken())
            .build();

    optimizedClient.enqueueCall(new Callback<OptimizedTripsResponse>() {
        @Override
        public void onResponse(Call<OptimizedTripsResponse> call, Response<OptimizedTripsResponse> response) {
            if (!response.isSuccessful()) {
                Log.d("DirectionsActivity", "no succes");
                Toast.makeText(OptimizationRound.this, 't', Toast.LENGTH_SHORT).show();
                return;
            } else {
                if (response.body().getTrips().isEmpty()) {
                    Log.d("DirectionsActivity", "impossible de detrminer l'itineraire" + " size = "
                            + response.body().getTrips().size());
                    Toast.makeText(OptimizationRound.this, "route ok",
                            Toast.LENGTH_SHORT).show();
                    return;
                }
            }

            // Get most optimized route from API response
            optimizedRoute = response.body().getTrips().get(0);
            drawOptimizedRoute(optimizedRoute);
        }

        @Override
        public void onFailure(Call<OptimizedTripsResponse> call, Throwable throwable) {
            Log.d("DirectionsActivity", "Error: " + throwable.getMessage());
        }
    });
    return null;
}

private void drawOptimizedRoute(DirectionsRoute route) {
    // Remove old polyline
    if (optimizedPolyline != null) {
        map.removePolyline(optimizedPolyline);
    }
    // Draw points on MapView
    LatLng[] pointsToDraw = convertLineStringToLatLng(route);
    optimizedPolyline = map.addPolyline(new PolylineOptions()
            .add(pointsToDraw)
            .color(Color.parseColor(TEAL_COLOR))
            .width(POLYLINE_WIDTH));
}

private LatLng[] convertLineStringToLatLng(DirectionsRoute route) {
    // Convert LineString coordinates into LatLng[]
    LineString lineString = LineString.fromPolyline(route.getGeometry(), PRECISION_6);
    List<Position> coordinates = lineString.getCoordinates();
    LatLng[] points = new LatLng[coordinates.size()];
    for (int i = 0; i < coordinates.size(); i++) {
        points[i] = new LatLng(
                coordinates.get(i).getLatitude(),
                coordinates.get(i).getLongitude());
    }
    return points;
}


@SuppressWarnings( {"MissingPermission"})
private void enableLocationPlugin() {
    // Check if permissions are enabled and if not request
    if (PermissionsManager.areLocationPermissionsGranted(this)) {
        // Create an instance of LOST location engine
        initializeLocationEngine();

        locationPlugin = new LocationLayerPlugin(mapView, map, locationEngine);
        locationPlugin.setLocationLayerEnabled(LocationLayerMode.TRACKING);
    } else {
        permissionsManager = new PermissionsManager(this);
        permissionsManager.requestLocationPermissions(this);
    }
}

@SuppressWarnings( {"MissingPermission"})
private void initializeLocationEngine() {
    locationEngine = new LostLocationEngine(OptimizationRound.this);
    locationEngine.setPriority(LocationEnginePriority.HIGH_ACCURACY);
    locationEngine.activate();

    Location lastLocation = locationEngine.getLastLocation();
    if (lastLocation != null) {
        originLocation = lastLocation;
        setCameraPosition(lastLocation);
    } else {
        locationEngine.addLocationEngineListener(this);
    }
}

private void setCameraPosition(Location location) {
    map.animateCamera(CameraUpdateFactory.newLatLngZoom(
            new LatLng(location.getLatitude(), location.getLongitude()), 13));
}

@Override
public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
    permissionsManager.onRequestPermissionsResult(requestCode, permissions, grantResults);
}

@Override
public void onExplanationNeeded(List<String> permissionsToExplain) {

}

@Override
public void onPermissionResult(boolean granted) {
    if (granted) {
        enableLocationPlugin();
    } else {
        finish();
    }
}

@Override
@SuppressWarnings( {"MissingPermission"})
public void onConnected() {
    locationEngine.requestLocationUpdates();
}

@Override
public void onLocationChanged(Location location) {
    if (location != null) {
        originLocation = location;
        setCameraPosition(location);
        locationEngine.removeLocationEngineListener(this);
    }
}

@Override
@SuppressWarnings( {"MissingPermission"})
protected void onStart() {
    super.onStart();
    if (locationEngine != null) {
        locationEngine.requestLocationUpdates();
    }
    if (locationPlugin != null) {
        locationPlugin.onStart();
    }
    mapView.onStart();
}

@Override
protected void onStop() {
    super.onStop();
    if (locationEngine != null) {
        locationEngine.removeLocationUpdates();
    }
    if (locationPlugin != null) {
        locationPlugin.onStop();
    }
    mapView.onStop();
}

@Override
protected void onDestroy() {
    super.onDestroy();
    mapView.onDestroy();
    if (locationEngine != null) {
        locationEngine.deactivate();
    }
}

@Override
public void onLowMemory() {
    super.onLowMemory();
    mapView.onLowMemory();
}

@Override
protected void onResume() {
    super.onResume();
    mapView.onResume();
}

@Override
protected void onPause() {
    super.onPause();
    mapView.onPause();
}

@Override
protected void onSaveInstanceState(Bundle outState) {
    super.onSaveInstanceState(outState);
    mapView.onSaveInstanceState(outState);
}

@覆盖
创建时受保护的void（Bundle savedInstanceState）{
super.onCreate（savedInstanceState）；
//此处配置了Mapbox访问令牌。这需要在应用程序中调用
//对象或位于包含mapview的同一活动中。
getInstance（这个，getString（R.string.access_令牌））；
//它包含XML格式的MapView，需要在配置访问令牌后调用。
setContentView（R.layout.activity_测试）；
//初始化位置对象列表并将原点位置添加到列表中
mFusedLocationClient=LocationServices.getFusedLocationProviderClient（此）；
if（ActivityCompat.checkSelfPermission（this，Manifest.permission.ACCESS\u FINE\u LOCATION）！=PackageManager.permission\u已授予和&ActivityCompat.checkSelfPermission（this，Manifest.permission.ACCESS\u LOCATION）！=PackageManager.permission\u已授予）{
考虑到呼叫
//ActivityCompat#请求权限
//在此处请求缺少的权限，然后覆盖
//public void onRequestPermissionsResult（int-requestCode，字符串[]权限，
//int[]格兰特结果）
//处理用户授予权限的情况。请参阅文档
//对于ActivityCompat，请请求权限以获取更多详细信息。
返回；
}
mFusedLocationClient.getLastLocation（）文件
.addOnSuccessListener（此，新的OnSuccessListener（）{
@凌驾
成功时的公共无效（位置）{
//已获取最后一个已知位置。在某些罕见情况下，此值可以为空。
如果（位置！=null）{
location.getLatitude（）；
location.getLongitude（）；
}
}
});
//设置地图视图
mapView=（mapView）findViewById（R.id.mapView）；
onCreate（savedInstanceState）；
getMapAsync（新的OnMapReadyCallback（）{
@凌驾
mapready上的公共无效（MapboxMap MapboxMap）{
map=mapboxMap；
//将起点和终点添加到地图
GetDurote（停止）；
enableLocationPlugin（）；
按钮=findViewById（R.id.startButton）；
setOnClickListener（新视图.OnClickListener（）{
公共void onClick（视图v）{
//使用Amazon Polly将Amazon Polly池id传递给语音合成
//设置为null以使用默认的Android语音合成器
字符串awsPoolId=null；
布尔模拟器输出=真；
NavigationLauncher.startNavigation（OptimizationRound.this，OptimizationDurote，null，false）；
方向路线op=最佳路线；
日志i（“te”、“d”+op）；
}
});
}
});
}
私有布尔值alreadyTwelveMarkersOnMap（）{
if（stops.size（）==12）{
返回true；
}否则{
返回false；
}
}
私有void addDestinationMarker（）{
addMarker（新的MarkerOptions（）
.位置（新车床（48.85661,2.35221999999884））
.标题（“ajout d'un marker”）；
addMarker（新的MarkerOptions（）
.位置（新车床（48.863837885793835，2.3865522753906134））
.标题（“ajout d'un marker”）；
}
私有void addPointToStopsList（）{
List tripStops=new ArrayList（）；
tripStops.add（位置.来自坐标（2.35221999999884,48.85661））；
tripStops.add（位置.来自坐标（2.3865522753906134,48.863837885793835））；
;
}
专用方向路由GetOptimizedLote（列表坐标）{
addDestinationMarker（）；
List tripStops=new ArrayList（）；
tripStops.add（位置.来自坐标（2.35221999999884,48.85661））；
tripStops.add（位置.来自坐标（2.3865522753906134,48.863837885793835））；
optimizedClient=new MapboxOptimizedTrips.Builder（）
.setSource（第一个）
.setDestination（任何）
.SET坐标（tripStops）
.setOverview（方向标准.OVERVIEW_FULL）
.setProfile（方向标准.PROFILE\U驱动）
.setAccessToken（Mapbox.getAccessToken（））
.build（）；
optimizedClient.enqueueCall（新回调（）{
@凌驾
公共void onResponse（调用、响应）{
如果（！response.issusccessful（））{
日志d（“指导活动”，“无成功”）；
Toast.makeText（OptimizationRound.this't'，Toast.LENGTH_SHORT.show（）；
返回；
}否则{
if（response.body（）.getTrips（）.isEmpty（））{
Log.d（“DirectionsActivity”，“不可能取消行程”+“size=”
+response.body（）.getTrips（）.size（））；
Toast.makeText（OptimizationRound.this，“路由确定”，
吐司。长度（短）。show（）；
返回；
}
}
//从API响应获取最优化的路由
OptimizedLote=response.body（）.getTrips（）.get（0）；
德鲁米特（德鲁米特）；
}
@凌驾
失败时公共无效（调用、可丢弃）{
Log.d（“DirectionsActivity”，“错误：+throwable.getMessage（））；
}
});
返回null；
}
专用空心电缆（DirectionsRoute）{
//除去