MLNInvalidOfflinePackException fix

src/database/tilesService/index.ts

@@ -4,6 +4,7 @@ import * as MapLibreRN from '@maplibre/maplibre-react-native';
 import { VECTOR_MAP_HOST } from 'src/constants';
 import { fetchLastMapTilesUpdate } from '@api/app';
 import { storage, StoreType } from 'src/storage';
+import { updateMapMetadata } from 'src/screens/OfflineMapsScreen/OfflineMapManager';
 
 const STYLE_URL = `${VECTOR_MAP_HOST}/nomadmania-maps2025.json`;
 const PACK_NAME = 'vector-map-pack';
@@ -30,13 +31,22 @@ async function setupOfflineRegion(): Promise<void> {
     const minZoom = 0;
     const maxZoom = 6;
 
-    const existingPacks = await MapLibreRN.OfflineManager.getPacks();
-    const pack = existingPacks.find((pack) => getPackName(pack) === PACK_NAME);
+    const pack = await MapLibreRN.OfflineManager.getPack(PACK_NAME);
 
     if (pack) {
-      const status = await pack.status();
-      if (status.percentage < 100) {
-        pack.resume();
+      try {
+        const status = await pack.status();
+        if (status.percentage < 100) {
+          pack.resume();
+        }
+      } catch {
+        await MapLibreRN.OfflineManager.createPack(
+          { name: PACK_NAME, bounds, minZoom, maxZoom, styleURL: STYLE_URL },
+          () => {},
+          (error) => {
+            if (error) console.error('Error creating offline pack:', error);
+          }
+        );
       }
     } else {
       await MapLibreRN.OfflineManager.createPack(
@@ -81,6 +91,7 @@ export async function updateMapsCache() {
           await MapLibreRN.OfflineManager.deletePack(name);
         } else {
           await MapLibreRN.OfflineManager.invalidatePack(name);
+          updateMapMetadata(name, { status: 'invalid' });
         }
       } catch {}
     }

src/screens/OfflineMapsScreen/OfflineMapManager.ts

@@ -88,14 +88,18 @@ const cleanupCompletedMaps = async () => {
       const pack = await getPack(map.id);
 
       if (pack) {
-        const status = await pack.status();
-
-        if (
-          status &&
-          (status.percentage === 100 ||
-            status.completedResourceCount === status.requiredResourceCount)
-        ) {
-          markPackAsCompleted(map.id);
+        try {
+          const status = await pack.status();
+
+          if (
+            status &&
+            (status.percentage === 100 ||
+              status.completedResourceCount === status.requiredResourceCount)
+          ) {
+            markPackAsCompleted(map.id);
+          }
+        } catch (statusError) {
+          console.warn(`Pack ${map.id} is invalid, skipping cleanup.`);
         }
       }
     }
@@ -242,25 +246,39 @@ const resumePackDownload = async (name: string, progressCallback?: any, errorCal
     }
 
     if (pack) {
-      const status = await pack.status();
-      if (
-        status &&
-        (status.percentage === 100 ||
-          status.completedResourceCount === status.requiredResourceCount)
-      ) {
-        markPackAsCompleted(name);
-        return;
+      try {
+        const status = await pack.status();
+        if (
+          status &&
+          (status.percentage === 100 ||
+            status.completedResourceCount === status.requiredResourceCount)
+        ) {
+          markPackAsCompleted(name);
+          return;
+        }
+      } catch (statusError) {
+        console.warn(`Pack ${name} status() failed, will re-create.`);
+        pack = null;
       }
 
-      subscribeToPackProgress(name, progressCallbacks[name], errorCallback);
+      if (pack) {
+        subscribeToPackProgress(name, progressCallbacks[name], errorCallback);
 
-      await pack.resume();
+        try {
+          await pack.resume();
+        } catch (resumeError) {
+          console.warn(`Pack ${name} resume() failed, will re-create.`);
+          pack = null;
+        }
 
-      updateMapMetadata(name, {
-        status: 'downloading',
-        isPaused: false
-      });
-      return;
+        if (pack) {
+          updateMapMetadata(name, {
+            status: 'downloading',
+            isPaused: false
+          });
+          return;
+        }
+      }
     }
 
     const mapsString = storage.getString(OFFLINE_MAPS_KEY);
@@ -329,7 +347,7 @@ const resumeAllPendingDownloads = async () => {
   }
 };
 
-const updateMapMetadata = (id, updates) => {
+export const updateMapMetadata = (id, updates) => {
   try {
     const mapsString = storage.getString(OFFLINE_MAPS_KEY);
     const maps = mapsString ? JSON.parse(mapsString) : [];

src/screens/OfflineMapsScreen/index.tsx

@@ -206,10 +206,10 @@ export default function OfflineMapsScreen({ navigation }: { navigation: any }) {
 
           if (map && map.status === 'downloading') {
             await offlineMapManager.cancelPackDownload(id);
+          } else {
+            await offlineMapManager.deletePack(id);
           }
 
-          await offlineMapManager.deletePack(id);
-
           const updatedMaps = maps.filter((map: any) => map.id !== id);
           storage.set(OFFLINE_MAPS_KEY, JSON.stringify(updatedMaps));