Merge branch 'release/0.6.9'

Clappr.podspec

@@ -1,6 +1,6 @@
 Pod::Spec.new do |s|
   s.name             = "Clappr"
-  s.version          = "0.6.8"
+  s.version          = "0.6.9"
   s.summary          = "An extensible media player for iOS"
   s.homepage         = "http://clappr.io"
   s.license          = 'MIT'
@@ -11,7 +11,8 @@ Pod::Spec.new do |s|
     "Bruno Torres" => "[email protected]",
     "Fernando Pinho" => "[email protected]",
     "Uéliton Freitas" => "[email protected]",
-    "Augusto Boranga" => "[email protected]"
+    "Augusto Boranga" => "[email protected]",
+    "Cristian Madrid" => "[email protected]",
   }
 
   s.source           = { :git => "https://github.com/clappr/clappr-ios.git", :tag => s.version.to_s }

Clappr/Classes/Base/Core.swift

@@ -10,8 +10,7 @@ open class Core: UIBaseObject, UIGestureRecognizerDelegate {
     private (set) lazy var fullscreenController = FullscreenController(nibName: nil, bundle: nil)
 
     lazy var fullscreenHandler: FullscreenStateHandler = {
-        let handler: FullscreenStateHandler = self.optionsUnboxer.fullscreenControledByApp ? FullscreenByApp() : FullscreenByPlayer(core: self)
-        return handler
+        return self.optionsUnboxer.fullscreenControledByApp ? FullscreenByApp(core: self) : FullscreenByPlayer(core: self) as FullscreenStateHandler
     }()
 
     lazy var optionsUnboxer: OptionsUnboxer = OptionsUnboxer(options: self.options)
@@ -147,11 +146,6 @@ open class Core: UIBaseObject, UIGestureRecognizerDelegate {
 
     open func setFullscreen(_ fullscreen: Bool) {
         mediaControl?.fullscreen = fullscreen
-        if fullscreen {
-            fullscreenHandler.enterInFullscreen()
-        } else {
-            fullscreenHandler.exitFullscreen()
-        }
     }
 
     open func destroy() {

Clappr/Classes/Base/FullScreenStateHandler.swift

@@ -1,6 +1,9 @@
 protocol FullscreenStateHandler {
 
-    init()
+    var core: Core { get }
+    var isOnFullscreen: Bool { get }
+
+    init(core: Core)
 
     func enterInFullscreen(_: EventUserInfo)
     func enterInFullscreen()
@@ -18,53 +21,48 @@ extension FullscreenStateHandler {
     func exitFullscreen() {
         exitFullscreen([:])
     }
+
+    var isOnFullscreen: Bool {
+        return core.mediaControl?.fullscreen ?? false
+    }
 }
 
-class FullscreenByApp: BaseObject, FullscreenStateHandler {
+struct FullscreenByApp: FullscreenStateHandler {
 
-    required override init() {
-        super.init()
-    }
+    var core: Core
 
     func enterInFullscreen(_: EventUserInfo = [:]) {
-        trigger(Event.requestFullscreen.rawValue)
+        guard !isOnFullscreen else { return }
+        core.trigger(InternalEvent.userRequestEnterInFullscreen.rawValue)
     }
 
     func exitFullscreen(_: EventUserInfo = [:]) {
-        trigger(Event.exitFullscreen.rawValue)
+        guard isOnFullscreen else { return }
+        core.trigger(InternalEvent.userRequestExitFullscreen.rawValue)
     }
 }
 
-class FullscreenByPlayer: BaseObject, FullscreenStateHandler {
+struct FullscreenByPlayer: FullscreenStateHandler {
 
-    weak var core: Core?
-
-    required override init() {
-        super.init()
-    }
-
-    convenience init(core: Core) {
-        self.init()
-        self.core = core
-    }
+    var core: Core
 
     func enterInFullscreen(_: EventUserInfo = [:]) {
-        guard let core = core else { return }
-        trigger(InternalEvent.willEnterFullscreen.rawValue)
+        guard !isOnFullscreen else { return }
+        core.trigger(InternalEvent.willEnterFullscreen.rawValue)
         core.mediaControl?.fullscreen = true
         core.fullscreenController.view.backgroundColor = UIColor.black
         core.fullscreenController.modalPresentationStyle = .overFullScreen
         core.parentController?.present(core.fullscreenController, animated: false, completion: nil)
         core.fullscreenController.view.addSubviewMatchingConstraints(core)
-        trigger(InternalEvent.didEnterFullscreen.rawValue)
+        core.trigger(InternalEvent.didEnterFullscreen.rawValue)
     }
 
     func exitFullscreen(_: EventUserInfo = [:]) {
-        guard let core = core else { return }
-        trigger(InternalEvent.willExitFullscreen.rawValue)
+        guard isOnFullscreen else { return }
+        core.trigger(InternalEvent.willExitFullscreen.rawValue)
         core.mediaControl?.fullscreen = false
         core.parentView?.addSubviewMatchingConstraints(core)
         core.fullscreenController.dismiss(animated: false, completion: nil)
-        trigger(InternalEvent.didExitFullscreen.rawValue)
+        core.trigger(InternalEvent.didExitFullscreen.rawValue)
     }
 }

Clappr/Classes/Base/Player.swift

@@ -76,6 +76,7 @@ open class Player: BaseObject {
              Event.playing.rawValue, Event.didComplete.rawValue,
              Event.didPause.rawValue, Event.stalled.rawValue,
              Event.didStop.rawValue, Event.bufferUpdate.rawValue,
+             Event.requestFullscreen.rawValue, Event.exitFullscreen.rawValue,
              Event.positionUpdate.rawValue, Event.willPlay.rawValue,
              Event.willPause.rawValue, Event.willStop.rawValue,
              Event.airPlayStatusUpdate.rawValue, Event.seek.rawValue])
@@ -94,10 +95,10 @@ open class Player: BaseObject {
         self.core?.on(InternalEvent.didChangeActivePlayback.rawValue) { [weak self] _ in self?.bindPlaybackEvents() }
         self.core?.on(InternalEvent.didEnterFullscreen.rawValue) { [weak self] (info: EventUserInfo) in self?.forward(.requestFullscreen, userInfo: info) }
         self.core?.on(InternalEvent.didExitFullscreen.rawValue) { [weak self] (info: EventUserInfo) in self?.forward(.exitFullscreen, userInfo: info) }
+        self.core?.on(InternalEvent.userRequestEnterInFullscreen.rawValue) { [weak self] (info: EventUserInfo) in self?.forward(.requestFullscreen, userInfo: info) }
+        self.core?.on(InternalEvent.userRequestExitFullscreen.rawValue) { [weak self] (info: EventUserInfo) in self?.forward(.exitFullscreen, userInfo: info) }
 
         bindPlaybackEvents()
-
-        self.core?.render()
     }
 
     open func attachTo(_ view: UIView, controller: UIViewController) {

Clappr/Classes/Enum/InternalEvent.swift

@@ -14,4 +14,6 @@ public enum InternalEvent: String {
     case didNotLoadSource
     case willDestroy
     case didDestroy
+    case userRequestEnterInFullscreen
+    case userRequestExitFullscreen
 }

Clappr/Info.plist

@@ -15,7 +15,7 @@
 	<key>CFBundlePackageType</key>
 	<string>FMWK</string>
 	<key>CFBundleShortVersionString</key>
-	<string>0.6.8</string>
+	<string>0.6.9</string>
 	<key>CFBundleSignature</key>
 	<string>????</string>
 	<key>CFBundleVersion</key>

Example/ViewController.swift

@@ -7,26 +7,17 @@ class ViewController: UIViewController {
     var player: Player!
     var options: Options = [:]
 
+    var fullscreenByApp: Bool {
+        return options[kFullscreenByApp] as? Bool ?? false
+    }
+
     override func viewDidLoad() {
         super.viewDidLoad()
         player = Player(options: options)
 
         listenToPlayerEvents()
 
         player.attachTo(playerContainer, controller: self)
-        NotificationCenter.default.addObserver(self, selector: #selector(ViewController.rotated), name: NSNotification.Name.UIDeviceOrientationDidChange, object: nil)
-    }
-
-    deinit {
-        NotificationCenter.default.removeObserver(self)
-    }
-
-    func rotated() {
-        if UIDevice.current.orientation.isLandscape {
-            player.setFullscreen(true)
-        } else {
-            player.setFullscreen(true)
-        }
     }
 
     func listenToPlayerEvents() {
@@ -42,18 +33,20 @@ class ViewController: UIViewController {
 
         player.on(Event.error) { userInfo in print("on Error: \(String(describing: userInfo))") }
 
-        player.on(Event.requestFullscreen) { _ in print("on Enter Fullscreen") }
-
-        player.on(Event.exitFullscreen) { _ in print("on Exit Fullscreen") }
-
         player.on(Event.stalled) { _ in print("on Stalled") }
 
         player.on(Event.requestFullscreen) { _ in
-            self.player.setFullscreen(true)
+            Logger.logInfo("Entrar em modo fullscreen")
+            if self.fullscreenByApp {
+                self.player.setFullscreen(true)
+            }
         }
 
         player.on(Event.exitFullscreen) { _ in
-            self.player.setFullscreen(false)
+            Logger.logInfo("Sair do modo fullscreen")
+            if self.fullscreenByApp {
+                self.player.setFullscreen(false)
+            }
         }
     }
 
@@ -68,4 +61,10 @@ class ViewController: UIViewController {
     override var preferredInterfaceOrientationForPresentation: UIInterfaceOrientation { // swiftlint:disable:this variable_name
         return UIInterfaceOrientation.portrait
     }
+
+    func showAlert(with title: String, message: String) {
+        let alertViewController = UIAlertController(title: title, message: message, preferredStyle: .alert)
+        alertViewController.addAction(UIAlertAction(title: "ok", style: UIAlertActionStyle.default, handler: nil))
+        self.navigationController?.present(alertViewController, animated: true, completion: nil)
+    }
 }

Tests/CoreTests.swift

@@ -44,17 +44,13 @@ class CoreTests: QuickSpec {
                         let options: Options = [kFullscreen: true]
                         let core = Core(options: options)
                         core.parentView = UIView()
-
-                        self.expectation(forNotification: InternalEvent.didEnterFullscreen.rawValue, object: core.fullscreenHandler) { notification in
-                            return true
-                        }
-
-                        self.expectation(forNotification: InternalEvent.willEnterFullscreen.rawValue, object: core.fullscreenHandler) { notification in
-                            return true
+                        var callbackWasCall = false
+                        core.on(InternalEvent.didEnterFullscreen.rawValue) { _ in
+                            callbackWasCall = true
                         }
-
                         core.render()
-                        self.waitForExpectations(timeout: 2, handler: nil)
+                        expect(callbackWasCall).toEventually(beTrue())
+
                         expect(core.parentView?.subviews.contains(core)).to(beFalse())
                         expect(core.fullscreenController.view.subviews.contains(core)).to(beTrue())
                         expect(core.mediaControl?.fullscreen).to(beTrue())
@@ -70,23 +66,17 @@ class CoreTests: QuickSpec {
                     }
 
                     it("Should start as fullscreen video when `kFullscreen: true` and `kFullscreenByApp: false` was passed") {
-                        let options: Options = [kFullscreen: true]
-                        let core = Core(options: options)
-                        core.parentView = UIView()
-
-                        self.expectation(forNotification: InternalEvent.didEnterFullscreen.rawValue, object: core.fullscreenHandler) { notification in
-                            return true
-                        }
-
-                        self.expectation(forNotification: InternalEvent.willEnterFullscreen.rawValue, object: core.fullscreenHandler) { notification in
-                            return true
+                        let player = Player(options: [kFullscreen: true] as Options)
+                        var callbackWasCalled = false
+                        player.on(.requestFullscreen) { _ in
+                            callbackWasCalled = true
                         }
+                        player.attachTo(UIView(), controller: UIViewController())
+                        player.setFullscreen(true)
+                        expect(callbackWasCalled).toEventually(beTrue())
 
-                        core.render()
-                        self.waitForExpectations(timeout: 2, handler: nil)
-                        expect(core.parentView?.subviews.contains(core)).to(beFalse())
-                        expect(core.fullscreenController.view.subviews.contains(core)).to(beTrue())
-                        expect(core.mediaControl?.fullscreen).to(beTrue())
+                        expect(player.core!.parentView?.subviews.contains(core)).to(beFalse())
+                        expect(player.core!.mediaControl?.fullscreen).to(beTrue())
                     }
 
                 }