AbukPlayerService

package com.abuk.abook.player


import android.app.PendingIntent
import android.app.TaskStackBuilder
import android.content.*
import android.os.Bundle
import android.support.v4.media.MediaBrowserCompat
import android.support.v4.media.MediaBrowserServiceCompat
import android.support.v4.media.session.MediaButtonReceiver
import android.support.v4.media.session.MediaSessionCompat
import android.text.TextUtils
import com.abuk.abook.R
import android.support.v4.media.MediaMetadataCompat
import android.support.v4.media.session.PlaybackStateCompat
import com.abuk.abook.event.NewQueueEvent
import org.greenrobot.eventbus.EventBus
import org.greenrobot.eventbus.Subscribe
import org.greenrobot.eventbus.ThreadMode
import android.content.Intent
import android.util.Log
import com.abuk.abook.Prefs
import com.abuk.abook.data.model.Book
import com.abuk.abook.event.NewBufferEvent
import com.abuk.abook.event.UpdateQueueItem
import com.abuk.abook.view.activity.PlayerActivity
import android.app.ActivityManager
import com.abuk.abook.ToastLogger
import com.raizlabs.android.dbflow.kotlinextensions.from
import com.raizlabs.android.dbflow.kotlinextensions.list
import com.raizlabs.android.dbflow.kotlinextensions.select


class PlayerService : MediaBrowserServiceCompat(),PlaybackManager.PlaybackServiceCallback {

    private lateinit var mediaSessionCompat: MediaSessionCompat

    private lateinit var playback: Playback

    private lateinit var queueManager: QueueManager
    lateinit var playbackManager: PlaybackManager

    private var notificationManager:NotificationManager? = null



    override fun onCreate() {
        super.onCreate()
        playback = ExoPlayback(this)
        queueManager = QueueManager(this.applicationContext, object : QueueManager.MetadataUpdateListener {
            override fun onMetadataChanged(metadata: MediaMetadataCompat) {
                mediaSessionCompat.setMetadata(metadata)
            }

            override fun onMetadataRetrieveError() {

            }

            override fun onCurrentQueueIndexUpdated(queueIndex: Int) {
                playbackManager.handlePlayRequest(true)

            }

            override fun onQueueUpdated(title: String, newQueue: List<MediaSessionCompat.QueueItem>) {
                mediaSessionCompat.setQueue(newQueue)
                mediaSessionCompat.setQueueTitle(title)
            }
        })
        playbackManager = PlaybackManager(this, queueManager, playback,this)
        initMediaSession()
        setMediaPlaybackState(PlaybackStateCompat.STATE_PAUSED)
        try {
            notificationManager = NotificationManager(this)
        } catch (e: Exception) {
            throw IllegalStateException("Could not create a MediaNotificationManager", e)
        }
//        val book = EventBus.getDefault().getStickyEvent(Book::class.java)
        try {
            val book = (select from Book::class).list[0]
            book.chapters = book.localChapters
//        book.authors = book.localAuthors
            if (book != null){
                queueManager.setCurrentQueue(book)
                val pr = Prefs(this)
                if (pr.isFirstPlay()) {
                    playbackManager.handlePlayRequest(true,resetStop = true)
                    pr.setFirstPlay()
                }else{
                    playbackManager.handlePlayRequest(false,resetStop = true)
                }

            }
        } catch (e: Exception) {
        }
        EventBus.getDefault().register(this)
        ToastLogger.log("create")
    }

    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
        MediaButtonReceiver.handleIntent(mediaSessionCompat,intent)
        ToastLogger.log("action" )
        return super.onStartCommand(intent, flags, startId)
    }


    private fun initMediaSession() {
        val mediaButtonReceiver = ComponentName(applicationContext, MediaButtonReceiver::class.java)
        mediaSessionCompat = MediaSessionCompat(applicationContext, "Tag", mediaButtonReceiver, null)
        mediaSessionCompat.setCallback(playbackManager.mediaSessionCallback)
        mediaSessionCompat.setFlags(MediaSessionCompat.FLAG_HANDLES_MEDIA_BUTTONS or MediaSessionCompat.FLAG_HANDLES_TRANSPORT_CONTROLS)
        val mediaButtonIntent = Intent(Intent.ACTION_MEDIA_BUTTON)
        mediaButtonIntent.setClass(this, MediaButtonReceiver::class.java)
        val pendingIntent = PendingIntent.getBroadcast(this, 0, mediaButtonIntent, 0)
        mediaSessionCompat.setMediaButtonReceiver(pendingIntent)
        val intent = Intent(this, PlayerActivity::class.java)
        val stackBuilder = TaskStackBuilder.create(this)
        stackBuilder.addNextIntentWithParentStack(intent)
        val pi = stackBuilder.getPendingIntent(0,PendingIntent.FLAG_UPDATE_CURRENT)
        mediaSessionCompat.setSessionActivity(pi)
        mediaSessionCompat.isActive = true
        sessionToken = mediaSessionCompat.sessionToken
    }

    private fun setMediaPlaybackState(state: Int) {
        val playbackstateBuilder = PlaybackStateCompat.Builder()
        if (state == PlaybackStateCompat.STATE_PLAYING) {
            playbackstateBuilder.setActions(PlaybackStateCompat.ACTION_PLAY_PAUSE or PlaybackStateCompat.ACTION_PAUSE)
        } else {
            playbackstateBuilder.setActions(PlaybackStateCompat.ACTION_PLAY_PAUSE or PlaybackStateCompat.ACTION_PLAY)
        }
        playbackstateBuilder.setState(state, PlaybackStateCompat.PLAYBACK_POSITION_UNKNOWN, 0f)
        mediaSessionCompat.setPlaybackState(playbackstateBuilder.build())
    }

    override fun onDestroy() {
        ToastLogger.log("destroy")
        super.onDestroy()
        playback.release()
        mediaSessionCompat.release()
        notificationManager?.stopNotification()
        EventBus.getDefault().unregister(this)
    }

    override fun onTaskRemoved(rootIntent: Intent?) {
        super.onTaskRemoved(rootIntent)
        stopPlayer()
    }


    fun stopPlayer(){
        if (notificationManager?.foreground != true)stopSelf()
    }

    override fun onNotificationRequired() {
        notificationManager?.startNotification()

    }

    override fun onPlaybackStateUpdated(newState: PlaybackStateCompat) {
        mediaSessionCompat.setPlaybackState(newState)
    }

    @Subscribe(threadMode = ThreadMode.MAIN)
    fun onQueueChange(queue: NewQueueEvent) {
//        queueManager.setCurrentQueue(queue.title,queue.queue,queue.startItem.toString())
//        queueManager.updateMetadata()
//        playbackManager.handlePlayRequest(false)
    }
    @Subscribe(threadMode = ThreadMode.MAIN)
    fun onQueueChange(update: UpdateQueueItem) {
        queueManager.updateItem(update.item)
    }
    @Subscribe(threadMode = ThreadMode.MAIN)
    fun onBuf(buffering: NewBufferEvent) {
        (playback as? ExoPlayback)?.bufferListener = buffering.onBufferingUpdateListener
    }


    override fun onLoadChildren(parentId: String, result: Result<MutableList<MediaBrowserCompat.MediaItem>>) {
        result.sendResult(null)
    }

    override fun onGetRoot(clientPackageName: String, clientUid: Int, rootHints: Bundle?): BrowserRoot? {
        return if (TextUtils.equals(clientPackageName, packageName)) {
            MediaBrowserServiceCompat.BrowserRoot(getString(R.string.app_name), null)
        } else null
    }
}