PlayerAndroid/app/src/main/java/code/name/monkey/retromusic/activities/base/AbsMusicServiceActivity.kt

package code.name.monkey.retromusic.activities.base

import android.Manifest
import android.content.*
import android.os.*
import code.name.monkey.retromusic.R
import code.name.monkey.retromusic.helper.MusicPlayerRemote
import code.name.monkey.retromusic.interfaces.MusicServiceEventListener
import code.name.monkey.retromusic.service.MusicService.*
import java.lang.ref.WeakReference
import java.util.*

abstract class AbsMusicServiceActivity : AbsBaseActivity(), MusicServiceEventListener {

	private val mMusicServiceEventListeners = ArrayList<MusicServiceEventListener>()

	private var serviceToken: MusicPlayerRemote.ServiceToken? = null
	private var musicStateReceiver: MusicStateReceiver? = null
	private var receiverRegistered: Boolean = false

	override fun onCreate(savedInstanceState: Bundle?) {
		super.onCreate(savedInstanceState)
		serviceToken = MusicPlayerRemote.bindToService(this, object : ServiceConnection {
			override fun onServiceConnected(name: ComponentName, service: IBinder) {
				this@AbsMusicServiceActivity.onServiceConnected()
			}

			override fun onServiceDisconnected(name: ComponentName) {
				this@AbsMusicServiceActivity.onServiceDisconnected()
			}
		})

		setPermissionDeniedMessage(getString(R.string.permission_external_storage_denied));
	}

	override fun onDestroy() {
		super.onDestroy()
		MusicPlayerRemote.unbindFromService(serviceToken)
		if (receiverRegistered) {
			unregisterReceiver(musicStateReceiver)
			receiverRegistered = false
		}
	}

	fun addMusicServiceEventListener(listener: MusicServiceEventListener?) {
		if (listener != null) {
			mMusicServiceEventListeners.add(listener)
		}
	}

	fun removeMusicServiceEventListener(listener: MusicServiceEventListener?) {
		if (listener != null) {
			mMusicServiceEventListeners.remove(listener)
		}
	}

	override fun onServiceConnected() {
		if (!receiverRegistered) {
			musicStateReceiver = MusicStateReceiver(this)

			val filter = IntentFilter()
			filter.addAction(PLAY_STATE_CHANGED)
			filter.addAction(SHUFFLE_MODE_CHANGED)
			filter.addAction(REPEAT_MODE_CHANGED)
			filter.addAction(META_CHANGED)
			filter.addAction(QUEUE_CHANGED)
			filter.addAction(MEDIA_STORE_CHANGED)
			filter.addAction(FAVORITE_STATE_CHANGED)

			registerReceiver(musicStateReceiver, filter)

			receiverRegistered = true
		}

		for (listener in mMusicServiceEventListeners) {
			listener.onServiceConnected()
		}
	}

	override fun onServiceDisconnected() {
		if (receiverRegistered) {
			unregisterReceiver(musicStateReceiver)
			receiverRegistered = false
		}

		for (listener in mMusicServiceEventListeners) {
			listener.onServiceDisconnected()
		}
	}

	override fun onPlayingMetaChanged() {
		for (listener in mMusicServiceEventListeners) {
			listener.onPlayingMetaChanged()
		}
	}

	override fun onQueueChanged() {
		for (listener in mMusicServiceEventListeners) {
			listener.onQueueChanged()
		}
	}

	override fun onPlayStateChanged() {
		for (listener in mMusicServiceEventListeners) {
			listener.onPlayStateChanged()
		}
	}

	override fun onMediaStoreChanged() {
		for (listener in mMusicServiceEventListeners) {
			listener.onMediaStoreChanged()
		}
	}

	override fun onRepeatModeChanged() {
		for (listener in mMusicServiceEventListeners) {
			listener.onRepeatModeChanged()
		}
	}

	override fun onShuffleModeChanged() {
		for (listener in mMusicServiceEventListeners) {
			listener.onShuffleModeChanged()
		}
	}

	override fun onHasPermissionsChanged(hasPermissions: Boolean) {
		super.onHasPermissionsChanged(hasPermissions)
		val intent = Intent(MEDIA_STORE_CHANGED)
		intent.putExtra(
				"from_permissions_changed",
				true
		) // just in case we need to know this at some point
		sendBroadcast(intent)
	}

	override fun getPermissionsToRequest(): Array<String> {
		return arrayOf(
				Manifest.permission.READ_EXTERNAL_STORAGE,
				Manifest.permission.WRITE_EXTERNAL_STORAGE
		)
	}

	private class MusicStateReceiver(activity: AbsMusicServiceActivity) : BroadcastReceiver() {

		private val reference: WeakReference<AbsMusicServiceActivity> = WeakReference(activity)

		override fun onReceive(context: Context, intent: Intent) {
			val action = intent.action
			val activity = reference.get()
			if (activity != null && action != null) {
				when (action) {
					FAVORITE_STATE_CHANGED, META_CHANGED -> activity.onPlayingMetaChanged()
					QUEUE_CHANGED                        -> activity.onQueueChanged()
					PLAY_STATE_CHANGED                   -> activity.onPlayStateChanged()
					REPEAT_MODE_CHANGED                  -> activity.onRepeatModeChanged()
					SHUFFLE_MODE_CHANGED                 -> activity.onShuffleModeChanged()
					MEDIA_STORE_CHANGED                  -> activity.onMediaStoreChanged()
				}
			}
		}
	}

	companion object {
		val TAG: String = AbsMusicServiceActivity::class.java.simpleName
	}
}