Add backup and restore functionality with localization support

- Introduced `SajiloBackup` struct for exporting and importing user preferences and day plans.
- Implemented `exportBackup` and `importBackup` methods in `AppModel` to handle backup operations.
- Added `SajiloBackupDocument` for file handling of backup data in JSON format.
- Enhanced `SettingsView` with UI elements for exporting and importing backups, including alerts for user feedback.
- Updated localization files to include new strings related to backup functionality in both English and Nepali.
- Added unit tests for `SajiloBackup` to ensure data integrity during encoding and decoding processes.
- Integrated a mini player in `DashboardView` for improved radio playback experience.

Author: adarshaacharya

Sources/SajiloApp/Core/Foundation/AppLanguage.swift

@@ -32,6 +32,12 @@ enum L10n {
     static let languageEnglish = LocalizedStringResource("language.english", bundle: .sajiloResources)
     static let languageNepali = LocalizedStringResource("language.nepali", bundle: .sajiloResources)
     static let settings = LocalizedStringResource("screen.settings", bundle: .sajiloResources)
+    static let backup = LocalizedStringResource("settings.backup", bundle: .sajiloResources)
+    static let exportData = LocalizedStringResource("settings.export-data", bundle: .sajiloResources)
+    static let importData = LocalizedStringResource("settings.import-data", bundle: .sajiloResources)
+    static let backupNote = LocalizedStringResource("settings.backup-note", bundle: .sajiloResources)
+    static let backupImported = LocalizedStringResource("settings.backup-imported", bundle: .sajiloResources)
+    static let ok = LocalizedStringResource("action.ok", bundle: .sajiloResources)
     static let back = LocalizedStringResource("action.back", bundle: .sajiloResources)
     static let festivals = LocalizedStringResource("action.festivals", bundle: .sajiloResources)
     static let convert = LocalizedStringResource("action.convert", bundle: .sajiloResources)

Sources/SajiloApp/Core/Persistence/SajiloBackup.swift

@@ -0,0 +1,69 @@
+import Foundation
+
+/// A portable, user-owned snapshot of Sajilo's personal data and preferences.
+/// Live feeds and caches are intentionally excluded: they are recreated from
+/// their public sources, while plans and choices cannot be reconstructed.
+struct SajiloBackup: Codable, Equatable, Sendable {
+    static let currentVersion = 1
+
+    struct Preferences: Codable, Equatable, Sendable {
+        var menuBarFormat: String
+        var customMenuBarShowsFlag: Bool
+        var customMenuBarShowsYear: Bool
+        var appLanguage: String
+        var numeralStyle: String
+        var weatherEnabled: Bool
+        var forexEnabled: Bool
+        var newsEnabled: Bool
+        var bazarEnabled: Bool
+        var rashifalEnabled: Bool
+        var radioEnabled: Bool
+        var weatherLocation: String
+        var forexFavourites: [String]
+        var vegetableFavourites: [String]
+        var selectedRashi: String?
+        var showsDockIcon: Bool
+        var notifyHolidayEve: Bool
+        var notifyFestivalEve: Bool
+    }
+
+    let formatVersion: Int
+    let exportedAt: Date
+    let preferences: Preferences
+    let dayPlans: [DayPlan]
+
+    init(preferences: Preferences, dayPlans: [DayPlan], exportedAt: Date = .now) {
+        formatVersion = Self.currentVersion
+        self.exportedAt = exportedAt
+        self.preferences = preferences
+        self.dayPlans = dayPlans
+    }
+
+    func encoded() throws -> Data {
+        let encoder = JSONEncoder()
+        encoder.outputFormatting = [.prettyPrinted, .sortedKeys]
+        encoder.dateEncodingStrategy = .iso8601
+        return try encoder.encode(self)
+    }
+
+    static func decode(_ data: Data) throws -> Self {
+        let decoder = JSONDecoder()
+        decoder.dateDecodingStrategy = .iso8601
+        let backup = try decoder.decode(Self.self, from: data)
+        guard backup.formatVersion == currentVersion else {
+            throw BackupError.unsupportedVersion(backup.formatVersion)
+        }
+        return backup
+    }
+
+    enum BackupError: LocalizedError, Equatable {
+        case unsupportedVersion(Int)
+
+        var errorDescription: String? {
+            switch self {
+            case let .unsupportedVersion(version):
+                "This backup uses an unsupported Sajilo format (version \(version))."
+            }
+        }
+    }
+}

Sources/SajiloApp/Features/AppModel.swift

@@ -707,6 +707,68 @@ final class AppModel {
         Task { [weak self] in await self?.rescheduleNotifications() }
     }
 
+    // MARK: - Backup
+
+    func exportBackup() throws -> Data {
+        try SajiloBackup(
+            preferences: .init(
+                menuBarFormat: selectedMenuBarFormat.rawValue,
+                customMenuBarShowsFlag: customMenuBarShowsFlag,
+                customMenuBarShowsYear: customMenuBarShowsYear,
+                appLanguage: appLanguage.rawValue,
+                numeralStyle: numeralStyle.rawValue,
+                weatherEnabled: isWeatherEnabled,
+                forexEnabled: isForexEnabled,
+                newsEnabled: isNewsEnabled,
+                bazarEnabled: isBazarEnabled,
+                rashifalEnabled: isRashifalEnabled,
+                radioEnabled: isRadioEnabled,
+                weatherLocation: selectedWeatherLocation.rawValue,
+                forexFavourites: forexFavourites,
+                vegetableFavourites: vegetableFavourites,
+                selectedRashi: selectedRashi?.rawValue,
+                showsDockIcon: showsDockIcon,
+                notifyHolidayEve: notificationOptions.eveOfPublicHoliday,
+                notifyFestivalEve: notificationOptions.eveOfFestival
+            ),
+            dayPlans: dayPlans
+        ).encoded()
+    }
+
+    /// Imports preferences and adds plans that are not already present. An
+    /// import never deletes local plans or overwrites one with the same ID.
+    func importBackup(_ data: Data) throws {
+        let backup = try SajiloBackup.decode(data)
+        let preferences = backup.preferences
+
+        selectedMenuBarFormat = MenuBarFormat(rawValue: preferences.menuBarFormat) ?? selectedMenuBarFormat
+        customMenuBarShowsFlag = preferences.customMenuBarShowsFlag
+        customMenuBarShowsYear = preferences.customMenuBarShowsYear
+        appLanguage = AppLanguage(rawValue: preferences.appLanguage) ?? appLanguage
+        numeralStyle = NumeralStyle(rawValue: preferences.numeralStyle) ?? numeralStyle
+        isWeatherEnabled = preferences.weatherEnabled
+        isForexEnabled = preferences.forexEnabled
+        isNewsEnabled = preferences.newsEnabled
+        isBazarEnabled = preferences.bazarEnabled
+        isRashifalEnabled = preferences.rashifalEnabled
+        isRadioEnabled = preferences.radioEnabled
+        selectedWeatherLocation = WeatherLocation(rawValue: preferences.weatherLocation) ?? selectedWeatherLocation
+        forexFavourites = preferences.forexFavourites
+        vegetableFavourites = preferences.vegetableFavourites
+        selectedRashi = preferences.selectedRashi.flatMap(RashiSign.init(rawValue:))
+        showsDockIcon = preferences.showsDockIcon
+        notificationOptions = .init(
+            eveOfPublicHoliday: preferences.notifyHolidayEve,
+            eveOfFestival: preferences.notifyFestivalEve
+        )
+
+        let existingIDs = Set(dayPlans.map(\.id))
+        dayPlans.append(contentsOf: backup.dayPlans.filter { !existingIDs.contains($0.id) })
+        dayPlanStore.save(dayPlans)
+        applyActivationPolicy()
+        Task { [weak self] in await self?.rescheduleNotifications() }
+    }
+
     // MARK: - Notifications
 
     /// Reads the current permission without prompting, so Settings can explain

Sources/SajiloApp/Features/Dashboard/DashboardView.swift

@@ -76,6 +76,15 @@ struct DashboardView: View {
                     .modifier(RouteLayer(isActive: route == .tools, edge: 1, reduceMotion: reduceMotion))
             }
 
+            if let station = model.radioPlayer.currentStation, model.radioPlayer.isPlaying {
+                RadioMiniPlayer(
+                    station: station,
+                    isResolving: model.radioPlayer.isResolving,
+                    openRadio: { navigate(to: .radio) },
+                    togglePlayback: { Task { await model.radioPlayer.toggle(station) } }
+                )
+            }
+
             actionBar
         }
         .environment(\.numeralStyle, model.numeralStyle)

Sources/SajiloApp/Features/Radio/RadioView.swift

@@ -157,6 +157,50 @@ private struct NowPlayingCard: View {
     }
 }
 
+/// Remains visible above Sajilo's navigation while a station is playing, so
+/// leaving the Radio screen never makes audio feel detached from the app.
+struct RadioMiniPlayer: View {
+    let station: RadioStation
+    let isResolving: Bool
+    let openRadio: () -> Void
+    let togglePlayback: () -> Void
+
+    var body: some View {
+        HStack(spacing: Theme.Space.s) {
+            EqualizerView(isPlaying: true)
+
+            Button(action: openRadio) {
+                VStack(alignment: .leading, spacing: 1) {
+                    Text(L10n.radio)
+                        .font(.caption2)
+                        .foregroundStyle(.secondary)
+                    Text(verbatim: station.name)
+                        .font(.caption.weight(.semibold))
+                        .lineLimit(1)
+                }
+                .frame(maxWidth: .infinity, alignment: .leading)
+                .contentShape(.rect)
+            }
+            .buttonStyle(.plain)
+            .accessibilityLabel("Now playing \(station.name)")
+            .accessibilityHint("Opens radio")
+
+            Button(action: togglePlayback) {
+                Image(systemName: isResolving ? "arrow.clockwise" : "pause.fill")
+            }
+            .buttonStyle(IconButtonStyle())
+            .disabled(isResolving)
+            .accessibilityLabel("Pause radio")
+        }
+        .padding(.horizontal, Theme.Space.m)
+        .padding(.vertical, Theme.Space.xs)
+        .background(Theme.Palette.brand.opacity(0.10))
+        .overlay(alignment: .top) {
+            Divider().opacity(0.45)
+        }
+    }
+}
+
 private struct StationRow: View {
     let station: RadioStation
     let isCurrent: Bool

Sources/SajiloApp/Features/Settings/SajiloBackupDocument.swift

@@ -0,0 +1,23 @@
+import UniformTypeIdentifiers
+import SwiftUI
+
+struct SajiloBackupDocument: FileDocument {
+    static let readableContentTypes: [UTType] = [.json]
+
+    let data: Data
+
+    init(data: Data) {
+        self.data = data
+    }
+
+    init(configuration: ReadConfiguration) throws {
+        guard let data = configuration.file.regularFileContents else {
+            throw CocoaError(.fileReadCorruptFile)
+        }
+        self.data = data
+    }
+
+    func fileWrapper(configuration: WriteConfiguration) throws -> FileWrapper {
+        FileWrapper(regularFileWithContents: data)
+    }
+}

Sources/SajiloApp/Features/Settings/SettingsView.swift

@@ -11,6 +11,10 @@ struct SettingsView: View {
     @Environment(\.appUpdater) private var appUpdater
     @Bindable var model: AppModel
     let onBack: () -> Void
+    @State private var backupDocument: SajiloBackupDocument?
+    @State private var isExportingBackup = false
+    @State private var isImportingBackup = false
+    @State private var backupMessage: String?
 
     var body: some View {
         VStack(spacing: 0) {
@@ -57,6 +61,26 @@ struct SettingsView: View {
                         .disabled(appUpdater == nil)
                     }
 
+                    SettingsSection(L10n.backup) {
+                        Button(L10n.exportData, systemImage: "square.and.arrow.up") {
+                            do {
+                                backupDocument = SajiloBackupDocument(data: try model.exportBackup())
+                                isExportingBackup = true
+                            } catch {
+                                backupMessage = error.localizedDescription
+                            }
+                        }
+
+                        Button(L10n.importData, systemImage: "square.and.arrow.down") {
+                            isImportingBackup = true
+                        }
+
+                        Text(L10n.backupNote)
+                            .font(.caption2)
+                            .foregroundStyle(.secondary)
+                            .fixedSize(horizontal: false, vertical: true)
+                    }
+
                     SettingsSection(L10n.numerals) {
                         Picker(L10n.numerals, selection: $model.numeralStyle) {
                             ForEach(NumeralStyle.allCases) { style in
@@ -146,6 +170,41 @@ struct SettingsView: View {
         // Reads the current permission; it never prompts, so opening Settings
         // cannot trigger a system dialog.
         .task { await model.refreshNotificationAuthorization() }
+        .fileExporter(
+            isPresented: $isExportingBackup,
+            document: backupDocument,
+            contentType: .json,
+            defaultFilename: "Sajilo-backup"
+        ) { result in
+            if case let .failure(error) = result {
+                backupMessage = error.localizedDescription
+            }
+        }
+        .fileImporter(
+            isPresented: $isImportingBackup,
+            allowedContentTypes: [.json],
+            allowsMultipleSelection: false
+        ) { result in
+            do {
+                let url = try result.get().first ?? { throw CocoaError(.fileReadNoSuchFile) }()
+                guard url.startAccessingSecurityScopedResource() else {
+                    throw CocoaError(.fileReadNoPermission)
+                }
+                defer { url.stopAccessingSecurityScopedResource() }
+                try model.importBackup(Data(contentsOf: url))
+                backupMessage = String(localized: L10n.backupImported)
+            } catch {
+                backupMessage = error.localizedDescription
+            }
+        }
+        .alert(L10n.backup, isPresented: Binding(
+            get: { backupMessage != nil },
+            set: { if !$0 { backupMessage = nil } }
+        )) {
+            Button(L10n.ok) { backupMessage = nil }
+        } message: {
+            Text(verbatim: backupMessage ?? "")
+        }
     }
 
     /// A reminder switched on but denied at the system level would otherwise

Sources/SajiloApp/Resources/en.lproj/Localizable.strings

@@ -99,6 +99,11 @@
 "screen.settings" = "Settings";
 "screen.upcoming" = "Upcoming events";
 "settings.bazar" = "Gold, silver and fuel";
+"settings.backup" = "Backup";
+"settings.backup-imported" = "Sajilo data imported.";
+"settings.backup-note" = "Backs up your personal dates and Sajilo settings. Live prices and news are fetched again.";
+"settings.export-data" = "Export Sajilo data…";
+"settings.import-data" = "Import Sajilo data…";
 "settings.bazar-source" = "Rates source";
 "settings.calendar-range" = "Calendar";
 "settings.city" = "City";

Sources/SajiloApp/Resources/ne.lproj/Localizable.strings

@@ -99,6 +99,11 @@
 "screen.settings" = "सेटिङ";
 "screen.upcoming" = "आगामी कार्यक्रमहरू";
 "settings.bazar" = "सुन, चाँदी र इन्धन";
+"settings.backup" = "ब्याकअप";
+"settings.backup-imported" = "Sajilo डेटा आयात भयो।";
+"settings.backup-note" = "तपाईंका व्यक्तिगत मिति र Sajilo सेटिङको ब्याकअप हुन्छ। मूल्य र समाचार फेरि ल्याइन्छ।";
+"settings.export-data" = "Sajilo डेटा निर्यात गर्नुहोस्…";
+"settings.import-data" = "Sajilo डेटा आयात गर्नुहोस्…";
 "settings.bazar-source" = "दरको स्रोत";
 "settings.calendar-range" = "पात्रो";
 "settings.city" = "सहर";