MediaBrowserService with ExoPlayer and PlayerControlView – How to access to the player instance from the UI (PlayerControlView)?

MediaBrowserService with ExoPlayer and PlayerControlView – Accessing the Player Instance from the UI

Introduction

This article explores the interaction between a MediaBrowserService, ExoPlayer, and PlayerControlView. Specifically, we’ll focus on how to access the ExoPlayer instance from the PlayerControlView for UI control purposes.

Background

• MediaBrowserService: A background service managing media browsing and playback functionality, often used with Android’s MediaBrowser library.
• ExoPlayer: A powerful and flexible media player library for Android, enabling advanced playback features.
• PlayerControlView: A UI component responsible for displaying playback controls like play/pause, volume, and seek bar.

The Challenge

The core issue is bridging the gap between the PlayerControlView’s UI events (like button clicks) and the ExoPlayer instance running within the MediaBrowserService.

Solution: Inter-Process Communication (IPC)

The most effective approach is using Android’s Inter-Process Communication (IPC) mechanisms to establish a communication channel between the UI and the service.

1. Implementing a Binder Interface

• Create an interface that defines the methods for interacting with the ExoPlayer from the PlayerControlView.
• This interface will be implemented by the MediaBrowserService, acting as the server, and by the PlayerControlView, acting as the client.

// Interface defined in both service and UI
interface IPlayerControlService {
  void play();
  void pause();
  void seekTo(long position);
  // ... other playback control methods
}

2. MediaBrowserService Implementation

• Implement the `IPlayerControlService` interface within the MediaBrowserService.
• Use a `Binder` class to expose the service’s methods to the PlayerControlView.

class MyMediaBrowserService extends MediaBrowserService {
  // ...

  private class PlayerControlBinder extends Binder implements IPlayerControlService {
    @Override
    public void play() {
      exoPlayer.play();
    }

    @Override
    public void pause() {
      exoPlayer.pause();
    }

    // ... other methods implementation
  }

  private final PlayerControlBinder binder = new PlayerControlBinder();

  @Override
  public IBinder onBind(Intent intent) {
    return binder;
  }
}

3. PlayerControlView Implementation

• Bind the PlayerControlView to the MediaBrowserService.
• Implement `ServiceConnection` to receive a reference to the `IPlayerControlService` object.
• Use the service reference to invoke methods for controlling the ExoPlayer.

public class PlayerControlView extends LinearLayout implements View.OnClickListener {
  // ...

  private IPlayerControlService playerControlService;

  private ServiceConnection serviceConnection = new ServiceConnection() {
    @Override
    public void onServiceConnected(ComponentName name, IBinder service) {
      playerControlService = (IPlayerControlService) service;
    }

    @Override
    public void onServiceDisconnected(ComponentName name) {
      playerControlService = null;
    }
  };

  @Override
  public void onClick(View view) {
    switch (view.getId()) {
      case R.id.play_button:
        if (playerControlService != null) {
          playerControlService.play();
        }
        break;
      // ... handle other control button clicks
    }
  }

  public void bindService(Context context) {
    Intent intent = new Intent(context, MyMediaBrowserService.class);
    context.bindService(intent, serviceConnection, Context.BIND_AUTO_CREATE);
  }

  public void unbindService(Context context) {
    context.unbindService(serviceConnection);
  }
}

Explanation

• The `IPlayerControlService` interface acts as the contract for inter-process communication.
• The MediaBrowserService implements the interface and uses a `Binder` to make its methods accessible to the UI.
• The PlayerControlView binds to the service, retrieves the service reference, and uses it to invoke playback control methods.

Summary

This approach effectively enables UI controls (PlayerControlView) to directly manipulate the ExoPlayer instance running within the MediaBrowserService. It leverages Android’s IPC mechanisms to ensure reliable and robust communication between processes.