ale/location
0
Fork 0
Código Incidencias Pull Requests Acciones Paquetes Proyectos Lanzamientos Wiki Actividad

all providers

Explorar el Código
Este commit está contenido en:
ale
2025-07-18 23:00:51 +02:00
padre ebd7f0d783
commit a753e73d95
Se han modificado 13 ficheros con 212 adiciones y 192 borrados
Descargar archivo de parche Descargar archivo de diferencias Expandir todos los archivos Contraer todos los archivos

259
app/src/main/java/com/manalejandro/location/LocationService.kt
Ver fichero

@@ -7,6 +7,16 @@ import kotlinx.coroutines.delay
class LocationService(private val context: Context) {
companion object {
// Lista de todos los proveedores de ubicación
private val ALL_PROVIDERS = listOf(
LocationManager.GPS_PROVIDER,
LocationManager.NETWORK_PROVIDER,
LocationManager.PASSIVE_PROVIDER,
"fused" // FUSED_PROVIDER
)
}
/**
* Simula obtener la última ubicación conocida que Google tendría guardada
* Devuelve una ubicación predeterminada o la última simulada
@@ -18,17 +28,25 @@ class LocationService(private val context: Context) {
// Primero intentar obtener la ubicación simulada guardada
val mockedLocation = getMockedLocation()
if (mockedLocation != null) {
// Sincronizar la ubicación en todos los proveedores para asegurar consistencia
mockLocation(mockedLocation.latitude, mockedLocation.longitude)
// Actualizar el timestamp para simular que Google la tiene guardada
return mockedLocation.apply {
return getMockedLocation()?.apply {
time = System.currentTimeMillis() - (1000 * 60 * 30) // 30 minutos atrás
}
}
// Si no hay ubicación simulada, devolver una ubicación predeterminada que Google tendría guardada (Madrid)
return Location(LocationManager.GPS_PROVIDER).apply {
latitude = 40.4168
longitude = -3.7038
time = System.currentTimeMillis() - (1000 * 60 * 60 * 2) // 2 horas atrás
// Si no hay ubicación simulada, establecer y devolver una ubicación predeterminada (Madrid)
val madridLat = 40.4168
val madridLng = -3.7038
// Guardar Madrid como ubicación predeterminada en todos los proveedores
mockLocation(madridLat, madridLng)
// Devolver la ubicación desde el método que prioriza los proveedores
return getMockedLocation()?.apply {
time = System.currentTimeMillis() - (1000 * 60 * 60 * 2) // 2 horas atrás para simular que es guardada
accuracy = 15.0f // Menos precisión para simular que es una ubicación guardada
}
}
@@ -44,16 +62,16 @@ class LocationService(private val context: Context) {
}
/**
* Guarda una ubicación simulada
* Guarda una ubicación simulada en todos los proveedores
*/
suspend fun mockLocation(latitude: Double, longitude: Double): Boolean {
return try {
val preferences = context.getSharedPreferences(LocationManager.GPS_PROVIDER, Context.MODE_PRIVATE)
preferences.edit()
.putString("latitude", latitude.toString())
.putString("longitude", longitude.toString())
.putLong("timestamp", System.currentTimeMillis())
.apply()
val timestamp = System.currentTimeMillis()
// Guardar la ubicación en todos los proveedores
ALL_PROVIDERS.forEach { provider ->
saveLocationForProvider(provider, latitude, longitude, timestamp)
}
// Simular un pequeño delay
delay(500)
@@ -64,76 +82,209 @@ class LocationService(private val context: Context) {
}
/**
* Obtiene la ubicación simulada guardada
* Guarda una ubicación para un proveedor específico
*/
private fun saveLocationForProvider(provider: String, latitude: Double, longitude: Double, timestamp: Long) {
val preferences = context.getSharedPreferences(provider, Context.MODE_PRIVATE)
preferences.edit()
.putString("latitude", latitude.toString())
.putString("longitude", longitude.toString())
.putLong("timestamp", timestamp)
.apply()
}
/**
* Obtiene la ubicación simulada guardada desde cualquier proveedor
* Prioriza GPS, luego NETWORK, luego FUSED, finalmente PASSIVE
*/
fun getMockedLocation(): Location? {
val preferences = context.getSharedPreferences(LocationManager.GPS_PROVIDER, Context.MODE_PRIVATE)
val priorityProviders = listOf(
LocationManager.GPS_PROVIDER,
LocationManager.NETWORK_PROVIDER,
"fused",
LocationManager.PASSIVE_PROVIDER
)
for (provider in priorityProviders) {
val location = getLocationFromProvider(provider)
if (location != null) {
return location
}
}
return null
}
/**
* Obtiene la ubicación guardada para un proveedor específico
*/
private fun getLocationFromProvider(provider: String): Location? {
val preferences = context.getSharedPreferences(provider, Context.MODE_PRIVATE)
val latStr = preferences.getString("latitude", null)
val lngStr = preferences.getString("longitude", null)
return if (latStr != null && lngStr != null) {
Location(LocationManager.GPS_PROVIDER).apply {
Location(provider).apply {
latitude = latStr.toDouble()
longitude = lngStr.toDouble()
time = preferences.getLong("timestamp", System.currentTimeMillis())
accuracy = 5.0f // Simular buena precisión
accuracy = when (provider) {
LocationManager.GPS_PROVIDER -> 5.0f
LocationManager.NETWORK_PROVIDER -> 20.0f
"fused" -> 8.0f
LocationManager.PASSIVE_PROVIDER -> 15.0f
else -> 10.0f
}
}
} else null
}
/**
* Genera ubicaciones aleatorias cercanas a una ubicación base
* Obtiene la ubicación simulada para un proveedor específico
*/
fun generateRandomNearbyLocation(baseLatitude: Double, baseLongitude: Double, radiusKm: Double = 1.0): Location {
fun getMockedLocationForProvider(provider: String): Location? {
return getLocationFromProvider(provider)
}
/**
* Obtiene todas las ubicaciones simuladas por proveedor
*/
fun getAllMockedLocations(): Map<String, Location?> {
return ALL_PROVIDERS.associateWith { provider ->
getLocationFromProvider(provider)
}
}
/**
* Sincroniza la última ubicación conocida en todos los proveedores
*/
suspend fun syncLocationAcrossProviders(): Boolean {
val lastLocation = getMockedLocation()
return if (lastLocation != null) {
mockLocation(lastLocation.latitude, lastLocation.longitude)
} else {
false
}
}
/**
* Obtiene la lista de ciudades populares disponibles
*/
fun getAvailablePopularCities(): List<String> {
return listOf("Madrid", "Barcelona", "Valencia", "Sevilla", "Bilbao")
}
/**
* Obtiene las ubicaciones populares como lista de pares (nombre, Location)
*/
fun getPopularLocations(): List<Pair<String, Location>> {
val popularLocations = mapOf(
"Madrid" to Pair(40.4168, -3.7038),
"Barcelona" to Pair(41.3851, 2.1734),
"Valencia" to Pair(39.4699, -0.3763),
"Sevilla" to Pair(37.3886, -5.9823),
"Bilbao" to Pair(43.2627, -2.9253)
)
return popularLocations.map { (name, coordinates) ->
val location = Location(LocationManager.GPS_PROVIDER).apply {
latitude = coordinates.first
longitude = coordinates.second
time = System.currentTimeMillis()
accuracy = 5.0f
}
Pair(name, location)
}
}
/**
* Genera una ubicación aleatoria cercana a una ubicación base y la guarda en todos los proveedores
*/
suspend fun generateRandomNearbyLocation(baseLatitude: Double, baseLongitude: Double, radiusKm: Double = 1.0): Location {
val random = kotlin.random.Random
// Generar offset aleatorio dentro del radio especificado
val offsetLat = (random.nextDouble() - 0.5) * 2 * (radiusKm / 111.0) // 1 grado lat ≈ 111 km
val offsetLng = (random.nextDouble() - 0.5) * 2 * (radiusKm / (111.0 * kotlin.math.cos(Math.toRadians(baseLatitude))))
val newLatitude = baseLatitude + offsetLat
val newLongitude = baseLongitude + offsetLng
// Crear la ubicación aleatoria
return Location(LocationManager.GPS_PROVIDER).apply {
latitude = baseLatitude + offsetLat
longitude = baseLongitude + offsetLng
latitude = newLatitude
longitude = newLongitude
time = System.currentTimeMillis()
accuracy = random.nextFloat() * 20 + 5 // Precisión entre 5-25 metros
accuracy = 5.0f
}
}
/**
* Obtiene ubicaciones predefinidas populares en España
* Verifica que una ubicación esté guardada en todos los proveedores
*/
fun getPopularLocations(): List<Pair<String, Location>> {
return listOf(
"Madrid" to Location(LocationManager.GPS_PROVIDER).apply {
latitude = 40.4168
longitude = -3.7038
time = System.currentTimeMillis()
accuracy = 10.0f
},
"Barcelona" to Location(LocationManager.GPS_PROVIDER).apply {
latitude = 41.3851
longitude = 2.1734
time = System.currentTimeMillis()
accuracy = 10.0f
},
"Valencia" to Location(LocationManager.GPS_PROVIDER).apply {
latitude = 39.4699
longitude = -0.3763
time = System.currentTimeMillis()
accuracy = 10.0f
},
"Sevilla" to Location(LocationManager.GPS_PROVIDER).apply {
latitude = 37.3886
longitude = -5.9823
time = System.currentTimeMillis()
accuracy = 10.0f
},
"Bilbao" to Location(LocationManager.GPS_PROVIDER).apply {
latitude = 43.2627
longitude = -2.9253
time = System.currentTimeMillis()
accuracy = 10.0f
fun verifyLocationInAllProviders(): Map<String, Boolean> {
return ALL_PROVIDERS.associateWith { provider ->
getLocationFromProvider(provider) != null
}
}
/**
* Obtiene información detallada de todos los proveedores
*/
fun getProvidersDebugInfo(): Map<String, String> {
return ALL_PROVIDERS.associateWith { provider ->
val location = getLocationFromProvider(provider)
if (location != null) {
"Lat: ${location.latitude}, Lng: ${location.longitude}, Time: ${location.time}, Accuracy: ${location.accuracy}"
} else {
"No location stored"
}
}
}
/**
* Establece una ubicación popular en España y la guarda en todos los proveedores
*/
suspend fun setPopularLocation(cityName: String): Boolean {
val popularLocations = mapOf(
"Madrid" to Pair(40.4168, -3.7038),
"Barcelona" to Pair(41.3851, 2.1734),
"Valencia" to Pair(39.4699, -0.3763),
"Sevilla" to Pair(37.3886, -5.9823),
"Bilbao" to Pair(43.2627, -2.9253)
)
val coordinates = popularLocations[cityName]
return if (coordinates != null) {
mockLocation(coordinates.first, coordinates.second)
} else {
false
}
}
/**
* Obtiene la ubicación actual configurada como objeto Location para una ciudad específica
*/
suspend fun getPopularLocationAsLocation(cityName: String): Location? {
val popularLocations = mapOf(
"Madrid" to Pair(40.4168, -3.7038),
"Barcelona" to Pair(41.3851, 2.1734),
"Valencia" to Pair(39.4699, -0.3763),
"Sevilla" to Pair(37.3886, -5.9823),
"Bilbao" to Pair(43.2627, -2.9253)
)
val coordinates = popularLocations[cityName]
return if (coordinates != null) {
// Establecer la ubicación en todos los proveedores
if (mockLocation(coordinates.first, coordinates.second)) {
// Devolver la ubicación desde el método que prioriza los proveedores
getMockedLocation()
} else {
null
}
} else {
null
}
}
}

8
app/src/main/java/com/manalejandro/location/LocationViewModel.kt
Ver fichero

@@ -141,15 +141,21 @@ class LocationViewModel(private val locationService: LocationService) : ViewMode
2.0 // Radio de 2 km
)
// Guardar la ubicación aleatoria en todos los proveedores
val success = locationService.mockLocation(randomLocation.latitude, randomLocation.longitude)
if (success) {
val mockedLocation = locationService.getMockedLocation()
_uiState.value = _uiState.value.copy(
mockedLocation = mockedLocation,
currentLocation = randomLocation,
currentLocation = mockedLocation, // Usar la ubicación desde el proveedor prioritario
isLoading = false,
error = null
)
} else {
_uiState.value = _uiState.value.copy(
isLoading = false,
error = "Error al guardar ubicación aleatoria"
)
}
} catch (e: Exception) {
_uiState.value = _uiState.value.copy(

BIN
app/src/main/res/images/location.png
Ver fichero

Archivo binario no mostrado.
Lado a lado

Antes

Anchura:  |  Altura:  |  Tamaño: 1.4 KiB