Skip to content

Latest commit

 

History

History
233 lines (183 loc) · 6.3 KB

README.md

File metadata and controls

233 lines (183 loc) · 6.3 KB
Raw

YTLiveStreaming

YTLiveStreaming is an open source iOS framework to create live broadcasts and video streams on YouTube using YouTube Live Streaming API (YouTube Data API v3)

Requirements

  • Xcode 13+
  • Swift 5.0

Introduction

  • fill Application Homepage link and Application Privacy Policy link. Submit for verification

  • as result you will have API_KEY and CLIENT_ID which will be used in Config.plist your iOS app later.

Installation

CocoaPods

CocoaPods is a dependency manager for Cocoa projects. You can install it with the following command:

$ gem install cocoapods

CocoaPods 1.1.0+ is required to build YTLiveStreaming

To integrate YTLiveStreaming into your Xcode project using CocoaPods, specify it in your Podfile:

source 'https://github.com/CocoaPods/Specs.git'
platform :ios, '13.0'
use_frameworks!

target '<Your Target Name>' do
    pod 'YTLiveStreaming'
end

Then, run the following command:

$ pod install

Swift Package Manager

To integrate YTLiveStreaming package using Apple's Swift package manager

  • open your Xcode project
  • select File - Add packages...
  • in the Apple Swift Packages screen select 'Search or Enter Package URL'
  • enter https://github.com/SKrotkih/YTLiveStreaming.git
  • make sure YTLiveStreaming is opened
  • press 'Add Package'
  • Xcode creates 'Package Pependencies' group with YTLiveStreaming package with last version
  • open your Xcode project settings - PROJECT section on the Package Dependencies tab
  • make sure the YTLiveStreaming package name is presented there

User guide

[YouTube Live Streaming API Reference](https://developers.google.com/youtube/v3/live/docs) 

import YTLiveStreaming

...

let input: YTLiveStreaming = YTLiveStreaming

...

// Get broadcasts list
let broadcastList = await input.getBroadcastListAsync()

// Get all events in different arrays of the LiveBroadcastStreamModel type
input.getAllBroadcasts(){ (upcomingEvents, liveNowEvents, completedEvents) in
   ...
}

// Get events separately:

// Get Ready to broadcast events
input.getUpcomingBroadcasts() { result in
      switch result {
          case .success(let upcomingEvents):
            ...
          case .failure(let error):
            ...
      }    
} 

// Get Live now broadcasts
input.getLiveNowBroadcasts() ( result in
      switch result {
          case .success(let  liveNowEvents):
              ...
          case .failure(let error):
              ...
      }
} 

// Get Completed broadcasts
input.getCompletedBroadcasts() ( result in
         switch result {
             case .success(let completedEvents):
                 ...
             case .failure(let error):
                 ...
         }
   } 

// Create Broadcast
input.createBroadcast(title, description: description, startTime: startDate, completion: { liveBroadcast in
   if let liveBroadcast = liveBroadcast {
      ...
   }
})

// Update of the existing broadcast: LiveBroadcastStreamModel
input.updateBroadcast(broadcast, completion: { success in
    if success {
       ...
    }      
})

// Start broadcast streaming video
input.startBroadcast(broadcast, delegate: self, completion: { streamName, streamUrl, _ in
   if let streamName = streamName, let streamUrl = streamUrl {
     completion(streamUrl, streamName)
   }
})

// Finish broadcast streaming video
input.completeBroadcast(broadcast, completion: { success in
   if success {
      ...
   }
})

// Delete all broadcast from the USER's account
if await input.deleteAllBroadcastsAsync() {
    // all broadcasts are deleted
}

// Delete broadcasts by IDs
if await input.deleteBroadcastsAsync(broadcastIDs) {
    // all broadcasts by IDs are deleted
}

// Delete broadcast by ID   
input.deleteBroadcast(id: broadcastId, completion: { success in
    if success {
       ...
    }
})

And some other public methods of the YTLiveStreaming class

Example of using YTLiveStreaming Framework

LiveEvents is an example of using the framework

Libraries Used

  • SwiftyJSON
  • Moya
  • KeychainAccess

Note. Here were used the following things:

The project was created 11-11-2016

Changes history: 27.12.2022

  • added async function to get broadcasts list
  • added async functions for deleting broadcasts 24.12.2022
  • build 0.2.36
  • create new public structure PostLiveBroadcastBody as insert broadcast request body 20-12-2022
  • build 0.2.29
  • update the project structure
  • add methods descriptions 19-12-2022
  • build 0.2.28
  • up to date all data structures
  • add descriptions for fields, requests, responses 25-07-2022
  • build 0.2.27 16-07-2022
  • build 0.2.26
  • package.swift was added 08-07-2022 Add ability to integrate the framework as a package 29-06-2022 Example project (LiveEvents) was removed from the project into a separate repo 14-06-2022
  • added Combine based method apart from RxSwift publisher subject to handle Google Sign-in results;
  • updated Google Sign-In according actual framework version;
  • implemented Google SignIn screen with using SwiftUI. 18-05-2021
  • added SwuftUI based content view for the YouTube video player 04-05-2021
  • added youtube-ios-player-helper as an video player
  • added Xcode unit test 15-03-2021
  • added Swiftlint
  • fixed Swiftlint warnings
  • Sample app was renamed to LiveEvents 29-04-2020
  • build 0.2.17
  • Sample app was redesigned
  • GoogleSignIn (used in the Sample app): up to 5.0.2