@umituz/react-native-location 1.0.0 → 1.0.3

package/src/infrastructure/services/LocationService.ts

@@ -1,298 +1,88 @@
-/**
- * Location Service Implementation
- *
- * Handles device location retrieval, permissions, caching, and reverse geocoding
- * with intelligent fallback strategies
- *
- * Features:
- * - Multi-tier accuracy fallback (High → Balanced → Cached)
- * - 15-minute location caching for performance
- * - Reverse geocoding with coordinate fallback
- * - Platform detection (iOS/Android only, no web)
- * - Silent failures (no console logging)
- * - AsyncStorage persistence
- *
- * Dependencies:
- * - expo-location (GPS and permissions API)
- * - AsyncStorage (cache persistence)
- *
- * USAGE:
- * ```typescript
- * import { locationService } from '@umituz/react-native-location';
- *
- * // Check permission
- * const hasPermission = await locationService.hasPermissions();
- *
- * // Request permission if needed
- * if (!hasPermission) {
- *   const granted = await locationService.requestPermissions();
- * }
- *
- * // Get current location
- * const location = await locationService.getCurrentLocation();
- * if (location) {
- *   console.log(location.latitude, location.longitude);
- *   console.log(locationService.formatLocation(location));
- * }
- * ```
- */
-
-import { Platform } from 'react-native';
-import * as Location from 'expo-location';
-import AsyncStorage from '@react-native-async-storage/async-storage';
-
-import type {
-  LocationData,
-  LocationPermissionStatus,
-  CachedLocation,
-  ILocationService,
-} from '../../domain/entities/Location';
-import { LOCATION_CONSTANTS } from '../../domain/entities/Location';
-
-class LocationService implements ILocationService {
-  private cachedLocation: LocationData | null = null;
-  private cachedAt: number = 0;
-  private permissionStatus: LocationPermissionStatus = 'unknown';
-
-  constructor() {
-    this.loadCachedLocation();
-  }
-
-  /**
-   * Check if location services are available on this platform
-   */
-  isLocationAvailable(): boolean {
-    // Location services not available on web
-    if (Platform.OS === 'web') {
-      return false;
-    }
-    return true;
-  }
-
-  /**
-   * Load cached location from AsyncStorage
-   */
-  private async loadCachedLocation(): Promise<void> {
-    try {
-      const cached = await AsyncStorage.getItem(LOCATION_CONSTANTS.CACHE_KEY);
-      if (cached) {
-        const parsed: CachedLocation = JSON.parse(cached);
-        if (Date.now() - parsed.cachedAt < LOCATION_CONSTANTS.CACHE_DURATION) {
-          this.cachedLocation = parsed.data;
-          this.cachedAt = parsed.cachedAt;
-        } else {
-          // Expired cache, remove it
-          await AsyncStorage.removeItem(LOCATION_CONSTANTS.CACHE_KEY);
+import * as Location from "expo-location";
+import { LocationData, LocationError } from "../../domain/entities/Location";
+
+export class LocationService {
+    /**
+     * Requests foreground location permissions.
+     * @returns boolean indicating if permission was granted.
+     */
+    async requestPermissions(): Promise<boolean> {
+        try {
+            console.log("[LocationService] Requesting permissions...");
+            const { status } = await Location.requestForegroundPermissionsAsync();
+            console.log("[LocationService] Permission status:", status);
+            return status === "granted";
+        } catch (error) {
+            console.error("[LocationService] Error requesting permissions:", error);
+            return false;
         }
-      }
-    } catch (error) {
-      // Silent failure on cache load
-    }
-  }
-
-  /**
-   * Save location to cache (AsyncStorage + memory)
-   */
-  private async saveCachedLocation(location: LocationData): Promise<void> {
-    try {
-      const cached: CachedLocation = {
-        data: location,
-        cachedAt: Date.now(),
-      };
-      this.cachedLocation = location;
-      this.cachedAt = cached.cachedAt;
-      await AsyncStorage.setItem(
-        LOCATION_CONSTANTS.CACHE_KEY,
-        JSON.stringify(cached)
-      );
-    } catch (error) {
-      // Silent failure on cache save
-    }
-  }
-
-  /**
-   * Get cached location if available and not expired
-   */
-  getCachedLocation(): LocationData | null {
-    if (!this.cachedLocation) {
-      return null;
-    }
-    const age = Date.now() - this.cachedAt;
-    if (age < LOCATION_CONSTANTS.CACHE_DURATION) {
-      return { ...this.cachedLocation, isCached: true };
-    }
-    return null;
-  }
-
-  /**
-   * Request location permissions from user
-   */
-  async requestPermissions(): Promise<boolean> {
-    if (!this.isLocationAvailable()) {
-      this.permissionStatus = 'denied';
-      return false;
-    }
-
-    try {
-      const { status } = await Location.requestForegroundPermissionsAsync();
-      this.permissionStatus = status === 'granted' ? 'granted' : 'denied';
-      return status === 'granted';
-    } catch (error) {
-      this.permissionStatus = 'denied';
-      return false;
-    }
-  }
-
-  /**
-   * Check if location permissions are granted
-   */
-  async hasPermissions(): Promise<boolean> {
-    if (!this.isLocationAvailable()) {
-      return false;
-    }
-
-    // Use cached permission status if available
-    if (this.permissionStatus !== 'unknown') {
-      return this.permissionStatus === 'granted';
     }
 
-    try {
-      const { status } = await Location.getForegroundPermissionsAsync();
-      this.permissionStatus = status === 'granted' ? 'granted' : 'denied';
-      return status === 'granted';
-    } catch (error) {
-      this.permissionStatus = 'denied';
-      return false;
-    }
-  }
-
-  /**
-   * Get permission status without requesting
-   */
-  getPermissionStatus(): LocationPermissionStatus {
-    return this.permissionStatus;
-  }
-
-  /**
-   * Get current location with fallback strategies
-   * Priority: High accuracy → Balanced accuracy → Cached location → null
-   */
-  async getCurrentLocation(): Promise<LocationData | null> {
-    if (!this.isLocationAvailable()) {
-      return null;
-    }
-
-    try {
-      const hasPermission = await this.hasPermissions();
-
-      if (!hasPermission) {
-        const granted = await this.requestPermissions();
-        if (!granted) {
-          // Return cached location if available
-          return this.getCachedLocation();
+    /**
+     * Gets the current position of the device.
+     * @param withAddress If true, also performs reverse geocoding.
+     */
+    async getCurrentPosition(withAddress: boolean = false): Promise<LocationData> {
+        console.log("[LocationService] getCurrentPosition called");
+        const hasPermission = await this.requestPermissions();
+        if (!hasPermission) {
+            console.warn("[LocationService] Permission denied");
+            throw { code: "PERMISSION_DENIED", message: "Location permission not granted" };
         }
-      }
-
-      // Try high accuracy first
-      let locationData = await this.getLocationWithAccuracy(
-        Location.Accuracy.High,
-        LOCATION_CONSTANTS.HIGH_ACCURACY_TIMEOUT
-      );
-
-      // Fallback to balanced accuracy if high accuracy fails
-      if (!locationData) {
-        locationData = await this.getLocationWithAccuracy(
-          Location.Accuracy.Balanced,
-          LOCATION_CONSTANTS.BALANCED_ACCURACY_TIMEOUT
-        );
-      }
-
-      // Fallback to cached location
-      if (!locationData) {
-        return this.getCachedLocation();
-      }
-
-      // Cache the new location
-      await this.saveCachedLocation(locationData);
 
-      return locationData;
-    } catch (error) {
-      // Return cached location as last resort
-      return this.getCachedLocation();
-    }
-  }
-
-  /**
-   * Get location with specific accuracy and timeout
-   */
-  private async getLocationWithAccuracy(
-    accuracy: Location.LocationAccuracy,
-    timeout: number
-  ): Promise<LocationData | null> {
-    try {
-      const location = (await Promise.race([
-        Location.getCurrentPositionAsync({ accuracy }),
-        new Promise<null>((_, reject) =>
-          setTimeout(() => reject(new Error('Timeout')), timeout)
-        ),
-      ])) as Location.LocationObject | null;
-
-      if (!location) {
-        return null;
-      }
-
-      const locationData: LocationData = {
-        latitude: location.coords.latitude,
-        longitude: location.coords.longitude,
-        timestamp: Date.now(),
-        accuracy: location.coords.accuracy ?? undefined,
-        isCached: false,
-      };
-
-      // Try to get address (reverse geocoding)
-      try {
-        const addresses = await Location.reverseGeocodeAsync({
-          latitude: location.coords.latitude,
-          longitude: location.coords.longitude,
-        });
-
-        if (addresses && addresses.length > 0) {
-          const address = addresses[0];
-          const addressParts = [address.street, address.city, address.region].filter(
-            Boolean
-          );
-
-          locationData.address =
-            addressParts.join(', ') || 'Unknown location';
+        try {
+            console.log("[LocationService] getting position async...");
+            const location = await Location.getCurrentPositionAsync({
+                accuracy: Location.Accuracy.Balanced,
+            });
+            console.log("[LocationService] position obtained", location);
+
+            let addressData;
+            if (withAddress) {
+                console.log("[LocationService] reverse geocoding...");
+                addressData = await this.reverseGeocode(
+                    location.coords.latitude,
+                    location.coords.longitude
+                );
+                console.log("[LocationService] address obtained", addressData);
+            }
+
+            return {
+                coords: {
+                    latitude: location.coords.latitude,
+                    longitude: location.coords.longitude,
+                },
+                timestamp: location.timestamp,
+                address: addressData,
+            };
+        } catch (error) {
+            console.error("[LocationService] Error getting location:", error);
+            // Type guard for error object
+            const errorMessage = error instanceof Error ? error.message : "Unknown error getting location";
+            throw { code: "LOCATION_ERROR", message: errorMessage };
         }
-      } catch (error) {
-        // Fallback to coordinates if geocoding fails
-        locationData.address = `${location.coords.latitude.toFixed(
-          LOCATION_CONSTANTS.COORDINATE_PRECISION
-        )}, ${location.coords.longitude.toFixed(LOCATION_CONSTANTS.COORDINATE_PRECISION)}`;
-      }
-
-      return locationData;
-    } catch (error) {
-      return null;
     }
-  }
 
-  /**
-   * Format location for display (address or coordinates)
-   */
-  formatLocation(location: LocationData): string {
-    if (location.address) {
-      return location.address;
+    /**
+     * Reverse geocodes coordinates to an address.
+     */
+    async reverseGeocode(latitude: number, longitude: number) {
+        try {
+            const [address] = await Location.reverseGeocodeAsync({ latitude, longitude });
+            if (!address) return undefined;
+
+            return {
+                city: address.city,
+                region: address.region,
+                country: address.country,
+                street: address.street,
+                formattedAddress: [address.city, address.country].filter(Boolean).join(", "),
+            };
+        } catch (error) {
+            console.warn("[LocationService] Reverse geocode failed:", error);
+            return undefined;
+        }
     }
-    return `${location.latitude.toFixed(
-      LOCATION_CONSTANTS.COORDINATE_PRECISION
-    )}, ${location.longitude.toFixed(LOCATION_CONSTANTS.COORDINATE_PRECISION)}`;
-  }
 }
 
-/**
- * Singleton instance
- * Use this for all location operations
- */
 export const locationService = new LocationService();

package/src/presentation/hooks/useLocation.ts

@@ -1,225 +1,42 @@
-/**
- * useLocation Hook
- *
- * React hook for device location services
- * Wraps locationService with React-friendly state management
- *
- * Features:
- * - Get current location with loading state
- * - Permission management
- * - Cached location access
- * - Error handling
- * - Format locations for display
- *
- * USAGE:
- * ```typescript
- * import { useLocation } from '@umituz/react-native-location';
- *
- * const MyComponent = () => {
- *   const {
- *     location,
- *     loading,
- *     error,
- *     hasPermission,
- *     requestPermission,
- *     getCurrentLocation,
- *     getCached,
- *     formatLocation,
- *   } = useLocation();
- *
- *   useEffect(() => {
- *     // Auto-fetch location on mount
- *     getCurrentLocation();
- *   }, []);
- *
- *   if (loading) return <LoadingIndicator />;
- *   if (error) return <ErrorMessage message={error} />;
- *
- *   return (
- *     <View>
- *       {location && (
- *         <Text>Location: {formatLocation(location)}</Text>
- *       )}
- *       <AtomicButton onPress={getCurrentLocation}>
- *         Refresh Location
- *       </AtomicButton>
- *     </View>
- *   );
- * };
- * ```
- */
-
-import { useState, useCallback, useEffect } from 'react';
-import { locationService } from '../../infrastructure/services/LocationService';
-import type {
-  LocationData,
-  LocationPermissionStatus,
-} from '../../domain/entities/Location';
-
-export interface UseLocationReturn {
-  /** Current location data (null if not retrieved) */
-  location: LocationData | null;
-
-  /** Loading state during location retrieval */
-  loading: boolean;
-
-  /** Error message if location retrieval failed */
-  error: string | null;
-
-  /** Current permission status */
-  permissionStatus: LocationPermissionStatus;
-
-  /** Whether location permissions are granted */
-  hasPermission: boolean;
-
-  /** Whether location services are available on this platform */
-  isAvailable: boolean;
-
-  /**
-   * Request location permissions from user
-   * @returns Promise resolving to true if granted
-   */
-  requestPermission: () => Promise<boolean>;
-
-  /**
-   * Get current location with fallback strategies
-   * Updates location state and handles errors
-   */
-  getCurrentLocation: () => Promise<void>;
-
-  /**
-   * Get cached location if available
-   * @returns Cached location or null
-   */
-  getCached: () => LocationData | null;
-
-  /**
-   * Format location for display
-   * @param loc - LocationData to format
-   * @returns Formatted string (address or coordinates)
-   */
-  formatLocation: (loc: LocationData) => string;
-
-  /**
-   * Clear current location state
-   */
-  clearLocation: () => void;
+import { useState, useCallback } from "react";
+import { locationService } from "../../infrastructure/services/LocationService";
+import { LocationData, LocationError } from "../../domain/entities/Location";
+
+export interface UseLocationResult {
+    location: LocationData | null;
+    isLoading: boolean;
+    error: LocationError | null;
+    getCurrentLocation: () => Promise<LocationData | null>;
 }
 
-/**
- * Hook for device location services
- */
-export const useLocation = (): UseLocationReturn => {
-  const [location, setLocation] = useState<LocationData | null>(null);
-  const [loading, setLoading] = useState<boolean>(false);
-  const [error, setError] = useState<string | null>(null);
-  const [permissionStatus, setPermissionStatus] =
-    useState<LocationPermissionStatus>('unknown');
-
-  // Check if location services are available
-  const isAvailable = locationService.isLocationAvailable();
-
-  // Check initial permission status
-  useEffect(() => {
-    const checkPermission = async () => {
-      const hasPermission = await locationService.hasPermissions();
-      setPermissionStatus(
-        hasPermission ? 'granted' : locationService.getPermissionStatus()
-      );
-    };
+export function useLocation(): UseLocationResult {
+    const [location, setLocation] = useState<LocationData | null>(null);
+    const [isLoading, setIsLoading] = useState(false);
+    const [error, setError] = useState<LocationError | null>(null);
 
-    if (isAvailable) {
-      checkPermission();
-    }
-  }, [isAvailable]);
-
-  /**
-   * Request location permissions
-   */
-  const requestPermission = useCallback(async (): Promise<boolean> => {
-    if (!isAvailable) {
-      setError('Location services not available on this platform');
-      setPermissionStatus('denied');
-      return false;
-    }
-
-    try {
-      const granted = await locationService.requestPermissions();
-      setPermissionStatus(granted ? 'granted' : 'denied');
-
-      if (!granted) {
-        setError('Location permission denied');
-      }
-
-      return granted;
-    } catch (err) {
-      setError('Failed to request location permission');
-      setPermissionStatus('denied');
-      return false;
-    }
-  }, [isAvailable]);
-
-  /**
-   * Get current location with fallback strategies
-   */
-  const getCurrentLocation = useCallback(async (): Promise<void> => {
-    if (!isAvailable) {
-      setError('Location services not available on this platform');
-      return;
-    }
-
-    setLoading(true);
-    setError(null);
-
-    try {
-      const currentLocation = await locationService.getCurrentLocation();
-
-      if (currentLocation) {
-        setLocation(currentLocation);
+    const getCurrentLocation = useCallback(async () => {
+        setIsLoading(true);
         setError(null);
-      } else {
-        setError('Unable to retrieve location');
-      }
-    } catch (err) {
-      setError('Failed to get location');
-    } finally {
-      setLoading(false);
-    }
-  }, [isAvailable]);
-
-  /**
-   * Get cached location
-   */
-  const getCached = useCallback((): LocationData | null => {
-    return locationService.getCachedLocation();
-  }, []);
-
-  /**
-   * Format location for display
-   */
-  const formatLocation = useCallback((loc: LocationData): string => {
-    return locationService.formatLocation(loc);
-  }, []);
-
-  /**
-   * Clear location state
-   */
-  const clearLocation = useCallback((): void => {
-    setLocation(null);
-    setError(null);
-  }, []);
-
-  return {
-    location,
-    loading,
-    error,
-    permissionStatus,
-    hasPermission: permissionStatus === 'granted',
-    isAvailable,
-    requestPermission,
-    getCurrentLocation,
-    getCached,
-    formatLocation,
-    clearLocation,
-  };
-};
+        try {
+            const data = await locationService.getCurrentPosition(true);
+            setLocation(data);
+            return data;
+        } catch (err: any) {
+            const errorObj = {
+                code: err.code || "UNKNOWN_ERROR",
+                message: err.message || "An unknown error occurred",
+            };
+            setError(errorObj);
+            return null;
+        } finally {
+            setIsLoading(false);
+        }
+    }, []);
+
+    return {
+        location,
+        isLoading,
+        error,
+        getCurrentLocation,
+    };
+}

package/LICENSE

@@ -1,22 +0,0 @@
-MIT License
-
-Copyright (c) 2024 Ümit UZ
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-