react-native-nitro-player 0.5.4 → 0.5.6

package/android/src/main/java/com/margelo/nitro/nitroplayer/core/NitroPlayerLogger.kt

@@ -12,7 +12,10 @@ object NitroPlayerLogger {
      * Use trailing lambda syntax: NitroPlayerLogger.log("Tag") { "msg $value" }
      * The lambda is inlined (no heap allocation) and skipped entirely when disabled.
      */
-    inline fun log(header: String = "NitroPlayer", message: () -> String) {
+    inline fun log(
+        header: String = "NitroPlayer",
+        message: () -> String,
+    ) {
         if (isEnabled) {
             Log.d(header, message())
         }
@@ -23,7 +26,10 @@ object NitroPlayerLogger {
      * Note: the String is evaluated at the call site before this function runs.
      * Migrate to the lambda overload for hot paths.
      */
-    fun log(header: String = "NitroPlayer", message: String) {
+    fun log(
+        header: String = "NitroPlayer",
+        message: String,
+    ) {
         if (isEnabled) {
             Log.d(header, message)
         }

package/android/src/main/java/com/margelo/nitro/nitroplayer/core/TrackPlayerCore.kt

@@ -698,10 +698,11 @@ class TrackPlayerCore private constructor(
         currentRepeatMode = mode
         if (::player.isInitialized) {
             handler.post {
-                player.repeatMode = when (mode) {
-                    RepeatMode.TRACK -> Player.REPEAT_MODE_ONE
-                    else -> Player.REPEAT_MODE_OFF
-                }
+                player.repeatMode =
+                    when (mode) {
+                        RepeatMode.TRACK -> Player.REPEAT_MODE_ONE
+                        else -> Player.REPEAT_MODE_OFF
+                    }
             }
         }
         NitroPlayerLogger.log("TrackPlayerCore", "🔁 setRepeatMode: $mode")

package/android/src/main/java/com/margelo/nitro/nitroplayer/download/DownloadDatabase.kt

@@ -1,27 +1,29 @@
 package com.margelo.nitro.nitroplayer.download
 
 import android.content.Context
-import android.content.SharedPreferences
-import android.util.Log
+import com.margelo.nitro.core.AnyMap
 import com.margelo.nitro.core.NullType
 import com.margelo.nitro.nitroplayer.*
 import com.margelo.nitro.nitroplayer.core.NitroPlayerLogger
 import com.margelo.nitro.nitroplayer.playlist.PlaylistManager
+import com.margelo.nitro.nitroplayer.storage.NitroPlayerStorage
 import org.json.JSONArray
 import org.json.JSONObject
 import java.io.File
 
 /**
- * Manages persistence of downloaded track metadata using SharedPreferences
+ * Manages persistence of downloaded track metadata using file storage
  */
 class DownloadDatabase private constructor(
     private val context: Context,
 ) {
     companion object {
         private const val TAG = "DownloadDatabase"
-        private const val PREFS_NAME = "NitroPlayerDownloads"
-        private const val KEY_DOWNLOADED_TRACKS = "downloaded_tracks"
-        private const val KEY_PLAYLIST_TRACKS = "playlist_tracks"
+
+        // Legacy SharedPreferences keys (migration only)
+        private const val LEGACY_PREFS_NAME = "NitroPlayerDownloads"
+        private const val LEGACY_KEY_DOWNLOADED_TRACKS = "downloaded_tracks"
+        private const val LEGACY_KEY_PLAYLIST_TRACKS = "playlist_tracks"
 
         @Volatile
         private var instance: DownloadDatabase? = null
@@ -32,7 +34,6 @@ class DownloadDatabase private constructor(
             }
     }
 
-    private val prefs: SharedPreferences = context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
     private val downloadedTracks = mutableMapOf<String, DownloadedTrackRecord>()
     private val playlistTracks = mutableMapOf<String, MutableSet<String>>()
     private val fileManager = DownloadFileManager.getInstance(context)
@@ -254,13 +255,13 @@ class DownloadDatabase private constructor(
     /** Validates all downloads and removes records for missing files */
     fun syncDownloads(): Int {
         synchronized(this) {
-            NitroPlayerLogger.log("DownloadDatabase", "syncDownloads called")
+            NitroPlayerLogger.log(TAG, "syncDownloads called")
 
             val trackIdsToRemove = mutableListOf<String>()
 
             for ((trackId, record) in downloadedTracks) {
                 if (!File(record.localPath).exists()) {
-                    NitroPlayerLogger.log("DownloadDatabase", "Missing file for track $trackId: ${record.localPath}")
+                    NitroPlayerLogger.log(TAG, "Missing file for track $trackId: ${record.localPath}")
                     trackIdsToRemove.add(trackId)
                 }
             }
@@ -283,9 +284,9 @@ class DownloadDatabase private constructor(
 
             if (trackIdsToRemove.isNotEmpty()) {
                 saveToDisk()
-                NitroPlayerLogger.log("DownloadDatabase", "Cleaned up ${trackIdsToRemove.size} orphaned records")
+                NitroPlayerLogger.log(TAG, "Cleaned up ${trackIdsToRemove.size} orphaned records")
             } else {
-                NitroPlayerLogger.log("DownloadDatabase", "All downloads are valid")
+                NitroPlayerLogger.log(TAG, "All downloads are valid")
             }
 
             return trackIdsToRemove.size
@@ -295,39 +296,81 @@ class DownloadDatabase private constructor(
     // Persistence
     private fun saveToDisk() {
         try {
-            // Save downloaded tracks
             val tracksJson = JSONObject()
             for ((trackId, record) in downloadedTracks) {
                 tracksJson.put(trackId, record.toJson())
             }
-            prefs.edit().putString(KEY_DOWNLOADED_TRACKS, tracksJson.toString()).apply()
 
-            // Save playlist associations
             val playlistJson = JSONObject()
             for ((playlistId, trackIds) in playlistTracks) {
                 playlistJson.put(playlistId, JSONArray(trackIds.toList()))
             }
-            prefs.edit().putString(KEY_PLAYLIST_TRACKS, playlistJson.toString()).apply()
+
+            val wrapper =
+                JSONObject().apply {
+                    put("downloadedTracks", tracksJson)
+                    put("playlistTracks", playlistJson)
+                }
+            NitroPlayerStorage.write(context, "downloads.json", wrapper.toString())
         } catch (e: Exception) {
             e.printStackTrace()
         }
     }
 
     private fun loadFromDisk() {
-        try {
-            // Load downloaded tracks
-            val tracksString = prefs.getString(KEY_DOWNLOADED_TRACKS, null)
-            if (tracksString != null) {
+        // 1. Try new JSON file (post-migration)
+        val json = NitroPlayerStorage.read(context, "downloads.json")
+        if (json != null) {
+            try {
+                val wrapper = JSONObject(json)
+
+                val tracksJson = wrapper.optJSONObject("downloadedTracks")
+                if (tracksJson != null) {
+                    for (trackId in tracksJson.keys()) {
+                        val record = DownloadedTrackRecord.fromJson(tracksJson.getJSONObject(trackId))
+                        downloadedTracks[trackId] = record
+                    }
+                }
+
+                val playlistJson = wrapper.optJSONObject("playlistTracks")
+                if (playlistJson != null) {
+                    for (playlistId in playlistJson.keys()) {
+                        val trackIdsArray = playlistJson.getJSONArray(playlistId)
+                        val trackIds = mutableSetOf<String>()
+                        for (i in 0 until trackIdsArray.length()) {
+                            trackIds.add(trackIdsArray.getString(i))
+                        }
+                        playlistTracks[playlistId] = trackIds
+                    }
+                }
+            } catch (e: Exception) {
+                e.printStackTrace()
+            }
+            return
+        }
+
+        // 2. Migrate from SharedPreferences (one-time, existing installs)
+        val prefs = context.getSharedPreferences(LEGACY_PREFS_NAME, Context.MODE_PRIVATE)
+        var didMigrate = false
+
+        val tracksString = prefs.getString(LEGACY_KEY_DOWNLOADED_TRACKS, null)
+        if (tracksString != null) {
+            try {
                 val tracksJson = JSONObject(tracksString)
                 for (trackId in tracksJson.keys()) {
                     val record = DownloadedTrackRecord.fromJson(tracksJson.getJSONObject(trackId))
                     downloadedTracks[trackId] = record
                 }
+                prefs.edit().remove(LEGACY_KEY_DOWNLOADED_TRACKS).apply()
+                didMigrate = true
+            } catch (e: Exception) {
+                e.printStackTrace()
             }
+        }
 
-            // Load playlist associations
-            val playlistString = prefs.getString(KEY_PLAYLIST_TRACKS, null)
-            if (playlistString != null) {
+        val playlistString = prefs.getString(LEGACY_KEY_PLAYLIST_TRACKS, null)
+        if (playlistString != null) {
+            try {
                 val playlistJson = JSONObject(playlistString)
                 for (playlistId in playlistJson.keys()) {
                     val trackIdsArray = playlistJson.getJSONArray(playlistId)
@@ -337,15 +380,27 @@ class DownloadDatabase private constructor(
                     }
                     playlistTracks[playlistId] = trackIds
                 }
+                prefs.edit().remove(LEGACY_KEY_PLAYLIST_TRACKS).apply()
+                didMigrate = true
+            } catch (e: Exception) {
+                e.printStackTrace()
             }
-        } catch (e: Exception) {
-            e.printStackTrace()
+        }
+
+        if (didMigrate) {
+            saveToDisk()
         }
     }
 
     // Conversion Helpers
-    private fun trackItemToRecord(track: TrackItem): TrackItemRecord =
-        TrackItemRecord(
+    private fun trackItemToRecord(track: TrackItem): TrackItemRecord {
+        val extraPayloadJson =
+            track.extraPayload?.let { payload ->
+                val extraPayloadMap = payload.toHashMap()
+                JSONObject(extraPayloadMap)
+            }
+
+        return TrackItemRecord(
             id = track.id,
             title = track.title,
             artist = track.artist,
@@ -353,7 +408,9 @@ class DownloadDatabase private constructor(
             duration = track.duration,
             url = track.url,
             artwork = track.artwork?.asSecondOrNull(),
+            extraPayload = extraPayloadJson,
         )
+    }
 
     private fun recordToTrackItem(record: TrackItemRecord): TrackItem {
         val artworkVariant =
@@ -363,6 +420,21 @@ class DownloadDatabase private constructor(
                 null
             }
 
+        val extraPayload: AnyMap? =
+            record.extraPayload?.let { extraPayloadJson ->
+                val map = AnyMap()
+                val keyIterator = extraPayloadJson.keys()
+                while (keyIterator.hasNext()) {
+                    val key = keyIterator.next()
+                    when (val value = extraPayloadJson.get(key)) {
+                        is String -> map.setString(key, value)
+                        is Number -> map.setDouble(key, value.toDouble())
+                        is Boolean -> map.setBoolean(key, value)
+                    }
+                }
+                map
+            }
+
         return TrackItem(
             id = record.id,
             title = record.title,
@@ -371,7 +443,7 @@ class DownloadDatabase private constructor(
             duration = record.duration,
             url = record.url,
             artwork = artworkVariant,
-            extraPayload = null,
+            extraPayload = extraPayload,
         )
     }
 
@@ -394,16 +466,14 @@ class DownloadDatabase private constructor(
         )
     }
 
-    private fun convertPlaylistManagerToNitro(playlist: com.margelo.nitro.nitroplayer.playlist.Playlist): Playlist {
-        // PlaylistManager already uses TrackItem from generated code with proper Variant types
-        return Playlist(
+    private fun convertPlaylistManagerToNitro(playlist: com.margelo.nitro.nitroplayer.playlist.Playlist): Playlist =
+        Playlist(
             id = playlist.id,
             name = playlist.name,
-            description = null, // PlaylistManager doesn't have description in Nitro Playlist
-            artwork = null, // PlaylistManager doesn't have artwork in Nitro Playlist
+            description = null,
+            artwork = null,
             tracks = playlist.tracks.toTypedArray(),
         )
-    }
 }
 
 // Internal record classes
@@ -449,6 +519,7 @@ internal data class TrackItemRecord(
     val duration: Double,
     val url: String,
     val artwork: String?,
+    val extraPayload: JSONObject?,
 ) {
     fun toJson(): JSONObject =
         JSONObject().apply {
@@ -459,6 +530,7 @@ internal data class TrackItemRecord(
             put("duration", duration)
             put("url", url)
             put("artwork", artwork)
+            put("extraPayload", extraPayload)
         }
 
     companion object {
@@ -471,6 +543,12 @@ internal data class TrackItemRecord(
                 duration = json.getDouble("duration"),
                 url = json.getString("url"),
                 artwork = if (json.isNull("artwork")) null else json.getString("artwork"),
+                extraPayload =
+                    if (json.has("extraPayload") && !json.isNull("extraPayload")) {
+                        json.getJSONObject("extraPayload")
+                    } else {
+                        null
+                    },
             )
     }
 }

package/android/src/main/java/com/margelo/nitro/nitroplayer/playlist/PlaylistManager.kt

@@ -1,14 +1,13 @@
 package com.margelo.nitro.nitroplayer.playlist
 
 import android.content.Context
-import android.content.SharedPreferences
 import com.margelo.nitro.core.AnyMap
-import com.margelo.nitro.core.NullType
 import com.margelo.nitro.nitroplayer.QueueOperation
 import com.margelo.nitro.nitroplayer.TrackItem
 import com.margelo.nitro.nitroplayer.Variant_NullType_String
 import com.margelo.nitro.nitroplayer.core.TrackPlayerCore
 import com.margelo.nitro.nitroplayer.media.NitroPlayerMediaBrowserService
+import com.margelo.nitro.nitroplayer.storage.NitroPlayerStorage
 import org.json.JSONArray
 import org.json.JSONObject
 import java.util.UUID
@@ -26,11 +25,8 @@ class PlaylistManager private constructor(
     private val playlistListeners = mutableMapOf<String, CopyOnWriteArrayList<(Playlist, QueueOperation?) -> Unit>>()
     private var currentPlaylistId: String? = null
 
-    private val sharedPreferences: SharedPreferences =
-        context.getSharedPreferences("NitroPlayerPlaylists", Context.MODE_PRIVATE)
-
     private val saveHandler = android.os.Handler(android.os.Looper.getMainLooper())
-    private val saveRunnable = Runnable { savePlaylistsToPreferences() }
+    private val saveRunnable = Runnable { saveToFile() }
 
     private fun scheduleSave() {
         saveHandler.removeCallbacks(saveRunnable)
@@ -42,6 +38,9 @@ class PlaylistManager private constructor(
         @Suppress("ktlint:standard:property-naming")
         private var INSTANCE: PlaylistManager? = null
 
+        // Legacy SharedPreferences name (migration only)
+        private const val LEGACY_PREFS_NAME = "NitroPlayerPlaylists"
+
         @JvmStatic
         fun getInstance(context: Context): PlaylistManager =
             INSTANCE ?: synchronized(this) {
@@ -50,7 +49,7 @@ class PlaylistManager private constructor(
     }
 
     init {
-        // Don't load from preferences on init - only load when Android Auto needs it
+        // Don't load from file on init - only load when Android Auto needs it
     }
 
     /**
@@ -368,7 +367,9 @@ class PlaylistManager private constructor(
         playlistListeners[playlistId]?.forEach { it(playlist, operation) }
     }
 
-    private fun savePlaylistsToPreferences() {
+    // MARK: - Persistence
+
+    private fun saveToFile() {
         try {
             val jsonArray = JSONArray()
             synchronized(playlists) {
@@ -390,7 +391,6 @@ class PlaylistManager private constructor(
                                         put("duration", track.duration)
                                         put("url", track.url)
                                         track.artwork?.let { put("artwork", it) }
-                                        // Serialize extraPayload to JSON for persistence
                                         track.extraPayload?.let { payload ->
                                             val extraPayloadMap = payload.toHashMap()
                                             val extraPayloadJson = JSONObject(extraPayloadMap)
@@ -405,84 +405,120 @@ class PlaylistManager private constructor(
                 }
             }
 
-            sharedPreferences
-                .edit()
-                .putString("playlists", jsonArray.toString())
-                .putString("currentPlaylistId", currentPlaylistId)
-                .apply()
+            val wrapper =
+                JSONObject().apply {
+                    put("playlists", jsonArray)
+                    put("currentPlaylistId", currentPlaylistId)
+                }
+            NitroPlayerStorage.write(context, "playlists.json", wrapper.toString())
         } catch (e: Exception) {
             e.printStackTrace()
         }
     }
 
-    private fun loadPlaylistsFromPreferences() {
-        try {
-            val jsonString = sharedPreferences.getString("playlists", null)
-            if (jsonString != null) {
-                val jsonArray = JSONArray(jsonString)
-                synchronized(playlists) {
-                    playlists.clear()
-                    for (i in 0 until jsonArray.length()) {
-                        val jsonObject = jsonArray.getJSONObject(i)
-                        val tracks = mutableListOf<TrackItem>()
-                        val tracksArray = jsonObject.getJSONArray("tracks")
-                        for (j in 0 until tracksArray.length()) {
-                            val trackObj = tracksArray.getJSONObject(j)
-                            val artworkStr = trackObj.optString("artwork")
-                            val artwork: Variant_NullType_String? =
-                                if (!artworkStr.isNullOrEmpty()) {
-                                    Variant_NullType_String.create(artworkStr)
-                                } else {
-                                    null
-                                }
-                            // Deserialize extraPayload from JSON
-                            val extraPayload: AnyMap? =
-                                if (trackObj.has("extraPayload")) {
-                                    val extraPayloadJson = trackObj.getJSONObject("extraPayload")
-                                    val map = AnyMap()
-                                    val keyIterator = extraPayloadJson.keys()
-                                    while (keyIterator.hasNext()) {
-                                        val key = keyIterator.next()
-                                        when (val value = extraPayloadJson.get(key)) {
-                                            is String -> map.setString(key, value)
-                                            is Number -> map.setDouble(key, value.toDouble())
-                                            is Boolean -> map.setBoolean(key, value)
-                                        }
-                                    }
-                                    map
-                                } else {
-                                    null
+    fun loadPlaylistsFromFile() {
+        // 1. Try new JSON file (post-migration)
+        val json = NitroPlayerStorage.read(context, "playlists.json")
+        if (json != null) {
+            try {
+                val wrapper = JSONObject(json)
+                val jsonArray = wrapper.optJSONArray("playlists") ?: JSONArray()
+                parseAndLoadPlaylists(jsonArray)
+                currentPlaylistId =
+                    if (wrapper.isNull("currentPlaylistId")) {
+                        null
+                    } else {
+                        wrapper.optString("currentPlaylistId", null.toString()).takeIf { it != "null" }
+                    }
+            } catch (e: Exception) {
+                e.printStackTrace()
+            }
+            return
+        }
+
+        // 2. Migrate from SharedPreferences (one-time, existing installs)
+        val prefs = context.getSharedPreferences(LEGACY_PREFS_NAME, Context.MODE_PRIVATE)
+        val legacyJson = prefs.getString("playlists", null)
+        if (legacyJson != null) {
+            try {
+                val jsonArray = JSONArray(legacyJson)
+                parseAndLoadPlaylists(jsonArray)
+                currentPlaylistId = prefs.getString("currentPlaylistId", null)
+                // Remove old SharedPreferences data to free space
+                prefs
+                    .edit()
+                    .remove("playlists")
+                    .remove("currentPlaylistId")
+                    .apply()
+                // Persist in new format
+                saveToFile()
+            } catch (e: Exception) {
+                e.printStackTrace()
+            }
+            return
+        }
+
+        // 3. Fresh install — nothing to load
+    }
+
+    private fun parseAndLoadPlaylists(jsonArray: JSONArray) {
+        synchronized(playlists) {
+            playlists.clear()
+            for (i in 0 until jsonArray.length()) {
+                val jsonObject = jsonArray.getJSONObject(i)
+                val tracks = mutableListOf<TrackItem>()
+                val tracksArray = jsonObject.getJSONArray("tracks")
+                for (j in 0 until tracksArray.length()) {
+                    val trackObj = tracksArray.getJSONObject(j)
+                    val artworkStr = trackObj.optString("artwork")
+                    val artwork: Variant_NullType_String? =
+                        if (!artworkStr.isNullOrEmpty()) {
+                            Variant_NullType_String.create(artworkStr)
+                        } else {
+                            null
+                        }
+                    val extraPayload: AnyMap? =
+                        if (trackObj.has("extraPayload")) {
+                            val extraPayloadJson = trackObj.getJSONObject("extraPayload")
+                            val map = AnyMap()
+                            val keyIterator = extraPayloadJson.keys()
+                            while (keyIterator.hasNext()) {
+                                val key = keyIterator.next()
+                                when (val value = extraPayloadJson.get(key)) {
+                                    is String -> map.setString(key, value)
+                                    is Number -> map.setDouble(key, value.toDouble())
+                                    is Boolean -> map.setBoolean(key, value)
                                 }
-                            tracks.add(
-                                TrackItem(
-                                    id = trackObj.getString("id"),
-                                    title = trackObj.getString("title"),
-                                    artist = trackObj.getString("artist"),
-                                    album = trackObj.getString("album"),
-                                    duration = trackObj.getDouble("duration"),
-                                    url = trackObj.getString("url"),
-                                    artwork = artwork,
-                                    extraPayload = extraPayload,
-                                ),
-                            )
+                            }
+                            map
+                        } else {
+                            null
                         }
-                        val descriptionStr = jsonObject.optString("description")
-                        val artworkStr = jsonObject.optString("artwork")
-                        val playlist =
-                            Playlist(
-                                id = jsonObject.getString("id"),
-                                name = jsonObject.getString("name"),
-                                description = if (!descriptionStr.isNullOrEmpty()) descriptionStr else null,
-                                artwork = if (!artworkStr.isNullOrEmpty()) artworkStr else null,
-                                tracks = tracks,
-                            )
-                        playlists[playlist.id] = playlist
-                    }
+                    tracks.add(
+                        TrackItem(
+                            id = trackObj.getString("id"),
+                            title = trackObj.getString("title"),
+                            artist = trackObj.getString("artist"),
+                            album = trackObj.getString("album"),
+                            duration = trackObj.getDouble("duration"),
+                            url = trackObj.getString("url"),
+                            artwork = artwork,
+                            extraPayload = extraPayload,
+                        ),
+                    )
                 }
-                currentPlaylistId = sharedPreferences.getString("currentPlaylistId", null)
+                val descriptionStr = jsonObject.optString("description")
+                val artworkStr = jsonObject.optString("artwork")
+                val playlist =
+                    Playlist(
+                        id = jsonObject.getString("id"),
+                        name = jsonObject.getString("name"),
+                        description = if (!descriptionStr.isNullOrEmpty()) descriptionStr else null,
+                        artwork = if (!artworkStr.isNullOrEmpty()) artworkStr else null,
+                        tracks = tracks,
+                    )
+                playlists[playlist.id] = playlist
             }
-        } catch (e: Exception) {
-            e.printStackTrace()
         }
     }
 }

package/android/src/main/java/com/margelo/nitro/nitroplayer/storage/NitroPlayerStorage.kt

@@ -0,0 +1,57 @@
+package com.margelo.nitro.nitroplayer.storage
+
+import android.content.Context
+import com.margelo.nitro.nitroplayer.core.NitroPlayerLogger
+import java.io.File
+
+object NitroPlayerStorage {
+    private const val TAG = "NitroPlayerStorage"
+    private const val DIR_NAME = "nitroplayer"
+
+    /** Reads the contents of [filename] from the NitroPlayer storage directory, or null if absent. */
+    fun read(
+        context: Context,
+        filename: String,
+    ): String? {
+        val file = File(storageDirectory(context), filename)
+        return if (file.exists()) {
+            try {
+                file.readText()
+            } catch (e: Exception) {
+                NitroPlayerLogger.log(TAG, "read($filename) failed: $e")
+                null
+            }
+        } else {
+            null
+        }
+    }
+
+    /**
+     * Atomically writes [json] to [filename] in the NitroPlayer storage directory.
+     * Writes to `<filename>.tmp` first, then renames — leaving the prior file
+     * untouched on failure (crash-safe).
+     */
+    fun write(
+        context: Context,
+        filename: String,
+        json: String,
+    ) {
+        try {
+            val dir = storageDirectory(context)
+            dir.mkdirs()
+            val tmp = File(dir, "$filename.tmp")
+            val dest = File(dir, filename)
+            tmp.writeText(json)
+            if (!tmp.renameTo(dest)) {
+                // renameTo can fail across mount points; copy then delete as fallback
+                dest.writeText(tmp.readText())
+                tmp.delete()
+            }
+        } catch (e: Exception) {
+            NitroPlayerLogger.log(TAG, "write($filename) failed: $e")
+        }
+    }
+
+    /** Returns the NitroPlayer subdirectory inside filesDir. */
+    private fun storageDirectory(context: Context): File = File(context.filesDir, DIR_NAME)
+}