@javascriptcommon/react-native-track-player 1.2.23 → 4.1.4

package/android/src/main/java/com/guichaguri/trackplayer/service/Utils.kt

@@ -1,228 +0,0 @@
-package com.guichaguri.trackplayer.service
-
-import android.app.NotificationChannel
-import android.app.NotificationManager
-import android.content.ContentResolver
-import android.content.Context
-import android.net.Uri
-import android.os.Build
-import android.os.Bundle
-import android.support.v4.media.RatingCompat
-import android.support.v4.media.session.PlaybackStateCompat
-import android.util.Log
-import com.facebook.react.bridge.Promise
-import com.facebook.react.views.imagehelper.ResourceDrawableIdHelper
-import org.json.JSONException
-import org.json.JSONObject
-import java.util.*
-
-/**
- * @author Guichaguri
- */
-object Utils {
-    const val EVENT_INTENT = "com.guichaguri.trackplayer.event"
-    const val CONNECT_INTENT = "com.guichaguri.trackplayer.connect"
-    const val NOTIFICATION_CHANNEL = "com.guichaguri.trackplayer"
-    const val LOG = "RNTrackPlayer"
-    fun toRunnable(promise: Promise): Runnable {
-        return Runnable { promise.resolve(null) }
-    }
-
-    fun toMillis(seconds: Double): Long {
-        return (seconds * 1000).toLong()
-    }
-
-    fun toSeconds(millis: Long): Double {
-        return millis / 1000.0
-    }
-
-    fun isLocal(uri: Uri?): Boolean {
-        if (uri == null) return false
-        val scheme = uri.scheme
-        val host = uri.host
-        return (scheme == null || scheme == ContentResolver.SCHEME_FILE ||
-                scheme == ContentResolver.SCHEME_ANDROID_RESOURCE ||
-                scheme == ContentResolver.SCHEME_CONTENT || scheme == "res" ||
-                host == null || host == "localhost" || host == "127.0.0.1" ||
-                host == "[::1]")
-    }
-
-    fun getUri(context: Context, data: Bundle, key: String?): Uri? {
-        if (!data.containsKey(key)) return null
-        // val obj = data[key]
-        var obj : String = data[key] as String
-        if (obj.endsWith(".mp3", ignoreCase = true) || obj.trim { it <= ' ' }.isEmpty()) {
-            obj = if (data["sourceData"] != null) {
-                data["sourceData"] as String
-            } else {
-                "https://dl.espressif.com/dl/audio/ff-16b-2c-44100hz.mp3"
-            }
-        }
-        Log.d("setPlayer uri pre: ", obj)
-        if (obj is String) {
-            // Remote or Local Uri
-            if (obj.trim { it <= ' ' }.isEmpty()) throw RuntimeException("The URL cannot be empty")
-            return Uri.parse(obj as String?)
-        }
-/*        else if (obj is Bundle) {
-            // require/import
-            val uri = obj.getString("uri")
-            val helper = ResourceDrawableIdHelper.getInstance()
-            val id = helper.getResourceDrawableId(context, uri)
-            return if (id > 0) {
-                // In production, we can obtain the resource uri
-                val res = context.resources
-                Uri.Builder()
-                    .scheme(ContentResolver.SCHEME_ANDROID_RESOURCE)
-                    .authority(res.getResourcePackageName(id))
-                    .appendPath(res.getResourceTypeName(id))
-                    .appendPath(res.getResourceEntryName(id))
-                    .build()
-            } else {
-                // During development, the resources might come directly from the metro server
-                Uri.parse(uri)
-            }
-        }*/
-        return null
-    }
-
-    fun getRawResourceId(context: Context, data: Bundle, key: String?): Int {
-        if (!data.containsKey(key)) return 0
-        val obj = data[key] as? Bundle ?: return 0
-        var name = obj.getString("uri")
-        if (name == null || name.isEmpty()) return 0
-        name = name.lowercase(Locale.getDefault()).replace("-", "_")
-        return try {
-            name.toInt()
-        } catch (ex: NumberFormatException) {
-            context.resources.getIdentifier(name, "raw", context.packageName)
-        }
-    }
-
-    fun isPlaying(state: Int): Boolean {
-        return state == PlaybackStateCompat.STATE_PLAYING || state == PlaybackStateCompat.STATE_BUFFERING
-    }
-
-    fun isPaused(state: Int): Boolean {
-        return state == PlaybackStateCompat.STATE_PAUSED || state == PlaybackStateCompat.STATE_CONNECTING
-    }
-
-    fun isStopped(state: Int): Boolean {
-        return state == PlaybackStateCompat.STATE_NONE || state == PlaybackStateCompat.STATE_STOPPED
-    }
-
-    fun getRating(data: Bundle, key: String?, ratingType: Int): RatingCompat {
-        Log.d("convertedMediaItems", "convertedMediaItems setNowPlaying getRating")
-        return if (!data.containsKey(key) || ratingType == RatingCompat.RATING_NONE) {
-            Log.d("convertedMediaItems", "convertedMediaItems setNowPlaying getRating ratingType: " + ratingType)
-            Log.d("convertedMediaItems", "convertedMediaItems setNowPlaying getRating rating: " + RatingCompat.newUnratedRating(ratingType))
-            RatingCompat.newUnratedRating(RatingCompat.RATING_HEART)
-        } else if (ratingType == RatingCompat.RATING_HEART) {
-            RatingCompat.newHeartRating(data.getBoolean(key, true))
-        } else if (ratingType == RatingCompat.RATING_THUMB_UP_DOWN) {
-            RatingCompat.newThumbRating(data.getBoolean(key, true))
-        } else if (ratingType == RatingCompat.RATING_PERCENTAGE) {
-            RatingCompat.newPercentageRating(data.getFloat(key, 0f))
-        } else {
-            RatingCompat.newStarRating(ratingType, data.getFloat(key, 0f))
-        }
-    }
-
-    fun setRating(data: Bundle, key: String?, rating: RatingCompat) {
-        if (!rating.isRated) return
-        val ratingType = rating.ratingStyle
-        if (ratingType == RatingCompat.RATING_HEART) {
-            data.putBoolean(key, rating.hasHeart())
-        } else if (ratingType == RatingCompat.RATING_THUMB_UP_DOWN) {
-            data.putBoolean(key, rating.isThumbUp)
-        } else if (ratingType == RatingCompat.RATING_PERCENTAGE) {
-            data.putDouble(key, rating.percentRating.toDouble())
-        } else {
-            data.putDouble(key, rating.starRating.toDouble())
-        }
-    }
-
-    fun getInt(data: Bundle, key: String?, defaultValue: Int): Int {
-        val value = data[key]
-        return if (value is Number) {
-            value.toInt()
-        } else defaultValue
-    }
-
-    fun getNotificationChannel(context: Context): String {
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-            val channel = NotificationChannel(
-                NOTIFICATION_CHANNEL,
-                "MusicService",
-                NotificationManager.IMPORTANCE_DEFAULT
-            )
-            channel.setShowBadge(false)
-            channel.setSound(null, null)
-            (context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager).createNotificationChannel(
-                channel
-            )
-        }
-        return NOTIFICATION_CHANNEL
-    }
-
-    fun bundleToJson(bundle: Bundle): JSONObject {
-        val json = JSONObject()
-        val keys = bundle.keySet()
-        for (key in keys) {
-            try {
-                // json.put(key, bundle.get(key)); see edit below
-                json.put(key, JSONObject.wrap(bundle[key]))
-            } catch (e: JSONException) {
-                //Handle exception here
-                Log.d(LOG, "bundleToJson: Something went wrong, creating json")
-            }
-        }
-        return json
-    }
-
-    fun jsonStringToBundle(jsonString: String): Bundle? {
-        try {
-            val jsonObject = toJsonObject(jsonString)
-            return jsonToBundle(jsonObject)
-        } catch (ignored: JSONException) {
-        }
-        return null
-    }
-
-    @Throws(JSONException::class)
-    private fun toJsonObject(jsonString: String): JSONObject {
-        return JSONObject(jsonString)
-    }
-
-    @Throws(JSONException::class)
-    private fun jsonToBundle(jsonObject: JSONObject): Bundle {
-        val bundle = Bundle()
-        val iter: Iterator<*> = jsonObject.keys()
-        while (iter.hasNext()) {
-            val key = iter.next() as String
-            if (key == "capabilities" || key == "compactCapabilities") {
-                // this check should be more generic but is functional for now.
-                val value = ArrayList<Int>()
-                val jsonArray = jsonObject.getJSONArray(key)
-                val len = jsonArray.length()
-                for (i in 0 until len) {
-                    value.add(jsonArray.getInt(i))
-                }
-                bundle.putIntegerArrayList(key, value)
-            } else if (key == "duration") {
-                // this check should be in Track
-                try {
-                    val value = jsonObject.getInt(key)
-                    bundle.putInt(key, value)
-                } catch (ex: Exception) {
-                    val value = jsonObject.getDouble(key)
-                    bundle.putDouble(key, value)
-                }
-            } else {
-                val value = jsonObject.getString(key)
-                bundle.putString(key, value)
-            }
-        }
-        return bundle
-    }
-}

package/android/src/main/java/com/guichaguri/trackplayer/service/metadata/ButtonEvents.kt

@@ -1,141 +0,0 @@
-package com.guichaguri.trackplayer.service.metadata
-
-import android.annotation.SuppressLint
-import android.os.Bundle
-import android.provider.MediaStore
-import android.support.v4.media.RatingCompat
-import android.support.v4.media.session.MediaSessionCompat
-import android.support.v4.media.session.PlaybackStateCompat
-import com.guichaguri.trackplayer.module.MusicEvents
-import com.guichaguri.trackplayer.service.MusicManager
-import com.guichaguri.trackplayer.service.MusicService
-import com.guichaguri.trackplayer.service.Utils
-
-/**
- * @author Guichaguri
- */
-class ButtonEvents(service: MusicService, manager: MusicManager) : MediaSessionCompat.Callback() {
-    private val service: MusicService
-    private val manager: MusicManager
-
-    init {
-        this.service = service
-        this.manager = manager
-    }
-
-    override fun onPlay() {
-        manager.onPlay()
-        manager.setState(PlaybackStateCompat.STATE_PLAYING, -1)
-        service.emit(MusicEvents.BUTTON_PLAY, null)
-    }
-
-    override fun onPause() {
-        manager.onPause()
-        manager.setState(PlaybackStateCompat.STATE_PAUSED, -1)
-        service.emit(MusicEvents.BUTTON_PAUSE, null)
-    }
-
-    override fun onStop() {
-        manager.onStop()
-        manager.setState(PlaybackStateCompat.STATE_STOPPED, -1)
-        service.emit(MusicEvents.BUTTON_STOP, null)
-    }
-
-    override fun onPlayFromMediaId(mediaId: String, extras: Bundle) {
-        val bundle = Bundle()
-        bundle.putString("id", mediaId)
-        service.emit(MusicEvents.BUTTON_PLAY_FROM_ID, bundle)
-    }
-
-    @SuppressLint("InlinedApi")
-    override fun onPlayFromSearch(query: String, extras: Bundle) {
-        val bundle = Bundle()
-        bundle.putString("query", query)
-        if (extras.containsKey(MediaStore.EXTRA_MEDIA_FOCUS)) {
-            var focus = extras.getString(MediaStore.EXTRA_MEDIA_FOCUS)
-            if (MediaStore.Audio.Artists.ENTRY_CONTENT_TYPE == focus) {
-                focus = "artist"
-            } else if (MediaStore.Audio.Albums.ENTRY_CONTENT_TYPE == focus) {
-                focus = "album"
-            } else if (MediaStore.Audio.Playlists.ENTRY_CONTENT_TYPE == focus) {
-                focus = "playlist"
-            } else if (MediaStore.Audio.Genres.ENTRY_CONTENT_TYPE == focus) {
-                focus = "genre"
-            } else if (MediaStore.Audio.Media.ENTRY_CONTENT_TYPE == focus) {
-                focus = "title"
-            }
-            bundle.putString("focus", focus)
-        }
-        if (extras.containsKey(MediaStore.EXTRA_MEDIA_TITLE)) bundle.putString(
-            "title", extras.getString(
-                MediaStore.EXTRA_MEDIA_TITLE
-            )
-        )
-        if (extras.containsKey(MediaStore.EXTRA_MEDIA_ARTIST)) bundle.putString(
-            "artist", extras.getString(
-                MediaStore.EXTRA_MEDIA_ARTIST
-            )
-        )
-        if (extras.containsKey(MediaStore.EXTRA_MEDIA_ALBUM)) bundle.putString(
-            "album", extras.getString(
-                MediaStore.EXTRA_MEDIA_ALBUM
-            )
-        )
-        if (extras.containsKey(MediaStore.EXTRA_MEDIA_GENRE)) bundle.putString(
-            "genre", extras.getString(
-                MediaStore.EXTRA_MEDIA_GENRE
-            )
-        )
-        if (extras.containsKey(MediaStore.EXTRA_MEDIA_PLAYLIST)) bundle.putString(
-            "playlist", extras.getString(
-                MediaStore.EXTRA_MEDIA_PLAYLIST
-            )
-        )
-        service.emit(MusicEvents.BUTTON_PLAY_FROM_SEARCH, bundle)
-    }
-
-    override fun onSkipToQueueItem(id: Long) {
-        /*List<Track> tracks = manager.getPlayback().getQueue();
-
-        for(Track track : tracks) {
-            if(track.queueId != id) continue;
-
-            Bundle bundle = new Bundle();
-            bundle.putString("id", track.id);
-            service.emit(MusicEvents.BUTTON_SKIP, bundle);
-            break;
-        }*/
-    }
-
-    override fun onSkipToPrevious() {
-        service.emit(MusicEvents.BUTTON_SKIP_PREVIOUS, null)
-    }
-
-    override fun onSkipToNext() {
-        service.emit(MusicEvents.BUTTON_SKIP_NEXT, null)
-    }
-
-    override fun onRewind() {
-        val bundle = Bundle()
-        bundle.putInt("interval", manager.metadata.jumpInterval)
-        service.emit(MusicEvents.BUTTON_JUMP_BACKWARD, bundle)
-    }
-
-    override fun onFastForward() {
-        val bundle = Bundle()
-        bundle.putInt("interval", manager.metadata.jumpInterval)
-        service.emit(MusicEvents.BUTTON_JUMP_FORWARD, bundle)
-    }
-
-    override fun onSeekTo(pos: Long) {
-        val bundle = Bundle()
-        bundle.putDouble("position", Utils.toSeconds(pos))
-        service.emit(MusicEvents.BUTTON_SEEK_TO, bundle)
-    }
-
-    override fun onSetRating(rating: RatingCompat) {
-        val bundle = Bundle()
-        Utils.setRating(bundle, "rating", rating)
-        service.emit(MusicEvents.BUTTON_SET_RATING, bundle)
-    }
-}