Opcja A
- User
Opcja A
Assistant
Świetnie, że wybrałeś Opcję A! Zaczniemy od podstawowej struktury aplikacji z śledzeniem GPS. Ponieważ nie mogę faktycznie stworzyć kodu w sposób interaktywny, przedstawię Ci plan działania, kluczowe komponenty i przykładowe fragmenty kodu, które pokazują, jak to zrobić przy użyciu React Native (framework do tworzenia aplikacji mobilnych na iOS i Android z JavaScript/TypeScript) i biblioteki Expo (ułatwia szybkie tworzenie i zarządzanie projektami React Native).
Cel: Podstawowa aplikacja śledząca GPS
Naszym celem jest stworzenie ekranu, który:
- Prosi o pozwolenie na dostęp do lokalizacji.
- Po uzyskaniu pozwolenia, zaczyna pobierać dane GPS (długość, szerokość, czas).
- Wyświetla aktualną pozycję na mapie.
- Rysuje ścieżkę przebytej trasy.
- Pokazuje podstawowe statystyki: przebyty dystans i czas.
- Posiada przycisk do rozpoczęcia i zatrzymania śledzenia.
Plan Działania i Kluczowe Komponenty:
-
Konfiguracja Projektu:
- Technologia: Użyjemy
Expo. Expo to zestaw narzędzi i usług, które ułatwiają tworzenie aplikacji React Native. Jest świetne do szybkiego prototypowania. - Instalacja: Potrzebujesz Node.js. Następnie zainstalujesz Expo CLI globalnie (
npm install -g expo-cli) i utworzysz nowy projekt (expo init MojaAplikacjaSportowa). - Dodatkowe Biblioteki: Będziemy potrzebować:
expo-location: Do dostępu do GPS.react-native-maps: Do wyświetlania map i rysowania tras.
- Technologia: Użyjemy
-
Zarządzanie Pozwoleniami:
- Aplikacje mobilne potrzebują zgody użytkownika na dostęp do wrażliwych danych, takich jak lokalizacja.
- Biblioteka
expo-locationzapewnia funkcje do pytania o pozwolenia (Location.requestForegroundPermissionsAsync). - Aplikacja powinna informować użytkownika, jeśli pozwolenie zostanie odmówione.
-
Komponent Śledzenia GPS:
- Stan aplikacji: Będziemy przechowywać informacje takie jak:
isTracking: czy aktualnie śledzimy trasę (boolean).locations: tablica obiektów{ latitude, longitude, timestamp }reprezentujących punkty trasy.currentDistance: aktualnie przebyty dystans (w metrach).elapsedTime: czas trwania bieżącej sesji (w sekundach).startTime: czas rozpoczęcia śledzenia.
- Funkcje:
startTracking():- Sprawdza pozwolenia.
- Ustawia
isTrackingnatrue. - Zapisuje
startTime. - Czyści poprzednie dane tras.
- Uruchamia
Location.watchPositionAsync, które regularnie dostarcza nowe dane o lokalizacji. - Każdy nowy punkt lokalizacji jest dodawany do tablicy
locations. - Obliczany jest dystans od poprzedniego punktu i sumowany.
stopTracking():- Zatrzymuje pobieranie danych GPS (
locationSubscription.remove()). - Ustawia
isTrackingnafalse. - W tym miejscu można zapisać zebrane dane do pamięci lokalnej (o czym później).
- Zatrzymuje pobieranie danych GPS (
- Obliczanie Dystansu: Do obliczenia odległości między dwoma punktami GPS (długość i szerokość geograficzna) użyjemy formuły Haversine.
- Stan aplikacji: Będziemy przechowywać informacje takie jak:
-
Wyświetlanie Mapy i Trasy:
- Biblioteka
react-native-maps: Pozwala na wyświetlanie interaktywnych map. - Konfiguracja OSM: Aby używać kafelków OpenStreetMap, zazwyczaj trzeba podać odpowiedni
providerlub skonfigurować niestandardowe adresy URL kafelków. Wreact-native-mapsdomyślnyPROVIDER_DEFAULTczęsto korzysta z danych OSM na platformach mobilnych, ale aby zapewnić dokładnie OSM i obsługę offline, może być potrzebna bardziej zaawansowana konfiguracja lub inne biblioteki. Na potrzeby tego podstawowego przykładu,PROVIDER_DEFAULTpozwoli nam zobaczyć mapę. - Komponent
MapView: Będzie centralnym elementem naszej mapy. - Komponent
Polyline: Użyjemy go do narysowania linii łączącej wszystkie punkty z tablicylocations. Linia ta będzie wizualizacją przebytej trasy. Marker: Oznaczy aktualną pozycję użytkownika na mapie.
- Biblioteka
-
Interfejs Użytkownika (UI):
- Proste przyciski "Start" / "Stop".
- Wyświetlanie aktualnego dystansu (np. w kilometrach) i czasu.
- Widok mapy.
Przykładowy Fragment Kodu (Głównego Komponentu
App.js):Poniżej przedstawiam, jak mógłby wyglądać główny plik aplikacji (
App.js), który łączy te elementy. Ten kod zakłada, że masz zainstalowane Expo i potrzebne pakiety (expo-location,react-native-maps).Aby uruchomić, utwórz nowy projekt Expo:
npx create-expo-app MojaAplikacjaSportowacd MojaAplikacjaSportowanpx expo install expo-location react-native-mapsNastępnie wklej poniższy kod do plikuApp.js.import React, { useState, useEffect, useRef } from 'react'; import { StyleSheet, Text, View, Button, Dimensions, Alert } from 'react-native'; import * as Location from 'expo-location'; import MapView, { Marker, Polyline, PROVIDER_DEFAULT } from 'react-native-maps'; // PROVIDER_DEFAULT używa map systemowych, które zazwyczaj pokazują dane OSM // Funkcja do obliczania odległości między dwoma punktami GPS (używa formuły Haversine) const calculateDistance = (point1, point2) => { const R = 6371e3; // Promień Ziemi w metrach const φ1 = point1.latitude * Math.PI / 180; // φ, λ w radianach const φ2 = point2.latitude * Math.PI / 180; const Δφ = (point2.latitude - point1.latitude) * Math.PI / 180; const Δλ = (point2.longitude - point1.longitude) * Math.PI / 180; const a = Math.sin(Δφ / 2) * Math.sin(Δφ / 2) + Math.cos(φ1) * Math.cos(φ2) * Math.sin(Δλ / 2) * Math.sin(Δλ / 2); const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a)); const d = R * c; // odległość w metrach return d; }; // Funkcja do formatowania czasu (sekundy na HH:MM:SS) const formatTime = (seconds) => { const h = Math.floor(seconds / 3600); const m = Math.floor((seconds % 3600) / 60); const s = Math.floor(seconds % 60); return `${h < 10 ? '0' : ''}${h}:${m < 10 ? '0' : ''}${m}:${s < 10 ? '0' : ''}${s}`; }; export default function App() { const [location, setLocation] = useState(null); // Aktualna pozycja const [locations, setLocations] = useState([]); // Tablica punktów trasy const [isTracking, setIsTracking] = useState(false); // Czy śledzimy const [currentDistance, setCurrentDistance] = useState(0); // Dystans w metrach const [elapsedTime, setElapsedTime] = useState(0); // Czas w sekundach const [startTime, setStartTime] = useState(null); // Moment rozpoczęcia śledzenia const mapRef = useRef(null); // Referencja do komponentu MapView let locationSubscription = null; // Zmienna do przechowywania subskrypcji lokalizacji // Hook useEffect do zarządzania pozwoleniami i pobierania pierwszej lokalizacji useEffect(() => { (async () => { // Prośba o pozwolenie na dostęp do lokalizacji w foregroundzie let { status } = await Location.requestForegroundPermissionsAsync(); if (status !== 'granted') { Alert.alert('Odmówiono dostępu do lokalizacji', 'Aplikacja potrzebuje dostępu do lokalizacji, aby śledzić Twoje aktywności.'); return; } // Pobierz pierwszą lokalizację, aby ustabilizować mapę na starcie try { let currentLocation = await Location.getCurrentPositionAsync({ accuracy: Location.Accuracy.Highest, // Najwyższa dokładność timeout: 5000, // Timeout w milisekundach }); setLocation(currentLocation); } catch (error) { console.error("Error getting current location:", error); Alert.alert('Błąd lokalizacji', 'Nie można pobrać bieżącej lokalizacji.'); } })(); }, []); // Hook useEffect do uruchamiania timera czasu useEffect(() => { let timerId; if (isTracking && startTime) { timerId = setInterval(() => { setElapsedTime(Math.floor((new Date() - startTime) / 1000)); }, 1000); } else if (!isTracking) { setElapsedTime(0); // Resetuj czas po zatrzymaniu } // Funkcja czyszcząca timer przy odmontowaniu komponentu lub zatrzymaniu śledzenia return () => clearInterval(timerId); }, [isTracking, startTime]); // Zależności: uruchamiaj ponownie, gdy zmieni się isTracking lub startTime // Funkcja rozpoczynająca śledzenie const startTracking = async () => { let { status } = await Location.getForegroundPermissionsAsync(); if (status !== 'granted') { Alert.alert('Brak pozwolenia', 'Aby rozpocząć śledzenie, musisz udzielić dostępu do lokalizacji.'); return; } setIsTracking(true); setStartTime(new Date()); setLocations([]); // Wyczyść poprzednią trasę setCurrentDistance(0); // Zresetuj dystans // Rozpocznij nasłuchiwanie zmian lokalizacji // Ustawiamy `distanceInterval` na 10m i `timeInterval` na 1s, aby mieć częste aktualizacje locationSubscription = await Location.watchPositionAsync( { enableHighAccuracy: true, distanceInterval: 10, // Pobieraj aktualizacje co 10 metrów timeInterval: 1000, // Pobieraj aktualizacje co 1 sekundę }, (newLocation) => { // Aktualizuj aktualną pozycję (do wyśrodkowania mapy) setLocation(newLocation); // Dodaj nowy punkt do tablicy tras i oblicz dystans setLocations((prevLocations) => { const newPath = [...prevLocations, newLocation.coords]; // Dodaj nowe koordynaty let distance = currentDistance; if (prevLocations.length > 0) { const prevCoords = prevLocations[prevLocations.length - 1]; distance += calculateDistance(prevCoords, newLocation.coords); // Dodaj odległość od poprzedniego punktu } setCurrentDistance(distance); // Zaktualizuj całkowity dystans return newPath; }); } ); console.log("Rozpoczynam śledzenie..."); }; // Funkcja zatrzymująca śledzenie const stopTracking = () => { if (locationSubscription) { locationSubscription.remove(); // Anuluj subskrypcję aktualizacji lokalizacji locationSubscription = null; } setIsTracking(false); console.log(`Zatrzymano śledzenie. Dystans: ${currentDistance.toFixed(2)} m, Czas: ${formatTime(elapsedTime)}`); // TUTAJ: W przyszłości zapiszemy `locations` do lokalnej bazy danych }; // Funkcja wywoływana, gdy mapa jest gotowa const handleMapReady = () => { if (location && mapRef.current) { // Animuj mapę do aktualnej lokalizacji użytkownika mapRef.current.animateToRegion({ latitude: location.coords.latitude, longitude: location.coords.longitude, latitudeDelta: 0.01, // Poziom zoomu (mniejsza wartość = większy zoom) longitudeDelta: 0.01, }); } }; // Ustalenie regionu mapy (gdzie ma być wyśrodkowana mapa) const mapRegion = location ? { latitude: location.coords.latitude, longitude: location.coords.longitude, latitudeDelta: 0.005, // Poziom zoomu longitudeDelta: 0.005, } : { // Domyślny region, jeśli lokalizacja nie jest jeszcze dostępna latitude: 52.0, // Przykładowe śródkowanie, np. na Europę longitude: 20.0, latitudeDelta: 5.0, longitudeDelta: 5.0, }; return ( <View style={styles.container}> <View style={styles.mapContainer}> <MapView ref={mapRef} provider={PROVIDER_DEFAULT} // Użyj domyślnego dostawcy map (Google na Android, Apple na iOS). Zazwyczaj pokazują dane OSM. style={styles.map} region={mapRegion} // Aktualizuj region mapy dynamicznie onMapReady={handleMapReady} // Wywołaj, gdy mapa jest gotowa showsUserLocation={true} // Pokaż kropkę wskazującą lokalizację użytkownika // Aby używać konkretnych kafelków OSM offline, można by użyć: // provider={null} // Wyłącza domyślnych dostawców // Wtedy trzeba by skonfigurować `urlTile` lub inną bibliotekę do pobierania kafelków. // Dla tej podstawowej wersji `PROVIDER_DEFAULT` jest wystarczający. > {/* Rysuj Polyline tylko jeśli mamy punkty trasy */} {locations.length > 0 && ( <Polyline coordinates={locations.map(loc => ({ latitude: loc.latitude, longitude: loc.longitude }))} strokeColor="#007AFF" // Kolor linii (niebieski) strokeWidth={3} // Grubość linii lineCap="round" // Zaokrąglenie końców linii /> )} {/* Dodaj marker na aktualną pozycję użytkownika */} {location && ( <Marker coordinate={{ latitude: location.coords.latitude, longitude: location.coords.longitude }} title="Aktualna Lokalizacja" pinColor="blue" /> )} </MapView> </View> <View style={styles.controls}> <Text style={styles.stats}>Dystans: {(currentDistance / 1000).toFixed(2)} km</Text> <Text style={styles.stats}>Czas: {formatTime(elapsedTime)}</Text> <Text style={styles.status}>{isTracking ? 'Nagrywanie...' : 'Zatrzymano'}</Text> <Button title={isTracking ? "Zatrzymaj" : "Rozpocznij"} onPress={isTracking ? stopTracking : startTracking} color={isTracking ? "red" : "green"} /> </View> </View> ); } // Styles definiujące wygląd komponentów const { width, height } = Dimensions.get('window'); const styles = StyleSheet.create({ container: { flex: 1, backgroundColor: '#fff', alignItems: 'center', justifyContent: 'center', }, mapContainer: { flex: 2, // Mapa zajmuje 2/3 wysokości ekranu width: '100%', justifyContent: 'center', alignItems: 'center', borderBottomWidth: 1, borderBottomColor: '#ccc' }, map: { width: Dimensions.get('window').width, height: '100%', }, controls: { flex: 1, // Kontrolki zajmują 1/3 wysokości ekranu width: '100%', justifyContent: 'center', alignItems: 'center', padding: 20, }, stats: { fontSize: 18, marginBottom: 10, }, status: { fontSize: 20, fontWeight: 'bold', marginVertical: 15, } });
Co dalej?
Ten kod tworzy podstawową funkcjonalność śledzenia i wyświetlania trasy. Kolejne kroki do budowy pełnoprawnej aplikacji to:
- Lokalne Przechowywanie Danych: Obecnie dane o trasie są tracone po zamknięciu aplikacji. Musimy użyć lokalnej bazy danych (np. SQLite) do zapisywania historii treningów. Biblioteka
expo-sqlitebędzie tutaj bardzo pomocna. - Eksport Danych: Dodanie możliwości eksportu tras do formatów takich jak GPX, aby można było je udostępniać lub analizować w innych programach.
- Szczegóły Treningu: Wyświetlanie dodatkowych statystyk (średnia prędkość, maksymalna prędkość, kadencja, wysokość, itp.).
- Obsługa Offline Map: Pobieranie kafelków OpenStreetMap do użytku offline. To jest bardziej zaawansowane i może wymagać użycia specyficznych bibliotek lub własnego rozwiązania do zarządzania kafelkami map.
- Interfejs Użytkownika: Budowanie bardziej rozbudowanego interfejsu użytkownika, obejmującego listy historii treningów, szczegóły poszczególnych tras, profile użytkowników itp.
Czy ten kierunek Ci odpowiada? Czy masz jakieś pytania dotyczące tego etapu lub chcesz przejść do omawiania następnych kroków, takich jak lokalne przechowywanie danych?
Other models, same or similar prompt
Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.