// create  online routing service 
 _onlineRoutingService = [[NTNutiteqOnlineRoutingService alloc] initWithSource:@"nutiteq.osm.car"];

 // create  online routing service 
 onlineRoutingService = new NutiteqOnlineRoutingService("nutiteq.osm.car");

 // create  online routing service
 onlineRoutingService = new NutiteqOnlineRoutingService("nutiteq.osm.car");

     // set route start end end points
     NTMapPosVector* poses = [[NTMapPosVector alloc] init];
     [poses add:startPos];
     [poses add:stopPos];
    
    NTRoutingRequest* request = [[NTRoutingRequest alloc] initWithProjection:[[self.mapView getOptions] getBaseProjection] points:poses];

    // this calculation should be in background thread
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        NTRoutingResult* route = [_onlineRoutingService calculateRoute:request];

       // process results in main thread, so it can update UI
        dispatch_async(dispatch_get_main_queue(), ^{
            if (route == nil){
                NSLog(@"route error");
                return;
            }
            
            NSDateFormatter *dateFormatter = [[NSDateFormatter alloc] init];
            [dateFormatter setDateFormat:@"HH:mm:ss"];
            [dateFormatter setTimeZone:[NSTimeZone timeZoneForSecondsFromGMT:0]];
            
            NSString* routeDesc = [NSString stringWithFormat:@"Route: %0.3f m, travel %@. Calculation took %0.3f s", [route getTotalDistance]/1000.0,
                                   [dateFormatter stringFromDate: [NSDate dateWithTimeIntervalSince1970:[route getTotalTime]]],
                                   duration];
            
            NSLog(@"%@",routeDesc);
            
            // get instructions
            for(int i=0; i < [[route getInstructions] size];i++){
                NTRoutingInstruction *instruction =[[route getInstructions] get:i];
                NSLog(@"%@",[instruction description]);

            }
        });
    });

    AsyncTask<Void, Void, RoutingResult> task = new AsyncTask<Void, Void, RoutingResult>() {

        protected RoutingResult doInBackground(Void... v) {
                MapPosVector poses = new MapPosVector();
                poses.add(startPos);
                poses.add(stopPos);
                RoutingRequest request = new RoutingRequest(mapView.getOptions().getBaseProjection(), poses);
                RoutingResult result = onlineRoutingService.calculateRoute(request);

                return result;
            }

            protected void onPostExecute(RoutingResult result) {
                if (result == null) {
                    Log.e(Const.LOG_TAG,"routing error");
                    return;
                }

                String routeText = "The route is " + (int) (result.getTotalDistance() / 100) / 10f
                        + "km (" + result.getTotalTime()
                        + " s)";
                Log.i(Const.LOG_TAG,routeText);

                // get instruction details
                RoutingInstructionVector instructions = result.getInstructions();
                boolean first = true;
                for (int i = 0; i < instructions.size(); i++) {
                    RoutingInstruction instruction = instructions.get(i);
                        Log.d(Const.LOG_TAG, instruction.toString());
                     }

                }
            }
        };

        task.execute();

    Task.Run (() => {
        MapPosVector poses = new MapPosVector ();
        poses.Add (startPos);
        poses.Add (stopPos);
        RoutingRequest request = new RoutingRequest (baseProjection, poses);
        RoutingResult result = onlineRoutingService.CalculateRoute (request);
                
        // get total route results
        String routeText = "The route is " + (int)(result.TotalDistance / 100) / 10f
                      + "km (" + result.TotalTime
                      + " sec) ";
        Log.Debug(routeText);   
                
        // get instructions, just log them
        RoutingInstructionVector instructions = result.Instructions;
        for (int i = 0; i < instructions.Count; i++) {
            RoutingInstruction instruction = instructions [i];
            Log.Debug(instruction.toString());

        }
    });

   // define PackageManger to download offline routing packages
    // Create folder for package manager. Package manager needs persistent writable folder.
    NSArray* paths = NSSearchPathForDirectoriesInDomains(NSApplicationSupportDirectory, NSUserDomainMask,YES);
    NSString* appSupportDir = [paths objectAtIndex: 0];
    NSString* packagesDir = [appSupportDir stringByAppendingString:@"/packages"];
    NSError *error;
    [[NSFileManager defaultManager] createDirectoryAtPath:packagesDir withIntermediateDirectories:YES attributes:nil error:&error];
    
    NTNutiteqPackageManager* packageManager = [[NTNutiteqPackageManager alloc] initWithSource:@"routing:nutiteq.osm.car" dataFolder:packagesDir];

    // create PackageManager instance for dealing with offline packages
        File packageFolder = new File(getApplicationContext().getExternalFilesDir(null), "routingpackages");
        if (!(packageFolder.mkdirs() || packageFolder.isDirectory())) {
            Log.e(Const.LOG_TAG, "Could not create package folder!");
        }
        packageManager = new NutiteqPackageManager("routing:nutiteq.osm.car", packageFolder.getAbsolutePath());
        

    // create PackageManager instance for dealing with offline packages
    var packageFolder = new File (GetExternalFilesDir(null), "routingpackages");
    if (!(packageFolder.Mkdirs() || packageFolder.IsDirectory)) {
        Log.Fatal("Could not create package folder!");
    }

    packageManager = new NutiteqPackageManager("routing:nutiteq.osm.car", packageFolder.AbsolutePath);

    @implementation RoutePackageManagerListener

    - (void)onPackageListUpdated
    {
        NSLog(@"onPackageListUpdated");
        // We have packages all country/regions
        // see list of available ID-s: https://developer.nutiteq.com/guides/packages
        // just append -routing to the ID-s
        // You can download several packages, and route is found through all of them
        
         [_packageManager startPackageDownload: @"EE-routing"];
         [_packageManager startPackageDownload: @"LV-routing"];
    }

    - (void)onPackageListFailed
    {
        NSLog(@"onPackageListFailed");
    }

    - (void)onPackageUpdated:(NSString*)packageId version:(int)version
    {
    }

    - (void)onPackageCancelled:(NSString*)packageId version:(int)version
    {
    }

    - (void)onPackageFailed:(NSString*)packageId version:(int)version errorType:(enum NTPackageErrorType)errorType
    {
        NSLog(@"onPackageFailed");
    }

    - (void)onPackageStatusChanged:(NSString*)packageId version:(int)version status:(NTPackageStatus*)status
    {
           // here you can get progress of download
        NSLog(@"onPackageStatusChanged progress: %f", [status getProgress]);
    }

    @end

    /**
     * Minimal for package manager events. Contains some empty methods.
     */
    class RoutePackageManagerListener extends PackageManagerListener {
        @Override
        public void onPackageListUpdated() {
          Log.d(Const.LOG_TAG, "Package list updated");
          // Start download of package of Estonia
          // see list of available ID-s: https://developer.nutiteq.com/guides/packages
          // just append -routing to the ID-s
          // You can download several packages, and route is found through all of them
              
          packageManager.startPackageDownload("EE-routing");
          packageManager.startPackageDownload("LV-routing");

        }

        @Override
        public void onPackageListFailed() {
            Log.e(Const.LOG_TAG, "Package list update failed");
        }

        @Override
        public void onPackageStatusChanged(String id, int version, PackageStatus status)  
        {
          // here you can monitor download process %
        }

        @Override
        public void onPackageCancelled(String id, int version) {
        }

        @Override
        public void onPackageUpdated(String id, int version) {
          Log.d(Const.LOG_TAG, "Offline package updated: " + id);
        }

        @Override
        public void onPackageFailed(String id, int version, PackageErrorType errorType) {
            Log.e(Const.LOG_TAG, "Offline package update failed: " + id);
        }
    }

    /**
     * Listener for package manager events. Contains many empty methods.
     */
    class RoutePackageManagerListener : PackageManagerListener {

        private OfflineRouting controller;

        public RoutingPackageListener(OfflineRouting controller){
            this.controller = controller;
        }

        public override void OnPackageListUpdated() {
            Log.Debug("Package list updated");
            // We have packages all country/regions
            // see list of available ID-s: https://developer.nutiteq.com/guides/packages
            // just append -routing to the ID-s
            // You can download several packages, and route is found through all of them

            controller.packageManager.StartPackageDownload("EE-routing");
            controller.packageManager.StartPackageDownload("LV-routing");
        }

        public override void OnPackageListFailed() {
            Log.Error("Package list update failed");
        }

        public override void OnPackageStatusChanged(String id, int version, PackageStatus status) {
          // here you can get progress of download
        }

        public override void OnPackageCancelled(String id, int version) {
        }

        public override void OnPackageUpdated(String id, int version) {
            Log.Debug("Offline package updated: " + id);
        }

        public override void OnPackageFailed(String id, int version, PackageErrorType errorType) {
            Log.Error("Offline package download failed: " + id);
        }
    }

     // 1. create routePackageManagerListener with your listener class
     RoutePackageManagerListener* _packageManagerListener = [[RoutePackageManagerListener alloc] init];
    [_packageManagerListener setPackageManager: packageManager];
    
    // Attach package manager listener
    [packageManager setPackageManagerListener:_packageManagerListener];

    // start PackageManager
    [packageManager start];
    
    // 2. now start download of packageList. When download is done, then the 
    // listener's OnPackageListUpdated() is called
    [packageManager startPackageListDownload];
    
    // 3. create offline routing service connected to package manager
    _offlineRoutingService = [[NTPackageManagerRoutingService alloc] initWithPackageManager:packageManager];

        
        // 1. set listener, and start PackageManager
        packageManager.setPackageManagerListener(new RoutePackageManagerListener());
        packageManager.start();
        
        // 2. fetch list of available packages from server. Note that this is asynchronous operation and listener will be notified via onPackageListUpdated when this succeeds.        
        packageManager.startPackageListDownload();
        
         // 3. create offline routing service connected to package manager
        offlineRoutingService = new PackageManagerRoutingService(packageManager);
        

            // 1. create and set listener, and start PackageManager
            packageManager.PackageManagerListener = new RoutingPackageListener(this);
            packageManager.Start();

            // 2. fetch list of available packages from server. Note that this is asynchronous operation and listener will be notified via onPackageListUpdated when this succeeds.        
            packageManager.StartPackageListDownload();

            // 3. create offline routing service connected to package manager
            offlineRoutingService = new PackageManagerRoutingService(packageManager);