Fix offline routing for mapeak and ihm support

Author: HarelM

IsraelHiking.Web/src/application/services/offline-files-download.service.ts

@@ -240,6 +240,7 @@ export class OfflineFilesDownloadService {
             for (const fileName of fileNames) {
                 this.loggingService.info(`[Offline Download] Deleting file ${fileName}`);
                 await this.fileService.deleteFileInDataDirectory(fileName);
+                this.pmtilesService.invalidateFile(fileName);
             }
         }
         downloadedTiles = this.store.selectSnapshot((s: ApplicationState) => s.offlineState.downloadedTiles);

IsraelHiking.Web/src/application/services/pmtiles.service.ts

@@ -36,15 +36,27 @@ export class PmTilesService {
     private readonly loggingService = inject(LoggingService);
     private readonly store = inject(Store);
 
+    /**
+     * Creates a source for the given file, throws when the file does not exist.
+     * Only existing files are cached, so a file that was downloaded later will be picked up.
+     */
     private async getSource(filePath: string): Promise<Source> {
         if (this.sourcesCache.has(filePath)) {
             return this.sourcesCache.get(filePath);
         }
+        await Filesystem.stat({ path: filePath, directory: Directory.Data });
         const source = new CapacitorSource(filePath);
         this.sourcesCache.set(filePath, source);
         return source;
     }
 
+    /**
+     * Removes a file from the sources cache, should be called when a file is deleted.
+     */
+    public invalidateFile(fileName: string): void {
+        this.sourcesCache.delete(fileName);
+    }
+
     /**
      * Get's a tile from the stored pmtiles file
      * @param url - should be something like custom://filename-without-pmtiles-extention/{z}/{x}/{y}.png
@@ -100,7 +112,7 @@ export class PmTilesService {
         try {
             await this.getSource(fileName);
         } catch (ex) {
-            this.loggingService.error(`Failed to open file ${fileName} for tile ${tileX}-${tileY} type ${type} and ${z}/${x}/${y}: ${(ex as Error).message}`);
+            this.loggingService.debug(`Failed to open file ${fileName} for tile ${tileX}-${tileY} type ${type} and ${z}/${x}/${y}: ${(ex as Error).message}`);
             return false;
         }
         return true;

IsraelHiking.Web/src/application/services/routing.provider.spec.ts

@@ -369,6 +369,53 @@ describe("RoutingProvider", () => {
         )
     );
 
+    it("Should fall back to the older schema when the newer schema is missing for one of the tiles",
+        inject([RoutingProvider, HttpTestingController, PmTilesService],
+            async (router: RoutingProvider, mockBackend: HttpTestingController, db: PmTilesService) => {
+                const featureCollection = {
+                    type: "FeatureCollection",
+                    features: [
+                        {
+                            type: "Feature",
+                            geometry: {
+                                type: "LineString",
+                                coordinates: [
+                                    [35.0001, 32.0001],
+                                    [35.0001, 32.0003],
+                                    [35.0003, 32.0003]
+                                ]
+                            },
+                            properties: {
+                                ihm_class: "track"
+                            }
+                        }
+                    ]
+                } as GeoJSON.FeatureCollection;
+
+                let mapeakAvailabilityCalls = 0;
+                db.isOfflineFileAvailable = (_z, _x, _y, type) => {
+                    if (type !== "mapeak-schema") {
+                        return Promise.resolve(true);
+                    }
+                    mapeakAvailabilityCalls++;
+                    return Promise.resolve(mapeakAvailabilityCalls === 1);
+                };
+                const usedSchemas: string[] = [];
+                db.getTileByType = (_z, _x, _y, type) => {
+                    usedSchemas.push(type);
+                    return Promise.resolve(createTileFromFeatureCollection(featureCollection));
+                };
+
+                const promise = router.getRoute({ lat: 32.0001, lng: 35.0001 }, { lat: 32.0003, lng: 35.0003 }, "Hike");
+
+                mockBackend.expectOne(() => true).flush(null, { status: 500, statusText: "Server error" });
+                const data = await promise;
+                expect(data.length).toBeGreaterThan(1);
+                expect(usedSchemas.every(s => s === "IHM-schema")).toBe(true);
+            }
+        )
+    );
+
     it("Should return start and end point when all lines are filtered out",
         inject([RoutingProvider, HttpTestingController, PmTilesService, Store],
             async (router: RoutingProvider, mockBackend: HttpTestingController, db: PmTilesService, store: Store) => {

IsraelHiking.Web/src/application/services/routing.provider.ts

@@ -83,16 +83,19 @@ export class RoutingProvider {
         if (tileXmax - tileXmin > 2 || tileYmax - tileYmin > 2) {
             throw new Error("Offline routing is only supported for adjecent tiles maximum...");
         }
-        let schema = RoutingProvider.IHM_ROUTING_SCHEMA;
-        for (const tile of tiles) {
-            if (!await this.pmTilesService.isOfflineFileAvailable(zoom, tile.x, tile.y, RoutingProvider.IHM_ROUTING_SCHEMA)
-                && !await this.pmTilesService.isOfflineFileAvailable(zoom, tile.x, tile.y, RoutingProvider.MAPEAK_ROUTING_SCHEMA)) {
-                throw new Error("Unable to find offline route, some tiles are missing");
-            }
-            if (await this.pmTilesService.isOfflineFileAvailable(zoom, tile.x, tile.y, RoutingProvider.MAPEAK_ROUTING_SCHEMA)) {
-                schema = RoutingProvider.MAPEAK_ROUTING_SCHEMA;
+        // A schema is usable only when all the relevant tiles are available in it, prefer the newer schema.
+        let schema: string = null;
+        for (const schemaCandidate of [RoutingProvider.MAPEAK_ROUTING_SCHEMA, RoutingProvider.IHM_ROUTING_SCHEMA]) {
+            const availability = await Promise.all(
+                tiles.map(tile => this.pmTilesService.isOfflineFileAvailable(zoom, tile.x, tile.y, schemaCandidate)));
+            if (availability.every(available => available)) {
+                schema = schemaCandidate;
+                break;
             }
         }
+        if (schema == null) {
+            throw new Error("Unable to find offline route, some tiles are missing");
+        }
         // increase the chance of getting a route by adding more tiles
         if (tileXmax === tileXmin) {
             tileXmax += 1;
@@ -136,6 +139,10 @@ export class RoutingProvider {
                     allCollection.push(this.featuresCache.get(key));
                     continue;
                 }
+                // The tiles range is extended beyond the start and end tiles, so some of them might not be available.
+                if (!await this.pmTilesService.isOfflineFileAvailable(zoom, tileX, tileY, schema)) {
+                    continue;
+                }
                 const collection = {
                     type: "FeatureCollection",
                     features: []