diff --git a/modules/astra-library-scanner/android/src/main/java/expo/modules/astralibraryscanner/AstraLibraryScannerModule.kt b/modules/astra-library-scanner/android/src/main/java/expo/modules/astralibraryscanner/AstraLibraryScannerModule.kt index f582291..c15f849 100644 --- a/modules/astra-library-scanner/android/src/main/java/expo/modules/astralibraryscanner/AstraLibraryScannerModule.kt +++ b/modules/astra-library-scanner/android/src/main/java/expo/modules/astralibraryscanner/AstraLibraryScannerModule.kt @@ -3,12 +3,16 @@ package expo.modules.astralibraryscanner import android.content.Context import android.content.Intent import android.media.AudioFormat +import android.media.MediaCodec import android.media.MediaExtractor import android.media.MediaFormat import android.media.MediaMetadataRetriever import android.net.Uri import android.os.Build import android.provider.DocumentsContract +import java.nio.ByteOrder +import kotlin.math.max +import kotlin.math.sqrt import expo.modules.kotlin.exception.Exceptions import expo.modules.kotlin.functions.Coroutine import expo.modules.kotlin.modules.Module @@ -37,6 +41,9 @@ class AstraLibraryScannerModule : Module() { // read and hashed once, not once per track. private val coverHashMemo = ConcurrentHashMap() + // Waveform decode is whole-file and CPU-heavy; throttle concurrent decodes. + private val waveformSemaphore = Semaphore(2) + override fun definition() = ModuleDefinition { Name("AstraLibraryScanner") @@ -55,6 +62,15 @@ class AstraLibraryScannerModule : Module() { } } + // Offline waveform peaks for the seek bar: full PCM decode -> RMS per bin, + // normalized to [0,1]. Heavy (whole-file decode), so cap concurrency and + // run lazily per track on the JS side; results are cached in SQLite there. + AsyncFunction("extractWaveform") Coroutine { uri: String, bins: Int -> + waveformSemaphore.withPermit { + withContext(Dispatchers.IO) { extractWaveform(uri, if (bins > 0) bins else 512) } + } + } + Function("getArtworkDirPath") { artworkDir().absolutePath } @@ -267,6 +283,158 @@ class AstraLibraryScannerModule : Module() { return result } + // --------------------------------------------------------------------------- + // Waveform peaks (offline RMS bins) + // --------------------------------------------------------------------------- + + // Decodes the whole file to PCM and accumulates RMS energy per bin (mirrors + // desktop waveformExtractor.extractWaveformPeaks), normalized to [0,1]. Returns + // an empty array on any failure (caller falls back to a flat seek bar). + private fun extractWaveform(uriStr: String, bins: Int): FloatArray { + val context = requireContext() + val uri = Uri.parse(uriStr) + val extractor = MediaExtractor() + var codec: MediaCodec? = null + try { + extractor.setDataSource(context, uri, null) + + var trackFormat: MediaFormat? = null + var trackIndex = -1 + for (i in 0 until extractor.trackCount) { + val f = extractor.getTrackFormat(i) + if (f.getString(MediaFormat.KEY_MIME)?.startsWith("audio/") == true) { + trackFormat = f; trackIndex = i; break + } + } + val format = trackFormat ?: return FloatArray(0) + extractor.selectTrack(trackIndex) + + val sampleRate = + if (format.containsKey(MediaFormat.KEY_SAMPLE_RATE)) format.getInteger(MediaFormat.KEY_SAMPLE_RATE) else 44100 + val durationUs = + if (format.containsKey(MediaFormat.KEY_DURATION)) format.getLong(MediaFormat.KEY_DURATION) else 0L + val totalFrames = max(1L, (durationUs / 1_000_000.0 * sampleRate).toLong()) + var channelCount = + if (format.containsKey(MediaFormat.KEY_CHANNEL_COUNT)) format.getInteger(MediaFormat.KEY_CHANNEL_COUNT) else 2 + var pcmFloat = false + + val sumSquares = DoubleArray(bins) + val counts = LongArray(bins) + + codec = MediaCodec.createDecoderByType(format.getString(MediaFormat.KEY_MIME)!!) + codec.configure(format, null, null, 0) + codec.start() + + val info = MediaCodec.BufferInfo() + var sawInputEOS = false + var sawOutputEOS = false + var frame = 0L + + while (!sawOutputEOS) { + if (!sawInputEOS) { + val inIndex = codec.dequeueInputBuffer(10_000) + if (inIndex >= 0) { + val inBuf = codec.getInputBuffer(inIndex)!! + val size = extractor.readSampleData(inBuf, 0) + if (size < 0) { + codec.queueInputBuffer(inIndex, 0, 0, 0, MediaCodec.BUFFER_FLAG_END_OF_STREAM) + sawInputEOS = true + } else { + codec.queueInputBuffer(inIndex, 0, size, extractor.sampleTime, 0) + extractor.advance() + } + } + } + + val outIndex = codec.dequeueOutputBuffer(info, 10_000) + if (outIndex >= 0) { + if (info.flags and MediaCodec.BUFFER_FLAG_END_OF_STREAM != 0) sawOutputEOS = true + if (info.size > 0) { + val out = codec.getOutputBuffer(outIndex)!! + out.position(info.offset) + out.limit(info.offset + info.size) + out.order(ByteOrder.nativeOrder()) + frame = accumulate(out, pcmFloat, channelCount, bins, totalFrames, frame, sumSquares, counts) + } + codec.releaseOutputBuffer(outIndex, false) + } else if (outIndex == MediaCodec.INFO_OUTPUT_FORMAT_CHANGED) { + val nf = codec.outputFormat + if (nf.containsKey(MediaFormat.KEY_CHANNEL_COUNT)) channelCount = nf.getInteger(MediaFormat.KEY_CHANNEL_COUNT) + if (nf.containsKey(MediaFormat.KEY_PCM_ENCODING)) { + pcmFloat = nf.getInteger(MediaFormat.KEY_PCM_ENCODING) == AudioFormat.ENCODING_PCM_FLOAT + } + } + } + + val peaks = FloatArray(bins) + var globalMax = 0.0 + for (i in 0 until bins) { + if (counts[i] > 0) { + val rms = sqrt(sumSquares[i] / counts[i]) + peaks[i] = rms.toFloat() + if (rms > globalMax) globalMax = rms + } + } + if (globalMax > 0) { + for (i in 0 until bins) peaks[i] = (peaks[i] / globalMax).toFloat() + } + return peaks + } catch (_: Throwable) { + return FloatArray(0) + } finally { + try { codec?.stop() } catch (_: Throwable) {} + try { codec?.release() } catch (_: Throwable) {} + try { extractor.release() } catch (_: Throwable) {} + } + } + + // Folds one decoded PCM buffer into the per-bin RMS accumulators. Handles + // 16-bit (default) and float PCM. Returns the updated running frame index. + private fun accumulate( + out: java.nio.ByteBuffer, + pcmFloat: Boolean, + channelCount: Int, + bins: Int, + totalFrames: Long, + startFrame: Long, + sumSquares: DoubleArray, + counts: LongArray + ): Long { + var frame = startFrame + if (pcmFloat) { + val fb = out.asFloatBuffer() + val n = fb.remaining() + var k = 0 + while (k < n) { + val bin = ((frame.toDouble() / totalFrames) * bins).toInt().coerceIn(0, bins - 1) + var c = 0 + while (c < channelCount && k < n) { + val s = fb.get(k).toDouble() + sumSquares[bin] += s * s + k++; c++ + } + counts[bin] += c.toLong() + frame++ + } + } else { + val sb = out.asShortBuffer() + val n = sb.remaining() + var k = 0 + while (k < n) { + val bin = ((frame.toDouble() / totalFrames) * bins).toInt().coerceIn(0, bins - 1) + var c = 0 + while (c < channelCount && k < n) { + val s = sb.get(k) / 32768.0 + sumSquares[bin] += s * s + k++; c++ + } + counts[bin] += c.toLong() + frame++ + } + } + return frame + } + private fun readBitsPerSample(format: MediaFormat): Int? { // The framework FLAC/WAV extractors expose "bits-per-sample"; other codecs // may expose a PCM encoding instead. Both are best-effort. diff --git a/modules/astra-library-scanner/index.ts b/modules/astra-library-scanner/index.ts index eefde6a..304aeab 100644 --- a/modules/astra-library-scanner/index.ts +++ b/modules/astra-library-scanner/index.ts @@ -55,6 +55,11 @@ type AstraLibraryScannerEvents = { declare class AstraLibraryScannerModuleType extends NativeModule { listAudioFiles(treeUri: string, extensions: string[]): Promise; extractMetadata(files: { uri: string; coverUri?: string | null }[]): Promise; + /** + * Decode the file's PCM and return `bins` RMS peaks normalized to [0,1] for + * the waveform seek bar. Whole-file decode (heavy); returns [] on failure. + */ + extractWaveform(uri: string, bins: number): Promise; getArtworkDirPath(): string; getPersistedTreeUris(): string[]; takePersistableUriPermission(uri: string): Promise; diff --git a/modules/astra-scope/android/CMakeLists.txt b/modules/astra-scope/android/CMakeLists.txt new file mode 100644 index 0000000..612f0de --- /dev/null +++ b/modules/astra-scope/android/CMakeLists.txt @@ -0,0 +1,19 @@ +cmake_minimum_required(VERSION 3.13) +project(astrascope) + +set(CMAKE_CXX_STANDARD 17) +set(CMAKE_CXX_STANDARD_REQUIRED ON) + +# Pure portable DSP + a plain-JNI bridge. No prefab / ReactAndroid / fbjni: +# comes from the NDK sysroot and we only link liblog. +add_library(astrascope SHARED + ../cpp/dsp_utils.cpp + ../cpp/spectrum.cpp + ../cpp/oscilloscope.cpp + ../cpp/vectorscope.cpp + ../cpp/scope_jni.cpp) + +target_include_directories(astrascope PRIVATE ../cpp) + +find_library(log-lib log) +target_link_libraries(astrascope ${log-lib}) diff --git a/modules/astra-scope/android/build.gradle b/modules/astra-scope/android/build.gradle new file mode 100644 index 0000000..9b82df4 --- /dev/null +++ b/modules/astra-scope/android/build.gradle @@ -0,0 +1,35 @@ +plugins { + id 'com.android.library' + id 'expo-module-gradle-plugin' +} + +group = 'expo.modules.astrascope' +version = '0.1.0' + +def reactNativeArchitectures() { + def value = project.getProperties().get("reactNativeArchitectures") + return value ? value.split(",") : ["armeabi-v7a", "arm64-v8a", "x86", "x86_64"] +} + +android { + namespace "expo.modules.astrascope" + defaultConfig { + versionCode 1 + versionName "0.1.0" + externalNativeBuild { + cmake { + cppFlags "-O3 -std=c++17 -fexceptions -frtti" + abiFilters(*reactNativeArchitectures()) + arguments "-DANDROID_STL=c++_shared" + } + } + } + externalNativeBuild { + cmake { + path "CMakeLists.txt" + } + } + lintOptions { + abortOnError false + } +} diff --git a/modules/astra-scope/android/src/main/AndroidManifest.xml b/modules/astra-scope/android/src/main/AndroidManifest.xml new file mode 100644 index 0000000..bdae66c --- /dev/null +++ b/modules/astra-scope/android/src/main/AndroidManifest.xml @@ -0,0 +1,2 @@ + + diff --git a/modules/astra-scope/android/src/main/java/expo/modules/astrascope/AstraScopeModule.kt b/modules/astra-scope/android/src/main/java/expo/modules/astrascope/AstraScopeModule.kt new file mode 100644 index 0000000..6bb26db --- /dev/null +++ b/modules/astra-scope/android/src/main/java/expo/modules/astrascope/AstraScopeModule.kt @@ -0,0 +1,28 @@ +package expo.modules.astrascope + +import expo.modules.kotlin.modules.Module +import expo.modules.kotlin.modules.ModuleDefinition +import expo.modules.kotlin.typedarray.Float32Array + +/** + * JS surface for the realtime scope. Both functions are synchronous (JSI): + * [getSpectrumFrame] is pulled once per render frame from the JS thread and + * fills a JS-preallocated Float32Array in place (no per-frame allocation, no + * event-emitter traffic). The PCM that feeds it arrives on the audio thread via + * the vendored kotlin-audio tap -> [ScopeBridge]. + */ +class AstraScopeModule : Module() { + override fun definition() = ModuleDefinition { + Name("AstraScope") + + // Gate the audio-thread tap (off when backgrounded/paused/reduced-motion). + Function("setActive") { active: Boolean -> + ScopeBridge.active = active + } + + // Fill `out` with the latest dB spectrum; returns the number of bins written. + Function("getSpectrumFrame") { out: Float32Array -> + ScopeBridge.nativeFillSpectrum(out.toDirectBuffer(), out.length) + } + } +} diff --git a/modules/astra-scope/android/src/main/java/expo/modules/astrascope/ScopeBridge.kt b/modules/astra-scope/android/src/main/java/expo/modules/astrascope/ScopeBridge.kt new file mode 100644 index 0000000..152f38b --- /dev/null +++ b/modules/astra-scope/android/src/main/java/expo/modules/astrascope/ScopeBridge.kt @@ -0,0 +1,36 @@ +package expo.modules.astrascope + +/** + * Process-wide bridge to the native scope driver (libastrascope.so). + * + * Loaded once here; the vendored kotlin-audio PCM tap (ScopeTapAudioProcessor) + * calls [nativePushFrames]/[nativeConfigure] from the ExoPlayer audio thread, + * while [AstraScopeModule] calls [nativeFillSpectrum] from the JS thread. The + * native side is single-producer/single-consumer and lock-free on the audio + * path; see scope_ring.h. + * + * [active] gates the tap so a backgrounded/paused app pays ~zero in the audio + * callback. The lifecycle owner (RN side) flips it via AstraScope.setActive(). + */ +object ScopeBridge { + init { + System.loadLibrary("astrascope") + } + + /** Set by the lifecycle owner; checked cheaply in the audio callback. */ + @Volatile + var active: Boolean = false + + /** Audio thread. Tell the analyzer the stream's sample rate / channels. */ + external fun nativeConfigure(sampleRate: Int, channelCount: Int) + + /** Audio thread. Push interleaved float PCM (frameCount * channelCount). */ + external fun nativePushFrames(frames: FloatArray, frameCount: Int, channelCount: Int) + + /** + * Render thread. Fill `buffer` (a direct ByteBuffer over the JS Float32Array's + * memory) with the latest dB spectrum, up to `capacityFloats` floats. + * Returns the number of bins written. Zero-copy: writes straight into JS memory. + */ + external fun nativeFillSpectrum(buffer: java.nio.ByteBuffer, capacityFloats: Int): Int +} diff --git a/modules/astra-scope/cpp/dsp_utils.cpp b/modules/astra-scope/cpp/dsp_utils.cpp new file mode 100644 index 0000000..3fba83b --- /dev/null +++ b/modules/astra-scope/cpp/dsp_utils.cpp @@ -0,0 +1,433 @@ +#define _USE_MATH_DEFINES +#include "dsp_utils.h" +#include +#include +#include + +namespace DSP { + +// FFT Implementation +FFT::FFT(size_t size) : size_(size) { + // Precompute twiddle factors + twiddles_.resize(size / 2); + for (size_t i = 0; i < size / 2; i++) { + float angle = -2.0f * M_PI * i / size; + twiddles_[i] = std::complex(cosf(angle), sinf(angle)); + } + buffer_.resize(size); + scratch_.resize(size); +} + +void FFT::bitReverse(std::complex* data) { + size_t n = size_; + for (size_t i = 1, j = 0; i < n; i++) { + size_t bit = n >> 1; + while (j & bit) { + j ^= bit; + bit >>= 1; + } + j ^= bit; + if (i < j) { + std::swap(data[i], data[j]); + } + } +} + +void FFT::forward(const float* input, std::complex* output) { + // Copy input to internal buffer + for (size_t i = 0; i < size_; i++) { + buffer_[i] = std::complex(input[i], 0.0f); + } + + bitReverse(buffer_.data()); + + // Cooley-Tukey FFT + for (size_t len = 2; len <= size_; len *= 2) { + size_t halfLen = len / 2; + size_t step = size_ / len; + for (size_t i = 0; i < size_; i += len) { + for (size_t j = 0; j < halfLen; j++) { + std::complex t = twiddles_[j * step] * buffer_[i + j + halfLen]; + buffer_[i + j + halfLen] = buffer_[i + j] - t; + buffer_[i + j] = buffer_[i + j] + t; + } + } + } + + memcpy(output, buffer_.data(), size_ * sizeof(std::complex)); +} + +void FFT::forward(const float* input, float* magnitudes) { + // Use scratch buffer for complex output to avoid allocation + forward(input, scratch_.data()); + + // Calculate magnitudes (only first half is useful) + // Scale by 2/N for correct magnitude + float scale = 2.0f / size_; + for (size_t i = 0; i < size_ / 2; i++) { + magnitudes[i] = std::abs(scratch_[i]) * scale; + } +} + +// BiquadFilter Implementation +BiquadFilter::BiquadFilter() + : b0_(1), b1_(0), b2_(0), a1_(0), a2_(0) + , x1_(0), x2_(0), y1_(0), y2_(0) {} + +void BiquadFilter::setLowpass(float frequency, float sampleRate, float Q) { + float omega = 2.0f * M_PI * frequency / sampleRate; + float sinOmega = sinf(omega); + float cosOmega = cosf(omega); + float alpha = sinOmega / (2.0f * Q); + + float a0 = 1.0f + alpha; + b0_ = (1.0f - cosOmega) / 2.0f / a0; + b1_ = (1.0f - cosOmega) / a0; + b2_ = (1.0f - cosOmega) / 2.0f / a0; + a1_ = -2.0f * cosOmega / a0; + a2_ = (1.0f - alpha) / a0; +} + +void BiquadFilter::setBandpass(float frequency, float sampleRate, float Q) { + float omega = 2.0f * M_PI * frequency / sampleRate; + float sinOmega = sinf(omega); + float cosOmega = cosf(omega); + float alpha = sinOmega / (2.0f * Q); + + float a0 = 1.0f + alpha; + b0_ = alpha / a0; + b1_ = 0.0f; + b2_ = -alpha / a0; + a1_ = -2.0f * cosOmega / a0; + a2_ = (1.0f - alpha) / a0; +} + +void BiquadFilter::setHighShelf(float frequency, float sampleRate, float gainDB, float Q) { + float A = powf(10.0f, gainDB / 40.0f); // sqrt(10^(dB/20)) + float omega = 2.0f * M_PI * frequency / sampleRate; + float sinOmega = sinf(omega); + float cosOmega = cosf(omega); + float alpha = sinOmega / (2.0f * Q); + + float a0 = (A + 1.0f) - (A - 1.0f) * cosOmega + 2.0f * sqrtf(A) * alpha; + b0_ = A * ((A + 1.0f) + (A - 1.0f) * cosOmega + 2.0f * sqrtf(A) * alpha) / a0; + b1_ = -2.0f * A * ((A - 1.0f) + (A + 1.0f) * cosOmega) / a0; + b2_ = A * ((A + 1.0f) + (A - 1.0f) * cosOmega - 2.0f * sqrtf(A) * alpha) / a0; + a1_ = 2.0f * ((A - 1.0f) - (A + 1.0f) * cosOmega) / a0; + a2_ = ((A + 1.0f) - (A - 1.0f) * cosOmega - 2.0f * sqrtf(A) * alpha) / a0; +} + +float BiquadFilter::process(float input) { + float output = b0_ * input + b1_ * x1_ + b2_ * x2_ - a1_ * y1_ - a2_ * y2_; + x2_ = x1_; + x1_ = input; + y2_ = y1_; + y1_ = output; + + // Denormal protection + if (std::abs(y1_) < 1e-20f) y1_ = 0.0f; + if (std::abs(y2_) < 1e-20f) y2_ = 0.0f; + + return output; +} + +void BiquadFilter::reset() { + x1_ = x2_ = y1_ = y2_ = 0.0f; +} + +void BiquadFilter::processBuffer(const float* input, float* output, size_t length, bool bidirectional) { + reset(); + + // Forward pass + for (size_t i = 0; i < length; i++) { + output[i] = process(input[i]); + } + + if (bidirectional) { + // Backward pass for zero phase delay + reset(); + for (int i = length - 1; i >= 0; i--) { + output[i] = process(output[i]); + } + } +} + +// FIRFilter Implementation +FIRFilter::FIRFilter() : idx_(0), order_(0) {} + +// Modified Bessel function of the first kind, order 0 (I0) +// Approximation from Abramowitz and Stegun +double FIRFilter::besselI0(double x) { + double ax = std::abs(x); + if (ax <= 3.75) { + double y = (x / 3.75); + y *= y; + return 1.0 + y * (3.5156229 + y * (3.0899424 + y * (1.2067492 + + y * (0.2659732 + y * (0.0360768 + y * 0.0045813))))); + } else { + double y = 3.75 / ax; + return (std::exp(ax) / std::sqrt(ax)) * (0.39894228 + + y * (0.01328592 + y * (0.00225319 + y * (-0.00157565 + + y * (0.00916281 + y * (-0.02057706 + y * (0.02635537 + + y * (-0.01647633 + y * 0.00392377)))))))); + } +} + +std::vector FIRFilter::kaiserWindow(size_t length, float beta) { + std::vector window(length); + if (length == 0) return window; + const double denom = besselI0(static_cast(beta)); + const double M = static_cast(length - 1); + for (size_t n = 0; n < length; ++n) { + double ratio = (M == 0.0) ? 0.0 : (2.0 * static_cast(n) / M - 1.0); + double val = besselI0(static_cast(beta) * + std::sqrt(std::max(0.0, 1.0 - ratio * ratio))) / denom; + window[n] = static_cast(val); + } + return window; +} + +void FIRFilter::designBandpass(float centerFreq, float bandwidth, float sampleRate, float sidelobeAtten) { + // Kaiser beta from sidelobe attenuation + float beta = sidelobeAtten < 21.0f ? 0.0f + : sidelobeAtten < 50.0f ? 0.5842f * powf(sidelobeAtten - 21.0f, 0.4f) + + 0.07886f * (sidelobeAtten - 21.0f) + : 0.1102f * (sidelobeAtten - 8.7f); + + // Normalized frequencies + float wc1 = 2.0f * static_cast(M_PI) * (centerFreq - bandwidth / 2.0f) / sampleRate; + float wc2 = 2.0f * static_cast(M_PI) * (centerFreq + bandwidth / 2.0f) / sampleRate; + wc1 = std::max(wc1, 0.001f); + wc2 = std::min(wc2, static_cast(M_PI) - 0.001f); + + // Calculate filter order + float deltaF = (wc2 - wc1) / static_cast(M_PI); + int order = static_cast((sidelobeAtten - 8) / (2.285 * deltaF * M_PI)); + order = std::clamp(order, 1, 512); + order_ = static_cast(order); + + size_t len = order + 1; + size_t centerTap = len / 2; + + // Ideal bandpass impulse response + std::vector ideal(len); + for (size_t i = 0; i < len; ++i) { + if (i == centerTap) { + ideal[i] = (wc2 - wc1) / static_cast(M_PI); + } else { + float n = static_cast(static_cast(i) - static_cast(centerTap)); + ideal[i] = (sinf(wc2 * n) - sinf(wc1 * n)) / (static_cast(M_PI) * n); + } + } + + // Apply Kaiser window + std::vector window = kaiserWindow(len, beta); + coeffs_.resize(len); + for (size_t i = 0; i < len; ++i) { + coeffs_[i] = ideal[i] * window[i]; + } + + // Normalize to unity gain at center frequency + float centerOmega = 2.0f * static_cast(M_PI) * centerFreq / sampleRate; + float response = 0.0f; + for (size_t i = 0; i < len; ++i) { + response += coeffs_[i] * cosf(centerOmega * + (static_cast(i) - static_cast(centerTap))); + } + if (std::abs(response) > 1e-6f) { + float scale = 1.0f / response; + for (float& coeff : coeffs_) { + coeff *= scale; + } + } + + // Reset delay line + delay_.resize(len, 0.0f); + idx_ = 0; +} + +float FIRFilter::process(float input) { + if (coeffs_.empty()) return input; + + size_t nTaps = coeffs_.size(); + idx_ %= nTaps; + delay_[idx_] = input; + + float out = 0.0f; + size_t firstLen = nTaps - idx_; + + // Process first segment [idx_ .. end] + for (size_t i = 0; i < firstLen; ++i) { + out += coeffs_[i] * delay_[idx_ + i]; + } + // Process second segment [0 .. idx_-1] + for (size_t i = 0; i < idx_; ++i) { + out += coeffs_[firstLen + i] * delay_[i]; + } + + idx_ = (idx_ + 1) % nTaps; + return out; +} + +void FIRFilter::reset() { + std::fill(delay_.begin(), delay_.end(), 0.0f); + idx_ = 0; +} + +// Pitch detection using autocorrelation +float detectPitch(const float* data, size_t length, float sampleRate, float minFreq, float maxFreq) { + int minPeriod = static_cast(sampleRate / maxFreq); + int maxPeriod = static_cast(sampleRate / minFreq); + + maxPeriod = std::min(maxPeriod, static_cast(length / 2)); + if (maxPeriod <= minPeriod) return 0.0f; + + float bestCorrelation = -1.0f; + int bestPeriod = 0; + + // Use a simplified autocorrelation: only compute for lags in range + for (int period = minPeriod; period < maxPeriod; period++) { + float correlation = 0.0f; + float energy1 = 0.0f; + float energy2 = 0.0f; + + // Use fewer samples for performance, but enough for accuracy + int samples = std::min(static_cast(length) - period, 512); + + for (int i = 0; i < samples; i++) { + correlation += data[i] * data[i + period]; + energy1 += data[i] * data[i]; + energy2 += data[i + period] * data[i + period]; + } + + // Normalized correlation + if (energy1 > 1e-9f && energy2 > 1e-9f) { + float norm = sqrtf(energy1 * energy2); + correlation /= norm; + + if (correlation > bestCorrelation) { + bestCorrelation = correlation; + bestPeriod = period; + } + } + } + + // Threshold for valid pitch + if (bestCorrelation < 0.5f || bestPeriod == 0) { + return 0.0f; // No confident pitch found + } + + // Parabolic interpolation for sub-sample accuracy could be added here + // but basic integer period is often enough for visual stabilization + + return sampleRate / bestPeriod; +} + +// FFT-based pitch detection (more stable than autocorrelation) +float detectPitchFFT(const float* data, size_t length, float sampleRate, float minFreq, float maxFreq) { + // Use power-of-2 FFT size + size_t fftSize = 2048; + if (length < fftSize) { + fftSize = 1024; + if (length < fftSize) { + fftSize = 512; + } + } + + FFT fft(fftSize); + std::vector magnitudes(fftSize / 2); + + // Apply Hann window and run FFT + std::vector windowed(fftSize, 0.0f); + size_t copyLen = std::min(length, fftSize); + for (size_t i = 0; i < copyLen; i++) { + float win = 0.5f * (1.0f - cosf(2.0f * static_cast(M_PI) * i / fftSize)); + windowed[i] = data[i] * win; + } + fft.forward(windowed.data(), magnitudes.data()); + + // Find peak in frequency range + int minBin = std::max(1, static_cast(minFreq * fftSize / sampleRate)); + int maxBin = std::min(static_cast(fftSize / 2 - 1), static_cast(maxFreq * fftSize / sampleRate)); + + if (minBin >= maxBin) { + return 0.0f; + } + + float peakMag = 0.0f; + int peakBin = minBin; + for (int i = minBin; i <= maxBin; i++) { + if (magnitudes[i] > peakMag) { + peakMag = magnitudes[i]; + peakBin = i; + } + } + + // Check if peak is significant (avoid noise) + if (peakMag < 1e-6f) { + return 0.0f; + } + + // Quadratic interpolation for sub-bin accuracy + if (peakBin > 0 && peakBin < static_cast(fftSize / 2) - 1) { + float y1 = magnitudes[peakBin - 1]; + float y2 = magnitudes[peakBin]; + float y3 = magnitudes[peakBin + 1]; + float denom = y1 - 2.0f * y2 + y3; + if (std::abs(denom) > 1e-9f) { + float offset = 0.5f * (y1 - y3) / denom; + offset = std::clamp(offset, -0.5f, 0.5f); + return (static_cast(peakBin) + offset) * sampleRate / static_cast(fftSize); + } + } + + return static_cast(peakBin) * sampleRate / static_cast(fftSize); +} + +// Find zero-crossing trigger point (sub-sample precision) +// searches in [searchStart, searchEnd) +// Finds the STRONGEST (steepest slope) rising zero crossing for consistency +float findTriggerPoint(const float* data, size_t length, int searchStart, int searchEnd) { + searchStart = std::max(1, searchStart); // Need i-1 + searchEnd = std::min(static_cast(length), searchEnd); + + if (searchStart >= searchEnd) return -1.0f; + + // Find the zero crossing with the steepest positive slope + float bestSlope = 0.0f; + int bestIdx = -1; + + for (int i = searchStart; i < searchEnd; i++) { + float prev = data[i - 1]; + float curr = data[i]; + + // Rising zero crossing: prev < 0 and curr >= 0 + if (prev < 0.0f && curr >= 0.0f) { + float slope = curr - prev; // Always positive for rising crossing + if (slope > bestSlope) { + bestSlope = slope; + bestIdx = i; + } + } + } + + if (bestIdx < 0) return -1.0f; + + // Linear interpolation for sub-sample precision + float prev = data[bestIdx - 1]; + float curr = data[bestIdx]; + float t = -prev / (curr - prev); + return static_cast(bestIdx - 1) + t; +} + +// Calculate RMS +float calculateRMS(const float* data, size_t length) { + if (length == 0) return 0.0f; + float sum = 0.0f; + for (size_t i = 0; i < length; i++) { + sum += data[i] * data[i]; + } + return sqrtf(sum / length); +} + +} // namespace DSP diff --git a/modules/astra-scope/cpp/dsp_utils.h b/modules/astra-scope/cpp/dsp_utils.h new file mode 100644 index 0000000..92136bd --- /dev/null +++ b/modules/astra-scope/cpp/dsp_utils.h @@ -0,0 +1,91 @@ +#pragma once +#define _USE_MATH_DEFINES +#include +#ifndef M_PI +#define M_PI 3.14159265358979323846 +#endif + +#include +#include +#include + +namespace DSP { + +// Simple FFT implementation (Cooley-Tukey radix-2) +class FFT { +public: + explicit FFT(size_t size); + void forward(const float* input, float* magnitudes); + void forward(const float* input, std::complex* output); + size_t getSize() const { return size_; } + +private: + size_t size_; + std::vector> twiddles_; + std::vector> buffer_; // Reuse buffer to avoid allocations + std::vector> scratch_; // Scratch buffer if needed + void bitReverse(std::complex* data); +}; + +// Biquad filter for lowpass/bandpass +class BiquadFilter { +public: + BiquadFilter(); + void setLowpass(float frequency, float sampleRate, float Q = 0.707f); + void setBandpass(float frequency, float sampleRate, float Q = 2.0f); + void setHighShelf(float frequency, float sampleRate, float gainDB, float Q = 0.707f); + float process(float input); + void reset(); + + // Process entire buffer (bidirectional for zero phase) + void processBuffer(const float* input, float* output, size_t length, bool bidirectional = true); + +private: + float b0_, b1_, b2_; + float a1_, a2_; + float x1_, x2_; + float y1_, y2_; +}; + +// Linear-phase FIR filter for stable trigger detection +// Uses Kaiser-windowed bandpass design for consistent zero crossings +class FIRFilter { +public: + FIRFilter(); + + // Design Kaiser-windowed bandpass filter centered on frequency + void designBandpass(float centerFreq, float bandwidth, float sampleRate, float sidelobeAtten = 60.0f); + + // Process single sample + float process(float input); + + // Get filter delay (for phase compensation) + size_t getDelay() const { return order_ / 2; } + + // Reset filter state + void reset(); + +private: + std::vector coeffs_; + std::vector delay_; + size_t idx_; + size_t order_; + + // Kaiser window helpers + static std::vector kaiserWindow(size_t length, float beta); + static double besselI0(double x); +}; + +// Pitch detection using autocorrelation +float detectPitch(const float* data, size_t length, float sampleRate, float minFreq = 40.0f, float maxFreq = 2000.0f); + +// FFT-based pitch detection (more stable than autocorrelation) +float detectPitchFFT(const float* data, size_t length, float sampleRate, float minFreq = 40.0f, float maxFreq = 2000.0f); + +// Find zero-crossing trigger point with hysteresis/hold-off (sub-sample precision) +float findTriggerPoint(const float* data, size_t length, int searchStart, int searchEnd); + +// Calculate RMS +float calculateRMS(const float* data, size_t length); + +} // namespace DSP diff --git a/modules/astra-scope/cpp/oscilloscope.cpp b/modules/astra-scope/cpp/oscilloscope.cpp new file mode 100644 index 0000000..7d2a158 --- /dev/null +++ b/modules/astra-scope/cpp/oscilloscope.cpp @@ -0,0 +1,331 @@ +#include "oscilloscope.h" +#include +#include + +namespace Visualizer { + +Oscilloscope::Oscilloscope() + : sampleRate_(48000.0f) + , pitchLock_(true) + , displaySamples_(2048) + , writePos_(0) + , lastFilterPitch_(200.0f) + , lastTrigger_(0) + , smoothedPitch_(200.0f) + , pitchSamplesProcessed_(0) { + + // Initialize circular buffers + circularBuffer_.resize(OSCILLOSCOPE_BUFFER_SIZE, 0.0f); + filteredBuffer_.resize(OSCILLOSCOPE_BUFFER_SIZE, 0.0f); + + // Initialize FIR bandpass filter centered at 200Hz with 10% bandwidth (20Hz) + // Tight bandwidth removes harmonics, leaving only ONE rising zero crossing per period + bandpassFilter_.designBandpass(200.0f, 20.0f, sampleRate_, 60.0f); + + // Initialize high shelf for pitch analysis (-3dB at 400Hz, Q=0.71) + // Reduces high frequency interference with pitch detection + pitchAnalysisShelf_.setHighShelf(400.0f, sampleRate_, -3.0f, 0.71f); + + // Initialize analysis and render buffers + displayBuffer_.resize(OSCILLOSCOPE_BUFFER_SIZE, 0.0f); + visualBuffer_.resize(OSCILLOSCOPE_BUFFER_SIZE, 0.0f); + + // Initialize display filters (high shelf + cascaded lowpass for steep rolloff) + displayShelf_.setHighShelf(400.0f, sampleRate_, -3.0f, 0.71f); + displayLowpass1_.setLowpass(18000.0f, sampleRate_, 0.707f); + displayLowpass2_.setLowpass(18000.0f, sampleRate_, 0.707f); + + // Initialize pitch detection lowpass (cascaded for steep slope) + pitchLowpass1_.setLowpass(18000.0f, sampleRate_, 0.707f); + pitchLowpass2_.setLowpass(18000.0f, sampleRate_, 0.707f); +} + +void Oscilloscope::setSampleRate(float sampleRate) { + sampleRate_ = sampleRate; + // Redesign filter with new sample rate (10% bandwidth) + float bandwidth = lastFilterPitch_ * 0.1f; + bandpassFilter_.designBandpass(lastFilterPitch_, bandwidth, sampleRate_, 60.0f); + // Update high shelf for new sample rate + pitchAnalysisShelf_.setHighShelf(400.0f, sampleRate_, -3.0f, 0.71f); + + // Update display filters + displayShelf_.setHighShelf(400.0f, sampleRate_, -3.0f, 0.71f); + displayLowpass1_.setLowpass(18000.0f, sampleRate_, 0.707f); + displayLowpass2_.setLowpass(18000.0f, sampleRate_, 0.707f); + + // Update pitch detection lowpass + pitchLowpass1_.setLowpass(18000.0f, sampleRate_, 0.707f); + pitchLowpass2_.setLowpass(18000.0f, sampleRate_, 0.707f); +} + +void Oscilloscope::setPitchLock(bool enabled) { + pitchLock_ = enabled; +} + +void Oscilloscope::setDisplaySamples(int samples) { + displaySamples_ = std::clamp(samples, 64, static_cast(OSCILLOSCOPE_BUFFER_SIZE - 1)); +} + +// Push samples into circular buffer (called from AudioWorklet) +void Oscilloscope::pushSamples(const float* samples, size_t count) { + for (size_t i = 0; i < count; i++) { + // Store raw sample + circularBuffer_[writePos_] = samples[i]; + + // Apply FIR bandpass filter and store filtered sample + // Linear-phase filter provides consistent zero crossings + filteredBuffer_[writePos_] = bandpassFilter_.process(samples[i]); + + // Tracking path: cascaded lowpass only + float displaySample = displayLowpass1_.process(samples[i]); + displaySample = displayLowpass2_.process(displaySample); + displayBuffer_[writePos_] = displaySample; + + // Visual path: high shelf on top of tracking sample + float visualSample = displayShelf_.process(displaySample); + visualBuffer_[writePos_] = visualSample; + + writePos_ = (writePos_ + 1) % OSCILLOSCOPE_BUFFER_SIZE; + } +} + +// Update filtered buffer from circular buffer (for backwards compatibility) +void Oscilloscope::updateFiltered() { + // This is called when using snapshot mode - filter is applied in pushSamples for continuous mode +} + +// Find trigger by searching BACKWARDS from target position +// With tight bandpass filter (10% bandwidth), there's only ONE rising zero crossing per period +// So we simply take the FIRST valid crossing found - no phase tracking needed +float Oscilloscope::findTriggerBackwards(size_t target, size_t range) { + float periodSamples = sampleRate_ / smoothedPitch_; + + // Search backwards from target to find FIRST rising zero crossing + for (size_t i = 0; i < range && i < OSCILLOSCOPE_BUFFER_SIZE; i++) { + size_t pos = (target + OSCILLOSCOPE_BUFFER_SIZE - i) % OSCILLOSCOPE_BUFFER_SIZE; + size_t prev = (pos + OSCILLOSCOPE_BUFFER_SIZE - 1) % OSCILLOSCOPE_BUFFER_SIZE; + + float prevVal = filteredBuffer_[prev]; + float currVal = filteredBuffer_[pos]; + + // Rising zero crossing + if (prevVal < 0.0f && currVal >= 0.0f) { + // Check signal amplitude (look ahead ~1/4 period) + size_t lookAhead = std::clamp( + static_cast(periodSamples / 4.0f), + static_cast(4), + static_cast(256) + ); + + float peakAfter = 0.0f; + for (size_t j = 0; j < lookAhead; j++) { + size_t checkPos = (pos + j) % OSCILLOSCOPE_BUFFER_SIZE; + float val = std::abs(filteredBuffer_[checkPos]); + if (val > peakAfter) peakAfter = val; + } + + // Only accept if signal has significant amplitude + if (peakAfter > 0.01f) { + // Sub-sample interpolation for smooth rendering + float t = -prevVal / (currVal - prevVal); + return static_cast(prev) + t; + } + } + } + + return -1.0f; // No crossing found +} + +// Process using circular buffer (continuous capture mode) +OscilloscopeResult Oscilloscope::process() { + OscilloscopeResult result; + result.triggerIndex = 0; + result.samplesToShow = displaySamples_; + result.detectedPitch = smoothedPitch_; + + if (!pitchLock_) { + return result; + } + + // Detect pitch from recent samples in circular buffer + // Use RAW buffer for pitch detection (filtered buffer may attenuate the fundamental) + // Use last 2048 samples for pitch detection + std::vector recentSamples(2048); + for (size_t i = 0; i < 2048; i++) { + size_t idx = (writePos_ + OSCILLOSCOPE_BUFFER_SIZE - 2048 + i) % OSCILLOSCOPE_BUFFER_SIZE; + recentSamples[i] = displayBuffer_[idx]; // Use RAW samples, not filtered + } + + // Apply high shelf filter to reduce HF interference with pitch detection + pitchAnalysisShelf_.reset(); + for (size_t i = 0; i < 2048; i++) { + recentSamples[i] = pitchAnalysisShelf_.process(recentSamples[i]); + } + + // Apply cascaded lowpass for steep HF rejection + pitchLowpass1_.reset(); + pitchLowpass2_.reset(); + for (size_t i = 0; i < 2048; i++) { + recentSamples[i] = pitchLowpass1_.process(recentSamples[i]); + recentSamples[i] = pitchLowpass2_.process(recentSamples[i]); + } + + float newPitch = DSP::detectPitchFFT(recentSamples.data(), 2048, sampleRate_, 40.0f, 1000.0f); + if (newPitch > 0.0f) { + pitchSamplesProcessed_++; + + // Adaptive smoothing: fast convergence initially, then conservative + // First ~20 frames: use 0.5/0.5 for quick lock-on + // After warmup: use 0.95/0.05 for stable tracking + float smoothingOld = (pitchSamplesProcessed_ < 20) ? 0.5f : 0.95f; + float smoothingNew = 1.0f - smoothingOld; + smoothedPitch_ = smoothedPitch_ * smoothingOld + newPitch * smoothingNew; + + // Redesign FIR bandpass filter if pitch changed significantly (>10%) + // This keeps the filter centered on the fundamental for stable trigger + if (std::abs(smoothedPitch_ - lastFilterPitch_) / lastFilterPitch_ > 0.1f) { + float bandwidth = smoothedPitch_ * 0.1f; // 10% of center freq (tight = single zero crossing) + bandpassFilter_.designBandpass(smoothedPitch_, bandwidth, sampleRate_, 60.0f); + lastFilterPitch_ = smoothedPitch_; + } + } + result.detectedPitch = smoothedPitch_; + + // Calculate target position for trigger search + // We search backwards from (writePos - displaySamples - firDelay) to find a rising zero crossing + float periodSamples = sampleRate_ / smoothedPitch_; + size_t samples = static_cast(displaySamples_); + size_t firDelay = bandpassFilter_.getDelay(); + + // Target: look back from current write position by display window size AND FIR delay + // This ensures we're searching in the correct region where filtered data is valid + size_t target = (writePos_ + OSCILLOSCOPE_BUFFER_SIZE - samples - firDelay) % OSCILLOSCOPE_BUFFER_SIZE; + + // Search range: 4 periods for robust detection + size_t range = static_cast(periodSamples * 4.0f); + + // Find zero crossing by searching backwards from target + float zeroCross = findTriggerBackwards(target, range); + + // LEFT-ANCHORED TRIGGER (MiniMeters style): + // The zero crossing IS the left edge of display + // Waveform starts at rising edge and extends rightward + if (zeroCross >= 0.0f) { + // Apply FIR filter delay compensation + // The filtered signal is delayed by order/2 samples relative to raw signal + size_t firDelay = bandpassFilter_.getDelay(); + + // The trigger index is where we start reading raw samples for display + // Compensate for filter delay so trigger aligns with raw audio + result.triggerIndex = zeroCross - static_cast(firDelay); + + // Wrap if negative + while (result.triggerIndex < 0) { + result.triggerIndex += OSCILLOSCOPE_BUFFER_SIZE; + } + } else { + // No crossing found - use target as fallback + result.triggerIndex = static_cast(target); + } + + return result; +} + +// Legacy snapshot processing (for backwards compatibility) +OscilloscopeResult Oscilloscope::processSnapshot(const float* audioData, size_t length) { + OscilloscopeResult result; + result.triggerIndex = 0; + result.samplesToShow = std::min(displaySamples_, static_cast(length)); + result.detectedPitch = smoothedPitch_; + + if (!pitchLock_ || length == 0) { + return result; + } + + // Push samples to circular buffer + pushSamples(audioData, length); + + // Use the new continuous process method + return process(); +} + +// Get samples from circular buffer starting at position (integer version) +// Returns filtered samples for display (high shelf + lowpass applied) +void Oscilloscope::getSamples(float* output, size_t startPos, size_t count) const { + for (size_t i = 0; i < count; i++) { + size_t idx = (startPos + i) % OSCILLOSCOPE_BUFFER_SIZE; + output[i] = visualBuffer_[idx]; // Visual-only filtered signal + } +} + +// Get samples with sub-sample interpolation (float start position) +// Uses Catmull-Rom spline for smooth rendering at sub-pixel precision +// This preserves the high-precision trigger position from zero-crossing detection +void Oscilloscope::getSamplesInterpolated(float* output, float startPos, size_t count) const { + for (size_t i = 0; i < count; i++) { + float pos = startPos + static_cast(i); + + // Wrap position to buffer bounds + while (pos < 0) pos += OSCILLOSCOPE_BUFFER_SIZE; + while (pos >= OSCILLOSCOPE_BUFFER_SIZE) pos -= OSCILLOSCOPE_BUFFER_SIZE; + + size_t idx = static_cast(pos) % OSCILLOSCOPE_BUFFER_SIZE; + float frac = pos - std::floor(pos); + + if (frac < 0.0001f) { + // No interpolation needed - exact sample position + output[i] = visualBuffer_[idx]; + } else { + // Cubic (Catmull-Rom) interpolation for smooth sub-sample rendering + // This eliminates pixel-level ghosting/jitter from truncated trigger positions + size_t i0 = (idx + OSCILLOSCOPE_BUFFER_SIZE - 1) % OSCILLOSCOPE_BUFFER_SIZE; + size_t i1 = idx; + size_t i2 = (idx + 1) % OSCILLOSCOPE_BUFFER_SIZE; + size_t i3 = (idx + 2) % OSCILLOSCOPE_BUFFER_SIZE; + + float y0 = visualBuffer_[i0]; + float y1 = visualBuffer_[i1]; + float y2 = visualBuffer_[i2]; + float y3 = visualBuffer_[i3]; + + // Catmull-Rom spline coefficients + float t = frac; + float t2 = t * t; + float t3 = t2 * t; + + output[i] = 0.5f * ( + (2.0f * y1) + + (-y0 + y2) * t + + (2.0f * y0 - 5.0f * y1 + 4.0f * y2 - y3) * t2 + + (-y0 + 3.0f * y1 - 3.0f * y2 + y3) * t3 + ); + } + } +} + +void Oscilloscope::reset() { + writePos_ = 0; + lastTrigger_ = 0.0f; + smoothedPitch_ = 200.0f; + lastFilterPitch_ = 200.0f; + pitchSamplesProcessed_ = 0; // Reset warmup counter for fast convergence on next use + + // Redesign filter to default 200Hz (reset() only clears delay line, not coefficients) + bandpassFilter_.designBandpass(200.0f, 20.0f, sampleRate_, 60.0f); + pitchAnalysisShelf_.reset(); + + // Reset display and pitch detection filters + displayShelf_.reset(); + displayLowpass1_.reset(); + displayLowpass2_.reset(); + pitchLowpass1_.reset(); + pitchLowpass2_.reset(); + + // Clear buffers + std::fill(circularBuffer_.begin(), circularBuffer_.end(), 0.0f); + std::fill(filteredBuffer_.begin(), filteredBuffer_.end(), 0.0f); + std::fill(displayBuffer_.begin(), displayBuffer_.end(), 0.0f); + std::fill(visualBuffer_.begin(), visualBuffer_.end(), 0.0f); +} + +} // namespace Visualizer diff --git a/modules/astra-scope/cpp/oscilloscope.h b/modules/astra-scope/cpp/oscilloscope.h new file mode 100644 index 0000000..2d57acf --- /dev/null +++ b/modules/astra-scope/cpp/oscilloscope.h @@ -0,0 +1,85 @@ +#pragma once + +#include "dsp_utils.h" +#include +#include + +namespace Visualizer { + +struct OscilloscopeResult { + float triggerIndex; + int samplesToShow; + float detectedPitch; +}; + +// Circular buffer size (same as pulse-visualizer) +constexpr size_t OSCILLOSCOPE_BUFFER_SIZE = 32768; + +class Oscilloscope { +public: + Oscilloscope(); + + // Configuration + void setSampleRate(float sampleRate); + void setPitchLock(bool enabled); + void setDisplaySamples(int samples); + + // Push samples into circular buffer (continuous capture) + void pushSamples(const float* samples, size_t count); + + // Process and find trigger point (uses circular buffer) + OscilloscopeResult process(); + + // Legacy: Process snapshot (for backwards compatibility) + OscilloscopeResult processSnapshot(const float* audioData, size_t length); + + // Get current write position + size_t getWritePos() const { return writePos_; } + + // Get samples from circular buffer (for rendering) + void getSamples(float* output, size_t startPos, size_t count) const; + + // Get samples with sub-sample interpolation (preserves trigger precision) + void getSamplesInterpolated(float* output, float startPos, size_t count) const; + + // Reset state + void reset(); + +private: + float sampleRate_; + bool pitchLock_; + int displaySamples_; + + // Circular buffer for continuous audio + std::vector circularBuffer_; + std::vector filteredBuffer_; + size_t writePos_; + + // Linear-phase FIR bandpass filter for stable trigger detection + DSP::FIRFilter bandpassFilter_; + float lastFilterPitch_; // Track pitch for filter redesign + + // High shelf filter to reduce HF before pitch detection + DSP::BiquadFilter pitchAnalysisShelf_; + + // Display filtering (high shelf + steep lowpass) + DSP::BiquadFilter displayShelf_; // High shelf for display + DSP::BiquadFilter displayLowpass1_; // First stage of cascaded lowpass + DSP::BiquadFilter displayLowpass2_; // Second stage (4th order total = 24dB/oct) + std::vector displayBuffer_; // Lowpass filtered samples for tracking + std::vector visualBuffer_; // Visual-only samples (display shelf applied) + + // Pitch detection lowpass (after existing high shelf) + DSP::BiquadFilter pitchLowpass1_; // First stage + DSP::BiquadFilter pitchLowpass2_; // Second stage + + float lastTrigger_; + float smoothedPitch_; + int pitchSamplesProcessed_; // Track samples for adaptive smoothing + + // Internal helpers + void updateFiltered(); + float findTriggerBackwards(size_t target, size_t range); +}; + +} // namespace Visualizer diff --git a/modules/astra-scope/cpp/scope_jni.cpp b/modules/astra-scope/cpp/scope_jni.cpp new file mode 100644 index 0000000..85d661c --- /dev/null +++ b/modules/astra-scope/cpp/scope_jni.cpp @@ -0,0 +1,60 @@ +// Plain-JNI bridge for ScopeBridge.kt. No fbjni / ReactAndroid β€” this library +// is pure DSP, so it only needs (NDK sysroot) and liblog. +// +// All JNI lives here (in the astra-scope module). The vendored kotlin-audio tap +// calls the Kotlin ScopeBridge, never JNI directly, so libastrascope.so is +// loaded exactly once. + +#include + +#include "scope_ring.h" + +namespace { +astra::ScopeDriver& driver() { return astra::ScopeDriver::instance(); } +} // namespace + +extern "C" { + +JNIEXPORT void JNICALL +Java_expo_modules_astrascope_ScopeBridge_nativeConfigure( + JNIEnv* /*env*/, jobject /*thiz*/, jint sampleRate, jint channelCount) { + driver().configure(static_cast(sampleRate), static_cast(channelCount)); +} + +// `frames` is interleaved float PCM with frameCount * channelCount elements. +JNIEXPORT void JNICALL +Java_expo_modules_astrascope_ScopeBridge_nativePushFrames( + JNIEnv* env, jobject /*thiz*/, jfloatArray frames, jint frameCount, + jint channelCount) { + if (frames == nullptr || frameCount <= 0 || channelCount <= 0) { + return; + } + auto* data = static_cast( + env->GetPrimitiveArrayCritical(frames, nullptr)); + if (data == nullptr) { + return; + } + driver().pushInterleaved(data, static_cast(frameCount), + static_cast(channelCount)); + // No JNI calls between Get/Release; abort copy-back (read-only access). + env->ReleasePrimitiveArrayCritical(frames, data, JNI_ABORT); +} + +// Fills a direct ByteBuffer (over the JS Float32Array's memory) with the latest +// spectrum (dB magnitudes), up to `capacityFloats` floats. Returns bin count. +// Zero-copy: writes straight into the JS-owned ArrayBuffer. +JNIEXPORT jint JNICALL +Java_expo_modules_astrascope_ScopeBridge_nativeFillSpectrum( + JNIEnv* env, jobject /*thiz*/, jobject buffer, jint capacityFloats) { + if (buffer == nullptr || capacityFloats <= 0) { + return 0; + } + auto* dst = static_cast(env->GetDirectBufferAddress(buffer)); + if (dst == nullptr) { + return 0; + } + const size_t n = driver().fillSpectrum(dst, static_cast(capacityFloats)); + return static_cast(n); +} + +} // extern "C" diff --git a/modules/astra-scope/cpp/scope_ring.h b/modules/astra-scope/cpp/scope_ring.h new file mode 100644 index 0000000..236ed85 --- /dev/null +++ b/modules/astra-scope/cpp/scope_ring.h @@ -0,0 +1,124 @@ +#pragma once + +// Process-wide scope driver: a single-producer / single-consumer bridge between +// the ExoPlayer audio thread (which pushes PCM via the tap AudioProcessor) and +// the JS render thread (which pulls the latest spectrum frame once per frame). +// +// Threading contract: +// - pushInterleaved() + configure() run on the AUDIO thread. They are +// allocation-free and lock-free: they only touch the ring (atomic write +// position) and an atomic pending-sample-rate. They NEVER touch the +// analyzer (no FFT on the audio callback). +// - fillSpectrum() runs on the single JS/render thread. It owns the analyzer +// and all consumer-only state. It snapshots the most recent fftSize mono +// samples from the ring and runs Visualizer::Spectrum::process there. +// +// The ring holds mono samples (the producer downmixes), sized well above the +// FFT window so a 60fps consumer never misses recent audio; on a snapshot we +// read only the most recent fftSize samples, so a slow consumer simply sees the +// latest window (correct for a rolling spectrum). + +#include "spectrum.h" + +#include +#include +#include +#include + +namespace astra { + +class ScopeDriver { + public: + static ScopeDriver& instance() { + static ScopeDriver driver; + return driver; + } + + // Audio thread. Cheap: just remember the rate; applied on the consumer side. + void configure(int sampleRate, int /*channelCount*/) { + if (sampleRate > 0) { + pendingSampleRate_.store(sampleRate, std::memory_order_release); + } + } + + // Audio thread. Downmix interleaved float frames to mono and write to ring. + // Allocation-free and lock-free (single producer). + void pushInterleaved(const float* data, size_t frames, int channels) { + if (data == nullptr || frames == 0 || channels <= 0) { + return; + } + size_t w = writePos_.load(std::memory_order_relaxed); + const float inv = 1.0f / static_cast(channels); + for (size_t f = 0; f < frames; ++f) { + float sum = 0.0f; + const float* frame = data + f * channels; + for (int c = 0; c < channels; ++c) { + sum += frame[c]; + } + ring_[w & kMask] = sum * inv; + ++w; + } + writePos_.store(w, std::memory_order_release); + } + + // Render thread (single consumer). Snapshot the most recent fftSize mono + // samples, run the FFT, copy up to `cap` dB magnitudes into `out`. + // Returns the number of bins written. + size_t fillSpectrum(float* out, size_t cap) { + if (out == nullptr || cap == 0) { + return 0; + } + + const int sr = pendingSampleRate_.load(std::memory_order_acquire); + if (sr != appliedSampleRate_) { + spectrum_.setSampleRate(static_cast(sr)); + appliedSampleRate_ = sr; + } + + const size_t fftSize = spectrum_.getFFTSize(); + const size_t w = writePos_.load(std::memory_order_acquire); + + const std::vector* mags; + if (w >= fftSize) { + scratch_.resize(fftSize); + const size_t start = w - fftSize; + for (size_t i = 0; i < fftSize; ++i) { + scratch_[i] = ring_[(start + i) & kMask]; + } + mags = &spectrum_.process(scratch_.data(), fftSize); + } else { + // Not enough audio yet β€” return current (silence-initialised) frame. + mags = &spectrum_.process(nullptr, 0); + } + + const size_t n = std::min(cap, mags->size()); + std::memcpy(out, mags->data(), n * sizeof(float)); + return n; + } + + size_t binCount() const { return spectrum_.getFFTSize() / 2; } + + void reset() { spectrum_.reset(); } + + private: + ScopeDriver() : spectrum_(kFftSize) { + spectrum_.setSmoothing(0.9f); + ring_.assign(kSize, 0.0f); + } + + static constexpr size_t kFftSize = 2048; // -> 1024 dB bins + static constexpr size_t kSize = 8192; // ring capacity (power of two) + static constexpr size_t kMask = kSize - 1; + + // Shared SPSC state. + std::vector ring_; + std::atomic writePos_{0}; + std::atomic pendingSampleRate_{44100}; + + // Consumer-only state. + std::vector scratch_; + Visualizer::Spectrum spectrum_; + int appliedSampleRate_{0}; +}; + +} // namespace astra diff --git a/modules/astra-scope/cpp/spectrum.cpp b/modules/astra-scope/cpp/spectrum.cpp new file mode 100644 index 0000000..c3d0475 --- /dev/null +++ b/modules/astra-scope/cpp/spectrum.cpp @@ -0,0 +1,132 @@ +#define _USE_MATH_DEFINES +#include "spectrum.h" +#include +#include +#include + +namespace Visualizer { + +Spectrum::Spectrum(size_t fftSize) + : fftSize_(fftSize) + , sampleRate_(44100.0f) + , smoothing_(0.9f) + , bufferedSamples_(0) { + fft_ = std::make_unique(fftSize); + historyBuffer_.resize(fftSize, 0.0f); + windowedInput_.resize(fftSize); + magnitudes_.resize(fftSize / 2); + // Initialize to silence (-100.0f dB) + smoothedMagnitudes_.resize(fftSize / 2, -100.0f); +} + +void Spectrum::setFFTSize(size_t size) { + if (size != fftSize_) { + fftSize_ = size; + fft_ = std::make_unique(size); + historyBuffer_.assign(size, 0.0f); + windowedInput_.resize(size); + magnitudes_.resize(size / 2); + // Initialize to silence (-100.0f dB) + smoothedMagnitudes_.resize(size / 2, -100.0f); + bufferedSamples_ = 0; + } +} + +void Spectrum::setSampleRate(float sampleRate) { + sampleRate_ = sampleRate; +} + +void Spectrum::setSmoothing(float smoothing) { + smoothing_ = std::clamp(smoothing, 0.0f, 0.99f); +} + +void Spectrum::applyWindow(const float* input, float* output, size_t length) { + if (length <= 1) { + if (length == 1) { + output[0] = input[0]; + } + return; + } + + // Hann window + for (size_t i = 0; i < length; i++) { + float window = 0.5f * (1.0f - cosf(2.0f * M_PI * i / (length - 1))); + output[i] = input[i] * window; + } +} + +void Spectrum::pushSamples(const float* input, size_t length) { + if (length == 0 || fftSize_ == 0) { + return; + } + + // Keep only the most recent fftSize_ samples. + if (length >= fftSize_) { + std::memcpy(historyBuffer_.data(), input + (length - fftSize_), fftSize_ * sizeof(float)); + bufferedSamples_ = fftSize_; + return; + } + + const size_t keep = fftSize_ - length; + std::move(historyBuffer_.begin() + length, historyBuffer_.end(), historyBuffer_.begin()); + std::memcpy(historyBuffer_.data() + keep, input, length * sizeof(float)); + bufferedSamples_ = std::min(fftSize_, bufferedSamples_ + length); +} + +const std::vector& Spectrum::process(const float* audioData, size_t length) { + if (audioData != nullptr && length > 0) { + pushSamples(audioData, length); + } + + if (historyBuffer_.empty() || magnitudes_.empty()) { + return smoothedMagnitudes_; + } + + // Always analyze a full FFT frame from the rolling buffer. + applyWindow(historyBuffer_.data(), windowedInput_.data(), fftSize_); + + // Perform FFT + fft_->forward(windowedInput_.data(), magnitudes_.data()); + + // Convert to dB and apply smoothing + for (size_t i = 0; i < magnitudes_.size(); i++) { + float mag = magnitudes_[i]; + + // Convert to dB + // Add epsilon to avoid log(0) + float db = 20.0f * log10f(std::max(mag, 1e-10f)); + + // Compensate Hann window coherent gain (about -6 dB). + db += 6.0f; + + // Clamp to a stable display range. + db = std::clamp(db, -120.0f, 12.0f); + + if (bufferedSamples_ < fftSize_) { + smoothedMagnitudes_[i] = db; + continue; + } + + // Apply temporal smoothing only (no bin-to-bin averaging). + smoothedMagnitudes_[i] = smoothing_ * smoothedMagnitudes_[i] + (1.0f - smoothing_) * db; + + // Safety check + if (!std::isfinite(smoothedMagnitudes_[i])) { + smoothedMagnitudes_[i] = -100.0f; + } + } + + return smoothedMagnitudes_; +} + +float Spectrum::binToFrequency(int bin) const { + return bin * sampleRate_ / fftSize_; +} + +void Spectrum::reset() { + std::fill(historyBuffer_.begin(), historyBuffer_.end(), 0.0f); + std::fill(smoothedMagnitudes_.begin(), smoothedMagnitudes_.end(), -100.0f); + bufferedSamples_ = 0; +} + +} // namespace Visualizer diff --git a/modules/astra-scope/cpp/spectrum.h b/modules/astra-scope/cpp/spectrum.h new file mode 100644 index 0000000..8d7322b --- /dev/null +++ b/modules/astra-scope/cpp/spectrum.h @@ -0,0 +1,45 @@ +#pragma once + +#include "dsp_utils.h" +#include +#include + +namespace Visualizer { + +class Spectrum { +public: + explicit Spectrum(size_t fftSize = 2048); + + // Configuration + void setFFTSize(size_t size); + size_t getFFTSize() const { return fftSize_; } + void setSampleRate(float sampleRate); + void setSmoothing(float smoothing); // 0.0 - 1.0 + + // Process audio and get spectrum data + // Returns magnitude data (size = fftSize / 2) + const std::vector& process(const float* audioData, size_t length); + + // Get frequency for a given bin + float binToFrequency(int bin) const; + + // Reset state + void reset(); + +private: + size_t fftSize_; + float sampleRate_; + float smoothing_; + + std::unique_ptr fft_; + std::vector historyBuffer_; + std::vector windowedInput_; + std::vector magnitudes_; + std::vector smoothedMagnitudes_; + size_t bufferedSamples_; + + void applyWindow(const float* input, float* output, size_t length); + void pushSamples(const float* input, size_t length); +}; + +} // namespace Visualizer diff --git a/modules/astra-scope/cpp/vectorscope.cpp b/modules/astra-scope/cpp/vectorscope.cpp new file mode 100644 index 0000000..ff1c5a7 --- /dev/null +++ b/modules/astra-scope/cpp/vectorscope.cpp @@ -0,0 +1,110 @@ +#include "vectorscope.h" +#include +#include + +namespace Visualizer { + +Vectorscope::Vectorscope() + : sampleRate_(48000.0f) + , bufferSize_(1024) + , writePos_(0) + , validSamples_(0) { + + leftBuffer_.resize(VECTORSCOPE_BUFFER_SIZE, 0.0f); + rightBuffer_.resize(VECTORSCOPE_BUFFER_SIZE, 0.0f); + points_.reserve(1024); + + // Cascaded lowpass at 8kHz, Butterworth (Q=0.707) + // Two stages per channel = 4th order = 24 dB/oct rolloff + // Removes HF noise that causes erratic Lissajous motion + leftLowpass1_.setLowpass(8000.0f, sampleRate_, 0.707f); + leftLowpass2_.setLowpass(8000.0f, sampleRate_, 0.707f); + rightLowpass1_.setLowpass(8000.0f, sampleRate_, 0.707f); + rightLowpass2_.setLowpass(8000.0f, sampleRate_, 0.707f); +} + +void Vectorscope::setSampleRate(float sampleRate) { + sampleRate_ = sampleRate; + // Redesign all filters with new sample rate + leftLowpass1_.setLowpass(8000.0f, sampleRate_, 0.707f); + leftLowpass2_.setLowpass(8000.0f, sampleRate_, 0.707f); + rightLowpass1_.setLowpass(8000.0f, sampleRate_, 0.707f); + rightLowpass2_.setLowpass(8000.0f, sampleRate_, 0.707f); +} + +void Vectorscope::setBufferSize(size_t size) { + bufferSize_ = size; + points_.reserve(size); +} + +void Vectorscope::pushSamples( + const float* leftChannel, + const float* rightChannel, + size_t length +) { + for (size_t i = 0; i < length; i++) { + // Apply cascaded lowpass filtering + float filteredL = leftLowpass1_.process(leftChannel[i]); + filteredL = leftLowpass2_.process(filteredL); + + float filteredR = rightLowpass1_.process(rightChannel[i]); + filteredR = rightLowpass2_.process(filteredR); + + leftBuffer_[writePos_] = filteredL; + rightBuffer_[writePos_] = filteredR; + + writePos_ = (writePos_ + 1) % VECTORSCOPE_BUFFER_SIZE; + if (validSamples_ < VECTORSCOPE_BUFFER_SIZE) { + validSamples_++; + } + } +} + +size_t Vectorscope::getPoints(float* xOut, float* yOut, size_t maxPoints) const { + size_t count = std::min(maxPoints, validSamples_); + + // Read the most recent `count` samples from the circular buffer + for (size_t i = 0; i < count; i++) { + size_t idx = (writePos_ + VECTORSCOPE_BUFFER_SIZE - count + i) % VECTORSCOPE_BUFFER_SIZE; + xOut[i] = rightBuffer_[idx]; // X = Right (standard Lissajous) + yOut[i] = leftBuffer_[idx]; // Y = Left + } + + return count; +} + +// Legacy process method (routes through new pipeline) +const std::vector& Vectorscope::process( + const float* leftChannel, + const float* rightChannel, + size_t length +) { + // Push through the filtering pipeline + pushSamples(leftChannel, rightChannel, length); + + // Build legacy output from buffer + points_.clear(); + size_t count = std::min(length, validSamples_); + for (size_t i = 0; i < count; i++) { + size_t idx = (writePos_ + VECTORSCOPE_BUFFER_SIZE - count + i) % VECTORSCOPE_BUFFER_SIZE; + VectorscopePoint p; + p.x = rightBuffer_[idx]; + p.y = leftBuffer_[idx]; + points_.push_back(p); + } + return points_; +} + +void Vectorscope::reset() { + writePos_ = 0; + validSamples_ = 0; + std::fill(leftBuffer_.begin(), leftBuffer_.end(), 0.0f); + std::fill(rightBuffer_.begin(), rightBuffer_.end(), 0.0f); + leftLowpass1_.reset(); + leftLowpass2_.reset(); + rightLowpass1_.reset(); + rightLowpass2_.reset(); + points_.clear(); +} + +} // namespace Visualizer diff --git a/modules/astra-scope/cpp/vectorscope.h b/modules/astra-scope/cpp/vectorscope.h new file mode 100644 index 0000000..0042c09 --- /dev/null +++ b/modules/astra-scope/cpp/vectorscope.h @@ -0,0 +1,66 @@ +#pragma once + +#include "dsp_utils.h" +#include +#include + +namespace Visualizer { + +struct VectorscopePoint { + float x; // Right channel + float y; // Left channel +}; + +// Circular buffer size (~170ms at 48kHz) +constexpr size_t VECTORSCOPE_BUFFER_SIZE = 8192; + +class Vectorscope { +public: + Vectorscope(); + + // Configuration + void setSampleRate(float sampleRate); + void setBufferSize(size_t size); // Legacy, kept for compat + size_t getBufferSize() const { return bufferSize_; } + + // Push stereo samples into circular buffer (called per worklet chunk) + void pushSamples(const float* leftChannel, const float* rightChannel, size_t length); + + // Get the most recent N points for rendering (from circular buffer) + // Returns count of valid points written to output arrays + size_t getPoints(float* xOut, float* yOut, size_t maxPoints) const; + + // Get number of valid samples in buffer + size_t getValidSamples() const { return validSamples_; } + + // Legacy process (kept for backwards compatibility) + const std::vector& process( + const float* leftChannel, + const float* rightChannel, + size_t length + ); + + // Reset state + void reset(); + +private: + float sampleRate_; + size_t bufferSize_; // Legacy + size_t writePos_; + size_t validSamples_; + + // Circular buffers for filtered L/R + std::vector leftBuffer_; + std::vector rightBuffer_; + + // Cascaded lowpass filters (4th order Butterworth at 8kHz per channel) + DSP::BiquadFilter leftLowpass1_; + DSP::BiquadFilter leftLowpass2_; + DSP::BiquadFilter rightLowpass1_; + DSP::BiquadFilter rightLowpass2_; + + // Legacy + std::vector points_; +}; + +} // namespace Visualizer diff --git a/modules/astra-scope/expo-module.config.json b/modules/astra-scope/expo-module.config.json new file mode 100644 index 0000000..e6fb4f3 --- /dev/null +++ b/modules/astra-scope/expo-module.config.json @@ -0,0 +1,6 @@ +{ + "platforms": ["android"], + "android": { + "modules": ["expo.modules.astrascope.AstraScopeModule"] + } +} diff --git a/modules/astra-scope/index.ts b/modules/astra-scope/index.ts new file mode 100644 index 0000000..fb75da9 --- /dev/null +++ b/modules/astra-scope/index.ts @@ -0,0 +1,21 @@ +import { requireNativeModule, type NativeModule } from 'expo-modules-core'; + +/** Number of spectrum bins returned by getSpectrumFrame (fftSize/2, fftSize=2048). */ +export const SPECTRUM_BINS = 1024; + +/** Spectrum values are dB magnitudes in this range (silence ~ -100). */ +export const SPECTRUM_DB_MIN = -100; +export const SPECTRUM_DB_MAX = 0; + +declare class AstraScopeModuleType extends NativeModule { + /** Gate the audio-thread PCM tap. Off when backgrounded/paused/reduced-motion. */ + setActive(active: boolean): void; + /** + * Fill `out` (length should be {@link SPECTRUM_BINS}) with the latest dB + * spectrum magnitudes in place; returns the number of bins written. Call once + * per render frame from the JS thread. + */ + getSpectrumFrame(out: Float32Array): number; +} + +export const AstraScope = requireNativeModule('AstraScope'); diff --git a/package-lock.json b/package-lock.json index fb42cf4..d8ed9c7 100644 --- a/package-lock.json +++ b/package-lock.json @@ -15,6 +15,7 @@ "@expo/vector-icons": "^15.0.2", "@op-engineering/op-sqlite": "^16.2.1", "@shopify/flash-list": "2.0.2", + "@shopify/react-native-skia": "2.6.2", "encoding-japanese": "^2.2.0", "expo": "~56.0.4", "expo-asset": "~56.0.14", @@ -3025,6 +3026,38 @@ "react-native": "*" } }, + "node_modules/@shopify/react-native-skia": { + "version": "2.6.2", + "resolved": "https://registry.npmjs.org/@shopify/react-native-skia/-/react-native-skia-2.6.2.tgz", + "integrity": "sha512-NzZ3+MRedZAUhguWw9DTCpWFd09Bq+tdGWhimGfJLGckuyoWGyimTiNTmaO2DeeivHTnGdv+eXbw7j/AV3LkRQ==", + "hasInstallScript": true, + "license": "MIT", + "dependencies": { + "canvaskit-wasm": "0.41.0", + "react-native-skia-android": "147.1.0", + "react-native-skia-apple-ios": "147.1.0", + "react-native-skia-apple-macos": "147.1.0", + "react-native-skia-apple-tvos": "147.1.0", + "react-reconciler": "0.31.0" + }, + "bin": { + "install-skia": "scripts/install-libs.js", + "setup-skia-web": "scripts/setup-canvaskit.js" + }, + "peerDependencies": { + "react": ">=19.0", + "react-native": ">=0.78", + "react-native-reanimated": ">=3.19.1" + }, + "peerDependenciesMeta": { + "react-native": { + "optional": true + }, + "react-native-reanimated": { + "optional": true + } + } + }, "node_modules/@sinclair/typebox": { "version": "0.27.10", "resolved": "https://registry.npmjs.org/@sinclair/typebox/-/typebox-0.27.10.tgz", @@ -3817,6 +3850,12 @@ "win32" ] }, + "node_modules/@webgpu/types": { + "version": "0.1.21", + "resolved": "https://registry.npmjs.org/@webgpu/types/-/types-0.1.21.tgz", + "integrity": "sha512-pUrWq3V5PiSGFLeLxoGqReTZmiiXwY3jRkIG5sLLKjyqNxrwm/04b4nw7LSmGWJcKk59XOM/YRTUwOzo4MMlow==", + "license": "BSD-3-Clause" + }, "node_modules/@xmldom/xmldom": { "version": "0.8.13", "resolved": "https://registry.npmjs.org/@xmldom/xmldom/-/xmldom-0.8.13.tgz", @@ -4577,6 +4616,15 @@ ], "license": "CC-BY-4.0" }, + "node_modules/canvaskit-wasm": { + "version": "0.41.0", + "resolved": "https://registry.npmjs.org/canvaskit-wasm/-/canvaskit-wasm-0.41.0.tgz", + "integrity": "sha512-cnbL02NFB3yOYMF/MtxViZHgD1vh55Pvy+zR8q4JuFvyCPejZP3eClkt2GuZ0S7jOmGMCJXaHBasbMChbR9JZg==", + "license": "BSD-3-Clause", + "dependencies": { + "@webgpu/types": "0.1.21" + } + }, "node_modules/chalk": { "version": "4.1.2", "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz", @@ -10325,6 +10373,30 @@ "react-native": ">=0.82.0" } }, + "node_modules/react-native-skia-android": { + "version": "147.1.0", + "resolved": "https://registry.npmjs.org/react-native-skia-android/-/react-native-skia-android-147.1.0.tgz", + "integrity": "sha512-pWA0M0G74AhjEop0HLCkjWJMup2HJxOmuUjfPt6kSDhYeWKVx8AEzWh0Fh19ah78zE/s4hD0Of0Tyem5shhiTg==", + "license": "MIT" + }, + "node_modules/react-native-skia-apple-ios": { + "version": "147.1.0", + "resolved": "https://registry.npmjs.org/react-native-skia-apple-ios/-/react-native-skia-apple-ios-147.1.0.tgz", + "integrity": "sha512-cr4rWe4Bf0H0TTutUp5cgHt5/Felttl1bh4BAAAsgAeL2F10FAK9urX8spjUshzMwjqXD7rNOWuFzU6ZcNlGKw==", + "license": "MIT" + }, + "node_modules/react-native-skia-apple-macos": { + "version": "147.1.0", + "resolved": "https://registry.npmjs.org/react-native-skia-apple-macos/-/react-native-skia-apple-macos-147.1.0.tgz", + "integrity": "sha512-Qbv0Y7LgawtRKuGk8gnGeh8nDWwNiu03LcX0mVaQzBBbxFDYvqejanA+AkO3p8gsQb+fsXRc9DAk+U8cBnzZvA==", + "license": "MIT" + }, + "node_modules/react-native-skia-apple-tvos": { + "version": "147.1.0", + "resolved": "https://registry.npmjs.org/react-native-skia-apple-tvos/-/react-native-skia-apple-tvos-147.1.0.tgz", + "integrity": "sha512-b+4vILXHPu++t8H41PHLBVsTab2LPqwXNdzgdScyl4+Cu8Ta34aUQW3T469cB0ogAMPdu//KV00w4YVpDZoRUQ==", + "license": "MIT" + }, "node_modules/react-native-svg": { "version": "15.15.4", "resolved": "https://registry.npmjs.org/react-native-svg/-/react-native-svg-15.15.4.tgz", @@ -10453,6 +10525,27 @@ "node": ">=10" } }, + "node_modules/react-reconciler": { + "version": "0.31.0", + "resolved": "https://registry.npmjs.org/react-reconciler/-/react-reconciler-0.31.0.tgz", + "integrity": "sha512-7Ob7Z+URmesIsIVRjnLoDGwBEG/tVitidU0nMsqX/eeJaLY89RISO/10ERe0MqmzuKUUB1rmY+h1itMbUHg9BQ==", + "license": "MIT", + "dependencies": { + "scheduler": "^0.25.0" + }, + "engines": { + "node": ">=0.10.0" + }, + "peerDependencies": { + "react": "^19.0.0" + } + }, + "node_modules/react-reconciler/node_modules/scheduler": { + "version": "0.25.0", + "resolved": "https://registry.npmjs.org/scheduler/-/scheduler-0.25.0.tgz", + "integrity": "sha512-xFVuu11jh+xcO7JOAGJNOXld8/TcEHK/4CituBUeUb5hqxJLj9YuemAEuvm9gQ/+pgXYfbQuqAkiYu+u7YEsNA==", + "license": "MIT" + }, "node_modules/react-refresh": { "version": "0.14.2", "resolved": "https://registry.npmjs.org/react-refresh/-/react-refresh-0.14.2.tgz", diff --git a/package.json b/package.json index a340504..d594c4d 100644 --- a/package.json +++ b/package.json @@ -9,6 +9,7 @@ "@expo/vector-icons": "^15.0.2", "@op-engineering/op-sqlite": "^16.2.1", "@shopify/flash-list": "2.0.2", + "@shopify/react-native-skia": "2.6.2", "encoding-japanese": "^2.2.0", "expo": "~56.0.4", "expo-asset": "~56.0.14", diff --git a/src/app/_layout.tsx b/src/app/_layout.tsx index de00333..3713150 100644 --- a/src/app/_layout.tsx +++ b/src/app/_layout.tsx @@ -16,6 +16,7 @@ import { JetBrainsMono_500Medium, } from '@expo-google-fonts/jetbrains-mono'; import { usePlaybackSync } from '@/audio/usePlaybackSync'; +import { useScopeLifecycle } from '@/scope/useScopeLifecycle'; import { useLibraryStore } from '@/stores/libraryStore'; import { colors } from '@/theme'; @@ -27,6 +28,12 @@ function PlaybackSync() { return null; } +/** Owns the visualizer on/off gate (foreground + playing + motion). Renders nothing. */ +function ScopeLifecycle() { + useScopeLifecycle(); + return null; +} + export default function RootLayout() { const [fontsLoaded] = useFonts({ Inter_400Regular, @@ -59,6 +66,7 @@ export default function RootLayout() { + diff --git a/src/app/now-playing.tsx b/src/app/now-playing.tsx index d518cc6..c4300cf 100644 --- a/src/app/now-playing.tsx +++ b/src/app/now-playing.tsx @@ -1,19 +1,42 @@ -import { View, Pressable, StyleSheet } from 'react-native'; +import { View, Pressable, StyleSheet, useWindowDimensions } from 'react-native'; import { Image } from 'expo-image'; import { Ionicons } from '@expo/vector-icons'; import { useRouter } from 'expo-router'; import { useSafeAreaInsets } from 'react-native-safe-area-context'; +import { Gesture, GestureDetector } from 'react-native-gesture-handler'; +import Animated, { + SlideInDown, + runOnJS, + useAnimatedStyle, + useSharedValue, + withSpring, +} from 'react-native-reanimated'; import { Text } from '@/components/Text'; import { AstraLogo } from '@/components/AstraLogo'; import { FormatBadges } from '@/components/FormatBadge'; -import { SeekBar } from '@/components/SeekBar'; +import { WaveformSeekBar } from '@/components/WaveformSeekBar'; +import { Visualizer } from '@/components/Visualizer'; import { colors, radius, spacing } from '@/theme'; import { usePlayerStore } from '@/stores/playerStore'; import { seekTo, skipToNext, skipToPrevious, togglePlay } from '@/audio/playbackController'; +type IconName = keyof typeof Ionicons.glyphMap; + +// Secondary controls are placeholders for now β€” laid out to settle the design. +const SUB_CONTROLS: { icon: IconName; label: string }[] = [ + { icon: 'shuffle', label: 'Shuffle' }, + { icon: 'heart-outline', label: 'Favorite' }, + { icon: 'list-outline', label: 'Queue' }, + { icon: 'repeat', label: 'Repeat' }, +]; + +const DISMISS_DISTANCE = 140; +const DISMISS_VELOCITY = 1000; + export default function NowPlayingScreen() { const router = useRouter(); const insets = useSafeAreaInsets(); + const { width: windowWidth, height: windowHeight } = useWindowDimensions(); const track = usePlayerStore((s) => s.currentTrack); const playbackState = usePlayerStore((s) => s.playbackState); const currentTime = usePlayerStore((s) => s.currentTime); @@ -21,103 +44,215 @@ export default function NowPlayingScreen() { const isPlaying = playbackState === 'playing'; const isLoading = playbackState === 'loading'; + const contentWidth = windowWidth - spacing.xl * 2; + const artSize = Math.min(296, contentWidth); + const source = track?.album?.trim() ? track.album : 'Library'; + + // Swipe down to minimize. The stack transition is disabled for this route, so + // the sheet owns one continuous enter/exit animation instead of handing off to + // a second native modal animation after release. + const translateY = useSharedValue(0); + const dismiss = () => router.back(); + + const dismissSheet = (velocity = 0) => { + translateY.value = withSpring( + windowHeight, + { + damping: 28, + stiffness: 240, + velocity, + overshootClamping: true, + }, + (finished) => { + if (finished) runOnJS(dismiss)(); + } + ); + }; + + const pan = Gesture.Pan() + .activeOffsetY(14) // engage only on a downward drag + .failOffsetY(-14) + .failOffsetX([-24, 24]) // let the horizontal seek drag through + .onUpdate((e) => { + translateY.value = e.translationY > 0 ? e.translationY : 0; + }) + .onEnd((e) => { + if (e.translationY > DISMISS_DISTANCE || e.velocityY > DISMISS_VELOCITY) { + translateY.value = withSpring( + windowHeight, + { + damping: 28, + stiffness: 240, + velocity: e.velocityY, + overshootClamping: true, + }, + (finished) => { + if (finished) runOnJS(dismiss)(); + } + ); + } else { + translateY.value = withSpring(0, { damping: 20, stiffness: 220 }); + } + }); + + const contentStyle = useAnimatedStyle(() => ({ + transform: [{ translateY: translateY.value }], + })); return ( - - router.back()} hitSlop={12}> - - - - {track ? ( - <> - - - {track.artworkData ? ( - - ) : ( - - )} + + + + + dismissSheet()} hitSlop={12}> + + + + + PLAYING FROM + + + {source} + + + + - - - {track.title} - - - {track.artist} - {track.album ? ` Β· ${track.album}` : ''} - - - + {track ? ( + <> + + + {track.artworkData ? ( + + ) : ( + + )} + + + + + + + + {track.title} + + + {track.artist} + + + + + + + + void seekTo(seconds)} + /> + + + + + + + + + + + + + + + + + + {SUB_CONTROLS.map((c) => ( + + + + ))} + + + ) : ( + + Nothing playing + + Start a track from Home. + - - - - void seekTo(seconds)} - /> - - - - - - - - - - - - - - - ) : ( - - Nothing playing - - Start a track from Home. - - - )} + )} + + ); } const styles = StyleSheet.create({ - root: { + backdrop: { + flex: 1, + backgroundColor: 'transparent', + }, + content: { flex: 1, backgroundColor: colors.bgPrimary, paddingHorizontal: spacing.xl, }, - close: { - alignSelf: 'flex-start', - padding: spacing.xs, + header: { + flexDirection: 'row', + alignItems: 'center', + justifyContent: 'space-between', }, - artWrap: { - flex: 1, + headerBtn: { + width: 32, + height: 32, alignItems: 'center', justifyContent: 'center', }, + headerMid: { + flex: 1, + alignItems: 'center', + }, + eyebrow: { + color: colors.textTertiary, + letterSpacing: 1.5, + fontSize: 10, + }, + source: { + color: colors.textSecondary, + marginTop: 1, + }, + artWrap: { + alignItems: 'center', + justifyContent: 'center', + marginTop: spacing.lg, + marginBottom: spacing.lg, + }, art: { - width: 260, - height: 260, borderRadius: radius.lg, backgroundColor: colors.bgTertiary, alignItems: 'center', @@ -128,33 +263,54 @@ const styles = StyleSheet.create({ width: '100%', height: '100%', }, - meta: { - marginTop: spacing.xl, + trackInfo: { + marginTop: spacing.md, + alignItems: 'center', }, - subtitle: { + centered: { + textAlign: 'center', + }, + artist: { + color: colors.accentText, marginTop: spacing.xs, }, badges: { marginTop: spacing.md, }, progressBlock: { - marginTop: spacing.md, + marginTop: spacing.lg, + }, + spacer: { + flex: 1, + minHeight: spacing.md, }, transport: { - marginTop: spacing.xl, flexDirection: 'row', alignItems: 'center', justifyContent: 'center', gap: spacing.xxl, }, playButton: { - width: 72, - height: 72, + width: 68, + height: 68, borderRadius: radius.pill, backgroundColor: colors.accent, alignItems: 'center', justifyContent: 'center', }, + subRow: { + flexDirection: 'row', + alignItems: 'center', + justifyContent: 'space-between', + marginTop: spacing.lg, + paddingHorizontal: spacing.sm, + }, + subBtn: { + width: 40, + height: 40, + alignItems: 'center', + justifyContent: 'center', + }, empty: { flex: 1, alignItems: 'center', diff --git a/src/components/MiniPlayer.tsx b/src/components/MiniPlayer.tsx index 970993a..3aa43bb 100644 --- a/src/components/MiniPlayer.tsx +++ b/src/components/MiniPlayer.tsx @@ -1,17 +1,25 @@ -import { View, Pressable, StyleSheet } from 'react-native'; +import { useState } from 'react'; +import { View, Pressable, StyleSheet, type LayoutChangeEvent } from 'react-native'; import { Image } from 'expo-image'; import { Ionicons } from '@expo/vector-icons'; import { useRouter } from 'expo-router'; import { Text } from './Text'; import { AstraLogo } from './AstraLogo'; -import { colors, layout, radius, spacing } from '@/theme'; +import { SpectrumCurve } from './SpectrumCurve'; +import { colors, radius, spacing } from '@/theme'; import { usePlayerStore } from '@/stores/playerStore'; -import { togglePlay } from '@/audio/playbackController'; +import { skipToNext, togglePlay } from '@/audio/playbackController'; +import { useScopeActive } from '@/scope/scopeStore'; +import { useSpectrumCurve } from '@/scope/useSpectrumCurve'; + +const PILL_HEIGHT = 56; +const ART = 42; +const CURVE_POINTS = 64; /** - * Persistent mini-player, rendered above the tab bar. Tapping the bar opens the - * full now-playing screen. The artwork box is where the spectrum "pulse" - * is-playing indicator will live at M3. + * Persistent floating mini-player (M3 redesign): a rounded pill above the tab + * bar with the live filled-line spectrum drifting behind the metadata. Tapping + * opens the full now-playing screen. */ export function MiniPlayer() { const router = useRouter(); @@ -20,24 +28,38 @@ export function MiniPlayer() { const currentTime = usePlayerStore((s) => s.currentTime); const duration = usePlayerStore((s) => s.duration); + const scopeActive = useScopeActive(); + const values = useSpectrumCurve(CURVE_POINTS, scopeActive); + const [pillWidth, setPillWidth] = useState(0); + if (!track) return null; const isPlaying = playbackState === 'playing'; const isLoading = playbackState === 'loading'; const progress = duration > 0 ? Math.min(1, currentTime / duration) : 0; - return ( - - - - + const onLayout = (e: LayoutChangeEvent) => setPillWidth(e.nativeEvent.layout.width); - router.push('/now-playing')}> + return ( + router.push('/now-playing')} onLayout={onLayout}> + {scopeActive && pillWidth > 0 && ( + + + + )} + + {track.artworkData ? ( ) : ( - + )} @@ -50,45 +72,56 @@ export function MiniPlayer() { - + - - + + + + + + + + + ); } const styles = StyleSheet.create({ - container: { - height: layout.miniPlayerHeight, - backgroundColor: colors.bgSecondary, - borderTopColor: colors.glassBorder, - borderTopWidth: StyleSheet.hairlineWidth, + pill: { + height: PILL_HEIGHT, + marginHorizontal: spacing.md, + marginTop: spacing.sm, + marginBottom: spacing.sm, + borderRadius: radius.lg, + backgroundColor: colors.bgTertiary, + borderColor: colors.glassBorder, + borderWidth: StyleSheet.hairlineWidth, + overflow: 'hidden', + justifyContent: 'center', }, - progressTrack: { - height: 2, - backgroundColor: colors.glassBorder, - }, - progressFill: { - height: 2, - backgroundColor: colors.accent, + spectrum: { + position: 'absolute', + top: 0, + left: 0, + right: 0, + bottom: 0, }, row: { - flex: 1, flexDirection: 'row', alignItems: 'center', - paddingHorizontal: spacing.md, - gap: spacing.md, + paddingHorizontal: spacing.sm, + gap: spacing.sm, }, art: { - width: 44, - height: 44, + width: ART, + height: ART, borderRadius: radius.sm, - backgroundColor: colors.bgTertiary, + backgroundColor: colors.bgSecondary, alignItems: 'center', justifyContent: 'center', overflow: 'hidden', @@ -103,12 +136,24 @@ const styles = StyleSheet.create({ title: { fontSize: 15, }, - playButton: { - width: 40, - height: 40, + control: { + width: 36, + height: 36, alignItems: 'center', justifyContent: 'center', }, + progressTrack: { + position: 'absolute', + left: 0, + right: 0, + bottom: 0, + height: 2, + backgroundColor: colors.glassBorder, + }, + progressFill: { + height: 2, + backgroundColor: colors.accent, + }, }); export default MiniPlayer; diff --git a/src/components/SpectrumCurve.tsx b/src/components/SpectrumCurve.tsx new file mode 100644 index 0000000..730ad35 --- /dev/null +++ b/src/components/SpectrumCurve.tsx @@ -0,0 +1,114 @@ +import { useMemo } from 'react'; +import { Canvas, Group, LinearGradient, Path, Skia, vec } from '@shopify/react-native-skia'; +import { colors } from '@/theme'; + +interface SpectrumCurveProps { + /** Normalized magnitudes in [0,1], one per point (see useSpectrumCurve). */ + values: number[]; + width: number; + height: number; + /** Hex line/fill color (e.g. theme accent). Defaults to the cyan accent. */ + color?: string; + lineWidth?: number; + /** 0..1 multiplier on the gradient fill under the line. */ + fillOpacity?: number; + /** Adds a soft wider stroke under the line for a glow. */ + glow?: boolean; +} + +/** #rrggbb -> rgba() with the given alpha. */ +function withAlpha(hex: string, alpha: number): string { + const r = parseInt(hex.slice(1, 3), 16); + const g = parseInt(hex.slice(3, 5), 16); + const b = parseInt(hex.slice(5, 7), 16); + return `rgba(${r}, ${g}, ${b}, ${alpha})`; +} + +/** + * Builds a smooth (quadratic-through-midpoints) path for the line, plus a copy + * closed to the baseline for the gradient fill. Same curve the desktop spectrum + * draws, ported to Skia. + */ +function buildPaths(values: number[], width: number, height: number, pad: number) { + const line = Skia.Path.Make(); + const n = values.length; + if (n < 2 || width <= 0 || height <= 0) return { line, fill: line.copy() }; + + const usableH = height - pad * 2; + const xAt = (i: number) => (i / (n - 1)) * width; + const yAt = (i: number) => { + const v = values[i] < 0 ? 0 : values[i] > 1 ? 1 : values[i]; + return pad + (1 - v) * usableH; + }; + + line.moveTo(xAt(0), yAt(0)); + for (let i = 1; i < n; i++) { + const midX = (xAt(i - 1) + xAt(i)) * 0.5; + const midY = (yAt(i - 1) + yAt(i)) * 0.5; + line.quadTo(xAt(i - 1), yAt(i - 1), midX, midY); + } + line.lineTo(xAt(n - 1), yAt(n - 1)); + + const fill = line.copy(); + fill.lineTo(width, height); + fill.lineTo(0, height); + fill.close(); + + return { line, fill }; +} + +/** + * Filled-line spectrum (the desktop "CURVE" look): a smooth line over a vertical + * gradient fill. Source-agnostic β€” give it normalized values and a size. + */ +export function SpectrumCurve({ + values, + width, + height, + color = colors.accent, + lineWidth = 2, + fillOpacity = 1, + glow = false, +}: SpectrumCurveProps) { + const pad = lineWidth; + const { line, fill } = useMemo( + () => buildPaths(values, width, height, pad), + [values, width, height, pad] + ); + + if (width <= 0 || height <= 0) return null; + + return ( + + + + + + + {glow && ( + + )} + + + ); +} + +export default SpectrumCurve; diff --git a/src/components/Visualizer.tsx b/src/components/Visualizer.tsx new file mode 100644 index 0000000..dc832b6 --- /dev/null +++ b/src/components/Visualizer.tsx @@ -0,0 +1,86 @@ +import { useState } from 'react'; +import { Pressable, StyleSheet, View } from 'react-native'; +import { Ionicons } from '@expo/vector-icons'; +import { Text } from './Text'; +import { SpectrumCurve } from './SpectrumCurve'; +import { colors, spacing } from '@/theme'; +import { useScopeActive } from '@/scope/scopeStore'; +import { useSpectrumCurve } from '@/scope/useSpectrumCurve'; + +const CANVAS_HEIGHT = 96; +const POINTS = 120; + +type Mode = 'spectrum' | 'scope'; + +/** + * Inline visualizer for the now-playing screen β€” no card chrome, it just lives + * in the layout. Tap anywhere on it to switch between the live filled-line + * Spectrum and the Scope (oscilloscope, placeholder until its native path lands). + */ +export function Visualizer({ width }: { width: number }) { + const [mode, setMode] = useState('spectrum'); + const scopeActive = useScopeActive(); + const spectrumActive = scopeActive && mode === 'spectrum'; + const values = useSpectrumCurve(POINTS, spectrumActive); + + const toggle = () => setMode((m) => (m === 'spectrum' ? 'scope' : 'spectrum')); + + return ( + + + + {mode === 'spectrum' ? 'SPECTRUM' : 'SCOPE'} + + + + + + {mode === 'spectrum' ? ( + + ) : ( + + + + OSCILLOSCOPE Β· COMING SOON + + + )} + + + ); +} + +const styles = StyleSheet.create({ + wrap: { + paddingVertical: spacing.xs, + }, + caption: { + flexDirection: 'row', + alignItems: 'center', + justifyContent: 'space-between', + marginBottom: spacing.xs, + }, + captionText: { + color: colors.textTertiary, + letterSpacing: 1.5, + fontSize: 10, + }, + placeholder: { + flex: 1, + alignItems: 'center', + justifyContent: 'center', + gap: spacing.xs, + }, + placeholderText: { + color: colors.textTertiary, + letterSpacing: 1.5, + fontSize: 10, + }, +}); + +export default Visualizer; diff --git a/src/components/WaveformSeekBar.tsx b/src/components/WaveformSeekBar.tsx new file mode 100644 index 0000000..ab3c323 --- /dev/null +++ b/src/components/WaveformSeekBar.tsx @@ -0,0 +1,194 @@ +import { useEffect, useMemo, useRef, useState } from 'react'; +import { View, StyleSheet, type GestureResponderEvent, type LayoutChangeEvent } from 'react-native'; +import { Canvas, Group, Path, Skia, rect } from '@shopify/react-native-skia'; +import { Text } from './Text'; +import { colors, spacing } from '@/theme'; +import { formatDuration } from '@/lib/format'; +import { downsampleWaveform, getWaveform } from '@/scope/waveform'; + +const CANVAS_HEIGHT = 58; +const BAR_WIDTH = 3; +const BAR_GAP = 2; +const MIN_BAR = 0.05; // floor so silent/idle sections still show a sliver +// While a seek is pending, keep showing the target until the player's reported +// position moves off the pre-seek value (`from`) β€” i.e. the seek has landed. +const HOLD_EPS = 0.75; + +interface WaveformSeekBarProps { + currentTime: number; + duration: number; + onSeek: (seconds: number) => void; + /** Identity of the playing track; a pending seek only applies to its own track. */ + trackKey?: string | number; + /** Track file URI used to load/cache the offline waveform peaks. */ + trackPath?: string; +} + +const clamp = (fraction: number) => Math.min(1, Math.max(0, fraction)); + +/** + * Waveform seek bar (M3) β€” ports desktop WaveformSeekBar's look (RMS bars, a + * played/unplayed split, draggable playhead) on Skia, while keeping SeekBar's + * tap/drag + pending-seek "hold" state machine verbatim so seeking behaves + * identically. Peaks load offline (getWaveform) and fall back to flat bars. + */ +export function WaveformSeekBar({ + currentTime, + duration, + onSeek, + trackKey, + trackPath, +}: WaveformSeekBarProps) { + const [scrubFraction, setScrubFraction] = useState(null); + const [barWidth, setBarWidth] = useState(0); + const [pendingSeek, setPendingSeek] = useState<{ + target: number; + from: number; + key?: string | number; + } | null>(null); + // Peaks tagged with the path they belong to, so a track change drops the old + // waveform as a pure derivation (no synchronous setState in the effect). + const [loaded, setLoaded] = useState<{ path: string; peaks: Float32Array | null } | null>(null); + + const widthRef = useRef(0); + const scrubRef = useRef(null); + const grantRef = useRef({ fraction: 0, pageX: 0 }); + + // Load (cache-first) the offline peaks whenever the track changes. + useEffect(() => { + if (!trackPath) return; + let cancelled = false; + void getWaveform(trackPath).then((peaks) => { + if (!cancelled) setLoaded({ path: trackPath, peaks }); + }); + return () => { + cancelled = true; + }; + }, [trackPath]); + + const source = loaded && loaded.path === trackPath ? loaded.peaks : null; + + const setScrub = (fraction: number | null) => { + scrubRef.current = fraction; + setScrubFraction(fraction); + }; + + const onLayout = (event: LayoutChangeEvent) => { + widthRef.current = event.nativeEvent.layout.width; + setBarWidth(event.nativeEvent.layout.width); + }; + + const handleGrant = (event: GestureResponderEvent) => { + const fraction = clamp(event.nativeEvent.locationX / Math.max(1, widthRef.current)); + grantRef.current = { fraction, pageX: event.nativeEvent.pageX }; + setScrub(fraction); + }; + + const handleMove = (event: GestureResponderEvent) => { + const delta = (event.nativeEvent.pageX - grantRef.current.pageX) / Math.max(1, widthRef.current); + setScrub(clamp(grantRef.current.fraction + delta)); + }; + + const handleRelease = () => { + const fraction = scrubRef.current ?? grantRef.current.fraction; + const target = fraction * duration; + // Capture the pre-seek position so we can hold the target until the player + // moves off it. Using `from` (not the target) means the hold releases when + // the seek lands and can never re-engage as playback advances past target. + setPendingSeek({ target, from: currentTime, key: trackKey }); + onSeek(target); + setScrub(null); + }; + + // Displayed position: scrub > held seek target > live progress. Hold while the + // player still reports the stale pre-seek position; release once it jumps. + const holdSeek = + pendingSeek != null && + pendingSeek.key === trackKey && + duration > 0 && + Math.abs(currentTime - pendingSeek.from) < HOLD_EPS; + const liveFraction = duration > 0 ? Math.min(1, currentTime / duration) : 0; + const heldFraction = holdSeek ? clamp(pendingSeek.target / duration) : null; + const fraction = scrubFraction ?? heldFraction ?? liveFraction; + const shownTime = fraction * duration; + + const barCount = Math.max(1, Math.floor(barWidth / (BAR_WIDTH + BAR_GAP))); + + // Build one Skia path of all bars (rounded rects). Drawn twice with a clip + // split at the playhead: played in accent, unplayed in glassBorder. + const barsPath = useMemo(() => { + const path = Skia.Path.Make(); + if (barWidth <= 0) return path; + const display = source + ? downsampleWaveform(source, barCount) + : new Float32Array(barCount).fill(MIN_BAR); + const r = BAR_WIDTH / 2; + for (let i = 0; i < barCount; i++) { + const amp = Math.max(MIN_BAR, display[i] ?? MIN_BAR); + const h = amp * CANVAS_HEIGHT; + const x = i * (BAR_WIDTH + BAR_GAP); + const y = (CANVAS_HEIGHT - h) / 2; + path.addRRect(Skia.RRectXY(Skia.XYWHRect(x, y, BAR_WIDTH, h), r, r)); + } + return path; + }, [source, barCount, barWidth]); + + const splitX = fraction * barWidth; + + return ( + + duration > 0} + onMoveShouldSetResponder={() => duration > 0} + onResponderTerminationRequest={() => false} + onResponderGrant={handleGrant} + onResponderMove={handleMove} + onResponderRelease={handleRelease} + onResponderTerminate={() => setScrub(null)} + accessibilityRole="adjustable" + accessibilityLabel="Seek" + accessibilityValue={{ min: 0, max: Math.round(duration), now: Math.round(shownTime) }} + > + + + + + + + + + + + + {formatDuration(shownTime)} + + + {formatDuration(duration)} + + + + ); +} + +const styles = StyleSheet.create({ + touchArea: { + justifyContent: 'center', + height: CANVAS_HEIGHT + spacing.md * 2, // generous touch target around the canvas + }, + times: { + flexDirection: 'row', + justifyContent: 'space-between', + marginTop: spacing.xs, + }, + time: { + color: colors.textTertiary, + fontSize: 13, + }, + timeActive: { + color: colors.accentText, + }, +}); + +export default WaveformSeekBar; diff --git a/src/db/schema.ts b/src/db/schema.ts index c866503..4214bc8 100644 --- a/src/db/schema.ts +++ b/src/db/schema.ts @@ -2,11 +2,13 @@ // src/main/services/library.ts). v1 covers M1 (local scan + browse); // v2 adds playlists + favorites (M2); v3 forces re-extraction of tracks whose // non-ASCII tags were truncated by the pre-fix op-sqlite binding (see database.ts); -// v4 adds a key-value settings table (artist grouping mode, future prefs). +// v4 adds a key-value settings table (artist grouping mode, future prefs); +// v5 caches offline waveform peaks for the M3 waveform seek bar; v6 repairs DBs +// that an abandoned earlier M3 spike left at v5 with a stale `waveform_cache`. import type { LibraryDatabase } from './database'; -export const SCHEMA_VERSION = 4; +export const SCHEMA_VERSION = 6; // One statement per entry β€” op-sqlite executes single statements. const MIGRATIONS: readonly (readonly string[])[] = [ @@ -90,6 +92,29 @@ const MIGRATIONS: readonly (readonly string[])[] = [ value TEXT NOT NULL )`, ], + // v4 -> v5 β€” cached waveform peaks (offline RMS bins) for the seek bar. + // Keyed by track path (SAF URI), no FK β€” survives folder removal/re-grant + // like favorites/playlists. `peaks` is a tightly-packed Float32 LE blob. + [ + `CREATE TABLE IF NOT EXISTS waveform_peaks ( + track_path TEXT PRIMARY KEY NOT NULL, + bins INTEGER NOT NULL, + peaks BLOB NOT NULL, + created_at INTEGER NOT NULL + )`, + ], + // v5 -> v6 β€” repair: an abandoned earlier M3 spike shipped a v5 that created a + // different `waveform_cache` table, leaving such DBs at v5 without the + // `waveform_peaks` table above. Create it if missing and drop the orphan. + [ + `CREATE TABLE IF NOT EXISTS waveform_peaks ( + track_path TEXT PRIMARY KEY NOT NULL, + bins INTEGER NOT NULL, + peaks BLOB NOT NULL, + created_at INTEGER NOT NULL + )`, + `DROP TABLE IF EXISTS waveform_cache`, + ], ]; export async function migrate(db: LibraryDatabase): Promise { diff --git a/src/db/waveformQueries.ts b/src/db/waveformQueries.ts new file mode 100644 index 0000000..dfdbbc0 --- /dev/null +++ b/src/db/waveformQueries.ts @@ -0,0 +1,45 @@ +// Waveform peak cache β€” offline RMS bins for the M3 waveform seek bar. +// Keyed by track path (SAF URI), mirroring favorites/playlists (no FK, so a row +// survives folder removal and resolves again on re-grant). Peaks are normalized +// to [0, 1] and stored as a tightly-packed Float32 little-endian blob. + +import type { LibraryDatabase } from './database'; + +export async function getWaveformPeaks( + db: LibraryDatabase, + trackPath: string +): Promise { + const row = await db.get<{ peaks: ArrayBuffer | ArrayBufferView }>( + 'SELECT peaks FROM waveform_peaks WHERE track_path = ?', + [trackPath] + ); + return row ? toFloat32(row.peaks) : null; +} + +export async function putWaveformPeaks( + db: LibraryDatabase, + trackPath: string, + peaks: Float32Array +): Promise { + // Bind the typed-array view directly (a valid ArrayBufferView Scalar); copy to + // a tight view first if it's a window into a larger buffer. + const tight = + peaks.byteOffset === 0 && peaks.byteLength === peaks.buffer.byteLength + ? peaks + : peaks.slice(); + await db.run( + `INSERT INTO waveform_peaks (track_path, bins, peaks, created_at) + VALUES (?, ?, ?, ?) + ON CONFLICT(track_path) DO UPDATE SET + bins = excluded.bins, peaks = excluded.peaks, created_at = excluded.created_at`, + [trackPath, peaks.length, tight, Date.now()] + ); +} + +function toFloat32(blob: ArrayBuffer | ArrayBufferView): Float32Array { + if (blob instanceof Float32Array) return blob; + if (ArrayBuffer.isView(blob)) { + return new Float32Array(blob.buffer, blob.byteOffset, Math.floor(blob.byteLength / 4)); + } + return new Float32Array(blob); +} diff --git a/src/scope/scopeStore.ts b/src/scope/scopeStore.ts new file mode 100644 index 0000000..44462ed --- /dev/null +++ b/src/scope/scopeStore.ts @@ -0,0 +1,18 @@ +import { create } from 'zustand'; + +/** + * Whether the visualizers should run. Set by useScopeLifecycle (foreground + + * playing + not reduced-motion) and read by the scope components so they only + * spin their frame loop when something is actually visible and moving. + */ +interface ScopeStore { + active: boolean; + setActive: (active: boolean) => void; +} + +export const useScopeStore = create((set) => ({ + active: false, + setActive: (active) => set({ active }), +})); + +export const useScopeActive = (): boolean => useScopeStore((s) => s.active); diff --git a/src/scope/useScopeLifecycle.ts b/src/scope/useScopeLifecycle.ts new file mode 100644 index 0000000..ec96a02 --- /dev/null +++ b/src/scope/useScopeLifecycle.ts @@ -0,0 +1,48 @@ +import { useEffect } from 'react'; +import { AccessibilityInfo, AppState } from 'react-native'; +import { AstraScope } from '../../modules/astra-scope'; +import { usePlayerStore } from '@/stores/playerStore'; +import { useScopeStore } from './scopeStore'; + +/** + * Single owner of the scope on/off gate. Visualizers run only when the app is + * foregrounded, audio is playing, and reduced-motion is off β€” which also stops + * the native PCM tap (AstraScope.setActive) so a backgrounded/paused app pays + * ~nothing in the audio callback. Mount once near the root. + */ +export function useScopeLifecycle(): void { + useEffect(() => { + let reduceMotion = false; + let appActive = AppState.currentState === 'active'; + + const recompute = () => { + const playing = usePlayerStore.getState().playbackState === 'playing'; + const on = playing && appActive && !reduceMotion; + AstraScope.setActive(on); + useScopeStore.getState().setActive(on); + }; + + const appSub = AppState.addEventListener('change', (state) => { + appActive = state === 'active'; + recompute(); + }); + const rmSub = AccessibilityInfo.addEventListener('reduceMotionChanged', (enabled) => { + reduceMotion = enabled; + recompute(); + }); + const unsubPlayer = usePlayerStore.subscribe(recompute); + void AccessibilityInfo.isReduceMotionEnabled().then((enabled) => { + reduceMotion = enabled; + recompute(); + }); + recompute(); + + return () => { + appSub.remove(); + rmSub.remove(); + unsubPlayer(); + AstraScope.setActive(false); + useScopeStore.getState().setActive(false); + }; + }, []); +} diff --git a/src/scope/useSpectrumCurve.ts b/src/scope/useSpectrumCurve.ts new file mode 100644 index 0000000..9e0932b --- /dev/null +++ b/src/scope/useSpectrumCurve.ts @@ -0,0 +1,91 @@ +import { useEffect, useMemo, useState } from 'react'; +import { AstraScope, SPECTRUM_BINS } from '../../modules/astra-scope'; + +const FRAME_MS = 32; // ~30fps β€” ambient, battery-friendly + +// Display window (dB). Tighter than the raw [-100,0] capture range so music +// fills the curve with punch instead of hugging the floor. +const DISPLAY_DB_MIN = -88; +const DISPLAY_DB_MAX = -16; +const DB_RANGE = DISPLAY_DB_MAX - DISPLAY_DB_MIN; + +// Map points across a log-frequency (geometric bin) axis like the desktop +// SpectrumAnalyzer, so the low end isn't squashed. Skip DC/rumble at the bottom. +const BIN_LOW = 2; +const BIN_HIGH = SPECTRUM_BINS - 1; +// Gentle upward tilt (dB/octave) so the curve reads as a shape, not a downward +// ramp dominated by bass β€” same idea as the desktop's spectrum tilt. +const TILT_DB_PER_OCT = 2; + +// Temporal smoothing: rise instantly, fall smoothly, for a fluid line. +const RELEASE = 0.72; + +// One reused buffer across all consumers: getSpectrumFrame fills it in place and +// we read it out synchronously on the JS thread, so a module-level buffer is safe. +const buffer = new Float32Array(SPECTRUM_BINS); + +/** + * Pulls the latest spectrum from the native tap on a JS-thread rAF loop (while + * `active`) and returns `pointCount` magnitudes in [0,1] sampled on a + * log-frequency axis, smoothed over time. Feeds the filled-line {@link + * SpectrumCurve}. Returns all-zero (flat) points when inactive β€” no loop, no + * setState β€” so callers render a clean baseline. + */ +export function useSpectrumCurve(pointCount: number, active: boolean): number[] { + const [values, setValues] = useState(() => new Array(pointCount).fill(0)); + const zeros = useMemo(() => new Array(pointCount).fill(0), [pointCount]); + + useEffect(() => { + if (!active) return; // inactive: no loop, no setState; caller gets `zeros` + let mounted = true; + let raf = 0; + let last = 0; + + const smoothed = new Float32Array(pointCount); + const logLow = Math.log(BIN_LOW); + const logHigh = Math.log(BIN_HIGH); + const binAt = (t: number) => Math.exp(logLow + t * (logHigh - logLow)); + const refBin = binAt(0.5); // tilt pivot (midband) + + const tick = (t: number) => { + if (!mounted) return; + raf = requestAnimationFrame(tick); + if (t - last < FRAME_MS) return; + last = t; + if (AstraScope.getSpectrumFrame(buffer) <= 0) return; + + const out = new Array(pointCount); + for (let p = 0; p < pointCount; p++) { + const b0 = binAt(p / pointCount); + const b1 = binAt((p + 1) / pointCount); + const lo = Math.max(BIN_LOW, Math.floor(b0)); + const hi = Math.min(BIN_HIGH, Math.max(lo, Math.ceil(b1))); + + // Peak (loudest bin) across the band β€” punchier than an average. + let db = -200; + for (let i = lo; i <= hi; i++) if (buffer[i] > db) db = buffer[i]; + + const octaves = Math.log2(Math.max(1, (b0 + b1) * 0.5) / refBin); + db += TILT_DB_PER_OCT * octaves; + + let norm = (db - DISPLAY_DB_MIN) / DB_RANGE; + if (norm < 0) norm = 0; + else if (norm > 1) norm = 1; + + const prev = smoothed[p]; + const next = norm >= prev ? norm : prev * RELEASE + norm * (1 - RELEASE); + smoothed[p] = next; + out[p] = next; + } + setValues(out); + }; + + raf = requestAnimationFrame(tick); + return () => { + mounted = false; + cancelAnimationFrame(raf); + }; + }, [active, pointCount]); + + return active ? values : zeros; +} diff --git a/src/scope/waveform.ts b/src/scope/waveform.ts new file mode 100644 index 0000000..8b81bbd --- /dev/null +++ b/src/scope/waveform.ts @@ -0,0 +1,80 @@ +// Waveform peaks for the seek bar: cache-first, decode-on-miss, store. The heavy +// native decode (AstraLibraryScanner.extractWaveform) runs once per track and the +// result is cached in SQLite; downsampleWaveform shapes the cached high-res peaks +// to the display's bar count at render time (ported from desktop waveformExtractor). + +import { AstraLibraryScanner } from '../../modules/astra-library-scanner'; +import { openLibraryDb } from '@/db/database'; +import { getWaveformPeaks, putWaveformPeaks } from '@/db/waveformQueries'; + +export const WAVEFORM_BINS = 512; + +// Dedupe concurrent requests for the same track (e.g. mini-player + now-playing). +const inflight = new Map>(); + +export function getWaveform(trackPath: string): Promise { + const existing = inflight.get(trackPath); + if (existing) return existing; + const task = loadWaveform(trackPath).finally(() => inflight.delete(trackPath)); + inflight.set(trackPath, task); + return task; +} + +async function loadWaveform(trackPath: string): Promise { + const db = await openLibraryDb(); + const cached = await getWaveformPeaks(db, trackPath); + if (cached && cached.length > 0) return cached; + + let raw: number[]; + try { + raw = await AstraLibraryScanner.extractWaveform(trackPath, WAVEFORM_BINS); + } catch { + return null; + } + if (!raw || raw.length === 0) return null; + + const peaks = Float32Array.from(raw); + await putWaveformPeaks(db, trackPath, peaks).catch(() => { + /* cache write failure is non-fatal */ + }); + return peaks; +} + +/** + * Downsample high-res peaks to `barCount` bars with a power curve and two + * smoothing passes. Ported verbatim from desktop waveformExtractor.ts so the + * mobile seek bar matches the desktop look. + */ +export function downsampleWaveform(source: Float32Array, barCount: number): Float32Array { + if (source.length === 0 || barCount <= 0) return new Float32Array(0); + const binsPerBar = source.length / barCount; + const peaks = new Float32Array(barCount); + + for (let i = 0; i < barCount; i++) { + const start = Math.floor(i * binsPerBar); + const end = Math.max(start + 1, Math.floor((i + 1) * binsPerBar)); + let sum = 0; + for (let j = start; j < end; j++) sum += source[j]; + peaks[i] = sum / (end - start); + } + + let max = 0; + for (let i = 0; i < barCount; i++) if (peaks[i] > max) max = peaks[i]; + if (max > 0) for (let i = 0; i < barCount; i++) peaks[i] /= max; + + // Power curve β€” exaggerate dynamic range. + for (let i = 0; i < barCount; i++) peaks[i] = peaks[i] ** 2; + + // Two smoothing passes. + let current = peaks; + for (let p = 0; p < 2; p++) { + const smoothed = new Float32Array(current.length); + smoothed[0] = current[0]; + smoothed[current.length - 1] = current[current.length - 1]; + for (let i = 1; i < current.length - 1; i++) { + smoothed[i] = current[i - 1] * 0.25 + current[i] * 0.5 + current[i + 1] * 0.25; + } + current = smoothed; + } + return current; +} diff --git a/src/theme/colors.ts b/src/theme/colors.ts index 8079170..3a9ba26 100644 --- a/src/theme/colors.ts +++ b/src/theme/colors.ts @@ -1,32 +1,33 @@ /** - * Astra color tokens β€” ported from desktop `src/renderer/styles/globals.css`. - * Dark-only on mobile (the desktop app is dark-only too). + * Astra color tokens. Dark-only. M3 redesign shifted the palette from + * cyan-on-black toward a softer indigo-on-navy "mobile-first" language; these + * tokens are the single source of truth, so a future theming pass can swap them. */ export const colors = { - // Base backgrounds - bgPrimary: '#000000', - bgSecondary: '#050505', - bgTertiary: '#0a0a0a', + // Base backgrounds (navy) + bgPrimary: '#080a0f', + bgSecondary: '#0c0f18', + bgTertiary: '#11162a', - // Glass / surface overlays (white alphas) - glassBg: 'rgba(255, 255, 255, 0.03)', - glassBorder: 'rgba(255, 255, 255, 0.08)', - glassHighlight: 'rgba(255, 255, 255, 0.05)', + // Glass / surface overlays (subtle blue-tinted alphas) + glassBg: 'rgba(124, 146, 196, 0.05)', + glassBorder: 'rgba(124, 146, 196, 0.16)', + glassHighlight: 'rgba(140, 162, 208, 0.08)', - // Text (white alphas) - textPrimary: 'rgba(255, 255, 255, 0.95)', - textSecondary: 'rgba(255, 255, 255, 0.6)', - textTertiary: 'rgba(255, 255, 255, 0.4)', + // Text (blue-tinted neutrals) + textPrimary: '#e2e8f4', + textSecondary: '#8a98b8', + textTertiary: '#52607f', // Warning amber (desktop .graph-meta-chip-warning) warning: '#f3d27d', - // Cyan accent - accent: '#38bdf8', - accentHover: '#7dd3fc', - accentGlow: 'rgba(56, 189, 248, 0.3)', - accentText: '#bae6fd', - accentTextStrong: '#e0f2fe', + // Indigo accent + accent: '#5b8aff', + accentHover: '#82a6ff', + accentGlow: 'rgba(91, 138, 255, 0.3)', + accentText: '#a9c0ff', + accentTextStrong: '#d6e2ff', // Astra mark fills (hsl(198 …) from the desktop logo) logoMain: '#00b3ff', // hsl(198 100% 50%) diff --git a/vendor/kotlinaudio/LICENSE b/vendor/kotlinaudio/LICENSE new file mode 100644 index 0000000..56313a2 --- /dev/null +++ b/vendor/kotlinaudio/LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright 2022 Double Symmetry GmbH + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/vendor/kotlinaudio/kotlin-audio/build.gradle b/vendor/kotlinaudio/kotlin-audio/build.gradle new file mode 100644 index 0000000..c7440d9 --- /dev/null +++ b/vendor/kotlinaudio/kotlin-audio/build.gradle @@ -0,0 +1,42 @@ +// Vendored fork of com.github.doublesymmetry:kotlinaudio v2.1.0 (Apache-2.0). +// Substituted in for the Jitpack binary so we can inject a PCM-tap AudioProcessor +// into the ExoPlayer it builds (see players/BaseAudioPlayer.kt + scope/). The +// ONLY source change vs upstream v2.1.0 is the single .setRenderersFactory(...) +// line in BaseAudioPlayer's init and the new scope/ package. Keep that diff +// minimal so re-vendoring on a kotlin-audio bump stays mechanical. + +plugins { + id 'com.android.library' + id 'org.jetbrains.kotlin.android' +} + +android { + namespace = "com.doublesymmetry.kotlinaudio" + compileSdk rootProject.ext.compileSdkVersion + + defaultConfig { + minSdk rootProject.ext.minSdkVersion + } + + compileOptions { + sourceCompatibility JavaVersion.VERSION_17 + targetCompatibility JavaVersion.VERSION_17 + } + kotlinOptions { + jvmTarget = '17' + } + lintOptions { + abortOnError false + } +} + +dependencies { + implementation 'io.coil-kt:coil:2.2.0' + implementation 'androidx.media:media:1.6.0' + api 'com.google.android.exoplayer:exoplayer:2.19.0' + api 'com.google.android.exoplayer:extension-mediasession:2.19.0' + api 'com.jakewharton.timber:timber:5.0.1' + + // The PCM tap forwards to expo.modules.astrascope.ScopeBridge. + implementation project(':astra-scope') +} diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/7a308bbc4fe84868415859cf0cc55834/results.bin b/vendor/kotlinaudio/kotlin-audio/build/.transforms/7a308bbc4fe84868415859cf0cc55834/results.bin new file mode 100644 index 0000000..0d259dd --- /dev/null +++ b/vendor/kotlinaudio/kotlin-audio/build/.transforms/7a308bbc4fe84868415859cf0cc55834/results.bin @@ -0,0 +1 @@ +o/classes diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/7a308bbc4fe84868415859cf0cc55834/transformed/classes/classes_dex/classes.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/7a308bbc4fe84868415859cf0cc55834/transformed/classes/classes_dex/classes.dex new file mode 100644 index 0000000..e8ea8d5 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/7a308bbc4fe84868415859cf0cc55834/transformed/classes/classes_dex/classes.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/results.bin b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/results.bin new file mode 100644 index 0000000..7ed749e --- /dev/null +++ b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/results.bin @@ -0,0 +1 @@ +o/bundleLibRuntimeToDirDebug diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/BuildConfig.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/BuildConfig.dex new file mode 100644 index 0000000..00e0091 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/BuildConfig.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/event/EventHolder.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/event/EventHolder.dex new file mode 100644 index 0000000..1e59ed6 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/event/EventHolder.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/event/NotificationEventHolder$updateNotificationState$1.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/event/NotificationEventHolder$updateNotificationState$1.dex new file mode 100644 index 0000000..ff7efe9 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/event/NotificationEventHolder$updateNotificationState$1.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/event/NotificationEventHolder.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/event/NotificationEventHolder.dex new file mode 100644 index 0000000..cc956df Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/event/NotificationEventHolder.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/event/PlayerEventHolder$updateAudioItemTransition$1.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/event/PlayerEventHolder$updateAudioItemTransition$1.dex new file mode 100644 index 0000000..21b9cc3 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/event/PlayerEventHolder$updateAudioItemTransition$1.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/event/PlayerEventHolder$updateAudioPlayerState$1.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/event/PlayerEventHolder$updateAudioPlayerState$1.dex new file mode 100644 index 0000000..fa21774 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/event/PlayerEventHolder$updateAudioPlayerState$1.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/event/PlayerEventHolder$updateOnAudioFocusChanged$1.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/event/PlayerEventHolder$updateOnAudioFocusChanged$1.dex new file mode 100644 index 0000000..eb11dd6 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/event/PlayerEventHolder$updateOnAudioFocusChanged$1.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/event/PlayerEventHolder$updateOnCommonMetadata$1.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/event/PlayerEventHolder$updateOnCommonMetadata$1.dex new file mode 100644 index 0000000..f990063 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/event/PlayerEventHolder$updateOnCommonMetadata$1.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/event/PlayerEventHolder$updateOnPlayerActionTriggeredExternally$1.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/event/PlayerEventHolder$updateOnPlayerActionTriggeredExternally$1.dex new file mode 100644 index 0000000..fc83458 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/event/PlayerEventHolder$updateOnPlayerActionTriggeredExternally$1.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/event/PlayerEventHolder$updateOnTimedMetadata$1.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/event/PlayerEventHolder$updateOnTimedMetadata$1.dex new file mode 100644 index 0000000..7906305 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/event/PlayerEventHolder$updateOnTimedMetadata$1.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/event/PlayerEventHolder$updatePlayWhenReadyChange$1.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/event/PlayerEventHolder$updatePlayWhenReadyChange$1.dex new file mode 100644 index 0000000..c7baf90 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/event/PlayerEventHolder$updatePlayWhenReadyChange$1.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/event/PlayerEventHolder$updatePlaybackEndedReason$1.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/event/PlayerEventHolder$updatePlaybackEndedReason$1.dex new file mode 100644 index 0000000..ceada62 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/event/PlayerEventHolder$updatePlaybackEndedReason$1.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/event/PlayerEventHolder$updatePlaybackError$1.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/event/PlayerEventHolder$updatePlaybackError$1.dex new file mode 100644 index 0000000..a181b7b Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/event/PlayerEventHolder$updatePlaybackError$1.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/event/PlayerEventHolder$updatePositionChangedReason$1.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/event/PlayerEventHolder$updatePositionChangedReason$1.dex new file mode 100644 index 0000000..44f2990 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/event/PlayerEventHolder$updatePositionChangedReason$1.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/event/PlayerEventHolder.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/event/PlayerEventHolder.dex new file mode 100644 index 0000000..a13cf85 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/event/PlayerEventHolder.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/AudioContentType.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/AudioContentType.dex new file mode 100644 index 0000000..6bda98e Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/AudioContentType.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/AudioItem.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/AudioItem.dex new file mode 100644 index 0000000..d694fa9 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/AudioItem.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/AudioItemHolder.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/AudioItemHolder.dex new file mode 100644 index 0000000..4f040cf Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/AudioItemHolder.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/AudioItemOptions.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/AudioItemOptions.dex new file mode 100644 index 0000000..7a499f4 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/AudioItemOptions.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/AudioItemTransitionReason$AUTO.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/AudioItemTransitionReason$AUTO.dex new file mode 100644 index 0000000..fbd9304 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/AudioItemTransitionReason$AUTO.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/AudioItemTransitionReason$QUEUE_CHANGED.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/AudioItemTransitionReason$QUEUE_CHANGED.dex new file mode 100644 index 0000000..9c3246f Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/AudioItemTransitionReason$QUEUE_CHANGED.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/AudioItemTransitionReason$REPEAT.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/AudioItemTransitionReason$REPEAT.dex new file mode 100644 index 0000000..ec9aaeb Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/AudioItemTransitionReason$REPEAT.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/AudioItemTransitionReason$SEEK_TO_ANOTHER_AUDIO_ITEM.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/AudioItemTransitionReason$SEEK_TO_ANOTHER_AUDIO_ITEM.dex new file mode 100644 index 0000000..e95c6fc Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/AudioItemTransitionReason$SEEK_TO_ANOTHER_AUDIO_ITEM.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/AudioItemTransitionReason.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/AudioItemTransitionReason.dex new file mode 100644 index 0000000..d2be831 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/AudioItemTransitionReason.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/AudioPlayerState.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/AudioPlayerState.dex new file mode 100644 index 0000000..3b6c2b8 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/AudioPlayerState.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/BufferConfig.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/BufferConfig.dex new file mode 100644 index 0000000..dd53883 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/BufferConfig.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/CacheConfig.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/CacheConfig.dex new file mode 100644 index 0000000..7b7e1ac Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/CacheConfig.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/Capability.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/Capability.dex new file mode 100644 index 0000000..5b25ac0 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/Capability.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/DefaultAudioItem.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/DefaultAudioItem.dex new file mode 100644 index 0000000..d028179 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/DefaultAudioItem.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/DefaultPlayerOptions.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/DefaultPlayerOptions.dex new file mode 100644 index 0000000..2cde7be Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/DefaultPlayerOptions.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/DefaultQueuedPlayerOptions$WhenMappings.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/DefaultQueuedPlayerOptions$WhenMappings.dex new file mode 100644 index 0000000..2b307b3 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/DefaultQueuedPlayerOptions$WhenMappings.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/DefaultQueuedPlayerOptions.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/DefaultQueuedPlayerOptions.dex new file mode 100644 index 0000000..b619a6c Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/DefaultQueuedPlayerOptions.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/FocusChangeData.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/FocusChangeData.dex new file mode 100644 index 0000000..1086c11 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/FocusChangeData.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/MediaSessionCallback$FORWARD.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/MediaSessionCallback$FORWARD.dex new file mode 100644 index 0000000..1121e8f Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/MediaSessionCallback$FORWARD.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/MediaSessionCallback$NEXT.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/MediaSessionCallback$NEXT.dex new file mode 100644 index 0000000..acec27e Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/MediaSessionCallback$NEXT.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/MediaSessionCallback$PAUSE.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/MediaSessionCallback$PAUSE.dex new file mode 100644 index 0000000..e3966ba Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/MediaSessionCallback$PAUSE.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/MediaSessionCallback$PLAY.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/MediaSessionCallback$PLAY.dex new file mode 100644 index 0000000..2a6f851 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/MediaSessionCallback$PLAY.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/MediaSessionCallback$PREVIOUS.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/MediaSessionCallback$PREVIOUS.dex new file mode 100644 index 0000000..3fae361 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/MediaSessionCallback$PREVIOUS.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/MediaSessionCallback$RATING.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/MediaSessionCallback$RATING.dex new file mode 100644 index 0000000..8939760 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/MediaSessionCallback$RATING.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/MediaSessionCallback$REWIND.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/MediaSessionCallback$REWIND.dex new file mode 100644 index 0000000..c1e6651 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/MediaSessionCallback$REWIND.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/MediaSessionCallback$SEEK.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/MediaSessionCallback$SEEK.dex new file mode 100644 index 0000000..f3cc01c Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/MediaSessionCallback$SEEK.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/MediaSessionCallback$STOP.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/MediaSessionCallback$STOP.dex new file mode 100644 index 0000000..2e08bf1 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/MediaSessionCallback$STOP.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/MediaSessionCallback.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/MediaSessionCallback.dex new file mode 100644 index 0000000..4cd4b54 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/MediaSessionCallback.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/MediaType.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/MediaType.dex new file mode 100644 index 0000000..eb0e39a Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/MediaType.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/NotificationButton$BACKWARD.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/NotificationButton$BACKWARD.dex new file mode 100644 index 0000000..b7c37f1 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/NotificationButton$BACKWARD.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/NotificationButton$FORWARD.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/NotificationButton$FORWARD.dex new file mode 100644 index 0000000..d4dbd61 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/NotificationButton$FORWARD.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/NotificationButton$NEXT.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/NotificationButton$NEXT.dex new file mode 100644 index 0000000..f09d9c2 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/NotificationButton$NEXT.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/NotificationButton$PLAY_PAUSE.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/NotificationButton$PLAY_PAUSE.dex new file mode 100644 index 0000000..ed6a621 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/NotificationButton$PLAY_PAUSE.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/NotificationButton$PREVIOUS.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/NotificationButton$PREVIOUS.dex new file mode 100644 index 0000000..05c67fe Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/NotificationButton$PREVIOUS.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/NotificationButton$SEEK_TO.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/NotificationButton$SEEK_TO.dex new file mode 100644 index 0000000..6a84295 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/NotificationButton$SEEK_TO.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/NotificationButton$STOP.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/NotificationButton$STOP.dex new file mode 100644 index 0000000..274e131 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/NotificationButton$STOP.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/NotificationButton.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/NotificationButton.dex new file mode 100644 index 0000000..3e32276 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/NotificationButton.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/NotificationConfig.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/NotificationConfig.dex new file mode 100644 index 0000000..516698d Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/NotificationConfig.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/NotificationState$CANCELLED.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/NotificationState$CANCELLED.dex new file mode 100644 index 0000000..aff1814 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/NotificationState$CANCELLED.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/NotificationState$POSTED.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/NotificationState$POSTED.dex new file mode 100644 index 0000000..4fa619e Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/NotificationState$POSTED.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/NotificationState.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/NotificationState.dex new file mode 100644 index 0000000..d1388be Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/NotificationState.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/PlayWhenReadyChangeData.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/PlayWhenReadyChangeData.dex new file mode 100644 index 0000000..d01ec50 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/PlayWhenReadyChangeData.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/PlaybackEndedReason.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/PlaybackEndedReason.dex new file mode 100644 index 0000000..a64b92b Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/PlaybackEndedReason.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/PlaybackError.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/PlaybackError.dex new file mode 100644 index 0000000..27fe065 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/PlaybackError.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/PlayerConfig.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/PlayerConfig.dex new file mode 100644 index 0000000..eb1d395 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/PlayerConfig.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/PlayerOptions.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/PlayerOptions.dex new file mode 100644 index 0000000..48a3eeb Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/PlayerOptions.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/PositionChangedReason$AUTO.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/PositionChangedReason$AUTO.dex new file mode 100644 index 0000000..83c1fdb Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/PositionChangedReason$AUTO.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/PositionChangedReason$QUEUE_CHANGED.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/PositionChangedReason$QUEUE_CHANGED.dex new file mode 100644 index 0000000..0dac458 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/PositionChangedReason$QUEUE_CHANGED.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/PositionChangedReason$SEEK.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/PositionChangedReason$SEEK.dex new file mode 100644 index 0000000..ac9def6 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/PositionChangedReason$SEEK.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/PositionChangedReason$SEEK_FAILED.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/PositionChangedReason$SEEK_FAILED.dex new file mode 100644 index 0000000..9648b0c Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/PositionChangedReason$SEEK_FAILED.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/PositionChangedReason$SKIPPED_PERIOD.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/PositionChangedReason$SKIPPED_PERIOD.dex new file mode 100644 index 0000000..1b6dc0c Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/PositionChangedReason$SKIPPED_PERIOD.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/PositionChangedReason$UNKNOWN.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/PositionChangedReason$UNKNOWN.dex new file mode 100644 index 0000000..76d1bb2 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/PositionChangedReason$UNKNOWN.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/PositionChangedReason.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/PositionChangedReason.dex new file mode 100644 index 0000000..c8d5985 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/PositionChangedReason.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/QueuedPlayerOptions.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/QueuedPlayerOptions.dex new file mode 100644 index 0000000..b01d7ce Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/QueuedPlayerOptions.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/RepeatMode$Companion.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/RepeatMode$Companion.dex new file mode 100644 index 0000000..821c1f5 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/RepeatMode$Companion.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/RepeatMode.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/RepeatMode.dex new file mode 100644 index 0000000..03ca414 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/RepeatMode.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/WakeMode.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/WakeMode.dex new file mode 100644 index 0000000..7cdbd60 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/models/WakeMode.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/notification/NotificationManager$1.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/notification/NotificationManager$1.dex new file mode 100644 index 0000000..625351c Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/notification/NotificationManager$1.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/notification/NotificationManager$Companion.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/notification/NotificationManager$Companion.dex new file mode 100644 index 0000000..72bd9ef Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/notification/NotificationManager$Companion.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/notification/NotificationManager$createMediaSessionAction$1.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/notification/NotificationManager$createMediaSessionAction$1.dex new file mode 100644 index 0000000..2b5b8d1 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/notification/NotificationManager$createMediaSessionAction$1.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/notification/NotificationManager$createNotification$1.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/notification/NotificationManager$createNotification$1.dex new file mode 100644 index 0000000..555010a Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/notification/NotificationManager$createNotification$1.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/notification/NotificationManager$customActionReceiver$1.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/notification/NotificationManager$customActionReceiver$1.dex new file mode 100644 index 0000000..c709a27 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/notification/NotificationManager$customActionReceiver$1.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/notification/NotificationManager$descriptionAdapter$1$getCurrentLargeIcon$$inlined$target$default$1.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/notification/NotificationManager$descriptionAdapter$1$getCurrentLargeIcon$$inlined$target$default$1.dex new file mode 100644 index 0000000..d7d6b05 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/notification/NotificationManager$descriptionAdapter$1$getCurrentLargeIcon$$inlined$target$default$1.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/notification/NotificationManager$descriptionAdapter$1.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/notification/NotificationManager$descriptionAdapter$1.dex new file mode 100644 index 0000000..b016024 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/notification/NotificationManager$descriptionAdapter$1.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/notification/NotificationManager$destroy$1.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/notification/NotificationManager$destroy$1.dex new file mode 100644 index 0000000..84484bd Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/notification/NotificationManager$destroy$1.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/notification/NotificationManager$invalidate$1.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/notification/NotificationManager$invalidate$1.dex new file mode 100644 index 0000000..8493177 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/notification/NotificationManager$invalidate$1.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/notification/NotificationManager$onNotificationCancelled$1.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/notification/NotificationManager$onNotificationCancelled$1.dex new file mode 100644 index 0000000..5076880 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/notification/NotificationManager$onNotificationCancelled$1.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/notification/NotificationManager$onNotificationPosted$1.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/notification/NotificationManager$onNotificationPosted$1.dex new file mode 100644 index 0000000..861645e Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/notification/NotificationManager$onNotificationPosted$1.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/notification/NotificationManager$showForwardButton$1.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/notification/NotificationManager$showForwardButton$1.dex new file mode 100644 index 0000000..c45671a Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/notification/NotificationManager$showForwardButton$1.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/notification/NotificationManager$showForwardButtonCompact$1.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/notification/NotificationManager$showForwardButtonCompact$1.dex new file mode 100644 index 0000000..fe5ef89 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/notification/NotificationManager$showForwardButtonCompact$1.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/notification/NotificationManager$showNextButton$1.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/notification/NotificationManager$showNextButton$1.dex new file mode 100644 index 0000000..0c18422 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/notification/NotificationManager$showNextButton$1.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/notification/NotificationManager$showNextButtonCompact$1.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/notification/NotificationManager$showNextButtonCompact$1.dex new file mode 100644 index 0000000..4f4d47c Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/notification/NotificationManager$showNextButtonCompact$1.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/notification/NotificationManager$showPlayPauseButton$1.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/notification/NotificationManager$showPlayPauseButton$1.dex new file mode 100644 index 0000000..4324cf7 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/notification/NotificationManager$showPlayPauseButton$1.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/notification/NotificationManager$showPreviousButton$1.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/notification/NotificationManager$showPreviousButton$1.dex new file mode 100644 index 0000000..1f28867 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/notification/NotificationManager$showPreviousButton$1.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/notification/NotificationManager$showPreviousButtonCompact$1.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/notification/NotificationManager$showPreviousButtonCompact$1.dex new file mode 100644 index 0000000..5ad6e3b Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/notification/NotificationManager$showPreviousButtonCompact$1.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/notification/NotificationManager$showRewindButton$1.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/notification/NotificationManager$showRewindButton$1.dex new file mode 100644 index 0000000..8c00110 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/notification/NotificationManager$showRewindButton$1.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/notification/NotificationManager$showRewindButtonCompact$1.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/notification/NotificationManager$showRewindButtonCompact$1.dex new file mode 100644 index 0000000..6c49b5f Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/notification/NotificationManager$showRewindButtonCompact$1.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/notification/NotificationManager$showStopButton$1.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/notification/NotificationManager$showStopButton$1.dex new file mode 100644 index 0000000..7dc3800 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/notification/NotificationManager$showStopButton$1.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/notification/NotificationManager$special$$inlined$target$default$1.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/notification/NotificationManager$special$$inlined$target$default$1.dex new file mode 100644 index 0000000..14eea94 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/notification/NotificationManager$special$$inlined$target$default$1.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/notification/NotificationManager$updateMediaSessionPlaybackActions$$inlined$sortedBy$1.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/notification/NotificationManager$updateMediaSessionPlaybackActions$$inlined$sortedBy$1.dex new file mode 100644 index 0000000..7bcc300 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/notification/NotificationManager$updateMediaSessionPlaybackActions$$inlined$sortedBy$1.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/notification/NotificationManager.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/notification/NotificationManager.dex new file mode 100644 index 0000000..0d2241a Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/notification/NotificationManager.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/players/AudioPlayer.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/players/AudioPlayer.dex new file mode 100644 index 0000000..38efd20 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/players/AudioPlayer.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/players/BaseAudioPlayer$2$WhenMappings.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/players/BaseAudioPlayer$2$WhenMappings.dex new file mode 100644 index 0000000..4f427fa Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/players/BaseAudioPlayer$2$WhenMappings.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/players/BaseAudioPlayer$2.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/players/BaseAudioPlayer$2.dex new file mode 100644 index 0000000..2edd38a Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/players/BaseAudioPlayer$2.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/players/BaseAudioPlayer$Companion.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/players/BaseAudioPlayer$Companion.dex new file mode 100644 index 0000000..eacddbb Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/players/BaseAudioPlayer$Companion.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/players/BaseAudioPlayer$PlayerListener.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/players/BaseAudioPlayer$PlayerListener.dex new file mode 100644 index 0000000..8ff4f46 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/players/BaseAudioPlayer$PlayerListener.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/players/BaseAudioPlayer$WhenMappings.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/players/BaseAudioPlayer$WhenMappings.dex new file mode 100644 index 0000000..afae875 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/players/BaseAudioPlayer$WhenMappings.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/players/BaseAudioPlayer$createForwardingPlayer$1.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/players/BaseAudioPlayer$createForwardingPlayer$1.dex new file mode 100644 index 0000000..5a7e491 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/players/BaseAudioPlayer$createForwardingPlayer$1.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/players/BaseAudioPlayer$ratingType$1.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/players/BaseAudioPlayer$ratingType$1.dex new file mode 100644 index 0000000..1a569f7 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/players/BaseAudioPlayer$ratingType$1.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/players/BaseAudioPlayer.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/players/BaseAudioPlayer.dex new file mode 100644 index 0000000..a026324 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/players/BaseAudioPlayer.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/players/QueuedAudioPlayer.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/players/QueuedAudioPlayer.dex new file mode 100644 index 0000000..f89a21c Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/players/QueuedAudioPlayer.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/players/components/MediaItemExtKt.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/players/components/MediaItemExtKt.dex new file mode 100644 index 0000000..7e6ce5d Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/players/components/MediaItemExtKt.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/players/components/PlayerCache.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/players/components/PlayerCache.dex new file mode 100644 index 0000000..6434e0f Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/players/components/PlayerCache.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/scope/ScopeRenderersFactoryKt$buildScopeRenderersFactory$1.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/scope/ScopeRenderersFactoryKt$buildScopeRenderersFactory$1.dex new file mode 100644 index 0000000..1f8f79c Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/scope/ScopeRenderersFactoryKt$buildScopeRenderersFactory$1.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/scope/ScopeRenderersFactoryKt.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/scope/ScopeRenderersFactoryKt.dex new file mode 100644 index 0000000..65e754b Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/scope/ScopeRenderersFactoryKt.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/scope/ScopeTapAudioProcessor.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/scope/ScopeTapAudioProcessor.dex new file mode 100644 index 0000000..c1f51b8 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/scope/ScopeTapAudioProcessor.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/utils/UtilsKt.dex b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/utils/UtilsKt.dex new file mode 100644 index 0000000..fa2e674 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/bundleLibRuntimeToDirDebug_dex/com/doublesymmetry/kotlinaudio/utils/UtilsKt.dex differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/desugar_graph.bin b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/desugar_graph.bin new file mode 100644 index 0000000..601f245 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/.transforms/efb325046c0dd0f6a51032165627c60b/transformed/bundleLibRuntimeToDirDebug/desugar_graph.bin differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/generated/source/buildConfig/debug/com/doublesymmetry/kotlinaudio/BuildConfig.java b/vendor/kotlinaudio/kotlin-audio/build/generated/source/buildConfig/debug/com/doublesymmetry/kotlinaudio/BuildConfig.java new file mode 100644 index 0000000..a5d8149 --- /dev/null +++ b/vendor/kotlinaudio/kotlin-audio/build/generated/source/buildConfig/debug/com/doublesymmetry/kotlinaudio/BuildConfig.java @@ -0,0 +1,10 @@ +/** + * Automatically generated file. DO NOT MODIFY + */ +package com.doublesymmetry.kotlinaudio; + +public final class BuildConfig { + public static final boolean DEBUG = Boolean.parseBoolean("true"); + public static final String LIBRARY_PACKAGE_NAME = "com.doublesymmetry.kotlinaudio"; + public static final String BUILD_TYPE = "debug"; +} diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/aapt_friendly_merged_manifests/debug/processDebugManifest/aapt/AndroidManifest.xml b/vendor/kotlinaudio/kotlin-audio/build/intermediates/aapt_friendly_merged_manifests/debug/processDebugManifest/aapt/AndroidManifest.xml new file mode 100644 index 0000000..c5eec88 --- /dev/null +++ b/vendor/kotlinaudio/kotlin-audio/build/intermediates/aapt_friendly_merged_manifests/debug/processDebugManifest/aapt/AndroidManifest.xml @@ -0,0 +1,7 @@ + + + + + + \ No newline at end of file diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/aapt_friendly_merged_manifests/debug/processDebugManifest/aapt/output-metadata.json b/vendor/kotlinaudio/kotlin-audio/build/intermediates/aapt_friendly_merged_manifests/debug/processDebugManifest/aapt/output-metadata.json new file mode 100644 index 0000000..f2ef417 --- /dev/null +++ b/vendor/kotlinaudio/kotlin-audio/build/intermediates/aapt_friendly_merged_manifests/debug/processDebugManifest/aapt/output-metadata.json @@ -0,0 +1,18 @@ +{ + "version": 3, + "artifactType": { + "type": "AAPT_FRIENDLY_MERGED_MANIFESTS", + "kind": "Directory" + }, + "applicationId": "com.doublesymmetry.kotlinaudio", + "variantName": "debug", + "elements": [ + { + "type": "SINGLE", + "filters": [], + "attributes": [], + "outputFile": "AndroidManifest.xml" + } + ], + "elementType": "File" +} \ No newline at end of file diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/aar_metadata/debug/writeDebugAarMetadata/aar-metadata.properties b/vendor/kotlinaudio/kotlin-audio/build/intermediates/aar_metadata/debug/writeDebugAarMetadata/aar-metadata.properties new file mode 100644 index 0000000..1211b1e --- /dev/null +++ b/vendor/kotlinaudio/kotlin-audio/build/intermediates/aar_metadata/debug/writeDebugAarMetadata/aar-metadata.properties @@ -0,0 +1,6 @@ +aarFormatVersion=1.0 +aarMetadataVersion=1.0 +minCompileSdk=1 +minCompileSdkExtension=0 +minAndroidGradlePluginVersion=1.0.0 +coreLibraryDesugaringEnabled=false diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/annotation_processor_list/debug/javaPreCompileDebug/annotationProcessors.json b/vendor/kotlinaudio/kotlin-audio/build/intermediates/annotation_processor_list/debug/javaPreCompileDebug/annotationProcessors.json new file mode 100644 index 0000000..9e26dfe --- /dev/null +++ b/vendor/kotlinaudio/kotlin-audio/build/intermediates/annotation_processor_list/debug/javaPreCompileDebug/annotationProcessors.json @@ -0,0 +1 @@ +{} \ No newline at end of file diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/compile_library_classes_jar/debug/bundleLibCompileToJarDebug/classes.jar b/vendor/kotlinaudio/kotlin-audio/build/intermediates/compile_library_classes_jar/debug/bundleLibCompileToJarDebug/classes.jar new file mode 100644 index 0000000..24ee9a6 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/compile_library_classes_jar/debug/bundleLibCompileToJarDebug/classes.jar differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/compile_r_class_jar/debug/generateDebugRFile/R.jar b/vendor/kotlinaudio/kotlin-audio/build/intermediates/compile_r_class_jar/debug/generateDebugRFile/R.jar new file mode 100644 index 0000000..c6a02b5 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/compile_r_class_jar/debug/generateDebugRFile/R.jar differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/compile_symbol_list/debug/generateDebugRFile/R.txt b/vendor/kotlinaudio/kotlin-audio/build/intermediates/compile_symbol_list/debug/generateDebugRFile/R.txt new file mode 100644 index 0000000..12069ca --- /dev/null +++ b/vendor/kotlinaudio/kotlin-audio/build/intermediates/compile_symbol_list/debug/generateDebugRFile/R.txt @@ -0,0 +1,10 @@ +int color black 0x0 +int color purple_200 0x0 +int color purple_500 0x0 +int color purple_700 0x0 +int color teal_200 0x0 +int color teal_700 0x0 +int color white 0x0 +int string pause 0x0 +int string play 0x0 +int string playback_channel_name 0x0 diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/incremental/debug/packageDebugResources/compile-file-map.properties b/vendor/kotlinaudio/kotlin-audio/build/intermediates/incremental/debug/packageDebugResources/compile-file-map.properties new file mode 100644 index 0000000..3a496aa --- /dev/null +++ b/vendor/kotlinaudio/kotlin-audio/build/intermediates/incremental/debug/packageDebugResources/compile-file-map.properties @@ -0,0 +1 @@ +#Wed Jun 17 14:38:54 EDT 2026 diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/incremental/debug/packageDebugResources/merged.dir/values/values.xml b/vendor/kotlinaudio/kotlin-audio/build/intermediates/incremental/debug/packageDebugResources/merged.dir/values/values.xml new file mode 100644 index 0000000..1064c63 --- /dev/null +++ b/vendor/kotlinaudio/kotlin-audio/build/intermediates/incremental/debug/packageDebugResources/merged.dir/values/values.xml @@ -0,0 +1,13 @@ + + + #FF000000 + #FFBB86FC + #FF6200EE + #FF3700B3 + #FF03DAC5 + #FF018786 + #FFFFFFFF + Pause + Play + Now Playing + \ No newline at end of file diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/incremental/debug/packageDebugResources/merger.xml b/vendor/kotlinaudio/kotlin-audio/build/intermediates/incremental/debug/packageDebugResources/merger.xml new file mode 100644 index 0000000..0e274a1 --- /dev/null +++ b/vendor/kotlinaudio/kotlin-audio/build/intermediates/incremental/debug/packageDebugResources/merger.xml @@ -0,0 +1,2 @@ + +#FFBB86FC#FF6200EE#FF3700B3#FF03DAC5#FF018786#FF000000#FFFFFFFFPlayNow PlayingPause \ No newline at end of file diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/incremental/mergeDebugAssets/merger.xml b/vendor/kotlinaudio/kotlin-audio/build/intermediates/incremental/mergeDebugAssets/merger.xml new file mode 100644 index 0000000..f850444 --- /dev/null +++ b/vendor/kotlinaudio/kotlin-audio/build/intermediates/incremental/mergeDebugAssets/merger.xml @@ -0,0 +1,2 @@ + + \ No newline at end of file diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/incremental/mergeDebugJniLibFolders/merger.xml b/vendor/kotlinaudio/kotlin-audio/build/intermediates/incremental/mergeDebugJniLibFolders/merger.xml new file mode 100644 index 0000000..350c19f --- /dev/null +++ b/vendor/kotlinaudio/kotlin-audio/build/intermediates/incremental/mergeDebugJniLibFolders/merger.xml @@ -0,0 +1,2 @@ + + \ No newline at end of file diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/incremental/mergeDebugShaders/merger.xml b/vendor/kotlinaudio/kotlin-audio/build/intermediates/incremental/mergeDebugShaders/merger.xml new file mode 100644 index 0000000..4aeb5eb --- /dev/null +++ b/vendor/kotlinaudio/kotlin-audio/build/intermediates/incremental/mergeDebugShaders/merger.xml @@ -0,0 +1,2 @@ + + \ No newline at end of file diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/java_res/debug/processDebugJavaRes/out/META-INF/kotlin-audio_debug.kotlin_module b/vendor/kotlinaudio/kotlin-audio/build/intermediates/java_res/debug/processDebugJavaRes/out/META-INF/kotlin-audio_debug.kotlin_module new file mode 100644 index 0000000..5007816 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/java_res/debug/processDebugJavaRes/out/META-INF/kotlin-audio_debug.kotlin_module differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/javac/debug/compileDebugJavaWithJavac/classes/com/doublesymmetry/kotlinaudio/BuildConfig.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/javac/debug/compileDebugJavaWithJavac/classes/com/doublesymmetry/kotlinaudio/BuildConfig.class new file mode 100644 index 0000000..5b47c2b Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/javac/debug/compileDebugJavaWithJavac/classes/com/doublesymmetry/kotlinaudio/BuildConfig.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/local_only_symbol_list/debug/parseDebugLocalResources/R-def.txt b/vendor/kotlinaudio/kotlin-audio/build/intermediates/local_only_symbol_list/debug/parseDebugLocalResources/R-def.txt new file mode 100644 index 0000000..8868aec --- /dev/null +++ b/vendor/kotlinaudio/kotlin-audio/build/intermediates/local_only_symbol_list/debug/parseDebugLocalResources/R-def.txt @@ -0,0 +1,12 @@ +R_DEF: Internal format may change without notice +local +color black +color purple_200 +color purple_500 +color purple_700 +color teal_200 +color teal_700 +color white +string pause +string play +string playback_channel_name diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/manifest_merge_blame_file/debug/processDebugManifest/manifest-merger-blame-debug-report.txt b/vendor/kotlinaudio/kotlin-audio/build/intermediates/manifest_merge_blame_file/debug/processDebugManifest/manifest-merger-blame-debug-report.txt new file mode 100644 index 0000000..cf034fc --- /dev/null +++ b/vendor/kotlinaudio/kotlin-audio/build/intermediates/manifest_merge_blame_file/debug/processDebugManifest/manifest-merger-blame-debug-report.txt @@ -0,0 +1,7 @@ +1 +2 +4 +5 +6 +7 diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/merged_manifest/debug/processDebugManifest/AndroidManifest.xml b/vendor/kotlinaudio/kotlin-audio/build/intermediates/merged_manifest/debug/processDebugManifest/AndroidManifest.xml new file mode 100644 index 0000000..c5eec88 --- /dev/null +++ b/vendor/kotlinaudio/kotlin-audio/build/intermediates/merged_manifest/debug/processDebugManifest/AndroidManifest.xml @@ -0,0 +1,7 @@ + + + + + + \ No newline at end of file diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/navigation_json/debug/extractDeepLinksDebug/navigation.json b/vendor/kotlinaudio/kotlin-audio/build/intermediates/navigation_json/debug/extractDeepLinksDebug/navigation.json new file mode 100644 index 0000000..0637a08 --- /dev/null +++ b/vendor/kotlinaudio/kotlin-audio/build/intermediates/navigation_json/debug/extractDeepLinksDebug/navigation.json @@ -0,0 +1 @@ +[] \ No newline at end of file diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/nested_resources_validation_report/debug/generateDebugResources/nestedResourcesValidationReport.txt b/vendor/kotlinaudio/kotlin-audio/build/intermediates/nested_resources_validation_report/debug/generateDebugResources/nestedResourcesValidationReport.txt new file mode 100644 index 0000000..08f4ebe --- /dev/null +++ b/vendor/kotlinaudio/kotlin-audio/build/intermediates/nested_resources_validation_report/debug/generateDebugResources/nestedResourcesValidationReport.txt @@ -0,0 +1 @@ +0 Warning/Error \ No newline at end of file diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/packaged_res/debug/packageDebugResources/values/values.xml b/vendor/kotlinaudio/kotlin-audio/build/intermediates/packaged_res/debug/packageDebugResources/values/values.xml new file mode 100644 index 0000000..1064c63 --- /dev/null +++ b/vendor/kotlinaudio/kotlin-audio/build/intermediates/packaged_res/debug/packageDebugResources/values/values.xml @@ -0,0 +1,13 @@ + + + #FF000000 + #FFBB86FC + #FF6200EE + #FF3700B3 + #FF03DAC5 + #FF018786 + #FFFFFFFF + Pause + Play + Now Playing + \ No newline at end of file diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/META-INF/kotlin-audio_debug.kotlin_module b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/META-INF/kotlin-audio_debug.kotlin_module new file mode 100644 index 0000000..5007816 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/META-INF/kotlin-audio_debug.kotlin_module differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/BuildConfig.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/BuildConfig.class new file mode 100644 index 0000000..5b47c2b Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/BuildConfig.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/event/EventHolder.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/event/EventHolder.class new file mode 100644 index 0000000..05060b4 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/event/EventHolder.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/event/NotificationEventHolder$updateNotificationState$1.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/event/NotificationEventHolder$updateNotificationState$1.class new file mode 100644 index 0000000..b4a1b02 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/event/NotificationEventHolder$updateNotificationState$1.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/event/NotificationEventHolder.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/event/NotificationEventHolder.class new file mode 100644 index 0000000..09765b9 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/event/NotificationEventHolder.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/event/PlayerEventHolder$updateAudioItemTransition$1.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/event/PlayerEventHolder$updateAudioItemTransition$1.class new file mode 100644 index 0000000..8c3c3cb Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/event/PlayerEventHolder$updateAudioItemTransition$1.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/event/PlayerEventHolder$updateAudioPlayerState$1.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/event/PlayerEventHolder$updateAudioPlayerState$1.class new file mode 100644 index 0000000..aaf7d1c Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/event/PlayerEventHolder$updateAudioPlayerState$1.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/event/PlayerEventHolder$updateOnAudioFocusChanged$1.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/event/PlayerEventHolder$updateOnAudioFocusChanged$1.class new file mode 100644 index 0000000..238d25c Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/event/PlayerEventHolder$updateOnAudioFocusChanged$1.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/event/PlayerEventHolder$updateOnCommonMetadata$1.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/event/PlayerEventHolder$updateOnCommonMetadata$1.class new file mode 100644 index 0000000..a80de41 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/event/PlayerEventHolder$updateOnCommonMetadata$1.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/event/PlayerEventHolder$updateOnPlayerActionTriggeredExternally$1.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/event/PlayerEventHolder$updateOnPlayerActionTriggeredExternally$1.class new file mode 100644 index 0000000..975112b Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/event/PlayerEventHolder$updateOnPlayerActionTriggeredExternally$1.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/event/PlayerEventHolder$updateOnTimedMetadata$1.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/event/PlayerEventHolder$updateOnTimedMetadata$1.class new file mode 100644 index 0000000..be90805 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/event/PlayerEventHolder$updateOnTimedMetadata$1.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/event/PlayerEventHolder$updatePlayWhenReadyChange$1.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/event/PlayerEventHolder$updatePlayWhenReadyChange$1.class new file mode 100644 index 0000000..13cfbcf Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/event/PlayerEventHolder$updatePlayWhenReadyChange$1.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/event/PlayerEventHolder$updatePlaybackEndedReason$1.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/event/PlayerEventHolder$updatePlaybackEndedReason$1.class new file mode 100644 index 0000000..ee7f84b Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/event/PlayerEventHolder$updatePlaybackEndedReason$1.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/event/PlayerEventHolder$updatePlaybackError$1.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/event/PlayerEventHolder$updatePlaybackError$1.class new file mode 100644 index 0000000..0bad8d5 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/event/PlayerEventHolder$updatePlaybackError$1.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/event/PlayerEventHolder$updatePositionChangedReason$1.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/event/PlayerEventHolder$updatePositionChangedReason$1.class new file mode 100644 index 0000000..83bb905 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/event/PlayerEventHolder$updatePositionChangedReason$1.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/event/PlayerEventHolder.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/event/PlayerEventHolder.class new file mode 100644 index 0000000..e99ada1 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/event/PlayerEventHolder.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/AudioContentType.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/AudioContentType.class new file mode 100644 index 0000000..5d227ca Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/AudioContentType.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/AudioItem.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/AudioItem.class new file mode 100644 index 0000000..817210f Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/AudioItem.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/AudioItemHolder.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/AudioItemHolder.class new file mode 100644 index 0000000..9a5d874 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/AudioItemHolder.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/AudioItemOptions.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/AudioItemOptions.class new file mode 100644 index 0000000..05c4736 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/AudioItemOptions.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/AudioItemTransitionReason$AUTO.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/AudioItemTransitionReason$AUTO.class new file mode 100644 index 0000000..e562f7a Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/AudioItemTransitionReason$AUTO.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/AudioItemTransitionReason$QUEUE_CHANGED.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/AudioItemTransitionReason$QUEUE_CHANGED.class new file mode 100644 index 0000000..be940bd Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/AudioItemTransitionReason$QUEUE_CHANGED.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/AudioItemTransitionReason$REPEAT.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/AudioItemTransitionReason$REPEAT.class new file mode 100644 index 0000000..a4225d1 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/AudioItemTransitionReason$REPEAT.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/AudioItemTransitionReason$SEEK_TO_ANOTHER_AUDIO_ITEM.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/AudioItemTransitionReason$SEEK_TO_ANOTHER_AUDIO_ITEM.class new file mode 100644 index 0000000..0c8b266 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/AudioItemTransitionReason$SEEK_TO_ANOTHER_AUDIO_ITEM.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/AudioItemTransitionReason.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/AudioItemTransitionReason.class new file mode 100644 index 0000000..0262296 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/AudioItemTransitionReason.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/AudioPlayerState.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/AudioPlayerState.class new file mode 100644 index 0000000..c95399b Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/AudioPlayerState.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/BufferConfig.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/BufferConfig.class new file mode 100644 index 0000000..14861f4 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/BufferConfig.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/CacheConfig.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/CacheConfig.class new file mode 100644 index 0000000..5e0f27a Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/CacheConfig.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/Capability.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/Capability.class new file mode 100644 index 0000000..5ce8861 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/Capability.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/DefaultAudioItem.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/DefaultAudioItem.class new file mode 100644 index 0000000..c7e4975 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/DefaultAudioItem.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/DefaultPlayerOptions.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/DefaultPlayerOptions.class new file mode 100644 index 0000000..f1799b5 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/DefaultPlayerOptions.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/DefaultQueuedPlayerOptions$WhenMappings.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/DefaultQueuedPlayerOptions$WhenMappings.class new file mode 100644 index 0000000..2e29ecb Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/DefaultQueuedPlayerOptions$WhenMappings.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/DefaultQueuedPlayerOptions.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/DefaultQueuedPlayerOptions.class new file mode 100644 index 0000000..24212af Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/DefaultQueuedPlayerOptions.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/FocusChangeData.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/FocusChangeData.class new file mode 100644 index 0000000..09f6155 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/FocusChangeData.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/MediaSessionCallback$FORWARD.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/MediaSessionCallback$FORWARD.class new file mode 100644 index 0000000..27a5104 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/MediaSessionCallback$FORWARD.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/MediaSessionCallback$NEXT.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/MediaSessionCallback$NEXT.class new file mode 100644 index 0000000..740cbb8 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/MediaSessionCallback$NEXT.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/MediaSessionCallback$PAUSE.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/MediaSessionCallback$PAUSE.class new file mode 100644 index 0000000..4449ea5 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/MediaSessionCallback$PAUSE.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/MediaSessionCallback$PLAY.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/MediaSessionCallback$PLAY.class new file mode 100644 index 0000000..7546e70 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/MediaSessionCallback$PLAY.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/MediaSessionCallback$PREVIOUS.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/MediaSessionCallback$PREVIOUS.class new file mode 100644 index 0000000..756314a Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/MediaSessionCallback$PREVIOUS.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/MediaSessionCallback$RATING.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/MediaSessionCallback$RATING.class new file mode 100644 index 0000000..5bf4e0f Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/MediaSessionCallback$RATING.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/MediaSessionCallback$REWIND.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/MediaSessionCallback$REWIND.class new file mode 100644 index 0000000..f14e87c Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/MediaSessionCallback$REWIND.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/MediaSessionCallback$SEEK.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/MediaSessionCallback$SEEK.class new file mode 100644 index 0000000..e8d651c Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/MediaSessionCallback$SEEK.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/MediaSessionCallback$STOP.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/MediaSessionCallback$STOP.class new file mode 100644 index 0000000..4499d11 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/MediaSessionCallback$STOP.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/MediaSessionCallback.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/MediaSessionCallback.class new file mode 100644 index 0000000..4362142 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/MediaSessionCallback.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/MediaType.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/MediaType.class new file mode 100644 index 0000000..2a76328 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/MediaType.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/NotificationButton$BACKWARD.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/NotificationButton$BACKWARD.class new file mode 100644 index 0000000..9590b9f Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/NotificationButton$BACKWARD.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/NotificationButton$FORWARD.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/NotificationButton$FORWARD.class new file mode 100644 index 0000000..ad2ecf8 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/NotificationButton$FORWARD.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/NotificationButton$NEXT.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/NotificationButton$NEXT.class new file mode 100644 index 0000000..df1460c Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/NotificationButton$NEXT.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/NotificationButton$PLAY_PAUSE.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/NotificationButton$PLAY_PAUSE.class new file mode 100644 index 0000000..ee2bd4b Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/NotificationButton$PLAY_PAUSE.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/NotificationButton$PREVIOUS.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/NotificationButton$PREVIOUS.class new file mode 100644 index 0000000..a671fa5 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/NotificationButton$PREVIOUS.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/NotificationButton$SEEK_TO.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/NotificationButton$SEEK_TO.class new file mode 100644 index 0000000..ff7d552 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/NotificationButton$SEEK_TO.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/NotificationButton$STOP.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/NotificationButton$STOP.class new file mode 100644 index 0000000..b65f8ad Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/NotificationButton$STOP.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/NotificationButton.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/NotificationButton.class new file mode 100644 index 0000000..5106e24 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/NotificationButton.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/NotificationConfig.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/NotificationConfig.class new file mode 100644 index 0000000..7123c06 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/NotificationConfig.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/NotificationState$CANCELLED.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/NotificationState$CANCELLED.class new file mode 100644 index 0000000..527cac5 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/NotificationState$CANCELLED.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/NotificationState$POSTED.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/NotificationState$POSTED.class new file mode 100644 index 0000000..16c3b50 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/NotificationState$POSTED.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/NotificationState.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/NotificationState.class new file mode 100644 index 0000000..a34108c Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/NotificationState.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/PlayWhenReadyChangeData.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/PlayWhenReadyChangeData.class new file mode 100644 index 0000000..1ff8344 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/PlayWhenReadyChangeData.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/PlaybackEndedReason.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/PlaybackEndedReason.class new file mode 100644 index 0000000..a078433 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/PlaybackEndedReason.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/PlaybackError.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/PlaybackError.class new file mode 100644 index 0000000..94e2a6e Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/PlaybackError.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/PlayerConfig.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/PlayerConfig.class new file mode 100644 index 0000000..538d23b Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/PlayerConfig.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/PlayerOptions.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/PlayerOptions.class new file mode 100644 index 0000000..da742fb Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/PlayerOptions.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/PositionChangedReason$AUTO.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/PositionChangedReason$AUTO.class new file mode 100644 index 0000000..da77c05 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/PositionChangedReason$AUTO.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/PositionChangedReason$QUEUE_CHANGED.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/PositionChangedReason$QUEUE_CHANGED.class new file mode 100644 index 0000000..58e1c60 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/PositionChangedReason$QUEUE_CHANGED.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/PositionChangedReason$SEEK.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/PositionChangedReason$SEEK.class new file mode 100644 index 0000000..d979c25 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/PositionChangedReason$SEEK.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/PositionChangedReason$SEEK_FAILED.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/PositionChangedReason$SEEK_FAILED.class new file mode 100644 index 0000000..97596fb Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/PositionChangedReason$SEEK_FAILED.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/PositionChangedReason$SKIPPED_PERIOD.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/PositionChangedReason$SKIPPED_PERIOD.class new file mode 100644 index 0000000..98fb2f8 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/PositionChangedReason$SKIPPED_PERIOD.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/PositionChangedReason$UNKNOWN.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/PositionChangedReason$UNKNOWN.class new file mode 100644 index 0000000..bbafead Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/PositionChangedReason$UNKNOWN.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/PositionChangedReason.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/PositionChangedReason.class new file mode 100644 index 0000000..beacbc6 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/PositionChangedReason.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/QueuedPlayerOptions.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/QueuedPlayerOptions.class new file mode 100644 index 0000000..50fe55e Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/QueuedPlayerOptions.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/RepeatMode$Companion.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/RepeatMode$Companion.class new file mode 100644 index 0000000..9f963ff Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/RepeatMode$Companion.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/RepeatMode.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/RepeatMode.class new file mode 100644 index 0000000..9583d30 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/RepeatMode.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/WakeMode.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/WakeMode.class new file mode 100644 index 0000000..705f6ef Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/models/WakeMode.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$1.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$1.class new file mode 100644 index 0000000..2e4e184 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$1.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$Companion.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$Companion.class new file mode 100644 index 0000000..b1ff271 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$Companion.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$createMediaSessionAction$1.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$createMediaSessionAction$1.class new file mode 100644 index 0000000..a9ccd3c Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$createMediaSessionAction$1.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$createNotification$1.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$createNotification$1.class new file mode 100644 index 0000000..5b2cce6 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$createNotification$1.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$customActionReceiver$1.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$customActionReceiver$1.class new file mode 100644 index 0000000..a26a04b Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$customActionReceiver$1.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$descriptionAdapter$1$getCurrentLargeIcon$$inlined$target$default$1.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$descriptionAdapter$1$getCurrentLargeIcon$$inlined$target$default$1.class new file mode 100644 index 0000000..742ffda Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$descriptionAdapter$1$getCurrentLargeIcon$$inlined$target$default$1.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$descriptionAdapter$1.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$descriptionAdapter$1.class new file mode 100644 index 0000000..e1ca374 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$descriptionAdapter$1.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$destroy$1.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$destroy$1.class new file mode 100644 index 0000000..9b9fa61 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$destroy$1.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$invalidate$1.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$invalidate$1.class new file mode 100644 index 0000000..814bef6 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$invalidate$1.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$onNotificationCancelled$1.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$onNotificationCancelled$1.class new file mode 100644 index 0000000..61bd272 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$onNotificationCancelled$1.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$onNotificationPosted$1.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$onNotificationPosted$1.class new file mode 100644 index 0000000..efe7220 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$onNotificationPosted$1.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$showForwardButton$1.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$showForwardButton$1.class new file mode 100644 index 0000000..cd15ed5 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$showForwardButton$1.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$showForwardButtonCompact$1.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$showForwardButtonCompact$1.class new file mode 100644 index 0000000..36d96af Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$showForwardButtonCompact$1.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$showNextButton$1.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$showNextButton$1.class new file mode 100644 index 0000000..d7921d6 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$showNextButton$1.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$showNextButtonCompact$1.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$showNextButtonCompact$1.class new file mode 100644 index 0000000..70700b2 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$showNextButtonCompact$1.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$showPlayPauseButton$1.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$showPlayPauseButton$1.class new file mode 100644 index 0000000..85f970f Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$showPlayPauseButton$1.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$showPreviousButton$1.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$showPreviousButton$1.class new file mode 100644 index 0000000..d4860e5 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$showPreviousButton$1.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$showPreviousButtonCompact$1.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$showPreviousButtonCompact$1.class new file mode 100644 index 0000000..3570f42 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$showPreviousButtonCompact$1.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$showRewindButton$1.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$showRewindButton$1.class new file mode 100644 index 0000000..78bfc75 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$showRewindButton$1.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$showRewindButtonCompact$1.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$showRewindButtonCompact$1.class new file mode 100644 index 0000000..c57f883 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$showRewindButtonCompact$1.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$showStopButton$1.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$showStopButton$1.class new file mode 100644 index 0000000..105a2b0 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$showStopButton$1.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$special$$inlined$target$default$1.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$special$$inlined$target$default$1.class new file mode 100644 index 0000000..ba44c3b Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$special$$inlined$target$default$1.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$updateMediaSessionPlaybackActions$$inlined$sortedBy$1.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$updateMediaSessionPlaybackActions$$inlined$sortedBy$1.class new file mode 100644 index 0000000..609a36e Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$updateMediaSessionPlaybackActions$$inlined$sortedBy$1.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/notification/NotificationManager.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/notification/NotificationManager.class new file mode 100644 index 0000000..adcd60a Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/notification/NotificationManager.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/players/AudioPlayer.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/players/AudioPlayer.class new file mode 100644 index 0000000..d1ba33d Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/players/AudioPlayer.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/players/BaseAudioPlayer$2$WhenMappings.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/players/BaseAudioPlayer$2$WhenMappings.class new file mode 100644 index 0000000..50881fb Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/players/BaseAudioPlayer$2$WhenMappings.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/players/BaseAudioPlayer$2.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/players/BaseAudioPlayer$2.class new file mode 100644 index 0000000..8d57ddc Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/players/BaseAudioPlayer$2.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/players/BaseAudioPlayer$Companion.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/players/BaseAudioPlayer$Companion.class new file mode 100644 index 0000000..125b5cb Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/players/BaseAudioPlayer$Companion.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/players/BaseAudioPlayer$PlayerListener.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/players/BaseAudioPlayer$PlayerListener.class new file mode 100644 index 0000000..8780c9a Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/players/BaseAudioPlayer$PlayerListener.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/players/BaseAudioPlayer$WhenMappings.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/players/BaseAudioPlayer$WhenMappings.class new file mode 100644 index 0000000..37790a2 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/players/BaseAudioPlayer$WhenMappings.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/players/BaseAudioPlayer$createForwardingPlayer$1.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/players/BaseAudioPlayer$createForwardingPlayer$1.class new file mode 100644 index 0000000..463ae3b Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/players/BaseAudioPlayer$createForwardingPlayer$1.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/players/BaseAudioPlayer$ratingType$1.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/players/BaseAudioPlayer$ratingType$1.class new file mode 100644 index 0000000..e6a2875 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/players/BaseAudioPlayer$ratingType$1.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/players/BaseAudioPlayer.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/players/BaseAudioPlayer.class new file mode 100644 index 0000000..1014987 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/players/BaseAudioPlayer.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/players/QueuedAudioPlayer.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/players/QueuedAudioPlayer.class new file mode 100644 index 0000000..7f6dab0 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/players/QueuedAudioPlayer.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/players/components/MediaItemExtKt.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/players/components/MediaItemExtKt.class new file mode 100644 index 0000000..8a96b7c Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/players/components/MediaItemExtKt.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/players/components/PlayerCache.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/players/components/PlayerCache.class new file mode 100644 index 0000000..5449769 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/players/components/PlayerCache.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/scope/ScopeRenderersFactoryKt$buildScopeRenderersFactory$1.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/scope/ScopeRenderersFactoryKt$buildScopeRenderersFactory$1.class new file mode 100644 index 0000000..77d4287 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/scope/ScopeRenderersFactoryKt$buildScopeRenderersFactory$1.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/scope/ScopeRenderersFactoryKt.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/scope/ScopeRenderersFactoryKt.class new file mode 100644 index 0000000..33360a1 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/scope/ScopeRenderersFactoryKt.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/scope/ScopeTapAudioProcessor.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/scope/ScopeTapAudioProcessor.class new file mode 100644 index 0000000..8bf76b8 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/scope/ScopeTapAudioProcessor.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/utils/UtilsKt.class b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/utils/UtilsKt.class new file mode 100644 index 0000000..b311af1 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_dir/debug/bundleLibRuntimeToDirDebug/com/doublesymmetry/kotlinaudio/utils/UtilsKt.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_jar/debug/bundleLibRuntimeToJarDebug/classes.jar b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_jar/debug/bundleLibRuntimeToJarDebug/classes.jar new file mode 100644 index 0000000..8091687 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/intermediates/runtime_library_classes_jar/debug/bundleLibRuntimeToJarDebug/classes.jar differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/intermediates/symbol_list_with_package_name/debug/generateDebugRFile/package-aware-r.txt b/vendor/kotlinaudio/kotlin-audio/build/intermediates/symbol_list_with_package_name/debug/generateDebugRFile/package-aware-r.txt new file mode 100644 index 0000000..520a7f3 --- /dev/null +++ b/vendor/kotlinaudio/kotlin-audio/build/intermediates/symbol_list_with_package_name/debug/generateDebugRFile/package-aware-r.txt @@ -0,0 +1,11 @@ +com.doublesymmetry.kotlinaudio +color black +color purple_200 +color purple_500 +color purple_700 +color teal_200 +color teal_700 +color white +string pause +string play +string playback_channel_name diff --git a/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/inputs/source-to-output.tab b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/inputs/source-to-output.tab new file mode 100644 index 0000000..74dca0f Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/inputs/source-to-output.tab differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/inputs/source-to-output.tab.keystream b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/inputs/source-to-output.tab.keystream new file mode 100644 index 0000000..bfab74d Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/inputs/source-to-output.tab.keystream differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/inputs/source-to-output.tab.keystream.len b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/inputs/source-to-output.tab.keystream.len new file mode 100644 index 0000000..7acc452 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/inputs/source-to-output.tab.keystream.len differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/inputs/source-to-output.tab.len b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/inputs/source-to-output.tab.len new file mode 100644 index 0000000..3085af4 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/inputs/source-to-output.tab.len differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/inputs/source-to-output.tab.values.at b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/inputs/source-to-output.tab.values.at new file mode 100644 index 0000000..5d2f238 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/inputs/source-to-output.tab.values.at differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/inputs/source-to-output.tab_i b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/inputs/source-to-output.tab_i new file mode 100644 index 0000000..e5bbf4d Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/inputs/source-to-output.tab_i differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/inputs/source-to-output.tab_i.len b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/inputs/source-to-output.tab_i.len new file mode 100644 index 0000000..131e265 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/inputs/source-to-output.tab_i.len differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/class-attributes.tab b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/class-attributes.tab new file mode 100644 index 0000000..f81f9ba Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/class-attributes.tab differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/class-attributes.tab.keystream b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/class-attributes.tab.keystream new file mode 100644 index 0000000..f4e73d8 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/class-attributes.tab.keystream differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/class-attributes.tab.keystream.len b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/class-attributes.tab.keystream.len new file mode 100644 index 0000000..952c5d6 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/class-attributes.tab.keystream.len differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/class-attributes.tab.len b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/class-attributes.tab.len new file mode 100644 index 0000000..74768ff Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/class-attributes.tab.len differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/class-attributes.tab.values.at b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/class-attributes.tab.values.at new file mode 100644 index 0000000..ebbcfcf Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/class-attributes.tab.values.at differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/class-attributes.tab_i b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/class-attributes.tab_i new file mode 100644 index 0000000..ea78307 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/class-attributes.tab_i differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/class-attributes.tab_i.len b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/class-attributes.tab_i.len new file mode 100644 index 0000000..131e265 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/class-attributes.tab_i.len differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/class-fq-name-to-source.tab b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/class-fq-name-to-source.tab new file mode 100644 index 0000000..27e3880 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/class-fq-name-to-source.tab differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/class-fq-name-to-source.tab.keystream b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/class-fq-name-to-source.tab.keystream new file mode 100644 index 0000000..f4e73d8 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/class-fq-name-to-source.tab.keystream differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/class-fq-name-to-source.tab.keystream.len b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/class-fq-name-to-source.tab.keystream.len new file mode 100644 index 0000000..952c5d6 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/class-fq-name-to-source.tab.keystream.len differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/class-fq-name-to-source.tab.len b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/class-fq-name-to-source.tab.len new file mode 100644 index 0000000..74768ff Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/class-fq-name-to-source.tab.len differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/class-fq-name-to-source.tab.values.at b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/class-fq-name-to-source.tab.values.at new file mode 100644 index 0000000..4825168 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/class-fq-name-to-source.tab.values.at differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/class-fq-name-to-source.tab_i b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/class-fq-name-to-source.tab_i new file mode 100644 index 0000000..ea78307 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/class-fq-name-to-source.tab_i differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/class-fq-name-to-source.tab_i.len b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/class-fq-name-to-source.tab_i.len new file mode 100644 index 0000000..131e265 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/class-fq-name-to-source.tab_i.len differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/constants.tab b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/constants.tab new file mode 100644 index 0000000..bdf584a Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/constants.tab differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/constants.tab.keystream b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/constants.tab.keystream new file mode 100644 index 0000000..ebf2fdd Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/constants.tab.keystream differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/constants.tab.keystream.len b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/constants.tab.keystream.len new file mode 100644 index 0000000..6309493 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/constants.tab.keystream.len differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/constants.tab.len b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/constants.tab.len new file mode 100644 index 0000000..2a17e6e Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/constants.tab.len differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/constants.tab.values.at b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/constants.tab.values.at new file mode 100644 index 0000000..1715732 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/constants.tab.values.at differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/constants.tab_i b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/constants.tab_i new file mode 100644 index 0000000..5361de8 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/constants.tab_i differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/constants.tab_i.len b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/constants.tab_i.len new file mode 100644 index 0000000..131e265 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/constants.tab_i.len differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/internal-name-to-source.tab b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/internal-name-to-source.tab new file mode 100644 index 0000000..5582096 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/internal-name-to-source.tab differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/internal-name-to-source.tab.keystream b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/internal-name-to-source.tab.keystream new file mode 100644 index 0000000..cecf6e2 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/internal-name-to-source.tab.keystream differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/internal-name-to-source.tab.keystream.len b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/internal-name-to-source.tab.keystream.len new file mode 100644 index 0000000..e6f5dea Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/internal-name-to-source.tab.keystream.len differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/internal-name-to-source.tab.len b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/internal-name-to-source.tab.len new file mode 100644 index 0000000..8a37598 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/internal-name-to-source.tab.len differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/internal-name-to-source.tab.values.at b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/internal-name-to-source.tab.values.at new file mode 100644 index 0000000..ddf6abe Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/internal-name-to-source.tab.values.at differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/internal-name-to-source.tab_i b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/internal-name-to-source.tab_i new file mode 100644 index 0000000..9f54bd4 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/internal-name-to-source.tab_i differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/internal-name-to-source.tab_i.len b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/internal-name-to-source.tab_i.len new file mode 100644 index 0000000..131e265 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/internal-name-to-source.tab_i.len differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/package-parts.tab b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/package-parts.tab new file mode 100644 index 0000000..4748c95 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/package-parts.tab differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/package-parts.tab.keystream b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/package-parts.tab.keystream new file mode 100644 index 0000000..ca2a395 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/package-parts.tab.keystream differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/package-parts.tab.keystream.len b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/package-parts.tab.keystream.len new file mode 100644 index 0000000..0150f67 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/package-parts.tab.keystream.len differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/package-parts.tab.len b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/package-parts.tab.len new file mode 100644 index 0000000..a9f80ae Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/package-parts.tab.len differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/package-parts.tab.values.at b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/package-parts.tab.values.at new file mode 100644 index 0000000..33c7d6c Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/package-parts.tab.values.at differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/package-parts.tab_i b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/package-parts.tab_i new file mode 100644 index 0000000..c872216 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/package-parts.tab_i differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/package-parts.tab_i.len b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/package-parts.tab_i.len new file mode 100644 index 0000000..131e265 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/package-parts.tab_i.len differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/proto.tab b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/proto.tab new file mode 100644 index 0000000..47b5f64 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/proto.tab differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/proto.tab.keystream b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/proto.tab.keystream new file mode 100644 index 0000000..c405bbc Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/proto.tab.keystream differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/proto.tab.keystream.len b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/proto.tab.keystream.len new file mode 100644 index 0000000..d9ceda7 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/proto.tab.keystream.len differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/proto.tab.len b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/proto.tab.len new file mode 100644 index 0000000..2553f37 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/proto.tab.len differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/proto.tab.values b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/proto.tab.values new file mode 100644 index 0000000..4f1948a Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/proto.tab.values differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/proto.tab.values.at b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/proto.tab.values.at new file mode 100644 index 0000000..7fbfa68 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/proto.tab.values.at differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/proto.tab.values.s b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/proto.tab.values.s new file mode 100644 index 0000000..e51a7a7 --- /dev/null +++ b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/proto.tab.values.s @@ -0,0 +1 @@ +Ι› \ No newline at end of file diff --git a/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/proto.tab_i b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/proto.tab_i new file mode 100644 index 0000000..58636fb Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/proto.tab_i differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/proto.tab_i.len b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/proto.tab_i.len new file mode 100644 index 0000000..131e265 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/proto.tab_i.len differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/source-to-classes.tab b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/source-to-classes.tab new file mode 100644 index 0000000..c2fb241 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/source-to-classes.tab differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/source-to-classes.tab.keystream b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/source-to-classes.tab.keystream new file mode 100644 index 0000000..bfab74d Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/source-to-classes.tab.keystream differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/source-to-classes.tab.keystream.len b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/source-to-classes.tab.keystream.len new file mode 100644 index 0000000..7acc452 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/source-to-classes.tab.keystream.len differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/source-to-classes.tab.len b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/source-to-classes.tab.len new file mode 100644 index 0000000..3085af4 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/source-to-classes.tab.len differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/source-to-classes.tab.values.at b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/source-to-classes.tab.values.at new file mode 100644 index 0000000..6d8a596 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/source-to-classes.tab.values.at differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/source-to-classes.tab_i b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/source-to-classes.tab_i new file mode 100644 index 0000000..e5bbf4d Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/source-to-classes.tab_i differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/source-to-classes.tab_i.len b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/source-to-classes.tab_i.len new file mode 100644 index 0000000..131e265 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/source-to-classes.tab_i.len differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/subtypes.tab b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/subtypes.tab new file mode 100644 index 0000000..66ad639 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/subtypes.tab differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/subtypes.tab.keystream b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/subtypes.tab.keystream new file mode 100644 index 0000000..e4cceda Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/subtypes.tab.keystream differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/subtypes.tab.keystream.len b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/subtypes.tab.keystream.len new file mode 100644 index 0000000..70fdfe7 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/subtypes.tab.keystream.len differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/subtypes.tab.len b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/subtypes.tab.len new file mode 100644 index 0000000..003bc0e Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/subtypes.tab.len differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/subtypes.tab.values.at b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/subtypes.tab.values.at new file mode 100644 index 0000000..27944a7 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/subtypes.tab.values.at differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/subtypes.tab_i b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/subtypes.tab_i new file mode 100644 index 0000000..3100ea8 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/subtypes.tab_i differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/subtypes.tab_i.len b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/subtypes.tab_i.len new file mode 100644 index 0000000..131e265 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/subtypes.tab_i.len differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/supertypes.tab b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/supertypes.tab new file mode 100644 index 0000000..37f87d0 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/supertypes.tab differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/supertypes.tab.keystream b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/supertypes.tab.keystream new file mode 100644 index 0000000..ea60ad8 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/supertypes.tab.keystream differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/supertypes.tab.keystream.len b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/supertypes.tab.keystream.len new file mode 100644 index 0000000..8fa92eb Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/supertypes.tab.keystream.len differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/supertypes.tab.len b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/supertypes.tab.len new file mode 100644 index 0000000..60e54ab Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/supertypes.tab.len differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/supertypes.tab.values.at b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/supertypes.tab.values.at new file mode 100644 index 0000000..109a406 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/supertypes.tab.values.at differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/supertypes.tab_i b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/supertypes.tab_i new file mode 100644 index 0000000..99b6109 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/supertypes.tab_i differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/supertypes.tab_i.len b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/supertypes.tab_i.len new file mode 100644 index 0000000..131e265 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/jvm/kotlin/supertypes.tab_i.len differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/lookups/counters.tab b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/lookups/counters.tab new file mode 100644 index 0000000..5007100 --- /dev/null +++ b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/lookups/counters.tab @@ -0,0 +1,2 @@ +31 +0 \ No newline at end of file diff --git a/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/lookups/file-to-id.tab b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/lookups/file-to-id.tab new file mode 100644 index 0000000..1b86ab7 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/lookups/file-to-id.tab differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/lookups/file-to-id.tab.keystream b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/lookups/file-to-id.tab.keystream new file mode 100644 index 0000000..bfab74d Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/lookups/file-to-id.tab.keystream differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/lookups/file-to-id.tab.keystream.len b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/lookups/file-to-id.tab.keystream.len new file mode 100644 index 0000000..7acc452 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/lookups/file-to-id.tab.keystream.len differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/lookups/file-to-id.tab.len b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/lookups/file-to-id.tab.len new file mode 100644 index 0000000..3085af4 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/lookups/file-to-id.tab.len differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/lookups/file-to-id.tab.values.at b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/lookups/file-to-id.tab.values.at new file mode 100644 index 0000000..ca46eca Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/lookups/file-to-id.tab.values.at differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/lookups/file-to-id.tab_i b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/lookups/file-to-id.tab_i new file mode 100644 index 0000000..e5bbf4d Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/lookups/file-to-id.tab_i differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/lookups/file-to-id.tab_i.len b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/lookups/file-to-id.tab_i.len new file mode 100644 index 0000000..131e265 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/lookups/file-to-id.tab_i.len differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/lookups/id-to-file.tab b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/lookups/id-to-file.tab new file mode 100644 index 0000000..331188a Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/lookups/id-to-file.tab differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/lookups/id-to-file.tab.keystream b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/lookups/id-to-file.tab.keystream new file mode 100644 index 0000000..31a0c7e Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/lookups/id-to-file.tab.keystream differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/lookups/id-to-file.tab.keystream.len b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/lookups/id-to-file.tab.keystream.len new file mode 100644 index 0000000..b01f22d Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/lookups/id-to-file.tab.keystream.len differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/lookups/id-to-file.tab.len b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/lookups/id-to-file.tab.len new file mode 100644 index 0000000..3085af4 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/lookups/id-to-file.tab.len differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/lookups/id-to-file.tab.values.at b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/lookups/id-to-file.tab.values.at new file mode 100644 index 0000000..34d02d6 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/lookups/id-to-file.tab.values.at differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/lookups/id-to-file.tab_i b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/lookups/id-to-file.tab_i new file mode 100644 index 0000000..aa13d7e Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/lookups/id-to-file.tab_i differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/lookups/id-to-file.tab_i.len b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/lookups/id-to-file.tab_i.len new file mode 100644 index 0000000..131e265 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/lookups/id-to-file.tab_i.len differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/lookups/lookups.tab b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/lookups/lookups.tab new file mode 100644 index 0000000..76ac1f3 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/lookups/lookups.tab differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/lookups/lookups.tab.keystream b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/lookups/lookups.tab.keystream new file mode 100644 index 0000000..6423b6e Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/lookups/lookups.tab.keystream differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/lookups/lookups.tab.keystream.len b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/lookups/lookups.tab.keystream.len new file mode 100644 index 0000000..f4c29f5 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/lookups/lookups.tab.keystream.len differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/lookups/lookups.tab.len b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/lookups/lookups.tab.len new file mode 100644 index 0000000..161e5d5 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/lookups/lookups.tab.len differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/lookups/lookups.tab.values.at b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/lookups/lookups.tab.values.at new file mode 100644 index 0000000..1bc8208 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/lookups/lookups.tab.values.at differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/lookups/lookups.tab_i b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/lookups/lookups.tab_i new file mode 100644 index 0000000..5487aa9 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/lookups/lookups.tab_i differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/lookups/lookups.tab_i.len b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/lookups/lookups.tab_i.len new file mode 100644 index 0000000..131e265 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/caches-jvm/lookups/lookups.tab_i.len differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/last-build.bin b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/last-build.bin new file mode 100644 index 0000000..2002b51 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/cacheable/last-build.bin differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/classpath-snapshot/shrunk-classpath-snapshot.bin b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/classpath-snapshot/shrunk-classpath-snapshot.bin new file mode 100644 index 0000000..d573ab8 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/classpath-snapshot/shrunk-classpath-snapshot.bin differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/local-state/build-history.bin b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/local-state/build-history.bin new file mode 100644 index 0000000..7de3451 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/kotlin/compileDebugKotlin/local-state/build-history.bin differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/outputs/logs/manifest-merger-debug-report.txt b/vendor/kotlinaudio/kotlin-audio/build/outputs/logs/manifest-merger-debug-report.txt new file mode 100644 index 0000000..b53c1f9 --- /dev/null +++ b/vendor/kotlinaudio/kotlin-audio/build/outputs/logs/manifest-merger-debug-report.txt @@ -0,0 +1,16 @@ +-- Merging decision tree log --- +manifest +ADDED from /Users/landerhartel/Documents/astra/astra-mobile/vendor/kotlinaudio/kotlin-audio/build/intermediates/tmp/ProcessLibraryManifest/debug/tempAndroidManifest7934958282317765418.xml:2:13-83 +INJECTED from /Users/landerhartel/Documents/astra/astra-mobile/vendor/kotlinaudio/kotlin-audio/build/intermediates/tmp/ProcessLibraryManifest/debug/tempAndroidManifest7934958282317765418.xml:2:13-83 + package + INJECTED from /Users/landerhartel/Documents/astra/astra-mobile/vendor/kotlinaudio/kotlin-audio/build/intermediates/tmp/ProcessLibraryManifest/debug/tempAndroidManifest7934958282317765418.xml + xmlns:android + ADDED from /Users/landerhartel/Documents/astra/astra-mobile/vendor/kotlinaudio/kotlin-audio/build/intermediates/tmp/ProcessLibraryManifest/debug/tempAndroidManifest7934958282317765418.xml:2:23-81 +uses-sdk +INJECTED from /Users/landerhartel/Documents/astra/astra-mobile/vendor/kotlinaudio/kotlin-audio/build/intermediates/tmp/ProcessLibraryManifest/debug/tempAndroidManifest7934958282317765418.xml reason: use-sdk injection requested +INJECTED from /Users/landerhartel/Documents/astra/astra-mobile/vendor/kotlinaudio/kotlin-audio/build/intermediates/tmp/ProcessLibraryManifest/debug/tempAndroidManifest7934958282317765418.xml +INJECTED from /Users/landerhartel/Documents/astra/astra-mobile/vendor/kotlinaudio/kotlin-audio/build/intermediates/tmp/ProcessLibraryManifest/debug/tempAndroidManifest7934958282317765418.xml + android:targetSdkVersion + INJECTED from /Users/landerhartel/Documents/astra/astra-mobile/vendor/kotlinaudio/kotlin-audio/build/intermediates/tmp/ProcessLibraryManifest/debug/tempAndroidManifest7934958282317765418.xml + android:minSdkVersion + INJECTED from /Users/landerhartel/Documents/astra/astra-mobile/vendor/kotlinaudio/kotlin-audio/build/intermediates/tmp/ProcessLibraryManifest/debug/tempAndroidManifest7934958282317765418.xml diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/compileDebugJavaWithJavac/previous-compilation-data.bin b/vendor/kotlinaudio/kotlin-audio/build/tmp/compileDebugJavaWithJavac/previous-compilation-data.bin new file mode 100644 index 0000000..75320ca Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/compileDebugJavaWithJavac/previous-compilation-data.bin differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/META-INF/kotlin-audio_debug.kotlin_module b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/META-INF/kotlin-audio_debug.kotlin_module new file mode 100644 index 0000000..5007816 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/META-INF/kotlin-audio_debug.kotlin_module differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/event/EventHolder.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/event/EventHolder.class new file mode 100644 index 0000000..05060b4 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/event/EventHolder.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/event/NotificationEventHolder$updateNotificationState$1.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/event/NotificationEventHolder$updateNotificationState$1.class new file mode 100644 index 0000000..b4a1b02 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/event/NotificationEventHolder$updateNotificationState$1.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/event/NotificationEventHolder.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/event/NotificationEventHolder.class new file mode 100644 index 0000000..09765b9 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/event/NotificationEventHolder.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/event/PlayerEventHolder$updateAudioItemTransition$1.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/event/PlayerEventHolder$updateAudioItemTransition$1.class new file mode 100644 index 0000000..8c3c3cb Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/event/PlayerEventHolder$updateAudioItemTransition$1.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/event/PlayerEventHolder$updateAudioPlayerState$1.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/event/PlayerEventHolder$updateAudioPlayerState$1.class new file mode 100644 index 0000000..aaf7d1c Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/event/PlayerEventHolder$updateAudioPlayerState$1.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/event/PlayerEventHolder$updateOnAudioFocusChanged$1.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/event/PlayerEventHolder$updateOnAudioFocusChanged$1.class new file mode 100644 index 0000000..238d25c Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/event/PlayerEventHolder$updateOnAudioFocusChanged$1.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/event/PlayerEventHolder$updateOnCommonMetadata$1.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/event/PlayerEventHolder$updateOnCommonMetadata$1.class new file mode 100644 index 0000000..a80de41 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/event/PlayerEventHolder$updateOnCommonMetadata$1.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/event/PlayerEventHolder$updateOnPlayerActionTriggeredExternally$1.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/event/PlayerEventHolder$updateOnPlayerActionTriggeredExternally$1.class new file mode 100644 index 0000000..975112b Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/event/PlayerEventHolder$updateOnPlayerActionTriggeredExternally$1.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/event/PlayerEventHolder$updateOnTimedMetadata$1.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/event/PlayerEventHolder$updateOnTimedMetadata$1.class new file mode 100644 index 0000000..be90805 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/event/PlayerEventHolder$updateOnTimedMetadata$1.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/event/PlayerEventHolder$updatePlayWhenReadyChange$1.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/event/PlayerEventHolder$updatePlayWhenReadyChange$1.class new file mode 100644 index 0000000..13cfbcf Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/event/PlayerEventHolder$updatePlayWhenReadyChange$1.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/event/PlayerEventHolder$updatePlaybackEndedReason$1.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/event/PlayerEventHolder$updatePlaybackEndedReason$1.class new file mode 100644 index 0000000..ee7f84b Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/event/PlayerEventHolder$updatePlaybackEndedReason$1.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/event/PlayerEventHolder$updatePlaybackError$1.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/event/PlayerEventHolder$updatePlaybackError$1.class new file mode 100644 index 0000000..0bad8d5 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/event/PlayerEventHolder$updatePlaybackError$1.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/event/PlayerEventHolder$updatePositionChangedReason$1.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/event/PlayerEventHolder$updatePositionChangedReason$1.class new file mode 100644 index 0000000..83bb905 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/event/PlayerEventHolder$updatePositionChangedReason$1.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/event/PlayerEventHolder.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/event/PlayerEventHolder.class new file mode 100644 index 0000000..e99ada1 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/event/PlayerEventHolder.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/AudioContentType.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/AudioContentType.class new file mode 100644 index 0000000..5d227ca Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/AudioContentType.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/AudioItem.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/AudioItem.class new file mode 100644 index 0000000..817210f Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/AudioItem.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/AudioItemHolder.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/AudioItemHolder.class new file mode 100644 index 0000000..9a5d874 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/AudioItemHolder.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/AudioItemOptions.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/AudioItemOptions.class new file mode 100644 index 0000000..05c4736 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/AudioItemOptions.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/AudioItemTransitionReason$AUTO.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/AudioItemTransitionReason$AUTO.class new file mode 100644 index 0000000..e562f7a Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/AudioItemTransitionReason$AUTO.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/AudioItemTransitionReason$QUEUE_CHANGED.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/AudioItemTransitionReason$QUEUE_CHANGED.class new file mode 100644 index 0000000..be940bd Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/AudioItemTransitionReason$QUEUE_CHANGED.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/AudioItemTransitionReason$REPEAT.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/AudioItemTransitionReason$REPEAT.class new file mode 100644 index 0000000..a4225d1 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/AudioItemTransitionReason$REPEAT.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/AudioItemTransitionReason$SEEK_TO_ANOTHER_AUDIO_ITEM.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/AudioItemTransitionReason$SEEK_TO_ANOTHER_AUDIO_ITEM.class new file mode 100644 index 0000000..0c8b266 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/AudioItemTransitionReason$SEEK_TO_ANOTHER_AUDIO_ITEM.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/AudioItemTransitionReason.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/AudioItemTransitionReason.class new file mode 100644 index 0000000..0262296 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/AudioItemTransitionReason.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/AudioPlayerState.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/AudioPlayerState.class new file mode 100644 index 0000000..c95399b Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/AudioPlayerState.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/BufferConfig.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/BufferConfig.class new file mode 100644 index 0000000..14861f4 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/BufferConfig.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/CacheConfig.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/CacheConfig.class new file mode 100644 index 0000000..5e0f27a Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/CacheConfig.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/Capability.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/Capability.class new file mode 100644 index 0000000..5ce8861 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/Capability.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/DefaultAudioItem.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/DefaultAudioItem.class new file mode 100644 index 0000000..c7e4975 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/DefaultAudioItem.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/DefaultPlayerOptions.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/DefaultPlayerOptions.class new file mode 100644 index 0000000..f1799b5 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/DefaultPlayerOptions.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/DefaultQueuedPlayerOptions$WhenMappings.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/DefaultQueuedPlayerOptions$WhenMappings.class new file mode 100644 index 0000000..2e29ecb Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/DefaultQueuedPlayerOptions$WhenMappings.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/DefaultQueuedPlayerOptions.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/DefaultQueuedPlayerOptions.class new file mode 100644 index 0000000..24212af Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/DefaultQueuedPlayerOptions.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/FocusChangeData.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/FocusChangeData.class new file mode 100644 index 0000000..09f6155 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/FocusChangeData.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/MediaSessionCallback$FORWARD.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/MediaSessionCallback$FORWARD.class new file mode 100644 index 0000000..27a5104 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/MediaSessionCallback$FORWARD.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/MediaSessionCallback$NEXT.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/MediaSessionCallback$NEXT.class new file mode 100644 index 0000000..740cbb8 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/MediaSessionCallback$NEXT.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/MediaSessionCallback$PAUSE.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/MediaSessionCallback$PAUSE.class new file mode 100644 index 0000000..4449ea5 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/MediaSessionCallback$PAUSE.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/MediaSessionCallback$PLAY.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/MediaSessionCallback$PLAY.class new file mode 100644 index 0000000..7546e70 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/MediaSessionCallback$PLAY.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/MediaSessionCallback$PREVIOUS.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/MediaSessionCallback$PREVIOUS.class new file mode 100644 index 0000000..756314a Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/MediaSessionCallback$PREVIOUS.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/MediaSessionCallback$RATING.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/MediaSessionCallback$RATING.class new file mode 100644 index 0000000..5bf4e0f Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/MediaSessionCallback$RATING.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/MediaSessionCallback$REWIND.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/MediaSessionCallback$REWIND.class new file mode 100644 index 0000000..f14e87c Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/MediaSessionCallback$REWIND.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/MediaSessionCallback$SEEK.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/MediaSessionCallback$SEEK.class new file mode 100644 index 0000000..e8d651c Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/MediaSessionCallback$SEEK.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/MediaSessionCallback$STOP.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/MediaSessionCallback$STOP.class new file mode 100644 index 0000000..4499d11 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/MediaSessionCallback$STOP.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/MediaSessionCallback.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/MediaSessionCallback.class new file mode 100644 index 0000000..4362142 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/MediaSessionCallback.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/MediaType.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/MediaType.class new file mode 100644 index 0000000..2a76328 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/MediaType.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/NotificationButton$BACKWARD.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/NotificationButton$BACKWARD.class new file mode 100644 index 0000000..9590b9f Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/NotificationButton$BACKWARD.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/NotificationButton$FORWARD.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/NotificationButton$FORWARD.class new file mode 100644 index 0000000..ad2ecf8 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/NotificationButton$FORWARD.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/NotificationButton$NEXT.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/NotificationButton$NEXT.class new file mode 100644 index 0000000..df1460c Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/NotificationButton$NEXT.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/NotificationButton$PLAY_PAUSE.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/NotificationButton$PLAY_PAUSE.class new file mode 100644 index 0000000..ee2bd4b Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/NotificationButton$PLAY_PAUSE.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/NotificationButton$PREVIOUS.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/NotificationButton$PREVIOUS.class new file mode 100644 index 0000000..a671fa5 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/NotificationButton$PREVIOUS.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/NotificationButton$SEEK_TO.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/NotificationButton$SEEK_TO.class new file mode 100644 index 0000000..ff7d552 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/NotificationButton$SEEK_TO.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/NotificationButton$STOP.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/NotificationButton$STOP.class new file mode 100644 index 0000000..b65f8ad Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/NotificationButton$STOP.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/NotificationButton.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/NotificationButton.class new file mode 100644 index 0000000..5106e24 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/NotificationButton.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/NotificationConfig.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/NotificationConfig.class new file mode 100644 index 0000000..7123c06 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/NotificationConfig.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/NotificationState$CANCELLED.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/NotificationState$CANCELLED.class new file mode 100644 index 0000000..527cac5 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/NotificationState$CANCELLED.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/NotificationState$POSTED.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/NotificationState$POSTED.class new file mode 100644 index 0000000..16c3b50 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/NotificationState$POSTED.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/NotificationState.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/NotificationState.class new file mode 100644 index 0000000..a34108c Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/NotificationState.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/PlayWhenReadyChangeData.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/PlayWhenReadyChangeData.class new file mode 100644 index 0000000..1ff8344 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/PlayWhenReadyChangeData.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/PlaybackEndedReason.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/PlaybackEndedReason.class new file mode 100644 index 0000000..a078433 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/PlaybackEndedReason.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/PlaybackError.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/PlaybackError.class new file mode 100644 index 0000000..94e2a6e Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/PlaybackError.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/PlayerConfig.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/PlayerConfig.class new file mode 100644 index 0000000..538d23b Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/PlayerConfig.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/PlayerOptions.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/PlayerOptions.class new file mode 100644 index 0000000..da742fb Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/PlayerOptions.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/PositionChangedReason$AUTO.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/PositionChangedReason$AUTO.class new file mode 100644 index 0000000..da77c05 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/PositionChangedReason$AUTO.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/PositionChangedReason$QUEUE_CHANGED.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/PositionChangedReason$QUEUE_CHANGED.class new file mode 100644 index 0000000..58e1c60 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/PositionChangedReason$QUEUE_CHANGED.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/PositionChangedReason$SEEK.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/PositionChangedReason$SEEK.class new file mode 100644 index 0000000..d979c25 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/PositionChangedReason$SEEK.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/PositionChangedReason$SEEK_FAILED.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/PositionChangedReason$SEEK_FAILED.class new file mode 100644 index 0000000..97596fb Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/PositionChangedReason$SEEK_FAILED.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/PositionChangedReason$SKIPPED_PERIOD.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/PositionChangedReason$SKIPPED_PERIOD.class new file mode 100644 index 0000000..98fb2f8 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/PositionChangedReason$SKIPPED_PERIOD.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/PositionChangedReason$UNKNOWN.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/PositionChangedReason$UNKNOWN.class new file mode 100644 index 0000000..bbafead Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/PositionChangedReason$UNKNOWN.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/PositionChangedReason.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/PositionChangedReason.class new file mode 100644 index 0000000..beacbc6 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/PositionChangedReason.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/QueuedPlayerOptions.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/QueuedPlayerOptions.class new file mode 100644 index 0000000..50fe55e Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/QueuedPlayerOptions.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/RepeatMode$Companion.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/RepeatMode$Companion.class new file mode 100644 index 0000000..9f963ff Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/RepeatMode$Companion.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/RepeatMode.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/RepeatMode.class new file mode 100644 index 0000000..9583d30 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/RepeatMode.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/WakeMode.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/WakeMode.class new file mode 100644 index 0000000..705f6ef Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/models/WakeMode.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$1.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$1.class new file mode 100644 index 0000000..2e4e184 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$1.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$Companion.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$Companion.class new file mode 100644 index 0000000..b1ff271 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$Companion.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$createMediaSessionAction$1.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$createMediaSessionAction$1.class new file mode 100644 index 0000000..a9ccd3c Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$createMediaSessionAction$1.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$createNotification$1.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$createNotification$1.class new file mode 100644 index 0000000..5b2cce6 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$createNotification$1.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$customActionReceiver$1.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$customActionReceiver$1.class new file mode 100644 index 0000000..a26a04b Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$customActionReceiver$1.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$descriptionAdapter$1$getCurrentLargeIcon$$inlined$target$default$1.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$descriptionAdapter$1$getCurrentLargeIcon$$inlined$target$default$1.class new file mode 100644 index 0000000..742ffda Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$descriptionAdapter$1$getCurrentLargeIcon$$inlined$target$default$1.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$descriptionAdapter$1.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$descriptionAdapter$1.class new file mode 100644 index 0000000..e1ca374 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$descriptionAdapter$1.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$destroy$1.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$destroy$1.class new file mode 100644 index 0000000..9b9fa61 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$destroy$1.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$invalidate$1.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$invalidate$1.class new file mode 100644 index 0000000..814bef6 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$invalidate$1.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$onNotificationCancelled$1.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$onNotificationCancelled$1.class new file mode 100644 index 0000000..61bd272 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$onNotificationCancelled$1.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$onNotificationPosted$1.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$onNotificationPosted$1.class new file mode 100644 index 0000000..efe7220 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$onNotificationPosted$1.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$showForwardButton$1.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$showForwardButton$1.class new file mode 100644 index 0000000..cd15ed5 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$showForwardButton$1.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$showForwardButtonCompact$1.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$showForwardButtonCompact$1.class new file mode 100644 index 0000000..36d96af Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$showForwardButtonCompact$1.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$showNextButton$1.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$showNextButton$1.class new file mode 100644 index 0000000..d7921d6 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$showNextButton$1.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$showNextButtonCompact$1.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$showNextButtonCompact$1.class new file mode 100644 index 0000000..70700b2 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$showNextButtonCompact$1.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$showPlayPauseButton$1.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$showPlayPauseButton$1.class new file mode 100644 index 0000000..85f970f Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$showPlayPauseButton$1.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$showPreviousButton$1.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$showPreviousButton$1.class new file mode 100644 index 0000000..d4860e5 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$showPreviousButton$1.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$showPreviousButtonCompact$1.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$showPreviousButtonCompact$1.class new file mode 100644 index 0000000..3570f42 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$showPreviousButtonCompact$1.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$showRewindButton$1.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$showRewindButton$1.class new file mode 100644 index 0000000..78bfc75 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$showRewindButton$1.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$showRewindButtonCompact$1.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$showRewindButtonCompact$1.class new file mode 100644 index 0000000..c57f883 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$showRewindButtonCompact$1.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$showStopButton$1.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$showStopButton$1.class new file mode 100644 index 0000000..105a2b0 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$showStopButton$1.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$special$$inlined$target$default$1.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$special$$inlined$target$default$1.class new file mode 100644 index 0000000..ba44c3b Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$special$$inlined$target$default$1.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$updateMediaSessionPlaybackActions$$inlined$sortedBy$1.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$updateMediaSessionPlaybackActions$$inlined$sortedBy$1.class new file mode 100644 index 0000000..609a36e Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/notification/NotificationManager$updateMediaSessionPlaybackActions$$inlined$sortedBy$1.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/notification/NotificationManager.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/notification/NotificationManager.class new file mode 100644 index 0000000..adcd60a Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/notification/NotificationManager.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/players/AudioPlayer.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/players/AudioPlayer.class new file mode 100644 index 0000000..d1ba33d Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/players/AudioPlayer.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/players/BaseAudioPlayer$2$WhenMappings.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/players/BaseAudioPlayer$2$WhenMappings.class new file mode 100644 index 0000000..50881fb Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/players/BaseAudioPlayer$2$WhenMappings.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/players/BaseAudioPlayer$2.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/players/BaseAudioPlayer$2.class new file mode 100644 index 0000000..8d57ddc Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/players/BaseAudioPlayer$2.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/players/BaseAudioPlayer$Companion.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/players/BaseAudioPlayer$Companion.class new file mode 100644 index 0000000..125b5cb Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/players/BaseAudioPlayer$Companion.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/players/BaseAudioPlayer$PlayerListener.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/players/BaseAudioPlayer$PlayerListener.class new file mode 100644 index 0000000..8780c9a Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/players/BaseAudioPlayer$PlayerListener.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/players/BaseAudioPlayer$WhenMappings.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/players/BaseAudioPlayer$WhenMappings.class new file mode 100644 index 0000000..37790a2 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/players/BaseAudioPlayer$WhenMappings.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/players/BaseAudioPlayer$createForwardingPlayer$1.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/players/BaseAudioPlayer$createForwardingPlayer$1.class new file mode 100644 index 0000000..463ae3b Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/players/BaseAudioPlayer$createForwardingPlayer$1.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/players/BaseAudioPlayer$ratingType$1.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/players/BaseAudioPlayer$ratingType$1.class new file mode 100644 index 0000000..e6a2875 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/players/BaseAudioPlayer$ratingType$1.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/players/BaseAudioPlayer.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/players/BaseAudioPlayer.class new file mode 100644 index 0000000..1014987 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/players/BaseAudioPlayer.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/players/QueuedAudioPlayer.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/players/QueuedAudioPlayer.class new file mode 100644 index 0000000..7f6dab0 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/players/QueuedAudioPlayer.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/players/components/MediaItemExtKt.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/players/components/MediaItemExtKt.class new file mode 100644 index 0000000..8a96b7c Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/players/components/MediaItemExtKt.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/players/components/PlayerCache.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/players/components/PlayerCache.class new file mode 100644 index 0000000..5449769 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/players/components/PlayerCache.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/scope/ScopeRenderersFactoryKt$buildScopeRenderersFactory$1.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/scope/ScopeRenderersFactoryKt$buildScopeRenderersFactory$1.class new file mode 100644 index 0000000..77d4287 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/scope/ScopeRenderersFactoryKt$buildScopeRenderersFactory$1.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/scope/ScopeRenderersFactoryKt.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/scope/ScopeRenderersFactoryKt.class new file mode 100644 index 0000000..33360a1 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/scope/ScopeRenderersFactoryKt.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/scope/ScopeTapAudioProcessor.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/scope/ScopeTapAudioProcessor.class new file mode 100644 index 0000000..8bf76b8 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/scope/ScopeTapAudioProcessor.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/utils/UtilsKt.class b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/utils/UtilsKt.class new file mode 100644 index 0000000..b311af1 Binary files /dev/null and b/vendor/kotlinaudio/kotlin-audio/build/tmp/kotlin-classes/debug/com/doublesymmetry/kotlinaudio/utils/UtilsKt.class differ diff --git a/vendor/kotlinaudio/kotlin-audio/src/main/java/com/doublesymmetry/kotlinaudio/event/EventHolder.kt b/vendor/kotlinaudio/kotlin-audio/src/main/java/com/doublesymmetry/kotlinaudio/event/EventHolder.kt new file mode 100644 index 0000000..8252e09 --- /dev/null +++ b/vendor/kotlinaudio/kotlin-audio/src/main/java/com/doublesymmetry/kotlinaudio/event/EventHolder.kt @@ -0,0 +1,33 @@ +package com.doublesymmetry.kotlinaudio.event + +class EventHolder internal constructor(private val notificationEventHolder: NotificationEventHolder, private val playerEventHolder: PlayerEventHolder) { + val audioItemTransition + get() = playerEventHolder.audioItemTransition + + val notificationStateChange + get() = notificationEventHolder.notificationStateChange + + val onAudioFocusChanged + get() = playerEventHolder.onAudioFocusChanged + + val onCommonMetadata + get() = playerEventHolder.onCommonMetadata + + val onTimedMetadata + get() = playerEventHolder.onTimedMetadata + + val onPlayerActionTriggeredExternally + get() = playerEventHolder.onPlayerActionTriggeredExternally + + val playbackEnd + get() = playerEventHolder.playbackEnd + + val playWhenReadyChange + get() = playerEventHolder.playWhenReadyChange + + val stateChange + get() = playerEventHolder.stateChange + + val playbackError + get() = playerEventHolder.playbackError +} \ No newline at end of file diff --git a/vendor/kotlinaudio/kotlin-audio/src/main/java/com/doublesymmetry/kotlinaudio/event/NotificationEventHolder.kt b/vendor/kotlinaudio/kotlin-audio/src/main/java/com/doublesymmetry/kotlinaudio/event/NotificationEventHolder.kt new file mode 100644 index 0000000..5545e2b --- /dev/null +++ b/vendor/kotlinaudio/kotlin-audio/src/main/java/com/doublesymmetry/kotlinaudio/event/NotificationEventHolder.kt @@ -0,0 +1,20 @@ +package com.doublesymmetry.kotlinaudio.event + +import com.doublesymmetry.kotlinaudio.models.NotificationState +import kotlinx.coroutines.MainScope +import kotlinx.coroutines.flow.MutableSharedFlow +import kotlinx.coroutines.flow.asSharedFlow +import kotlinx.coroutines.launch + +class NotificationEventHolder { + private val coroutineScope = MainScope() + + private var _notificationStateChange = MutableSharedFlow(1) + var notificationStateChange = _notificationStateChange.asSharedFlow() + + internal fun updateNotificationState(state: NotificationState) { + coroutineScope.launch { + _notificationStateChange.emit(state) + } + } +} \ No newline at end of file diff --git a/vendor/kotlinaudio/kotlin-audio/src/main/java/com/doublesymmetry/kotlinaudio/event/PlayerEventHolder.kt b/vendor/kotlinaudio/kotlin-audio/src/main/java/com/doublesymmetry/kotlinaudio/event/PlayerEventHolder.kt new file mode 100644 index 0000000..259bde4 --- /dev/null +++ b/vendor/kotlinaudio/kotlin-audio/src/main/java/com/doublesymmetry/kotlinaudio/event/PlayerEventHolder.kt @@ -0,0 +1,123 @@ +package com.doublesymmetry.kotlinaudio.event + +import com.doublesymmetry.kotlinaudio.models.* +import com.google.android.exoplayer2.MediaMetadata +import com.google.android.exoplayer2.metadata.Metadata +import kotlinx.coroutines.MainScope +import kotlinx.coroutines.flow.MutableSharedFlow +import kotlinx.coroutines.flow.MutableStateFlow +import kotlinx.coroutines.flow.asSharedFlow +import kotlinx.coroutines.flow.asStateFlow +import kotlinx.coroutines.launch + +class PlayerEventHolder { + private val coroutineScope = MainScope() + + private var _stateChange = MutableSharedFlow(1) + var stateChange = _stateChange.asSharedFlow() + + private var _playbackEnd = MutableSharedFlow(1) + var playbackEnd = _playbackEnd.asSharedFlow() + + private var _playbackError = MutableSharedFlow(1) + var playbackError = _playbackError.asSharedFlow() + + private var _playWhenReadyChange = MutableSharedFlow(1) + /** + * Use these events to track when [com.doublesymmetry.kotlinaudio.players.BaseAudioPlayer.playWhenReady] + * changes. + */ + var playWhenReadyChange = _playWhenReadyChange.asSharedFlow() + + private var _audioItemTransition = MutableSharedFlow(1) + + /** + * Use these events to track when and why an [AudioItem] transitions to another. + * + * Examples of an audio transition include changes to [AudioItem] queue, an [AudioItem] on repeat, skipping an [AudioItem], or simply when the [AudioItem] has finished. + */ + var audioItemTransition = _audioItemTransition.asSharedFlow() + + private var _positionChanged = MutableSharedFlow(1) + var positionChanged = _positionChanged.asSharedFlow() + + private var _onAudioFocusChanged = MutableSharedFlow(1) + var onAudioFocusChanged = _onAudioFocusChanged.asSharedFlow() + + private var _onCommonMetadata = MutableSharedFlow(1) + var onCommonMetadata = _onCommonMetadata.asSharedFlow() + + private var _onTimedMetadata = MutableSharedFlow(1) + var onTimedMetadata = _onTimedMetadata.asSharedFlow() + + private var _onPlayerActionTriggeredExternally = MutableSharedFlow() + + /** + * Use these events to track whenever a player action has been triggered from an outside source. + * + * The sources can be: media buttons on headphones, Android Wear, Android Auto, Google Assistant, media notification, etc. + * + * For this observable to send events, set [interceptPlayerActionsTriggeredExternally][com.doublesymmetry.kotlinaudio.models.PlayerConfig.interceptPlayerActionsTriggeredExternally] to true. + */ + var onPlayerActionTriggeredExternally = _onPlayerActionTriggeredExternally.asSharedFlow() + + internal fun updateAudioPlayerState(state: AudioPlayerState) { + coroutineScope.launch { + _stateChange.emit(state) + } + } + + internal fun updatePlaybackEndedReason(reason: PlaybackEndedReason) { + coroutineScope.launch { + _playbackEnd.emit(reason) + } + } + + internal fun updatePlayWhenReadyChange(playWhenReadyChange: PlayWhenReadyChangeData) { + coroutineScope.launch { + _playWhenReadyChange.emit(playWhenReadyChange) + } + } + + internal fun updateAudioItemTransition(reason: AudioItemTransitionReason) { + coroutineScope.launch { + _audioItemTransition.emit(reason) + } + } + + internal fun updatePositionChangedReason(reason: PositionChangedReason) { + coroutineScope.launch { + _positionChanged.emit(reason) + } + } + + internal fun updateOnAudioFocusChanged(isPaused: Boolean, isPermanent: Boolean) { + coroutineScope.launch { + _onAudioFocusChanged.emit(FocusChangeData(isPaused, isPermanent)) + } + } + + internal fun updateOnCommonMetadata(metadata: MediaMetadata) { + coroutineScope.launch { + _onCommonMetadata.emit(metadata) + } + } + + internal fun updateOnTimedMetadata(metadata: Metadata) { + coroutineScope.launch { + _onTimedMetadata.emit(metadata) + } + } + + internal fun updatePlaybackError(error: PlaybackError) { + coroutineScope.launch { + _playbackError.emit(error) + } + } + + internal fun updateOnPlayerActionTriggeredExternally(callback: MediaSessionCallback) { + coroutineScope.launch { + _onPlayerActionTriggeredExternally.emit(callback) + } + } +} \ No newline at end of file diff --git a/vendor/kotlinaudio/kotlin-audio/src/main/java/com/doublesymmetry/kotlinaudio/models/AudioContentType.kt b/vendor/kotlinaudio/kotlin-audio/src/main/java/com/doublesymmetry/kotlinaudio/models/AudioContentType.kt new file mode 100644 index 0000000..68b8310 --- /dev/null +++ b/vendor/kotlinaudio/kotlin-audio/src/main/java/com/doublesymmetry/kotlinaudio/models/AudioContentType.kt @@ -0,0 +1,10 @@ +package com.doublesymmetry.kotlinaudio.models + +enum class AudioContentType { + MUSIC, + SPEECH, + SONIFICATION, + MOVIE, + UNKNOWN +} + diff --git a/vendor/kotlinaudio/kotlin-audio/src/main/java/com/doublesymmetry/kotlinaudio/models/AudioItem.kt b/vendor/kotlinaudio/kotlin-audio/src/main/java/com/doublesymmetry/kotlinaudio/models/AudioItem.kt new file mode 100644 index 0000000..badf6eb --- /dev/null +++ b/vendor/kotlinaudio/kotlin-audio/src/main/java/com/doublesymmetry/kotlinaudio/models/AudioItem.kt @@ -0,0 +1,64 @@ +package com.doublesymmetry.kotlinaudio.models + +import android.graphics.Bitmap + +interface AudioItem { + var audioUrl: String + val type: MediaType + var artist: String? + var title: String? + var albumTitle: String? + val artwork: String? + val duration: Long? + val options: AudioItemOptions? +} + +data class AudioItemOptions( + val headers: MutableMap? = null, + val userAgent: String? = null, + val resourceId: Int? = null +) + +enum class MediaType(val value: String) { + /** + * The default media type. Should be used for streams over HTTP or files + */ + DEFAULT("default"), + + /** + * The DASH media type for adaptive streams. Should be used with DASH manifests. + */ + DASH("dash"), + + /** + * The HLS media type for adaptive streams. Should be used with HLS playlists. + */ + HLS("hls"), + + /** + * The SmoothStreaming media type for adaptive streams. Should be used with SmoothStreaming manifests. + */ + SMOOTH_STREAMING("smoothstreaming"); +} + +data class DefaultAudioItem( + override var audioUrl: String, + + /** + * Set to [MediaType.DEFAULT] by default. + */ + override val type: MediaType = MediaType.DEFAULT, + + override var artist: String? = null, + override var title: String? = null, + override var albumTitle: String? = null, + override var artwork: String? = null, + override val duration: Long? = null, + override val options: AudioItemOptions? = null, +) : AudioItem + +class AudioItemHolder( + var audioItem: AudioItem +) { + var artworkBitmap: Bitmap? = null +} diff --git a/vendor/kotlinaudio/kotlin-audio/src/main/java/com/doublesymmetry/kotlinaudio/models/AudioItemTransitionReason.kt b/vendor/kotlinaudio/kotlin-audio/src/main/java/com/doublesymmetry/kotlinaudio/models/AudioItemTransitionReason.kt new file mode 100644 index 0000000..bf6b24c --- /dev/null +++ b/vendor/kotlinaudio/kotlin-audio/src/main/java/com/doublesymmetry/kotlinaudio/models/AudioItemTransitionReason.kt @@ -0,0 +1,33 @@ +package com.doublesymmetry.kotlinaudio.models + +/** + * Use these events to track when and why an [AudioItem] transitions to another. + * Examples of an audio transition include changes to [AudioItem] queue, an [AudioItem] on repeat, skipping an [AudioItem], or simply when the [AudioItem] has finished. + */ +sealed class AudioItemTransitionReason(val oldPosition: Long) { + /** + * Playback has automatically transitioned to the next [AudioItem]. + * + * This reason also indicates a transition caused by another player. + */ + class AUTO(oldPosition: Long) : AudioItemTransitionReason(oldPosition) + + /** + * A seek to another [AudioItem] has occurred. Usually triggered when calling + * [QueuedAudioPlayer.next][com.doublesymmetry.kotlinaudio.players.QueuedAudioPlayer.next] + * or [QueuedAudioPlayer.previous][com.doublesymmetry.kotlinaudio.players.QueuedAudioPlayer.previous]. + */ + class SEEK_TO_ANOTHER_AUDIO_ITEM(oldPosition: Long) : AudioItemTransitionReason(oldPosition) + + /** + * The [AudioItem] has been repeated. + */ + class REPEAT(oldPosition: Long) : AudioItemTransitionReason(oldPosition) + + /** + * The current [AudioItem] has changed because of a change in the queue. This can either be if + * the [AudioItem] previously being played has been removed, or when the queue becomes non-empty + * after being empty. + */ + class QUEUE_CHANGED(oldPosition: Long) : AudioItemTransitionReason(oldPosition) +} diff --git a/vendor/kotlinaudio/kotlin-audio/src/main/java/com/doublesymmetry/kotlinaudio/models/AudioPlayerState.kt b/vendor/kotlinaudio/kotlin-audio/src/main/java/com/doublesymmetry/kotlinaudio/models/AudioPlayerState.kt new file mode 100644 index 0000000..da9ca13 --- /dev/null +++ b/vendor/kotlinaudio/kotlin-audio/src/main/java/com/doublesymmetry/kotlinaudio/models/AudioPlayerState.kt @@ -0,0 +1,30 @@ +package com.doublesymmetry.kotlinaudio.models + +enum class AudioPlayerState { + /** The current [AudioItem] is being loaded for playback. */ + LOADING, + + /** The current [AudioItem] is loaded, and the player is ready to start playing. */ + READY, + + /** The current [AudioItem] is currently buffering. */ + BUFFERING, + + /** The player is paused. */ + PAUSED, + + /** The player is stopped. */ + STOPPED, + + /** The player is playing. */ + PLAYING, + + /** No [AudioItem] is loaded and the player is doing nothing. */ + IDLE, + + /** Playback stopped due to the end of the queue being reached. */ + ENDED, + + /** The player stopped playing due to an error. */ + ERROR +} diff --git a/vendor/kotlinaudio/kotlin-audio/src/main/java/com/doublesymmetry/kotlinaudio/models/BufferConfig.kt b/vendor/kotlinaudio/kotlin-audio/src/main/java/com/doublesymmetry/kotlinaudio/models/BufferConfig.kt new file mode 100644 index 0000000..36a150d --- /dev/null +++ b/vendor/kotlinaudio/kotlin-audio/src/main/java/com/doublesymmetry/kotlinaudio/models/BufferConfig.kt @@ -0,0 +1,8 @@ +package com.doublesymmetry.kotlinaudio.models + +data class BufferConfig( + val minBuffer: Int?, + val maxBuffer: Int?, + val playBuffer: Int?, + val backBuffer: Int?, +) diff --git a/vendor/kotlinaudio/kotlin-audio/src/main/java/com/doublesymmetry/kotlinaudio/models/CacheConfig.kt b/vendor/kotlinaudio/kotlin-audio/src/main/java/com/doublesymmetry/kotlinaudio/models/CacheConfig.kt new file mode 100644 index 0000000..4fde481 --- /dev/null +++ b/vendor/kotlinaudio/kotlin-audio/src/main/java/com/doublesymmetry/kotlinaudio/models/CacheConfig.kt @@ -0,0 +1,17 @@ +package com.doublesymmetry.kotlinaudio.models + +/** + * Configuration for cache properties of player. + */ +data class CacheConfig( + /** + * Maximum player cache size in kilobytes. + */ + val maxCacheSize: Long?, + + /** + * Cache identifier, used to make cache directory. + */ + val identifier: String = "TrackPlayer" +) + diff --git a/vendor/kotlinaudio/kotlin-audio/src/main/java/com/doublesymmetry/kotlinaudio/models/Capability.kt b/vendor/kotlinaudio/kotlin-audio/src/main/java/com/doublesymmetry/kotlinaudio/models/Capability.kt new file mode 100644 index 0000000..2f99caa --- /dev/null +++ b/vendor/kotlinaudio/kotlin-audio/src/main/java/com/doublesymmetry/kotlinaudio/models/Capability.kt @@ -0,0 +1,19 @@ +package com.doublesymmetry.kotlinaudio.models + +enum class Capability { + PLAY, + PLAY_FROM_ID, + PLAY_FROM_SEARCH, + PAUSE, + STOP, + SEEK_TO, + SKIP, + SKIP_TO_NEXT, + SKIP_TO_PREVIOUS, + JUMP_FORWARD, + JUMP_BACKWARD, + SET_RATING, + LIKE, + DISLIKE, + BOOKMARK +} diff --git a/vendor/kotlinaudio/kotlin-audio/src/main/java/com/doublesymmetry/kotlinaudio/models/FocusChangeData.kt b/vendor/kotlinaudio/kotlin-audio/src/main/java/com/doublesymmetry/kotlinaudio/models/FocusChangeData.kt new file mode 100644 index 0000000..3df1dbe --- /dev/null +++ b/vendor/kotlinaudio/kotlin-audio/src/main/java/com/doublesymmetry/kotlinaudio/models/FocusChangeData.kt @@ -0,0 +1,3 @@ +package com.doublesymmetry.kotlinaudio.models + +data class FocusChangeData(val isPaused: Boolean, val isFocusLostPermanently: Boolean) diff --git a/vendor/kotlinaudio/kotlin-audio/src/main/java/com/doublesymmetry/kotlinaudio/models/MediaSessionCallback.kt b/vendor/kotlinaudio/kotlin-audio/src/main/java/com/doublesymmetry/kotlinaudio/models/MediaSessionCallback.kt new file mode 100644 index 0000000..415cbcf --- /dev/null +++ b/vendor/kotlinaudio/kotlin-audio/src/main/java/com/doublesymmetry/kotlinaudio/models/MediaSessionCallback.kt @@ -0,0 +1,16 @@ +package com.doublesymmetry.kotlinaudio.models + +import android.os.Bundle +import android.support.v4.media.RatingCompat + +sealed class MediaSessionCallback { + class RATING(val rating: RatingCompat, extras: Bundle?): MediaSessionCallback() + object PLAY : MediaSessionCallback() + object PAUSE : MediaSessionCallback() + object NEXT : MediaSessionCallback() + object PREVIOUS : MediaSessionCallback() + object FORWARD : MediaSessionCallback() + object REWIND : MediaSessionCallback() + object STOP : MediaSessionCallback() + class SEEK(val positionMs: Long): MediaSessionCallback() +} diff --git a/vendor/kotlinaudio/kotlin-audio/src/main/java/com/doublesymmetry/kotlinaudio/models/NotificationConfig.kt b/vendor/kotlinaudio/kotlin-audio/src/main/java/com/doublesymmetry/kotlinaudio/models/NotificationConfig.kt new file mode 100644 index 0000000..28563de --- /dev/null +++ b/vendor/kotlinaudio/kotlin-audio/src/main/java/com/doublesymmetry/kotlinaudio/models/NotificationConfig.kt @@ -0,0 +1,42 @@ +package com.doublesymmetry.kotlinaudio.models + +import android.app.PendingIntent +import androidx.annotation.DrawableRes + +/** + * Used to configure the player notification. + * @param buttons Provide customized notification buttons. They will be shown by default. Note that buttons can still be shown and hidden at runtime by using the functions in [NotificationManager][com.doublesymmetry.kotlinaudio.notification.NotificationManager], but they will have the default icon if not set explicitly here. + * @param accentColor The accent color of the notification. + * @param smallIcon The small icon of the notification which is also shown in the system status bar. + * @param pendingIntent The [PendingIntent] that would be called when tapping on the notification itself. + */ +data class NotificationConfig( + val buttons: List, + val accentColor: Int? = null, + @DrawableRes val smallIcon: Int? = null, + val pendingIntent: PendingIntent? = null +) + +/** + * Provide customized notification buttons. They will be shown by default. Note that buttons can still be shown and hidden at runtime by using the functions in [NotificationManager][com.doublesymmetry.kotlinaudio.notification.NotificationManager], but they will have the default icon if not set explicitly here. + * @see [com.doublesymmetry.kotlinaudio.notification.NotificationManager.showPlayPauseButton] + * @see [com.doublesymmetry.kotlinaudio.notification.NotificationManager.showStopButton] + * @see [com.doublesymmetry.kotlinaudio.notification.NotificationManager.showRewindButton] + * @see [com.doublesymmetry.kotlinaudio.notification.NotificationManager.showRewindButtonCompact] + * @see [com.doublesymmetry.kotlinaudio.notification.NotificationManager.showForwardButton] + * @see [com.doublesymmetry.kotlinaudio.notification.NotificationManager.showForwardButtonCompact] + * @see [com.doublesymmetry.kotlinaudio.notification.NotificationManager.showNextButton] + * @see [com.doublesymmetry.kotlinaudio.notification.NotificationManager.showNextButtonCompact] + * @see [com.doublesymmetry.kotlinaudio.notification.NotificationManager.showPreviousButton] + * @see [com.doublesymmetry.kotlinaudio.notification.NotificationManager.showPreviousButtonCompact] + */ +@Suppress("ClassName") +sealed class NotificationButton { + class PLAY_PAUSE(@DrawableRes val playIcon: Int? = null, @DrawableRes val pauseIcon: Int? = null): NotificationButton() + class STOP(@DrawableRes val icon: Int? = null): NotificationButton() + class FORWARD(@DrawableRes val icon: Int? = null, val isCompact: Boolean = false): NotificationButton() + class BACKWARD(@DrawableRes val icon: Int? = null, val isCompact: Boolean = false): NotificationButton() + class NEXT(@DrawableRes val icon: Int? = null, val isCompact: Boolean = false): NotificationButton() + class PREVIOUS(@DrawableRes val icon: Int? = null, val isCompact: Boolean = false): NotificationButton() + object SEEK_TO : NotificationButton() +} \ No newline at end of file diff --git a/vendor/kotlinaudio/kotlin-audio/src/main/java/com/doublesymmetry/kotlinaudio/models/NotificationState.kt b/vendor/kotlinaudio/kotlin-audio/src/main/java/com/doublesymmetry/kotlinaudio/models/NotificationState.kt new file mode 100644 index 0000000..73c15f1 --- /dev/null +++ b/vendor/kotlinaudio/kotlin-audio/src/main/java/com/doublesymmetry/kotlinaudio/models/NotificationState.kt @@ -0,0 +1,8 @@ +package com.doublesymmetry.kotlinaudio.models + +import android.app.Notification + +sealed class NotificationState { + class POSTED(val notificationId: Int, val notification: Notification, val ongoing: Boolean) : NotificationState() + class CANCELLED(val notificationId: Int): NotificationState() +} \ No newline at end of file diff --git a/vendor/kotlinaudio/kotlin-audio/src/main/java/com/doublesymmetry/kotlinaudio/models/PlayWhenReadyChangeData.kt b/vendor/kotlinaudio/kotlin-audio/src/main/java/com/doublesymmetry/kotlinaudio/models/PlayWhenReadyChangeData.kt new file mode 100644 index 0000000..b142b24 --- /dev/null +++ b/vendor/kotlinaudio/kotlin-audio/src/main/java/com/doublesymmetry/kotlinaudio/models/PlayWhenReadyChangeData.kt @@ -0,0 +1,5 @@ +package com.doublesymmetry.kotlinaudio.models + +import com.google.android.exoplayer2.Player + +data class PlayWhenReadyChangeData(val playWhenReady: Boolean, val pausedBecauseReachedEnd: Boolean) diff --git a/vendor/kotlinaudio/kotlin-audio/src/main/java/com/doublesymmetry/kotlinaudio/models/PlaybackEndedReason.kt b/vendor/kotlinaudio/kotlin-audio/src/main/java/com/doublesymmetry/kotlinaudio/models/PlaybackEndedReason.kt new file mode 100644 index 0000000..9ab62cf --- /dev/null +++ b/vendor/kotlinaudio/kotlin-audio/src/main/java/com/doublesymmetry/kotlinaudio/models/PlaybackEndedReason.kt @@ -0,0 +1,5 @@ +package com.doublesymmetry.kotlinaudio.models + +enum class PlaybackEndedReason { + PLAYED_UNTIL_END, PLAYER_STOPPED, SKIPPED_TO_NEXT, SKIPPED_TO_PREVIOUS, JUMPED_TO_INDEX +} \ No newline at end of file diff --git a/vendor/kotlinaudio/kotlin-audio/src/main/java/com/doublesymmetry/kotlinaudio/models/PlaybackError.kt b/vendor/kotlinaudio/kotlin-audio/src/main/java/com/doublesymmetry/kotlinaudio/models/PlaybackError.kt new file mode 100644 index 0000000..7a736a6 --- /dev/null +++ b/vendor/kotlinaudio/kotlin-audio/src/main/java/com/doublesymmetry/kotlinaudio/models/PlaybackError.kt @@ -0,0 +1,6 @@ +package com.doublesymmetry.kotlinaudio.models + +data class PlaybackError ( + val code: String? = null, + val message: String? = null +) \ No newline at end of file diff --git a/vendor/kotlinaudio/kotlin-audio/src/main/java/com/doublesymmetry/kotlinaudio/models/PlayerConfig.kt b/vendor/kotlinaudio/kotlin-audio/src/main/java/com/doublesymmetry/kotlinaudio/models/PlayerConfig.kt new file mode 100644 index 0000000..74cb654 --- /dev/null +++ b/vendor/kotlinaudio/kotlin-audio/src/main/java/com/doublesymmetry/kotlinaudio/models/PlayerConfig.kt @@ -0,0 +1,36 @@ +package com.doublesymmetry.kotlinaudio.models + +data class PlayerConfig( + /** + * Toggle whether or not a player action triggered from an outside source should be intercepted. + * + * The sources can be: media buttons on headphones, Android Wear, Android Auto, Google Assistant, media notification, etc. + * + * Setting this to true enables the use of [onPlayerActionTriggeredExternally][com.doublesymmetry.kotlinaudio.event.PlayerEventHolder.onPlayerActionTriggeredExternally] events. + * + * **Example**: + * ``` + * val player = QueuedAudioPlayer(requireActivity(), playerConfig = PlayerConfig(interceptPlayerActionsTriggeredExternally = true)) + * ``` + */ + var interceptPlayerActionsTriggeredExternally: Boolean = false, + + /** + * Toggle whether the player should pause automatically when audio is rerouted from a headset to device speakers. + */ + val handleAudioBecomingNoisy: Boolean = false, + + /** + * Whether audio focus should be managed automatically. See https://medium.com/google-exoplayer/easy-audio-focus-with-exoplayer-a2dcbbe4640e + */ + val handleAudioFocus: Boolean = false, + /** + * The audio content type. + */ + val audioContentType: AudioContentType = AudioContentType.MUSIC, + + /** + * The audio usage. + */ + val wakeMode: WakeMode = WakeMode.NONE, +) diff --git a/vendor/kotlinaudio/kotlin-audio/src/main/java/com/doublesymmetry/kotlinaudio/models/PlayerOptions.kt b/vendor/kotlinaudio/kotlin-audio/src/main/java/com/doublesymmetry/kotlinaudio/models/PlayerOptions.kt new file mode 100644 index 0000000..0617c46 --- /dev/null +++ b/vendor/kotlinaudio/kotlin-audio/src/main/java/com/doublesymmetry/kotlinaudio/models/PlayerOptions.kt @@ -0,0 +1,9 @@ +package com.doublesymmetry.kotlinaudio.models + +interface PlayerOptions { + var alwaysPauseOnInterruption: Boolean +} + +internal data class DefaultPlayerOptions( + override var alwaysPauseOnInterruption: Boolean = false, +) : PlayerOptions diff --git a/vendor/kotlinaudio/kotlin-audio/src/main/java/com/doublesymmetry/kotlinaudio/models/PositionChangedReason.kt b/vendor/kotlinaudio/kotlin-audio/src/main/java/com/doublesymmetry/kotlinaudio/models/PositionChangedReason.kt new file mode 100644 index 0000000..7b8cc64 --- /dev/null +++ b/vendor/kotlinaudio/kotlin-audio/src/main/java/com/doublesymmetry/kotlinaudio/models/PositionChangedReason.kt @@ -0,0 +1,39 @@ +package com.doublesymmetry.kotlinaudio.models + +/** + * Use these events to track when and why the positionMs of an [AudioItem] changes. + * Examples include changes to [AudioItem] queue, seeking, skipping, etc. + */ +sealed class PositionChangedReason(val oldPosition: Long, val newPosition: Long) { + /** + * Position has changed because the player has automatically transitioned to the next [AudioItem]. + * + * @see [AudioItemTransitionReason] + */ + class AUTO(oldPosition: Long, newPosition: Long) : PositionChangedReason(oldPosition, newPosition) + + /** + * Position has changed because of a queue update. + */ + class QUEUE_CHANGED(oldPosition: Long, newPosition: Long) : PositionChangedReason(oldPosition, newPosition) + + /** + * Position has changed because a seek has occurred within the current [AudioItem], or another one. + */ + class SEEK(oldPosition: Long, newPosition: Long) : PositionChangedReason(oldPosition, newPosition) + + /** + * Position has changed because an attempted seek has failed. This can occur if we tried to see to an invalid positionMs. + */ + class SEEK_FAILED(oldPosition: Long, newPosition: Long) : PositionChangedReason(oldPosition, newPosition) + + /** + * Position has changed because a period (example: an ad) has been skipped. + */ + class SKIPPED_PERIOD(oldPosition: Long, newPosition: Long) : PositionChangedReason(oldPosition, newPosition) + + /** + * Position has changed for an unknown reason. + */ + class UNKNOWN(oldPosition: Long, newPosition: Long) : PositionChangedReason(oldPosition, newPosition) +} diff --git a/vendor/kotlinaudio/kotlin-audio/src/main/java/com/doublesymmetry/kotlinaudio/models/QueuedPlayerOptions.kt b/vendor/kotlinaudio/kotlin-audio/src/main/java/com/doublesymmetry/kotlinaudio/models/QueuedPlayerOptions.kt new file mode 100644 index 0000000..9028ac6 --- /dev/null +++ b/vendor/kotlinaudio/kotlin-audio/src/main/java/com/doublesymmetry/kotlinaudio/models/QueuedPlayerOptions.kt @@ -0,0 +1,49 @@ +package com.doublesymmetry.kotlinaudio.models + +import com.google.android.exoplayer2.ExoPlayer +import com.google.android.exoplayer2.Player + +interface QueuedPlayerOptions : PlayerOptions { + override var alwaysPauseOnInterruption: Boolean + var repeatMode: RepeatMode +} + +class DefaultQueuedPlayerOptions( + private val exoPlayer: ExoPlayer, + override var alwaysPauseOnInterruption: Boolean = false, +) : QueuedPlayerOptions { + // Functions in data classes might or might not be a bit of a code smell. + // I'm using the passed exoPlayer which breaks separation of concerns. But it's also useful. + // More here: https://www.reddit.com/r/Kotlin/comments/ehqe4e/why_is_it_bad_practice_to_have_functions_in_data/ + // TODO: Figure out a way for this function to be outside of this data class + override var repeatMode: RepeatMode + get() { + return when (exoPlayer.repeatMode) { + Player.REPEAT_MODE_ALL -> RepeatMode.ALL + Player.REPEAT_MODE_ONE -> RepeatMode.ONE + else -> RepeatMode.OFF + } + } + set(value) { + when (value) { + RepeatMode.ALL -> exoPlayer.repeatMode = Player.REPEAT_MODE_ALL + RepeatMode.ONE -> exoPlayer.repeatMode = Player.REPEAT_MODE_ONE + RepeatMode.OFF -> exoPlayer.repeatMode = Player.REPEAT_MODE_OFF + } + } +} + +enum class RepeatMode { + OFF, ONE, ALL; + + companion object { + fun fromOrdinal(ordinal: Int): RepeatMode { + return when (ordinal) { + 0 -> OFF + 1 -> ONE + 2 -> ALL + else -> error("Wrong ordinal") + } + } + } +} diff --git a/vendor/kotlinaudio/kotlin-audio/src/main/java/com/doublesymmetry/kotlinaudio/models/WakeMode.kt b/vendor/kotlinaudio/kotlin-audio/src/main/java/com/doublesymmetry/kotlinaudio/models/WakeMode.kt new file mode 100644 index 0000000..dd42361 --- /dev/null +++ b/vendor/kotlinaudio/kotlin-audio/src/main/java/com/doublesymmetry/kotlinaudio/models/WakeMode.kt @@ -0,0 +1,7 @@ +package com.doublesymmetry.kotlinaudio.models + +enum class WakeMode { + NONE, + LOCAL, + NETWORK, +} diff --git a/vendor/kotlinaudio/kotlin-audio/src/main/java/com/doublesymmetry/kotlinaudio/notification/NotificationManager.kt b/vendor/kotlinaudio/kotlin-audio/src/main/java/com/doublesymmetry/kotlinaudio/notification/NotificationManager.kt new file mode 100644 index 0000000..d8a8367 --- /dev/null +++ b/vendor/kotlinaudio/kotlin-audio/src/main/java/com/doublesymmetry/kotlinaudio/notification/NotificationManager.kt @@ -0,0 +1,811 @@ +package com.doublesymmetry.kotlinaudio.notification + +import android.app.Notification +import android.app.PendingIntent +import android.content.Context +import android.content.Intent +import android.graphics.Bitmap +import android.graphics.BitmapFactory +import android.graphics.Color +import android.graphics.drawable.BitmapDrawable +import android.os.Build +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.support.v4.media.session.PlaybackStateCompat +import androidx.annotation.DrawableRes +import androidx.core.app.NotificationCompat +import coil.imageLoader +import coil.request.Disposable +import coil.request.ImageRequest +import com.doublesymmetry.kotlinaudio.R +import com.doublesymmetry.kotlinaudio.event.NotificationEventHolder +import com.doublesymmetry.kotlinaudio.event.PlayerEventHolder +import com.doublesymmetry.kotlinaudio.models.AudioItem +import com.doublesymmetry.kotlinaudio.models.MediaSessionCallback +import com.doublesymmetry.kotlinaudio.models.NotificationButton +import com.doublesymmetry.kotlinaudio.models.NotificationConfig +import com.doublesymmetry.kotlinaudio.models.NotificationState +import com.doublesymmetry.kotlinaudio.players.components.getAudioItemHolder +import com.google.android.exoplayer2.C +import com.google.android.exoplayer2.Player +import com.google.android.exoplayer2.ext.mediasession.MediaSessionConnector +import com.google.android.exoplayer2.ext.mediasession.TimelineQueueNavigator +import com.google.android.exoplayer2.ui.PlayerNotificationManager +import com.google.android.exoplayer2.ui.PlayerNotificationManager.CustomActionReceiver +import kotlinx.coroutines.MainScope +import kotlinx.coroutines.delay +import kotlinx.coroutines.launch +import okhttp3.Headers +import okhttp3.Headers.Companion.toHeaders + +class NotificationManager internal constructor( + private val context: Context, + private val player: Player, + private val mediaSession: MediaSessionCompat, + private val mediaSessionConnector: MediaSessionConnector, + val event: NotificationEventHolder, + val playerEventHolder: PlayerEventHolder +) : PlayerNotificationManager.NotificationListener { + private var pendingIntent: PendingIntent? = null + private val descriptionAdapter = object : PlayerNotificationManager.MediaDescriptionAdapter { + override fun getCurrentContentTitle(player: Player): CharSequence { + return getTitle() ?: "" + } + + override fun createCurrentContentIntent(player: Player): PendingIntent? { + return pendingIntent + } + + override fun getCurrentContentText(player: Player): CharSequence? { + return getArtist() ?: "" + } + + override fun getCurrentSubText(player: Player): CharSequence? { + return player.mediaMetadata.displayTitle + } + + override fun getCurrentLargeIcon( + player: Player, + callback: PlayerNotificationManager.BitmapCallback, + ): Bitmap? { + val bitmap = getCachedArtworkBitmap() + if (bitmap != null) { + return bitmap + } + val artwork = getMediaItemArtworkUrl() + val headers = getNetworkHeaders() + val holder = player.currentMediaItem?.getAudioItemHolder() + if (artwork != null && holder?.artworkBitmap == null) { + context.imageLoader.enqueue( + ImageRequest.Builder(context) + .data(artwork) + .headers(headers) + .target { result -> + val resultBitmap = (result as BitmapDrawable).bitmap + holder?.artworkBitmap = resultBitmap + invalidate() + } + .build() + ) + } + return iconPlaceholder + } + } + + private var internalNotificationManager: PlayerNotificationManager? = null + private val scope = MainScope() + private val buttons = mutableSetOf() + private var invalidateThrottleCount = 0 + private var iconPlaceholder = Bitmap.createBitmap(64, 64, Bitmap.Config.ARGB_8888) + + private var notificationMetadataBitmap: Bitmap? = null + private var notificationMetadataArtworkDisposable: Disposable? = null + + /** + * The item that should be used for the notification + * This is used when the user manually sets the notification item + * + * _Note: If [BaseAudioPlayer.automaticallyUpdateNotificationMetadata] is true, this will + * get override on a track change_ + */ + internal var overrideAudioItem: AudioItem? = null + set(value) { + notificationMetadataBitmap = null + val headers = getNetworkHeaders() + + if (field != value) { + if (value?.artwork != null) { + notificationMetadataArtworkDisposable?.dispose() + notificationMetadataArtworkDisposable = context.imageLoader.enqueue( + ImageRequest.Builder(context) + .data(value.artwork) + .headers(headers) + .target { result -> + notificationMetadataBitmap = (result as BitmapDrawable).bitmap + invalidate() + } + .build() + ) + } + } + + field = value + invalidate() + } + + private fun getTitle(index: Int? = null): String? { + val mediaItem = if (index == null) player.currentMediaItem else player.getMediaItemAt(index) + + val audioItem = mediaItem?.getAudioItemHolder()?.audioItem + return overrideAudioItem?.title + ?:mediaItem?.mediaMetadata?.title?.toString() + ?: audioItem?.title + } + + private fun getArtist(index: Int? = null): String? { + val mediaItem = if (index == null) player.currentMediaItem else player.getMediaItemAt(index) + val audioItem = mediaItem?.getAudioItemHolder()?.audioItem + + return overrideAudioItem?.artist + ?: mediaItem?.mediaMetadata?.artist?.toString() + ?: mediaItem?.mediaMetadata?.albumArtist?.toString() + ?: audioItem?.artist + } + + private fun getGenre(index: Int? = null): String? { + val mediaItem = if (index == null) player.currentMediaItem else player.getMediaItemAt(index) + return mediaItem?.mediaMetadata?.genre?.toString() + } + + private fun getAlbumTitle(index: Int? = null): String? { + val mediaItem = if (index == null) player.currentMediaItem else player.getMediaItemAt(index) + return mediaItem?.mediaMetadata?.albumTitle?.toString() + ?: mediaItem?.getAudioItemHolder()?.audioItem?.albumTitle + } + + private fun getArtworkUrl(index: Int? = null): String? { + return getMediaItemArtworkUrl(index) + } + + private fun getMediaItemArtworkUrl(index: Int? = null): String? { + val mediaItem = if (index == null) player.currentMediaItem else player.getMediaItemAt(index) + + return overrideAudioItem?.artwork + ?: mediaItem?.mediaMetadata?.artworkUri?.toString() + ?: mediaItem?.getAudioItemHolder()?.audioItem?.artwork + } + + private fun getNetworkHeaders(): Headers { + return player.currentMediaItem?.getAudioItemHolder()?.audioItem?.options?.headers?.toHeaders() ?: Headers.Builder().build() + } + + /** + * Returns the cached artwork bitmap for the current media item. + * Bitmap might be cached if the media item has extracted one from the media file + * or if a user is setting custom data for the notification. + */ + private fun getCachedArtworkBitmap(index: Int? = null): Bitmap? { + val mediaItem = if (index == null) player.currentMediaItem else player.getMediaItemAt(index) + val isCurrent = index == null || index == player.currentMediaItemIndex + val artworkData = player.mediaMetadata.artworkData + + return if (isCurrent && overrideAudioItem != null) { + notificationMetadataBitmap + } else if (isCurrent && artworkData != null) { + BitmapFactory.decodeByteArray(artworkData, 0, artworkData.size) + } else { + mediaItem?.getAudioItemHolder()?.artworkBitmap + } + } + + private fun getDuration(index: Int? = null): Long? { + val mediaItem = if (index == null) player.currentMediaItem + else player.getMediaItemAt(index) + + return if (player.isCurrentMediaItemDynamic || player.duration == C.TIME_UNSET) { + overrideAudioItem?.duration ?: mediaItem?.getAudioItemHolder()?.audioItem?.duration ?: -1 + } else { + overrideAudioItem?.duration ?: player.duration + } + } + + private fun getUserRating(index: Int? = null): RatingCompat? { + val mediaItem = if (index == null) player.currentMediaItem + else player.getMediaItemAt(index) + return RatingCompat.fromRating(mediaItem?.mediaMetadata?.userRating) + } + + var showPlayPauseButton = false + set(value) { + scope.launch { + field = value + internalNotificationManager?.setUsePlayPauseActions(value) + } + } + + var showStopButton = false + set(value) { + scope.launch { + field = value + internalNotificationManager?.setUseStopAction(value) + } + } + + var showForwardButton = false + set(value) { + scope.launch { + field = value + internalNotificationManager?.setUseFastForwardAction(value) + } + } + + /** + * Controls whether or not this button should appear when the notification is compact (collapsed). + */ + var showForwardButtonCompact = false + set(value) { + scope.launch { + field = value + internalNotificationManager?.setUseFastForwardActionInCompactView(value) + } + } + + var showRewindButton = false + set(value) { + scope.launch { + field = value + internalNotificationManager?.setUseRewindAction(value) + } + } + + /** + * Controls whether or not this button should appear when the notification is compact (collapsed). + */ + var showRewindButtonCompact = false + set(value) { + scope.launch { + field = value + internalNotificationManager?.setUseRewindActionInCompactView(value) + } + } + + var showNextButton = false + set(value) { + scope.launch { + field = value + internalNotificationManager?.setUseNextAction(value) + } + } + + /** + * Controls whether or not this button should appear when the notification is compact (collapsed). + */ + var showNextButtonCompact = false + set(value) { + scope.launch { + field = value + internalNotificationManager?.setUseNextActionInCompactView(value) + } + } + + var showPreviousButton = false + set(value) { + scope.launch { + field = value + internalNotificationManager?.setUsePreviousAction(value) + } + } + + /** + * Controls whether or not this button should appear when the notification is compact (collapsed). + */ + var showPreviousButtonCompact = false + set(value) { + scope.launch { + field = value + internalNotificationManager?.setUsePreviousActionInCompactView(value) + } + } + + var stopIcon: Int? = null + var forwardIcon: Int? = null + var rewindIcon: Int? = null + + init { + mediaSessionConnector.setQueueNavigator( + object : TimelineQueueNavigator(mediaSession) { + override fun getSupportedQueueNavigatorActions(player: Player): Long { + return buttons.fold(0) { acc, button -> + acc or when (button) { + is NotificationButton.NEXT -> { + PlaybackStateCompat.ACTION_SKIP_TO_NEXT + } + is NotificationButton.PREVIOUS -> { + PlaybackStateCompat.ACTION_SKIP_TO_PREVIOUS + } + else -> { + 0 + } + } + } + } + + override fun getMediaDescription( + player: Player, + windowIndex: Int + ): MediaDescriptionCompat { + val title = getTitle(windowIndex) + val artist = getArtist(windowIndex) + return MediaDescriptionCompat.Builder().apply { + setTitle(title) + setSubtitle(artist) + setExtras(Bundle().apply { + title?.let { + putString(MediaMetadataCompat.METADATA_KEY_TITLE, it) + } + artist?.let { + putString(MediaMetadataCompat.METADATA_KEY_ARTIST, it) + } + }) + }.build() + } + } + ) + mediaSessionConnector.setMetadataDeduplicationEnabled(true) + } + + /** + * Overrides the notification metadata with the given [AudioItem]. + * + * _Note: If [BaseAudioPlayer.automaticallyUpdateNotificationMetadata] is true, this will + * get override on a track change._ + */ + public fun overrideMetadata(item: AudioItem) { + overrideAudioItem = item + } + + public fun getMediaMetadataCompat(): MediaMetadataCompat { + val currentItemMetadata = player.currentMediaItem?.mediaMetadata + + return MediaMetadataCompat.Builder().apply { + getArtist()?.let { + putString(MediaMetadataCompat.METADATA_KEY_ARTIST, it) + } + getTitle()?.let { + putString(MediaMetadataCompat.METADATA_KEY_TITLE, it) + putString(MediaMetadataCompat.METADATA_KEY_DISPLAY_TITLE, it) + } + currentItemMetadata?.subtitle?.let { + putString( + MediaMetadataCompat.METADATA_KEY_DISPLAY_SUBTITLE, it.toString() + ) + } + currentItemMetadata?.description?.let { + putString( + MediaMetadataCompat.METADATA_KEY_DISPLAY_DESCRIPTION, it.toString() + ) + } + getAlbumTitle()?.let { + putString(MediaMetadataCompat.METADATA_KEY_ALBUM, it) + } + getGenre()?.let { + putString(MediaMetadataCompat.METADATA_KEY_GENRE, it) + } + getDuration()?.let { + putLong(MediaMetadataCompat.METADATA_KEY_DURATION, it) + } + getArtworkUrl()?.let { + putString(MediaMetadataCompat.METADATA_KEY_ART_URI, it) + } + getCachedArtworkBitmap()?.let { + putBitmap(MediaMetadataCompat.METADATA_KEY_ALBUM_ART, it); + putBitmap(MediaMetadataCompat.METADATA_KEY_DISPLAY_ICON, it); + } + getUserRating()?.let { + putRating(MediaMetadataCompat.METADATA_KEY_RATING, it) + } + }.build() + } + + private fun createNotificationAction( + drawable: Int, + action: String, + instanceId: Int + ): NotificationCompat.Action { + val intent: Intent = Intent(action).setPackage(context.packageName) + val pendingIntent = PendingIntent.getBroadcast( + context, + instanceId, + intent, + if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) { + PendingIntent.FLAG_IMMUTABLE or PendingIntent.FLAG_CANCEL_CURRENT + } else { + PendingIntent.FLAG_CANCEL_CURRENT + } + ) + return NotificationCompat.Action.Builder(drawable, action, pendingIntent).build() + } + + private fun handlePlayerAction(action: String) { + when (action) { + REWIND -> { + playerEventHolder.updateOnPlayerActionTriggeredExternally(MediaSessionCallback.REWIND) + } + FORWARD -> { + playerEventHolder.updateOnPlayerActionTriggeredExternally(MediaSessionCallback.FORWARD) + } + STOP -> { + playerEventHolder.updateOnPlayerActionTriggeredExternally(MediaSessionCallback.STOP) + } + + } + } + + private val customActionReceiver = object : CustomActionReceiver { + override fun createCustomActions( + context: Context, + instanceId: Int + ): MutableMap { + if (!needsCustomActionsToAddMissingButtons) return mutableMapOf() + return mutableMapOf( + REWIND to createNotificationAction( + rewindIcon ?: DEFAULT_REWIND_ICON, + REWIND, + instanceId + ), + FORWARD to createNotificationAction( + forwardIcon ?: DEFAULT_FORWARD_ICON, + FORWARD, + instanceId + ), + STOP to createNotificationAction( + stopIcon ?: DEFAULT_STOP_ICON, + STOP, + instanceId + ) + ) + } + + override fun getCustomActions(player: Player): List { + if (!needsCustomActionsToAddMissingButtons) return emptyList() + return buttons.mapNotNull { + when (it) { + is NotificationButton.BACKWARD -> { + REWIND + } + is NotificationButton.FORWARD -> { + FORWARD + } + is NotificationButton.STOP -> { + STOP + } + else -> { + null + } + } + } + } + + override fun onCustomAction(player: Player, action: String, intent: Intent) { + handlePlayerAction(action) + } + } + + fun invalidate() { + if (invalidateThrottleCount++ == 0) { + scope.launch { + internalNotificationManager?.invalidate() + mediaSessionConnector.invalidateMediaSessionQueue() + mediaSessionConnector.invalidateMediaSessionMetadata() + delay(300) + val wasThrottled = invalidateThrottleCount > 1 + invalidateThrottleCount = 0 + if (wasThrottled) { + invalidate() + } + } + } + } + + /** + * Create a media player notification that automatically updates. Call this + * method again with a different configuration to update the notification. + */ + fun createNotification(config: NotificationConfig) = scope.launch { + if (isNotificationButtonsChanged(config.buttons)) { + hideNotification() + } + + buttons.apply { + clear() + addAll(config.buttons) + } + + stopIcon = null + forwardIcon = null + rewindIcon = null + + updateMediaSessionPlaybackActions() + + pendingIntent = config.pendingIntent + showPlayPauseButton = false + showForwardButton = false + showRewindButton = false + showNextButton = false + showPreviousButton = false + showStopButton = false + if (internalNotificationManager == null) { + internalNotificationManager = + PlayerNotificationManager.Builder(context, NOTIFICATION_ID, CHANNEL_ID) + .apply { + setChannelNameResourceId(R.string.playback_channel_name) + setMediaDescriptionAdapter(descriptionAdapter) + setCustomActionReceiver(customActionReceiver) + setNotificationListener(this@NotificationManager) + + for (button in buttons) { + if (button == null) continue + when (button) { + is NotificationButton.PLAY_PAUSE -> { + button.playIcon?.let { setPlayActionIconResourceId(it) } + button.pauseIcon?.let { setPauseActionIconResourceId(it) } + } + + is NotificationButton.STOP -> button.icon?.let { + setStopActionIconResourceId( + it + ) + } + + is NotificationButton.FORWARD -> button.icon?.let { + setFastForwardActionIconResourceId( + it + ) + } + + is NotificationButton.BACKWARD -> button.icon?.let { + setRewindActionIconResourceId( + it + ) + } + + is NotificationButton.NEXT -> button.icon?.let { + setNextActionIconResourceId( + it + ) + } + + is NotificationButton.PREVIOUS -> button.icon?.let { + setPreviousActionIconResourceId( + it + ) + } + + else -> {} + } + } + }.build().apply { + setMediaSessionToken(mediaSession.sessionToken) + setPlayer(player) + } + } + setupInternalNotificationManager(config) + } + + private fun isNotificationButtonsChanged(newButtons: List): Boolean { + val currentNotificationButtonsMapByType = buttons.filterNotNull().associateBy { it::class } + return newButtons.any { newButton -> + when (newButton) { + is NotificationButton.PLAY_PAUSE -> { + (currentNotificationButtonsMapByType[NotificationButton.PLAY_PAUSE::class] as? NotificationButton.PLAY_PAUSE).let { currentButton -> + newButton.pauseIcon != currentButton?.pauseIcon || newButton.playIcon != currentButton?.playIcon + } + } + + is NotificationButton.STOP -> { + (currentNotificationButtonsMapByType[NotificationButton.STOP::class] as? NotificationButton.STOP).let { currentButton -> + newButton.icon != currentButton?.icon + } + } + + is NotificationButton.FORWARD -> { + (currentNotificationButtonsMapByType[NotificationButton.FORWARD::class] as? NotificationButton.FORWARD).let { currentButton -> + newButton.icon != currentButton?.icon + } + } + + is NotificationButton.BACKWARD -> { + (currentNotificationButtonsMapByType[NotificationButton.BACKWARD::class] as? NotificationButton.BACKWARD).let { currentButton -> + newButton.icon != currentButton?.icon + } + } + + is NotificationButton.NEXT -> { + (currentNotificationButtonsMapByType[NotificationButton.NEXT::class] as? NotificationButton.NEXT).let { currentButton -> + newButton.icon != currentButton?.icon + } + } + + is NotificationButton.PREVIOUS -> { + (currentNotificationButtonsMapByType[NotificationButton.PREVIOUS::class] as? NotificationButton.PREVIOUS).let { currentButton -> + newButton.icon != currentButton?.icon + } + } + + else -> false + } + } + } + + private fun updateMediaSessionPlaybackActions() { + mediaSessionConnector.setEnabledPlaybackActions( + buttons.fold( + PlaybackStateCompat.ACTION_SET_REPEAT_MODE + or PlaybackStateCompat.ACTION_SET_SHUFFLE_MODE + or PlaybackStateCompat.ACTION_SET_PLAYBACK_SPEED + ) { acc, button -> + acc or when (button) { + is NotificationButton.PLAY_PAUSE -> { + PlaybackStateCompat.ACTION_PLAY or PlaybackStateCompat.ACTION_PAUSE + } + is NotificationButton.BACKWARD -> { + rewindIcon = button.icon ?: rewindIcon + PlaybackStateCompat.ACTION_REWIND + } + is NotificationButton.FORWARD -> { + forwardIcon = button.icon ?: forwardIcon + PlaybackStateCompat.ACTION_FAST_FORWARD + } + is NotificationButton.SEEK_TO -> { + PlaybackStateCompat.ACTION_SEEK_TO + } + is NotificationButton.STOP -> { + stopIcon = button.icon ?: stopIcon + PlaybackStateCompat.ACTION_STOP + } + else -> { + 0 + } + } + } + ) + if (needsCustomActionsToAddMissingButtons) { + val customActionProviders = buttons + .sortedBy { + when (it) { + is NotificationButton.BACKWARD -> 1 + is NotificationButton.FORWARD -> 2 + is NotificationButton.STOP -> 3 + else -> 4 + } + } + .mapNotNull { + when (it) { + is NotificationButton.BACKWARD -> { + createMediaSessionAction(rewindIcon ?: DEFAULT_REWIND_ICON, REWIND) + } + is NotificationButton.FORWARD -> { + createMediaSessionAction(forwardIcon ?: DEFAULT_FORWARD_ICON, FORWARD) + } + is NotificationButton.STOP -> { + createMediaSessionAction(stopIcon ?: DEFAULT_STOP_ICON, STOP) + } + else -> { + null + } + } + } + mediaSessionConnector.setCustomActionProviders(*customActionProviders.toTypedArray()) + } + } + + private fun setupInternalNotificationManager(config: NotificationConfig) { + internalNotificationManager?.run { + setColor(config.accentColor ?: Color.TRANSPARENT) + config.smallIcon?.let { setSmallIcon(it) } + for (button in buttons) { + if (button == null) continue + when (button) { + is NotificationButton.PLAY_PAUSE -> { + showPlayPauseButton = true + } + + is NotificationButton.STOP -> { + showStopButton = true + } + + is NotificationButton.FORWARD -> { + showForwardButton = true + showForwardButtonCompact = button.isCompact + } + + is NotificationButton.BACKWARD -> { + showRewindButton = true + showRewindButtonCompact = button.isCompact + } + + is NotificationButton.NEXT -> { + showNextButton = true + showNextButtonCompact = button.isCompact + } + + is NotificationButton.PREVIOUS -> { + showPreviousButton = true + showPreviousButtonCompact = button.isCompact + } + + else -> {} + } + } + } + } + + fun hideNotification() { + internalNotificationManager?.setPlayer(null) + internalNotificationManager = null + invalidate() + } + + override fun onNotificationPosted( + notificationId: Int, + notification: Notification, + ongoing: Boolean + ) { + scope.launch { + event.updateNotificationState( + NotificationState.POSTED( + notificationId, + notification, + ongoing + ) + ) + } + } + + override fun onNotificationCancelled(notificationId: Int, dismissedByUser: Boolean) { + scope.launch { + event.updateNotificationState(NotificationState.CANCELLED(notificationId)) + } + } + + internal fun destroy() = scope.launch { + internalNotificationManager?.setPlayer(null) + } + + private fun createMediaSessionAction( + @DrawableRes drawableRes: Int, + actionName: String + ): MediaSessionConnector.CustomActionProvider { + return object : MediaSessionConnector.CustomActionProvider { + override fun getCustomAction(player: Player): PlaybackStateCompat.CustomAction? { + return PlaybackStateCompat.CustomAction.Builder(actionName, actionName, drawableRes) + .build() + } + + override fun onCustomAction(player: Player, action: String, extras: Bundle?) { + handlePlayerAction(action) + } + } + } + + companion object { + // Due to the removal of rewind, forward, and stop buttons from the standard notification + // controls in Android 13, custom actions are implemented to support them + // https://developer.android.com/about/versions/13/behavior-changes-13#playback-controls + private val needsCustomActionsToAddMissingButtons = Build.VERSION.SDK_INT >= 33 + private const val REWIND = "rewind" + private const val FORWARD = "forward" + private const val STOP = "stop" + private const val NOTIFICATION_ID = 1 + private const val CHANNEL_ID = "kotlin_audio_player" + private val DEFAULT_STOP_ICON = + com.google.android.exoplayer2.ui.R.drawable.exo_notification_stop + private val DEFAULT_REWIND_ICON = + com.google.android.exoplayer2.ui.R.drawable.exo_notification_rewind + private val DEFAULT_FORWARD_ICON = + com.google.android.exoplayer2.ui.R.drawable.exo_notification_fastforward + } +} diff --git a/vendor/kotlinaudio/kotlin-audio/src/main/java/com/doublesymmetry/kotlinaudio/players/AudioPlayer.kt b/vendor/kotlinaudio/kotlin-audio/src/main/java/com/doublesymmetry/kotlinaudio/players/AudioPlayer.kt new file mode 100644 index 0000000..5dc6a1f --- /dev/null +++ b/vendor/kotlinaudio/kotlin-audio/src/main/java/com/doublesymmetry/kotlinaudio/players/AudioPlayer.kt @@ -0,0 +1,8 @@ +package com.doublesymmetry.kotlinaudio.players + +import android.content.Context +import com.doublesymmetry.kotlinaudio.models.BufferConfig +import com.doublesymmetry.kotlinaudio.models.CacheConfig +import com.doublesymmetry.kotlinaudio.models.PlayerConfig + +class AudioPlayer(context: Context, playerConfig: PlayerConfig = PlayerConfig(), bufferConfig: BufferConfig? = null, cacheConfig: CacheConfig? = null): BaseAudioPlayer(context, playerConfig, bufferConfig, cacheConfig) \ No newline at end of file diff --git a/vendor/kotlinaudio/kotlin-audio/src/main/java/com/doublesymmetry/kotlinaudio/players/BaseAudioPlayer.kt b/vendor/kotlinaudio/kotlin-audio/src/main/java/com/doublesymmetry/kotlinaudio/players/BaseAudioPlayer.kt new file mode 100644 index 0000000..17c550b --- /dev/null +++ b/vendor/kotlinaudio/kotlin-audio/src/main/java/com/doublesymmetry/kotlinaudio/players/BaseAudioPlayer.kt @@ -0,0 +1,764 @@ +package com.doublesymmetry.kotlinaudio.players + +import android.content.Context +import android.media.AudioManager +import android.media.AudioManager.AUDIOFOCUS_LOSS +import android.net.Uri +import android.os.Bundle +import android.os.ResultReceiver +import android.support.v4.media.RatingCompat +import android.support.v4.media.session.MediaSessionCompat +import androidx.annotation.CallSuper +import androidx.core.content.ContextCompat +import androidx.media.AudioAttributesCompat +import androidx.media.AudioAttributesCompat.CONTENT_TYPE_MUSIC +import androidx.media.AudioAttributesCompat.USAGE_MEDIA +import androidx.media.AudioFocusRequestCompat +import androidx.media.AudioManagerCompat +import androidx.media.AudioManagerCompat.AUDIOFOCUS_GAIN +import com.doublesymmetry.kotlinaudio.event.EventHolder +import com.doublesymmetry.kotlinaudio.event.NotificationEventHolder +import com.doublesymmetry.kotlinaudio.event.PlayerEventHolder +import com.doublesymmetry.kotlinaudio.models.AudioContentType +import com.doublesymmetry.kotlinaudio.models.AudioItem +import com.doublesymmetry.kotlinaudio.models.AudioItemHolder +import com.doublesymmetry.kotlinaudio.models.AudioItemTransitionReason +import com.doublesymmetry.kotlinaudio.models.AudioPlayerState +import com.doublesymmetry.kotlinaudio.models.BufferConfig +import com.doublesymmetry.kotlinaudio.models.CacheConfig +import com.doublesymmetry.kotlinaudio.models.DefaultPlayerOptions +import com.doublesymmetry.kotlinaudio.models.MediaSessionCallback +import com.doublesymmetry.kotlinaudio.models.MediaType +import com.doublesymmetry.kotlinaudio.models.PlayWhenReadyChangeData +import com.doublesymmetry.kotlinaudio.models.PlaybackError +import com.doublesymmetry.kotlinaudio.models.PlayerConfig +import com.doublesymmetry.kotlinaudio.models.PlayerOptions +import com.doublesymmetry.kotlinaudio.models.PositionChangedReason +import com.doublesymmetry.kotlinaudio.models.WakeMode +import com.doublesymmetry.kotlinaudio.notification.NotificationManager +import com.doublesymmetry.kotlinaudio.players.components.PlayerCache +import com.doublesymmetry.kotlinaudio.players.components.getAudioItemHolder +import com.doublesymmetry.kotlinaudio.utils.isUriLocalFile +import com.google.android.exoplayer2.C +import com.google.android.exoplayer2.DefaultLoadControl +import com.google.android.exoplayer2.DefaultLoadControl.Builder +import com.google.android.exoplayer2.DefaultLoadControl.DEFAULT_BACK_BUFFER_DURATION_MS +import com.google.android.exoplayer2.DefaultLoadControl.DEFAULT_BUFFER_FOR_PLAYBACK_AFTER_REBUFFER_MS +import com.google.android.exoplayer2.DefaultLoadControl.DEFAULT_BUFFER_FOR_PLAYBACK_MS +import com.google.android.exoplayer2.DefaultLoadControl.DEFAULT_MAX_BUFFER_MS +import com.google.android.exoplayer2.DefaultLoadControl.DEFAULT_MIN_BUFFER_MS +import com.google.android.exoplayer2.ExoPlayer +import com.google.android.exoplayer2.ForwardingPlayer +import com.google.android.exoplayer2.MediaItem +import com.google.android.exoplayer2.MediaMetadata +import com.google.android.exoplayer2.PlaybackException +import com.google.android.exoplayer2.Player +import com.google.android.exoplayer2.Player.Listener +import com.google.android.exoplayer2.audio.AudioAttributes +import com.google.android.exoplayer2.ext.mediasession.MediaSessionConnector +import com.google.android.exoplayer2.extractor.DefaultExtractorsFactory +import com.google.android.exoplayer2.metadata.Metadata +import com.google.android.exoplayer2.source.MediaSource +import com.google.android.exoplayer2.source.ProgressiveMediaSource +import com.google.android.exoplayer2.source.dash.DashMediaSource +import com.google.android.exoplayer2.source.dash.DefaultDashChunkSource +import com.google.android.exoplayer2.source.hls.HlsMediaSource +import com.google.android.exoplayer2.source.smoothstreaming.DefaultSsChunkSource +import com.google.android.exoplayer2.source.smoothstreaming.SsMediaSource +import com.google.android.exoplayer2.upstream.DataSource +import com.google.android.exoplayer2.upstream.DataSpec +import com.google.android.exoplayer2.upstream.DefaultDataSourceFactory +import com.google.android.exoplayer2.upstream.DefaultHttpDataSource +import com.google.android.exoplayer2.upstream.RawResourceDataSource +import com.google.android.exoplayer2.upstream.cache.CacheDataSource +import com.google.android.exoplayer2.upstream.cache.SimpleCache +import com.google.android.exoplayer2.util.Util +import kotlinx.coroutines.MainScope +import kotlinx.coroutines.launch +import timber.log.Timber +import java.util.Locale +import java.util.concurrent.TimeUnit + +abstract class BaseAudioPlayer internal constructor( + internal val context: Context, + playerConfig: PlayerConfig, + private val bufferConfig: BufferConfig?, + private val cacheConfig: CacheConfig? +) : AudioManager.OnAudioFocusChangeListener { + protected val exoPlayer: ExoPlayer + + private var cache: SimpleCache? = null + private val scope = MainScope() + private var playerConfig: PlayerConfig = playerConfig + + val notificationManager: NotificationManager + + open val playerOptions: PlayerOptions = DefaultPlayerOptions() + + open val currentItem: AudioItem? + get() = exoPlayer.currentMediaItem?.getAudioItemHolder()?.audioItem + + var playbackError: PlaybackError? = null + var playerState: AudioPlayerState = AudioPlayerState.IDLE + private set(value) { + if (value != field) { + field = value + playerEventHolder.updateAudioPlayerState(value) + if (!playerConfig.handleAudioFocus) { + when (value) { + AudioPlayerState.IDLE, + AudioPlayerState.ERROR -> abandonAudioFocusIfHeld() + AudioPlayerState.READY -> requestAudioFocus() + else -> {} + } + } + } + } + + var playWhenReady: Boolean + get() = exoPlayer.playWhenReady + set(value) { + exoPlayer.playWhenReady = value + } + + val duration: Long + get() { + return if (exoPlayer.duration == C.TIME_UNSET) 0 + else exoPlayer.duration + } + + val isCurrentMediaItemLive: Boolean + get() = exoPlayer.isCurrentMediaItemLive + + private var oldPosition = 0L + + val position: Long + get() { + return if (exoPlayer.currentPosition == C.POSITION_UNSET.toLong()) 0 + else exoPlayer.currentPosition + } + + val bufferedPosition: Long + get() { + return if (exoPlayer.bufferedPosition == C.POSITION_UNSET.toLong()) 0 + else exoPlayer.bufferedPosition + } + + var volume: Float + get() = exoPlayer.volume + set(value) { + exoPlayer.volume = value * volumeMultiplier + } + + var playbackSpeed: Float + get() = exoPlayer.playbackParameters.speed + set(value) { + exoPlayer.setPlaybackSpeed(value) + } + + var automaticallyUpdateNotificationMetadata: Boolean = true + + private var volumeMultiplier = 1f + private set(value) { + field = value + volume = volume + } + + val isPlaying + get() = exoPlayer.isPlaying + + private val notificationEventHolder = NotificationEventHolder() + private val playerEventHolder = PlayerEventHolder() + + var ratingType: Int = RatingCompat.RATING_NONE + set(value) { + field = value + + mediaSession.setRatingType(ratingType) + mediaSessionConnector.setRatingCallback(object : MediaSessionConnector.RatingCallback { + override fun onCommand( + player: Player, + command: String, + extras: Bundle?, + cb: ResultReceiver? + ): Boolean { + return true + } + + override fun onSetRating(player: Player, rating: RatingCompat) { + playerEventHolder.updateOnPlayerActionTriggeredExternally( + MediaSessionCallback.RATING( + rating, + null + ) + ) + } + + override fun onSetRating(player: Player, rating: RatingCompat, extras: Bundle?) { + playerEventHolder.updateOnPlayerActionTriggeredExternally( + MediaSessionCallback.RATING( + rating, + extras + ) + ) + } + }) + } + + val event = EventHolder(notificationEventHolder, playerEventHolder) + + private var focus: AudioFocusRequestCompat? = null + private var hasAudioFocus = false + private var wasDucking = false + + private val mediaSession = MediaSessionCompat(context, "KotlinAudioPlayer") + private val mediaSessionConnector = MediaSessionConnector(mediaSession) + + init { + if (cacheConfig != null) { + cache = PlayerCache.getInstance(context, cacheConfig) + } + + exoPlayer = ExoPlayer.Builder(context) + // ASTRA M3: insert the pre-EQ PCM tap into the audio sink's processor + // chain. This is the ONLY change vs upstream kotlin-audio v2.1.0. + .setRenderersFactory( + com.doublesymmetry.kotlinaudio.scope.buildScopeRenderersFactory(context) + ) + .setHandleAudioBecomingNoisy(playerConfig.handleAudioBecomingNoisy) + .setWakeMode( + when (playerConfig.wakeMode) { + WakeMode.NONE -> C.WAKE_MODE_NONE + WakeMode.LOCAL -> C.WAKE_MODE_LOCAL + WakeMode.NETWORK -> C.WAKE_MODE_NETWORK + } + ) + .apply { + if (bufferConfig != null) setLoadControl(setupBuffer(bufferConfig)) + } + .build() + + mediaSession.isActive = true + + val playerToUse = + if (playerConfig.interceptPlayerActionsTriggeredExternally) createForwardingPlayer() else exoPlayer + + notificationManager = NotificationManager( + context, + playerToUse, + mediaSession, + mediaSessionConnector, + notificationEventHolder, + playerEventHolder + ) + + exoPlayer.addListener(PlayerListener()) + + scope.launch { + // Whether ExoPlayer should manage audio focus for us automatically + // see https://medium.com/google-exoplayer/easy-audio-focus-with-exoplayer-a2dcbbe4640e + val audioAttributes = AudioAttributes.Builder() + .setUsage(C.USAGE_MEDIA) + .setContentType( + when (playerConfig.audioContentType) { + AudioContentType.MUSIC -> C.AUDIO_CONTENT_TYPE_MUSIC + AudioContentType.SPEECH -> C.AUDIO_CONTENT_TYPE_SPEECH + AudioContentType.SONIFICATION -> C.AUDIO_CONTENT_TYPE_SONIFICATION + AudioContentType.MOVIE -> C.AUDIO_CONTENT_TYPE_MOVIE + AudioContentType.UNKNOWN -> C.AUDIO_CONTENT_TYPE_UNKNOWN + } + ) + .build(); + exoPlayer.setAudioAttributes(audioAttributes, playerConfig.handleAudioFocus); + mediaSessionConnector.setPlayer(playerToUse) + mediaSessionConnector.setMediaMetadataProvider { + notificationManager.getMediaMetadataCompat() + } + } + + playerEventHolder.updateAudioPlayerState(AudioPlayerState.IDLE) + } + + private fun createForwardingPlayer(): ForwardingPlayer { + return object : ForwardingPlayer(exoPlayer) { + override fun play() { + playerEventHolder.updateOnPlayerActionTriggeredExternally(MediaSessionCallback.PLAY) + } + + override fun pause() { + playerEventHolder.updateOnPlayerActionTriggeredExternally(MediaSessionCallback.PAUSE) + } + + override fun seekToNext() { + playerEventHolder.updateOnPlayerActionTriggeredExternally(MediaSessionCallback.NEXT) + } + + override fun seekToPrevious() { + playerEventHolder.updateOnPlayerActionTriggeredExternally(MediaSessionCallback.PREVIOUS) + } + + override fun seekForward() { + playerEventHolder.updateOnPlayerActionTriggeredExternally(MediaSessionCallback.FORWARD) + } + + override fun seekBack() { + playerEventHolder.updateOnPlayerActionTriggeredExternally(MediaSessionCallback.REWIND) + } + + override fun stop() { + playerEventHolder.updateOnPlayerActionTriggeredExternally(MediaSessionCallback.STOP) + } + + override fun seekTo(mediaItemIndex: Int, positionMs: Long) { + playerEventHolder.updateOnPlayerActionTriggeredExternally( + MediaSessionCallback.SEEK( + positionMs + ) + ) + } + + override fun seekTo(positionMs: Long) { + playerEventHolder.updateOnPlayerActionTriggeredExternally( + MediaSessionCallback.SEEK( + positionMs + ) + ) + } + } + } + + internal fun updateNotificationIfNecessary(overrideAudioItem: AudioItem? = null) { + if (automaticallyUpdateNotificationMetadata) { + notificationManager.overrideAudioItem = overrideAudioItem + } + } + + private fun setupBuffer(bufferConfig: BufferConfig): DefaultLoadControl { + bufferConfig.apply { + val multiplier = + DEFAULT_BUFFER_FOR_PLAYBACK_AFTER_REBUFFER_MS / DEFAULT_BUFFER_FOR_PLAYBACK_MS + val minBuffer = + if (minBuffer != null && minBuffer != 0) minBuffer else DEFAULT_MIN_BUFFER_MS + val maxBuffer = + if (maxBuffer != null && maxBuffer != 0) maxBuffer else DEFAULT_MAX_BUFFER_MS + val playBuffer = + if (playBuffer != null && playBuffer != 0) playBuffer else DEFAULT_BUFFER_FOR_PLAYBACK_MS + val backBuffer = + if (backBuffer != null && backBuffer != 0) backBuffer else DEFAULT_BACK_BUFFER_DURATION_MS + + return Builder() + .setBufferDurationsMs(minBuffer, maxBuffer, playBuffer, playBuffer * multiplier) + .setBackBuffer(backBuffer, false) + .build() + } + } + + /** + * Will replace the current item with a new one and load it into the player. + * @param item The [AudioItem] to replace the current one. + * @param playWhenReady Whether playback starts automatically. + */ + open fun load(item: AudioItem, playWhenReady: Boolean = true) { + exoPlayer.playWhenReady = playWhenReady + load(item) + } + + /** + * Will replace the current item with a new one and load it into the player. + * @param item The [AudioItem] to replace the current one. + */ + open fun load(item: AudioItem) { + val mediaSource = getMediaSourceFromAudioItem(item) + exoPlayer.addMediaSource(mediaSource) + exoPlayer.prepare() + } + + fun togglePlaying() { + if (exoPlayer.isPlaying) { + pause() + } else { + play() + } + } + + var skipSilence: Boolean + get() = exoPlayer.skipSilenceEnabled + set(value) { + exoPlayer.skipSilenceEnabled = value; + } + + fun play() { + exoPlayer.play() + if (currentItem != null) { + exoPlayer.prepare() + } + } + + fun prepare() { + if (currentItem != null) { + exoPlayer.prepare() + } + } + + fun pause() { + exoPlayer.pause() + } + + /** + * Stops playback, without clearing the active item. Calling this method will cause the playback + * state to transition to AudioPlayerState.IDLE and the player will release the loaded media and + * resources required for playback. + */ + @CallSuper + open fun stop() { + playerState = AudioPlayerState.STOPPED + exoPlayer.playWhenReady = false + exoPlayer.stop() + } + + @CallSuper + open fun clear() { + exoPlayer.clearMediaItems() + } + + /** + * Pause playback whenever an item plays to its end. + */ + fun setPauseAtEndOfItem(pause: Boolean) { + exoPlayer.pauseAtEndOfMediaItems = pause + } + + /** + * Stops and destroys the player. Only call this when you are finished using the player, otherwise use [pause]. + */ + @CallSuper + open fun destroy() { + abandonAudioFocusIfHeld() + stop() + notificationManager.destroy() + exoPlayer.release() + cache?.release() + cache = null + mediaSession.isActive = false + } + + open fun seek(duration: Long, unit: TimeUnit) { + val positionMs = TimeUnit.MILLISECONDS.convert(duration, unit) + exoPlayer.seekTo(positionMs) + } + + open fun seekBy(offset: Long, unit: TimeUnit) { + val positionMs = exoPlayer.currentPosition + TimeUnit.MILLISECONDS.convert(offset, unit) + exoPlayer.seekTo(positionMs) + } + + protected fun getMediaSourceFromAudioItem(audioItem: AudioItem): MediaSource { + val uri = Uri.parse(audioItem.audioUrl) + val mediaItem = MediaItem.Builder() + .setUri(audioItem.audioUrl) + .setTag(AudioItemHolder(audioItem)) + .build() + + val userAgent = + if (audioItem.options == null || audioItem.options!!.userAgent.isNullOrBlank()) { + Util.getUserAgent(context, APPLICATION_NAME) + } else { + audioItem.options!!.userAgent + } + + val factory: DataSource.Factory = when { + audioItem.options?.resourceId != null -> { + val raw = RawResourceDataSource(context) + raw.open(DataSpec(uri)) + DataSource.Factory { raw } + } + isUriLocalFile(uri) -> { + DefaultDataSourceFactory(context, userAgent) + } + else -> { + val tempFactory = DefaultHttpDataSource.Factory().apply { + setUserAgent(userAgent) + setAllowCrossProtocolRedirects(true) + + audioItem.options?.headers?.let { + setDefaultRequestProperties(it.toMap()) + } + } + + enableCaching(tempFactory) + } + } + + return when (audioItem.type) { + MediaType.DASH -> createDashSource(mediaItem, factory) + MediaType.HLS -> createHlsSource(mediaItem, factory) + MediaType.SMOOTH_STREAMING -> createSsSource(mediaItem, factory) + else -> createProgressiveSource(mediaItem, factory) + } + } + + private fun createDashSource(mediaItem: MediaItem, factory: DataSource.Factory?): MediaSource { + return DashMediaSource.Factory(DefaultDashChunkSource.Factory(factory!!), factory) + .createMediaSource(mediaItem) + } + + private fun createHlsSource(mediaItem: MediaItem, factory: DataSource.Factory?): MediaSource { + return HlsMediaSource.Factory(factory!!) + .createMediaSource(mediaItem) + } + + private fun createSsSource(mediaItem: MediaItem, factory: DataSource.Factory?): MediaSource { + return SsMediaSource.Factory(DefaultSsChunkSource.Factory(factory!!), factory) + .createMediaSource(mediaItem) + } + + private fun createProgressiveSource( + mediaItem: MediaItem, + factory: DataSource.Factory + ): ProgressiveMediaSource { + return ProgressiveMediaSource.Factory( + factory, DefaultExtractorsFactory() + .setConstantBitrateSeekingEnabled(true) + ) + .createMediaSource(mediaItem) + } + + private fun enableCaching(factory: DataSource.Factory): DataSource.Factory { + return if (cache == null || cacheConfig == null || (cacheConfig.maxCacheSize ?: 0) <= 0) { + factory + } else { + CacheDataSource.Factory().apply { + setCache(this@BaseAudioPlayer.cache!!) + setUpstreamDataSourceFactory(factory) + setFlags(CacheDataSource.FLAG_IGNORE_CACHE_ON_ERROR) + } + } + } + + private fun requestAudioFocus() { + if (hasAudioFocus) return + Timber.d("Requesting audio focus...") + + val manager = ContextCompat.getSystemService(context, AudioManager::class.java) + + focus = AudioFocusRequestCompat.Builder(AUDIOFOCUS_GAIN) + .setOnAudioFocusChangeListener(this) + .setAudioAttributes( + AudioAttributesCompat.Builder() + .setUsage(USAGE_MEDIA) + .setContentType(CONTENT_TYPE_MUSIC) + .build() + ) + .setWillPauseWhenDucked(playerOptions.alwaysPauseOnInterruption) + .build() + + val result: Int = if (manager != null && focus != null) { + AudioManagerCompat.requestAudioFocus(manager, focus!!) + } else { + AudioManager.AUDIOFOCUS_REQUEST_FAILED + } + + hasAudioFocus = (result == AudioManager.AUDIOFOCUS_REQUEST_GRANTED) + } + + private fun abandonAudioFocusIfHeld() { + if (!hasAudioFocus) return + Timber.d("Abandoning audio focus...") + + val manager = ContextCompat.getSystemService(context, AudioManager::class.java) + + val result: Int = if (manager != null && focus != null) { + AudioManagerCompat.abandonAudioFocusRequest(manager, focus!!) + } else { + AudioManager.AUDIOFOCUS_REQUEST_FAILED + } + + hasAudioFocus = (result != AudioManager.AUDIOFOCUS_REQUEST_GRANTED) + } + + override fun onAudioFocusChange(focusChange: Int) { + Timber.d("Audio focus changed") + val isPermanent = focusChange == AUDIOFOCUS_LOSS + val isPaused = when (focusChange) { + AUDIOFOCUS_LOSS, AudioManager.AUDIOFOCUS_LOSS_TRANSIENT -> true + AudioManager.AUDIOFOCUS_LOSS_TRANSIENT_CAN_DUCK -> playerOptions.alwaysPauseOnInterruption + else -> false + } + if (!playerConfig.handleAudioFocus) { + if (isPermanent) abandonAudioFocusIfHeld() + + val isDucking = focusChange == AudioManager.AUDIOFOCUS_LOSS_TRANSIENT_CAN_DUCK + && !playerOptions.alwaysPauseOnInterruption + if (isDucking) { + volumeMultiplier = 0.5f + wasDucking = true + } else if (wasDucking) { + volumeMultiplier = 1f + wasDucking = false + } + } + + playerEventHolder.updateOnAudioFocusChanged(isPaused, isPermanent) + } + + companion object { + const val APPLICATION_NAME = "react-native-track-player" + } + + inner class PlayerListener : Listener { + /** + * Called when there is metadata associated with the current playback time. + */ + override fun onMetadata(metadata: Metadata) { + playerEventHolder.updateOnTimedMetadata(metadata) + } + + override fun onMediaMetadataChanged(mediaMetadata: MediaMetadata) { + playerEventHolder.updateOnCommonMetadata(mediaMetadata) + } + + /** + * A position discontinuity occurs when the playing period changes, the playback position + * jumps within the period currently being played, or when the playing period has been + * skipped or removed. + */ + override fun onPositionDiscontinuity( + oldPosition: Player.PositionInfo, + newPosition: Player.PositionInfo, + reason: Int + ) { + this@BaseAudioPlayer.oldPosition = oldPosition.positionMs + + when (reason) { + Player.DISCONTINUITY_REASON_AUTO_TRANSITION -> playerEventHolder.updatePositionChangedReason( + PositionChangedReason.AUTO(oldPosition.positionMs, newPosition.positionMs) + ) + Player.DISCONTINUITY_REASON_SEEK -> playerEventHolder.updatePositionChangedReason( + PositionChangedReason.SEEK(oldPosition.positionMs, newPosition.positionMs) + ) + Player.DISCONTINUITY_REASON_SEEK_ADJUSTMENT -> playerEventHolder.updatePositionChangedReason( + PositionChangedReason.SEEK_FAILED( + oldPosition.positionMs, + newPosition.positionMs + ) + ) + Player.DISCONTINUITY_REASON_REMOVE -> playerEventHolder.updatePositionChangedReason( + PositionChangedReason.QUEUE_CHANGED( + oldPosition.positionMs, + newPosition.positionMs + ) + ) + Player.DISCONTINUITY_REASON_SKIP -> playerEventHolder.updatePositionChangedReason( + PositionChangedReason.SKIPPED_PERIOD( + oldPosition.positionMs, + newPosition.positionMs + ) + ) + Player.DISCONTINUITY_REASON_INTERNAL -> playerEventHolder.updatePositionChangedReason( + PositionChangedReason.UNKNOWN(oldPosition.positionMs, newPosition.positionMs) + ) + } + } + + /** + * Called when playback transitions to a media item or starts repeating a media item + * according to the current repeat mode. Note that this callback is also called when the + * playlist becomes non-empty or empty as a consequence of a playlist change. + */ + override fun onMediaItemTransition(mediaItem: MediaItem?, reason: Int) { + when (reason) { + Player.MEDIA_ITEM_TRANSITION_REASON_AUTO -> playerEventHolder.updateAudioItemTransition( + AudioItemTransitionReason.AUTO(oldPosition) + ) + Player.MEDIA_ITEM_TRANSITION_REASON_PLAYLIST_CHANGED -> playerEventHolder.updateAudioItemTransition( + AudioItemTransitionReason.QUEUE_CHANGED(oldPosition) + ) + Player.MEDIA_ITEM_TRANSITION_REASON_REPEAT -> playerEventHolder.updateAudioItemTransition( + AudioItemTransitionReason.REPEAT(oldPosition) + ) + Player.MEDIA_ITEM_TRANSITION_REASON_SEEK -> playerEventHolder.updateAudioItemTransition( + AudioItemTransitionReason.SEEK_TO_ANOTHER_AUDIO_ITEM(oldPosition) + ) + } + + updateNotificationIfNecessary() + } + + /** + * Called when the value returned from Player.getPlayWhenReady() changes. + */ + override fun onPlayWhenReadyChanged(playWhenReady: Boolean, reason: Int) { + val pausedBecauseReachedEnd = reason == Player.PLAY_WHEN_READY_CHANGE_REASON_END_OF_MEDIA_ITEM + playerEventHolder.updatePlayWhenReadyChange(PlayWhenReadyChangeData(playWhenReady, pausedBecauseReachedEnd)) + } + + /** + * The generic onEvents callback provides access to the Player object and specifies the set + * of events that occurred together. It’s always called after the callbacks that correspond + * to the individual events. + */ + override fun onEvents(player: Player, events: Player.Events) { + // Note that it is necessary to set `playerState` in order, since each mutation fires an + // event. + for (i in 0 until events.size()) { + when (events[i]) { + Player.EVENT_PLAYBACK_STATE_CHANGED -> { + val state = when (player.playbackState) { + Player.STATE_BUFFERING -> AudioPlayerState.BUFFERING + Player.STATE_READY -> AudioPlayerState.READY + Player.STATE_IDLE -> + // Avoid transitioning to idle from error or stopped + if ( + playerState == AudioPlayerState.ERROR || + playerState == AudioPlayerState.STOPPED + ) + null + else + AudioPlayerState.IDLE + Player.STATE_ENDED -> + if (player.mediaItemCount > 0) AudioPlayerState.ENDED + else AudioPlayerState.IDLE + else -> null // noop + } + if (state != null && state != playerState) { + playerState = state + } + } + Player.EVENT_MEDIA_ITEM_TRANSITION -> { + playbackError = null + if (currentItem != null) { + playerState = AudioPlayerState.LOADING + if (isPlaying) { + playerState = AudioPlayerState.READY + playerState = AudioPlayerState.PLAYING + } + } + } + Player.EVENT_PLAY_WHEN_READY_CHANGED -> { + if (!player.playWhenReady && playerState != AudioPlayerState.STOPPED) { + playerState = AudioPlayerState.PAUSED + } + } + Player.EVENT_IS_PLAYING_CHANGED -> { + if (player.isPlaying) { + playerState = AudioPlayerState.PLAYING + } + } + } + } + } + + override fun onPlayerError(error: PlaybackException) { + val _playbackError = PlaybackError( + error.errorCodeName + .replace("ERROR_CODE_", "") + .lowercase(Locale.getDefault()) + .replace("_", "-"), + error.message + ) + playerEventHolder.updatePlaybackError(_playbackError) + playbackError = _playbackError + playerState = AudioPlayerState.ERROR + } + } +} diff --git a/vendor/kotlinaudio/kotlin-audio/src/main/java/com/doublesymmetry/kotlinaudio/players/QueuedAudioPlayer.kt b/vendor/kotlinaudio/kotlin-audio/src/main/java/com/doublesymmetry/kotlinaudio/players/QueuedAudioPlayer.kt new file mode 100644 index 0000000..78a5b62 --- /dev/null +++ b/vendor/kotlinaudio/kotlin-audio/src/main/java/com/doublesymmetry/kotlinaudio/players/QueuedAudioPlayer.kt @@ -0,0 +1,255 @@ +package com.doublesymmetry.kotlinaudio.players + +import android.content.Context +import com.doublesymmetry.kotlinaudio.models.* +import com.doublesymmetry.kotlinaudio.players.components.getAudioItemHolder +import com.google.android.exoplayer2.C +import com.google.android.exoplayer2.IllegalSeekPositionException +import com.google.android.exoplayer2.source.MediaSource +import java.util.* +import kotlin.math.max +import kotlin.math.min + +class QueuedAudioPlayer( + context: Context, + playerConfig: PlayerConfig = PlayerConfig(), + bufferConfig: BufferConfig? = null, + cacheConfig: CacheConfig? = null +) : BaseAudioPlayer(context, playerConfig, bufferConfig, cacheConfig) { + private val queue = LinkedList() + override val playerOptions = DefaultQueuedPlayerOptions(exoPlayer) + + val currentIndex + get() = exoPlayer.currentMediaItemIndex + + override val currentItem: AudioItem? + get() = queue.getOrNull(currentIndex)?.mediaItem?.getAudioItemHolder()?.audioItem + + val nextIndex: Int? + get() { + return if (exoPlayer.nextMediaItemIndex == C.INDEX_UNSET) null + else exoPlayer.nextMediaItemIndex + } + + val previousIndex: Int? + get() { + return if (exoPlayer.previousMediaItemIndex == C.INDEX_UNSET) null + else exoPlayer.previousMediaItemIndex + } + + val items: List + get() = queue.map { it.mediaItem.getAudioItemHolder().audioItem } + + val previousItems: List + get() { + return if (queue.isEmpty()) emptyList() + else queue + .subList(0, exoPlayer.currentMediaItemIndex) + .map { it.mediaItem.getAudioItemHolder().audioItem } + } + + val nextItems: List + get() { + return if (queue.isEmpty()) emptyList() + else queue + .subList(exoPlayer.currentMediaItemIndex, queue.lastIndex) + .map { it.mediaItem.getAudioItemHolder().audioItem } + } + + val nextItem: AudioItem? + get() = items.getOrNull(currentIndex + 1) + + val previousItem: AudioItem? + get() = items.getOrNull(currentIndex - 1) + + override fun load(item: AudioItem, playWhenReady: Boolean) { + load(item) + exoPlayer.playWhenReady = playWhenReady + } + + override fun load(item: AudioItem) { + if (queue.isEmpty()) { + add(item) + } else { + val mediaSource = getMediaSourceFromAudioItem(item) + queue[currentIndex] = mediaSource + exoPlayer.addMediaSource(currentIndex + 1, mediaSource) + exoPlayer.removeMediaItem(currentIndex) + exoPlayer.seekTo(currentIndex, C.TIME_UNSET); + exoPlayer.prepare() + } + } + + /** + * Add a single item to the queue. If the AudioPlayer has no item loaded, it will load the `item`. + * @param item The [AudioItem] to add. + */ + fun add(item: AudioItem, playWhenReady: Boolean) { + exoPlayer.playWhenReady = playWhenReady + add(item) + } + + /** + * Add a single item to the queue. If the AudioPlayer has no item loaded, it will load the `item`. + * @param item The [AudioItem] to add. + * @param playWhenReady Whether playback starts automatically. + */ + fun add(item: AudioItem) { + val mediaSource = getMediaSourceFromAudioItem(item) + queue.add(mediaSource) + exoPlayer.addMediaSource(mediaSource) + exoPlayer.prepare() + } + + /** + * Add multiple items to the queue. If the AudioPlayer has no item loaded, it will load the first item in the list. + * @param items The [AudioItem]s to add. + * @param playWhenReady Whether playback starts automatically. + */ + fun add(items: List, playWhenReady: Boolean) { + exoPlayer.playWhenReady = playWhenReady + add(items) + } + + /** + * Add multiple items to the queue. If the AudioPlayer has no item loaded, it will load the first item in the list. + * @param items The [AudioItem]s to add. + */ + fun add(items: List) { + val mediaSources = items.map { getMediaSourceFromAudioItem(it) } + queue.addAll(mediaSources) + exoPlayer.addMediaSources(mediaSources) + exoPlayer.prepare() + } + + + /** + * Add multiple items to the queue. + * @param items The [AudioItem]s to add. + * @param atIndex Index to insert items at, if no items loaded this will not automatically start playback. + */ + fun add(items: List, atIndex: Int) { + val mediaSources = items.map { getMediaSourceFromAudioItem(it) } + queue.addAll(atIndex, mediaSources) + exoPlayer.addMediaSources(atIndex, mediaSources) + exoPlayer.prepare() + } + + /** + * Remove an item from the queue. + * @param index The index of the item to remove. + */ + fun remove(index: Int) { + queue.removeAt(index) + exoPlayer.removeMediaItem(index) + } + + /** + * Remove items from the queue. + * @param indexes The indexes of the items to remove. + */ + fun remove(indexes: List) { + val sorted = indexes.toMutableList() + // Sort the indexes in descending order so we can safely remove them one by one + // without having the next index possibly newly pointing to another item than intended: + sorted.sortDescending() + sorted.forEach { + remove(it) + } + } + + /** + * Skip to the next item in the queue, which may depend on the current repeat mode. + * Does nothing if there is no next item to skip to. + */ + fun next() { + exoPlayer.seekToNextMediaItem() + exoPlayer.prepare() + } + + /** + * Skip to the previous item in the queue, which may depend on the current repeat mode. + * Does nothing if there is no previous item to skip to. + */ + fun previous() { + exoPlayer.seekToPreviousMediaItem() + exoPlayer.prepare() + } + + /** + * Move an item in the queue from one position to another. + * @param fromIndex The index of the item ot move. + * @param toIndex The index to move the item to. If the index is larger than the size of the queue, the item is moved to the end of the queue instead. + */ + fun move(fromIndex: Int, toIndex: Int) { + exoPlayer.moveMediaItem(fromIndex, toIndex) + val item = queue[fromIndex] + queue.removeAt(fromIndex) + queue.add(max(0, min(items.size, if (toIndex > fromIndex) toIndex else toIndex - 1)), item) + } + + /** + * Jump to an item in the queue. + * @param index the index to jump to + * @param playWhenReady Whether playback starts automatically. + */ + fun jumpToItem(index: Int, playWhenReady: Boolean) { + exoPlayer.playWhenReady = playWhenReady + jumpToItem(index) + } + + /** + * Jump to an item in the queue. + * @param index the index to jump to + */ + fun jumpToItem(index: Int) { + try { + exoPlayer.seekTo(index, C.TIME_UNSET) + exoPlayer.prepare() + } catch (e: IllegalSeekPositionException) { + throw Error("This item index $index does not exist. The size of the queue is ${queue.size} items.") + } + } + + /** + * Replaces item at index in queue. + * If updating current index, we update the notification metadata if [automaticallyUpdateNotificationMetadata] is true. + */ + fun replaceItem(index: Int, item: AudioItem) { + val mediaSource = getMediaSourceFromAudioItem(item) + queue[index] = mediaSource + if (index == currentIndex) { + updateNotificationIfNecessary(overrideAudioItem = item) + } + } + + /** + * Removes all the upcoming items, if any (the ones returned by [next]). + */ + fun removeUpcomingItems() { + if (queue.lastIndex == -1 || currentIndex == -1) return + val lastIndex = queue.lastIndex + 1 + val fromIndex = currentIndex + 1 + + exoPlayer.removeMediaItems(fromIndex, lastIndex) + queue.subList(fromIndex, lastIndex).clear() + } + + /** + * Removes all the previous items, if any (the ones returned by [previous]). + */ + fun removePreviousItems() { + exoPlayer.removeMediaItems(0, currentIndex) + queue.subList(0, currentIndex).clear() + } + + override fun destroy() { + queue.clear() + super.destroy() + } + + override fun clear() { + queue.clear() + super.clear() + } +} diff --git a/vendor/kotlinaudio/kotlin-audio/src/main/java/com/doublesymmetry/kotlinaudio/players/components/MediaItemExt.kt b/vendor/kotlinaudio/kotlin-audio/src/main/java/com/doublesymmetry/kotlinaudio/players/components/MediaItemExt.kt new file mode 100644 index 0000000..f7a8570 --- /dev/null +++ b/vendor/kotlinaudio/kotlin-audio/src/main/java/com/doublesymmetry/kotlinaudio/players/components/MediaItemExt.kt @@ -0,0 +1,8 @@ +package com.doublesymmetry.kotlinaudio.players.components + +import com.doublesymmetry.kotlinaudio.models.AudioItemHolder +import com.google.android.exoplayer2.MediaItem + +fun MediaItem.getAudioItemHolder(): AudioItemHolder { + return localConfiguration!!.tag as AudioItemHolder +} diff --git a/vendor/kotlinaudio/kotlin-audio/src/main/java/com/doublesymmetry/kotlinaudio/players/components/PlayerCache.kt b/vendor/kotlinaudio/kotlin-audio/src/main/java/com/doublesymmetry/kotlinaudio/players/components/PlayerCache.kt new file mode 100644 index 0000000..e502d26 --- /dev/null +++ b/vendor/kotlinaudio/kotlin-audio/src/main/java/com/doublesymmetry/kotlinaudio/players/components/PlayerCache.kt @@ -0,0 +1,26 @@ +package com.doublesymmetry.kotlinaudio.players.components + +import android.content.Context +import com.doublesymmetry.kotlinaudio.models.CacheConfig +import com.google.android.exoplayer2.database.DatabaseProvider +import com.google.android.exoplayer2.database.StandaloneDatabaseProvider +import com.google.android.exoplayer2.upstream.cache.LeastRecentlyUsedCacheEvictor +import com.google.android.exoplayer2.upstream.cache.SimpleCache +import java.io.File + +object PlayerCache { + @Volatile + private var instance: SimpleCache? = null + + fun getInstance(context: Context, cacheConfig: CacheConfig): SimpleCache? { + val cacheDir = File(context.cacheDir, cacheConfig.identifier) + val db: DatabaseProvider = StandaloneDatabaseProvider(context) + + instance ?: synchronized(this) { + instance ?: SimpleCache(cacheDir, LeastRecentlyUsedCacheEvictor(cacheConfig.maxCacheSize ?: 0), db) + .also { instance = it } + } + + return instance + } +} \ No newline at end of file diff --git a/vendor/kotlinaudio/kotlin-audio/src/main/java/com/doublesymmetry/kotlinaudio/scope/ScopeRenderersFactory.kt b/vendor/kotlinaudio/kotlin-audio/src/main/java/com/doublesymmetry/kotlinaudio/scope/ScopeRenderersFactory.kt new file mode 100644 index 0000000..09acee3 --- /dev/null +++ b/vendor/kotlinaudio/kotlin-audio/src/main/java/com/doublesymmetry/kotlinaudio/scope/ScopeRenderersFactory.kt @@ -0,0 +1,28 @@ +package com.doublesymmetry.kotlinaudio.scope + +import android.content.Context +import com.google.android.exoplayer2.DefaultRenderersFactory +import com.google.android.exoplayer2.audio.AudioProcessor +import com.google.android.exoplayer2.audio.AudioSink +import com.google.android.exoplayer2.audio.DefaultAudioSink + +/** + * A DefaultRenderersFactory whose audio sink runs our pre-EQ PCM tap as the + * first (and, for M3, only) AudioProcessor. Float-output / playback-param + * capabilities are preserved by forwarding the flags. M4 will prepend the EQ + * AudioProcessor (and add a second post-EQ tap) to this same chain. + */ +fun buildScopeRenderersFactory(context: Context): DefaultRenderersFactory = + object : DefaultRenderersFactory(context) { + override fun buildAudioSink( + context: Context, + enableFloatOutput: Boolean, + enableAudioTrackPlaybackParams: Boolean, + enableOffload: Boolean + ): AudioSink = + DefaultAudioSink.Builder(context) + .setEnableFloatOutput(enableFloatOutput) + .setEnableAudioTrackPlaybackParams(enableAudioTrackPlaybackParams) + .setAudioProcessors(arrayOf(ScopeTapAudioProcessor())) + .build() + } diff --git a/vendor/kotlinaudio/kotlin-audio/src/main/java/com/doublesymmetry/kotlinaudio/scope/ScopeTapAudioProcessor.kt b/vendor/kotlinaudio/kotlin-audio/src/main/java/com/doublesymmetry/kotlinaudio/scope/ScopeTapAudioProcessor.kt new file mode 100644 index 0000000..3baf16a --- /dev/null +++ b/vendor/kotlinaudio/kotlin-audio/src/main/java/com/doublesymmetry/kotlinaudio/scope/ScopeTapAudioProcessor.kt @@ -0,0 +1,76 @@ +package com.doublesymmetry.kotlinaudio.scope + +import com.google.android.exoplayer2.C +import com.google.android.exoplayer2.audio.AudioProcessor +import com.google.android.exoplayer2.audio.BaseAudioProcessor +import expo.modules.astrascope.ScopeBridge +import java.nio.ByteBuffer +import java.nio.ByteOrder + +/** + * Pass-through ExoPlayer AudioProcessor (M3 pre-EQ tap). Output == input so the + * audio path stays bit-exact; when the scope is active it also copies a mono + * downmix-ready interleaved float frame to the native analyzer via ScopeBridge. + * Allocation-free in steady state (reuses a scratch buffer); the ScopeBridge.active + * gate keeps a backgrounded/paused app's audio callback at ~zero cost. + */ +class ScopeTapAudioProcessor : BaseAudioProcessor() { + private var scratch = FloatArray(0) + + override fun onConfigure( + inputAudioFormat: AudioProcessor.AudioFormat + ): AudioProcessor.AudioFormat { + if (inputAudioFormat.encoding == C.ENCODING_PCM_16BIT || + inputAudioFormat.encoding == C.ENCODING_PCM_FLOAT + ) { + ScopeBridge.nativeConfigure(inputAudioFormat.sampleRate, inputAudioFormat.channelCount) + } + // Always pass the format through unchanged. + return inputAudioFormat + } + + override fun queueInput(inputBuffer: ByteBuffer) { + val remaining = inputBuffer.remaining() + if (remaining <= 0) return + + if (ScopeBridge.active) { + tap(inputBuffer) + } + + // Forward the audio unchanged (reads inputBuffer's own position/limit). + val out = replaceOutputBuffer(remaining) + out.put(inputBuffer) + out.flip() + } + + // Reads from a duplicate so inputBuffer's position is left intact for forwarding. + private fun tap(inputBuffer: ByteBuffer) { + val channels = inputAudioFormat.channelCount + if (channels <= 0) return + val dup = inputBuffer.duplicate().order(ByteOrder.nativeOrder()) + + when (inputAudioFormat.encoding) { + C.ENCODING_PCM_FLOAT -> { + val fb = dup.asFloatBuffer() + val n = fb.remaining() + if (n <= 0) return + if (scratch.size < n) scratch = FloatArray(n) + fb.get(scratch, 0, n) + ScopeBridge.nativePushFrames(scratch, n / channels, channels) + } + C.ENCODING_PCM_16BIT -> { + val sb = dup.asShortBuffer() + val n = sb.remaining() + if (n <= 0) return + if (scratch.size < n) scratch = FloatArray(n) + var i = 0 + while (i < n) { + scratch[i] = sb.get(i) / 32768f + i++ + } + ScopeBridge.nativePushFrames(scratch, n / channels, channels) + } + else -> { /* unsupported PCM encoding β€” forward only */ } + } + } +} diff --git a/vendor/kotlinaudio/kotlin-audio/src/main/java/com/doublesymmetry/kotlinaudio/utils/Utils.kt b/vendor/kotlinaudio/kotlin-audio/src/main/java/com/doublesymmetry/kotlinaudio/utils/Utils.kt new file mode 100644 index 0000000..c6f0ced --- /dev/null +++ b/vendor/kotlinaudio/kotlin-audio/src/main/java/com/doublesymmetry/kotlinaudio/utils/Utils.kt @@ -0,0 +1,16 @@ +package com.doublesymmetry.kotlinaudio.utils + +import android.content.ContentResolver +import android.net.Uri +import com.google.android.exoplayer2.upstream.RawResourceDataSource + +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 == RawResourceDataSource.RAW_RESOURCE_SCHEME || scheme == "res" || host == null +} \ No newline at end of file diff --git a/vendor/kotlinaudio/kotlin-audio/src/main/res/values/colors.xml b/vendor/kotlinaudio/kotlin-audio/src/main/res/values/colors.xml new file mode 100644 index 0000000..f8c6127 --- /dev/null +++ b/vendor/kotlinaudio/kotlin-audio/src/main/res/values/colors.xml @@ -0,0 +1,10 @@ + + + #FFBB86FC + #FF6200EE + #FF3700B3 + #FF03DAC5 + #FF018786 + #FF000000 + #FFFFFFFF + \ No newline at end of file diff --git a/vendor/kotlinaudio/kotlin-audio/src/main/res/values/strings.xml b/vendor/kotlinaudio/kotlin-audio/src/main/res/values/strings.xml new file mode 100644 index 0000000..807886a --- /dev/null +++ b/vendor/kotlinaudio/kotlin-audio/src/main/res/values/strings.xml @@ -0,0 +1,5 @@ + + Play + Now Playing + Pause + \ No newline at end of file