Navigation SDK v2 for Androidを試してみる (中身を見る編)

418         // initialize the location puck
419         binding.mapView.location.apply {
420             this.locationPuck = LocationPuck2D(
421                 bearingImage = ContextCompat.getDrawable(
422                     this@TurnByTurnExperienceActivity,
423                     R.drawable.mapbox_navigation_puck_icon
424                 )
425             )
426             setLocationProvider(navigationLocationProvider)
427             enabled = true
428         }

430         // initialize Mapbox Navigation
431         mapboxNavigation = if (MapboxNavigationProvider.isCreated()) {
432             MapboxNavigationProvider.retrieve()
433         } else {
434             MapboxNavigationProvider.create(
435                 NavigationOptions.Builder(this.applicationContext)
436                     .accessToken(getString(R.string.mapbox_access_token))
437                     // comment out the location engine setting block to disable simulation
438                     .locationEngine(replayLocationEngine)
439                     .build()
440             )
441         }

443         // initialize Navigation Camera
444         viewportDataSource = MapboxNavigationViewportDataSource(mapboxMap)
445         navigationCamera = NavigationCamera(
446             mapboxMap,
447             binding.mapView.camera,
448             viewportDataSource
449         )

480         // initialize maneuver api that feeds the data to the top banner maneuver view
481         maneuverApi = MapboxManeuverApi(
482             MapboxDistanceFormatter(distanceFormatterOptions)
483         )

485         // initialize bottom progress view
486         tripProgressApi = MapboxTripProgressApi(
487             TripProgressUpdateFormatter.Builder(this)
488                 .distanceRemainingFormatter(
489                     DistanceRemainingFormatter(distanceFormatterOptions)
490                 )
491                 .timeRemainingFormatter(
492                     TimeRemainingFormatter(this)
493                 )
494                 .percentRouteTraveledFormatter(
495                     PercentDistanceTraveledFormatter()
496                 )
497                 .estimatedTimeToArrivalFormatter(
498                     EstimatedTimeToArrivalFormatter(this, TimeFormat.NONE_SPECIFIED)
499                 )
500                 .build()
501         )

503         // initialize voice instructions api and the voice instruction player
504         speechApi = MapboxSpeechApi(
505             this,
506             getString(R.string.mapbox_access_token),
507             Locale.US.language
508         )
509         voiceInstructionsPlayer = MapboxVoiceInstructionsPlayer(
510             this,
511             getString(R.string.mapbox_access_token),
512             Locale.US.language
513         )

515         // initialize route line, the withRouteLineBelowLayerId is specified to place
516         // the route line below road labels layer on the map
517         // the value of this option will depend on the style that you are using
518         // and under which layer the route line should be placed on the map layers stack
519         val mapboxRouteLineOptions = MapboxRouteLineOptions.Builder(this)
520             .withRouteLineBelowLayerId("road-label")
521             .build()
522         routeLineApi = MapboxRouteLineApi(mapboxRouteLineOptions)
523         routeLineView = MapboxRouteLineView(mapboxRouteLineOptions)
524
525         // initialize maneuver arrow view to draw arrows on the map
526         val routeArrowOptions = RouteArrowOptions.Builder(this).build()
527         routeArrowView = MapboxRouteArrowView(routeArrowOptions)

560         // start the trip session to being receiving location updates in free drive
561         // and later when a route is set also receiving route progress updates
562         mapboxNavigation.startTripSession()

533             // add long click listener that search for a route to the clicked destination
534             binding.mapView.gestures.addOnMapLongClickListener { point ->
535                 findRoute(point)
536                 true
537             }

609     private fun findRoute(destination: Point) {
...
620         mapboxNavigation.requestRoutes(
621             RouteOptions.builder()
622                 .applyDefaultNavigationOptions()
623                 .applyLanguageAndVoiceUnitOptions(this)
624                 .coordinatesList(listOf(originPoint, destination))
625                 // provide the bearing for the origin of the request to ensure
626                 // that the returned route faces in the direction of the current user movement
627                 .bearingsList(
628                     listOf(
629                         Bearing.builder()
630                             .angle(originLocation.bearing.toDouble())
631                             .degrees(45.0)
632                             .build(),
633                         null
634                     )
635                 )
636                 .build(),
637             object : RouterCallback {
638                 override fun onRoutesReady(
639                     routes: List<DirectionsRoute>,
640                     routerOrigin: RouterOrigin
641                 ) {
642                     setRouteAndStartNavigation(routes)
643                 }
...

659     private fun setRouteAndStartNavigation(routes: List<DirectionsRoute>) {
660         // set routes, where the first route in the list is the primary route that
661         // will be used for active guidance
662         mapboxNavigation.setRoutes(routes)
...

659     private fun setRouteAndStartNavigation(routes: List<DirectionsRoute>) {
...
664         // start location simulation along the primary route
665         startSimulation(routes.first())
...
674     }
...
90     private fun startSimulation(route: DirectionsRoute) {
691         mapboxReplayer.run {
...
697             play()
698         }
699     }

    override fun replayEvents(replayEvents: List<ReplayEventBase>) {
        replayEvents.forEach { event ->
            when (event) {
                is ReplayEventUpdateLocation -> replayLocation(event)
            }
        }
    }
...
    private fun replayLocation(event: ReplayEventUpdateLocation) {
...

        registeredCallbacks.forEach { it.onSuccess(locationEngineResult) }
...
    }

    private fun updateRawLocation(rawLocation: Location) {
        if (state != TripSessionState.STARTED) return

        this.rawLocation = rawLocation
        locationObservers.forEach { it.onNewRawLocation(rawLocation) }
        mainJobController.scope.launch {
            navigator.updateLocation(rawLocation.toFixLocation())
        }
    }

    private fun updateLocationMatcherResult(locationMatcherResult: LocationMatcherResult) {
        this.locationMatcherResult = locationMatcherResult
        locationObservers.forEach { it.onNewLocationMatcherResult(locationMatcherResult) }
    }

565     override fun onStart() {
...
569         mapboxNavigation.registerRoutesObserver(routesObserver)

299     private val locationObserver = object : LocationObserver {
300         var firstLocationUpdateReceived = false
301
302         override fun onNewRawLocation(rawLocation: Location) {
303             // not handled
304         }
305
306         override fun onNewLocationMatcherResult(locationMatcherResult: LocationMatcherResult) {
307             val enhancedLocation = locationMatcherResult.enhancedLocation
308             // update location puck's position on the map
309             navigationLocationProvider.changePosition(
310                 location = enhancedLocation,
311                 keyPoints = locationMatcherResult.keyPoints,
312             )
313
314             // update camera position to account for new location
315             viewportDataSource.onLocationChanged(enhancedLocation)
316             viewportDataSource.evaluate()
317
318             // if this is the first location update the activity has received,
319             // it's best to immediately move the camera to the current user location
320             if (!firstLocationUpdateReceived) {
321                 firstLocationUpdateReceived = true
322                 navigationCamera.requestNavigationCameraToOverview(
323                     stateTransitionOptions = NavigationCameraTransitionOptions.Builder()
324                         .maxDuration(0) // instant transition
325                         .build()
326                 )
327             }
328         }
329     }

309             navigationLocationProvider.changePosition(
310                 location = enhancedLocation,
311                 keyPoints = locationMatcherResult.keyPoints,
312             )

315             viewportDataSource.onLocationChanged(enhancedLocation)
316             viewportDataSource.evaluate()

565     override fun onStart() {
...
570         mapboxNavigation.registerRouteProgressObserver(routeProgressObserver)
...

331     /**
332      * Gets notified with progress along the currently active route.
333      */
334     private val routeProgressObserver = RouteProgressObserver { routeProgress ->
335         // update the camera position to account for the progressed fragment of the route
336         viewportDataSource.onRouteProgressChanged(routeProgress)
337         viewportDataSource.evaluate()
338
339         // draw the upcoming maneuver arrow on the map
340         val style = mapboxMap.getStyle()
341         if (style != null) {
342             val maneuverArrowResult = routeArrowApi.addUpcomingManeuverArrow(routeProgress)
343             routeArrowView.renderManeuverUpdate(style, maneuverArrowResult)
344         }
345
346         // update top banner with maneuver instructions
347         val maneuvers = maneuverApi.getManeuvers(routeProgress)
348         maneuvers.fold(
349             { error ->
350                 Toast.makeText(
351                     this@TurnByTurnExperienceActivity,
352                     error.errorMessage,
353                     Toast.LENGTH_SHORT
354                 ).show()
355             },
356             {
357                 binding.maneuverView.visibility = View.VISIBLE
358                 binding.maneuverView.renderManeuvers(maneuvers)
359             }
360         )
361
362         // update bottom trip progress summary
363         binding.tripProgressView.render(
364             tripProgressApi.getTripProgress(routeProgress)
365         )
366     }

565     override fun onStart() {
...
572         mapboxNavigation.registerVoiceInstructionsObserver(voiceInstructionsObserver)
...

247     /**
248      * Observes when a new voice instruction should be played.
249      */
250     private val voiceInstructionsObserver = VoiceInstructionsObserver { voiceInstructions ->
251         speechApi.generate(voiceInstructions, speechCallback)
252     }
253
254     /**
255      * Based on whether the synthesized audio file is available, the callback plays the file
256      * or uses the fall back which is played back using the on-device Text-To-Speech engine.
257      */
258     private val speechCallback =
259         MapboxNavigationConsumer<Expected<SpeechError, SpeechValue>> { expected ->
260             expected.fold(
261                 { error ->
262                     // play the instruction via fallback text-to-speech engine
263                     voiceInstructionsPlayer.play(
264                         error.fallback,
265                         voiceInstructionsPlayerCallback
266                     )
267                 },
268                 { value ->
269                     // play the sound file from the external generator
270                     voiceInstructionsPlayer.play(
271                         value.announcement,
272                         voiceInstructionsPlayerCallback
273                     )
274                 }
275             )
276         }