Perplexity Computer
823 lines
40 KiB
Kotlin
823 lines
40 KiB
Kotlin
package de.waypointaudio.io
|
||
|
||
import android.content.Context
|
||
import android.net.Uri
|
||
import com.google.gson.Gson
|
||
import com.google.gson.GsonBuilder
|
||
import com.google.gson.JsonObject
|
||
import com.google.gson.JsonParser
|
||
import com.google.gson.reflect.TypeToken
|
||
import de.waypointaudio.data.GpsTrackPoint
|
||
import de.waypointaudio.data.MusicSourceType
|
||
import de.waypointaudio.data.PlaylistItem
|
||
import de.waypointaudio.data.StreamEntry
|
||
import de.waypointaudio.data.TourAudioSettings
|
||
import de.waypointaudio.data.TourPlaybackDefaults
|
||
import de.waypointaudio.data.TourCover
|
||
import de.waypointaudio.data.TourRoute
|
||
import de.waypointaudio.data.TrackDraft
|
||
import de.waypointaudio.data.Waypoint
|
||
import de.waypointaudio.data.WaypointMusicBehavior
|
||
import java.io.File
|
||
import java.io.FileOutputStream
|
||
import java.text.SimpleDateFormat
|
||
import java.util.Date
|
||
import java.util.Locale
|
||
import java.util.UUID
|
||
import java.util.zip.ZipEntry
|
||
import java.util.zip.ZipInputStream
|
||
|
||
/**
|
||
* Liest und importiert ein vom [BackupExportManager] erzeugtes ZIP-Backup.
|
||
*
|
||
* Strategie: Merge-only. Bestehende Daten werden NICHT überschrieben.
|
||
* - Touren mit gleichem Namen werden beim Import umbenannt mit Suffix " (Import)"
|
||
* bzw. " (Import 2)", … bis ein freier Name gefunden ist.
|
||
* - Wegpunkte aus solchen Touren werden mitgewandert (tourName aktualisiert).
|
||
* - Wegpunkt-IDs werden bei Kollision durch neue UUIDs ersetzt.
|
||
* - Track-Entwürfe werden zur jeweiligen (ggf. umbenannten) Tour gespeichert.
|
||
* - Begleitmusik-Einstellungen werden nur für Touren importiert, die noch keine
|
||
* Konfiguration haben (per Tour). Für umbenannte Touren wird die importierte
|
||
* Konfiguration unter dem neuen Namen abgelegt.
|
||
* - Medien aus `media/atmo/...` und `media/waypoints/...` werden in den
|
||
* App-internen `files/`-Ordner extrahiert (als `file://`-URIs adressierbar).
|
||
* Nach dem Entpacken werden die importierten Atmo-Playlist- und
|
||
* Wegpunkt-`soundUri`-Verweise nach Möglichkeit auf die extrahierten Dateien
|
||
* umgeschrieben. Verbleibende `content://`-URIs bleiben als Best-Effort
|
||
* erhalten – Hinweistext in [ImportResult.warnings].
|
||
*/
|
||
object BackupImportManager {
|
||
|
||
private val gson: Gson = GsonBuilder().create()
|
||
|
||
data class ImportSelection(
|
||
val toursAndWaypoints: Boolean = true,
|
||
val trackDrafts: Boolean = true,
|
||
val mediaAndAtmo: Boolean = true,
|
||
val settings: Boolean = true
|
||
)
|
||
|
||
/**
|
||
* Liste der vom Manifest deklarierten Sektionen UND die im ZIP tatsächlich
|
||
* vorhandenen Sektionen (für UI-Vorauswahl).
|
||
*/
|
||
data class ManifestInfo(
|
||
val format: String?,
|
||
val formatVersion: Int?,
|
||
val createdAt: String?,
|
||
val appVersionName: String?,
|
||
val appVersionCode: Int?,
|
||
val sectionsAvailable: SectionAvailability,
|
||
val errorMessage: String? = null
|
||
)
|
||
|
||
data class SectionAvailability(
|
||
val toursAndWaypoints: Boolean = false,
|
||
val trackDrafts: Boolean = false,
|
||
val mediaAndAtmo: Boolean = false,
|
||
val settings: Boolean = false
|
||
)
|
||
|
||
data class ImportResult(
|
||
val errorMessage: String? = null,
|
||
val toursImported: Int = 0,
|
||
val toursRenamed: Int = 0,
|
||
val waypointsImported: Int = 0,
|
||
val tourDefaultsImported: Int = 0,
|
||
val tracksImported: Int = 0,
|
||
val musicSettingsImported: Int = 0,
|
||
val mediaExtracted: Int = 0,
|
||
val mediaSkipped: Int = 0,
|
||
val warnings: List<String> = emptyList(),
|
||
val newTourSelection: String? = null
|
||
)
|
||
|
||
/** Ergebnis-Daten, das der Aufrufer (ViewModel) in die DataStores schreibt. */
|
||
data class ImportPayload(
|
||
val mergedWaypoints: List<Waypoint>,
|
||
val mergedTours: List<String>,
|
||
val tourDefaultsToWrite: Map<String, TourPlaybackDefaults>,
|
||
val tracksToWrite: Map<String, List<GpsTrackPoint>>,
|
||
val musicToWrite: Map<String, TourAudioSettings>,
|
||
// v2.4.6 — Tourrouten, die geschrieben werden sollen (Map endgültiger Tourname → Route).
|
||
val tourRoutesToWrite: Map<String, TourRoute> = emptyMap(),
|
||
// v2.5.5 — Tour-Cover, die geschrieben werden sollen (Map endgültiger Tourname → Cover).
|
||
val tourCoversToWrite: Map<String, TourCover> = emptyMap(),
|
||
// v2.5.48 — Echte TrackDraft-Objekte, die als neue Drafts hinzugefügt werden sollen.
|
||
val trackDraftsToAdd: List<TrackDraft> = emptyList(),
|
||
val trackMinDistanceMeters: Int?,
|
||
val newTourSelection: String?,
|
||
val warnings: List<String>,
|
||
val toursImported: Int,
|
||
val toursRenamed: Int,
|
||
val waypointsImported: Int,
|
||
val tracksImported: Int,
|
||
val musicSettingsImported: Int,
|
||
val mediaExtracted: Int,
|
||
val mediaSkipped: Int,
|
||
val tourDefaultsImported: Int,
|
||
val tourRoutesImported: Int = 0,
|
||
val tourCoversImported: Int = 0
|
||
)
|
||
|
||
/**
|
||
* Liest das Manifest und gibt vorhandene Sektionen zurück, ohne weitere
|
||
* Daten anzuwenden. Nutzt SAF-`Uri`. Off-UI-Thread aufrufen.
|
||
*/
|
||
fun readManifest(context: Context, sourceUri: Uri): ManifestInfo {
|
||
return runCatching {
|
||
val ins = context.contentResolver.openInputStream(sourceUri)
|
||
?: return ManifestInfo(null, null, null, null, null,
|
||
SectionAvailability(),
|
||
errorMessage = "Datei konnte nicht geöffnet werden.")
|
||
|
||
var manifestJson: JsonObject? = null
|
||
val available = mutableMapOf(
|
||
"tours" to false,
|
||
"drafts" to false,
|
||
"music" to false,
|
||
"settings" to false
|
||
)
|
||
|
||
ZipInputStream(ins).use { zin ->
|
||
while (true) {
|
||
val e = zin.nextEntry ?: break
|
||
when (e.name) {
|
||
"manifest.json" -> {
|
||
val bytes = zin.readBytes()
|
||
manifestJson = JsonParser.parseString(String(bytes, Charsets.UTF_8))
|
||
.asJsonObject
|
||
}
|
||
"data/tours.json" -> available["tours"] = true
|
||
"data/track_drafts.json" -> available["drafts"] = true
|
||
"data/music_settings.json" -> available["music"] = true
|
||
"data/settings.json" -> available["settings"] = true
|
||
}
|
||
zin.closeEntry()
|
||
}
|
||
}
|
||
|
||
if (manifestJson == null) {
|
||
return ManifestInfo(
|
||
format = null, formatVersion = null, createdAt = null,
|
||
appVersionName = null, appVersionCode = null,
|
||
sectionsAvailable = SectionAvailability(),
|
||
errorMessage = "Kein gültiges Backup: manifest.json fehlt."
|
||
)
|
||
}
|
||
val mf = manifestJson!!
|
||
val format = mf.get("format")?.asString
|
||
val formatVersion = mf.get("formatVersion")?.asInt
|
||
if (format != "GPS2Audio-Backup") {
|
||
return ManifestInfo(
|
||
format = format, formatVersion = formatVersion, createdAt = null,
|
||
appVersionName = null, appVersionCode = null,
|
||
sectionsAvailable = SectionAvailability(),
|
||
errorMessage = "Format wird nicht unterstützt: $format"
|
||
)
|
||
}
|
||
ManifestInfo(
|
||
format = format,
|
||
formatVersion = formatVersion,
|
||
createdAt = mf.get("createdAt")?.asString,
|
||
appVersionName = mf.get("appVersionName")?.asString,
|
||
appVersionCode = mf.get("appVersionCode")?.asInt,
|
||
sectionsAvailable = SectionAvailability(
|
||
toursAndWaypoints = available["tours"] == true,
|
||
trackDrafts = available["drafts"] == true,
|
||
mediaAndAtmo = available["music"] == true,
|
||
settings = available["settings"] == true
|
||
)
|
||
)
|
||
}.getOrElse { e ->
|
||
ManifestInfo(
|
||
format = null, formatVersion = null, createdAt = null,
|
||
appVersionName = null, appVersionCode = null,
|
||
sectionsAvailable = SectionAvailability(),
|
||
errorMessage = "Backup konnte nicht gelesen werden: ${e.localizedMessage ?: e.javaClass.simpleName}"
|
||
)
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Liest das Backup und berechnet die zu schreibenden, gemergten Daten.
|
||
* Schreibt KEINE DataStore-Daten – das macht der Aufrufer (ViewModel).
|
||
* Schreibt jedoch die extrahierten Mediendateien in den App-internen Speicher.
|
||
*/
|
||
fun buildImportPayload(
|
||
context: Context,
|
||
sourceUri: Uri,
|
||
selection: ImportSelection,
|
||
existingWaypoints: List<Waypoint>,
|
||
existingTours: List<String>,
|
||
existingTourDefaults: Map<String, TourPlaybackDefaults>,
|
||
existingTracks: Map<String, List<GpsTrackPoint>>,
|
||
existingMusic: Map<String, TourAudioSettings>,
|
||
// v2.4.6 — bestehende Tourrouten, damit wir keine bereits vorhandene Route überschreiben.
|
||
existingTourRoutes: Map<String, TourRoute> = emptyMap(),
|
||
// v2.5.5 — bestehende Tour-Cover, damit eigene Auswahl nicht überschrieben wird.
|
||
existingTourCovers: Map<String, TourCover> = emptyMap()
|
||
): Pair<ImportPayload?, String?> {
|
||
return runCatching {
|
||
// ---- ZIP einlesen (alle JSON in Memory, Medien in interne Datei extrahieren) ----
|
||
val mediaTargetDir = File(context.filesDir, "imported_media").apply { mkdirs() }
|
||
val timestamp = SimpleDateFormat("yyyyMMdd_HHmmss", Locale.US).format(Date())
|
||
val sessionDir = File(mediaTargetDir, timestamp).apply { mkdirs() }
|
||
|
||
// Map: zip-pfad → file://-URI der extrahierten Datei
|
||
val extractedMedia = mutableMapOf<String, String>()
|
||
// Mapping originaler displayName/dateiname → zip-pfade (für Best-Effort-Match)
|
||
val mediaByLeafName = mutableMapOf<String, MutableList<String>>()
|
||
|
||
var manifestJson: JsonObject? = null
|
||
var toursJson: String? = null
|
||
var draftsJson: String? = null
|
||
var musicJson: String? = null
|
||
var settingsJson: String? = null
|
||
|
||
val ins0 = context.contentResolver.openInputStream(sourceUri)
|
||
?: return null to "Datei konnte nicht geöffnet werden."
|
||
ZipInputStream(ins0).use { zin ->
|
||
while (true) {
|
||
val e = zin.nextEntry ?: break
|
||
when {
|
||
e.isDirectory -> {}
|
||
e.name == "manifest.json" -> {
|
||
manifestJson = JsonParser.parseString(zin.readBytes().toString(Charsets.UTF_8))
|
||
.asJsonObject
|
||
}
|
||
e.name == "data/tours.json" ->
|
||
toursJson = zin.readBytes().toString(Charsets.UTF_8)
|
||
e.name == "data/track_drafts.json" ->
|
||
draftsJson = zin.readBytes().toString(Charsets.UTF_8)
|
||
e.name == "data/music_settings.json" ->
|
||
musicJson = zin.readBytes().toString(Charsets.UTF_8)
|
||
e.name == "data/settings.json" ->
|
||
settingsJson = zin.readBytes().toString(Charsets.UTF_8)
|
||
// Mediendateien
|
||
e.name.startsWith("media/") &&
|
||
!e.name.endsWith("/") -> {
|
||
// v2.5.7 — Cover-Bilder (media/covers/...) gehören zu
|
||
// "Touren und Wegpunkte" und werden auch dann extrahiert,
|
||
// wenn Medien/Atmo nicht gewählt wurde, damit Tour-Cover
|
||
// beim Import nicht verloren gehen.
|
||
val isCoverFile = e.name.startsWith("media/covers/")
|
||
val shouldExtract =
|
||
(isCoverFile && selection.toursAndWaypoints) ||
|
||
(!isCoverFile && selection.mediaAndAtmo)
|
||
if (shouldExtract) {
|
||
val outFile = safeMediaTarget(sessionDir, e)
|
||
if (outFile != null) {
|
||
FileOutputStream(outFile).use { fout ->
|
||
zin.copyTo(fout)
|
||
}
|
||
val uri = Uri.fromFile(outFile).toString()
|
||
extractedMedia[e.name] = uri
|
||
val leaf = outFile.name.lowercase(Locale.US)
|
||
mediaByLeafName.getOrPut(leaf) { mutableListOf() }
|
||
.add(e.name)
|
||
}
|
||
}
|
||
}
|
||
else -> { /* Ignorieren (z. B. media_manifest.json) */ }
|
||
}
|
||
zin.closeEntry()
|
||
}
|
||
}
|
||
|
||
if (manifestJson == null) {
|
||
return null to "Kein gültiges Backup: manifest.json fehlt."
|
||
}
|
||
val mf = manifestJson!!
|
||
if (mf.get("format")?.asString != "GPS2Audio-Backup") {
|
||
return null to "Format wird nicht unterstützt."
|
||
}
|
||
|
||
val warnings = mutableListOf<String>()
|
||
|
||
// ---- Tours + Waypoints ----
|
||
val resultTours = existingTours.toMutableList()
|
||
// Mapping: original importierter Tourname → endgültiger Name (ggf. umbenannt)
|
||
val tourRename = mutableMapOf<String, String>()
|
||
var toursImported = 0
|
||
var toursRenamed = 0
|
||
var newTourSelection: String? = null
|
||
|
||
val mergedWaypoints = existingWaypoints.toMutableList()
|
||
val existingIds = existingWaypoints.map { it.id }.toMutableSet()
|
||
var waypointsImported = 0
|
||
val tourDefaultsToWrite = mutableMapOf<String, TourPlaybackDefaults>()
|
||
var tourDefaultsImported = 0
|
||
// v2.4.6 — Tourrouten Merge-Buffer.
|
||
val tourRoutesToWrite = mutableMapOf<String, TourRoute>()
|
||
var tourRoutesImported = 0
|
||
// v2.5.5 — Tour-Cover Merge-Buffer.
|
||
val tourCoversToWrite = mutableMapOf<String, TourCover>()
|
||
var tourCoversImported = 0
|
||
|
||
if (selection.toursAndWaypoints && toursJson != null) {
|
||
val payload = runCatching {
|
||
JsonParser.parseString(toursJson).asJsonObject
|
||
}.getOrNull()
|
||
if (payload != null) {
|
||
val importedTourList: List<String> = runCatching {
|
||
gson.fromJson<List<String>>(
|
||
payload.get("tours"),
|
||
object : TypeToken<List<String>>() {}.type
|
||
) ?: emptyList()
|
||
}.getOrDefault(emptyList())
|
||
|
||
importedTourList.forEach { rawName ->
|
||
val name = rawName.ifBlank { Waypoint.DEFAULT_TOUR_NAME }
|
||
if (name == Waypoint.DEFAULT_TOUR_NAME) {
|
||
// Standard-Tour wird nicht umbenannt – Inhalte werden gemergt.
|
||
tourRename[name] = name
|
||
} else if (name in resultTours) {
|
||
val unique = uniqueName(name, resultTours)
|
||
tourRename[name] = unique
|
||
resultTours.add(unique)
|
||
toursRenamed++
|
||
toursImported++
|
||
} else {
|
||
tourRename[name] = name
|
||
resultTours.add(name)
|
||
toursImported++
|
||
}
|
||
}
|
||
if (toursImported > 0) {
|
||
// Ersten neu importierten/umbenannten Tournamen für UI vormerken
|
||
newTourSelection = importedTourList
|
||
.firstOrNull { it != Waypoint.DEFAULT_TOUR_NAME }
|
||
?.let { tourRename[it] }
|
||
}
|
||
|
||
val importedWps: List<Waypoint> = runCatching {
|
||
gson.fromJson<List<Waypoint>>(
|
||
payload.get("waypoints"),
|
||
object : TypeToken<List<Waypoint>>() {}.type
|
||
) ?: emptyList()
|
||
}.getOrDefault(emptyList())
|
||
|
||
importedWps.forEach { w ->
|
||
val originalTour = w.tourName.ifBlank { Waypoint.DEFAULT_TOUR_NAME }
|
||
val mappedTour = tourRename[originalTour]
|
||
?: run {
|
||
// Tour war nicht in `tours`, also als neue/aliased aufnehmen
|
||
if (originalTour == Waypoint.DEFAULT_TOUR_NAME ||
|
||
originalTour !in resultTours
|
||
) {
|
||
if (originalTour != Waypoint.DEFAULT_TOUR_NAME) {
|
||
resultTours.add(originalTour)
|
||
}
|
||
tourRename[originalTour] = originalTour
|
||
originalTour
|
||
} else {
|
||
val unique = uniqueName(originalTour, resultTours)
|
||
tourRename[originalTour] = unique
|
||
resultTours.add(unique)
|
||
toursRenamed++
|
||
unique
|
||
}
|
||
}
|
||
|
||
val newId = if (w.id in existingIds) UUID.randomUUID().toString() else w.id
|
||
existingIds.add(newId)
|
||
|
||
val tourMediaFolder =
|
||
"media/waypoints/${sanitize(originalTour)}/"
|
||
|
||
val rewrittenSoundUri = rewriteMediaReference(
|
||
originalUri = w.soundUri,
|
||
originalDisplayName = w.soundName,
|
||
extractedMedia = extractedMedia,
|
||
mediaByLeafName = mediaByLeafName,
|
||
preferZipFolder = tourMediaFolder
|
||
)
|
||
|
||
// v2.5.12 — Auch die URIs der Multi-Clip-Liste auf
|
||
// extrahierte Dateien umschreiben. Alte Backups ohne
|
||
// audioClips erzeugen hier eine leere Liste – die
|
||
// Migration auf Legacy-Felder erfolgt zur Laufzeit
|
||
// über [effectiveClips].
|
||
val rewrittenClips = w.audioClips.map { c ->
|
||
val newUri = rewriteMediaReference(
|
||
originalUri = c.uri,
|
||
originalDisplayName = c.displayFileName
|
||
.ifBlank { c.title },
|
||
extractedMedia = extractedMedia,
|
||
mediaByLeafName = mediaByLeafName,
|
||
preferZipFolder = tourMediaFolder
|
||
) ?: c.uri
|
||
c.copy(uri = newUri)
|
||
}
|
||
|
||
mergedWaypoints.add(
|
||
w.copy(
|
||
id = newId,
|
||
tourName = mappedTour,
|
||
soundUri = rewrittenSoundUri ?: w.soundUri,
|
||
audioClips = rewrittenClips
|
||
)
|
||
)
|
||
waypointsImported++
|
||
}
|
||
|
||
val tourDefaultsImportedRaw: Map<String, TourPlaybackDefaults> = runCatching {
|
||
gson.fromJson<Map<String, TourPlaybackDefaults>>(
|
||
payload.get("tourDefaults"),
|
||
object : TypeToken<Map<String, TourPlaybackDefaults>>() {}.type
|
||
) ?: emptyMap()
|
||
}.getOrDefault(emptyMap())
|
||
tourDefaultsImportedRaw.forEach { (origName, def) ->
|
||
val mapped = tourRename[origName] ?: origName
|
||
if (mapped !in existingTourDefaults) {
|
||
tourDefaultsToWrite[mapped] = def.copy(tourName = mapped)
|
||
tourDefaultsImported++
|
||
}
|
||
}
|
||
|
||
// v2.4.6 — Tourrouten aus tours.json (optional, rückwärtskompatibel).
|
||
val tourRoutesImportedRaw: Map<String, TourRoute> = runCatching {
|
||
gson.fromJson<Map<String, TourRoute>>(
|
||
payload.get("tourRoutes"),
|
||
object : TypeToken<Map<String, TourRoute>>() {}.type
|
||
) ?: emptyMap()
|
||
}.getOrDefault(emptyMap())
|
||
tourRoutesImportedRaw.forEach { (origName, route) ->
|
||
val mapped = tourRename[origName] ?: origName
|
||
if (mapped !in existingTourRoutes) {
|
||
tourRoutesToWrite[mapped] = route.copy(
|
||
updatedAtMillis = System.currentTimeMillis()
|
||
)
|
||
tourRoutesImported++
|
||
} else {
|
||
warnings.add("Tourroute für „$mapped“ bereits vorhanden – nicht überschrieben.")
|
||
}
|
||
}
|
||
|
||
// v2.5.5/2.5.7/2.5.31 — Tour-Cover aus tours.json (optional, rückwärtskompatibel).
|
||
// Falls Cover-Bild vorhanden ist (imageUri = ZIP-relativer Pfad
|
||
// wie "media/covers/<idx>_<tour>.jpg" (v2.5.31+) oder
|
||
// "media/covers/<tour>.jpg" (v2.5.7–v2.5.30)), wird die extrahierte
|
||
// Datei via [TourCoverImageStore.saveFromFile] in die app-interne
|
||
// Ablage übernommen. Schlägt das fehl, bleibt Icon+Palette
|
||
// erhalten und das Bild entfällt.
|
||
//
|
||
// Rückwärtskompatibilität: Beide Pfad-Formate werden erkannt, da
|
||
// der extractedMedia-Index immer den originalen ZIP-Entry-Namen
|
||
// (e.name) als Schlüssel verwendet.
|
||
val tourCoversImportedRaw: Map<String, TourCover> = runCatching {
|
||
gson.fromJson<Map<String, TourCover>>(
|
||
payload.get("tourCovers"),
|
||
object : TypeToken<Map<String, TourCover>>() {}.type
|
||
) ?: emptyMap()
|
||
}.getOrDefault(emptyMap())
|
||
tourCoversImportedRaw.forEach { (origName, cover) ->
|
||
val mapped = tourRename[origName] ?: origName
|
||
if (mapped !in existingTourCovers) {
|
||
val zipRelativeImage = cover.imageUri
|
||
val resolvedImagePath: String? = if (
|
||
!zipRelativeImage.isNullOrBlank() &&
|
||
zipRelativeImage.startsWith("media/covers/")
|
||
) {
|
||
val extractedFileUri = extractedMedia[zipRelativeImage]
|
||
if (extractedFileUri != null) {
|
||
runCatching {
|
||
val path = Uri.parse(extractedFileUri).path
|
||
if (path != null) {
|
||
de.waypointaudio.util.TourCoverImageStore
|
||
.saveFromFile(context, java.io.File(path), mapped)
|
||
} else {
|
||
android.util.Log.w("BackupImportManager",
|
||
"Cover-URI-Pfad null für Tour \"$mapped\" (extractedFileUri=$extractedFileUri)")
|
||
null
|
||
}
|
||
}.onFailure { e ->
|
||
android.util.Log.w("BackupImportManager",
|
||
"saveFromFile fehlgeschlagen für Tour \"$mapped\": ${e.localizedMessage}")
|
||
}.getOrNull()
|
||
} else {
|
||
// Bild-Datei war nicht im ZIP oder wurde nicht extrahiert.
|
||
android.util.Log.w("BackupImportManager",
|
||
"Cover-Datei \"$zipRelativeImage\" nicht im ZIP für Tour \"$mapped\"")
|
||
null
|
||
}
|
||
} else {
|
||
// imageUri ist null, leer oder ein absoluter Pfad
|
||
// vom Quell-Gerät – nicht importierbar.
|
||
null
|
||
}
|
||
tourCoversToWrite[mapped] = cover.copy(imageUri = resolvedImagePath)
|
||
tourCoversImported++
|
||
}
|
||
}
|
||
} else {
|
||
warnings.add("data/tours.json konnte nicht gelesen werden.")
|
||
}
|
||
}
|
||
|
||
// ---- Track-Entwürfe ----
|
||
// v2.5.48 FIX: Importiert echte TrackDraft-Objekte aus dem "drafts"-Array.
|
||
// Abwärtskompatibilität: Alte Backups schrieben fälschlicherweise die
|
||
// gpsTracks-Map unter "tracks" in track_drafts.json. Falls "drafts" fehlt
|
||
// aber "tracks" vorhanden ist, wird das alte Format erkannt und toleriert
|
||
// (kein Crash, keine Datenverluste an bestehenden Touren/Waypoints).
|
||
val tracksToWrite = mutableMapOf<String, List<GpsTrackPoint>>()
|
||
val trackDraftsToAdd = mutableListOf<TrackDraft>()
|
||
var tracksImported = 0
|
||
if (selection.trackDrafts && draftsJson != null) {
|
||
val obj = runCatching {
|
||
JsonParser.parseString(draftsJson).asJsonObject
|
||
}.getOrNull()
|
||
|
||
if (obj != null) {
|
||
// Neues Format (v2.5.48+): "drafts" enthält eine Liste echter TrackDraft-Objekte.
|
||
val hasDraftsKey = obj.has("drafts") && !obj.get("drafts").isJsonNull
|
||
|
||
if (hasDraftsKey) {
|
||
// Neues Format: Liste von TrackDraft-Objekten
|
||
val importedDrafts: List<TrackDraft> = runCatching {
|
||
gson.fromJson<List<TrackDraft>>(
|
||
obj.get("drafts"),
|
||
object : TypeToken<List<TrackDraft>>() {}.type
|
||
) ?: emptyList()
|
||
}.getOrDefault(emptyList())
|
||
|
||
importedDrafts.forEach { draft ->
|
||
// Tourname-Mapping anwenden (für den Fall, dass Tour umbenannt wurde).
|
||
val origTour = draft.sourceTourName
|
||
val mappedTour = tourRename[origTour]
|
||
?: run {
|
||
if (origTour == Waypoint.DEFAULT_TOUR_NAME ||
|
||
origTour in resultTours
|
||
) {
|
||
origTour
|
||
} else {
|
||
resultTours.add(origTour)
|
||
origTour
|
||
}
|
||
}
|
||
// Neue UUID vergeben, damit importierte Drafts nie mit
|
||
// vorhandenen Drafts-IDs kollidieren.
|
||
val newDraft = draft.copy(
|
||
id = java.util.UUID.randomUUID().toString(),
|
||
sourceTourName = mappedTour,
|
||
updatedAt = System.currentTimeMillis()
|
||
)
|
||
trackDraftsToAdd.add(newDraft)
|
||
tracksImported++
|
||
}
|
||
} else {
|
||
// Altes (fehlerhaftes) Format: "tracks" enthält gpsTracks-Map.
|
||
// Tolerieren ohne Crash, aber nicht in Tracks oder Drafts importieren,
|
||
// da der Inhalt GPS-Track-Daten (nicht Draft-Metadaten) sind.
|
||
// Hinweis in Warnings ausgeben.
|
||
val hasTracksKey = obj.has("tracks") && !obj.get("tracks").isJsonNull
|
||
if (hasTracksKey) {
|
||
warnings.add(
|
||
"Hinweis: track_drafts.json aus älterem Backup-Format erkannt " +
|
||
"(enthält GPS-Tracks statt Draft-Objekte). " +
|
||
"TrackDraft-Namen/Notizen können nicht wiederhergestellt werden. " +
|
||
"Bestehende Touren und Wegpunkte bleiben unverändert."
|
||
)
|
||
}
|
||
// Keine Daten importieren aus altem, fehlerh. Format — kein Crash.
|
||
}
|
||
}
|
||
}
|
||
|
||
// ---- Begleitmusik ----
|
||
val musicToWrite = mutableMapOf<String, TourAudioSettings>()
|
||
var musicSettingsImported = 0
|
||
if (selection.mediaAndAtmo && musicJson != null) {
|
||
val obj = runCatching {
|
||
JsonParser.parseString(musicJson).asJsonObject
|
||
}.getOrNull()
|
||
val mapJson: JsonObject? = obj?.getAsJsonObject("musicSettings")
|
||
mapJson?.entrySet()?.forEach { entry ->
|
||
val origTour = entry.key
|
||
val mappedTour = tourRename[origTour] ?: origTour
|
||
if (mappedTour in existingMusic) {
|
||
warnings.add("Begleitmusik für Tour „$mappedTour\" bereits vorhanden – nicht überschrieben.")
|
||
return@forEach
|
||
}
|
||
val src = entry.value.asJsonObject
|
||
val settings = parseMusicSettings(src) ?: return@forEach
|
||
val rewritten = settings.copy(
|
||
localPlaylist = settings.localPlaylist.map { item ->
|
||
val newUri = rewriteMediaReference(
|
||
originalUri = item.uriString,
|
||
originalDisplayName = item.displayName,
|
||
extractedMedia = extractedMedia,
|
||
mediaByLeafName = mediaByLeafName,
|
||
preferZipFolder = "media/atmo/${sanitize(origTour)}/"
|
||
) ?: item.uriString
|
||
PlaylistItem(uriString = newUri, displayName = item.displayName)
|
||
}
|
||
)
|
||
musicToWrite[mappedTour] = rewritten
|
||
musicSettingsImported++
|
||
}
|
||
}
|
||
|
||
// ---- Settings ----
|
||
var trackMinDistanceMeters: Int? = null
|
||
if (selection.settings && settingsJson != null) {
|
||
val obj = runCatching {
|
||
JsonParser.parseString(settingsJson).asJsonObject
|
||
}.getOrNull()
|
||
val v = obj?.get("trackMinDistanceMeters")
|
||
if (v != null && v.isJsonPrimitive && v.asJsonPrimitive.isNumber) {
|
||
val n = v.asInt
|
||
if (n in 1..500) trackMinDistanceMeters = n
|
||
}
|
||
}
|
||
|
||
// ---- Medien-Statistik ----
|
||
val mediaExtracted = extractedMedia.size
|
||
val mediaSkipped = if (selection.mediaAndAtmo && extractedMedia.isEmpty()) {
|
||
// ZIP enthielt evtl. keine Medien – kein Fehler
|
||
0
|
||
} else 0
|
||
|
||
if (mediaExtracted > 0) {
|
||
warnings.add("Importierte Mediendateien wurden nach app-internem Speicher kopiert (interner Pfad).")
|
||
}
|
||
if (selection.mediaAndAtmo) {
|
||
// Falls `content://`-URIs übrig sind, weisen wir darauf hin
|
||
val orphanContentUris = mergedWaypoints.sumOf { wp ->
|
||
val legacy = if (wp.soundUri.startsWith("content://")) 1 else 0
|
||
val clips = wp.audioClips.count { it.uri.startsWith("content://") }
|
||
legacy + clips
|
||
} + musicToWrite.values.sumOf { ms ->
|
||
ms.localPlaylist.count { it.uriString.startsWith("content://") }
|
||
}
|
||
if (orphanContentUris > 0) {
|
||
warnings.add(
|
||
"Hinweis: Einige Verweise zeigen auf externe `content://`-URIs aus dem ursprünglichen Gerät. " +
|
||
"Diese sind nach Import meist nicht mehr abspielbar."
|
||
)
|
||
}
|
||
}
|
||
|
||
ImportPayload(
|
||
mergedWaypoints = mergedWaypoints,
|
||
mergedTours = resultTours.distinct(),
|
||
tourDefaultsToWrite = tourDefaultsToWrite,
|
||
tracksToWrite = tracksToWrite,
|
||
musicToWrite = musicToWrite,
|
||
tourRoutesToWrite = tourRoutesToWrite,
|
||
tourCoversToWrite = tourCoversToWrite,
|
||
// v2.5.48 — Echte TrackDraft-Objekte weitergeben.
|
||
trackDraftsToAdd = trackDraftsToAdd,
|
||
trackMinDistanceMeters = trackMinDistanceMeters,
|
||
newTourSelection = newTourSelection,
|
||
warnings = warnings,
|
||
toursImported = toursImported,
|
||
toursRenamed = toursRenamed,
|
||
waypointsImported = waypointsImported,
|
||
tracksImported = tracksImported,
|
||
musicSettingsImported = musicSettingsImported,
|
||
mediaExtracted = mediaExtracted,
|
||
mediaSkipped = mediaSkipped,
|
||
tourDefaultsImported = tourDefaultsImported,
|
||
tourRoutesImported = tourRoutesImported,
|
||
tourCoversImported = tourCoversImported
|
||
) to null
|
||
}.getOrElse { e ->
|
||
null to "Backup konnte nicht importiert werden: ${e.localizedMessage ?: e.javaClass.simpleName}"
|
||
}
|
||
}
|
||
|
||
// ----------------------------------------------------------------------
|
||
// Hilfsfunktionen
|
||
// ----------------------------------------------------------------------
|
||
|
||
private fun uniqueName(base: String, existing: List<String>): String {
|
||
val first = "$base (Import)"
|
||
if (first !in existing) return first
|
||
var i = 2
|
||
while (true) {
|
||
val cand = "$base (Import $i)"
|
||
if (cand !in existing) return cand
|
||
i++
|
||
if (i > 999) return "$base (Import ${System.currentTimeMillis()})"
|
||
}
|
||
}
|
||
|
||
private fun parseMusicSettings(obj: JsonObject): TourAudioSettings? {
|
||
return runCatching {
|
||
val sourceType = runCatching {
|
||
MusicSourceType.valueOf(obj.get("sourceType")?.asString ?: "LOCAL_PLAYLIST")
|
||
}.getOrDefault(MusicSourceType.LOCAL_PLAYLIST)
|
||
val behavior = runCatching {
|
||
WaypointMusicBehavior.valueOf(obj.get("behavior")?.asString ?: "PAUSE_RESUME")
|
||
}.getOrDefault(WaypointMusicBehavior.PAUSE_RESUME)
|
||
val playlist = obj.getAsJsonArray("localPlaylist")?.mapNotNull { el ->
|
||
val o = el.asJsonObject
|
||
PlaylistItem(
|
||
uriString = o.get("uriString")?.asString ?: return@mapNotNull null,
|
||
displayName = o.get("displayName")?.asString ?: ""
|
||
)
|
||
} ?: emptyList()
|
||
val streamList = obj.getAsJsonArray("streamPlaylist")?.mapNotNull { el ->
|
||
val o = el.asJsonObject
|
||
val url = o.get("url")?.asString ?: return@mapNotNull null
|
||
StreamEntry(
|
||
url = url,
|
||
name = o.get("name")?.asString ?: ""
|
||
)
|
||
} ?: emptyList()
|
||
val legacyStreamUrl = obj.get("streamUrl")?.takeIf { !it.isJsonNull }?.asString
|
||
// Legacy-Backups (v2.0.7 und älter) hatten nur streamUrl – wenn keine streamPlaylist
|
||
// gespeichert wurde, aber legacy-URL vorhanden ist, migrieren wir sie zu einem
|
||
// einzelnen StreamEntry.
|
||
val effectiveStreams = if (streamList.isEmpty() && !legacyStreamUrl.isNullOrBlank()) {
|
||
listOf(StreamEntry(url = legacyStreamUrl, name = ""))
|
||
} else streamList
|
||
TourAudioSettings(
|
||
enabled = obj.get("enabled")?.asBoolean ?: false,
|
||
sourceType = sourceType,
|
||
localPlaylist = playlist,
|
||
streamPlaylist = effectiveStreams,
|
||
streamUrl = null,
|
||
behavior = behavior,
|
||
fadeDurationMs = obj.get("fadeDurationMs")?.asLong ?: 1500L,
|
||
duckVolume = obj.get("duckVolume")?.asFloat ?: 0.25f,
|
||
shuffle = obj.get("shuffle")?.asBoolean ?: false,
|
||
autoStartAfterWaypoint = obj.get("autoStartAfterWaypoint")?.asBoolean ?: false
|
||
)
|
||
}.getOrNull()
|
||
}
|
||
|
||
/**
|
||
* Versucht, eine Original-URI (die zur Backup-Zeit eingelesen wurde) auf eine
|
||
* frisch extrahierte Datei abzubilden.
|
||
*
|
||
* 1. Wenn Originalpfad in [extractedMedia] direkt referenziert ist (z. B.
|
||
* bei `file://`-URIs aus dem Backup-Manifest), → diese benutzen.
|
||
* 2. Sonst: nach `displayName`/Dateiname im bevorzugten Ordner suchen.
|
||
* 3. Sonst: nach `displayName`/Dateiname global suchen.
|
||
*
|
||
* Gibt `null` zurück, wenn keine extrahierte Datei zugeordnet werden konnte.
|
||
*/
|
||
private fun rewriteMediaReference(
|
||
originalUri: String,
|
||
originalDisplayName: String,
|
||
extractedMedia: Map<String, String>,
|
||
mediaByLeafName: Map<String, List<String>>,
|
||
preferZipFolder: String
|
||
): String? {
|
||
if (originalUri.isBlank()) return null
|
||
// 1. Direkter Treffer (Pfad)
|
||
extractedMedia[originalUri]?.let { return it }
|
||
|
||
// 2. Nach displayName im bevorzugten Ordner
|
||
val sanName = sanitize(originalDisplayName.ifBlank { "" }).lowercase(Locale.US)
|
||
if (sanName.isNotBlank()) {
|
||
val candidates = mediaByLeafName[sanName] ?: emptyList()
|
||
val preferred = candidates.firstOrNull { it.startsWith(preferZipFolder) }
|
||
if (preferred != null) extractedMedia[preferred]?.let { return it }
|
||
// 3. Global
|
||
candidates.firstOrNull()?.let { extractedMedia[it]?.let { u -> return u } }
|
||
}
|
||
|
||
// 4. Letzter Pfad-Komponente der originalen URI versuchen
|
||
val tail = originalUri.substringAfterLast('/').substringBefore('?')
|
||
.lowercase(Locale.US)
|
||
if (tail.isNotBlank()) {
|
||
val candidates = mediaByLeafName[tail] ?: emptyList()
|
||
val preferred = candidates.firstOrNull { it.startsWith(preferZipFolder) }
|
||
if (preferred != null) extractedMedia[preferred]?.let { return it }
|
||
candidates.firstOrNull()?.let { extractedMedia[it]?.let { u -> return u } }
|
||
}
|
||
return null
|
||
}
|
||
|
||
/** Verhindert Path-Traversal beim Entpacken in einen Zielordner. */
|
||
private fun safeMediaTarget(baseDir: File, entry: ZipEntry): File? {
|
||
val rel = entry.name.removePrefix("media/")
|
||
if (rel.contains("..")) return null
|
||
val safe = rel.split('/').joinToString(File.separator) { sanitizeForFs(it) }
|
||
if (safe.isBlank()) return null
|
||
val target = File(baseDir, safe)
|
||
// Path-Traversal-Schutz: Ziel muss Unterpfad von baseDir bleiben
|
||
val basePath = baseDir.canonicalPath
|
||
if (!target.canonicalPath.startsWith(basePath)) return null
|
||
target.parentFile?.mkdirs()
|
||
return target
|
||
}
|
||
|
||
private fun sanitize(s: String): String {
|
||
return s.replace(Regex("[\\\\/:*?\"<>|\\u0000-\\u001F]"), "_")
|
||
.replace(Regex("_+"), "_")
|
||
.trim('_', ' ', '.')
|
||
.take(120)
|
||
}
|
||
|
||
private fun sanitizeForFs(s: String): String {
|
||
if (s.isBlank()) return "_"
|
||
return sanitize(s).ifBlank { "_" }
|
||
}
|
||
}
|