mirror of
https://github.com/FoggedLens/deflock-app.git
synced 2026-08-11 21:50:32 +02:00
532 lines
18 KiB
Dart
532 lines
18 KiB
Dart
import 'dart:io';
|
|
import 'dart:convert';
|
|
import 'dart:math';
|
|
import 'package:flutter/foundation.dart';
|
|
import 'package:http/http.dart' as http;
|
|
import 'package:latlong2/latlong.dart';
|
|
import 'package:flutter_map/flutter_map.dart' show LatLngBounds;
|
|
import 'package:path_provider/path_provider.dart';
|
|
import '../models/osm_camera_node.dart';
|
|
|
|
/// Model for an offline area
|
|
enum OfflineAreaStatus { downloading, complete, error, cancelled }
|
|
|
|
class OfflineArea {
|
|
final String id;
|
|
String name;
|
|
final LatLngBounds bounds;
|
|
final int minZoom;
|
|
final int maxZoom;
|
|
final String directory; // base dir for area storage
|
|
OfflineAreaStatus status;
|
|
double progress; // 0.0 - 1.0
|
|
int tilesDownloaded;
|
|
int tilesTotal;
|
|
List<OsmCameraNode> cameras;
|
|
int sizeBytes; // Disk size in bytes
|
|
final bool isPermanent; // Not user-deletable if true
|
|
|
|
OfflineArea({
|
|
required this.id,
|
|
this.name = '',
|
|
required this.bounds,
|
|
required this.minZoom,
|
|
required this.maxZoom,
|
|
required this.directory,
|
|
this.status = OfflineAreaStatus.downloading,
|
|
this.progress = 0,
|
|
this.tilesDownloaded = 0,
|
|
this.tilesTotal = 0,
|
|
this.cameras = const [],
|
|
this.sizeBytes = 0,
|
|
this.isPermanent = false,
|
|
});
|
|
|
|
Map<String, dynamic> toJson() => {
|
|
'id': id,
|
|
'name': name,
|
|
'bounds': {
|
|
'sw': {'lat': bounds.southWest.latitude, 'lng': bounds.southWest.longitude},
|
|
'ne': {'lat': bounds.northEast.latitude, 'lng': bounds.northEast.longitude},
|
|
},
|
|
'minZoom': minZoom,
|
|
'maxZoom': maxZoom,
|
|
'directory': directory,
|
|
'status': status.name,
|
|
'progress': progress,
|
|
'tilesDownloaded': tilesDownloaded,
|
|
'tilesTotal': tilesTotal,
|
|
'cameras': cameras.map((c) => c.toJson()).toList(),
|
|
'sizeBytes': sizeBytes,
|
|
'isPermanent': isPermanent,
|
|
};
|
|
|
|
static OfflineArea fromJson(Map<String, dynamic> json) {
|
|
final bounds = LatLngBounds(
|
|
LatLng(json['bounds']['sw']['lat'], json['bounds']['sw']['lng']),
|
|
LatLng(json['bounds']['ne']['lat'], json['bounds']['ne']['lng']),
|
|
);
|
|
return OfflineArea(
|
|
id: json['id'],
|
|
name: json['name'] ?? '',
|
|
bounds: bounds,
|
|
minZoom: json['minZoom'],
|
|
maxZoom: json['maxZoom'],
|
|
directory: json['directory'],
|
|
status: OfflineAreaStatus.values.firstWhere(
|
|
(e) => e.name == json['status'], orElse: () => OfflineAreaStatus.error),
|
|
progress: (json['progress'] ?? 0).toDouble(),
|
|
tilesDownloaded: json['tilesDownloaded'] ?? 0,
|
|
tilesTotal: json['tilesTotal'] ?? 0,
|
|
cameras: (json['cameras'] as List? ?? [])
|
|
.map((e) => OsmCameraNode.fromJson(e)).toList(),
|
|
sizeBytes: json['sizeBytes'] ?? 0,
|
|
isPermanent: json['isPermanent'] ?? false,
|
|
);
|
|
}
|
|
}
|
|
|
|
/// Service for managing download, storage, and retrieval of offline map areas and cameras.
|
|
class OfflineAreaService {
|
|
// Public wrapper to allow UI code to persist area changes
|
|
// Wrapper removed; see implementation at line 204
|
|
/// Compute area disk usage (recursive)
|
|
Future<int> getAreaSizeBytes(OfflineArea area) async {
|
|
int total = 0;
|
|
final dir = Directory(area.directory);
|
|
if (await dir.exists()) {
|
|
await for (var fse in dir.list(recursive: true)) {
|
|
if (fse is File) {
|
|
total += await fse.length();
|
|
}
|
|
}
|
|
}
|
|
area.sizeBytes = total;
|
|
await saveAreasToDisk();
|
|
return total;
|
|
}
|
|
|
|
static final OfflineAreaService _instance = OfflineAreaService._();
|
|
factory OfflineAreaService() => _instance;
|
|
OfflineAreaService._() {
|
|
_loadAreasFromDisk().then((_) => _ensureAndAutoDownloadWorldArea());
|
|
}
|
|
|
|
// Ensure permanent world area exists and auto-download if tiles missing
|
|
Future<void> _ensureAndAutoDownloadWorldArea() async {
|
|
final dir = await getOfflineAreaDir();
|
|
final worldDir = "${dir.path}/world_z1_4";
|
|
final LatLngBounds worldBounds = globalWorldBounds();
|
|
OfflineArea? world;
|
|
for (final a in _areas) {
|
|
if (a.isPermanent) { world = a; break; }
|
|
}
|
|
final Set<List<int>> expectedTiles = computeTileList(worldBounds, 1, 4);
|
|
|
|
// Recount actual files if world area exists (can be slow but only on launch or change)
|
|
if (world != null) {
|
|
int filesFound = 0;
|
|
List<List<int>> missingTiles = [];
|
|
for (final tile in expectedTiles) {
|
|
final f = File('${world.directory}/tiles/${tile[0]}/${tile[1]}/${tile[2]}.png');
|
|
if (f.existsSync()) {
|
|
filesFound++;
|
|
} else if (missingTiles.length < 10) {
|
|
missingTiles.add(tile);
|
|
}
|
|
}
|
|
if (filesFound != expectedTiles.length) {
|
|
debugPrint('World area: missing \\${expectedTiles.length - filesFound} tiles. First few: \\$missingTiles');
|
|
} else {
|
|
debugPrint('World area: all tiles accounted for.');
|
|
}
|
|
|
|
world.tilesTotal = expectedTiles.length;
|
|
world.tilesDownloaded = filesFound;
|
|
world.progress = (world.tilesTotal == 0) ? 0.0 : (filesFound / world.tilesTotal);
|
|
if (filesFound == world.tilesTotal) {
|
|
world.status = OfflineAreaStatus.complete;
|
|
await saveAreasToDisk();
|
|
return;
|
|
} else {
|
|
world.status = OfflineAreaStatus.downloading;
|
|
await saveAreasToDisk();
|
|
downloadArea(
|
|
id: world.id,
|
|
bounds: world.bounds,
|
|
minZoom: world.minZoom,
|
|
maxZoom: world.maxZoom,
|
|
directory: world.directory,
|
|
name: world.name,
|
|
onProgress: null,
|
|
onComplete: null,
|
|
);
|
|
return;
|
|
}
|
|
}
|
|
// If not present, create and start download
|
|
world = OfflineArea(
|
|
id: 'permanent_world_z1_4',
|
|
name: 'World (zoom 1-4)',
|
|
bounds: worldBounds,
|
|
minZoom: 1,
|
|
maxZoom: 4,
|
|
directory: worldDir,
|
|
status: OfflineAreaStatus.downloading,
|
|
progress: 0.0,
|
|
isPermanent: true,
|
|
tilesTotal: expectedTiles.length,
|
|
tilesDownloaded: 0,
|
|
);
|
|
_areas.insert(0, world);
|
|
await saveAreasToDisk();
|
|
downloadArea(
|
|
id: world.id,
|
|
bounds: world.bounds,
|
|
minZoom: world.minZoom,
|
|
maxZoom: world.maxZoom,
|
|
directory: world.directory,
|
|
name: world.name,
|
|
onProgress: null,
|
|
onComplete: null,
|
|
);
|
|
}
|
|
|
|
final List<OfflineArea> _areas = [];
|
|
|
|
/// Where offline area data/metadata lives
|
|
Future<Directory> getOfflineAreaDir() async {
|
|
final dir = await getApplicationDocumentsDirectory();
|
|
final areaRoot = Directory("${dir.path}/offline_areas");
|
|
if (!areaRoot.existsSync()) {
|
|
areaRoot.createSync(recursive: true);
|
|
}
|
|
return areaRoot;
|
|
}
|
|
|
|
Future<File> _getMetadataPath() async {
|
|
final dir = await getOfflineAreaDir();
|
|
return File("${dir.path}/offline_areas.json");
|
|
}
|
|
|
|
List<OfflineArea> get offlineAreas => List.unmodifiable(_areas);
|
|
|
|
/// Start downloading an area: tiles and camera points.
|
|
/// [onProgress] is called with 0.0..1.0, [onComplete] when finished or failed.
|
|
Future<void> downloadArea({
|
|
required String id,
|
|
required LatLngBounds bounds,
|
|
required int minZoom,
|
|
required int maxZoom,
|
|
required String directory,
|
|
void Function(double progress)? onProgress,
|
|
void Function(OfflineAreaStatus status)? onComplete,
|
|
String? name,
|
|
}) async {
|
|
// If area with same id exists, replace its contents, else add.
|
|
OfflineArea? area;
|
|
for (final a in _areas) {
|
|
if (a.id == id) { area = a; break; }
|
|
}
|
|
if (area != null) {
|
|
// Remove area and its files before creating fresh
|
|
_areas.remove(area);
|
|
final dirObj = Directory(area.directory);
|
|
if (await dirObj.exists()) {
|
|
await dirObj.delete(recursive: true);
|
|
}
|
|
}
|
|
area = OfflineArea(
|
|
id: id,
|
|
name: name ?? area?.name ?? '',
|
|
bounds: bounds,
|
|
minZoom: minZoom,
|
|
maxZoom: maxZoom,
|
|
directory: directory,
|
|
isPermanent: area?.isPermanent ?? false,
|
|
);
|
|
_areas.add(area);
|
|
await saveAreasToDisk();
|
|
|
|
try {
|
|
// STEP 1: Tiles: user areas get only their bbox/zooms; world area gets only global z=1..4
|
|
Set<List<int>> allTiles;
|
|
if (area.isPermanent) {
|
|
allTiles = computeTileList(globalWorldBounds(), 1, 4);
|
|
} else {
|
|
allTiles = computeTileList(bounds, minZoom, maxZoom);
|
|
}
|
|
area.tilesTotal = allTiles.length;
|
|
|
|
// NEW ROBUST MULTI-PASS DOWNLOAD
|
|
// Will try up to 3 passes, only downloading what's still missing each time;
|
|
// area marked error (and non-permanent ones deleted) if incomplete after 3 passes
|
|
const int maxPasses = 3;
|
|
int pass = 0;
|
|
Set<List<int>> allTilesSet = allTiles.toSet();
|
|
Set<List<int>> tilesToFetch = allTilesSet;
|
|
bool success = false;
|
|
int totalDone = 0; // cumulative
|
|
while (pass < maxPasses && tilesToFetch.isNotEmpty) {
|
|
pass++;
|
|
int doneThisPass = 0;
|
|
debugPrint('DownloadArea: pass #$pass for area $id. Need \\${tilesToFetch.length} tiles.');
|
|
for (final tile in tilesToFetch) {
|
|
if (area.status == OfflineAreaStatus.cancelled) break;
|
|
try {
|
|
await _downloadTile(tile[0], tile[1], tile[2], directory);
|
|
totalDone++;
|
|
doneThisPass++;
|
|
area.tilesDownloaded = totalDone;
|
|
area.progress = area.tilesTotal == 0 ? 0.0 : ((area.tilesDownloaded) / area.tilesTotal);
|
|
} catch (e) {
|
|
debugPrint('Tile download failed for z=\\${tile[0]}, x=\\${tile[1]}, y=\\${tile[2]}: \\$e');
|
|
}
|
|
if (onProgress != null) onProgress(area.progress);
|
|
}
|
|
await getAreaSizeBytes(area); // Update size as we download
|
|
await saveAreasToDisk();
|
|
// After a pass, check for missing tiles
|
|
Set<List<int>> missingTiles = {};
|
|
for (final tile in allTilesSet) {
|
|
final f = File('$directory/tiles/${tile[0]}/${tile[1]}/${tile[2]}.png');
|
|
if (!f.existsSync()) missingTiles.add(tile);
|
|
}
|
|
if (missingTiles.isEmpty) {
|
|
success = true;
|
|
break;
|
|
}
|
|
tilesToFetch = missingTiles;
|
|
}
|
|
|
|
// STEP 2: Fetch cameras for this bbox (all, not limited!)
|
|
if (!area.isPermanent) {
|
|
final cameras = await _downloadAllCameras(bounds);
|
|
area.cameras = cameras;
|
|
await _saveCameras(cameras, directory);
|
|
} else {
|
|
area.cameras = [];
|
|
}
|
|
await getAreaSizeBytes(area);
|
|
|
|
if (success) {
|
|
area.status = OfflineAreaStatus.complete;
|
|
area.progress = 1.0;
|
|
debugPrint('Area $id: all tiles accounted for and area marked complete.');
|
|
} else {
|
|
area.status = OfflineAreaStatus.error;
|
|
debugPrint('Area $id: MISSING tiles after $maxPasses passes. First 10: \\${tilesToFetch.toList().take(10)}');
|
|
// Clean up area if not permanent
|
|
if (!area.isPermanent) {
|
|
final dirObj = Directory(area.directory);
|
|
if (await dirObj.exists()) {
|
|
await dirObj.delete(recursive: true);
|
|
}
|
|
_areas.remove(area);
|
|
}
|
|
}
|
|
await saveAreasToDisk();
|
|
if (onComplete != null) onComplete(area.status);
|
|
} catch (e) {
|
|
area.status = OfflineAreaStatus.error;
|
|
await saveAreasToDisk();
|
|
if (onComplete != null) onComplete(area.status);
|
|
}
|
|
}
|
|
|
|
void cancelDownload(String id) async {
|
|
final area = _areas.firstWhere((a) => a.id == id, orElse: () => throw 'Area not found');
|
|
area.status = OfflineAreaStatus.cancelled;
|
|
// Delete partial files as on standard delete
|
|
final dir = Directory(area.directory);
|
|
if (await dir.exists()) {
|
|
await dir.delete(recursive: true);
|
|
}
|
|
_areas.remove(area); // always remove, world will get recreated/refetched as needed
|
|
await saveAreasToDisk();
|
|
if (area.isPermanent) {
|
|
// Immediately recreate and auto-download world area
|
|
_ensureAndAutoDownloadWorldArea();
|
|
}
|
|
}
|
|
|
|
void deleteArea(String id) async {
|
|
final area = _areas.firstWhere((a) => a.id == id, orElse: () => throw 'Area not found');
|
|
final dir = Directory(area.directory);
|
|
if (await dir.exists()) {
|
|
await dir.delete(recursive: true);
|
|
}
|
|
_areas.remove(area);
|
|
await saveAreasToDisk();
|
|
}
|
|
|
|
// --- PERSISTENCE LOGIC ---
|
|
|
|
Future<void> saveAreasToDisk() async {
|
|
try {
|
|
final file = await _getMetadataPath();
|
|
final content = jsonEncode(_areas.map((a) => a.toJson()).toList());
|
|
await file.writeAsString(content);
|
|
} catch (e) {
|
|
debugPrint('Failed to save offline areas: $e');
|
|
}
|
|
}
|
|
|
|
Future<void> _loadAreasFromDisk() async {
|
|
try {
|
|
final file = await _getMetadataPath();
|
|
if (!(await file.exists())) return;
|
|
final str = await file.readAsString();
|
|
if (str.trim().isEmpty) return;
|
|
late final List data;
|
|
try {
|
|
data = jsonDecode(str);
|
|
} catch (e) {
|
|
debugPrint('Failed to parse offline areas json: $e');
|
|
return;
|
|
}
|
|
_areas.clear();
|
|
for (final areaJson in data) {
|
|
final area = OfflineArea.fromJson(areaJson);
|
|
// Check if directory still exists; adjust status if not
|
|
if (!Directory(area.directory).existsSync()) {
|
|
area.status = OfflineAreaStatus.error;
|
|
} else {
|
|
// Update sizeBytes async
|
|
getAreaSizeBytes(area);
|
|
}
|
|
_areas.add(area);
|
|
}
|
|
} catch (e) {
|
|
debugPrint('Failed to load offline areas: $e');
|
|
}
|
|
}
|
|
|
|
// --- TILE LOGIC ---
|
|
|
|
/// Returns set of [z, x, y] tuples needed to cover [bounds] at [zMin]..[zMax].
|
|
Set<List<int>> computeTileList(LatLngBounds bounds, int zMin, int zMax) {
|
|
Set<List<int>> tiles = {};
|
|
const double epsilon = 1e-7;
|
|
double latMin = min(bounds.southWest.latitude, bounds.northEast.latitude);
|
|
double latMax = max(bounds.southWest.latitude, bounds.northEast.latitude);
|
|
double lonMin = min(bounds.southWest.longitude, bounds.northEast.longitude);
|
|
double lonMax = max(bounds.southWest.longitude, bounds.northEast.longitude);
|
|
// Expand degenerate/flat areas a hair
|
|
if ((latMax - latMin).abs() < epsilon) {
|
|
latMin -= epsilon;
|
|
latMax += epsilon;
|
|
}
|
|
if ((lonMax - lonMin).abs() < epsilon) {
|
|
lonMin -= epsilon;
|
|
lonMax += epsilon;
|
|
}
|
|
for (int z = zMin; z <= zMax; z++) {
|
|
final n = pow(2, z).toInt();
|
|
final minTile = _latLonToTile(latMin, lonMin, z);
|
|
final maxTile = _latLonToTile(latMax, lonMax, z);
|
|
final minX = min(minTile[0], maxTile[0]);
|
|
final maxX = max(minTile[0], maxTile[0]);
|
|
final minY = min(minTile[1], maxTile[1]);
|
|
final maxY = max(minTile[1], maxTile[1]);
|
|
|
|
// New diagnostics!
|
|
// Removed verbose debugPrint analysis outputs
|
|
for (int x = minX; x <= maxX; x++) {
|
|
for (int y = minY; y <= maxY; y++) {
|
|
tiles.add([z, x, y]);
|
|
}
|
|
}
|
|
// Removed verbose debugPrint tile add outputs
|
|
}
|
|
return tiles;
|
|
}
|
|
|
|
// Returns x, y as double for NE corners
|
|
List<double> _latLonToTileRaw(double lat, double lon, int zoom) {
|
|
final n = pow(2.0, zoom);
|
|
final xtile = (lon + 180.0) / 360.0 * n;
|
|
final ytile = (1.0 - log(tan(lat * pi / 180.0) + 1.0 / cos(lat * pi / 180.0)) / pi) / 2.0 * n;
|
|
return [xtile, ytile];
|
|
}
|
|
|
|
/// Finds the minimum zoom at which a single tile covers [bounds].
|
|
/// Returns the highest z (up to [maxSearchZoom]) for which both corners are in the same tile.
|
|
int findDynamicMinZoom(LatLngBounds bounds, {int maxSearchZoom = 19}) {
|
|
for (int z = 1; z <= maxSearchZoom; z++) {
|
|
final swTile = _latLonToTile(bounds.southWest.latitude, bounds.southWest.longitude, z);
|
|
final neTile = _latLonToTile(bounds.northEast.latitude, bounds.northEast.longitude, z);
|
|
if (swTile[0] != neTile[0] || swTile[1] != neTile[1]) {
|
|
return z - 1 > 0 ? z - 1 : 1;
|
|
}
|
|
}
|
|
return maxSearchZoom;
|
|
}
|
|
|
|
/// Converts lat/lon+zoom to OSM tile xy as [x, y]
|
|
List<int> _latLonToTile(double lat, double lon, int zoom) {
|
|
final n = pow(2.0, zoom);
|
|
final xtile = ((lon + 180.0) / 360.0 * n).floor();
|
|
final ytile = ((1.0 - log(tan(lat * pi / 180.0) + 1.0 / cos(lat * pi / 180.0)) / pi) / 2.0 * n).floor();
|
|
return [xtile, ytile];
|
|
}
|
|
|
|
LatLngBounds globalWorldBounds() {
|
|
// Use slightly shrunken bounds to avoid tile index overflow at extreme coordinates
|
|
return LatLngBounds(LatLng(-85.0, -179.9), LatLng(85.0, 179.9));
|
|
}
|
|
|
|
Future<void> _downloadTile(int z, int x, int y, String baseDir) async {
|
|
final url = 'https://tile.openstreetmap.org/$z/$x/$y.png';
|
|
final dir = Directory('$baseDir/tiles/$z/$x');
|
|
await dir.create(recursive: true);
|
|
final file = File('${dir.path}/$y.png');
|
|
if (await file.exists()) return; // already downloaded
|
|
const int maxAttempts = 3;
|
|
int attempt = 0;
|
|
final random = Random();
|
|
// Backoff schedule in ms: 0 (immediate), 3000±500 (3s+/-), 10000±2000 (10s+/-)
|
|
final delays = [0, 3000 + random.nextInt(1000) - 500, 10000 + random.nextInt(4000) - 2000];
|
|
while (true) {
|
|
try {
|
|
attempt++;
|
|
final resp = await http.get(Uri.parse(url));
|
|
if (resp.statusCode == 200) {
|
|
await file.writeAsBytes(resp.bodyBytes);
|
|
return;
|
|
} else {
|
|
throw Exception('Failed to download tile $z/$x/$y (status \\${resp.statusCode})');
|
|
}
|
|
} catch (e) {
|
|
if (attempt >= maxAttempts) {
|
|
throw Exception('Failed to download tile $z/$x/$y after $attempt attempts: $e');
|
|
}
|
|
final delay = delays[attempt-1].clamp(0, 60000);
|
|
debugPrint('Retrying tile $z/$x/$y after failure (attempt $attempt, delaying \\${delay}ms): $e');
|
|
await Future.delayed(Duration(milliseconds: delay));
|
|
}
|
|
}
|
|
}
|
|
|
|
// --- CAMERA LOGIC ---
|
|
Future<List<OsmCameraNode>> _downloadAllCameras(LatLngBounds bounds) async {
|
|
// Overpass QL: fetch all cameras with no limit.
|
|
final sw = bounds.southWest;
|
|
final ne = bounds.northEast;
|
|
final bbox = [sw.latitude, sw.longitude, ne.latitude, ne.longitude].join(',');
|
|
final query = '[out:json][timeout:60];node["man_made"="surveillance"]["camera:mount"="pole"]($bbox);out body;';
|
|
final url = 'https://overpass-api.de/api/interpreter';
|
|
final resp = await http.post(Uri.parse(url), body: { 'data': query });
|
|
if (resp.statusCode != 200) {
|
|
throw Exception('Failed to fetch cameras');
|
|
}
|
|
final data = jsonDecode(resp.body);
|
|
return (data['elements'] as List<dynamic>?)?.map((e) => OsmCameraNode.fromJson(e)).toList() ?? [];
|
|
}
|
|
|
|
Future<void> _saveCameras(List<OsmCameraNode> cams, String dir) async {
|
|
final file = File('$dir/cameras.json');
|
|
await file.writeAsString(jsonEncode(cams.map((c) => c.toJson()).toList()));
|
|
}
|
|
}
|