feat: implement webapp routing

src/App.js

@@ -36,7 +36,8 @@ import { useNetService } from '/libs/services/NetService'
 import { withSentry } from '/libs/monitoring/Sentry'
 import { ThemeProvider } from '/app/theme/ThemeProvider'
 import { useInitI18n } from '/locales/useInitI18n'
-import { SharingProvider } from '/app/view/sharing/SharingProvider'
+import { SharingProvider } from '/app/view/Sharing/SharingProvider'
+import { ErrorProvider } from '/app/view/Error/ErrorProvider'
 
 // Polyfill needed for cozy-client connection
 if (!global.btoa) {
@@ -57,7 +58,11 @@ const App = ({ setClient }) => {
 
   const { initialRoute, isLoading } = useAppBootstrap(client)
 
-  useGlobalAppState()
+  useGlobalAppState({
+    onNavigationRequest: route => {
+      RootNavigation.navigate(route)
+    }
+  })
   useSecureBackgroundSplashScreen()
   useCookieResyncOnResume()
   useNotifications()
@@ -75,24 +80,28 @@ const Nav = ({ client, setClient }) => {
 
   return (
     <NavigationContainer ref={RootNavigation.navigationRef}>
-      <NativeIntentProvider localMethods={localMethods(client)}>
-        <View
-          style={[
-            styles.view,
-            {
-              backgroundColor: colors.primaryColor
-            }
-          ]}
-        >
-          <StatusBar
-            barStyle="light-content"
-            backgroundColor="transparent"
-            translucent
-          />
-          <IconChangedModal />
-          <App setClient={setClient} />
-        </View>
-      </NativeIntentProvider>
+      <ErrorProvider>
+        <SharingProvider>
+          <NativeIntentProvider localMethods={localMethods(client)}>
+            <View
+              style={[
+                styles.view,
+                {
+                  backgroundColor: colors.primaryColor
+                }
+              ]}
+            >
+              <StatusBar
+                barStyle="light-content"
+                backgroundColor="transparent"
+                translucent
+              />
+              <IconChangedModal />
+              <App setClient={setClient} />
+            </View>
+          </NativeIntentProvider>
+        </SharingProvider>
+      </ErrorProvider>
     </NavigationContainer>
   )
 }
@@ -159,9 +168,7 @@ const Wrapper = () => {
                 <SplashScreenProvider>
                   <NetStatusBoundary>
                     <ThemeProvider>
-                      <SharingProvider>
-                        <WrappedApp />
-                      </SharingProvider>
+                      <WrappedApp />
                     </ThemeProvider>
                   </NetStatusBoundary>
                 </SplashScreenProvider>

src/AppRouter.jsx

@@ -11,7 +11,7 @@ import { ManagerScreen } from '/app/view/Manager/ManagerScreen'
 import { OnboardingScreen } from '/screens/login/OnboardingScreen'
 import { WelcomeScreen } from '/screens/welcome/WelcomeScreen'
 import { routes } from '/constants/routes'
-import { SharingScreen } from '/app/view/sharing/SharingScreen'
+import { SharingScreen } from '/app/view/Sharing/SharingScreen'
 import { PasswordPrompt } from '/app/view/Secure/PasswordPrompt'
 import { PinPrompt } from '/app/view/Secure/PinPrompt'
 import { SetPasswordView } from '/app/view/Secure/SetPasswordView'

src/app/domain/authorization/services/SecurityService.ts

@@ -29,6 +29,7 @@ import { navigateToApp } from '/libs/functions/openApp'
 import { hideSplashScreen } from '/app/theme/SplashScreenService'
 import { SecurityNavigationService } from '/app/domain/authorization/services/SecurityNavigationService'
 import { getData, StorageKeys } from '/libs/localStore'
+import { SharingIntentStatus } from '/app/domain/sharing/models/SharingState'
 
 // Can use mock functions in dev environment
 const fns = getDevModeFunctions(
@@ -79,15 +80,18 @@ export const determineSecurityFlow = async (
     href: string
     slug: string
   },
-  isCallerHandlingSplashscreen?: boolean
+  isCallerHandlingSplashscreen?: boolean,
+  sharingIntentStatus?: SharingIntentStatus
 ): Promise<void> => {
+  const openedWithSharing =
+    sharingIntentStatus === SharingIntentStatus.OpenedViaSharing
   SecurityNavigationService.startListening()
 
   const callbackNav = async (): Promise<void> => {
     try {
       if (navigationObject) {
         await navigateToApp(navigationObject)
-      } else navigate(routes.home)
+      } else navigate(openedWithSharing ? routes.sharing : routes.home)
     } catch (error) {
       devlog('🔏', 'Error navigating to app, defaulting to home', error)
       navigate(routes.home)

src/app/domain/sharing/models/SharingCozyApp.ts

@@ -0,0 +1,21 @@
+export interface SharingCozyApp {
+  _id: string
+  _type: string
+  accept_documents_from_flagship?: {
+    accepted_mime_types: string[]
+    max_number_of_files: number
+    max_size_per_file_in_MB: number
+    route_to_upload: string
+  }
+  accept_from_flagship?: boolean
+  attributes: {
+    accept_documents_from_flagship?: {
+      accepted_mime_types: string[]
+      max_number_of_files: number
+      max_size_per_file_in_MB: number
+      route_to_upload: string
+    }
+    accept_from_flagship?: boolean
+  }
+  slug: string
+}

src/app/domain/sharing/models/SharingState.ts

@@ -8,14 +8,30 @@ export enum SharingIntentStatus {
 
 export enum SharingActionType {
   SetIntentStatus = 'SET_INTENT_STATUS',
-  SetFilesToUpload = 'SET_FILES_TO_UPLOAD'
+  SetFilesToUpload = 'SET_FILES_TO_UPLOAD',
+  SetRouteToUpload = 'SET_ROUTE_TO_UPLOAD',
+  SetFlowErrored = 'SET_FLOW_ERRORED',
+  SetRecoveryState = 'SET_RECOVERY_STATE'
 }
 
 export interface SharingState {
   sharingIntentStatus: SharingIntentStatus
   filesToUpload: ReceivedFile[]
+  routeToUpload?: { href: string; slug: string }
+  errored: boolean
 }
 
 export type SharingAction =
   | { type: SharingActionType.SetIntentStatus; payload: SharingIntentStatus }
   | { type: SharingActionType.SetFilesToUpload; payload: ReceivedFile[] }
+  | {
+      type: SharingActionType.SetRouteToUpload
+      payload: { href: string; slug: string }
+    }
+  | { type: SharingActionType.SetFlowErrored; payload: boolean }
+  | { type: SharingActionType.SetRecoveryState }
+
+export interface ServiceResponse<T> {
+  result?: T
+  error?: string
+}

src/app/domain/sharing/services/SharingNetwork.spec.ts

@@ -0,0 +1,59 @@
+import CozyClient from 'cozy-client'
+
+import { SharingCozyApp } from '/app/domain/sharing/models/SharingCozyApp'
+import { getRouteToUpload } from '/app/domain/sharing/services/SharingNetwork'
+
+describe('getRouteToUpload', () => {
+  const mockCozyClient = new CozyClient({
+    uri: 'http://cozy.local',
+    capabilities: { flat_subdomains: true }
+  })
+
+  it('returns empty object if no client is provided', () => {
+    const result = getRouteToUpload()
+    expect(result).toEqual({})
+  })
+
+  it('returns empty object if cozyApps is not an array or empty', () => {
+    // @ts-expect-error Testing invalid input
+    const result = getRouteToUpload(null, mockCozyClient)
+    expect(result).toEqual({})
+  })
+
+  it('returns empty object if no matching app is found', () => {
+    const cozyApps = [{ slug: 'wrong-app' } as SharingCozyApp]
+
+    const result = getRouteToUpload(cozyApps, mockCozyClient)
+    expect(result).toEqual({})
+  })
+
+  it('returns the correct href and slug', () => {
+    const cozyApps = [
+      {
+        slug: 'drive',
+        accept_documents_from_flagship: {
+          route_to_upload: '/upload-route'
+        },
+        attributes: {
+          accept_documents_from_flagship: {
+            route_to_upload: '/upload-route'
+          }
+        }
+      } as SharingCozyApp
+    ]
+    const result = getRouteToUpload(cozyApps, mockCozyClient, 'drive')
+    expect(result).toEqual({
+      result: {
+        href: 'http://cozy-drive.local/#/upload-route',
+        slug: 'drive'
+      }
+    })
+  })
+
+  it('handles an error gracefully', () => {
+    const brokenClient = new CozyClient({ uri: undefined })
+    const cozyApps = [{ slug: 'drive' } as SharingCozyApp]
+    const result = getRouteToUpload(cozyApps, brokenClient)
+    expect(result).toEqual({ error: 'Error determining route to upload.' })
+  })
+})

src/app/domain/sharing/services/SharingNetwork.ts

@@ -0,0 +1,48 @@
+import CozyClient, { generateWebLink, Q } from 'cozy-client'
+
+import { sharingLogger } from '/app/domain/sharing'
+import { SharingCozyApp } from '/app/domain/sharing/models/SharingCozyApp'
+import { ServiceResponse } from '/app/domain/sharing/models/SharingState'
+
+export const fetchSharingCozyApps = {
+  definition: Q('io.cozy.apps').where({
+    'accept_documents_from_flagship.route_to_upload': { $exists: true },
+    accept_from_flagship: true
+  }),
+  options: {
+    as: 'io.cozy.apps/fetchSharingCozyApps'
+  }
+}
+
+export const getRouteToUpload = (
+  cozyApps?: SharingCozyApp[],
+  client?: CozyClient | null,
+  appName = 'drive'
+): ServiceResponse<{ href: string; slug: string }> => {
+  try {
+    if (!client || !Array.isArray(cozyApps) || cozyApps.length === 0) return {}
+
+    const cozyApp = cozyApps.find(cozyApp => cozyApp.slug === appName)
+    if (!cozyApp) return {}
+    const hash =
+      cozyApp.accept_documents_from_flagship?.route_to_upload ??
+      cozyApp.attributes.accept_documents_from_flagship?.route_to_upload
+    const slug = cozyApp.slug
+    if (!hash || !slug) return {}
+
+    const href = generateWebLink({
+      cozyUrl: client.getStackClient().uri,
+      pathname: '',
+      slug,
+      subDomainType: client.capabilities.flat_subdomains ? 'flat' : 'nested',
+      hash: hash.replace(/^\/?#?\//, ''),
+      searchParams: []
+    })
+
+    sharingLogger.info('routeToUpload is', { href, slug })
+    return { result: { href, slug: cozyApp.slug } }
+  } catch (error) {
+    sharingLogger.error('Error when getting routeToUpload', error)
+    return { error: 'Error determining route to upload.' }
+  }
+}

src/app/domain/sharing/services/SharingStatus.ts

@@ -33,9 +33,7 @@ export const handleSharing = (
       : SharingIntentStatus.NotOpenedViaSharing
 
     sharingLogger.info(
-      `${
-        isAndroid ? 'Android' : 'iOS'
-      } App was opened or resumed via sharing, setting status to ${newStatus}`
+      `App was opened or resumed via sharing, setting status to ${newStatus}`
     )
 
     setStatus(newStatus)

src/app/view/Error/ErrorProvider.tsx

@@ -0,0 +1,62 @@
+import React, { ReactNode, useCallback, useEffect } from 'react'
+
+import { ErrorToaster } from '/app/view/Error/ErrorToaster'
+
+interface ErrorState {
+  message: string | null
+}
+
+export const ErrorStateContext = React.createContext<ErrorState>({
+  message: null
+})
+export const ErrorDispatchContext = React.createContext<
+  React.Dispatch<React.SetStateAction<string | null>>
+>(() => {
+  // eslint-disable-next-line no-console
+  console.warn('ErrorDispatchContext used outside of ErrorProvider.')
+})
+
+export const ErrorProvider = ({
+  children
+}: {
+  children: ReactNode
+}): JSX.Element => {
+  const [error, setError] = React.useState<string | null>(null)
+
+  useEffect(() => {
+    if (error) {
+      const timer = setTimeout(() => setError(null), 3000)
+      return () => clearTimeout(timer)
+    }
+  }, [error])
+
+  return (
+    <ErrorStateContext.Provider value={{ message: error }}>
+      <ErrorDispatchContext.Provider value={setError}>
+        {error ? <ErrorToaster /> : null}
+        {children}
+      </ErrorDispatchContext.Provider>
+    </ErrorStateContext.Provider>
+  )
+}
+
+interface ErrorHook {
+  error: ErrorState
+  setError: React.Dispatch<React.SetStateAction<string | null>>
+  handleError: (errorMessage: string, callback?: () => void) => void
+}
+
+export const useError = (): ErrorHook => {
+  const error = React.useContext(ErrorStateContext)
+  const setError = React.useContext(ErrorDispatchContext)
+
+  const handleError = useCallback(
+    (errorMessage: string, callback?: () => void): void => {
+      setError(errorMessage)
+      callback?.()
+    },
+    [setError]
+  )
+
+  return { error, setError, handleError }
+}