Design a Video Streaming App (YouTube / Netflix)

ABR streaming encodes the same video at multiple quality levels (240p to 4K) and splits each into short chunks (~4 s). The player monitors its download speed and buffer depth in real-time. When bandwidth drops, it switches to a lower-quality rendition for the next chunk — preventing the video from stalling. When bandwidth improves, it upgrades. Without ABR, a 4K stream would pause and buffer every few seconds on a congested network, while a 240p stream would waste the capacity of a fast connection. ABR gives the best possible quality at any given bandwidth condition, invisibly and automatically.

HLS was developed by Apple and uses Apple's FairPlay DRM — not natively supported on Android. DASH (Dynamic Adaptive Streaming over HTTP) is an open standard with full Widevine DRM support, which is Android's native DRM system. ExoPlayer supports DASH natively with excellent ABR algorithms. DASH also offers finer-grained segment control, supports more codec options (VP9, AV1, H.265), and has better multi-audio-track and subtitle support. The only reason to use HLS on Android is if the content server only provides HLS (common with AWS MediaConvert defaults) — ExoPlayer supports both.

ExoPlayer is expensive to create and buffers data in memory. If it lives in the Activity, a screen rotation destroys and recreates it — causing a brief stall, re-fetching the manifest, and losing the buffer. In the ViewModel, ExoPlayer survives configuration changes. The Activity only attaches/detaches PlayerView (the SurfaceView that renders frames) in onStart/onStop. The player keeps buffering and playing through the rotation. The position, buffer, and ABR state are all preserved seamlessly. The ViewModel's onCleared() is the right place to call player.release() — it's called only when the user genuinely leaves the screen.

Use MediaSessionService (Media3 / Jetpack Media) which keeps ExoPlayer alive in the background as a foreground service. Bind the Activity to the service. When the Activity goes to onStop, detach the PlayerView surface — ExoPlayer continues playing audio only (video decoder released to save power). The system shows a media notification with transport controls. The service handles audio focus changes (phone call → pause). When the user returns, the Activity re-binds and attaches the PlayerView — video resumes instantly because ExoPlayer never stopped. On Android 13+, request POST_NOTIFICATIONS permission for the media notification.

ExoPlayer's default AdaptiveTrackSelection uses two inputs: (1) Bandwidth estimate: measured as bytes downloaded per second across recent segments, with a conservative fraction applied (e.g., 75% of measured bandwidth) to avoid over-estimating; (2) Buffer health: how many seconds are buffered ahead. The algorithm selects the highest rendition whose bitrate is safely below the available bandwidth. It also enforces hysteresis — requiring bandwidth to sustain a higher quality for a minimum number of chunks before upgrading (prevents rapid oscillation). You can customise via DefaultBandwidthMeter or implement your own BandwidthMeter for platform-specific signal strength data.

ExoPlayer provides a DownloadManager and DownloadService API. Build a DownloadRequest with the manifest URI and the desired track selection (e.g., 720p video + English audio). Run DownloadService as a foreground service with a Wi-Fi constraint. The service downloads and stores all required segments in the app's internal storage. For DRM content, request an offline license via OfflineLicenseHelper and store the encrypted key. To play offline, use DownloadHelper.createMediaSource(downloadRequest, dataSourceFactory) — ExoPlayer loads from local storage transparently. Store download metadata (videoId, path, expiresAt, size) in Room for the Downloads screen.

Widevine is a DRM system built into Android's MediaDrm API. It has three security levels: L1 (hardware-enforced, required for HD/4K), L2, L3 (software, SD only). The flow: (1) ExoPlayer extracts the PSSH (Protection System Specific Header) from the encrypted DASH manifest; (2) It creates a key request and sends it to your license server with the user's auth token; (3) The license server validates entitlement and returns an encrypted content key; (4) MediaDrm decrypts the key in the device's TEE (Trusted Execution Environment); (5) The hardware video decoder uses the key to decrypt segments frame-by-frame — the key never appears in clear memory, making screen recording capture impossible at L1.

Call enterPictureInPictureMode(PictureInPictureParams.Builder().setAspectRatio(Rational(16, 9)).setSourceRectHint(playerViewRect).build()). The sourceRectHint gives the system the current bounds of the player for a smooth shrink animation. Add RemoteAction buttons (play/pause) via setActions(). Override onPictureInPictureModeChanged to hide/show UI controls. Declare android:supportsPictureInPicture="true" and android:configChanges="screenSize|smallestScreenSize|screenLayout|orientation" in the manifest — this prevents Activity recreation on PiP enter/exit. Auto-enter PiP on home button via setPictureInPictureParams with setAutoEnterEnabled(true) (Android 12+).

Save position in Room's watch_history table: videoId, resumePositionMs, totalDurationMs, lastWatchedAt. Write the position periodically (every 5–10 s) and on ViewModel.onCleared(). Avoid writing on every player position update — that's 60 writes/second. On play: query Room for the stored position, call player.seekTo(resumePositionMs) before prepare(). Show a "Resume from 12:34" chip if the position is more than 60 s in. The server can also store watch progress for cross-device sync — send the position in a background call every 30 s and on pause/stop.

ExoPlayer with MediaSessionService handles audio focus automatically when you call player.setAudioAttributes(AudioAttributes.DEFAULT, handleAudioFocus = true). When a phone call arrives: Android sends an audio focus loss event; ExoPlayer pauses automatically and lowers to silent. When the call ends: ExoPlayer resumes if it was playing (not paused by the user). For transient interruptions (navigation prompt): ExoPlayer ducks (lowers volume temporarily) and restores after the prompt. You don't need to write audio focus logic manually — setting handleAudioFocus = true delegates it to ExoPlayer's internal AudioFocusManager.

Surface detach (playerView.player = null) disconnects the rendering surface from ExoPlayer. ExoPlayer keeps playing and buffering, but video frames aren't rendered anywhere — only audio output continues. This is what you do in onStop when the app goes to background. Player release (player.release()) completely destroys the player: releases the audio/video decoder, closes the MediaDrm session, stops all background threads, and frees memory. This is done in ViewModel.onCleared() — only when the user truly leaves the screen. Calling release in onStop would destroy the buffer on every screen rotation, causing a 1–2 s stall on return.

DASH manifests include subtitle AdaptationSet entries (WebVTT or TTML format). ExoPlayer selects the preferred subtitle language via DefaultTrackSelector.Parameters.setPreferredTextLanguage("en"). To let the user switch: call player.currentTracks.groups and filter for TrackType.TEXT groups. Show available languages in a bottom sheet. On selection: trackSelector.buildUponParameters().setPreferredTextLanguage("fr").build(). Subtitles render in the SubtitleView inside PlayerView — style them via playerView.subtitleView?.setStyle(CaptionStyleCompat(...)) to match the app's font and colour scheme.

Time-to-first-frame (TTFF) is measured from player.prepare() to the first Player.STATE_READY callback. Key optimisations: (1) Start at 480p: configure ABR to begin at a lower quality, so the first buffer fills faster; upgrade quality once stable; (2) Manifest CDN: host the .mpd manifest on CDN edge nodes near users — a 50 ms manifest fetch vs 200 ms origin; (3) Pre-warm: start fetching the manifest (not segments) as soon as the user taps a thumbnail, before the player screen loads; (4) Reduce initial buffer: set bufferForPlaybackMs = 1500 — start playback after 1.5 s buffered rather than 15 s. Track TTFF as a P50/P95 metric in production analytics.

ExoPlayer supports playback speed natively: player.setPlaybackParameters(PlaybackParameters(speed = 1.5f)). This applies to both audio (pitch-corrected by default using SonicAudioProcessor so voices don't sound like chipmunks) and video. Show a speed picker in the player menu. Persist the user's preferred speed in SharedPreferences and restore it on each video. Note that at 2x, ABR needs more bandwidth to keep up with consumption — you may want to pre-buffer a larger window or force a slightly lower quality rendition at high speeds.

Acquire a WakeLock during video playback to prevent the CPU from sleeping and the network from disconnecting mid-stream. ExoPlayer can do this automatically: player.setWakeMode(C.WAKE_MODE_NETWORK) acquires both a partial WakeLock (CPU awake) and a Wi-Fi WakeLock (Wi-Fi stays connected) while playing. When the player pauses or releases, the lock is released automatically. Without this, Android may drop the Wi-Fi connection during playback on some devices, causing a network error. Declare WAKE_LOCK and CHANGE_WIFI_MULTICAST_STATE permissions in the manifest.

Use ViewPager2 with one Fragment per video. Maintain a pool of 2–3 ExoPlayer instances (not one per page — expensive). When a page becomes visible: assign a player to it, set media, call prepare() and play(). When a page is offscreen by 1 position: pause and queue for release. Pre-warm the next video by calling player.setMediaItem(nextItem); player.prepare() while the current video plays — ExoPlayer buffers it in background. Limit buffer to 20 s (maxBufferMs=20_000) since short videos are often <60 s total. This gives near-instant playback on swipe without loading all videos into memory.

Implement AnalyticsListener and register via player.addAnalyticsListener(myListener). Track: (1) onLoadStarted/onLoadCompleted → measure segment download time; (2) onPlaybackStateChanged → when state changes to STATE_BUFFERING, record timestamp; when back to STATE_READY, emit a rebuffer_event with duration; (3) onVideoSizeChanged → log quality switches; (4) onPlayerError → log error type and segment URL. Batch these events and send to your analytics backend every 30 s during playback and on stop. Key metrics to dashboard: stall rate (stall_seconds / total_play_seconds), TTFF P95, quality distribution, abandonment rate (quit before first frame).

Two layers of expiry: (1) DRM license expiry: the Widevine offline license has a built-in playback_duration_seconds and license_duration_seconds — set by the license server at download time. After expiry, ExoPlayer can't decrypt the segments even if they exist on disk; (2) Client-side enforcement: store expiresAt in Room's downloads table. On the Downloads screen, check expiry before showing the play button. Run a nightly WorkManager job that deletes expired download files and calls DownloadManager.removeDownload(downloadId). Show a countdown timer for rentals approaching expiry. On rental purchase, the server returns the expiry timestamp along with the manifest URL.

ExoPlayer's DefaultLoadErrorHandlingPolicy retries failed segment downloads with exponential backoff (1 s, 2 s, 4 s … up to a max). You can configure the retry count and whether to retry on 5xx vs 4xx errors. For CDN failover: provide a DataSource.Factory that tries the primary CDN URL first and falls back to a secondary origin URL on 4xx/5xx. This is done via a custom DataSource that catches HttpDataSourceException and rewrites the URL to the fallback host. ExoPlayer does not re-fetch the manifest on segment failure — implement LoadErrorHandlingPolicy.getFallbackSelectionFor to switch the CDN base URL in the manifest for subsequent requests.

ExoPlayer provides a TestExoPlayerBuilder and fake FakeMediaSource for unit testing without actual media. For integration tests: (1) Use MockWebServer to serve a real DASH manifest and fake segment responses; (2) Build an ExoPlayer with a custom FakeClock (to control time in buffer calculations); (3) Use player.addListener with a CountDownLatch waiting for STATE_READY; (4) Assert player.currentPosition, playbackState, and videoFormat?.height. For ABR testing: throttle MockWebServer's response rate and assert the player switched to a lower rendition. For DRM tests: mock the license server endpoint and verify the correct init data is sent.