Merge branch 'tsumugi/devel' into tsumugi/master

app/build.gradle

         applicationId "fr.forum_thalie.tsumugi"
         minSdkVersion 16
         targetSdkVersion 29
-        versionCode 112
-        versionName "1.1.2"
+        versionCode 113
+        versionName "1.1.3"
         testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
         vectorDrawables.useSupportLibrary = true
     }

app/src/main/java/fr/forum_thalie/tsumugi/BootBroadcastReceiver.kt

 import android.util.Log
 import androidx.preference.PreferenceManager
 import fr.forum_thalie.tsumugi.alarm.RadioAlarm
+import fr.forum_thalie.tsumugi.planning.Planning
 import fr.forum_thalie.tsumugi.playerstore.PlayerStore
 
 class BootBroadcastReceiver : BroadcastReceiver(){
         {
 
             RadioAlarm.instance.setNextAlarm(context) // schedule next alarm
+            Planning.instance.parseUrl(context = context)
             if (!PlayerStore.instance.isInitialized)
                 PlayerStore.instance.initApi()
             if (PlayerStore.instance.streamerName.value.isNullOrBlank())

app/src/main/java/fr/forum_thalie/tsumugi/RadioService.kt

                     PlayerStore.instance.isStreamDown = true
                 }
                 else -> {
-                    PlayerStore.instance.fetchApi(numberOfSongs >= 2)
+                    PlayerStore.instance.fetchApi(/* numberOfSongs >= 2 */)
                 }
             }
         }

app/src/main/java/fr/forum_thalie/tsumugi/playerstore/PlayerStore.kt

 import android.util.Log
 import androidx.lifecycle.MutableLiveData
 import fr.forum_thalie.tsumugi.*
+import fr.forum_thalie.tsumugi.planning.Planning
 import org.json.JSONObject
 import java.net.URL
 import java.text.ParseException
 
     private fun getTimestamp(s: String) : Long
     {
-        val dateFormat = SimpleDateFormat("yyyy-MM-dd hh:mm:ss", Locale.getDefault())
+        val dateFormat = SimpleDateFormat("yyyy-MM-dd hh:mm:ss z", Locale.getDefault())
         try {
-            val t: Date? = dateFormat.parse(s)
+            val t: Date? = dateFormat.parse("$s ${Planning.instance.timeZone.id}")
+            //[REMOVE LOG CALLS]Log.d(tag, "date: $s -> $t")
             return t!!.time
         } catch (e: ParseException) {
             e.printStackTrace()
 
         currentSong.stopTime.value = ends
 
+        val apiTime = getTimestamp(res.getJSONObject("station").getString("schedulerTime"))
         // I noticed that the server has a big (3 to 9 seconds !!) offset for current time.
         // we can measure it when the player is playing, to compensate it and have our progress bar perfectly timed
         // latencyCompensator is set to null when beginPlaying() (we can't measure it at the moment we start playing, since we're in the middle of a song),
         // at this moment, we set it to 0. Then, next time the updateApi is called when we're playing, we measure the latency and we set out latencyComparator.
         if(isCompensatingLatency)
         {
-            latencyCompensator = getTimestamp(res.getJSONObject("station").getString("schedulerTime")) - (currentSong.startTime.value ?: getTimestamp(res.getJSONObject("station").getString("schedulerTime")))
-            //[REMOVE LOG CALLS]Log.d((tag, "latency compensator set to ${(latencyCompensator).toFloat()/1000} s")
+            latencyCompensator = apiTime - (currentSong.startTime.value!!)
+            //[REMOVE LOG CALLS]Log.d(tag, "latency compensator set to ${(latencyCompensator).toFloat() / 1000} s")
         }
-        currentTime.value = getTimestamp(res.getJSONObject("station").getString("schedulerTime")) - (latencyCompensator)
+        currentTime.value = apiTime - (latencyCompensator)
 
         /*
         val listeners = resMain.getInt("listeners")
     // ##################################################
 
     fun updateQueue() {
-        if (queue.isNotEmpty()) {
-            queue.remove(queue.first())
-            //[REMOVE LOG CALLS]Log.d((tag, queue.toString())
-            fetchLastRequest()
-            isQueueUpdated.value = true
-        } else if (isInitialized) {
-            fetchLastRequest()
-        } else {
-            //[REMOVE LOG CALLS]Log.d((tag,  "queue is empty! fetching anyway !!")
-            fetchLastRequest()
-        }
+        //[REMOVE LOG CALLS]Log.d(tag, queue.toString())
+        fetchLastRequest()
     }
 
     fun updateLp() {
 
     private fun fetchLastRequest()
     {
+        isQueueUpdated.value = false
         val sleepScrape: (Any?) -> String = {
             /* we can maximize our chances to retrieve the last queued song by specifically waiting for the number of seconds we measure between ICY metadata and API change.
              we add 2 seconds just to get a higher probability that the API has correctly updated. (the latency compensator can have a jitter of 1 second usually)
                     initApi()
                 } else
                 */
-                if (resMain.has("next") /*&& queue.isNotEmpty()*/) {
+                if (resMain.has("next")) {
                     val queueJSON =
                         resMain.getJSONObject("next")
                     val t = extractSong(queueJSON)
-                    if (queue.isNotEmpty() && (t == queue.last() || t == currentSong))
+                    if (queue.isNotEmpty() && (t == queue.last() || t == currentSong) && isQueueUpdated.value == false)
                     {
-                        //[REMOVE LOG CALLS]Log.d((tag, playerStoreTag +  "Song already in there: $t")
+                        //[REMOVE LOG CALLS]Log.d(tag, playerStoreTag +  "Song already in there: $t\nQueue:$queue")
                         Async(sleepScrape, post)
                     } else {
+                        if (queue.isNotEmpty())
+                            queue.remove(queue.first())
                         queue.add(queue.size, t)
                         //[REMOVE LOG CALLS]Log.d(tag, playerStoreTag +  "added last queue song: $t")
                         isQueueUpdated.value = true
+                        return // FUUUCK IT WAS CALLING THE ASYNC ONE MORE TIME AFTERWARDS !?
                     }
                 }
             }

app/src/main/java/fr/forum_thalie/tsumugi/playerstore/Song.kt

     override fun equals(other: Any?) : Boolean
     {
         val song: Song = other as Song
-        return this.title.value == song.title.value && this.artist.value == song.artist.value
+        return this.title.value === song.title.value && this.artist.value === song.artist.value
     }
 
     fun copy(song: Song) {