react-native-media-notification 0.2.0

package/android/src/main/java/com/mediacontrols/MediaControlsService.kt

@@ -0,0 +1,233 @@
+package com.mediacontrols
+
+import android.app.NotificationChannel
+import android.app.NotificationManager
+import android.app.Service
+import android.content.ComponentName
+import android.content.Intent
+import android.os.Binder
+import android.os.Build
+import android.os.Bundle
+import android.os.IBinder
+import android.view.KeyEvent
+import androidx.annotation.RequiresApi
+import androidx.media3.common.MediaItem
+import androidx.media3.common.Player
+import androidx.media3.common.util.UnstableApi
+import androidx.media3.session.MediaController
+import androidx.media3.session.MediaSession
+import androidx.media3.session.MediaSessionService
+import androidx.media3.session.SessionCommand
+import androidx.media3.session.SessionError
+import androidx.media3.session.SessionResult
+import androidx.media3.session.SessionToken
+import com.facebook.react.bridge.ReactApplicationContext
+import com.google.common.util.concurrent.Futures
+import com.google.common.util.concurrent.ListenableFuture
+
+@UnstableApi
+class MediaControlsService : MediaSessionService() {
+
+    private var mediaSession: MediaSession? = null
+    private val binder = LocalBinder()
+    private var mediaController: MediaController? = null
+
+    companion object {
+        private const val CHANNEL_ID = "media_controls_channel"
+        var reactContext: ReactApplicationContext? = null
+        var player: MediaControlsPlayer? = null
+    }
+
+    inner class LocalBinder : Binder() {
+        fun getService(): MediaControlsService = this@MediaControlsService
+    }
+
+    override fun onBind(intent: Intent?): IBinder {
+        return if (intent?.action == "androidx.media3.session.MediaSessionService" ||
+                   intent?.action == "android.media.browse.MediaBrowserService") {
+            super.onBind(intent)!!
+        } else {
+            binder
+        }
+    }
+
+    override fun onCreate() {
+        super.onCreate()
+
+        // TODO: handle headless service with HeadlessJsTask
+        if (player == null || reactContext == null) {
+            return
+        }
+
+        // Create notification channel for Android O and above
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            createNotificationChannel()
+        }
+
+        // Create media session
+        mediaSession = MediaSession.Builder(this, player!!)
+            .setCallback(MediaSessionCallback())
+            .setId("MediaControlsSession")
+            .build()
+
+        updateCustomLayout()
+
+        player?.addListener(object : Player.Listener {
+            override fun onShuffleModeEnabledChanged(shuffleModeEnabled: Boolean) {
+                updateCustomLayout()
+            }
+
+            override fun onRepeatModeChanged(repeatMode: Int) {
+                updateCustomLayout()
+            }
+        })
+
+        setMediaNotificationProvider(MediaNotificationProvider(this))
+
+        // Create MediaController for media controls
+        setupMediaController()
+
+        android.util.Log.d("MediaControlsService", "Service created with new player instance")
+    }
+
+    private fun updateCustomLayout() {
+        mediaSession?.setMediaButtonPreferences(player!!.getAvailableCustomCommands().toList())
+    }
+
+    private fun setupMediaController() {
+        mediaSession?.let { session ->
+            val sessionToken = SessionToken(this, ComponentName(this, MediaControlsService::class.java))
+
+            val controllerFuture = MediaController.Builder(this, sessionToken)
+                .buildAsync()
+
+            controllerFuture.addListener({
+                try {
+                    mediaController = controllerFuture.get()
+                } catch (e: Exception) {
+                    android.util.Log.e("MediaControlsService", "Failed to create MediaController", e)
+                }
+            }, androidx.core.content.ContextCompat.getMainExecutor(this))
+        }
+    }
+
+    @RequiresApi(Build.VERSION_CODES.O)
+    private fun createNotificationChannel() {
+        val channel = NotificationChannel(
+            CHANNEL_ID,
+            "Media Controls",
+            NotificationManager.IMPORTANCE_LOW
+        ).apply {
+            description = "Media playback controls"
+            setShowBadge(false)
+            setSound(null, null)
+        }
+
+        val notificationManager = getSystemService(NotificationManager::class.java)
+        notificationManager.createNotificationChannel(channel)
+    }
+
+    override fun onGetSession(controllerInfo: MediaSession.ControllerInfo): MediaSession? {
+        return mediaSession
+    }
+
+    override fun onDestroy() {
+        this.stopNotificationAndService()
+        super.onDestroy()
+    }
+
+    fun stopNotificationAndService() {
+        stopForeground(Service.STOP_FOREGROUND_REMOVE)
+        stopSelf()
+        player?.releaseFocus()
+        mediaSession?.release()
+        mediaSession = null
+    }
+
+    fun getPlayer(): MediaControlsPlayer? = player
+
+    private inner class MediaSessionCallback : MediaSession.Callback {
+
+        override fun onConnect(
+            session: MediaSession,
+            controller: MediaSession.ControllerInfo
+        ): MediaSession.ConnectionResult {
+            // Accept all connections and provide full access to player commands
+            val sessionCommands = MediaSession.ConnectionResult.DEFAULT_SESSION_COMMANDS.buildUpon()
+                .addSessionCommands(CustomCommandButton.entries.map { c -> c.commandButton.sessionCommand!! })
+                .build()
+
+            val playerCommands = MediaSession.ConnectionResult.DEFAULT_PLAYER_COMMANDS.buildUpon()
+                .build()
+
+            return MediaSession.ConnectionResult.AcceptedResultBuilder(session)
+                .setAvailableSessionCommands(sessionCommands)
+                .setAvailablePlayerCommands(playerCommands)
+                .build()
+        }
+
+        override fun onPostConnect(session: MediaSession, controller: MediaSession.ControllerInfo) {
+            super.onPostConnect(session, controller)
+            //mediaSession?.setCustomLayout(CustomCommandButton.entries.map { c -> c.commandButton })
+        }
+
+        override fun onCustomCommand(
+            session: MediaSession,
+            controller: MediaSession.ControllerInfo,
+            customCommand: SessionCommand,
+            args: Bundle
+        ): ListenableFuture<SessionResult> {
+            // Handle custom commands if needed
+            return when (customCommand.customAction) {
+                "TOGGLE_PLAY_PAUSE" -> {
+                    player?.let { p ->
+                        if (p.isPlaying) {
+                            p.pause()
+                        } else {
+                            p.play()
+                        }
+                    }
+                    Futures.immediateFuture(SessionResult(SessionResult.RESULT_SUCCESS))
+                }
+                CustomCommandButton.FORWARD.customAction -> {
+                    player?.seekForward()
+                    Futures.immediateFuture(SessionResult(SessionResult.RESULT_SUCCESS))
+                }
+                CustomCommandButton.REWIND.customAction -> {
+                    player?.seekBack()
+                    Futures.immediateFuture(SessionResult(SessionResult.RESULT_SUCCESS))
+                }
+                CustomCommandButton.SHUFFLE_ON.customAction, CustomCommandButton.SHUFFLE_OFF.customAction -> {
+                    player?.emitShuffleClicked()
+                    Futures.immediateFuture(SessionResult(SessionResult.RESULT_SUCCESS))
+                }
+                CustomCommandButton.REPEAT_ONE.customAction, CustomCommandButton.REPEAT_OFF.customAction, CustomCommandButton.REPEAT_ALL.customAction -> {
+                    player?.emitRepeatClicked()
+                    Futures.immediateFuture(SessionResult(SessionResult.RESULT_SUCCESS))
+                }
+                else -> Futures.immediateFuture(SessionResult(SessionError.ERROR_UNKNOWN))
+            }
+        }
+
+        override fun onAddMediaItems(
+            mediaSession: MediaSession,
+            controller: MediaSession.ControllerInfo,
+            mediaItems: List<MediaItem>
+        ): ListenableFuture<List<MediaItem>> {
+            // Return the media items as-is since we're handling metadata updates separately
+            return Futures.immediateFuture(mediaItems)
+        }
+
+        override fun onSetMediaItems(
+            mediaSession: MediaSession,
+            controller: MediaSession.ControllerInfo,
+            mediaItems: List<MediaItem>,
+            startIndex: Int,
+            startPositionMs: Long
+        ): ListenableFuture<MediaSession.MediaItemsWithStartPosition> {
+            return Futures.immediateFuture(
+                MediaSession.MediaItemsWithStartPosition(mediaItems, startIndex, startPositionMs)
+            )
+        }
+    }
+}

package/android/src/main/java/com/mediacontrols/MediaNotificationProvider.kt

@@ -0,0 +1,74 @@
+package com.mediacontrols
+
+import android.app.PendingIntent
+import android.content.Context
+import android.content.Intent
+import android.content.pm.PackageManager
+import android.os.Bundle
+import androidx.media3.session.CommandButton
+import androidx.media3.session.MediaNotification
+import androidx.media3.session.MediaSession
+import androidx.media3.ui.PlayerNotificationManager
+import androidx.media3.common.util.UnstableApi
+import com.google.common.collect.ImmutableList
+
+@UnstableApi
+class MediaNotificationProvider(private val context: Context) : MediaNotification.Provider {
+
+    override fun createNotification(
+        mediaSession: MediaSession,
+        customLayout: ImmutableList<CommandButton>,
+        actionFactory: MediaNotification.ActionFactory,
+        onNotificationChangedCallback: MediaNotification.Provider.Callback
+    ): MediaNotification {
+
+        // Create PendingIntent to open the app when notification is clicked
+        val contentIntent = createContentIntent()
+
+        // Get the default notification from the session
+        val defaultProvider = androidx.media3.session.DefaultMediaNotificationProvider(context)
+        val notification = defaultProvider.createNotification(
+            mediaSession,
+            customLayout,
+            actionFactory,
+            onNotificationChangedCallback
+        )
+
+        // Modify the notification to add the content intent
+        val modifiedNotification = notification.notification.apply {
+            contentIntent?.let { pendingIntent ->
+                this.contentIntent = pendingIntent
+            }
+        }
+
+        return MediaNotification(notification.notificationId, modifiedNotification)
+    }
+
+    private fun createContentIntent(): PendingIntent? {
+        return try {
+            // Get the launcher activity from the host app
+            val packageManager = context.packageManager
+            val intent = packageManager.getLaunchIntentForPackage(context.packageName)
+            intent?.let {
+                PendingIntent.getActivity(
+                    context,
+                    0,
+                    it,
+                    PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
+                )
+            }
+        } catch (e: Exception) {
+            android.util.Log.e("MediaNotificationProvider", "Failed to create content intent", e)
+            null
+        }
+    }
+
+    override fun handleCustomCommand(
+        session: MediaSession,
+        action: String,
+        extras: Bundle
+    ): Boolean {
+        // Handle custom commands if needed
+        return false
+    }
+}

package/ios/MediaControls.h

@@ -0,0 +1,5 @@
+#import <MediaControlsSpec/MediaControlsSpec.h>
+
+@interface MediaControls : NativeMediaControlsSpecBase <NativeMediaControlsSpec>
+
+@end

package/ios/MediaControls.mm

@@ -0,0 +1,300 @@
+#import "MediaControls.h"
+#import <MediaPlayer/MediaPlayer.h>
+#import <AVFoundation/AVFoundation.h>
+
+@interface MediaControls ()
+@property (nonatomic, assign) BOOL audioInterruptionEnabled;
+@property (nonatomic, assign) BOOL hasListeners;
+@property (nonatomic, assign) BOOL audioInterrupted;
+@property (nonatomic, assign) BOOL explictlyPaused;
+@end
+
+@implementation MediaControls
+
+RCT_EXPORT_MODULE()
+
+- (instancetype)init {
+    self = [super init];
+    if (self) {
+        _audioInterruptionEnabled = NO;
+        [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(audioHardwareRouteChanged:) name:AVAudioSessionRouteChangeNotification object:nil];
+        [[UIApplication sharedApplication] beginReceivingRemoteControlEvents];
+    }
+    return self;
+}
+
+- (void)stopObserving {
+    [[NSNotificationCenter defaultCenter] removeObserver:self];
+}
+
+- (NSArray<NSString *> *)supportedEvents {
+    return @[@"play", @"pause", @"stop", @"skipToNext", @"skipToPrevious", @"seekForward", @"seekBackward", @"seek"];
+}
+
+#pragma mark - React Native Methods
+
+RCT_EXPORT_METHOD(setControlEnabled:(NSString*)name enabled:(BOOL)enabled) {
+  MPRemoteCommandCenter *commandCenter = [MPRemoteCommandCenter sharedCommandCenter];
+  if ([name  isEqual: @"play"]) {
+    [commandCenter.playCommand addTarget:self action:@selector(handlePlayCommand:)];
+    commandCenter.playCommand.enabled = enabled;
+  }
+
+  if ([name  isEqual: @"pause"]) {
+    [commandCenter.pauseCommand addTarget:self action:@selector(handlePauseCommand:)];
+    commandCenter.pauseCommand.enabled = enabled;
+  }
+
+  if ([name  isEqual: @"stop"]) {
+    [commandCenter.stopCommand addTarget:self action:@selector(handleStopCommand:)];
+    commandCenter.stopCommand.enabled = enabled;
+  }
+
+  if ([name  isEqual: @"skipToNext"]) {
+    [commandCenter.nextTrackCommand addTarget:self action:@selector(handleNextTrackCommand:)];
+    commandCenter.nextTrackCommand.enabled = enabled;
+  }
+
+  if ([name  isEqual: @"skipToPrevious"]) {
+    [commandCenter.previousTrackCommand addTarget:self action:@selector(handlePreviousTrackCommand:)];
+    commandCenter.previousTrackCommand.enabled = enabled;
+  }
+
+  if ([name  isEqual: @"seekForward"]) {
+    [commandCenter.seekForwardCommand addTarget:self action:@selector(handleSeekForwardCommand:)];
+    commandCenter.seekForwardCommand.enabled = enabled;
+  }
+
+  if ([name  isEqual: @"seekBackward"]) {
+    [commandCenter.seekBackwardCommand addTarget:self action:@selector(handleSeekBackwardCommand:)];
+    commandCenter.seekBackwardCommand.enabled = enabled;
+  }
+
+  if ([name  isEqual: @"seek"]) {
+    [commandCenter.changePlaybackPositionCommand addTarget:self action:@selector(handleChangePlaybackPositionCommand:)];
+    commandCenter.changePlaybackPositionCommand.enabled = enabled;
+  }
+}
+
+RCT_EXPORT_METHOD(updateMetadata:(JS::NativeMediaControls::MediaTrackMetadata &)metadata
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject) {
+
+    MPNowPlayingInfoCenter *_nowPlayingCenter = [MPNowPlayingInfoCenter defaultCenter];
+
+    @try {
+        NSMutableDictionary *nowPlayingInfo = [NSMutableDictionary dictionary];
+
+        if (metadata.title().length > 0) {
+            nowPlayingInfo[MPMediaItemPropertyTitle] = metadata.title();
+        }
+
+        if (metadata.artist().length > 0) {
+            nowPlayingInfo[MPMediaItemPropertyArtist] = metadata.artist();
+        }
+
+        if (metadata.album().length > 0) {
+            nowPlayingInfo[MPMediaItemPropertyAlbumTitle] = metadata.album();
+        }
+
+        if (metadata.duration().has_value()) {
+            double duration = metadata.duration().value();
+            nowPlayingInfo[MPMediaItemPropertyPlaybackDuration] = [NSNumber numberWithDouble:duration];
+        }
+
+        if (metadata.position().has_value()) {
+            double position = metadata.position().value();
+            nowPlayingInfo[MPNowPlayingInfoPropertyElapsedPlaybackTime] = [NSNumber numberWithDouble:position];
+        }
+
+        nowPlayingInfo[MPNowPlayingInfoPropertyPlaybackRate] = metadata.isPlaying() ? [NSNumber numberWithDouble:1] : [NSNumber numberWithDouble:0];
+
+        _nowPlayingCenter.nowPlayingInfo = nowPlayingInfo;
+
+        if (@available(iOS 11.0, *)) {
+            if (!self.audioInterrupted) {
+                self.explictlyPaused = false;
+            }
+
+            if (metadata.isPlaying()) {
+                _nowPlayingCenter.playbackState = MPNowPlayingPlaybackStatePlaying;
+            } else {
+                _nowPlayingCenter.playbackState = MPNowPlayingPlaybackStatePaused;
+
+                if (!self.audioInterrupted) {
+                    self.explictlyPaused = true;
+                }
+            }
+        }
+
+
+        // Load artwork if provided
+        if (metadata.artwork().length > 0) {
+            NSString *artworkURL = metadata.artwork();
+            [self loadArtworkFromURL:artworkURL completion:^(UIImage *image) {
+                if (!image) {
+                    return;
+                }
+                dispatch_async(dispatch_get_main_queue(), ^{
+                    MPNowPlayingInfoCenter *center = [MPNowPlayingInfoCenter defaultCenter];
+                    MPMediaItemArtwork *artwork = [[MPMediaItemArtwork alloc] initWithBoundsSize:image.size requestHandler:^UIImage * _Nonnull(CGSize size) {
+                        return image;
+                    }];
+                    NSMutableDictionary *mediaDict = (center.nowPlayingInfo != nil) ? [[NSMutableDictionary alloc] initWithDictionary: center.nowPlayingInfo] : [NSMutableDictionary dictionary];
+                    [mediaDict setValue:artwork forKey:MPMediaItemPropertyArtwork];
+                    center.nowPlayingInfo = mediaDict;
+                });
+            }];
+        }
+
+        resolve(nil);
+    }
+    @catch (NSException *exception) {
+        reject(@"UPDATE_METADATA_ERROR", exception.reason, nil);
+    }
+}
+
+RCT_EXPORT_METHOD(stopMediaNotification:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject) {
+    @try {
+        [MPNowPlayingInfoCenter defaultCenter].nowPlayingInfo = nil;
+        resolve(nil);
+    }
+    @catch (NSException *exception) {
+        reject(@"STOP_NOTIFICATION_ERROR", exception.reason, nil);
+    }
+}
+
+RCT_EXPORT_METHOD(enableAudioInterruption:(BOOL)enabled
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject) {
+    @try {
+        _audioInterruptionEnabled = enabled;
+
+        if (enabled) {
+            [[NSNotificationCenter defaultCenter] addObserver:self
+                                                     selector:@selector(audioSessionInterrupted:)
+                                                         name:AVAudioSessionInterruptionNotification
+                                                       object:nil];
+        } else {
+            [[NSNotificationCenter defaultCenter] removeObserver:self
+                                                            name:AVAudioSessionInterruptionNotification
+                                                          object:nil];
+        }
+
+        resolve(nil);
+    }
+    @catch (NSException *exception) {
+        reject(@"AUDIO_INTERRUPTION_ERROR", exception.reason, nil);
+    }
+}
+
+RCT_EXPORT_METHOD(enableBackgroundMode:(BOOL) enabled){
+    AVAudioSession *session = [AVAudioSession sharedInstance];
+    [session setCategory: AVAudioSessionCategoryPlayback error: nil];
+    [session setActive: enabled error: nil];
+}
+
+- (MPRemoteCommandHandlerStatus)handlePlayCommand:(MPRemoteCommandEvent *)event {
+    [self emitEvent:@"play" position:nil];
+    return MPRemoteCommandHandlerStatusSuccess;
+}
+
+- (MPRemoteCommandHandlerStatus)handlePauseCommand:(MPRemoteCommandEvent *)event {
+    [self emitEvent:@"pause" position:nil];
+    return MPRemoteCommandHandlerStatusSuccess;
+}
+
+- (MPRemoteCommandHandlerStatus)handleStopCommand:(MPRemoteCommandEvent *)event {
+    [self emitEvent:@"stop" position:nil];
+    return MPRemoteCommandHandlerStatusSuccess;
+}
+
+- (MPRemoteCommandHandlerStatus)handleNextTrackCommand:(MPRemoteCommandEvent *)event {
+    [self emitEvent:@"skipToNext" position:nil];
+    return MPRemoteCommandHandlerStatusSuccess;
+}
+
+- (MPRemoteCommandHandlerStatus)handlePreviousTrackCommand:(MPRemoteCommandEvent *)event {
+    [self emitEvent:@"skipToPrevious" position:nil];
+    return MPRemoteCommandHandlerStatusSuccess;
+}
+
+- (MPRemoteCommandHandlerStatus)handleSeekForwardCommand:(MPRemoteCommandEvent *)event {
+    [self emitEvent:@"seekForward" position:nil];
+    return MPRemoteCommandHandlerStatusSuccess;
+}
+
+- (MPRemoteCommandHandlerStatus)handleSeekBackwardCommand:(MPRemoteCommandEvent *)event {
+    [self emitEvent:@"seekBackward" position:nil];
+    return MPRemoteCommandHandlerStatusSuccess;
+}
+
+- (MPRemoteCommandHandlerStatus)handleChangePlaybackPositionCommand:(MPChangePlaybackPositionCommandEvent *)event {
+    [self emitEvent:@"seek" position:[NSNumber numberWithDouble:event.positionTime]];
+    return MPRemoteCommandHandlerStatusSuccess;
+}
+
+- (void)emitEvent:(NSString*) name position:(nullable NSNumber*) position {
+  NSMutableDictionary *params = [NSMutableDictionary dictionary];
+  params[@"command"] = name;
+  if (position) {
+    params[@"seekPosition"] = position;
+  }
+  [self emitOnEvent:params];
+}
+
+#pragma mark - Audio Interruption Handler
+
+- (void)audioSessionInterrupted:(NSNotification *)notification {
+    if (!_audioInterruptionEnabled) return;
+
+    NSInteger interruptionType = [notification.userInfo[AVAudioSessionInterruptionTypeKey] integerValue];
+
+    if (interruptionType == AVAudioSessionInterruptionTypeBegan) {
+        self.audioInterrupted = true;
+        if (!self.explictlyPaused) {
+            [self emitEvent:@"pause" position:nil];
+        }
+    } else if (interruptionType == AVAudioSessionInterruptionTypeEnded) {
+        self.audioInterrupted = false;
+        if (!self.explictlyPaused) {
+            [self emitEvent:@"play" position:nil];
+        }
+    }
+}
+
+- (void)audioHardwareRouteChanged:(NSNotification *)notification {
+    NSInteger routeChangeReason = [notification.userInfo[AVAudioSessionRouteChangeReasonKey] integerValue];
+    if (routeChangeReason == AVAudioSessionRouteChangeReasonOldDeviceUnavailable) {
+        //headphones unplugged or bluetooth device disconnected, iOS will pause audio
+        [self emitEvent:@"pause" position:nil];
+    }
+}
+
+#pragma mark - Helper Methods
+
+- (void)loadArtworkFromURL:(NSString *)urlString completion:(void (^)(UIImage *))completion {
+    NSURL *url = [NSURL URLWithString:urlString];
+    if (!url) {
+        completion(nil);
+        return;
+    }
+
+    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+        NSData *imageData = [NSData dataWithContentsOfURL:url];
+        UIImage *image = imageData ? [UIImage imageWithData:imageData] : nil;
+
+        dispatch_async(dispatch_get_main_queue(), ^{
+            completion(image);
+        });
+    });
+}
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params
+{
+    return std::make_shared<facebook::react::NativeMediaControlsSpecJSI>(params);
+}
+
+@end

package/lib/module/NativeMediaControls.js

@@ -0,0 +1,7 @@
+"use strict";
+
+import { TurboModuleRegistry } from 'react-native';
+// Event types
+export const ALL_MEDIA_EVENTS = ['play', 'pause', 'stop', 'skipToNext', 'skipToPrevious', 'seekForward', 'seekBackward', 'seek', 'shuffle', 'repeatMode'];
+export default TurboModuleRegistry.getEnforcing('MediaControls');
+//# sourceMappingURL=NativeMediaControls.js.map

package/lib/module/NativeMediaControls.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["TurboModuleRegistry","ALL_MEDIA_EVENTS","getEnforcing"],"sourceRoot":"..\\..\\src","sources":["NativeMediaControls.ts"],"mappings":";;AACA,SAASA,mBAAmB,QAAQ,cAAc;AAGlD;AACA,OAAO,MAAMC,gBAAgB,GAAG,CAC9B,MAAM,EACN,OAAO,EACP,MAAM,EACN,YAAY,EACZ,gBAAgB,EAChB,aAAa,EACb,cAAc,EACd,MAAM,EACN,SAAS,EACT,YAAY,CACJ;AAqCV,eAAeD,mBAAmB,CAACE,YAAY,CAAO,eAAe,CAAC","ignoreList":[]}

package/lib/module/index.js

@@ -0,0 +1,75 @@
+"use strict";
+
+import MediaControls, { ALL_MEDIA_EVENTS } from "./NativeMediaControls.js";
+import { EventEmitter } from 'fbemitter';
+const eventEmitter = new EventEmitter();
+let unsubscribe = null;
+const setUpNativeEventListener = () => {
+  if (unsubscribe) return;
+  unsubscribe = MediaControls.onEvent(event => {
+    const {
+      command,
+      seekPosition
+    } = event;
+    eventEmitter.emit(command, {
+      position: seekPosition
+    });
+  });
+};
+
+/**
+ * Updates the metadata for the current media track.
+ */
+export async function updateMetadata(metadata) {
+  return MediaControls.updateMetadata(metadata);
+}
+
+/**
+ * Stops the media notification and clears any ongoing playback state.
+ */
+export async function stopMediaNotification() {
+  return MediaControls.stopMediaNotification();
+}
+
+/**
+ * Activates or deactivates audio interruption handling.
+ */
+export async function enableAudioInterruption(enabled) {
+  return MediaControls.enableAudioInterruption(enabled);
+}
+
+/**
+ * Activates the audio session for media playback.
+ * Call this method before starting media playback to ensure proper Control Center integration.
+ */
+export function enableBackgroundMode(enabled) {
+  MediaControls.enableBackgroundMode(enabled);
+}
+export function setControlEnabled(name, enabled) {
+  if (!ALL_MEDIA_EVENTS.includes(name)) {
+    throw new Error(`Unknown media control event: ${name}`);
+  }
+  MediaControls.setControlEnabled(name, enabled);
+}
+
+/**
+ * Register an event listener for media control events.
+ */
+export function addEventListener(event, handler) {
+  setUpNativeEventListener();
+  return eventEmitter.addListener(event, handler);
+}
+
+/**
+ * Remove a specific event listener for media control events.
+ */
+export function removeAllListeners(event) {
+  if (event) {
+    eventEmitter.removeAllListeners(event);
+  } else {
+    ALL_MEDIA_EVENTS.forEach(e => eventEmitter.removeAllListeners(e));
+  }
+}
+
+// Export types
+//# sourceMappingURL=index.js.map