@capgo/capacitor-media-session 7.0.0

package/CapgoMediaSession.podspec

@@ -0,0 +1,17 @@
+require 'json'
+
+package = JSON.parse(File.read(File.join(__dir__, 'package.json')))
+
+Pod::Spec.new do |s|
+  s.name = 'CapgoMediaSession'
+  s.version = package['version']
+  s.summary = package['description']
+  s.license = package['license']
+  s.homepage = package['repository']['url']
+  s.author = package['author']
+  s.source = { :git => package['repository']['url'], :tag => s.version.to_s }
+  s.source_files = 'ios/Sources/**/*.{swift,h,m,c,cc,mm,cpp}'
+  s.ios.deployment_target = '14.0'
+  s.dependency 'Capacitor'
+  s.swift_version = '5.1'
+end

package/Package.swift

@@ -0,0 +1,28 @@
+// swift-tools-version: 5.9
+import PackageDescription
+
+let package = Package(
+    name: "CapgoMediaSession",
+    platforms: [.iOS(.v14)],
+    products: [
+        .library(
+            name: "CapgoMediaSession",
+            targets: ["MediaSessionPlugin"])
+    ],
+    dependencies: [
+        .package(url: "https://github.com/ionic-team/capacitor-swift-pm.git", from: "7.0.0")
+    ],
+    targets: [
+        .target(
+            name: "MediaSessionPlugin",
+            dependencies: [
+                .product(name: "Capacitor", package: "capacitor-swift-pm"),
+                .product(name: "Cordova", package: "capacitor-swift-pm")
+            ],
+            path: "ios/Sources/MediaSessionPlugin"),
+        .testTarget(
+            name: "MediaSessionPluginTests",
+            dependencies: ["MediaSessionPlugin"],
+            path: "ios/Tests/MediaSessionPluginTests")
+    ]
+)

package/README.md

@@ -0,0 +1,164 @@
+# @capgo/capacitor-media-session
+ <a href="https://capgo.app/"><img src='https://raw.githubusercontent.com/Cap-go/capgo/main/assets/capgo_banner.png' alt='Capgo - Instant updates for capacitor'/></a>
+
+<div align="center">
+  <h2><a href="https://capgo.app/?ref=plugin"> ➡️ Get Instant updates for your App with Capgo</a></h2>
+  <h2><a href="https://capgo.app/consulting/?ref=plugin"> Missing a feature? We’ll build the plugin for you 💪</a></h2>
+</div>
+Expose media session controls for Capacitor apps
+
+## Install
+
+```bash
+npm install @capgo/capacitor-media-session
+npx cap sync
+```
+
+## API
+
+<docgen-index>
+
+* [`setMetadata(...)`](#setmetadata)
+* [`setPlaybackState(...)`](#setplaybackstate)
+* [`setActionHandler(...)`](#setactionhandler)
+* [`setPositionState(...)`](#setpositionstate)
+* [Interfaces](#interfaces)
+* [Type Aliases](#type-aliases)
+
+</docgen-index>
+
+<docgen-api>
+<!--Update the source file JSDoc comments and rerun docgen to update the docs below-->
+
+### setMetadata(...)
+
+```typescript
+setMetadata(options: MetadataOptions) => Promise<void>
+```
+
+Sets metadata of the currently playing media.
+
+| Param         | Type                                                        |
+| ------------- | ----------------------------------------------------------- |
+| **`options`** | <code><a href="#metadataoptions">MetadataOptions</a></code> |
+
+--------------------
+
+
+### setPlaybackState(...)
+
+```typescript
+setPlaybackState(options: PlaybackStateOptions) => Promise<void>
+```
+
+Updates the playback state of the media session.
+
+| Param         | Type                                                                  |
+| ------------- | --------------------------------------------------------------------- |
+| **`options`** | <code><a href="#playbackstateoptions">PlaybackStateOptions</a></code> |
+
+--------------------
+
+
+### setActionHandler(...)
+
+```typescript
+setActionHandler(options: ActionHandlerOptions, handler: ActionHandler | null) => Promise<void>
+```
+
+Registers a handler for a media session action.
+
+| Param         | Type                                                                  |
+| ------------- | --------------------------------------------------------------------- |
+| **`options`** | <code><a href="#actionhandleroptions">ActionHandlerOptions</a></code> |
+| **`handler`** | <code><a href="#actionhandler">ActionHandler</a> \| null</code>       |
+
+--------------------
+
+
+### setPositionState(...)
+
+```typescript
+setPositionState(options: PositionStateOptions) => Promise<void>
+```
+
+Updates position state for the active media session.
+
+| Param         | Type                                                                  |
+| ------------- | --------------------------------------------------------------------- |
+| **`options`** | <code><a href="#positionstateoptions">PositionStateOptions</a></code> |
+
+--------------------
+
+
+### Interfaces
+
+
+#### MetadataOptions
+
+| Prop          | Type                      |
+| ------------- | ------------------------- |
+| **`album`**   | <code>string</code>       |
+| **`artist`**  | <code>string</code>       |
+| **`artwork`** | <code>MediaImage[]</code> |
+| **`title`**   | <code>string</code>       |
+
+
+#### MediaImage
+
+| Prop        | Type                |
+| ----------- | ------------------- |
+| **`src`**   | <code>string</code> |
+| **`sizes`** | <code>string</code> |
+| **`type`**  | <code>string</code> |
+
+
+#### PlaybackStateOptions
+
+| Prop                | Type                                                                            |
+| ------------------- | ------------------------------------------------------------------------------- |
+| **`playbackState`** | <code><a href="#mediasessionplaybackstate">MediaSessionPlaybackState</a></code> |
+
+
+#### ActionHandlerOptions
+
+| Prop         | Type                                                              |
+| ------------ | ----------------------------------------------------------------- |
+| **`action`** | <code><a href="#mediasessionaction">MediaSessionAction</a></code> |
+
+
+#### ActionDetails
+
+| Prop           | Type                                                              |
+| -------------- | ----------------------------------------------------------------- |
+| **`action`**   | <code><a href="#mediasessionaction">MediaSessionAction</a></code> |
+| **`seekTime`** | <code>number \| null</code>                                       |
+
+
+#### PositionStateOptions
+
+| Prop               | Type                |
+| ------------------ | ------------------- |
+| **`duration`**     | <code>number</code> |
+| **`playbackRate`** | <code>number</code> |
+| **`position`**     | <code>number</code> |
+
+
+### Type Aliases
+
+
+#### MediaSessionPlaybackState
+
+<code>'none' | 'paused' | 'playing'</code>
+
+
+#### MediaSessionAction
+
+<code>'play' | 'pause' | 'seekbackward' | 'seekforward' | 'previoustrack' | 'nexttrack' | 'seekto' | 'stop'</code>
+
+
+#### ActionHandler
+
+<code>(details: <a href="#actiondetails">ActionDetails</a>): void</code>
+
+</docgen-api>

package/android/build.gradle

@@ -0,0 +1,60 @@
+ext {
+    junitVersion = project.hasProperty('junitVersion') ? rootProject.ext.junitVersion : '4.13.2'
+    androidxAppCompatVersion = project.hasProperty('androidxAppCompatVersion') ? rootProject.ext.androidxAppCompatVersion : '1.7.0'
+    androidxJunitVersion = project.hasProperty('androidxJunitVersion') ? rootProject.ext.androidxJunitVersion : '1.2.1'
+    androidxEspressoCoreVersion = project.hasProperty('androidxEspressoCoreVersion') ? rootProject.ext.androidxEspressoCoreVersion : '3.6.1'
+    androidxMediaVersion = project.hasProperty('androidxMediaVersion') ? rootProject.ext.androidxMediaVersion : '1.7.0'
+}
+
+buildscript {
+    repositories {
+        google()
+        mavenCentral()
+    }
+    dependencies {
+        classpath 'com.android.tools.build:gradle:8.7.2'
+    }
+}
+
+apply plugin: 'com.android.library'
+
+android {
+    namespace "com.capgo.mediasession"
+    compileSdk project.hasProperty('compileSdkVersion') ? rootProject.ext.compileSdkVersion : 35
+    defaultConfig {
+        minSdkVersion project.hasProperty('minSdkVersion') ? rootProject.ext.minSdkVersion : 23
+        targetSdkVersion project.hasProperty('targetSdkVersion') ? rootProject.ext.targetSdkVersion : 35
+        versionCode 1
+        versionName "1.0"
+        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
+    }
+    buildTypes {
+        release {
+            minifyEnabled false
+            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
+        }
+    }
+    lintOptions {
+        abortOnError false
+    }
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_21
+        targetCompatibility JavaVersion.VERSION_21
+    }
+}
+
+repositories {
+    google()
+    mavenCentral()
+}
+
+
+dependencies {
+    implementation fileTree(dir: 'libs', include: ['*.jar'])
+    implementation project(':capacitor-android')
+    implementation "androidx.appcompat:appcompat:$androidxAppCompatVersion"
+    implementation "androidx.media:media:$androidxMediaVersion"
+    testImplementation "junit:junit:$junitVersion"
+    androidTestImplementation "androidx.test.ext:junit:$androidxJunitVersion"
+    androidTestImplementation "androidx.test.espresso:espresso-core:$androidxEspressoCoreVersion"
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,26 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
+
+    <application>
+        <service
+            android:name=".MediaSessionService"
+            android:enabled="true"
+            android:exported="true"
+            android:foregroundServiceType="mediaPlayback">
+            <intent-filter>
+                <action android:name="android.intent.action.MEDIA_BUTTON" />
+            </intent-filter>
+        </service>
+
+        <receiver
+            android:name="androidx.media.session.MediaButtonReceiver"
+            android:exported="true">
+            <intent-filter>
+                <action android:name="android.intent.action.MEDIA_BUTTON" />
+            </intent-filter>
+        </receiver>
+    </application>
+
+</manifest>

package/android/src/main/java/com/capgo/mediasession/MediaSessionCallback.java

@@ -0,0 +1,55 @@
+package com.capgo.mediasession;
+
+import android.support.v4.media.session.MediaSessionCompat;
+import com.getcapacitor.JSObject;
+
+public class MediaSessionCallback extends MediaSessionCompat.Callback {
+
+    private final MediaSessionPlugin plugin;
+
+    MediaSessionCallback(MediaSessionPlugin plugin) {
+        this.plugin = plugin;
+    }
+
+    @Override
+    public void onPlay() {
+        plugin.actionCallback("play");
+    }
+
+    @Override
+    public void onPause() {
+        plugin.actionCallback("pause");
+    }
+
+    @Override
+    public void onSeekTo(long pos) {
+        JSObject data = new JSObject();
+        data.put("seekTime", (double) pos / 1000.0);
+        plugin.actionCallback("seekto", data);
+    }
+
+    @Override
+    public void onRewind() {
+        plugin.actionCallback("seekbackward");
+    }
+
+    @Override
+    public void onFastForward() {
+        plugin.actionCallback("seekforward");
+    }
+
+    @Override
+    public void onSkipToPrevious() {
+        plugin.actionCallback("previoustrack");
+    }
+
+    @Override
+    public void onSkipToNext() {
+        plugin.actionCallback("nexttrack");
+    }
+
+    @Override
+    public void onStop() {
+        plugin.actionCallback("stop");
+    }
+}

package/android/src/main/java/com/capgo/mediasession/MediaSessionPlugin.java

@@ -0,0 +1,277 @@
+package com.capgo.mediasession;
+
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.Intent;
+import android.content.ServiceConnection;
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.os.IBinder;
+import android.support.v4.media.session.PlaybackStateCompat;
+import android.util.Base64;
+import android.util.Log;
+import androidx.core.content.ContextCompat;
+import com.getcapacitor.JSArray;
+import com.getcapacitor.JSObject;
+import com.getcapacitor.Plugin;
+import com.getcapacitor.PluginCall;
+import com.getcapacitor.PluginMethod;
+import com.getcapacitor.annotation.CapacitorPlugin;
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.HttpURLConnection;
+import java.net.URL;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+@CapacitorPlugin(name = "MediaSession")
+public class MediaSessionPlugin extends Plugin {
+
+    private static final String TAG = "CapgoMediaSession";
+
+    private boolean startServiceOnlyDuringPlayback = true;
+
+    private String title = "";
+    private String artist = "";
+    private String album = "";
+    private Bitmap artwork;
+    private String playbackState = "none";
+    private double duration = 0.0;
+    private double position = 0.0;
+    private double playbackRate = 1.0;
+
+    private final Map<String, PluginCall> actionHandlers = new HashMap<>();
+
+    private MediaSessionService service;
+
+    private final ServiceConnection serviceConnection = new ServiceConnection() {
+        @Override
+        public void onServiceConnected(ComponentName componentName, IBinder binder) {
+            MediaSessionService.LocalBinder localBinder = (MediaSessionService.LocalBinder) binder;
+            service = localBinder.getService();
+            if (getActivity() == null) {
+                return;
+            }
+            Intent launchIntent = new Intent(getActivity(), getActivity().getClass());
+            service.connectAndInitialize(MediaSessionPlugin.this, launchIntent);
+            updateServiceMetadata();
+            updateServicePlaybackState();
+            updateServicePositionState();
+        }
+
+        @Override
+        public void onServiceDisconnected(ComponentName componentName) {
+            Log.d(TAG, "Disconnected from MediaSessionService");
+            service = null;
+        }
+    };
+
+    @Override
+    public void load() {
+        super.load();
+
+        String foregroundServiceConfig = getConfig().getString("foregroundService", "");
+        if ("always".equals(foregroundServiceConfig)) {
+            startServiceOnlyDuringPlayback = false;
+        }
+
+        if (!startServiceOnlyDuringPlayback) {
+            startMediaService();
+        }
+    }
+
+    @Override
+    protected void handleAppStop() {
+        super.handleAppStop();
+
+        if (startServiceOnlyDuringPlayback && service != null && !isPlaybackActive()) {
+            stopMediaService();
+        }
+    }
+
+    private void startMediaService() {
+        Context context = getContext();
+        if (context == null || getActivity() == null) {
+            return;
+        }
+
+        Intent intent = new Intent(context, MediaSessionService.class);
+        ContextCompat.startForegroundService(context, intent);
+        context.bindService(intent, serviceConnection, Context.BIND_AUTO_CREATE);
+    }
+
+    private void stopMediaService() {
+        Context context = getContext();
+        if (context == null || service == null) {
+            return;
+        }
+
+        try {
+            context.unbindService(serviceConnection);
+        } catch (IllegalArgumentException ex) {
+            Log.w(TAG, "Service already unbound", ex);
+        }
+        service = null;
+    }
+
+    private boolean isPlaybackActive() {
+        return "playing".equals(playbackState) || "paused".equals(playbackState);
+    }
+
+    private void updateServiceMetadata() {
+        if (service == null) {
+            return;
+        }
+        service.setTitle(title);
+        service.setArtist(artist);
+        service.setAlbum(album);
+        service.setArtwork(artwork);
+        service.update();
+    }
+
+    private void updateServicePlaybackState() {
+        if (service == null) {
+            return;
+        }
+
+        if ("playing".equals(playbackState)) {
+            service.setPlaybackState(PlaybackStateCompat.STATE_PLAYING);
+        } else if ("paused".equals(playbackState)) {
+            service.setPlaybackState(PlaybackStateCompat.STATE_PAUSED);
+        } else {
+            service.setPlaybackState(PlaybackStateCompat.STATE_NONE);
+        }
+        service.update();
+    }
+
+    private void updateServicePositionState() {
+        if (service == null) {
+            return;
+        }
+
+        service.setDuration(Math.round(duration * 1000));
+        service.setPosition(Math.round(position * 1000));
+        float playbackSpeed = playbackRate == 0.0 ? 1.0F : (float) playbackRate;
+        service.setPlaybackSpeed(playbackSpeed);
+        service.update();
+    }
+
+    private Bitmap urlToBitmap(String url) throws IOException {
+        if (url == null || url.isEmpty()) {
+            return null;
+        }
+
+        boolean blobUrl = url.startsWith("blob:");
+        if (blobUrl) {
+            Log.i(TAG, "Blob URLs are not supported for media artwork");
+            return null;
+        }
+
+        boolean httpUrl = url.startsWith("http");
+        if (httpUrl) {
+            HttpURLConnection connection = (HttpURLConnection) new URL(url).openConnection();
+            connection.setDoInput(true);
+            connection.connect();
+            try (InputStream inputStream = connection.getInputStream()) {
+                return BitmapFactory.decodeStream(inputStream);
+            }
+        }
+
+        int base64Index = url.indexOf(";base64,");
+        if (base64Index != -1) {
+            String base64Data = url.substring(base64Index + 8);
+            byte[] decoded = Base64.decode(base64Data, Base64.DEFAULT);
+            return BitmapFactory.decodeByteArray(decoded, 0, decoded.length);
+        }
+
+        return null;
+    }
+
+    @PluginMethod
+    public void setMetadata(PluginCall call) {
+        title = call.getString("title", title);
+        artist = call.getString("artist", artist);
+        album = call.getString("album", album);
+
+        try {
+            JSArray artworkArray = call.getArray("artwork");
+            if (artworkArray != null) {
+                List<JSONObject> artworkList = artworkArray.toList();
+                for (JSONObject artworkJson : artworkList) {
+                    String src = artworkJson.optString("src", null);
+                    if (src != null) {
+                        artwork = urlToBitmap(src);
+                        break;
+                    }
+                }
+            }
+        } catch (JSONException | IOException ex) {
+            Log.w(TAG, "Unable to parse artwork", ex);
+        }
+
+        updateServiceMetadata();
+        call.resolve();
+    }
+
+    @PluginMethod
+    public void setPlaybackState(PluginCall call) {
+        playbackState = call.getString("playbackState", playbackState);
+
+        boolean playbackActive = isPlaybackActive();
+        if (startServiceOnlyDuringPlayback && service == null && playbackActive) {
+            startMediaService();
+        } else if (startServiceOnlyDuringPlayback && service != null && !playbackActive) {
+            stopMediaService();
+        } else {
+            updateServicePlaybackState();
+        }
+
+        call.resolve();
+    }
+
+    @PluginMethod
+    public void setPositionState(PluginCall call) {
+        duration = call.getDouble("duration", duration);
+        position = call.getDouble("position", position);
+        playbackRate = call.getFloat("playbackRate", (float) playbackRate);
+
+        updateServicePositionState();
+        call.resolve();
+    }
+
+    @PluginMethod(returnType = PluginMethod.RETURN_CALLBACK)
+    public void setActionHandler(PluginCall call) {
+        call.setKeepAlive(true);
+        String action = call.getString("action");
+        if (action != null) {
+            actionHandlers.put(action, call);
+            if (service != null) {
+                service.updatePossibleActions();
+            }
+        } else {
+            call.resolve();
+        }
+    }
+
+    public boolean hasActionHandler(String action) {
+        PluginCall handler = actionHandlers.get(action);
+        return handler != null && !PluginCall.CALLBACK_ID_DANGLING.equals(handler.getCallbackId());
+    }
+
+    public void actionCallback(String action) {
+        actionCallback(action, new JSObject());
+    }
+
+    public void actionCallback(String action, JSObject data) {
+        PluginCall handler = actionHandlers.get(action);
+        if (handler != null && !PluginCall.CALLBACK_ID_DANGLING.equals(handler.getCallbackId())) {
+            data.put("action", action);
+            handler.resolve(data);
+        } else {
+            Log.d(TAG, "No handler for action " + action);
+        }
+    }
+}