Menu

Lumen help

Integrate with Mesh Delivery SDK for iOS, iPadOS & tvOS

Mesh Delivery for Streaming can be easily integrated into your iOS app in just a few simple steps using our SDK for iOS. In this guide, we will show you how to integrate the Mesh Delivery SDK with your app for Apple devices.

Not into tutorials?  

Code Example

Framework installation

Mesh Delivery SDK is delivered as an Xcode framework and is available on Cocoapods.

CocoaPods

Note: Cocoapods 1.6.0 + is recommended

To integrate Lumen Mesh SDK into your Xcode project using CocoaPods, specify this in your Podfile:

                target 'MyApp' do
  use_frameworks!
  pod 'LumenMeshSDK'
end

Then, run the following command:

                pod install

Configuration

Disable app transport security

 

In the Project Navigator, right click on "Info.plist", and "Open as" → "Source Code". Add the following lines with the right parameters values.

                <key>NSAppTransportSecurity</key>
<dict>
  <key>NSAllowsArbitraryLoads</key>
  <true/>
</dict>

Set the Client Delivery Key


In the Project Navigator, right click on the main target "Info.plist", and "Open as" → "Source Code".
 

Add the following lines with the values of the right parameters:

                <key>DeliveryClient</key>
<dict>
  <key>Key</key>
  <string><delivery-client-key></string>
</dict>

Here, the key element contained in DeliveryClient refers to the deliveryClientKey that you will find in the Account section of the Mesh Delivery Dashboard. If you don't have a DeliveryClientKey, you can register for a free trial account on our website.

 

We strongly recommend to set the delivery client key in Info.plist. However, if not possible, it is also possible to pass your delivieryClientKey during the initialization step.

Code Integration

First, import the SDK.

                import LumenMeshSDK

SDK Initialization


Initialize the Delivery SDK from the AppDelegate.

                @main
class AppDelegate: UIResponder, UIApplicationDelegate {
  func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
    /*
     * If you can not add your Delivery Client Key in Info.plist
     * Call instead: LMDeliveryClient.initializeApp(withDeliveryKey: "<delivery-client-key>")
     */
    LMDeliveryClient.initializeApp()
    ...
  }

  ...
}

Bridge between your player and the LMDeliveryClient

 

In order to work correctly, the SDK instance uses a PlayerInteractor.

 

It is the component in charge of the interactions between the player and the SDK. It monitors Quality of Service (QoS) metrics and allows the SDK to behave accordingly.

 

When integrating the SDK, you are free to implement this component but we provide an implementation example PlayerInteractor that satisifies these requirements for AVPlayer in our sample integration.

Instantiate a LMDeliveryClient


Now that the SDK is initialized, you are able to create LMDeliveryClient instances.

 

Once your AVPlayer is up and ready, you will need to configure your LMDeliveryClient instance:

                func createDeliveryClient() -> LMDeliveryClient {
  return LMDeliveryClientBuilder.clientBuilder()
         /*
          * Set the player interactor to use
          * Check the bridge section to know more
          *
          * param: an instance of a class subclassing LMPlayerInteractorBase.
          */
         .playerInteractor(PlayerInteractor())
         /*
          * Build a LumenDeliveryClient instance
          *
          * param: String. The video stream url
          */
         .build(url)
}

Note: PlayerInteractor is referencing the bridge class from the previous step. The name maybe different in your case, but it must subclass LMPlayerInteractorBase

Start the SDK instance and get the final URL


Calling the start() method on the LMDeliveryClient instance will start the SDK.

 

While starting, the SDK will generate a new URL to leverage Mesh Delivery streaming capabilities. Once it has started, make sure to retrieve the final URL and instantiate an AVPlayerItem with it.

                var deliveryClient = createDeliveryClient()
deliveryClient.start();

guard let deliveryUrl = deliveryClient.localManifestURL else {
  fatalError("Local url manifest could not be generated")
}

let playerItem = AVPlayerItem(asset: AVURLAsset(url: deliveryUrl))

Play the stream


Start the player with the new url provided by the LMDeliveryClient and link it with the PlayerInteractor:

                let player = AVPlayer(playerItem: playerItem)
playerInteractor.linkPlayer(player!)

player?.play()

Hopefully, the video is playing as expected. Congrats!

 

 

Stop the SDK


Make sure to stop the LMDeliveryClient once you are done with the video. We recommend to put it in the viewDidDisappear(:bool) or any callback terminating the player lifecycle.

                self.deliveryClient.stop()

Additional Options

You can pass additional options when creating a LMDeliveryClient

                func createDeliveryClient() -> LMDeliveryClient {
  return LMDeliveryClientBuilder.clientBuilder()
         /*
          * Set the player interactor to use
          * Check the bridge section to know more
          *
          * param: an instance of a class subclassing LMPlayerInteractorBase.
          */
         .playerInteractor(PlayerInteractor())
         /*
          * Set Mesh property
          *
          * param: String
          */
         .meshProperty("MY_PROPERTY")
         /*
          * Set the Delivery Client Key
          * Is only required if it was not set in Info.plist
          * Will override the Info.plist DeliveryClientKey value
          *
          * param: String
          */
         .deliveryClientKey("<delivery-client-key>")
         /*
          * Set the content id
          * A string that identifies your content
          * By default, it uses the stream url
          *
          * param: String
          */
         .contentId("MY_CONTENT_ID")
         /*
          * Set the log level
          * See the "How to investigate?" to know more
          *
          * param: LumenLogLevel
          */
         .logLevel(.info)
          /*
           * Set latency in seconds
           *
           * param: Int
           */
         .latency(3)
         /*
          * Set a proxy server
          * Allows the use of a proxy server in the middle
          * Format is host:port
          *
          * params: String
          */
         .proxyServer("MY_PROXY_HOST:PORT")
         /*
          * Build a LumenDeliveryClient instance
          *
          * param: String. The video stream url
          */
         .build(url)
}

Troubleshooting

Enable logs


By default the log level is set to OFF. it can be overridden during a LMDeliveryClientPlugin Creation: 

                func createDeliveryClient() -> LMDeliveryClient {
  return LMDeliveryClientBuilder.clientBuilder()
         .playerInteractor(PlayerInteractor())
         .logLevel(.warning)
         .build(url)
}

You can also use LumenStatsView, a utils library that allows the display of Mesh Delivery information on the device. For more information, please follow the Monitoring Tools documentation.

 

Learn how you can configure Mesh Delivery for Android to best suit your needs