> For the complete documentation index, see [llms.txt](https://docs.firework.com/firework-for-developers/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.firework.com/firework-for-developers/android-sdk/integration-guide/fullscreen-player.md).

# Open Fullscreen Player

The `FireworkSdk.startPlayer()` method launches a fullscreen video player in a separate activity. This is useful when you want to play videos directly without embedding a FwVideoFeedView or FwStoryblock in your layout.

## Overview

Unlike `FwVideoFeedView` and `FwStoryBlockView`, which are embedded views, `FireworkSdk.startPlayer()` launches a standalone player activity that takes over the entire screen. This approach is ideal for:

* Opening specific videos from deep links
* Playing videos from custom UI elements (buttons, banners, etc.)
* Handling video notifications
* Creating custom video entry points

## Usage

`FireworkSdk.startPlayer()` has two variants:

### 1. Start Player with URL

Launch a specific video directly using its URL:

```kotlin
val viewOptions = ViewOptions.Builder()
    .playerOption(
        PlayerOption.Builder()
            .showShareButton(true)
            .enablePipMode(true)
            .build()
    )
    .build()

val result = FireworkSdk.startPlayer(
    viewOptions = viewOptions,
    url = "https://your-video-url"
)

when (result) {
    is PlayerLaunchResult.Success -> {
        // Player launched successfully
    }
    is PlayerLaunchResult.Failure -> {
        // Handle launch failure
        Log.e("Player", "Failed to launch player: ${result.message}")
    }
}
```

### 2. Start Player with Feed Configuration

Launch the player with a feed configuration, allowing users to browse through multiple videos:

```kotlin
val viewOptions = ViewOptions.Builder()
    .baseOption(
        BaseOption.Builder()
            .feedResource(FeedResource.Discovery)
            .build()
    )
    .playerOption(
        PlayerOption.Builder()
            .showShareButton(true)
            .enablePipMode(true)
            .build()
    )
    .build()

val result = FireworkSdk.startPlayer(viewOptions)

when (result) {
    is PlayerLaunchResult.Success -> {
        // Player launched successfully
    }
    is PlayerLaunchResult.Failure -> {
        // Handle launch failure
        Log.e("Player", "Failed to launch player: ${result.message}")
    }
}
```

## Using Kotlin DSL

For more concise syntax, use the DSL:

```kotlin
val viewOptions = viewOptions {
    baseOptions {
        feedResource(FeedResource.Discovery)
    }
    playerOptions {
        showShareButton(true)
        enablePipMode(true)
        autoPlayOnComplete(true)
    }
}

val result = FireworkSdk.startPlayer(viewOptions)
```

## Launch Result

Both variants return a `PlayerLaunchResult` that indicates success or failure:

```kotlin
sealed class PlayerLaunchResult {
    object Success : PlayerLaunchResult()
    class Failure(val message: String) : PlayerLaunchResult()
}
```

### Handling Results

```kotlin
when (val result = FireworkSdk.startPlayer(viewOptions, url)) {
    is PlayerLaunchResult.Success -> {
        // Player launched successfully
        // The player activity is now running
    }
    is PlayerLaunchResult.Failure -> {
        // Launch failed
        Toast.makeText(
            context,
            "Failed to open video: ${result.message}",
            Toast.LENGTH_SHORT
        ).show()
    }
}
```

## Configuration

The player can be configured using `ViewOptions`. Key options include:

### Player Appearance

```kotlin
val viewOptions = viewOptions {
    playerOptions {
        // Player mode
        playerMode(PlayerMode.FULL_BLEED_MODE)
        
        // UI elements
        showShareButton(true)
        showMuteButton(true)
        showFireworkLogo(false)
        
        // Playback behavior
        autoPlayOnComplete(true)
        autoplay(true)
    }
}
```

### Content Source

When not using a specific URL, configure the content source:

```kotlin
val viewOptions = viewOptions {
    baseOptions {
        // Discovery feed
        feedResource(FeedResource.Discovery)
        
        // Or specific playlist
        // feedResource(
        //     FeedResource.Playlist(
        //         channelId = "your_channel_id",
        //         playlistId = "your_playlist_id"
        //     )
        // )
    }
}
```

### Picture-in-Picture

Enable PIP mode to allow users to minimize the player:

```kotlin
val viewOptions = viewOptions {
    playerOptions {
        enablePipMode(true)
    }
}
```

## Player Launch Modes

You can configure the player activity launch mode:

```kotlin
// Set globally for all players
FireworkSdk.setPlayerLaunchMode(FwPlayerActivityLaunchMode.SINGLE_TASK)

// Then launch player
FireworkSdk.startPlayer(viewOptions)
```

Available launch modes:

* `SINGLE_TASK` - Standard single task launch mode
* `SINGLE_INSTANCE` - Single instance launch mode for complete isolation
* `SINGLE_TASK_WITH_OWN_AFFINITY` - Single task with custom affinity for separation

## Important Notes

* The SDK must be initialized before calling `startPlayer()`
* The player launches in a new activity, separate from your app's activity stack
* Always handle `PlayerLaunchResult.Failure` to provide user feedback
* ViewOptions can customize all aspects of player behavior
* The player handles its own lifecycle - no manual cleanup required
* URL variant is useful for specific videos, feed variant for browsing multiple videos

## Comparison with Other Widgets

| Feature                  | FwVideoFeedView | FwStoryBlockView | startPlayer()     |
| ------------------------ | --------------- | ---------------- | ----------------- |
| **Embedding**            | Embedded view   | Embedded view    | Separate activity |
| **Layout Control**       | Full control    | Full control     | No control        |
| **Thumbnail Display**    | Yes             | No               | No                |
| **Lifecycle Management** | Automatic       | Manual           | Automatic         |
| **Content Selection**    | User selects    | Auto-play        | Direct play       |
| **Return Result**        | No              | No               | Yes               |

## See Also

* [ViewOptions Configuration](/firework-for-developers/android-sdk/integration-guide/configuration.md) - Complete configuration options
* [PlayerOption](/firework-for-developers/android-sdk/integration-guide/configuration/player-options.md) - Player customization
* [BaseOption](/firework-for-developers/android-sdk/integration-guide/configuration/base-options.md) - Feed source configuration
* [Feed Sources](/firework-for-developers/android-sdk/integration-guide/feed-sources.md) - Available content sources