Continuing work on #16

app/src/main/java/com/example/mear/MainActivity.kt

@@ -54,7 +54,8 @@ class MainActivity : AppCompatActivity() {
         if (TrackPayer == null) {
             TrackPayer = MediaPlayer()
             playerInitialized = true
-            TrackPayer!!.setDataSource(allTracks!![currentSong!!].songPath)
+            val tr = TrackRepository(this).getTrack(currentSong!!)
+            TrackPayer!!.setDataSource(tr.songPath)
             TrackPayer!!.prepare()
         }
     }
@@ -65,9 +66,6 @@ class MainActivity : AppCompatActivity() {
             if (!TrackPayer!!.isPlaying) {
                 TrackPayer!!.start()
                 configureTrackDisplay()
-
-
-                println("ss")
             } else {
                 TrackPayer!!.pause()
             }
@@ -85,7 +83,7 @@ class MainActivity : AppCompatActivity() {
             }
 
             TrackPayer!!.reset()
-            TrackPayer!!.setDataSource(allTracks!![currentSong!!].songPath)
+            TrackPayer!!.setDataSource(TrackRepository(this).getTrack(currentSong!!).songPath)
             TrackPayer!!.prepare()
             TrackPayer!!.start()
             configureTrackDisplay()
@@ -104,7 +102,7 @@ class MainActivity : AppCompatActivity() {
             }
 
             TrackPayer!!.reset()
-            TrackPayer!!.setDataSource(allTracks!![currentSong!!].songPath)
+            TrackPayer!!.setDataSource(TrackRepository(this).getTrack(currentSong!!).songPath)
             TrackPayer!!.prepare()
             TrackPayer!!.start()
             configureTrackDisplay()
@@ -115,12 +113,13 @@ class MainActivity : AppCompatActivity() {
         }
     }
     private fun configureTrackDisplay() {
-        val trackTitle = allTracks!![currentSong!!].title
-        val albumTitle = allTracks!![currentSong!!].album
+        val currTrack = TrackRepository(this).getTrack(currentSong!!)
+        val trackTitle = currTrack.title
+        val albumTitle = currTrack.album
         var trackCover: ByteArray? = null
 
-        if (!(allTracks!![currentSong!!].TrackCover == null)) {
-            trackCover = allTracks!![currentSong!!].TrackCover
+        if (!(currTrack.TrackCover == null)) {
+            trackCover = currTrack.TrackCover
         }
 
         TrackTitle.text.clear()
@@ -143,16 +142,16 @@ class MainActivity : AppCompatActivity() {
             when (playType) {
                 PlayTypes.PlayPreviousSong -> {
                     if (currentSong!! == 0) {
-                        songIndex = allTracks!!.size - 1
+                        songIndex = songCount
                     } else {
                         songIndex = currentSong!!.dec()
                     }
                 }
                 PlayTypes.PlaySong -> {
-                    songIndex = Random.nextInt(0, allTracks!!.size - 1)
+                    songIndex = Random.nextInt(0, songCount!!)
                 }
                 PlayTypes.PlayNextSong -> {
-                    if (currentSong!! == (allTracks!!.size - 1)) {
+                    if (currentSong!! == songCount!!) {
                         songIndex = 0
                     } else {
                         songIndex = currentSong!!.inc()
@@ -177,69 +176,44 @@ class MainActivity : AppCompatActivity() {
         return allSongs!!
     }
     private fun loadTracks(allSongs: MutableList<String>) {
-        var trackMgr = TrackManager(allSongs!!)
-        trackMgr.configureTracks()
-        val allTracks = trackMgr.allTracks
-        trackMgr = TrackManager( listOf())
-        this.allTracks = allTracks
+        try {
 
-        databaseInit(allTracks!!)
-        val obk = TrackRepository(this).getAll()
+        //var trackMgr = TrackManager(allSongs!!)
+        //trackMgr.deleteTable(this)
+            //songCount = trackMgr.configureTracks(this)
+        //songCount = trackMgr.configureTracks(this)
+        //TrackRepository(this).createSongCount(songCount!!)
+        //var sC = TrackRepository(this).getSongCount()
+        //trackMgr.dumpToDatabase(this)
+        //trackMgr.dumpToDatabase()
+        //val allTracks = trackMgr.allTracks
+        //databaseInit(allTracks!!)
+        //databaseInit(trackMgr.allTracks!!)
+        //trackMgr = TrackManager( mutableListOf())
+
+        //val obk = TrackRepository(this).getAll()
+        //TrackRepository(this).songCount = TrackRepository(this).getAll().size
+            songCount = TrackRepository(this).getSongCount()
 
         currentSong = fetchSongIndex(PlayTypes.PlaySong)
+        }
+        catch (ex: Exception) {
+            val exMsg = ex.message
+        }
     }
 
     private fun databaseInit(allTracks: MutableList<Track>) {
-        /**
-        database.use {
-            dropTable("Track")
-            createTable("Track", true,
-                "Id" to INTEGER + PRIMARY_KEY + UNIQUE,
-                "Title" to INTEGER, "Album" to TEXT, "Artist" to TEXT,
-                "Duration" to INTEGER, "Cover" to BLOB, "SongPath" to TEXT
-            )
-            for (songData in allTracks) {
-                insert("Track",
-                    "id" to songData.id,
-                    "Title" to songData.title,
-                    "Album" to songData.album,
-                    "Artist" to songData.artist,
-                    "Duration" to songData.length,
-                    "Cover" to songData.TrackCover,
-                    "FilePath" to songData.songPath)
-            }
-        }
-        */
-        /**
-        myDB.createTable("Track", true,
-            "Id" to INTEGER + UNIQUE,
-            "Title" to TEXT, "Artist" to TEXT, "Album" to TEXT,
-            "Duration" to INTEGER, "Cover" to BLOB, "SongPath" to TEXT)
-        */
-
 
         TrackRepository(this).delete()
         for (songData in allTracks) {
             TrackRepository(this).create(songData)
         }
     }
-    /**
-    private fun databaseGetTracks(db: ManagedSQLiteOpenHelper): List<Track> = db.use {
-        val trackParser = classParser<Track>()
-        var dbObj = db.readableDatabase
-        dbObj.use {
-            select("Track").exec {
-                val ss = this
-                val tracks: List<Track> = parseList()
-            }
-        }
-    }
-    */
 
     private var TrackPayer: MediaPlayer? = null
-    private var allTracks: MutableList<Track>? = null
     private var currentSong: Int? = null
     private var playerInitialized: Boolean? = null
+    private var songCount: Int? = null
 
     private enum class PlayTypes {
         PlayNextSong, PlaySong, PlayPreviousSong

app/src/main/java/com/example/mear/management/DatabaseManager.kt

@@ -28,10 +28,14 @@ class DatabaseManager(ctx: Context): ManagedSQLiteOpenHelper(ctx, "Mear",
             "Title" to TEXT, "Album" to TEXT, "Artist" to TEXT,
             "Cover" to BLOB, "Duration" to INTEGER,
             "FilePath" to TEXT)
+        db!!.createTable("TrackCount", true,
+            "Id" to INTEGER + PRIMARY_KEY + UNIQUE,
+            "TotalSongs" to INTEGER)
     }
 
     override fun onUpgrade(db: SQLiteDatabase?, oldVersion: Int, newVersion: Int) {
         db!!.dropTable("Track")
+        db!!.dropTable("TrackCount")
     }
 
 

app/src/main/java/com/example/mear/management/MusicFiles.kt

@@ -2,15 +2,14 @@ package com.example.mear.management
 
 import java.io.File
 import java.lang.Exception
-import kotlin.io.*
 
-class MusicFiles (val demoPath:  File) {
+class MusicFiles (private val demoPath:  File) {
 
 
     fun loadAllMusicPaths() {
         try {
             allSongs = mutableListOf()
-            val demoPath = this.demoPath.absoluteFile.toString() +"/music/"
+            val demoPath = this.demoPath.absoluteFile.toString() + "/music/"
             val f = File(demoPath)
             var count = 0
 
@@ -45,5 +44,5 @@ class MusicFiles (val demoPath:  File) {
 
     var allSongs: MutableList<String>?= null
     var songCount: Int? = null
-    val musicSongLimit = 120
+    val musicSongLimit = Int.MAX_VALUE
 }

app/src/main/java/com/example/mear/management/TrackManager.kt

@@ -1,5 +1,6 @@
 package com.example.mear.management
 
+import android.content.Context
 import android.graphics.BitmapFactory
 import android.media.MediaMetadataRetriever
 
@@ -7,12 +8,12 @@ import java.lang.Exception
 
 import com.example.mear.models.Track
 
-class TrackManager(val allSongPath: List<String>) {
+class TrackManager(var allSongPath: MutableList<String>) {
 
 
-    fun configureTracks() {
+    fun configureTracks(ctx: Context): Int {
+        var id = 0
         try {
-            var id = 0
             allTracks = mutableListOf()
             for (musicPath in allSongPath) {
                 var mmr = MediaMetadataRetriever()
@@ -30,19 +31,36 @@ class TrackManager(val allSongPath: List<String>) {
                 }
                 else {
                     art = mmr.embeddedPicture
-                    var songImage = BitmapFactory
-                        .decodeByteArray(art, 0, art!!.size)
+                }
+                if (trackTitle == null || trackArtist == null || trackAlbum == null ||
+                        trackLenghStr == null) {
+                    println("dd")
                 }
 
                 var track = Track(id, trackTitle, trackArtist, trackAlbum, trackLength,
                     art!!, musicPath)
+                dumpToDatabase(ctx, track)
                 id++
-                allTracks!!.add(track)
             }
+            TrackRepository(ctx).createSongCount((id -1))
         }
         catch (ex: Exception) {
             val exMsg = ex.message
         }
+        return id.dec()
+    }
+    fun dumpToDatabase(ctx: Context) {
+        TrackRepository(ctx).delete()
+        for (songData in allTracks!!) {
+            TrackRepository(ctx).create(songData)
+            allTracks!!.removeAt(songData.id  )
+        }
+    }
+    fun deleteTable(ctx: Context) {
+        TrackRepository(ctx).delete()
+    }
+    private fun dumpToDatabase(ctx: Context, track: Track) {
+        TrackRepository(ctx).create(track)
     }
 
     var allTracks: MutableList<Track>? = null

app/src/main/java/com/example/mear/management/TrackRepository.kt

@@ -1,13 +1,10 @@
 package com.example.mear.management
 
 import android.content.Context
-import com.example.mear.database
-
-import java.util.ArrayList
 
 import org.jetbrains.anko.db.*
 
-import com.example.mear.management.*
+import com.example.mear.database
 import com.example.mear.models.Track
 
 class TrackRepository(val context: Context) {
@@ -15,21 +12,55 @@ class TrackRepository(val context: Context) {
     fun getAll(): List<Track> = context.database.use {
         val tracks = mutableListOf<Track>()
 
-        select("Track", "id", "Title")
+        select("Track" )
             .parseList(object : MapRowParser<Track>{
                 override fun parseRow(columns: Map<String, Any?>): Track {
                     val id = columns.getValue("Id")
                     val title = columns.getValue("Title")
+                    val artist = columns.getValue("Artist").toString()
+                    val album = columns.getValue("Album").toString()
+                    val duration = columns.getValue("Duration").toString().toInt()
+                    val cover = columns.getValue("Cover").toString().toByteArray()
+                    val songPath = columns.getValue("FilePath").toString()
 
-                    val track = Track(id.toString().toInt(), title.toString(),"","",0,
-                        ByteArray(0), "")
+                    val track = Track(id.toString().toInt(), title.toString(),artist,album,
+                        duration,cover,songPath)
                     tracks.add(track)
 
                     return track
                 }
             })
+        sonC = tracks.count()
         tracks
     }
+    fun getTrack(id: Int): Track = context.database.use {
+        select("Track").where("Id = $id")
+            .parseSingle(object: MapRowParser<Track>{
+                override fun parseRow(columns: Map<String, Any?>): Track {
+                    val id = columns.getValue("Id").toString().toInt()
+                    val title = columns.getValue("Title").toString()
+                    val artist = columns.getValue("Artist").toString()
+                    var album = columns.getValue("Album").toString()
+                    val duration = columns.getValue("Duration").toString().toInt()
+                    var cover = columns.getValue("Cover").toString().toByteArray()
+                    var filePath = columns.getValue("FilePath").toString()
+
+                    val track = Track(id, title, artist, album, duration,
+                        cover, filePath)
+
+                    return track
+                }
+            })
+    }
+    fun getSongCount(): Int = context.database.use {
+        select("TrackCount").limit(1)
+            .parseSingle(object : MapRowParser<Int>{
+                override fun parseRow(columns: Map<String, Any?>): Int {
+
+                    return columns.getValue("TotalSongs").toString().toInt()
+                }
+            })
+    }
 
     fun create(track: Track) = context.database.use {
         insert("Track",
@@ -38,9 +69,14 @@ class TrackRepository(val context: Context) {
             "Album" to track.album,
             "Artist" to track.artist,
             "Duration" to track.length,
-            "SongPath" to track.songPath,
+            "FilePath" to track.songPath,
             "Cover" to track.TrackCover)
     }
+    fun createSongCount(songCount: Int) = context.database.use {
+        insert("TrackCount",
+            "Id" to 0,
+            "TotalSongs" to songCount)
+    }
 
     fun delete(track: Track) = context.database.use {
         delete("Track", whereClause = "id = {$track.id}")
@@ -48,4 +84,11 @@ class TrackRepository(val context: Context) {
     fun delete() = context.database.use {
         delete("Track")
     }
+
+
+    var songCount: Int? = null
+
+    companion object {
+        var sonC: Int = 0
+    }
 }