@umituz/react-native-location 1.0.27 → 1.0.28

package/src/infrastructure/services/LocationService.ts

@@ -1,13 +1,18 @@
+/**
+ * Infrastructure Layer - Location Service
+ *
+ * Refactored location service using domain services and ports.
+ * DRY principle - no code duplication.
+ */
+
 import * as Location from "expo-location";
-import { storageRepository, unwrap } from "@umituz/react-native-design-system/storage";
-import {
-    LocationData,
-    LocationAddress,
-    LocationConfig,
-    LocationError,
-    LocationErrorCode,
-} from "../../types/location.types";
-import { LocationUtils } from "../utils/LocationUtils";
+import { LocationData, LocationAddress, LocationConfig } from "../../types/location.types";
+import { ILocationPort } from "../../application/ports/ILocationPort";
+import { ICachePort } from "../../application/ports/ICachePort";
+import { ILoggerPort } from "../../application/ports/ILoggerPort";
+import { PermissionService } from "../../domain/services/PermissionService";
+import { LocationErrors } from "../../domain/errors/LocationErrors";
+import { CacheUtils } from "../repositories/LocationCache.repository";
 
 interface CachedLocationData {
     location: LocationData;
@@ -23,67 +28,20 @@ const DEFAULT_CONFIG: Required<LocationConfig> = {
     withAddress: true,
 };
 
-export class LocationService {
+export class LocationService implements ILocationPort {
     private config: Required<LocationConfig>;
     private inFlightRequest: Promise<LocationData> | null = null;
 
-    constructor(config: LocationConfig = {}) {
+    constructor(
+        private cache: ICachePort,
+        private logger: ILoggerPort,
+        config: LocationConfig = {}
+    ) {
         this.config = { ...DEFAULT_CONFIG, ...config };
     }
 
-    async requestPermissions(): Promise<boolean> {
-        try {
-            const { status: current } = await Location.getForegroundPermissionsAsync();
-            if (current === "granted") return true;
-
-            if (__DEV__) console.log("[LocationService] Requesting permissions...");
-            const { status } = await Location.requestForegroundPermissionsAsync();
-            return status === "granted";
-        } catch (error) {
-            if (__DEV__) console.error("[LocationService] Error requesting permissions:", error);
-            return false;
-        }
-    }
-
-    private getCacheKey(): string {
-        return LocationUtils.generateCacheKey(this.config.cacheKey, this.config.withAddress);
-    }
-
-    private async getCachedLocation(): Promise<LocationData | null> {
-        if (!this.config.enableCache) return null;
-
-        try {
-            const cacheKey = this.getCacheKey();
-            const result = await storageRepository.getItem<CachedLocationData | null>(cacheKey, null);
-            const cached = unwrap(result, null);
-
-            if (!cached) return null;
-
-            if (LocationUtils.isCacheExpired(cached.timestamp, this.config.cacheDuration)) {
-                await storageRepository.removeItem(cacheKey);
-                return null;
-            }
-
-            if (__DEV__) console.log("[LocationService] Using cached location");
-            return cached.location;
-        } catch (error) {
-            if (__DEV__) console.error("[LocationService] Cache read error:", error);
-            return null;
-        }
-    }
-
-    private async cacheLocation(location: LocationData): Promise<void> {
-        if (!this.config.enableCache) return;
-
-        try {
-            const data: CachedLocationData = { location, timestamp: Date.now() };
-            await storageRepository.setItem(this.getCacheKey(), data);
-        } catch (error) {
-            if (__DEV__) console.error("[LocationService] Cache write error:", error);
-        }
-    }
-
     async getCurrentPosition(): Promise<LocationData> {
+        // Request deduplication
         if (this.inFlightRequest) {
             return this.inFlightRequest;
         }
@@ -97,42 +55,65 @@ export class LocationService {
     }
 
     private async fetchPosition(): Promise<LocationData> {
+        // Cache check
         const cached = await this.getCachedLocation();
         if (cached) return cached;
 
-        const hasPermission = await this.requestPermissions();
+        // Permission check
+        const hasPermission = await PermissionService.request();
         if (!hasPermission) {
-            throw this.createError("PERMISSION_DENIED", "Location permission not granted");
+            throw LocationErrors.permissionDenied();
         }
 
-        try {
-            const location = await this.getPositionWithTimeout();
+        // Fetch with timeout
+        const location = await this.getPositionWithTimeout();
 
-            let address: LocationAddress | undefined;
-            if (this.config.withAddress) {
-                address = await this.reverseGeocode(
-                    location.coords.latitude,
-                    location.coords.longitude,
-                );
-            }
+        // Optional reverse geocoding
+        let address: LocationAddress | undefined;
+        if (this.config.withAddress) {
+            address = await this.reverseGeocode(
+                location.coords.latitude,
+                location.coords.longitude
+            );
+        }
 
-            const locationData: LocationData = {
-                coords: {
-                    latitude: location.coords.latitude,
-                    longitude: location.coords.longitude,
-                },
-                timestamp: location.timestamp,
-                address,
-            };
+        const locationData: LocationData = {
+            coords: {
+                latitude: location.coords.latitude,
+                longitude: location.coords.longitude,
+            },
+            timestamp: location.timestamp,
+            address,
+        };
+
+        await this.cacheLocation(locationData);
+        return locationData;
+    }
 
-            await this.cacheLocation(locationData);
-            return locationData;
-        } catch (error) {
-            if (__DEV__) console.error("[LocationService] Error getting location:", error);
+    private async getCachedLocation(): Promise<LocationData | null> {
+        if (!this.config.enableCache) return null;
+
+        const cacheKey = CacheUtils.generateKey(this.config.cacheKey, this.config.withAddress);
+        const cached = await this.cache.get(cacheKey);
+
+        if (!cached) return null;
 
-            const message = error instanceof Error ? error.message : "Unknown error getting location";
-            throw this.createError("UNKNOWN_ERROR", message);
+        if (CacheUtils.isExpired(cached.timestamp, this.config.cacheDuration)) {
+            await this.cache.remove(cacheKey);
+            return null;
         }
+
+        this.logger.debug("Using cached location");
+        return cached.location;
+    }
+
+    private async cacheLocation(location: LocationData): Promise<void> {
+        if (!this.config.enableCache) return;
+
+        const cacheKey = CacheUtils.generateKey(this.config.cacheKey, this.config.withAddress);
+        const data: CachedLocationData = { location, timestamp: Date.now() };
+
+        await this.cache.set(cacheKey, data);
     }
 
     private async getPositionWithTimeout(): Promise<Location.LocationObject> {
@@ -144,17 +125,18 @@ export class LocationService {
 
         const timeoutPromise = new Promise<never>((_, reject) => {
             timeoutId = setTimeout(() => {
-                reject(this.createError("TIMEOUT", `Location request timed out after ${this.config.timeout}ms`));
+                reject(
+                    LocationErrors.timeout(
+                        `Location request timed out after ${this.config.timeout}ms`
+                    )
+                );
             }, this.config.timeout);
         });
 
         try {
-            const result = await Promise.race([locationPromise, timeoutPromise]);
-            return result;
+            return await Promise.race([locationPromise, timeoutPromise]);
         } finally {
-            if (timeoutId !== null) {
-                clearTimeout(timeoutId);
-            }
+            if (timeoutId !== null) clearTimeout(timeoutId);
         }
     }
 
@@ -163,30 +145,35 @@ export class LocationService {
             const [address] = await Location.reverseGeocodeAsync({ latitude, longitude });
             if (!address) return undefined;
 
-            return LocationUtils.buildFormattedAddress(address);
+            return this.buildAddress(address);
         } catch (error) {
-            if (__DEV__) console.error("[LocationService] Reverse geocode failed:", error);
+            this.logger.error("Reverse geocode failed", error);
             return undefined;
         }
     }
 
+    private buildAddress(
+        address: Pick<Location.LocationGeocodedAddress, "street" | "city" | "region" | "country">
+    ): LocationAddress {
+        const parts = [address.street, address.city, address.region, address.country].filter(
+            Boolean
+        ) as string[];
+
+        return {
+            city: address.city ?? null,
+            region: address.region ?? null,
+            country: address.country ?? null,
+            street: address.street ?? null,
+            formattedAddress: parts.length > 0 ? parts.join(", ") : null,
+        };
+    }
+
     async isLocationEnabled(): Promise<boolean> {
-        try {
-            return await Location.hasServicesEnabledAsync();
-        } catch (error) {
-            if (__DEV__) console.error("[LocationService] Error checking location enabled:", error);
-            return false;
-        }
+        return PermissionService.areServicesEnabled();
     }
 
-    async getPermissionStatus(): Promise<Location.PermissionStatus> {
-        try {
-            const { status } = await Location.getForegroundPermissionsAsync();
-            return status;
-        } catch (error) {
-            if (__DEV__) console.error("[LocationService] Error getting permission status:", error);
-            return Location.PermissionStatus.UNDETERMINED;
-        }
+    async getPermissionStatus(): Promise<string> {
+        return await PermissionService.getStatus();
     }
 
     async getLastKnownPosition(): Promise<LocationData | null> {
@@ -202,15 +189,8 @@ export class LocationService {
                 timestamp: location.timestamp,
             };
         } catch (error) {
-            if (__DEV__) console.error("[LocationService] Error getting last known position:", error);
+            this.logger.error("Error getting last known position", error);
             return null;
         }
     }
-
-    private createError(code: LocationErrorCode, message: string): LocationError & Error {
-        const error = new Error(message) as Error & LocationError;
-        error.name = "LocationError";
-        error.code = code;
-        return error;
-    }
 }

package/src/infrastructure/services/LocationWatcherService.ts

@@ -0,0 +1,95 @@
+/**
+ * Infrastructure Layer - Location Watcher Service
+ *
+ * Refactored watcher using domain services.
+ * Shares permission logic with LocationService (DRY).
+ */
+
+import * as Location from "expo-location";
+import { LocationData, LocationWatcherOptions } from "../../types/location.types";
+import { ILocationWatcherPort } from "../../application/ports/ILocationPort";
+import { ILoggerPort } from "../../application/ports/ILoggerPort";
+import { PermissionService } from "../../domain/services/PermissionService";
+import { LocationErrors } from "../../domain/errors/LocationErrors";
+
+const DEFAULT_OPTIONS: Required<LocationWatcherOptions> = {
+    accuracy: Location.Accuracy.Balanced,
+    distanceInterval: 10,
+    timeInterval: 10000,
+};
+
+export class LocationWatcher implements ILocationWatcherPort {
+    private subscription: Location.LocationSubscription | null = null;
+    private options: Required<LocationWatcherOptions>;
+
+    constructor(
+        private logger: ILoggerPort,
+        options: LocationWatcherOptions = {}
+    ) {
+        this.options = { ...DEFAULT_OPTIONS, ...options };
+    }
+
+    async watchPosition(
+        onSuccess: (location: LocationData) => void,
+        onError?: (error: Error) => void
+    ): Promise<void> {
+        this.clearWatch();
+
+        // Permission check
+        const hasPermission = await PermissionService.request();
+        if (!hasPermission) {
+            const error = LocationErrors.permissionDenied();
+            onError?.(error);
+            return;
+        }
+
+        try {
+            this.subscription = await Location.watchPositionAsync(
+                {
+                    accuracy: this.options.accuracy,
+                    distanceInterval: this.options.distanceInterval,
+                    timeInterval: this.options.timeInterval,
+                },
+                (location) => {
+                    onSuccess(this.mapToLocationData(location));
+                }
+            );
+
+            this.logger.debug("Started watching location");
+        } catch (error) {
+            const locationError = this.handleError(error);
+            onError?.(locationError);
+        }
+    }
+
+    clearWatch(): void {
+        if (this.subscription) {
+            this.logger.debug("Clearing location watch");
+            this.subscription.remove();
+            this.subscription = null;
+        }
+    }
+
+    isWatching(): boolean {
+        return this.subscription !== null;
+    }
+
+    private mapToLocationData(location: Location.LocationObject): LocationData {
+        return {
+            coords: {
+                latitude: location.coords.latitude,
+                longitude: location.coords.longitude,
+            },
+            timestamp: location.timestamp,
+        };
+    }
+
+    private handleError(error: unknown): Error {
+        this.logger.error("Error watching position", error);
+
+        const code = LocationErrors.extractErrorCode(error);
+        const message = LocationErrors.extractMessage(error);
+
+        return LocationErrors.unknown(message);
+    }
+}

package/src/infrastructure/utils/Accuracy.utils.ts

@@ -0,0 +1,51 @@
+/**
+ * Infrastructure Layer - Accuracy Utilities
+ *
+ * Accuracy formatting and validation utilities.
+ * Extracted from LocationUtils for single responsibility.
+ */
+
+export class AccuracyUtils {
+    private static readonly EXCELLENT_THRESHOLD = 10;
+    private static readonly GOOD_THRESHOLD = 50;
+    private static readonly FAIR_THRESHOLD = 100;
+    private static readonly DEFAULT_MAX_ACCURACY = 100;
+
+    /**
+     * Accuracy değerini formatla
+     */
+    static format(accuracy: number | null | undefined): string {
+        if (accuracy === null || accuracy === undefined) {
+            return "Unknown";
+        }
+
+        if (accuracy < this.EXCELLENT_THRESHOLD) {
+            return `Excellent (±${Math.round(accuracy)}m)`;
+        }
+        if (accuracy < this.GOOD_THRESHOLD) {
+            return `Good (±${Math.round(accuracy)}m)`;
+        }
+        if (accuracy < this.FAIR_THRESHOLD) {
+            return `Fair (±${Math.round(accuracy)}m)`;
+        }
+        return `Poor (±${Math.round(accuracy)}m)`;
+    }
+
+    /**
+     * Accuracy değeri geçerli mi?
+     */
+    static isValid(
+        accuracy: number | null | undefined,
+        maxAccuracy = this.DEFAULT_MAX_ACCURACY
+    ): boolean {
+        if (accuracy === null || accuracy === undefined) {
+            return false;
+        }
+
+        if (!Number.isFinite(accuracy)) {
+            return false;
+        }
+
+        return accuracy > 0 && accuracy <= maxAccuracy;
+    }
+}

package/src/infrastructure/utils/ObjectComparison.utils.ts

@@ -0,0 +1,22 @@
+/**
+ * Infrastructure Layer - Object Comparison Utilities
+ *
+ * Deep comparison utilities for React hooks.
+ * Used for stable reference generation.
+ */
+
+export class ObjectComparison {
+    /**
+     * İki objeyi derinlemesine karşılaştır
+     */
+    static deepEqual(obj1: unknown, obj2: unknown): boolean {
+        return JSON.stringify(obj1) === JSON.stringify(obj2);
+    }
+
+    /**
+     * Stable string referans oluştur
+     */
+    static getStableReference(obj: unknown): string {
+        return JSON.stringify(obj ?? {});
+    }
+}

package/src/presentation/hooks/useLocationHook.ts

@@ -0,0 +1,99 @@
+/**
+ * Presentation Layer - useLocation Hook
+ *
+ * Refactored using domain errors and ports.
+ * Simplified error handling using LocationErrors.
+ */
+
+import { useState, useCallback, useRef, useEffect } from "react";
+import { LocationService } from "../../infrastructure/services/LocationService";
+import { LocationCacheRepository } from "../../infrastructure/repositories/LocationCache.repository";
+import { LocationLogger } from "../../infrastructure/services/LocationLoggerService";
+import { LocationData, LocationError, LocationConfig } from "../../types/location.types";
+import { LocationErrors } from "../../domain/errors/LocationErrors";
+import { ILoggerPort } from "../../application/ports/ILoggerPort";
+
+// Default logger instance
+const defaultLogger: ILoggerPort = new LocationLogger("useLocation");
+
+export interface UseLocationResult {
+    location: LocationData | null;
+    isLoading: boolean;
+    error: LocationError | null;
+    getCurrentLocation: () => Promise<LocationData | null>;
+}
+
+/**
+ * Stable reference generator for config comparison
+ */
+function getStableReference(obj: unknown): string {
+    return JSON.stringify(obj ?? {});
+}
+
+export function useLocation(
+    config?: LocationConfig,
+    logger: ILoggerPort = defaultLogger
+): UseLocationResult {
+    // Stable references for config and service
+    const configStringRef = useRef<string>(getStableReference(config));
+    const serviceRef = useRef<LocationService | null>(null);
+
+    // Update service when config changes
+    const currentConfigString = getStableReference(config);
+    if (configStringRef.current !== currentConfigString) {
+        configStringRef.current = currentConfigString;
+        serviceRef.current = new LocationService(
+            new LocationCacheRepository(),
+            logger,
+            config
+        );
+    }
+
+    // Initialize service on first render
+    if (!serviceRef.current) {
+        serviceRef.current = new LocationService(new LocationCacheRepository(), logger, config);
+    }
+
+    const [location, setLocation] = useState<LocationData | null>(null);
+    const [isLoading, setIsLoading] = useState(false);
+    const [error, setError] = useState<LocationError | null>(null);
+    const mountedRef = useRef(true);
+
+    useEffect(() => {
+        mountedRef.current = true;
+        return () => {
+            mountedRef.current = false;
+        };
+    }, []);
+
+    const getCurrentLocation = useCallback(async () => {
+        if (!serviceRef.current) return null;
+
+        setIsLoading(true);
+        setError(null);
+
+        try {
+            const data = await serviceRef.current.getCurrentPosition();
+            if (mountedRef.current) {
+                setLocation(data);
+            }
+            return data;
+        } catch (err) {
+            const locationError: LocationError = {
+                code: LocationErrors.extractErrorCode(err),
+                message: LocationErrors.extractMessage(err),
+            };
+
+            if (mountedRef.current) {
+                setError(locationError);
+            }
+            return null;
+        } finally {
+            if (mountedRef.current) {
+                setIsLoading(false);
+            }
+        }
+    }, [configStringRef]);
+
+    return { location, isLoading, error, getCurrentLocation };
+}

package/src/presentation/hooks/useLocationWatchHook.ts

@@ -0,0 +1,98 @@
+/**
+ * Presentation Layer - useLocationWatch Hook
+ *
+ * Refactored using LocationWatcher and domain services.
+ * Simplified state management.
+ */
+
+import { useEffect, useRef, useState, useCallback } from "react";
+import { LocationWatcher } from "../../infrastructure/services/LocationWatcherService";
+import { LocationLogger } from "../../infrastructure/services/LocationLoggerService";
+import { LocationData, LocationError, LocationWatcherOptions } from "../../types/location.types";
+import { ILoggerPort } from "../../application/ports/ILoggerPort";
+import { LocationErrors } from "../../domain/errors/LocationErrors";
+
+// Default logger instance
+const defaultLogger: ILoggerPort = new LocationLogger("useLocationWatch");
+
+export interface UseLocationWatchResult {
+    location: LocationData | null;
+    error: LocationError | null;
+    isWatching: boolean;
+    startWatching: () => Promise<void>;
+    stopWatching: () => void;
+}
+
+/**
+ * Stable reference generator for options comparison
+ */
+function getStableReference(obj: unknown): string {
+    return JSON.stringify(obj ?? {});
+}
+
+export function useLocationWatch(
+    options?: LocationWatcherOptions,
+    logger: ILoggerPort = defaultLogger
+): UseLocationWatchResult {
+    // Stable reference for options
+    const optionsStringRef = useRef<string>(getStableReference(options));
+    const watcherRef = useRef<LocationWatcher | null>(null);
+
+    // State
+    const [location, setLocation] = useState<LocationData | null>(null);
+    const [error, setError] = useState<LocationError | null>(null);
+    const [isWatching, setIsWatching] = useState(false);
+
+    // Initialize watcher on first render
+    if (!watcherRef.current) {
+        watcherRef.current = new LocationWatcher(logger, options);
+    }
+
+    const stopWatching = useCallback(() => {
+        if (watcherRef.current) {
+            watcherRef.current.clearWatch();
+            setIsWatching(false);
+        }
+    }, []);
+
+    const startWatching = useCallback(async () => {
+        if (!watcherRef.current) return;
+
+        stopWatching();
+        setError(null);
+
+        // Recreate watcher if options changed
+        const currentOptionsString = getStableReference(options);
+        if (optionsStringRef.current !== currentOptionsString) {
+            optionsStringRef.current = currentOptionsString;
+            watcherRef.current = new LocationWatcher(logger, options);
+        }
+
+        await watcherRef.current.watchPosition(
+            (data) => {
+                setLocation(data);
+                setError(null);
+            },
+            (err) => {
+                const locationError: LocationError = {
+                    code: LocationErrors.extractErrorCode(err),
+                    message: LocationErrors.extractMessage(err),
+                };
+                setError(locationError);
+                setIsWatching(false);
+            }
+        );
+
+        if (watcherRef.current.isWatching()) {
+            setIsWatching(true);
+        }
+    }, [optionsStringRef, stopWatching, logger, options]);
+
+    useEffect(() => {
+        return () => {
+            stopWatching();
+        };
+    }, [stopWatching]);
+
+    return { location, error, isWatching, startWatching, stopWatching };
+}