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

package/android/src/main/java/com/lovegaoshi/kotlinaudio/processors/TeeListener.kt

@@ -0,0 +1,171 @@
+// credits: https://github.com/cora32/Media3Player/blob/df06c3d72598b8e7f75fcfd22c5e9da8bc98e0a0/app/src/main/java/io/iskopasi/player_test/PlayerService.kt#L18
+package com.lovegaoshi.kotlinaudio.processors
+
+import androidx.media3.common.util.UnstableApi
+import androidx.media3.common.audio.AudioProcessor.EMPTY_BUFFER
+import androidx.media3.exoplayer.audio.TeeAudioProcessor.AudioBufferSink
+import com.lovegaoshi.kotlinaudio.utils.FFT
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import java.nio.ByteBuffer
+import java.nio.ByteOrder
+import kotlin.math.floor
+import kotlin.math.min
+import kotlin.math.pow
+import kotlin.math.sqrt
+
+val FREQUENCY_BAND_LIMITS = arrayOf(
+    20, 32, 40, 50, 63, 80, 100, 125, 160, 200, 250, 315, 400, 500, 630,
+    800, 1000, 1250, 1600, 2000, 2500, 3150, 4000, 5000, 6300, 8000, 10000,
+    12500, 16000, 20000
+)
+
+@UnstableApi
+class TeeListener(
+    val sampleRate: Int,
+    val emitter: FFTEmitter? ) : AudioBufferSink {
+    private var sampleRateHz = 0
+    private var channelCount = 1
+    private var encoding = 0
+    private var fft = FFT( sampleRate)
+    private var fftBuffer = EMPTY_BUFFER
+    private val chartData = FloatArray(sampleRate)
+    private val src = FloatArray(sampleRate)
+    private val frequencyMap = DoubleArray(FREQUENCY_BAND_LIMITS.size)
+    private var isProcessing = false
+
+    override fun flush(sampleRateHz: Int, channelCount: Int, encoding: Int) {
+        this.sampleRateHz = sampleRateHz
+        this.channelCount = channelCount
+        this.encoding = encoding
+    }
+
+    override fun handleBuffer(buffer: ByteBuffer) {
+        if (isProcessing) return
+
+        isProcessing = true
+
+        // Cannot access buffer in different thread
+        fillBuffer(buffer)
+
+        CoroutineScope(Dispatchers.IO).launch {
+            processFFT()
+
+            isProcessing = false
+        }
+        /**
+         * code I copied elsewhere
+        val doubleBuffer = buffer.asDoubleBuffer()
+        val data = DoubleArray(doubleBuffer.limit())
+        doubleBuffer.get(data)
+        val numFrames: Int = data.size / channelCount
+        val rawData = DoubleArray(numFrames)
+        Log.d("APMFFT", "buffer handling size: $numFrames, $sampleRateHz, $channelCount")
+        //took average of all channel data
+        for (i in 0..<numFrames) {
+        var sum = 0.0
+        for (ch in 0..<channelCount) {
+        sum += (data[channelCount * i + ch] + 32768)
+        }
+        rawData[i] = (sum / channelCount)
+        }
+         */
+    }
+
+    private fun fillBuffer(buffer: ByteBuffer) {
+        val limit = buffer.limit()
+        val frameCount = (limit - buffer.position()) / (2 * channelCount)
+        val singleChannelOutputSize = frameCount * 2
+
+        if (fftBuffer.capacity() < singleChannelOutputSize) {
+            fftBuffer =
+                ByteBuffer.allocateDirect(singleChannelOutputSize)
+                    .order(ByteOrder.nativeOrder())
+        } else {
+            fftBuffer.clear()
+        }
+
+        // Each signal = short (2 bytes)
+        // Use average of 2 channels as an input signal
+        for (position in buffer.position() until limit step channelCount * 2) {
+            var sum = 0
+
+            for (channelIndex in 0 until channelCount) {
+                val current = buffer.getShort(position + channelIndex * 2)
+                sum += current
+            }
+
+            fftBuffer.putShort((sum / channelCount).toShort())
+        }
+    }
+    private fun processFFT() {
+        val maxLimit = min(fftBuffer.limit(), sampleRate)
+
+        for (i in 0 until maxLimit step 2) {
+            val short = fftBuffer.getShort(i)
+
+            src[i] = short.toFloat()
+        }
+
+        val srcCopy = src.clone()
+        // DC bin is located at index 0, 1, nyquist at index n-2, n-1
+        fft.fft(srcCopy, FloatArray(sampleRate))
+        // Fill amplitude data
+        // The resulting graph is mirrored, so get only left part
+        for (i in 0 until srcCopy.size / 2) {
+            val real = srcCopy[i * 2]
+            val imaginary = srcCopy[i * 2 + 1]
+            val amplitude = sqrt(real.pow(2) + imaginary.pow(2))
+
+            chartData[i] = amplitude
+        }
+
+        val size = sampleRate / 2
+        var startIndex = 0
+        var maxAvgAmplitude = 0f
+        var maxRawAmplitude = 0f
+
+        // Group amplitudes by their frequencies
+        for ((index, frequency) in FREQUENCY_BAND_LIMITS.withIndex()) {
+            val endIndex = floor(frequency / 20000f * size).toInt()
+
+            var accum = 0f
+            // Sum amplitudes for current frequency bin
+            for (i in startIndex until endIndex) {
+                val amplitude = chartData[i]
+                accum += amplitude
+
+                // Find max amplitude of all frequencies
+                if (amplitude > maxRawAmplitude) {
+                    maxRawAmplitude = amplitude
+                }
+            }
+
+            // Sometimes frequency group range can be 0
+            val amplitude = if (endIndex - startIndex == 0)
+                0f
+            else {
+                // Get avg amplitude for frequency bin
+                accum / (endIndex - startIndex).toFloat()
+            }
+
+            // Fill avg amplitude for each frequency
+            frequencyMap[index] = amplitude.toDouble()
+
+            // Get max avg amplitude
+            if (amplitude > maxAvgAmplitude) {
+                maxAvgAmplitude = amplitude
+            }
+
+            startIndex = endIndex
+        }
+        emitter?.onSpectrumReady(chartData, maxRawAmplitude)
+        emitter?.onFrequencyFFTReady(frequencyMap, maxAvgAmplitude)
+    }
+}
+
+interface FFTEmitter {
+    fun onSpectrumReady(spectrum: FloatArray, maxRawAmp: Float)
+    fun onFrequencyFFTReady(fft: DoubleArray, maxAvgAmp: Float)
+}

package/android/src/main/java/com/lovegaoshi/kotlinaudio/service/MusicService.kt

@@ -0,0 +1,127 @@
+@file: OptIn(UnstableApi::class) package com.lovegaoshi.kotlinaudio.service
+
+import android.content.Intent
+import android.os.Binder
+import android.os.Bundle
+import android.os.IBinder
+import androidx.annotation.OptIn
+import androidx.media3.common.util.UnstableApi
+import androidx.media3.session.MediaLibraryService
+import androidx.media3.session.MediaSession
+import androidx.media3.session.SessionCommand
+import androidx.media3.session.SessionResult
+import com.google.common.util.concurrent.ListenableFuture
+import com.lovegaoshi.kotlinaudio.models.CustomButton
+import com.lovegaoshi.kotlinaudio.models.PlayerOptions
+import com.lovegaoshi.kotlinaudio.player.QueuedAudioPlayer
+import timber.log.Timber
+
+class MusicService : MediaLibraryService() {
+    private val binder = MusicBinder()
+    lateinit var player: QueuedAudioPlayer
+    private lateinit var mediaSession: MediaLibrarySession
+
+    override fun onGetSession(controllerInfo: MediaSession.ControllerInfo): MediaLibrarySession =
+        mediaSession
+
+    // Create your player and media session in the onCreate lifecycle event
+    override fun onCreate() {
+        super.onCreate()
+        // Service is immediately set up for the KA example.
+        setupService(listOf(
+            CustomButton(displayName = CROSSFADE_PREV_PREPARE),
+            CustomButton(displayName = CROSSFADE_PREV),
+            CustomButton(displayName = CROSSFADE_NEXT_PREPARE),
+            CustomButton(displayName = CROSSFADE_NEXT),
+        ))
+        // setMediaNotificationProvider()
+    }
+
+    private fun setupService(customActions: List<CustomButton> = arrayListOf()) {
+
+        player = QueuedAudioPlayer(this, PlayerOptions(crossfade = true, nativeExample = true))
+        mediaSession = MediaLibrarySession
+            .Builder(this, player.player, CustomMediaSessionCallback(customActions))
+            .setCustomLayout(customActions.filter { v -> v.onLayout }.map{ v -> v.commandButton})
+            .setId("APM")
+            .build()
+    }
+
+    // The user dismissed the app from the recent tasks
+    override fun onTaskRemoved(rootIntent: Intent?) {
+        val player = mediaSession.player
+        if (!player.playWhenReady || player.mediaItemCount == 0) {
+            // Stop the service if not playing, continue playing in the background
+            // otherwise.
+            stopSelf()
+        }
+    }
+
+    // Remember to release the player and media session in onDestroy
+    override fun onDestroy() {
+        mediaSession.run {
+            player.release()
+            release()
+            mediaSession.release()
+        }
+        super.onDestroy()
+    }
+
+    @UnstableApi private inner class CustomMediaSessionCallback(
+        val customActions: List<CustomButton>
+    ) : MediaLibrarySession.Callback {
+
+        override fun onCustomCommand(
+            session: MediaSession,
+            controller: MediaSession.ControllerInfo,
+            customCommand: SessionCommand,
+            args: Bundle
+        ): ListenableFuture<SessionResult> {
+            Timber.tag("APM").d("custom command triggered: ${customCommand.customAction}")
+            when (customCommand.customAction) {
+                CROSSFADE_PREV_PREPARE -> { player.crossFadePrepare(true) }
+                CROSSFADE_PREV -> { player.switchExoPlayer({ player.previous() }) }
+                CROSSFADE_NEXT_PREPARE -> { player.crossFadePrepare() }
+                CROSSFADE_NEXT -> {
+                    player.switchExoPlayer()
+                    mediaSession.player = player.player
+                    this@MusicService.onUpdateNotification(mediaSession, true)
+                }
+            }
+            return super.onCustomCommand(session, controller, customCommand, args)
+        }
+
+        // Configure commands available to the controller in onConnect()
+        override fun onConnect(
+            session: MediaSession,
+            controller: MediaSession.ControllerInfo
+        ): MediaSession.ConnectionResult {
+            val sessionCommands = MediaSession.ConnectionResult.DEFAULT_SESSION_AND_LIBRARY_COMMANDS.buildUpon()
+            customActions.forEach{
+                v -> v.commandButton.sessionCommand?.let { sessionCommands.add(it) }
+            }
+            return MediaSession.ConnectionResult.AcceptedResultBuilder(session)
+                .setAvailableSessionCommands(sessionCommands.build())
+                .setAvailablePlayerCommands(MediaSession.ConnectionResult.DEFAULT_PLAYER_COMMANDS)
+                .build()
+        }
+    }
+
+    inner class MusicBinder : Binder() {
+        val service = this@MusicService
+    }
+
+    override fun onBind(intent: Intent?): IBinder? {
+        val intentAction = intent?.action
+        return if (intentAction != null) {
+            super.onBind(intent)
+        } else {
+            binder
+        }
+    }
+}
+
+const val CROSSFADE_PREV_PREPARE = "crossfade prev prepare"
+const val CROSSFADE_PREV = "crossfade prev"
+const val CROSSFADE_NEXT_PREPARE = "crossfade next prepare"
+const val CROSSFADE_NEXT = "crossfade next"

package/android/src/main/java/com/lovegaoshi/kotlinaudio/utils/FFT.java

@@ -0,0 +1,99 @@
+/***************************************************************
+ 00089   * fft.c
+ 00090   * Douglas L. Jones
+ 00091   * University of Illinois at Urbana-Champaign
+ 00092   * January 19, 1992
+ 00093   * http://cnx.rice.edu/content/m12016/latest/
+ 00094   *
+ 00095   *   fft: in-place radix-2 DIT DFT of a complex input
+ 00096   *
+ 00097   *   input:
+ 00098   * n: length of FFT: must be a power of two
+ 00099   * m: n = 2**m
+ 00100   *   input/output
+ 00101   * x: double array of length n with real part of data
+ 00102   * y: double array of length n with imag part of data
+ 00103   *
+ 00104   *   Permission to copy and use this program is granted
+ 00105   *   as long as this header is included.
+ ***************************************************************/
+package com.lovegaoshi.kotlinaudio.utils;
+
+public class FFT {
+
+    int n, m;
+
+    // Lookup tables. Only need to recompute when size of FFT changes.
+    double[] cos;
+    double[] sin;
+
+    public FFT(int n) {
+        this.n = n;
+        this.m = (int) (Math.log(n) / Math.log(2));
+
+        // Make sure n is a power of 2
+        if (n != (1 << m))
+            throw new RuntimeException("FFT length must be power of 2");
+
+        // precompute tables
+        cos = new double[n / 2];
+        sin = new double[n / 2];
+
+        for (int i = 0; i < n / 2; i++) {
+            cos[i] = Math.cos(-2 * Math.PI * i / n);
+            sin[i] = Math.sin(-2 * Math.PI * i / n);
+        }
+
+    }
+
+    public void fft(float[] x, float[] y) {
+        int i, j, k, n1, n2, a;
+        float c, s, t1, t2;
+
+        // Bit-reverse
+        j = 0;
+        n2 = n / 2;
+        for (i = 1; i < n - 1; i++) {
+            n1 = n2;
+            while (j >= n1) {
+                j = j - n1;
+                n1 = n1 / 2;
+            }
+            j = j + n1;
+
+            if (i < j) {
+                t1 = x[i];
+                x[i] = x[j];
+                x[j] = t1;
+                t1 = y[i];
+                y[i] = y[j];
+                y[j] = t1;
+            }
+        }
+
+        // FFT
+        n1 = 0;
+        n2 = 1;
+
+        for (i = 0; i < m; i++) {
+            n1 = n2;
+            n2 = n2 + n2;
+            a = 0;
+
+            for (j = 0; j < n1; j++) {
+                c = (float) cos[a];
+                s = (float) sin[a];
+                a += 1 << (m - i - 1);
+
+                for (k = j; k < n; k = k + n2) {
+                    t1 = c * x[k + n1] - s * y[k + n1];
+                    t2 = s * x[k + n1] + c * y[k + n1];
+                    x[k + n1] = x[k] - t1;
+                    y[k + n1] = y[k] - t2;
+                    x[k] = x[k] + t1;
+                    y[k] = y[k] + t2;
+                }
+            }
+        }
+    }
+}

package/android/src/main/java/com/lovegaoshi/kotlinaudio/utils/Utils.kt

@@ -0,0 +1,113 @@
+package com.lovegaoshi.kotlinaudio.utils
+
+import android.annotation.SuppressLint
+import android.content.ContentResolver
+import android.content.ContentUris
+import android.content.ContentValues
+import android.graphics.Bitmap
+import android.graphics.BitmapFactory
+import android.media.MediaMetadataRetriever
+import android.net.Uri
+import android.os.Build
+import android.os.Environment
+import android.provider.MediaStore
+import androidx.annotation.RequiresApi
+import java.io.OutputStream
+
+fun isUriLocalFile(uri: Uri?): Boolean {
+    if (uri == null) return false
+    val scheme = uri.scheme
+    val host = uri.host
+    if((scheme == "http" || scheme == "https") && (host == "localhost" || host == "127.0.0.1" || host == "[::1]"))
+    {
+        return false
+    }
+    return scheme == null
+            || scheme == ContentResolver.SCHEME_FILE
+            || scheme == ContentResolver.SCHEME_ANDROID_RESOURCE
+            || scheme == ContentResolver.SCHEME_CONTENT
+            || scheme == "res" || host == null
+}
+
+const val bitmapCoverFileName = "APMCover.png"
+val bitmapCoverDir = "${Environment.DIRECTORY_PICTURES}/APMCache/"
+
+
+@RequiresApi(Build.VERSION_CODES.R)
+@SuppressLint("Range")
+fun findAPMCacheApi(contentResolver: ContentResolver, contentUri: Uri = MediaStore.Images.Media.EXTERNAL_CONTENT_URI): Uri? {
+    val selection = "${MediaStore.MediaColumns.RELATIVE_PATH}=?"
+    val selectionArgs = arrayOf(bitmapCoverDir)
+    val cursor = contentResolver.query(contentUri, null, selection,selectionArgs,null)
+    if (cursor != null && cursor.count > 0) {
+        while (cursor.moveToNext()) {
+            val filename = cursor.getString(cursor.getColumnIndex(MediaStore.MediaColumns.DISPLAY_NAME))
+            if (filename == bitmapCoverFileName) {
+                val id = cursor.getLong(cursor.getColumnIndex(MediaStore.MediaColumns._ID))
+                cursor.close()
+                return ContentUris.withAppendedId(contentUri, id)
+            }
+        }
+        cursor.close()
+    }
+    return null
+}
+
+@RequiresApi(Build.VERSION_CODES.R)
+fun getAPMCacheBitmapUri(contentResolver: ContentResolver, contentValues: ContentValues): Uri? {
+    val contentUri = MediaStore.Images.Media.EXTERNAL_CONTENT_URI
+    val mAPMUri = findAPMCacheApi(contentResolver, contentUri)
+    if (mAPMUri != null ) contentResolver.delete(mAPMUri, null)
+    return contentResolver.insert(contentUri, contentValues)
+}
+
+fun getEmbeddedBitmapArray(path: String?): ByteArray? {
+    if (path == null) return null
+    val mmr = MediaMetadataRetriever()
+    try {
+        mmr.setDataSource(path)
+        return mmr.embeddedPicture
+    } catch (e: Exception) {
+        return null
+    }
+}
+
+fun getEmbeddedBitmap(path: String?): Bitmap? {
+    val artworkData = getEmbeddedBitmapArray(path)
+    return if (artworkData == null) null else BitmapFactory.decodeByteArray(artworkData, 0, artworkData.size)
+}
+
+var cacheKeyG = ""
+// HACK: this will insert a png file at pictures/APMCache/APMCover.png.
+fun saveMediaCoverToPng(path: String?, contentResolver: ContentResolver, cacheKey: String): String? {
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+        if (cacheKey == cacheKeyG) {
+            return findAPMCacheApi(contentResolver).toString()
+        }
+        val contentValues = ContentValues().apply {
+            put(MediaStore.MediaColumns.DISPLAY_NAME, bitmapCoverFileName)
+            put(MediaStore.MediaColumns.MIME_TYPE, "image/png")
+            put(MediaStore.MediaColumns.RELATIVE_PATH, bitmapCoverDir)
+            put(MediaStore.MediaColumns.IS_PENDING, 1)
+        }
+        val imageUri = getAPMCacheBitmapUri(contentResolver, contentValues)
+        val bitmap = getEmbeddedBitmap(path) ?: return null
+        cacheKeyG = cacheKey
+        var fos: OutputStream?
+
+        contentResolver.also { resolver ->
+            fos = imageUri?.let { resolver.openOutputStream(it) }
+        }
+        // TODO: add error handling
+        if (imageUri == null) return null
+        fos?.use { bitmap.compress(Bitmap.CompressFormat.PNG, 70, it) }
+        contentValues.clear()
+        contentValues.put(MediaStore.Video.Media.IS_PENDING, 0)
+        contentResolver.update(imageUri, contentValues, null, null)
+        return imageUri.toString()
+    }
+    return null
+    // TODO: does this insert without overwriting?
+    // return MediaStore.Images.Media.insertImage(contentResolver, bitmap,
+     //   bitmapCoverFileName,"APMCover")
+}

package/android/src/main/res/drawable/baseline_repeat_24.xml

@@ -0,0 +1,5 @@
+<vector android:autoMirrored="true" android:height="24dp"
+    android:tint="#FFFFFF" android:viewportHeight="24"
+    android:viewportWidth="24" android:width="24dp" xmlns:android="http://schemas.android.com/apk/res/android">
+    <path android:fillColor="@android:color/white" android:pathData="M7,7h10v3l4,-4 -4,-4v3L5,5v6h2L7,7zM17,17L7,17v-3l-4,4 4,4v-3h12v-6h-2v4z"/>
+</vector>

package/android/src/main/res/drawable/baseline_repeat_one_24.xml

@@ -0,0 +1,5 @@
+<vector android:autoMirrored="true" android:height="24dp"
+    android:tint="#FFFFFF" android:viewportHeight="24"
+    android:viewportWidth="24" android:width="24dp" xmlns:android="http://schemas.android.com/apk/res/android">
+    <path android:fillColor="@android:color/white" android:pathData="M7,7h10v3l4,-4 -4,-4v3L5,5v6h2L7,7zM17,17L7,17v-3l-4,4 4,4v-3h12v-6h-2v4zM13,15L13,9h-1l-2,1v1h1.5v4L13,15z"/>
+</vector>

package/android/src/main/res/drawable/forward.xml

@@ -0,0 +1,5 @@
+<vector android:autoMirrored="true" android:height="24dp"
+    android:tint="#FFFFFF" android:viewportHeight="24"
+    android:viewportWidth="24" android:width="24dp" xmlns:android="http://schemas.android.com/apk/res/android">
+    <path android:fillColor="@android:color/white" android:pathData="M18,13c0,3.31 -2.69,6 -6,6s-6,-2.69 -6,-6s2.69,-6 6,-6v4l5,-5l-5,-5v4c-4.42,0 -8,3.58 -8,8c0,4.42 3.58,8 8,8c4.42,0 8,-3.58 8,-8H18z"/>
+    </vector>

package/android/src/main/res/drawable/heart_24px.xml

@@ -0,0 +1,5 @@
+<vector android:autoMirrored="true" android:height="24dp"
+    android:viewportHeight="960" android:viewportWidth="960"
+    android:width="24dp" xmlns:android="http://schemas.android.com/apk/res/android">
+    <path android:fillColor="@android:color/white" android:pathData="M480,840L422,788Q321,697 255,631Q189,565 150,512.5Q111,460 95.5,416Q80,372 80,326Q80,232 143,169Q206,106 300,106Q352,106 399,128Q446,150 480,190Q514,150 561,128Q608,106 660,106Q754,106 817,169Q880,232 880,326Q880,372 864.5,416Q849,460 810,512.5Q771,565 705,631Q639,697 538,788L480,840Z"/>
+</vector>

package/android/src/main/res/drawable/hearte_24px.xml

@@ -0,0 +1,5 @@
+<vector android:autoMirrored="true" android:height="24dp"
+    android:viewportHeight="960" android:viewportWidth="960"
+    android:width="24dp" xmlns:android="http://schemas.android.com/apk/res/android">
+    <path android:fillColor="@android:color/white" android:pathData="M480,840L422,788Q321,697 255,631Q189,565 150,512.5Q111,460 95.5,416Q80,372 80,326Q80,232 143,169Q206,106 300,106Q352,106 399,128Q446,150 480,190Q514,150 561,128Q608,106 660,106Q754,106 817,169Q880,232 880,326Q880,372 864.5,416Q849,460 810,512.5Q771,565 705,631Q639,697 538,788L480,840ZM480,732Q576,646 638,584.5Q700,523 736,477.5Q772,432 786,396.5Q800,361 800,326Q800,266 760,226Q720,186 660,186Q613,186 573,212.5Q533,239 518,280L518,280L442,280L442,280Q427,239 387,212.5Q347,186 300,186Q240,186 200,226Q160,266 160,326Q160,361 174,396.5Q188,432 224,477.5Q260,523 322,584.5Q384,646 480,732ZM480,459Q480,459 480,459Q480,459 480,459Q480,459 480,459Q480,459 480,459Q480,459 480,459Q480,459 480,459Q480,459 480,459Q480,459 480,459L480,459L480,459L480,459Q480,459 480,459Q480,459 480,459Q480,459 480,459Q480,459 480,459Q480,459 480,459Q480,459 480,459Q480,459 480,459Q480,459 480,459Z"/>
+</vector>

package/android/src/main/res/drawable/ifl_24px.xml

@@ -0,0 +1,5 @@
+<vector android:autoMirrored="true" android:height="24dp"
+    android:viewportHeight="960" android:viewportWidth="960"
+    android:width="24dp" xmlns:android="http://schemas.android.com/apk/res/android">
+    <path android:fillColor="@android:color/white" android:pathData="M640,700Q665,700 682.5,682.5Q700,665 700,640Q700,615 682.5,597.5Q665,580 640,580Q615,580 597.5,597.5Q580,615 580,640Q580,665 597.5,682.5Q615,700 640,700ZM480,540Q505,540 522.5,522.5Q540,505 540,480Q540,455 522.5,437.5Q505,420 480,420Q455,420 437.5,437.5Q420,455 420,480Q420,505 437.5,522.5Q455,540 480,540ZM320,380Q345,380 362.5,362.5Q380,345 380,320Q380,295 362.5,277.5Q345,260 320,260Q295,260 277.5,277.5Q260,295 260,320Q260,345 277.5,362.5Q295,380 320,380ZM200,840Q167,840 143.5,816.5Q120,793 120,760L120,200Q120,167 143.5,143.5Q167,120 200,120L760,120Q793,120 816.5,143.5Q840,167 840,200L840,760Q840,793 816.5,816.5Q793,840 760,840L200,840ZM200,760L760,760Q760,760 760,760Q760,760 760,760L760,200Q760,200 760,200Q760,200 760,200L200,200Q200,200 200,200Q200,200 200,200L200,760Q200,760 200,760Q200,760 200,760ZM200,200L200,200Q200,200 200,200Q200,200 200,200L200,760Q200,760 200,760Q200,760 200,760L200,760Q200,760 200,760Q200,760 200,760L200,200Q200,200 200,200Q200,200 200,200Z"/>
+</vector>

package/android/src/main/res/drawable/rewind.xml

@@ -0,0 +1,5 @@
+<vector android:autoMirrored="true" android:height="24dp"
+    android:tint="#FFFFFF" android:viewportHeight="24"
+    android:viewportWidth="24" android:width="24dp" xmlns:android="http://schemas.android.com/apk/res/android">
+    <path android:fillColor="@android:color/white" android:pathData="M12,5V1L7,6l5,5V7c3.31,0 6,2.69 6,6s-2.69,6 -6,6 -6,-2.69 -6,-6H4c0,4.42 3.58,8 8,8s8,-3.58 8,-8 -3.58,-8 -8,-8z"/>
+</vector>

package/android/src/main/res/drawable/shuffle_24px.xml

@@ -0,0 +1,5 @@
+<vector android:autoMirrored="true" android:height="24dp"
+    android:viewportHeight="960" android:viewportWidth="960"
+    android:width="24dp" xmlns:android="http://schemas.android.com/apk/res/android">
+    <path android:fillColor="@android:color/white" android:pathData="M560,800L560,720L664,720L537,593L594,536L720,662L720,560L800,560L800,800L560,800ZM216,800L160,744L664,240L560,240L560,160L800,160L800,400L720,400L720,296L216,800ZM367,423L160,216L216,160L423,367L367,423Z"/>
+</vector>

package/android/src/main/res/values/strings.xml

@@ -1,6 +1,5 @@
 <resources>
-    <string name="play">Play</string>
+    <string name="rntp_temporary_channel_id">rntp_temporary_channel</string>
     <string name="playback_channel_name">Now Playing</string>
-    <string name="pause">Pause</string>
-</resources>
-
+    <string name="rntp_temporary_channel_name">temporary_channel</string>
+</resources>

package/android/src/main/res/xml/automotive_app_desc.xml

@@ -0,0 +1,3 @@
+<automotiveApp>
+    <uses name="media"/>
+</automotiveApp>

package/ios/Example/SwiftAudio/Assets.xcassets/22AMI.imageset/Contents.json

@@ -0,0 +1,21 @@
+{
+  "images" : [
+    {
+      "filename" : "22AMillion.jpg",
+      "idiom" : "universal",
+      "scale" : "1x"
+    },
+    {
+      "idiom" : "universal",
+      "scale" : "2x"
+    },
+    {
+      "idiom" : "universal",
+      "scale" : "3x"
+    }
+  ],
+  "info" : {
+    "author" : "xcode",
+    "version" : 1
+  }
+}

package/ios/Example/SwiftAudio/Assets.xcassets/AccentColor.colorset/Contents.json

@@ -0,0 +1,11 @@
+{
+  "colors" : [
+    {
+      "idiom" : "universal"
+    }
+  ],
+  "info" : {
+    "author" : "xcode",
+    "version" : 1
+  }
+}