##音楽アプリを作りたい
音楽アプリを作りたいんだけど、MediaSessionとかMediaBrowserServiceとかメンドクサイ。秒で音楽を再生できるようにしたい。という人向けの記事です。自分のメモ的な面もあるので、不備があればコメントお願いします。質問されればいつでも答える所存。

##秒で基本的な機能を実装したい
###その1
MusicClassとMusicServiceという名でktファイルを作成。（マニフェストに登録とかはすっ飛ばします）

###その2
以下MusicClassのソースコード。これをコピーして貼り付け。

（自分のアプリからそのまま引っ張ってきているのでエラー多いかも。使わないなと思ったところは消して構わない。気にすることなかれ。）

class MusicClass(_context: Context) {

    private val context = _context
    private var service: MediaBrowserServiceCompat? = null

    private var musicMap = mutableMapOf<String, MusicData>()
    private val artworkMap = mutableMapOf<String, Bitmap?>()

    private var currentMusicData: MusicData?
        set(value) = settings.setString(SETTING_MUSIC_VALUE, "CurrentMusic", value?.musicId)
        get() = musicMap[settings.getString(SETTING_MUSIC_VALUE, "CurrentMusic", null)]

    private var currentMusicState: Int = 1
        set(value) {
            field = value
            callbacks.forEach { it.onUpdatePlayerState(value) }
        }

    private var queueIndex = -1
    private var queueItems = mutableListOf<MediaSessionCompat.QueueItem>()
    private var queueItemsOriginal = mutableListOf<MediaSessionCompat.QueueItem>()

    private var initMusicClassFlag = false
    private var initFirstConnection = false
    private var initMusicBrowserFlag = false
    private var tryConnectFlag = true

    private val audioManager: AudioManager by lazy { context.getSystemService(Context.AUDIO_SERVICE) as AudioManager }
    private val defaultArtwork: Bitmap by lazy { BitmapFactory.decodeResource(context.resources, R.drawable.album_art) }

    private lateinit var musicPlayer: MediaPlayer
    private lateinit var mediaSession: MediaSessionCompat
    private lateinit var mediaBrowser: MediaBrowserCompat
    private lateinit var mediaController: MediaControllerCompat

    private var listener: MusicListener? = null
    private var onCurrentMusicChangedListener: OnCurrentMusicChanged? = null
    private var callbacks = mutableListOf<MusicCallback>()

    private var reserveAction: (() -> Unit?)? = null

    private val mediaControllerCallback = object : MediaControllerCompat.Callback() {
        override fun onPlaybackStateChanged(state: PlaybackStateCompat?) {
            super.onPlaybackStateChanged(state)
            global.log(MUSIC_TAG, "MusicClass onPlaybackStateChanged")

            if (state != null) {
                callbacks.forEach { it.onUpdatePlayerState(state.state) }
            }
        }

        override fun onMetadataChanged(metadata: MediaMetadataCompat?) {
            super.onMetadataChanged(metadata)
            global.log(MUSIC_TAG, "MusicClass onMetadataChanged")

            if (metadata != null) {
                callbacks.forEach { it.onUpdateMusicMetadata(metadata) }
            }
        }
    }

    private val mediaSessionCallback = object : MediaSessionCompat.Callback() {
        override fun onPlayFromMediaId(mediaId: String?, extras: Bundle?) {
            currentMusicState = PlaybackStateCompat.STATE_PLAYING
            musicMap[mediaId]?.let {
                mediaSession.setMetadata(getMusicMetadata(mediaId))
                listener?.onPlayFromMusicData(it)
            }
        }

        override fun onPlay() {
            listener?.onPlay()
            currentMusicState = PlaybackStateCompat.STATE_PLAYING
        }

        override fun onPause() {
            listener?.onPause()
            currentMusicState = PlaybackStateCompat.STATE_PAUSED
        }

        override fun onStop() {
            listener?.onStop()
            currentMusicState = PlaybackStateCompat.STATE_STOPPED
        }

        override fun onSkipToNext() {
            if (queueItems.isNotEmpty()) {
                queueIndex = if (queueIndex + 1 >= queueItems.size) 0 else queueIndex + 1
                val musicData = musicMap[queueItems[queueIndex].description.mediaId] ?: return
                listener?.onSkipToNext(musicData, currentMusicState == PlaybackStateCompat.STATE_PLAYING)
            }
        }

        override fun onSkipToPrevious() {
            if (queueItems.isNotEmpty()) {
                if ((settings.currentMusicProgress.toInt() / 1000) > 4 && settings.pGetBoolean("pOneStepBack", true)) {
                    listener?.onSeekTo(0)
                } else {
                    queueIndex = if (queueIndex <= 0) queueItems.size - 1 else queueIndex - 1
                    val musicData = musicMap[queueItems[queueIndex].description.mediaId] ?: return
                    listener?.onSkipToPrevious(musicData, currentMusicState == PlaybackStateCompat.STATE_PLAYING)
                }
            }
        }

        override fun onSetShuffleMode(shuffleMode: Int) {
            if (shuffleMode == PlaybackStateCompat.SHUFFLE_MODE_NONE) {
                settings.shuffleMode = false
                queueItems = queueItemsOriginal.toMutableList()
            } else {
                settings.shuffleMode = true
                val currentQueueItem = queueItems[queueIndex]
                val tempQueueList = mutableListOf<MediaSessionCompat.QueueItem>()
                queueItems.forEach {
                    if (it.description.mediaId != currentMusicData?.musicId) {
                        tempQueueList.add(it)
                    }
                }
                queueItems.clear()
                queueItems.add(currentQueueItem)
                queueItems.addAll(tempQueueList.shuffled())
            }

            currentMusicData?.let { updateQueueIndex(it) }
        }

        override fun onSetRepeatMode(repeatMode: Int) {
            settings.repeatMode = repeatMode
        }

        override fun onSeekTo(pos: Long) {
            listener?.onSeekTo(pos)
        }

        override fun onMediaButtonEvent(mediaButtonEvent: Intent?): Boolean {
            val key: KeyEvent? = mediaButtonEvent!!.getParcelableExtra(Intent.EXTRA_KEY_EVENT)
            global.log(MUSIC_TAG, "MusicClass onMediaButtonEvent: ${key?.keyCode}")
            return when (key?.keyCode) {
                KeyEvent.KEYCODE_MEDIA_PLAY     -> {
                    currentMusicData?.let { this@MusicClass.onPlay(it, null) }
                    true
                }
                KeyEvent.KEYCODE_MEDIA_PAUSE    -> {
                    this@MusicClass.onPause()
                    true
                }
                KeyEvent.KEYCODE_MEDIA_NEXT     -> {
                    this@MusicClass.onSkipToNext()
                    true
                }
                KeyEvent.KEYCODE_MEDIA_PREVIOUS -> {
                    this@MusicClass.onSkipToPrevious()
                    true
                }
                else                            -> super.onMediaButtonEvent(mediaButtonEvent)
            }
        }
    }

    private val connectionCallback = object : MediaBrowserCompat.ConnectionCallback() {
        override fun onConnected() {
            global.log(MUSIC_TAG, "MusicClass onConnected: server connected.")

            mediaController = MediaControllerCompat(context, mediaBrowser.sessionToken)
            mediaController.registerCallback(mediaControllerCallback)

            initQueueItems()

            initMusicBrowserFlag = true
            initFirstConnection = true
            tryConnectFlag = true
            callbacks.forEach { it.onMusicPlayerConnected() }

            reserveAction?.let { it() }
            reserveAction = null
        }

        override fun onConnectionFailed() {
            tryConnectFlag = true
            global.log(MUSIC_TAG, "MusicClass onConnectionFailed: server connection failed.")
        }

        override fun onConnectionSuspended() {
            tryConnectFlag = true
            global.log(MUSIC_TAG, "MusicClass onConnectionSuspended: server connection suspended.")
        }
    }

    init {
        initialize()
    }

    fun connect() {
        if (!initMusicClassFlag) {
            initialize()
        }

        if (!initMusicBrowserFlag && tryConnectFlag) {
            global.log(MUSIC_TAG, "connecting...")
            tryConnectFlag = false
            mediaBrowser.connect()
        } else if (initMusicBrowserFlag) {
            global.log(MUSIC_TAG, "server already connected.")
            callbacks.forEach { it.onMusicPlayerConnected() }
        } else global.log(MUSIC_TAG, "Reject connection.")
    }

    fun disconnect() {
        mediaController.unregisterCallback(mediaControllerCallback)
        mediaBrowser.disconnect()

        callbacks.forEach { it.onMusicPlayerDisconnected() }

        initMusicBrowserFlag = false
        tryConnectFlag = true

        global.log(MUSIC_TAG, "disconnected.")
    }

    fun attach(service: MediaBrowserServiceCompat, musicPlayer: MediaPlayer) {
        global.log(MUSIC_TAG, "MusicClass attach: service attach.")
        this.service = service
        this.musicPlayer = musicPlayer

        music.mediaSession = MediaSessionCompat(service.baseContext, MusicService::class.java.simpleName).apply {
            setPlaybackState(
                PlaybackStateCompat.Builder()
                    .setActions(PlaybackStateCompat.ACTION_PLAY or PlaybackStateCompat.ACTION_PAUSE or PlaybackStateCompat.ACTION_SKIP_TO_NEXT or PlaybackStateCompat.ACTION_STOP)
                    .build()
            )
            setCallback(music.mediaSessionCallback)
            service.sessionToken = sessionToken
        }
    }

    fun detach() {
        global.log(MUSIC_TAG, "MusicClass detach: service detach.")
        this.service = null
    }

    private fun initialize() {
        global.log(MUSIC_TAG, "MusicClass initialize: Server is initializing...")
        getMusic()
        mediaBrowser = MediaBrowserCompat(context, ComponentName(context, MusicService::class.java), connectionCallback, null)
        initMusicClassFlag = true
    }
    
    fun clearData() {
        musicMap.clear()
        artworkMap.clear()
    }

    fun reserveMusicAction(action: () -> (Unit)) {
        if (!initMusicBrowserFlag) reserveAction = action
        else action()
    }

    fun setCurrentMusic(newData: MusicData) {
        global.log(MUSIC_TAG, "MusicClass setCurrentMusic: change current music data.")
        currentMusicData = newData
        onCurrentMusicChangedListener?.onCurrentMusicChanged(newData)
        callbacks.forEach { it.onUpdateCurrentMusicData(newData) }
    }
    
    fun isConnect() = initMusicBrowserFlag

    fun getCurrentMusic() = currentMusicData

    fun getCurrentMusicState() = currentMusicState

    fun getMusicMap() = musicMap

    fun getQueueList() = queueItems

    fun getQueueIndex() = queueIndex

    fun getArtworkFromMap(albumName: String?) = artworkMap[albumName]

    fun onPlay(musicData: MusicData, queueList: List<MusicData>?, onShuffle: Boolean = true, repeat: Boolean = false) {
        if (!isConnect()) {
            reserveMusicAction { onPlay(musicData, queueList, onShuffle, repeat) }
            connect()
        } else if (currentMusicData?.musicId != musicData.musicId || currentMusicState == 1 || currentMusicState == PlaybackStateCompat.STATE_STOPPED || repeat) {
            if (queueList != null) setQueueItemList(musicData, queueList, onShuffle)
            saveQueueItem()
            mediaController.transportControls.playFromMediaId(musicData.musicId, null)
        } else {
            saveQueueItem()
            mediaController.transportControls.play()
        }
    }

    fun onPause() {
        if (!isConnect()) {
            reserveMusicAction { onPause() }
            connect()
        } else mediaController.transportControls.pause()
    }

    fun onStop() {
        mediaController.transportControls.stop()
    }

    fun onSkipToNext() {
        if (!isConnect()) {
            reserveMusicAction { onSkipToNext() }
            connect()
        } else mediaController.transportControls.skipToNext()
    }

    fun onSkipToPrevious() {
        if (!isConnect()) {
            reserveMusicAction { onSkipToPrevious() }
            connect()
        } else mediaController.transportControls.skipToPrevious()
    }

    fun onShuffle(mode: Int) {
        if (!isConnect()) {
            reserveMusicAction { onShuffle(mode) }
            connect()
        } else mediaController.transportControls.setShuffleMode(mode)
    }

    fun onRepeat(mode: Int) {
        if (!isConnect()) {
            reserveMusicAction { onRepeat(mode) }
            connect()
        } else mediaController.transportControls.setRepeatMode(mode)
    }

    fun onSeek(progress: Long) {
        if (!isConnect()) {
            reserveMusicAction { onSeek(progress) }
            connect()
        } else mediaController.transportControls.seekTo(progress)
    }

    fun addCallback(callback: MusicCallback) {
        this.callbacks.add(callback)
    }

    fun removeCallback(callback: MusicCallback) {
        this.callbacks.remove(callback)
    }

    fun setListener(listener: MusicListener) {
        this.listener = listener
    }

    fun removeListener() {
        this.listener = null
    }

    fun setCurrentMusicChangeListener(listener: OnCurrentMusicChanged) {
        this.onCurrentMusicChangedListener = listener
    }

    fun removeCurrentMusicChangeListener() {
        this.onCurrentMusicChangedListener = null
    }

    fun setVolume(volumeLeft: Float, volumeRight: Float) {
        callbacks.forEach { it.onUpdatePlayerVolume(volumeLeft, volumeRight) }
    }

    fun resetVolume() {
        val baseAudioVolume = settings.pGetInt("qBaseVolume", 5).toFloat() / 10f
        callbacks.forEach { it.onUpdatePlayerVolume(baseAudioVolume, baseAudioVolume) }
    }

    fun setBass(strength: Int) {
        callbacks.forEach { it.onUpdatePlayerBass((strength * 50).toShort()) }
    }

    fun resetBass() {
        callbacks.forEach { it.onUpdatePlayerBass(0) }
    }

    fun setEqualizer(hzMap: Pair<Int, Int>) {
        callbacks.forEach { it.onUpdatePlayerEqualizer(hzMap) }
    }

    fun resetEqualizer() {
        global.equalizerBandMap.forEach { band ->
            callbacks.forEach { it.onUpdatePlayerEqualizer(Pair(band.key, 0)) }
        }
    }

    fun setReverbEffect(effect: Short) {
        callbacks.forEach { it.onUpdatePlayerReverbEffect(effect) }
    }

    fun progressUpdate(progress: Long) {
        settings.currentMusicProgress = progress
        callbacks.forEach { it.onUpdateMusicProgress(progress) }
    }

    fun setMasterMute(isMute: Boolean): Boolean {
        val audioMethods = audioManager.javaClass.declaredMethods
        for(method in audioMethods){
            if(method.name == "setMasterMute"){
                try {
                    method.invoke(audioManager, isMute, 0)
                    Log.d(MUSIC_TAG, "set master mute success. STATUS: $isMute")
                    return true
                }
                catch (e: Exception){
                    global.stackTrace(e.toString())
                }
            }
        }
        Log.d(MUSIC_TAG, "set master mute failed. STATUS: $isMute")
        return false
    }

    fun isMasterMute(): Boolean {
        val audioMethods = audioManager.javaClass.declaredMethods
        for(method in audioMethods){
            if(method.name == "isMasterMute"){
                try {
                    val status = method.invoke(audioManager) as Boolean
                    Log.d(MUSIC_TAG, "get master mute success. STATUS: $status")
                    return status
                }
                catch (e: Exception){
                    global.stackTrace(e.toString())
                }
            }
        }
        Log.d(MUSIC_TAG, "set master mute failed.")
        return false
    }

    fun getMusic() {
        var cursor: Cursor? = null
        val tempMap = mutableMapOf<String, MusicData>()

        try {
            cursor = context.contentResolver.query(MediaStore.Audio.Media.EXTERNAL_CONTENT_URI, null, null, null, "title")

            if (cursor != null && cursor.moveToFirst()) {
                val artistColumn: Int = cursor.getColumnIndex(MediaStore.Audio.Media.ARTIST)
                val titleColumn: Int = cursor.getColumnIndex(MediaStore.Audio.Media.TITLE)
                val albumColumn: Int = cursor.getColumnIndex(MediaStore.Audio.Media.ALBUM)
                val albumIdColumn: Int = cursor.getColumnIndex(MediaStore.Audio.Media.ALBUM_ID)
                val durationColumn: Int = cursor.getColumnIndex(MediaStore.Audio.Media.DURATION)
                val idColumn: Int = cursor.getColumnIndex(MediaStore.Audio.Media._ID)
                val idTruck: Int = cursor.getColumnIndex(MediaStore.Audio.Media.TRACK)
                val pathColumn: Int = cursor.getColumnIndex(MediaStore.Audio.Media.DATA)
                val yearColumn = cursor.getColumnIndex(MediaStore.Audio.Media.YEAR)

                do {
                    if (cursor.getInt(durationColumn) > 3000) {
                        val contentUri = Uri.withAppendedPath(MediaStore.Audio.Media.EXTERNAL_CONTENT_URI, cursor.getInt(idColumn).toString())
                        tempMap[cursor.getInt(idColumn).toString()] = MusicData(
                            cursor.getInt(idColumn).toString(),
                            cursor.getString(pathColumn),
                            null,
                            cursor.getString(titleColumn),
                            cursor.getString(artistColumn),
                            cursor.getString(albumColumn),
                            cursor.getLong(albumIdColumn),
                            cursor.getInt(durationColumn),
                            cursor.getString(idTruck),
                            cursor.getInt(yearColumn).toString(),
                            null,
                            contentUri
                        )
                    }
                } while (cursor.moveToNext())
            }
        } catch (e: Exception) {
            e.printStackTrace()
        }

        cursor?.close()
        musicMap = tempMap
    }

    fun getMusicMediaItem(_musicData: MusicData?, musicId: String? = null): MediaBrowserCompat.MediaItem {
        val musicData = _musicData ?: musicMap[musicId] ?: throw IllegalStateException("Cannot found music data.")

        val metadata = MediaMetadataCompat.Builder().putString(MediaMetadataCompat.METADATA_KEY_MEDIA_ID, musicData.musicId)
            .putString(MediaMetadataCompat.METADATA_KEY_TITLE, musicData.title).putString(MediaMetadataCompat.METADATA_KEY_ARTIST, musicData.artist)
            .putString(MediaMetadataCompat.METADATA_KEY_ALBUM, musicData.album)
            .putLong(MediaMetadataCompat.METADATA_KEY_DURATION, musicData.duration.toLong())
            .putBitmap(MediaMetadataCompat.METADATA_KEY_ALBUM_ART, musicData.albumArt).build()
        return MediaBrowserCompat.MediaItem(metadata.description, MediaBrowserCompat.MediaItem.FLAG_PLAYABLE)
    }

    fun getMusicMetadata(id: String?): MediaMetadataCompat? {
        id ?: return null
        val musicData = musicMap[id] ?: return null
        return MediaMetadataCompat.Builder().putString(MediaMetadataCompat.METADATA_KEY_MEDIA_ID, musicData.musicId)
            .putString(MediaMetadataCompat.METADATA_KEY_TITLE, musicData.title).putString(MediaMetadataCompat.METADATA_KEY_ARTIST, musicData.artist)
            .putString(MediaMetadataCompat.METADATA_KEY_ALBUM, musicData.album)
            .putLong(MediaMetadataCompat.METADATA_KEY_DURATION, musicData.duration.toLong())
            .putBitmap(MediaMetadataCompat.METADATA_KEY_ALBUM_ART, musicData.albumArt).build()
    }

    fun getMusicMetadataList(): MutableList<MediaBrowserCompat.MediaItem> {
        var index = 0
        val metadataList = mutableListOf<MediaBrowserCompat.MediaItem>()
        for ((_, musicData) in musicMap) {
            val metadata = MediaMetadataCompat.Builder().putString(MediaMetadataCompat.METADATA_KEY_MEDIA_ID, musicData.musicId)
                .putString(MediaMetadataCompat.METADATA_KEY_TITLE, musicData.title)
                .putString(MediaMetadataCompat.METADATA_KEY_ARTIST, musicData.artist)
                .putString(MediaMetadataCompat.METADATA_KEY_ALBUM, musicData.album)
                .putLong(MediaMetadataCompat.METADATA_KEY_DURATION, musicData.duration.toLong())
                .putBitmap(MediaMetadataCompat.METADATA_KEY_ALBUM_ART, musicData.albumArt).build()

            metadataList.add(MediaBrowserCompat.MediaItem(metadata.description, MediaBrowserCompat.MediaItem.FLAG_PLAYABLE))
            index++
        }
        return metadataList
    }

    fun getArtwork(musicData: MusicData?, _albumName: String? = null, _albumId: Long? = null): Bitmap {
        val musicId = musicData?.musicId
        val albumName = musicData?.album ?: _albumName
        val albumId = musicData?.albumId ?: _albumId

        if (albumName == null || albumId == null) return defaultArtwork

        try {
            val albumArtFile = File(context.filesDir, "${musicData?.albumId}.bmp")
            val albumArtUri = Uri.parse("content://media/external/audio/albumart")
            val albumUri = ContentUris.withAppendedId(albumArtUri, albumId)

            if (albumArtFile.exists()) {
                BitmapFactory.decodeFile(albumArtFile.absolutePath)?.let {
                    artworkMap[albumName] = it
                    musicMap[musicId]?.albumArt = it
                    return it
                }
            }

            val inputStream = context.contentResolver.openInputStream(albumUri)
            BitmapFactory.decodeStream(inputStream)?.let {
                artworkMap[albumName] = it
                musicMap[musicId]?.albumArt = it
                return it
            }
        } catch (e: FileNotFoundException) {
        } catch (e: IOException) {
        } catch (e: Exception) {
            e.printStackTrace()
        }

        if (musicMap[musicId]?.albumArt != null) return musicMap[musicId]?.albumArt!!
        if (artworkMap[albumName] != null) return artworkMap[albumName]!!

        val char1 = if (albumName.isNotEmpty()) albumName[0].toString().toUpperCase(Locale.ROOT) else null
        val char2 = if (albumName.length > 1) albumName[1].toString().toUpperCase(Locale.ROOT) else null
        val resolution = settings.pGetString("pResolution", "400")?.toInt() ?: 400

        val defaultArtworkView = when (resolution) {
            800  -> View.inflate(context, R.layout.view_default_artwork_0, null)
            600  -> View.inflate(context, R.layout.view_default_artwork_1, null)
            400  -> View.inflate(context, R.layout.view_default_artwork_2, null)
            300  -> View.inflate(context, R.layout.view_default_artwork_3, null)
            200  -> View.inflate(context, R.layout.view_default_artwork_4, null)
            else -> View.inflate(context, R.layout.view_default_artwork_2, null)
        }

        if (char1 != null && char2 != null) {
            defaultArtworkView.findViewById<TextView>(R.id.VDA_Char1).text = char1
            defaultArtworkView.findViewById<TextView>(R.id.VDA_Char2).text = char2
        } else if (char1 != null && char2 == null) {
            defaultArtworkView.findViewById<TextView>(R.id.VDA_Char1).text = char1
            defaultArtworkView.findViewById<TextView>(R.id.VDA_Char2).text = char1
        } else if (char1 == null && char2 == null) {
            global.log(TAG, "char1 & char2 name is null so return default artwork")
            return defaultArtwork
        }

        defaultArtworkView.findViewById<ConstraintLayout>(R.id.VDA_Background).background = when (global.getStringColorCode(albumName)) {
            0    -> ColorDrawable(ContextCompat.getColor(context, R.color.colorDefaultArtwork0))
            1    -> ColorDrawable(ContextCompat.getColor(context, R.color.colorDefaultArtwork1))
            2    -> ColorDrawable(ContextCompat.getColor(context, R.color.colorDefaultArtwork2))
            3    -> ColorDrawable(ContextCompat.getColor(context, R.color.colorDefaultArtwork3))
            4    -> ColorDrawable(ContextCompat.getColor(context, R.color.colorDefaultArtwork4))
            else -> ColorDrawable(ContextCompat.getColor(context, R.color.colorDefaultArtwork0))
        }

        if (defaultArtworkView.measuredHeight <= 0) {
            defaultArtworkView.measure(
                View.MeasureSpec.makeMeasureSpec(resolution, View.MeasureSpec.EXACTLY),
                View.MeasureSpec.makeMeasureSpec(resolution, View.MeasureSpec.EXACTLY)
            )

            val defBitmap = Bitmap.createBitmap(defaultArtworkView.measuredWidth, defaultArtworkView.measuredHeight, Bitmap.Config.ARGB_8888)
            val canvas = Canvas(defBitmap)

            defaultArtworkView.layout(0, 0, defaultArtworkView.measuredWidth, defaultArtworkView.measuredHeight)
            defaultArtworkView.draw(canvas)

            val scaleX = (0.7f * defBitmap.width).toInt()
            val scaleY = (0.7f * defBitmap.height).toInt()
            val startX = (defBitmap.width - scaleX) / 2
            val startY = (defBitmap.height - scaleY) / 2

            val resultBitmap = Bitmap.createBitmap(defBitmap, startX, startY, scaleX, scaleY, null, true)

            artworkMap[albumName] = resultBitmap
            musicMap[musicId]?.albumArt = resultBitmap

            return resultBitmap
        }

        return defaultArtwork
    }

    fun updateQueueIndex(musicData: MusicData?) {
        for ((i, data) in queueItems.withIndex()) {
            if (data.description.mediaId == musicData?.musicId) {
                queueIndex = i
                break
            }
        }
    }

    fun initQueueItems() {
        val arrays = getQueueItem()

        queueItems = arrays.first
        queueItemsOriginal = arrays.second

        if (queueItems.isEmpty() || queueItemsOriginal.isEmpty()) {
            queueItems.clear()
            for ((i, item) in getMusicMetadataList().withIndex()) {
                queueItems.add(MediaSessionCompat.QueueItem(item.description, i.toLong()))
            }
            queueItemsOriginal.addAll(queueItems)
        }
    }

    private fun saveQueueItem() {
        thread {
            val dataList = mutableListOf<String>()
            val dataList2 = mutableListOf<String>()
            val queueItems = queueItems.toList()
            val queueItemsOriginal = queueItemsOriginal.toList()

            queueItems.forEach { dataList.add(it.description.mediaId ?: "") }
            queueItemsOriginal.forEach { dataList2.add(it.description.mediaId ?: "") }

            val json = Gson().toJson(dataList)
            val json2 = Gson().toJson(dataList2)

            settings.setString(SETTING_MUSIC_VALUE, "queueItems", json)
            settings.setString(SETTING_MUSIC_VALUE, "queueItemsOriginal", json2)
        }
    }

    fun addQueueItemsList(musicList: List<MusicData>) {
        val addList = mutableListOf<MediaSessionCompat.QueueItem>()

        for ((addCount, data) in musicList.withIndex()) {
            addList.add(MediaSessionCompat.QueueItem(getMusicMediaItem(data).description, (queueItems.size + addCount).toLong()))
        }

        queueItems.addAll(if (settings.shuffleMode) addList.shuffled() else addList)
        queueItemsOriginal.addAll(addList)
    }

    fun setQueueItemList(newMusicData: MusicData?, musicList: List<MusicData>, onShuffle: Boolean = true) {
        val tempList = mutableListOf<MediaSessionCompat.QueueItem>()

        for ((i, musicData) in musicList.withIndex()) {
            tempList.add(MediaSessionCompat.QueueItem(getMusicMediaItem(musicData).description, i.toLong()))
        }

        queueItems.clear()
        queueItems.addAll(tempList)
        queueItemsOriginal.clear()
        queueItemsOriginal.addAll(queueItems)

        updateQueueIndex(newMusicData)

        if (settings.shuffleMode && onShuffle) {
            onShuffle(PlaybackStateCompat.SHUFFLE_MODE_ALL)
        }
    }

    private fun getQueueItem(): Pair<MutableList<MediaSessionCompat.QueueItem>, MutableList<MediaSessionCompat.QueueItem>> {
        val json = settings.getString(SETTING_MUSIC_VALUE, "queueItems", null) ?: return Pair(mutableListOf(), mutableListOf())
        val json2 = settings.getString(SETTING_MUSIC_VALUE, "queueItemsOriginal", null) ?: return Pair(mutableListOf(), mutableListOf())
        val arrayList: List<String> = Gson().fromJson(json, ArrayList<String>().javaClass) ?: listOf()
        val arrayList2: List<String> = Gson().fromJson(json2, ArrayList<String>().javaClass) ?: listOf()
        val items = mutableListOf<MediaSessionCompat.QueueItem>()
        val items2 = mutableListOf<MediaSessionCompat.QueueItem>()
        val item3 = mutableListOf<MusicData?>()

        for ((i, id) in arrayList.withIndex()) {
            val description = getMusicMediaItem(null, id).description
            items.add(MediaSessionCompat.QueueItem(description, i.toLong()))
            item3.add(musicMap[id])
        }

        for ((i, id) in arrayList2.withIndex()) {
            val description = getMusicMediaItem(null, id).description
            items2.add(MediaSessionCompat.QueueItem(description, i.toLong()))
        }

        return Pair(items, items2)
    }

    fun setMusicMetadata(
        musicData: MusicData,
        newTitle: String,
        newArtist: String,
        newAlbum: String,
        newTrack: String,
        newYear: String,
        newAlbumId: String,
        newAlbumArtUri: Uri?
    ): Boolean {

        musicData.uri ?: return false

        val fileName = global.getFileName(musicData.path) ?: return false
        val artworkFileName = "${musicData.albumId}.bmp"
        val inputStream = context.contentResolver.openInputStream(musicData.uri!!) ?: return false
        val inputStream2 = newAlbumArtUri?.let { context.contentResolver.openInputStream(it) }

        context.openFileOutput(fileName, Context.MODE_PRIVATE).use { outputStream ->
            inputStream.use { it.copyTo(outputStream) }
        }

        context.openFileOutput(artworkFileName, Context.MODE_PRIVATE).use { outputStream ->
            inputStream2?.use { it.copyTo(outputStream) }
        }

        val albumArtUri = Uri.parse("content://media/external/audio/albumart")
        val albumUri = ContentUris.withAppendedId(albumArtUri, musicData.albumId)

        context.contentResolver.delete(albumUri, null, null)

        val artwork = ArtworkFactory.createArtworkFromFile(File(context.filesDir, artworkFileName))
        val audioFile = AudioFileIO.read(File(context.filesDir, fileName))

        audioFile.tag.apply {
            setField(FieldKey.TITLE, newTitle)
            setField(FieldKey.ARTIST, newArtist)
            setField(FieldKey.ALBUM, newAlbum)
            setField(FieldKey.TRACK, newTrack)
            setField(FieldKey.YEAR, newYear)

            newAlbumArtUri?.let { setField(artwork) }
        }

        audioFile.commit()

        val localFile = File(context.filesDir, fileName)

        if (localFile.exists()) {
            context.contentResolver.openOutputStream(musicData.uri!!)?.use { outputStream ->
                FileInputStream(localFile).use { it.copyTo(outputStream) }
            }
        }

        localFile.delete()

        val contentValues = ContentValues().apply {
            put(MediaStore.Audio.Media.ALBUM_ID, newAlbumId.toInt())
        }

        context.contentResolver.update(musicData.uri!!, contentValues, null, null)

        clearData()
        getMusic()

        return true
    }

    fun createMusicNotify(notificationManager: NotificationManager, notifyId: Int): Notification? {
        val musicData = currentMusicData ?: return null

        val notifyTitle = musicData.title
        val notifyText = musicData.artist
        val channelName = context.getString(R.string.mediaNotifyChannel)
        val channelDescription = context.getString(R.string.mediaNotifyDescription)

        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O && notificationManager.getNotificationChannel(notifyId.toString()) == null) {
            val channel = NotificationChannel(notifyId.toString(), channelName, NotificationManager.IMPORTANCE_LOW).apply {
                description = channelDescription
            }

            notificationManager.createNotificationChannel(channel)
        }

        val stackBuilder = TaskStackBuilder.create(context).addNextIntent(Intent(context, MusicActivity::class.java))
        val pendingIntent = stackBuilder.getPendingIntent(0, PendingIntent.FLAG_UPDATE_CURRENT)

        val notificationBuilder = NotificationCompat.Builder(context, notifyId.toString()).apply {
            setStyle(
                androidx.media.app.NotificationCompat.MediaStyle().setMediaSession(mediaSession.sessionToken).setShowActionsInCompactView(0, 1, 2)
                    .setShowCancelButton(true)
                    .setCancelButtonIntent(MediaButtonReceiver.buildMediaButtonPendingIntent(context, PlaybackStateCompat.ACTION_STOP))
            )
            setSmallIcon(R.drawable.ic_music)
            setLargeIcon(getArtwork(musicData))
            setContentTitle(notifyTitle)
            setContentText(notifyText)
            setAutoCancel(false)
            setDeleteIntent(MediaButtonReceiver.buildMediaButtonPendingIntent(context, PlaybackStateCompat.ACTION_STOP))
            setVisibility(NotificationCompat.VISIBILITY_PUBLIC)
            setContentIntent(pendingIntent)
        }

        var action = NotificationCompat.Action(
            R.drawable.notification_backward_48,
            context.getString(R.string.SkipToPrevious),
            MediaButtonReceiver.buildMediaButtonPendingIntent(context, PlaybackStateCompat.ACTION_SKIP_TO_PREVIOUS)
        )

        notificationBuilder.addAction(action)

        action = if (currentMusicState == PlaybackStateCompat.STATE_PLAYING) {
            NotificationCompat.Action(
                R.drawable.notification_pause_48,
                context.getString(R.string.pause),
                MediaButtonReceiver.buildMediaButtonPendingIntent(context, PlaybackStateCompat.ACTION_PAUSE)
            )
        } else {
            NotificationCompat.Action(
                R.drawable.notification_play_48,
                context.getString(R.string.play),
                MediaButtonReceiver.buildMediaButtonPendingIntent(context, PlaybackStateCompat.ACTION_PLAY)
            )
        }

        notificationBuilder.addAction(action)

        action = NotificationCompat.Action(
            R.drawable.notification_forward_48,
            context.getString(R.string.SkipToNext),
            MediaButtonReceiver.buildMediaButtonPendingIntent(context, PlaybackStateCompat.ACTION_SKIP_TO_NEXT)
        )

        notificationBuilder.addAction(action)

        return notificationBuilder.build()
    }

    abstract class MusicCallback {
        open fun onMusicPlayerConnected() {}
        open fun onMusicPlayerDisconnected() {}
        open fun onUpdatePlayerState(state: Int) {}
        open fun onUpdatePlayerVolume(volumeLeft: Float, volumeRight: Float) {}
        open fun onUpdatePlayerBass(strength: Short) {}
        open fun onUpdatePlayerEqualizer(hzPair: Pair<Int, Int>) {}
        open fun onUpdatePlayerReverbEffect(effect: Short) {}
        open fun onUpdateCurrentMusicData(newData: MusicData) {}
        open fun onUpdateMusicMetadata(metadata: MediaMetadataCompat) {}
        open fun onUpdateMusicProgress(progress: Long) {}
    }

    interface MusicListener {
        fun onSetMusicData(musicData: MusicData)
        fun onPlayFromMusicData(musicData: MusicData, focedFirst: Boolean = false)
        fun onPlay()
        fun onPause()
        fun onStop()
        fun onSkipToNext(musicData: MusicData, isPlay: Boolean)
        fun onSkipToPrevious(musicData: MusicData, isPlay: Boolean)
        fun onSeekTo(progress: Long)
    }

    interface OnCurrentMusicChanged {
        fun onCurrentMusicChanged(newData: MusicData)
    }

    companion object {
        const val MUSIC_TAG = "<MUSIC>"
    }
}

data class MusicData(
    val musicId: String,
    val path: String,
    var albumArt: Bitmap?,
    val title: String,
    val artist: String,
    val album: String,
    val albumId: Long,
    val duration: Int,
    val truck: String?,
    val year: String,
    var favorite: Boolean?,
    var uri: Uri? = null,
    var queueId: Int = -1
)

###その4
MusicClassを超省略して、主要な関数のみ説明。

#####MusicClassの基本
インスタンスはアプリ内で一つだけ作成。トップレベルで保持することを推奨。(今回はトップレベルで"music"という名でインスタンスを作成している)

ApplicationクラスのonCreateなどで作成することを推奨。

#####initialize
MusicClassを初期化＆音楽ライブラリの準備＆MediaBrowserService接続準備

#####connect, disconnect
MediaBrowserと接続or切断するための関数。

#####attach. detach
MediaBrowserからクラスに接続or切断するための関数。

上記にも書いたが、基本は全ての音楽関連処理をこのクラスで行う。実際にMediaPlayerなどを使って音楽を再生するのはMusieServiceの役目。

#####onPlay, onPause, onStop, etc...
音楽を再生、中断、中止など。

#####getMusic
contentProviderから音楽情報を引っ張ってくる。MediaBrowserに頼らない私流のやり方。外部から安易に呼び出さないこと推奨。

#####getArtwork
artworkを取得。今気づいたけど、オリジナルの処理が入っているからエラー出るかも。ごめん。ここは重要ではないので消しても構わない。

#####MusicCallback
MusicClassの状態変化によって呼び出される。機能は関数名そのまま。

#####MusiscListener
音楽の再生状態の変化によって呼び出される。MediaPlayerなどの音楽を実際に再生するクラス以外overrideしてはいけない。

#####reserveMusicAction
MediaBrowserとまだ接続してないけど、接続したらやってね！という動作を登録しておきたいときに使用する。

#####setCurrentMusic
currentMusicを更新したいときに呼ぶ。MediaPlayerなどの音楽を実際に再生するクラス以外overrideしてはいけない。

###その5
以下MusicServiceのソースコード。これをコピーして貼り付け。

（自分のアプリからそのまま引っ張ってきているのでエラー多いかも。使わないなと思ったところは消して構わない。気にすることなかれ。）


class MusicService : MediaBrowserServiceCompat() {

    private lateinit var audioFocusRequest: AudioFocusRequestCompat
    private lateinit var bassBoost: BassBoost
    private lateinit var equalizer: Equalizer
    private lateinit var presetReverb: PresetReverb

    private var musicPlayer = MediaPlayer()
    private val audioManager by lazy { getSystemService(Context.AUDIO_SERVICE) as AudioManager }
    private val audioNoisyFilter = IntentFilter(AudioManager.ACTION_AUDIO_BECOMING_NOISY)

    private var bootFlag = true

    private val audioNoisyReceiver = object : BroadcastReceiver() {
        override fun onReceive(context: Context, intent: Intent) {
            music.onPause()
        }
    }

    private val completionListener = MediaPlayer.OnCompletionListener {
        global.log(MUSIC_TAG, "MusicService onCompletionListener: onComplete")

        when (settings.repeatMode) {
            PlaybackStateCompat.REPEAT_MODE_ALL  -> {
                music.onSkipToNext()
            }
            PlaybackStateCompat.REPEAT_MODE_ONE  -> {
                music.onSeek(0)
                music.getCurrentMusic()?.let { it1 -> music.onPlay(it1, null, onShuffle = true) }
            }
            PlaybackStateCompat.REPEAT_MODE_NONE -> {
                if (music.getQueueIndex() + 1 >= music.getQueueList().size) music.onPause()
                music.onSkipToNext()
            }
            else                                 -> music.onSkipToNext()
        }
    }

    private val playerErrorListener = MediaPlayer.OnErrorListener { _, _, _ ->
        Log.d(MUSIC_TAG, "service: Invalid state of music player.")
        resetMusicPlayer()
        return@OnErrorListener true
    }

    private val audioFocusChangeListener = AudioManager.OnAudioFocusChangeListener { audioFocus ->
        when (audioFocus) {
            AudioManager.AUDIOFOCUS_GAIN           -> {
                global.log(MUSIC_TAG, "MusicService : AudioFocus gain.")
                music.getCurrentMusic()?.let { music.onPlay(it, null) }
            }
            AudioManager.AUDIOFOCUS_LOSS           -> {
                global.log(MUSIC_TAG, "MusicService : AudioFocus lost.")
                music.onPause()
            }
            AudioManager.AUDIOFOCUS_LOSS_TRANSIENT -> {
                global.log(MUSIC_TAG, "MusicService : AudioFocus loss transient.")
                music.onPause()
            }
        }
    }

    private val musicCallback = object : MusicClass.MusicCallback() {
        override fun onMusicPlayerConnected() {
            prepare()
        }

        override fun onUpdatePlayerState(state: Int) {
            musicNotify()

            if(Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) music.getCurrentVolumeDb()
        }

        override fun onUpdatePlayerVolume(volumeLeft: Float, volumeRight: Float) {
            musicPlayer.setVolume(volumeLeft, volumeRight)
            Log.d(MUSIC_TAG, "set music volume ($volumeLeft, $volumeRight).")
        }

        override fun onUpdatePlayerBass(strength: Short) {
            try {
                bassBoost.setStrength(strength)
                Log.d(MUSIC_TAG, "bass boost. STG: $strength")
            } catch (e: Exception) {
                global.stackTrace(e.toString())
            }
        }

        override fun onUpdatePlayerEqualizer(hzPair: Pair<Int, Int>) {
            try {
                equalizer.setBandLevel(hzPair.first.toShort(), hzPair.second.toShort())
                Log.d(MUSIC_TAG, "set equalizer. $hzPair")
            } catch (e: Exception) {
                global.stackTrace(e.toString())
            }
        }

        override fun onUpdatePlayerReverbEffect(effect: Short) {
            try {
                presetReverb.preset = effect
                Log.d(MUSIC_TAG, "set reverb effect. $effect")
            } catch (e: Exception) {
                global.stackTrace(e.toString())
            }
        }
    }

    private val musicListener = object : MusicClass.MusicListener {
        override fun onSetMusicData(musicData: MusicData) {
            global.log(MUSIC_TAG, "MusicService onSetMusicData: Set new music data.")
            musicPlayer.reset()
            musicPlayer.setDataSource(musicData.path)
            musicPlayer.prepare()
            global.addMusicHistory(musicData.musicId)

            musicNotify()
        }

        override fun onPlayFromMusicData(musicData: MusicData, focedFirst: Boolean) {
            onSetMusicData(musicData)
            if (musicData.musicId == music.getCurrentMusic()?.musicId && settings.pGetBoolean("pMiddlePlay", true) && !focedFirst) {
                onSeekTo(settings.currentMusicProgress)
            }
            music.setCurrentMusic(musicData)
            music.onPlay(musicData, null)
        }

        override fun onPlay() {
            if (gainAudioFocus()) {
                val baseAudioVolume = settings.pGetInt("qBaseVolume", 5).toFloat() / 10f
                val volume = if (settings.pGetBoolean("qDynamicNormalizer", false)) {
                    music.dynamicNormalize(music.getCurrentMusic()) ?: baseAudioVolume
                } else baseAudioVolume

                Log.d(MUSIC_TAG, "set music volume $volume.")

                registerReceiver(audioNoisyReceiver, audioNoisyFilter)
                music.setVolume(volume, volume)

                musicPlayer.setOnCompletionListener(completionListener)
                musicPlayer.start()
                global.setTimer()
            }
        }

        override fun onPause() {
            musicPlayer.pause()
            releaseAudioFocus()
            removeReceiver()
            global.cancelTimer()
        }

        override fun onStop() {
            musicPlayer.stop()
            releaseAudioFocus()
            removeReceiver()
            global.cancelTimer()

            disorganize()
        }

        override fun onSkipToNext(musicData: MusicData, isPlay: Boolean) {
            onSetMusicData(musicData)
            if (isPlay) onPlayFromMusicData(musicData, true)
            else {
                music.setCurrentMusic(musicData)
                music.progressUpdate(0)
            }
        }

        override fun onSkipToPrevious(musicData: MusicData, isPlay: Boolean) {
            onSetMusicData(musicData)
            if (isPlay) onPlayFromMusicData(musicData, true)
            else {
                music.setCurrentMusic(musicData)
                music.progressUpdate(0)
            }
        }

        override fun onSeekTo(progress: Long) {
            musicPlayer.seekTo(progress.toInt())
            music.progressUpdate(progress)
        }

        private fun removeReceiver() {
            try {
                unregisterReceiver(audioNoisyReceiver)
            } catch (e: IllegalArgumentException) {
            } catch (e: Exception) {
                e.printStackTrace()
            }
        }
    }

    private val progressUpdate = object : Runnable {
        override fun run() {
            if (musicPlayer.isPlaying) music.progressUpdate(musicPlayer.currentPosition.toLong())
            global.handler.postDelayed(this, 500)
        }
    }

    override fun onGetRoot(clientPackageName: String, clientUid: Int, rootHints: Bundle?): BrowserRoot? {
        global.log(MUSIC_TAG, "MusicService onGetRoot")
        return BrowserRoot("All-OK", null)
    }

    override fun onLoadChildren(parentId: String, result: Result<MutableList<MediaBrowserCompat.MediaItem>>) {
        global.log(MUSIC_TAG, "MusicService onLoadChildren")
        result.sendResult(music.getMusicMetadataList())
    }

    override fun onCreate() {
        super.onCreate()

        music.addCallback(musicCallback)
        music.setListener(musicListener)
        music.attach(this, musicPlayer)

        global.handler.postDelayed(progressUpdate, 500)

        global.log(MUSIC_TAG, "MusicService onCreate: connected to Server.")
    }

    override fun onDestroy() {
        super.onDestroy()
        global.log(MUSIC_TAG, "MusicService onDestroy: disconnected from server.")
    }

    private fun prepare() {
        global.log(MUSIC_TAG, "MusicService prepare: preparing...")

        resetMusicPlayer()
        initAudioEffect()

        audioFocusRequest = AudioFocusRequestCompat.Builder(AudioManagerCompat.AUDIOFOCUS_GAIN).setAudioAttributes(
                AudioAttributesCompat.Builder().setUsage(AudioAttributesCompat.USAGE_MEDIA).setContentType(AudioAttributesCompat.CONTENT_TYPE_MUSIC)
                    .build()
            ).setOnAudioFocusChangeListener(audioFocusChangeListener).build()

        music.getCurrentMusic()?.let { musicListener.onSetMusicData(it) }

        global.log(MUSIC_TAG, "MusicService prepare: prepared.")
    }

    private fun disorganize() {
        global.log(MUSIC_TAG, "MusicService disorganize: disorganizing...")

        bootFlag = false
        stopForeground(false)

        musicPlayer.release()
        bassBoost.release()
        equalizer.release()

        global.handler.removeCallbacks(progressUpdate)

        music.detach()
        music.removeListener()
        music.removeCallback(musicCallback)
        music.disconnect()

        stopSelf()

        global.log(MUSIC_TAG, "MusicService disorganize: disorganized.")
    }

    private fun initAudioEffect() {
        bassBoost = BassBoost(100, musicPlayer.audioSessionId)
        equalizer = Equalizer(100, musicPlayer.audioSessionId)
        presetReverb = PresetReverb(100, 0)

        musicPlayer.attachAuxEffect(presetReverb.id)
        musicPlayer.setAuxEffectSendLevel(1f)

        bassBoost.enabled = false
        equalizer.enabled = false
        presetReverb.enabled = false

        if (settings.pGetBoolean("qBassBoost", false)) {
            music.setBass(settings.pGetInt("qBassBoostValue", 0))
        }

        music.setReverbEffect(settings.pGetString("qReverbEffector", "0")?.toShort() ?: 0)

        val bands = equalizer.numberOfBands
        global.minEQLevel = equalizer.bandLevelRange[0]
        global.maxWQLevel = equalizer.bandLevelRange[1]
        global.equalizerBandMap.clear()

        for (i in 0 until bands) {
            global.equalizerBandMap[i] = (equalizer.getCenterFreq(i.toShort()) / 1000).toString() + "Hz"
        }

        AudioEffect.queryEffects().forEach {
            Log.d(MUSIC_TAG, "AUDIO EFFECT: ${it.name}, TYPE: ${it.type}")
        }

        bassBoost.enabled = true
        equalizer.enabled = true
        presetReverb.enabled = true

        Log.d(MUSIC_TAG, "audio effect initialized.")
    }

    private fun resetMusicPlayer() {
        musicPlayer.release()
        musicPlayer = MediaPlayer()
        musicPlayer.setOnErrorListener(playerErrorListener)
    }

    private fun gainAudioFocus(): Boolean {
        return when (AudioManagerCompat.requestAudioFocus(audioManager, audioFocusRequest)) {
            AudioManager.AUDIOFOCUS_REQUEST_GRANTED -> true
            AudioManager.AUDIOFOCUS_REQUEST_FAILED  -> false
            AudioManager.AUDIOFOCUS_REQUEST_DELAYED -> false
            else                                    -> false
        }
    }

    private fun releaseAudioFocus() {
        AudioManagerCompat.abandonAudioFocusRequest(audioManager, audioFocusRequest)
    }

    private fun musicNotify() {
        if (!bootFlag) return

        try {
            val notificationManager = baseContext.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
            val notify = music.createMusicNotify(notificationManager, MUSIC_NOTIFY_ID) ?: return

            if (music.getCurrentMusicState() == PlaybackStateCompat.STATE_PLAYING) startForeground(MUSIC_NOTIFY_ID, notify)
            else stopForeground(false)

            notificationManager.notify(MUSIC_NOTIFY_ID, notify)
        } catch (e: Exception) {
            global.stackTrace(e.toString())
        }
    }

    companion object {
        const val MUSIC_NOTIFY_ID = 671
    }
}

###その6
MusicServiceを超省略して、主要な関数のみ説明。

#####prepare
MusicServiceを初期化＆MusicClassとの通信確立＆再生準備

#####disorganize
MusicServiceを破棄＆MusicClassとの通信を切断

#####musicNotify
音楽再生中はForegroundServiceとして振る舞い、中断中はいつでも破棄可能とする。

#####musicCallback, musicListener
MusicClassからの指示を拾い、実際に音楽を再生したりする。

#####progressUpdate
0.5sずつに呼び出して音楽の再生状況をMusicClassに報告する。（MusicClassはそれを受けて音楽の再生状況をActivityに伝えたりする）

###その7
あとはApplicationクラスでMusicClassをインスタンス化して、実際にActivityなどでmusic.onPlayを呼び出せば音楽が再生される。

##まとめ
質問を随時受付中。
この記事は自分のために高速で作ったものなので不備ありありだが、質問されれれば全力で答えていく。