tvOS/iOS Media Player: Seamless Streaming, Custom Controls

The constantly growing demand for interactive consumption of content has driven TV and mobile operating systems to become ever more sophisticated at breakneck speed, especially as concerns playing back media. Apple’s platform, its iOS and tvOS operating systems, offers powerful developer tools, particularly through Swift, to allow the creation of rich, responsive, highly customizable media players. Companies and developers who want to improve the user experience on Apple devices must leverage the right tools, programming languages like Swift, and effective development methodologies.

This article explores the creation of a robust media player on iOS and tvOS using Swift. From ensuring effortless playback to crafting custom control interfaces, we will walk you through the innovative features of Apple’s native frameworks, the best practices of iOS app development, and how professional Swift development services can help you craft compelling media experiences. Whether you’re an enterprise looking to deliver a high-quality video product or a developer enhancing playback features, this is what you need.

Swift Media Player: Why It Matters for Building

Apple’s language of choice, Swift, is performance-oriented, secure, and maintainable. When creating Apple media apps, Swift allows for rapid, stable, and scalable products. Employing an iOS Swift development team translates to having an app that meets the platform’s current guideline requirements and benefits from system features to the fullest.

Why Swift is the go-to choice:

• Type safety and optionals avoid common bugs during video buffering or network processing.
• Swift’s protocol-oriented model of programming is compatible with AVPlayer’s delegate methods.
• Asynchronous execution of code using Combine or Swift Concurrency simplifies streaming and background work.
• SwiftUI support in newer OS releases enables more effective construction of media interfaces using declarative UI syntax.

These features make media apps not only functional but also responsive and future-proof. A skilled Swift development agency provides seamless integration with native APIs, meaning improved stability and lower resource consumption.

Under the Hood: How We Fixed It

• Seamless Video Streaming and AVPlayer Integration: We integrated AVPlayer for smooth video playback across both TVOS and iPhone platforms. Key issues solved include:
• Efficient Video Streaming: Optimized video streaming from the server to ensure minimal buffering and low latency, providing users with a seamless viewing experience.
• Customizable Playback: Implemented features like cropping videos to a specific start time (e.g., 2 minutes), fast-forwarding, and rewinding through swipe gestures.
• Continuous Playback: Automatically started the next video once the current one finished, eliminating interruptions.
• Video Timeline and Contextual Metadata: The app displays timestamps (e.g., “00:50 – Children Playing”) to enhance user engagement with the content. This was achieved by:
• Time-based Metadata: Added metadata to videos that displayed specific details about the video content at given timestamps.
• Interactive UI: Designed an intuitive UI that displays these time markers for users to understand key moments in the video and navigate to them.
• Cross-Platform Compatibility and UI Consistency: To ensure consistent functionality across iPhone and TVOS:
• Unified Video Controls: Implemented gestures and controls that work seamlessly on both platforms (e.g., swipe gestures for fast-forward and rewind).
• UI/UX Optimization: Optimized the UI for both iPhone and TVOS, ensuring intuitive navigation and control over video playback.

A) Video Permission Management & Authentication

For managing video permissions and user authentication, we handle user sessions securely and ensure data access control:
Code Snippet:
// Authenticate and request permission for accessing video content
private func authenticateUser() {
    if !isUserLoggedIn() {
        promptLoginScreen()
    } else {
        fetchUserVideos()
    }
}
private func isUserLoggedIn() -> Bool {
    // Check if user is logged in
    return UserDefaults.standard.bool(forKey: “isLoggedIn”)
}
private func promptLoginScreen() {
    // Show login screen for user authentication
    let loginVC = LoginViewController()
    present(loginVC, animated: true, completion: nil)
}

B) Fetching Video Content and Storing Data

We fetch video data from the server and store the user’s watched videos for a smooth viewing experience:

1. Fetching Video Data from Server
   Using a network client, we retrieve the user’s video list, including metadata such as start time, duration, and video description.

Code Snippet:
// Fetch video data from server
private func fetchUserVideos() {
    let url = URL(string: “https://example.com/api/videos”)!
    let task = URLSession.shared.dataTask(with: url) { data, response, error in
        if let data = data {
            parseVideoData(data)
        } else {
            print(“Error fetching videos: \(String(describing: error))”)
        }
    }
    task.resume()
}

private func parseVideoData(_ data: Data) {
    // Parse JSON response and display videos to the user
    do {
        let decoder = JSONDecoder()
        let videos = try decoder.decode([Video].self, from: data)
        DispatchQueue.main.async {
            // Update UI with fetched videos
            self.updateVideoList(videos)
        }
    } catch {
        print(“Error parsing video data: \(error)”)

2. Storing Users’ Video History

We store the user’s video history and preferences locally, so their watched content is available even when offline.

Code Snippet:

// Save user video history locally
private func saveVideoHistory(video: Video) {
    var history = loadVideoHistory()
    history.append(video)
    UserDefaults.standard.set(try? PropertyListEncoder().encode(history), forKey: “videoHistory”)
}
private func loadVideoHistory() -> [Video] {
    guard let data = UserDefaults.standard.value(forKey: “videoHistory”) as? Data else {
        return []
    }
    return (try? PropertyListDecoder().decode([Video].self, from: data)) ?? []
}
    }
}

C) Handling Playback Control and Progress Updates on UI

We developed a system to provide real-time progress updates on video playback, allowing users to track their viewing progress:

• Updating Progress Bar

We implemented a progress bar that updates in real-time as the user watches the video:

Code Snippet:

// Update progress bar with video playback status
private func updateProgressBar(currentTime: CMTime, videoDuration: CMTime) {
    let progress = CMTimeGetSeconds(currentTime) / CMTimeGetSeconds(videoDuration)
    progressBar.setProgress(Float(progress), animated: true)
}

•  Real-Time Video Controls and Fast-Forward/Rewind

We enabled users to fast-forward or rewind the video with swipe gestures:

Code Snippet:

// Handle fast-forward and rewind with swipe gestures
func handleSwipeGesture(_ gesture: UISwipeGestureRecognizer) {
    let currentTime = player.currentTime()
    var newTime = currentTime
    if gesture.direction == .right {
        newTime = currentTime + CMTime(seconds: 10, preferredTimescale: 1)  // Fast-forward 10 seconds
    } else if gesture.direction == .left {
        newTime = currentTime – CMTime(seconds: 10, preferredTimescale: 1)  // Rewind 10 seconds
    }
    player.seek(to: newTime)
}

D) Real-Time Video Transition (Next Video Auto-Play)

To ensure an uninterrupted viewing experience, we implemented an automatic transition to the next video when one finishes:

Code Snippet:

// Play the next video after the current one finishes
func playerItemDidReachEnd(notification: Notification) {
    if let nextVideoURL = getNextVideoURL() {
        let nextPlayerItem = AVPlayerItem(url: nextVideoURL)
        player.replaceCurrentItem(with: nextPlayerItem)
        player.play()
    }
}
func getNextVideoURL() -> URL? {
    // Logic to get the next video URL from the queue or list
    return URL(string: “https://example.com/api/next-video”)
}

E) Handling User Interactions and UI Updates

We ensured that the user experience is intuitive by handling video controls, progress, and transitions effectively across both TVOS and iPhone.

Code Snippet:

// Handle user interaction to jump to a specific time in the video
@objc func jumpToSpecificTime(sender: UIButton) {
    let targetTime = CMTime(seconds: 50, preferredTimescale: 1) // Jump to 50 seconds
    player.seek(to: targetTime)}

F) Real-time player view in TVOS devices

Video Player and gesture integration example

•  Managed the necessary permission, rationalPermission and runtime permission handler.
• Fetch the required data API’s and store it.
• Handled the playback callbacks and real-time progress on UI.
• Managed the real-time video play and auto-play feature once the video ended.
• Managed the end users’ interactions on player and real-time effects based on the gesture tap.
• Real-time player view on iOS devices.
• Real-time player view in TVOS devices.