Ziggeo's Swift SDK is the ultimate video recording/playback SDK out there.

Ziggeo's iOS Swift SDK is managed publicly on GitHub here.

Upgrading from v.1.0.6 to v.1.0.7

The update bring new serverAuthToken and clientAuthToken parameters in ziggeo.connect object (useful for global auth tokens).

Upgrading from v.1.0.5 to v.1.0.6

New changes bring new features without changing the entry or exit points of any methods or functions. You can safely upgrade without any changes to your existing codes.

Added feature:

Video recorder can be utilized with server_auth and client_auth auth tokens.
- To specify them for recorder you should use extraArgsForCreateVideo
Video player can be utilized with server_auth and client_auth auth tokens.
- To specify them for player you should use method described bellow

Setup

Create iOS App
Add ZiggeoSwiftFramework.framework
Add bridging header in case of mixed objective-C/Swift project
```
#import <ZiggeoSwiftFramework/ZiggeoSwiftFramework.h>
```
Make sure ZiggeoSwiftFramework.framework is added to Embedded Binaries and Linked Framework sections in your app target settings

Configure audio session in the AppDelegate

  func application(_ application: UIApplication, didFinishLaunchingWithOptions ...) {
      // Override point for customization after application launch.
      do {
          try AVAudioSession.sharedInstance().setCategory(AVAudioSessionCategoryPlayAndRecord, with: [AVAudioSessionCategoryOptions.duckOthers, AVAudioSessionCategoryOptions.defaultToSpeaker]);
      }
      catch {}
      return true
  }

Add NSCameraUsageDescription and NSMicrophoneUsageDescription sections into the info.plist file

Building/Packaging App

Grab framework from Swift-Client-SDK/Output/ directory. Use Swift 3.2 version for Xcode 9.0+, Swift 3.1 version for Xcode 8.3+ and Swift 3 for older Xcode versions
Add framework into "linked frameworks" and "embedded binaries" at the project build settings
Clean and rebuild the application

CocoaPods Support (optional)

Install CocoaPods
```
$ sudo gem install cocoapods
```
Create new iOS project
Init pods in the xcode project directory
```
$ pod init
```

Add framework to Podfile

pod 'ZiggeoSwiftSDK', :git => 'https://github.com/Ziggeo/Swift-Client-SDK.git', :branch => '1.0.0'

Install framework
```
$ pod install
```
Reopen the project using the .xcworkspace

Preparing App for the Submission to App Store

Create "new run script phase" at the application target build settings to strip the unused architectures. Use the script provided with the Swift-Client-SDK/TestApplication example (TestApplication target settings -> Build phases -> Run script section)

Basic Usage

Initialize Application

import ZiggeoSwiftFramework

var m_ziggeo: Ziggeo! = nil;
m_ziggeo = Ziggeo(token: "YOUR_APP_TOKEN_HERE");

Video Player

Initialization

func createPlayer()->AVPlayer {
   let player = ZiggeoPlayer(application: m_ziggeo, videoToken: "ZIGGEO_VIDEO_TOKEN");
   return player;
}

Initialization with optional authorization token

ZiggeoPlayer.createPlayerWithAdditionalParams(application: m_ziggeo, videoToken: "VIDEO_TOKEN", params: ["client_auth":"CLIENT_AUTH_TOKEN"]) { (player:ZiggeoPlayer?) in
    DispatchQueue.main.async {
        let playerController: AVPlayerViewController = AVPlayerViewController();
        playerController.player = player;
        self.present(playerController, animated: true, completion: nil);
        playerController.player?.play();
    }
}

Fullscreen Playback

@IBAction func playFullScreen(sender: AnyObject) {
    let playerController: AVPlayerViewController = AVPlayerViewController();
    playerController.player = createPlayer();
    self.presentViewController(playerController, animated: true, completion: nil);
    playerController.player?.play();
}

Embedded Playback

@IBAction func playEmbedded(sender: AnyObject) {
    //cleanup
    if m_embeddedPlayer != nil {
        m_embeddedPlayer.pause();
        m_embeddedPlayerLayer.removeFromSuperlayer();
        m_embeddedPlayer = nil;
        m_embeddedPlayerLayer = nil;
    }
    m_embeddedPlayer = createPlayer();
    m_embeddedPlayerLayer = AVPlayerLayer(player: m_embeddedPlayer);
    m_embeddedPlayerLayer.frame = videoViewPlaceholder.frame;
    videoViewPlaceholder.layer.addSublayer(m_embeddedPlayerLayer);
    m_embeddedPlayer.play();
}

Video Recorder

@IBAction func record(sender: AnyObject) {
    let recorder = ZiggeoRecorder(application: m_ziggeo);
    self.presentViewController(recorder, animated: true, completion: nil);
}

Enable Cover Selector Dialog

recorder.coverSelectorEnabled = true;

Enable Recorded Video Preview Dialog

recorder.recordedVideoPreviewEnabled = true;

Disable Camera Flip Button

recorder.cameraFlipButtonVisible = false;

Set Active Camera Device

recorder.cameraDevice = UIImagePickerControllerCameraDevice.Rear;

Additional Video Parameters (effects, profiles, etc)

recorder.extraArgsForCreateVideo = ["effect_profile": "12345"];

Authorization tokens

Recorder-level auth tokens:

    recorder.extraArgsForCreateVideo = ["client_auth" : "CLIENT_AUTH_TOKEN"];

Global (application-level) auth tokens:

    m_ziggeo.connect.clientAuthToken = "CLIENT_AUTH_TOKEN";

Advanced SDK Usage

Ziggeo API Access

You can use the SDK to access Ziggeo Server API methods in the async manner. The SDK provides the following functionality:

Create/remove/index videos
Custom Ziggeo Embedded Server API requests

All API methods work asynchronously and never block the calling thread. As an option, you may use custom callbacks (completion blocks) to receive results.

Videos API

Get Video Accessor Object

let videos = m_ziggeo.videos;

Get All Videos

videos.Index(nil) { (jsonArray, error) in
    NSLog("index error: \(error), response: \(jsonArray)");
};

Videos Delegate

class ViewController: UIViewController, ... ZiggeoVideosDelegate {
...
  //somewhere after initializing Ziggeo object
  m_ziggeo.videos.delegate = self;
...
}

Get Video Preparing to Upload Event After the Token Received

    public func videoPreparingToUpload(_ sourcePath: String, token: String) {
        NSLog("preparing to upload \(sourcePath) video with token \(token)");
    }

Get Video Preparing to Upload Event Before the Actual Token Received

    public func videoPreparingToUpload(_ sourcePath: String) {
        NSLog("preparing to upload \(sourcePath) video");
    }

Get Video Failed (or Cancelled) to Upload Event

    public func videoFailedToUpload(_ sourcePath: String) {
        NSLog("failed to upload \(sourcePath) video");
    }

Get Video Upload Started Event

    public func videoUploadStarted(_ sourcePath: String, token: String, backgroundTask: URLSessionTask) {
        NSLog("upload started with \(sourcePath) video and token \(token)");

        //capture the uploading task to be able to cancel it later using m_uploadingTask.cancel()
        m_uploadingTask = backgroundTask;
    }

Get Video Upload Complete Event

    public func videoUploadComplete(_ sourcePath: String, token: String, response: URLResponse?, error: NSError?, json:  NSDictionary?) {
        NSLog("upload complete with \(sourcePath) video and token \(token)");
    }

Get Video Upload Progress Report

    public func videoUploadProgress(_ sourcePath: String, token: String, totalBytesSent: Int64, totalBytesExpectedToSend:  Int64) {
        NSLog("upload progress is \(totalBytesSent) from total \(totalBytesExpectedToSend)");
    }

Create New Video

Basic

videos.CreateVideo(nil, file: fileToUpload.path!, cover: nil, callback: nil, progress: nil);

Advanced

Add custom completion/progress callbacks here to make the SDK inform your app about uploading progress and response. Cover image is optional -- Ziggeo can generate default video cover shot.

videos.CreateVideo(nil, file: fileToUpload.path!, cover: UIImage?, callback: { (jsonObject, response, error) in
    //update ui
}, progress: { (totalBytesSent, totalBytesExpectedToSend) in
    //update progress ui
})

Delete video

videos.DeleteVideo("YOUR_VIDEO_TOKEN", callback: { (responseData, response, error) in
    //update ui
})

Retrieve Video URL to Use in Custom Player

let url = videos.GetURLForVideo("YOUR_VIDEO_TOKEN_HERE"))

Remote video thumbs are cached on client side, so you can call the method as frequently as you wish without the performance or network load impact

videos.GetImageForVideo("YOUR_VIDEO_TOKEN_HERE", callback: { (image, response, error) in
    //update UI with the received image
})

Local video thumbs are cached on client side, so you can call the method as frequently as you wish without the performance impact

self.application.videos.GetImageForLocalVideo("LOCAL_VIDEO_PATH", callback: { (image, error) in
    //update UI with the received image
})

Custom Ziggeo API Requests

The SDK provides an opportunity to make custom requests to Ziggeo Embedded Server API. You can make POST/GET/custom_method requests and receive RAW data, json-dictionary or string as the result.

Get API Accessor Object

let connection = self.application.connect;

Make POST Request and Parse JSON Response

connection.PostJsonWithPath(path, data: NSDictionary?, callback: { (jsonObject, response, error) in
//jsonObject contains parsed json response received from Ziggeo API Server
})

Make POST Request and Get RAW Data Response

connection.PostWithPath(path: String, data: NSDictionary?, callback: { (data, response, error) in
//data contains RAW data received from Ziggeo API Server
})

Make GET Request and Get String Response

connection.GetStringWithPath(path: String, data: NSDictionary?, callback: { (string, response, error) in
    //the string contains stringified response received from Ziggeo API Server
})

We also have an Objective C SDK, see here.
We also have an Android SDK, see here.
For a list of features, see here.

Documentation

iOS Swift SDK