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

package/android/src/main/java/com/guichaguri/trackplayer/model/Track.kt

@@ -0,0 +1,120 @@
+package com.guichaguri.trackplayer.model
+
+import android.content.Context
+import android.net.Uri
+import android.os.Bundle
+import android.support.v4.media.MediaDescriptionCompat
+import android.support.v4.media.MediaMetadataCompat
+import android.support.v4.media.RatingCompat
+import android.support.v4.media.session.MediaSessionCompat
+import android.util.Log
+import com.guichaguri.trackplayer.kotlinaudio.models.AudioItemOptions
+import com.guichaguri.trackplayer.kotlinaudio.models.MediaType
+import com.guichaguri.trackplayer.service.Utils
+import com.guichaguri.trackplayer.service.Utils.bundleToJson
+import org.json.JSONObject
+
+/**
+ * @author Guichaguri
+ */
+class Track(context: Context?, bundle: Bundle, ratingType: Int) {
+    var url: String = ""
+    var id: String?
+    var resourceId: Int? = null // leave it null, not 0
+    var type = MediaType.DEFAULT
+    var contentType: String?
+    var userAgent: String?
+    var artwork: Uri? = null
+    var title: String? = null
+    var artist: String? = null
+    var album: String? = null
+    var date: String? = null
+    var genre: String? = null
+    var duration: Long = 0
+    var originalItem: Bundle?
+    var json: JSONObject
+    var rating: RatingCompat? = null
+    var headers: MutableMap<String, String>? = null
+    val queueId: Long
+
+    init {
+        id = bundle.getString("mediaId")
+        val trackType = bundle.getString("type", "default")
+        for (t in MediaType.values()) {
+            if (t.name.equals(trackType, ignoreCase = true)) {
+                type = t
+                break
+            }
+        }
+        if (bundle.getString("sourceData") != null) {
+            url = bundle.getString("sourceData").toString()
+        }
+        contentType = bundle.getString("contentType")
+        userAgent = bundle.getString("userAgent")
+        val httpHeaders = bundle.getBundle("headers")
+        if (httpHeaders != null) {
+            headers = HashMap()
+            for (header in httpHeaders.keySet()) {
+                (headers as HashMap<String, String?>)[header] = httpHeaders.getString(header)
+            }
+        }
+        setMetadata(context, bundle, ratingType)
+        queueId = System.currentTimeMillis()
+        json = bundleToJson(bundle)
+        originalItem = bundle
+    }
+
+    fun setMetadata(context: Context?, bundle: Bundle, ratingType: Int) {
+        artwork = context?.let { Utils.getUri(it, bundle, "artwork") }
+        title = bundle.getString("title")
+        artist = bundle.getString("artist")
+        album = bundle.getString("album")
+        date = bundle.getString("date")
+        genre = bundle.getString("genre")
+        duration = try {
+            Utils.toMillis(bundle.getDouble("duration", 0.0))
+        } catch (ex: Exception) {
+            val durationInt = bundle.getInt("duration", 0)
+            Utils.toMillis(durationInt.toDouble())
+        }
+        rating = Utils.getRating(bundle, "rating", ratingType)
+        if (originalItem != null && originalItem != bundle) originalItem!!.putAll(bundle)
+    }
+
+    fun toMediaMetadata(): MediaMetadataCompat.Builder {
+        val builder = MediaMetadataCompat.Builder()
+        builder.putString(MediaMetadataCompat.METADATA_KEY_TITLE, title)
+        builder.putString(MediaMetadataCompat.METADATA_KEY_ARTIST, artist)
+        builder.putString(MediaMetadataCompat.METADATA_KEY_ALBUM, album)
+        builder.putString(MediaMetadataCompat.METADATA_KEY_DATE, date)
+        builder.putString(MediaMetadataCompat.METADATA_KEY_GENRE, genre)
+        //builder.putString(METADATA_KEY_MEDIA_URI, uri.toString());
+        builder.putString(MediaMetadataCompat.METADATA_KEY_MEDIA_ID, id)
+        if (duration > 0) {
+            builder.putLong(MediaMetadataCompat.METADATA_KEY_DURATION, duration)
+        }
+//        if (artwork != null) {
+//            builder.putString(MediaMetadataCompat.METADATA_KEY_ART_URI, artwork.toString())
+//        }
+        if (rating != null) {
+            builder.putRating(MediaMetadataCompat.METADATA_KEY_RATING, rating)
+        }
+        return builder
+    }
+
+    fun toQueueItem(): MediaSessionCompat.QueueItem {
+        val descr = MediaDescriptionCompat.Builder()
+            .setTitle(title)
+            .setSubtitle(artist)
+            .setMediaId(id) //.setMediaUri(uri)
+            .setIconUri(artwork)
+            .build()
+        return MediaSessionCompat.QueueItem(descr, queueId)
+    }
+
+    fun toAudioItem(): TrackAudioItem {
+        return TrackAudioItem(this, type, url, artist, title, album, artwork.toString(), duration,
+            AudioItemOptions(headers, userAgent, resourceId)
+        )
+    }
+}

package/android/src/main/java/com/guichaguri/trackplayer/model/TrackAudioItem.kt

@@ -0,0 +1,19 @@
+package com.guichaguri.trackplayer.model
+
+import android.graphics.Bitmap
+import com.guichaguri.trackplayer.kotlinaudio.models.AudioItem
+import com.guichaguri.trackplayer.kotlinaudio.models.AudioItemOptions
+import com.guichaguri.trackplayer.kotlinaudio.models.MediaType
+
+data class TrackAudioItem(
+    val track: Track,
+    override val type: MediaType,
+    override var audioUrl: String,
+    override var artist: String? = null,
+    override var title: String? = null,
+    override var albumTitle: String? = null,
+    override val artwork: String? = null,
+    override val duration: Long = 0,
+    override val options: AudioItemOptions? = null,
+    override var artworkBitmap: Bitmap? = null
+): AudioItem

package/android/src/main/java/com/guichaguri/trackplayer/model/TrackType.kt

@@ -0,0 +1,11 @@
+package com.guichaguri.trackplayer.model
+
+enum class TrackType(val typeName: String) {
+    DEFAULT("default"),
+
+    DASH("dash"),
+
+    HLS("hls"),
+
+    SMOOTH_STREAMING("smoothstreaming")
+}

package/android/src/main/java/com/guichaguri/trackplayer/module/AutoConnectionDetector.kt

@@ -0,0 +1,151 @@
+package com.guichaguri.trackplayer.module
+
+import android.annotation.SuppressLint
+import android.content.AsyncQueryHandler
+import android.content.BroadcastReceiver
+import android.content.ContentResolver
+import android.content.Context
+import android.content.Intent
+import android.content.IntentFilter
+import android.database.Cursor
+import android.net.Uri
+import android.os.Build
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.modules.core.DeviceEventManagerModule
+
+class AutoConnectionDetector(
+    val context: ReactContext,
+    private val onConnectionChange: ((Boolean) -> Unit)? = null
+) {
+
+    companion object {
+        const val TAG = "AutoConnectionDetector"
+
+        // columnName for provider to query on connection status
+        const val CAR_CONNECTION_STATE = "CarConnectionState"
+
+        // auto app on your phone will send broadcast with this action when connection state changes
+        const val ACTION_CAR_CONNECTION_UPDATED = "androidx.car.app.connection.action.CAR_CONNECTION_UPDATED"
+
+        // phone is not connected to car
+        const val CONNECTION_TYPE_NOT_CONNECTED = 0
+
+        // phone is connected to Automotive OS
+        const val CONNECTION_TYPE_NATIVE = 1
+
+        // phone is connected to Android Auto
+        const val CONNECTION_TYPE_PROJECTION = 2
+
+        private const val QUERY_TOKEN = 42
+
+        private const val CAR_CONNECTION_AUTHORITY = "androidx.car.app.connection"
+
+        private val PROJECTION_HOST_URI = Uri.Builder().scheme("content").authority(CAR_CONNECTION_AUTHORITY).build()
+
+        private const val CAR_CONNECTION_UPDATE = "car-connection-update"
+    }
+
+    var isCarConnected = false
+
+    private val carConnectionReceiver = CarConnectionBroadcastReceiver()
+    private val carConnectionQueryHandler = CarConnectionQueryHandler(context.contentResolver, context, this, onConnectionChange)
+    private var isReceiverRegistered = false
+
+    fun registerCarConnectionReceiver() {
+        if (!isReceiverRegistered) {
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+                context.registerReceiver(carConnectionReceiver, IntentFilter(ACTION_CAR_CONNECTION_UPDATED), Context.RECEIVER_NOT_EXPORTED)
+            } else @SuppressLint("UnspecifiedRegisterReceiverFlag") {
+                context.registerReceiver(carConnectionReceiver, IntentFilter(ACTION_CAR_CONNECTION_UPDATED))
+            }
+            isReceiverRegistered = true
+        }
+        queryForState()
+    }
+
+    fun unRegisterCarConnectionReceiver() {
+        if (isReceiverRegistered) {
+            context.unregisterReceiver(carConnectionReceiver)
+            isReceiverRegistered = false
+        }
+    }
+
+    private fun queryForState() {
+        carConnectionQueryHandler.startQuery(
+            QUERY_TOKEN,
+            null,
+            PROJECTION_HOST_URI,
+            arrayOf(CAR_CONNECTION_STATE),
+            null,
+            null,
+            null
+        )
+    }
+
+    inner class CarConnectionBroadcastReceiver : BroadcastReceiver() {
+        // query for connection state every time the receiver receives the broadcast
+        override fun onReceive(context: Context?, intent: Intent?) {
+            queryForState()
+        }
+    }
+
+    internal class CarConnectionQueryHandler(
+        resolver: ContentResolver?,
+        private val context: ReactContext?,
+        private val autoConnectionDetector: AutoConnectionDetector,
+        private val onConnectionChange: ((Boolean) -> Unit)? = null,
+    ) : AsyncQueryHandler(resolver) {
+
+        private fun emitConnectionUpdate(params: WritableMap) {
+            context?.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)?.emit(
+                CAR_CONNECTION_UPDATE, params
+            )
+        }
+
+        private fun notifyCarConnected() {
+            autoConnectionDetector.isCarConnected = true
+            val params = Arguments.createMap()
+            params.putBoolean("connected", true)
+            emitConnectionUpdate(params)
+            onConnectionChange?.invoke(true)
+        }
+
+        private fun notifyCarDisconnected() {
+            autoConnectionDetector.isCarConnected = false
+            val params = Arguments.createMap()
+            params.putBoolean("connected", false)
+            emitConnectionUpdate(params)
+            onConnectionChange?.invoke(false)
+        }
+
+        // notify new queryed connection status when query complete
+        override fun onQueryComplete(token: Int, cookie: Any?, response: Cursor?) {
+            if (response == null) {
+                // Null response from content provider when checking connection to the car, treating as disconnected
+                notifyCarDisconnected()
+                return
+            }
+            val carConnectionTypeColumn = response.getColumnIndex(CAR_CONNECTION_STATE)
+            if (carConnectionTypeColumn < 0) {
+                // Connection to car response is missing the connection type, treating as disconnected
+                notifyCarDisconnected()
+                return
+            }
+            if (!response.moveToNext()) {
+                // Connection to car response is empty, treating as disconnected
+                notifyCarDisconnected()
+                return
+            }
+            val connectionState = response.getInt(carConnectionTypeColumn)
+            if (connectionState == CONNECTION_TYPE_NOT_CONNECTED) {
+                // Android Auto disconnected
+                notifyCarDisconnected()
+            } else {
+                // Android Auto connected
+                notifyCarConnected()
+            }
+        }
+    }
+}

package/android/src/main/java/com/guichaguri/trackplayer/module/MusicEvents.kt

@@ -0,0 +1,66 @@
+package com.guichaguri.trackplayer.module
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.modules.core.DeviceEventManagerModule.RCTDeviceEventEmitter
+
+/**
+ * @author Milen Pivchev @mpivchev
+ */
+class MusicEvents(private val reactContext: ReactContext) : BroadcastReceiver() {
+    override fun onReceive(context: Context, intent: Intent) {
+        val event = intent.getStringExtra("event")
+        val data = intent.getBundleExtra("data")
+        val map = if (data != null) Arguments.fromBundle(data) else null
+        reactContext.getJSModule(RCTDeviceEventEmitter::class.java).emit(
+            event!!, map
+        )
+    }
+
+    companion object {
+        // Media Control Events
+        const val BUTTON_PLAY = "remote-play"
+        const val BUTTON_PLAY_FROM_ID = "remote-play-id"
+        const val SEARCH = "remote-search"
+        const val BUTTON_PLAY_FROM_SEARCH = "remote-play-search"
+        const val BUTTON_PLAY_FROM_QUEUE = "remote-play-queue"
+        const val BUTTON_PAUSE = "remote-pause"
+        const val BUTTON_STOP = "remote-stop"
+        const val BUTTON_SKIP = "remote-skip"
+        const val BUTTON_SKIP_NEXT = "remote-next"
+        const val BUTTON_SKIP_PREVIOUS = "remote-previous"
+        const val BUTTON_SEEK_TO = "remote-seek"
+        const val BUTTON_SET_RATING = "remote-set-rating"
+        const val BUTTON_JUMP_FORWARD = "remote-jump-forward"
+        const val BUTTON_JUMP_BACKWARD = "remote-jump-backward"
+        const val BUTTON_DUCK = "remote-duck"
+        const val BUTTON_BROWSE = "remote-browse"
+        const val BUTTON_SHUFFLE = "remote-shuffle"
+        const val BUTTON_REPEAT = "remote-repeat"
+        const val BUTTON_TRACK_STATUS = "remote-track-status"
+
+        // Playback Events
+        const val PLAYBACK_PLAY_WHEN_READY_CHANGED = "playback-play-when-ready-changed"
+        const val PLAYBACK_STATE = "playback-state"
+        const val PLAYBACK_TRACK_CHANGED = "playback-track-changed"
+        const val PLAYBACK_ACTIVE_TRACK_CHANGED = "playback-active-track-changed"
+        const val PLAYBACK_QUEUE_ENDED = "playback-queue-ended"
+        const val PLAYBACK_METADATA = "playback-metadata-received"
+        const val PLAYBACK_PROGRESS_UPDATED = "playback-progress-updated"
+        const val PLAYBACK_ERROR = "playback-error"
+
+        // Metadata Events
+        const val METADATA_CHAPTER_RECEIVED = "metadata-chapter-received"
+        const val METADATA_TIMED_RECEIVED = "metadata-timed-received"
+        const val METADATA_COMMON_RECEIVED = "metadata-common-received"
+        const val METADATA_PAYLOAD_KEY = "metadata"
+
+        // Other
+        const val PLAYER_ERROR = "player-error"
+
+        const val EVENT_INTENT = "com.doublesymmetry.trackplayer.event"
+    }
+}