sync files

mobile/hooks/useAutoSync.ts

@@ -9,13 +9,6 @@ import { API_BASE_URL, ENDPOINTS } from '../constants/api';
 import { ApiError } from '../types';
 import { setIsSyncing } from './useSyncQueue';
 
-function canSyncFolder(folder: StoredFolder, netInfo: NetInfoState): boolean {
-  if (folder.syncMode !== 'auto') return false;
-  if (!netInfo.isConnected) return false;
-  if (!folder.syncCellular && netInfo.type !== 'wifi') return false;
-  return true;
-}
-
 interface UploadResult {
   name: string;
   id: string;
@@ -53,38 +46,52 @@ async function uploadFile(file: { uri: string; type: string; name: string }): Pr
   return item as UploadResult;
 }
 
+function canSyncBasedOnNetwork(netInfo: NetInfoState, cellularAllowed: boolean): boolean {
+  if (!netInfo.isConnected) return false;
+  if (!cellularAllowed && netInfo.type !== 'wifi') return false;
+  return true;
+}
+
 export function useAutoSync() {
   const queryClient = useQueryClient();
   const isRunning = useRef(false);
 
   const checkAndSync = useCallback(async () => {
     if (isRunning.current) return;
+
+    const globalMode = safDirectory.getGlobalSyncMode();
+    if (globalMode === 'off') return;
+
     isRunning.current = true;
 
     try {
-      const folders = safDirectory.getAll();
-      const autoFolders = folders.filter((f) => f.syncMode === 'auto');
-      if (autoFolders.length === 0) return;
-
+      const globalCellular = safDirectory.getGlobalSyncCellular();
       const netInfo = await NetInfo.fetch();
-      const eligible = autoFolders.filter((f) => canSyncFolder(f, netInfo));
-      if (eligible.length === 0) return;
 
-      const eligibleIds = new Set(eligible.map((f) => f.id));
+      if (!canSyncBasedOnNetwork(netInfo, globalCellular)) return;
+
       const registry = localFileRegistry.getAll();
-
-      const pendingFiles = registry.filter(
-        (entry) =>
-          !entry.backendFileId &&
-          entry.syncStatus === 'local' &&
-          entry.folderId &&
-          eligibleIds.has(entry.folderId) &&
-          entry.localUri
+      let pendingFiles = registry.filter(
+        (entry) => !entry.backendFileId && entry.syncStatus === 'local' && entry.localUri
       );
 
+      if (globalMode === 'auto') {
+        // Mode auto global : tous les fichiers locaux sans backendFileId
+        // (pas de filtre par dossier)
+      } else {
+        // Mode manuel : uniquement les fichiers des dossiers en mode auto
+        const allFolders = safDirectory.getAll();
+        const autoFolderIds = new Set(
+          allFolders.filter((f) => f.syncMode === 'auto').map((f) => f.id)
+        );
+        pendingFiles = pendingFiles.filter(
+          (entry) => entry.folderId && autoFolderIds.has(entry.folderId)
+        );
+      }
+
       if (pendingFiles.length === 0) return;
 
-      console.log(`[useAutoSync] upload de ${pendingFiles.length} fichier(s)`);
+      console.log(`[useAutoSync] mode=${globalMode}, upload de ${pendingFiles.length} fichier(s)`);
       setIsSyncing(true);
 
       for (const entry of pendingFiles) {

mobile/hooks/useLocalFiles.ts

@@ -1,4 +1,4 @@
-import { useMemo } from 'react';
+import { useMemo, useEffect, useRef } from 'react';
 import { useDeviceFiles } from './useDeviceFiles';
 import { localFileRegistry } from '../services/localFileRegistry';
 import { LocalFileEntry } from '../types';
@@ -8,6 +8,23 @@ export function useLocalFiles() {
 
   const registryEntries = useMemo(() => localFileRegistry.getAll(), []);
 
+  useEffect(() => {
+    for (const df of deviceFiles) {
+      if (localFileRegistry.get(df.id)) continue;
+      const entry: LocalFileEntry = {
+        id: df.id,
+        localUri: df.uri,
+        name: df.name,
+        mimeType: df.mimeType,
+        size: df.size,
+        syncStatus: 'local',
+        createdAt: df.createdAt,
+        folderId: df.folderId,
+      };
+      localFileRegistry.register(entry);
+    }
+  }, [deviceFiles]);
+
   const localFiles = useMemo(() => {
     const merged = new Map<string, LocalFileEntry>();
 

mobile/hooks/useSyncQueue.ts

@@ -20,12 +20,9 @@ export function useSyncQueue() {
   const { folders } = useDeviceFiles();
 
   const refresh = useCallback(() => {
-    const allFolders = safDirectory.getAll();
-    const syncFolderIds = new Set(
-      allFolders.filter((f) => f.syncMode !== 'none').map((f) => f.id)
-    );
+    const globalMode = safDirectory.getGlobalSyncMode();
 
-    if (syncFolderIds.size === 0) {
+    if (globalMode === 'off') {
       setPendingCount(0);
       setIsSyncingState(getIsSyncing());
       return;
@@ -33,11 +30,21 @@ export function useSyncQueue() {
 
     const registry = localFileRegistry.getAll();
     let count = 0;
+
     for (const entry of registry) {
       if (entry.backendFileId) continue;
       if (entry.syncStatus !== 'local') continue;
-      if (entry.folderId && !syncFolderIds.has(entry.folderId)) continue;
-      count++;
+
+      if (globalMode === 'auto') {
+        count++;
+      } else {
+        // mode manuel : uniquement les fichiers des dossiers en mode auto
+        if (!entry.folderId) continue;
+        const folder = safDirectory.getAll().find((f) => f.id === entry.folderId);
+        if (folder && folder.syncMode === 'auto') {
+          count++;
+        }
+      }
     }
 
     setPendingCount(count);