RC-T47 Map Routing App Fixes

app.config.ts

@@ -55,8 +55,10 @@ export default ({ config }: ConfigContext): ExpoConfig => ({
       UIViewControllerBasedStatusBarAppearance: false,
       NSBluetoothAlwaysUsageDescription:
         'Resgrid IC uses Bluetooth to connect to wireless headsets and speaker-microphone accessories for Push-to-Talk audio. For example, when you pair a Bluetooth speaker-mic, pressing its talk button transmits your voice to your department audio channel.',
-      // Allow the app to open its own custom-scheme deep links (needed for SSO callbacks)
-      LSApplicationQueriesSchemes: ['resgridic'],
+      // Allow the app to open its own custom-scheme deep links (needed for SSO callbacks).
+      // The navigation apps the Navigation App setting can hand directions to are detected with
+      // canOpenURL, which only answers for declared schemes (src/lib/navigation.ts).
+      LSApplicationQueriesSchemes: ['resgridic', 'waze', 'comgooglemaps'],
     },
     entitlements: {
       // Required for APNs registration. Previously added by the withForegroundNotifications

customManifest.plugin.js

@@ -2,6 +2,33 @@ const { withAndroidManifest, AndroidConfig } = require('expo/config-plugins');
 
 const SERVICE_NAME = 'app.notifee.core.ForegroundService';
 
+// Schemes src/lib/navigation.ts probes with Linking.canOpenURL before handing directions to a navigation
+// app. Android 11+ answers false for any scheme the manifest does not declare in <queries>, even when the
+// app is installed. (iOS declares the same schemes in LSApplicationQueriesSchemes in app.config.ts.)
+const NAVIGATION_QUERY_SCHEMES = ['waze'];
+
+/** Adds a VIEW-intent <queries> entry for each navigation scheme the manifest does not declare yet. */
+const addNavigationAppQueries = (manifest) => {
+  manifest.manifest.queries = manifest.manifest.queries || [];
+  if (manifest.manifest.queries.length === 0) {
+    manifest.manifest.queries.push({});
+  }
+
+  const declaresScheme = (scheme) => manifest.manifest.queries.some((query) => (query.intent || []).some((intent) => (intent.data || []).some((data) => data?.$?.['android:scheme'] === scheme)));
+
+  const queries = manifest.manifest.queries[0];
+  queries.intent = queries.intent || [];
+  for (const scheme of NAVIGATION_QUERY_SCHEMES) {
+    if (!declaresScheme(scheme)) {
+      queries.intent.push({
+        action: [{ $: { 'android:name': 'android.intent.action.VIEW' } }],
+        data: [{ $: { 'android:scheme': scheme } }],
+      });
+    }
+  }
+  return manifest;
+};
+
 const withForegroundService = (config) => {
   return withAndroidManifest(config, async (config) => {
     const manifest = config.modResults;
@@ -10,6 +37,8 @@ const withForegroundService = (config) => {
       manifest.manifest.$['xmlns:tools'] = 'http://schemas.android.com/tools';
     }
 
+    addNavigationAppQueries(manifest);
+
     const mainApplication = AndroidConfig.Manifest.getMainApplicationOrThrow(manifest);
 
     mainApplication['service'] = mainApplication['service'] || [];
@@ -35,3 +64,4 @@ const withForegroundService = (config) => {
 };
 
 module.exports = withForegroundService;
+module.exports.addNavigationAppQueries = addNavigationAppQueries;

src/app/(app)/poi/[id].tsx

@@ -55,7 +55,7 @@ export default function PoiDetailScreen() {
       return;
     }
 
-    const success = await openMapsWithDirections(poi.Latitude, poi.Longitude, getPoiSelectionLabel(poi, poiTypesById), userLatitude || undefined, userLongitude || undefined);
+    const success = await openMapsWithDirections(poi.Latitude, poi.Longitude, getPoiSelectionLabel(poi, poiTypesById), userLatitude || undefined, userLongitude || undefined, poi.Address);
     if (!success) {
       showToast('error', t('routes.failed_to_open_poi_maps'));
     }

src/app/(app)/settings.tsx

@@ -10,6 +10,7 @@ import { Item } from '@/components/settings/item';
 import { KeepAliveItem } from '@/components/settings/keep-alive-item';
 import { LanguageItem } from '@/components/settings/language-item';
 import { LoginInfoBottomSheet } from '@/components/settings/login-info-bottom-sheet';
+import { NavigationAppItem } from '@/components/settings/navigation-app-item';
 import { ServerUrlBottomSheet } from '@/components/settings/server-url-bottom-sheet';
 import { ThemeItem } from '@/components/settings/theme-item';
 import { ToggleItem } from '@/components/settings/toggle-item';
@@ -145,6 +146,7 @@ export default function Settings() {
             <VStack space="sm">
               <ThemeItem />
               <LanguageItem />
+              <NavigationAppItem />
               <KeepAliveItem />
               <BluetoothDeviceItem />
             </VStack>

src/app/call/[id].tsx

@@ -271,14 +271,18 @@ export default function CallDetail() {
    * Opens the device's native maps application with directions to the call location
    */
   const handleRoute = async () => {
-    if (coordinates.latitude === null || coordinates.longitude === null) {
+    // A withheld address must not leave the app in a navigation URL; coordinates still route.
+    const routableAddress = call?.Address && !isFieldRedacted(call.RedactedFields, ProtectedFieldIds.callAddress, call.Address) ? call.Address.trim() : '';
+
+    if ((coordinates.latitude === null || coordinates.longitude === null) && !routableAddress) {
       showToast('error', t('call_detail.no_location_for_routing'));
       return;
     }
 
     try {
-      const destinationName = call?.Address || t('call_detail.call_location');
-      const success = await openMapsWithDirections(coordinates.latitude, coordinates.longitude, destinationName, userLatitude || undefined, userLongitude || undefined);
+      const destinationName = routableAddress || t('call_detail.call_location');
+      // Without usable coordinates the helper navigates to the address instead.
+      const success = await openMapsWithDirections(coordinates.latitude, coordinates.longitude, destinationName, userLatitude || undefined, userLongitude || undefined, routableAddress);
 
       if (!success) {
         showToast('error', t('call_detail.failed_to_open_maps'));

src/app/call/__tests__/[id].test.tsx

@@ -328,6 +328,17 @@ jest.mock('react-i18next', () => ({
   }),
 }));
 
+// Route hands the destination to the navigation helper, which src/lib/__tests__/navigation.test.ts covers.
+const mockOpenMapsWithDirections = jest.fn();
+jest.mock('@/lib/navigation', () => ({
+  openMapsWithDirections: (...args: unknown[]) => mockOpenMapsWithDirections(...args),
+}));
+
+// How a withheld value is drawn is ProtectedText's concern; a plain stand-in suits this suite's light UI mocks.
+jest.mock('@/components/data-protection/protected-text', () => ({
+  ProtectedText: ({ value }: { value?: string | null }) => value ?? null,
+}));
+
 // React Native mocks
 jest.mock('react-native', () => ({
   View: jest.fn().mockImplementation(({ children, ...props }) => children),
@@ -779,4 +790,97 @@ describe('CallDetail', () => {
       });
     });
   });
+
+  describe('Route', () => {
+    const routableCall = {
+      CallId: 'test-call-id',
+      Name: 'Test Call',
+      Number: 'C2024001',
+      Priority: 2,
+      Type: 'Emergency',
+      Address: ' 123 Main St ',
+      Latitude: '40.7128',
+      Longitude: '-74.0060',
+      NotesCount: 0,
+      ImgagesCount: 0,
+      FileCount: 0,
+    };
+
+    const mockShowToast = jest.fn();
+
+    const setCall = (call: Record<string, unknown>) => {
+      mockUseCallDetailStore.mockImplementation((selector: any) => {
+        const store = { call, callExtraData: null, callPriority: null, isLoading: false, error: null, fetchCallDetail: jest.fn(), reset: jest.fn() };
+        return selector ? selector(store) : store;
+      });
+    };
+
+    beforeEach(() => {
+      mockOpenMapsWithDirections.mockReset();
+      mockOpenMapsWithDirections.mockResolvedValue(true);
+      mockShowToast.mockReset();
+      mockUseToastStore.mockImplementation((selector: any) => {
+        const store = { showToast: mockShowToast };
+        return selector ? selector(store) : store;
+      });
+    });
+
+    it('routes to the call coordinates, named by the trimmed address, with the address as the fallback', async () => {
+      setCall(routableCall);
+
+      const { getByTestId } = render(<CallDetail />);
+      fireEvent.press(getByTestId('button--common.route'));
+
+      await waitFor(() => {
+        expect(mockOpenMapsWithDirections).toHaveBeenCalledWith(40.7128, -74.006, '123 Main St', 40.7128, -74.006, '123 Main St');
+      });
+    });
+
+    it('routes to the address when the call has no usable coordinates', async () => {
+      setCall({ ...routableCall, Latitude: '0', Longitude: '0' });
+
+      const { getByTestId } = render(<CallDetail />);
+      fireEvent.press(getByTestId('button--common.route'));
+
+      await waitFor(() => {
+        expect(mockOpenMapsWithDirections).toHaveBeenCalledWith(null, null, '123 Main St', 40.7128, -74.006, '123 Main St');
+      });
+      expect(mockShowToast).not.toHaveBeenCalled();
+    });
+
+    it('keeps a withheld address out of the navigation app', async () => {
+      setCall({ ...routableCall, RedactedFields: ['calls.address'] });
+
+      const { getByTestId } = render(<CallDetail />);
+      fireEvent.press(getByTestId('button--common.route'));
+
+      await waitFor(() => {
+        expect(mockOpenMapsWithDirections).toHaveBeenCalledWith(40.7128, -74.006, 'call_detail.call_location', 40.7128, -74.006, '');
+      });
+    });
+
+    it('opens nothing and explains why without coordinates or a usable address', async () => {
+      setCall({ ...routableCall, Latitude: '0', Longitude: '0', RedactedFields: ['calls.address'] });
+
+      const { getByTestId } = render(<CallDetail />);
+      fireEvent.press(getByTestId('button--common.route'));
+
+      await waitFor(() => {
+        expect(mockShowToast).toHaveBeenCalledWith('error', 'call_detail.no_location_for_routing');
+      });
+      expect(mockOpenMapsWithDirections).not.toHaveBeenCalled();
+    });
+
+    it('tells the user when no navigation app opened', async () => {
+      mockOpenMapsWithDirections.mockResolvedValue(false);
+      setCall(routableCall);
+
+      const { getByTestId } = render(<CallDetail />);
+      fireEvent.press(getByTestId('button--common.route'));
+
+      await waitFor(() => {
+        expect(mockShowToast).toHaveBeenCalledWith('error', 'call_detail.failed_to_open_maps');
+      });
+    });
+  });
 });

src/components/contacts/contact-details-extra.tsx

@@ -1,16 +1,16 @@
 import { LockIcon } from 'lucide-react-native';
 import React, { useCallback, useEffect } from 'react';
 import { useTranslation } from 'react-i18next';
-import { Linking, View } from 'react-native';
+import { View } from 'react-native';
 
 import { ProtectedRevealBar } from '@/components/data-protection/protected-reveal-bar';
 import { HStack } from '@/components/ui/hstack';
 import { HomeIcon, MapPinIcon, SettingsIcon } from '@/components/ui/lucide-icons';
 import { Pressable } from '@/components/ui/pressable';
 import { Text } from '@/components/ui/text';
 import { VStack } from '@/components/ui/vstack';
-import { mapsUrls } from '@/lib/contacts/format';
-import { logger } from '@/lib/logging';
+import { parseCoordinates } from '@/lib/contacts/format';
+import { openMapsWithAddress, openMapsWithDirections } from '@/lib/navigation';
 import { type ContactAddressData, type ContactResultData } from '@/models/v4/contacts/contactResultData';
 import { useContactsStore } from '@/stores/contacts/store';
 
@@ -20,17 +20,14 @@ interface ContactDetailsExtraProps {
   showCustomFields?: boolean;
 }
 
+// Opens the navigation app chosen in Settings, which also logs a failure. A "lat,lng" value routes to the point.
 const openMaps = async (query: string) => {
-  const { app, web } = mapsUrls(query);
-  try {
-    if (app && (await Linking.canOpenURL(app))) {
-      await Linking.openURL(app);
-      return;
-    }
-    await Linking.openURL(web);
-  } catch (error) {
-    logger.warn({ message: 'Could not open maps for contact address', context: { error } });
+  const coordinates = parseCoordinates(query);
+  if (coordinates) {
+    await openMapsWithDirections(coordinates.latitude, coordinates.longitude, undefined, undefined, undefined, query);
+    return;
   }
+  await openMapsWithAddress(query);
 };
 
 const AddressRow = ({ label, address }: { label: string; address: ContactAddressData }) => {

src/components/contacts/contact-details-sheet.tsx

@@ -1,7 +1,7 @@
 import { router } from 'expo-router';
 import React, { useCallback, useState } from 'react';
 import { useTranslation } from 'react-i18next';
-import { Linking, Platform, ScrollView, useWindowDimensions, View } from 'react-native';
+import { Linking, ScrollView, useWindowDimensions, View } from 'react-native';
 
 import { LocationHistoryPanel } from '@/components/calls/location-history-panel';
 import { Avatar, AvatarImage } from '@/components/ui/avatar';
@@ -26,6 +26,7 @@ import {
 import { useAnalytics } from '@/hooks/use-analytics';
 import { htmlToText, withoutRedacted } from '@/lib/contacts/format';
 import { logger } from '@/lib/logging';
+import { openMapsWithAddress } from '@/lib/navigation';
 import { ContactType } from '@/models/v4/contacts/contactResultData';
 import { useContactsStore } from '@/stores/contacts/store';
 import { TermKeys, useTerm } from '@/stores/terminology/store';
@@ -84,8 +85,13 @@ const ContactField: React.FC<ContactFieldProps> = ({ label, value, icon, isLink,
   const handlePress = useCallback(async () => {
     if (action === 'none' || !value) return;
 
+    if (action === 'address') {
+      // The navigation app chosen in Settings; the helper owns the per-platform URLs, the fallbacks and the failure log.
+      await openMapsWithAddress(fullAddress || value.toString());
+      return;
+    }
+
     let url: string | null = null;
-    let webFallbackUrl: string | null = null;
 
     switch (action) {
       case 'email':
@@ -94,17 +100,6 @@ const ContactField: React.FC<ContactFieldProps> = ({ label, value, icon, isLink,
       case 'phone':
         url = `tel:${value.toString().replace(/[^0-9+]/g, '')}`;
         break;
-      case 'address': {
-        const addressToOpen = fullAddress || value.toString();
-        const encodedAddress = encodeURIComponent(addressToOpen);
-        webFallbackUrl = `https://maps.google.com/?q=${encodedAddress}`;
-        url = Platform.select({
-          ios: `maps:0,0?q=${encodedAddress}`,
-          android: `geo:0,0?q=${encodedAddress}`,
-          default: webFallbackUrl,
-        });
-        break;
-      }
       case 'website': {
         const websiteUrl = value.toString();
         url = websiteUrl.startsWith('http') ? websiteUrl : `https://${websiteUrl}`;
@@ -117,9 +112,6 @@ const ContactField: React.FC<ContactFieldProps> = ({ label, value, icon, isLink,
         const canOpen = await Linking.canOpenURL(url);
         if (canOpen) {
           await Linking.openURL(url);
-        } else if (action === 'address' && webFallbackUrl) {
-          // Fallback to Google Maps web URL for address action
-          await Linking.openURL(webFallbackUrl);
         } else {
           logger.warn({
             message: 'Cannot open URL',
@@ -131,18 +123,6 @@ const ContactField: React.FC<ContactFieldProps> = ({ label, value, icon, isLink,
           message: 'Failed to open URL from contact details',
           context: { error, url, action },
         });
-
-        // For address action, attempt web fallback on error
-        if (action === 'address' && webFallbackUrl) {
-          try {
-            await Linking.openURL(webFallbackUrl);
-          } catch (fallbackError) {
-            logger.error({
-              message: 'Failed to open fallback Google Maps URL',
-              context: { error: fallbackError, webFallbackUrl },
-            });
-          }
-        }
       }
     }
   }, [action, value, fullAddress]);