react-native-theoplayer 2.5.0 → 2.7.0

package/CHANGELOG.md

@@ -5,6 +5,30 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
 and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
 
+## [2.7.0] - 23-05-15
+
+### Changed
+
+- Approved player behaviour on iOS and Android when doing player operations such as `play` and `pause` in case no source was set.
+
+### Fixed
+
+- Fixed an issue on Android where if an invalid view tag is passed to the native bridge, it would crash the player.
+
+## [2.6.0] - 23-05-05
+
+### Fixed
+
+- Fixed an issue on Android where the `currentProgramDateTime` property of `TimeUpdateEvent` would not be formatted in milliseconds.
+- Fixed an issue on Android where the order of text and media tracks would change when adding tracks.
+- Fixed an issue on Web where an exception would be thrown when accessing the player API after the player had been destroyed.
+- Fixed an issue with Google IMA where the main content wasn't resumed after a pre-roll ended.
+
+### Changed
+
+- Use `enum` instead of a string union for `ABRStrategyType`.
+- Changed the way artwork is fetched for NowPlayingInfo on the iOS Lockscreen, to prevent a crash caused by threading issues.
+
 ## [2.5.0] - 23-04-26
 
 ### Added

package/android/src/main/java/com/theoplayer/PlayerEventEmitter.kt

@@ -338,7 +338,7 @@ class PlayerEventEmitter internal constructor(
 
     // Limit update rate.
     val dt = now - lastTimeUpdate
-    return timeUpdateRate == TimeUpdateRate.LIMITED_ONE_HZ && dt < 1e03 ||
+    return timeUpdateRate == TimeUpdateRate.LIMITED_ONE_HZ && dt < 1e3 ||
       timeUpdateRate == TimeUpdateRate.LIMITED_TWO_HZ && dt < 500 ||
       timeUpdateRate == TimeUpdateRate.LIMITED_THREE_HZ && dt < 333
   }
@@ -481,24 +481,17 @@ class PlayerEventEmitter internal constructor(
   }
 
   private fun activeAudioTrack(): MediaTrack<AudioQuality>? {
-    return if (playerView.player != null) activeTrack(
-      playerView.player!!.audioTracks
-    ) else null
+    return activeTrack(playerView.player?.audioTracks)
   }
 
   private fun activeVideoTrack(): MediaTrack<VideoQuality>? {
-    return if (playerView.player != null) activeTrack(
-      playerView.player!!.videoTracks
-    ) else null
+    return activeTrack(playerView.player?.videoTracks)
   }
 
   private fun <T : Quality?> activeTrack(tracks: MediaTrackList<T>?): MediaTrack<T>? {
-    tracks?.forEach { track ->
-      if (track.isEnabled) {
-        return track
-      }
+    return tracks?.first { track ->
+      track.isEnabled
     }
-    return null
   }
 
   private val onActiveQualityChanged = EventListener<QualityChangedEvent<*, *>> { event ->
@@ -642,13 +635,14 @@ class PlayerEventEmitter internal constructor(
           }
         })
     }
-    if (BuildConfig.EXTENSION_CAST && playerView.castApi != null) {
-      castEventAdapter = CastEventAdapter(playerView.castApi!!,
-        object : CastEventAdapter.Emitter {
+    if (BuildConfig.EXTENSION_CAST) {
+      castEventAdapter = playerView.castApi?.let {
+        CastEventAdapter(it, object : CastEventAdapter.Emitter {
           override fun emit(payload: WritableMap?) {
             receiveEvent(EVENT_CAST_EVENT, payload)
           }
         })
+      }
     }
   }
 

package/android/src/main/java/com/theoplayer/util/PayloadBuilder.kt

@@ -74,7 +74,8 @@ class PayloadBuilder {
     currentProgramDateTime?.let {
       payload.putDouble(
         EVENT_PROP_CURRENT_PROGRAM_DATE_TIME,
-        (1e03 * currentProgramDateTime.time).toLong().toDouble()
+        // Date.time is already formatted in msecs.
+        currentProgramDateTime.time.toDouble()
       )
     }
   }

package/android/src/main/java/com/theoplayer/util/ViewResolver.kt

@@ -1,9 +1,12 @@
 package com.theoplayer.util
 
+import android.util.Log
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.uimanager.UIManagerModule
 import com.theoplayer.ReactTHEOplayerView
 
+private const val TAG = "ViewResolver"
+
 class ViewResolver(private val reactContext: ReactApplicationContext) {
   private var uiManager: UIManagerModule? = null
 
@@ -12,7 +15,12 @@ class ViewResolver(private val reactContext: ReactApplicationContext) {
       uiManager = reactContext.getNativeModule(UIManagerModule::class.java)
     }
     uiManager?.addUIBlock {
-      onResolved(it.resolveView(tag) as ReactTHEOplayerView)
+      try {
+        onResolved(it.resolveView(tag) as ReactTHEOplayerView)
+      } catch (ignore: Exception) {
+        // The ReactTHEOplayerView instance could not be resolved: log but do not forward exception.
+        Log.w(TAG, "Failed to resolve ReactTHEOplayerView tag $tag")
+      }
     }
   }
 }

package/ios/THEOplayerRCTDebug.swift

@@ -1,16 +1,16 @@
 // THEOplayerRCTDebug.swift
 
 // General debug flag, if set to false none of the debug prints will appear
-let DEBUG = false
+let DEBUG = true
 
 // Debug flag to monitor incoming Theoplayer events
-let DEBUG_THEOPLAYER_EVENTS = DEBUG && false
+let DEBUG_THEOPLAYER_EVENTS = DEBUG && true
 
 // Debug flag to monitor eventhandler setup and breakdown
 let DEBUG_EVENTHANDLER = DEBUG && false
 
 // Debug flag to monitor the interactions for each view with its underlying theoplayer instance
-let DEBUG_THEOPLAYER_INTERACTION = DEBUG && false
+let DEBUG_THEOPLAYER_INTERACTION = DEBUG && true
 
 // Debug flag to monitor contentProtection integration handling
 let DEBUG_CONTENT_PROTECTION_API = DEBUG && false

package/ios/THEOplayerRCTMainEventHandler.swift

@@ -75,52 +75,52 @@ public class THEOplayerRCTMainEventHandler {
         
         // PLAY
         self.playListener = player.addEventListener(type: PlayerEventTypes.PLAY) { [weak self] event in
-            if DEBUG_THEOPLAYER_EVENTS { print("[NATIVE] Received PLAY event from THEOplayer") }
+            if DEBUG_THEOPLAYER_EVENTS { PrintUtils.printLog(logText: "[NATIVE] Received PLAY event from THEOplayer") }
             if let forwardedPlayEvent = self?.onNativePlay {
                 forwardedPlayEvent([:])
             }
         }
-        if DEBUG_EVENTHANDLER { print("[NATIVE] Play listener attached to THEOplayer") }
+        if DEBUG_EVENTHANDLER { PrintUtils.printLog(logText: "[NATIVE] Play listener attached to THEOplayer") }
         
         // PAUSE
         self.pauseListener = player.addEventListener(type: PlayerEventTypes.PAUSE) { [weak self] event in
-            if DEBUG_THEOPLAYER_EVENTS { print("[NATIVE] Received PAUSE event from THEOplayer") }
+            if DEBUG_THEOPLAYER_EVENTS { PrintUtils.printLog(logText: "[NATIVE] Received PAUSE event from THEOplayer") }
             if let forwardedPauseEvent = self?.onNativePause {
                 forwardedPauseEvent([:])
             }
         }
-        if DEBUG_EVENTHANDLER { print("[NATIVE] Pause listener attached to THEOplayer") }
+        if DEBUG_EVENTHANDLER { PrintUtils.printLog(logText: "[NATIVE] Pause listener attached to THEOplayer") }
         
         // SOURCE_CHANGE
         self.sourceChangeListener = player.addEventListener(type: PlayerEventTypes.SOURCE_CHANGE) { [weak self] event in
-            if DEBUG_THEOPLAYER_EVENTS { print("[NATIVE] Received SOURCE_CHANGE event from THEOplayer") }
+            if DEBUG_THEOPLAYER_EVENTS { PrintUtils.printLog(logText: "[NATIVE] Received SOURCE_CHANGE event from THEOplayer") }
             if let forwardedSourceChangeEvent = self?.onNativeSourceChange {
                 forwardedSourceChangeEvent([:])
             }
         }
-        if DEBUG_EVENTHANDLER { print("[NATIVE] SourceChange listener attached to THEOplayer") }
+        if DEBUG_EVENTHANDLER { PrintUtils.printLog(logText: "[NATIVE] SourceChange listener attached to THEOplayer") }
         
         // LOAD_START
         self.loadStartListener = player.addEventListener(type: PlayerEventTypes.LOAD_START) { [weak self] event in
-            if DEBUG_THEOPLAYER_EVENTS { print("[NATIVE] Received LOAD_START event from THEOplayer") }
+            if DEBUG_THEOPLAYER_EVENTS { PrintUtils.printLog(logText: "[NATIVE] Received LOAD_START event from THEOplayer") }
             if let forwardedLoadStartEvent = self?.onNativeLoadStart {
                 forwardedLoadStartEvent([:])
             }
         }
-        if DEBUG_EVENTHANDLER { print("[NATIVE] LoadStart listener attached to THEOplayer") }
+        if DEBUG_EVENTHANDLER { PrintUtils.printLog(logText: "[NATIVE] LoadStart listener attached to THEOplayer") }
         
         // READY_STATE_CHANGE
         self.readyStateChangeListener = player.addEventListener(type: PlayerEventTypes.READY_STATE_CHANGE) { [weak self] event in
-            if DEBUG_THEOPLAYER_EVENTS { print("[NATIVE] Received READY_STATE_CHANGE event from THEOplayer") }
+            if DEBUG_THEOPLAYER_EVENTS { PrintUtils.printLog(logText: "[NATIVE] Received READY_STATE_CHANGE event from THEOplayer") }
             if let forwardedReadyStateChangeEvent = self?.onNativeReadyStateChange {
                 forwardedReadyStateChangeEvent(["readyState": event.readyState.rawValue - 1]) // [1-5] (iOS only) => [0-4] (other platforms + RN)
             }
         }
-        if DEBUG_EVENTHANDLER { print("[NATIVE] ReadyStateChange listener attached to THEOplayer") }
+        if DEBUG_EVENTHANDLER { PrintUtils.printLog(logText: "[NATIVE] ReadyStateChange listener attached to THEOplayer") }
         
         // DURATION_CHANGE
         self.durationChangeListener = player.addEventListener(type: PlayerEventTypes.DURATION_CHANGE) { [weak self] event in
-            if DEBUG_THEOPLAYER_EVENTS { print("[NATIVE] Received DURATION_CHANGE event from THEOplayer") }
+            if DEBUG_THEOPLAYER_EVENTS { PrintUtils.printLog(logText: "[NATIVE] Received DURATION_CHANGE event from THEOplayer") }
             if let forwardedDurationChangeEvent = self?.onNativeDurationChange {
                 forwardedDurationChangeEvent(
                     [
@@ -129,11 +129,11 @@ public class THEOplayerRCTMainEventHandler {
                 )
             }
         }
-        if DEBUG_EVENTHANDLER { print("[NATIVE] DurationChange listener attached to THEOplayer") }
+        if DEBUG_EVENTHANDLER { PrintUtils.printLog(logText: "[NATIVE] DurationChange listener attached to THEOplayer") }
         
         // VOLUME_CHANGE
         self.volumeChangeListener = player.addEventListener(type: PlayerEventTypes.VOLUME_CHANGE) { [weak self, weak player] event in
-            if DEBUG_THEOPLAYER_EVENTS { print("[NATIVE] Received VOLUME_CHANGE event from THEOplayer") }
+            if DEBUG_THEOPLAYER_EVENTS { PrintUtils.printLog(logText: "[NATIVE] Received VOLUME_CHANGE event from THEOplayer") }
             if let wplayer = player,
                let forwardedVolumeChangeEvent = self?.onNativeVolumeChange {
                 forwardedVolumeChangeEvent(
@@ -144,11 +144,11 @@ public class THEOplayerRCTMainEventHandler {
                 )
             }
         }
-        if DEBUG_EVENTHANDLER { print("[NATIVE] VolumeChange listener attached to THEOplayer") }
+        if DEBUG_EVENTHANDLER { PrintUtils.printLog(logText: "[NATIVE] VolumeChange listener attached to THEOplayer") }
         
         // PROGRESS
         self.progressListener = player.addEventListener(type: PlayerEventTypes.PROGRESS) { [weak self, weak player] event in
-            //if DEBUG_THEOPLAYER_EVENTS { print("[NATIVE] Received PROGRESS event from THEOplayer") }
+            //if DEBUG_THEOPLAYER_EVENTS { PrintUtils.printLog(logText: "[NATIVE] Received PROGRESS event from THEOplayer") }
             if let wplayer = player,
                let forwardedProgressEvent = self?.onNativeProgress {
                 wplayer.requestSeekable(completionHandler: { seekableTimeRanges, error in
@@ -181,11 +181,11 @@ public class THEOplayerRCTMainEventHandler {
                 })
             }
         }
-        if DEBUG_EVENTHANDLER { print("[NATIVE] Progress listener attached to THEOplayer") }
+        if DEBUG_EVENTHANDLER { PrintUtils.printLog(logText: "[NATIVE] Progress listener attached to THEOplayer") }
         
         // TIME_UPDATE
         self.timeUpdateListener = player.addEventListener(type: PlayerEventTypes.TIME_UPDATE) { [weak self] event in
-            //if DEBUG_THEOPLAYER_EVENTS { print("[NATIVE] Received TIME_UPDATE event from THEOplayer") }
+            //if DEBUG_THEOPLAYER_EVENTS { PrintUtils.printLog(logText: "[NATIVE] Received TIME_UPDATE event from THEOplayer") }
             if let forwardedTimeUpdateEvent = self?.onNativeTimeUpdate {
                 let currentTime = event.currentTime * 1000                                                          // sec -> msec
                 let currentProgramDateTime = (event.currentProgramDateTime?.timeIntervalSince1970 ?? 0.0) * 1000    // sec -> msec
@@ -197,47 +197,47 @@ public class THEOplayerRCTMainEventHandler {
                 )
             }
         }
-        if DEBUG_EVENTHANDLER { print("[NATIVE] TimeUpdate listener attached to THEOplayer") }
+        if DEBUG_EVENTHANDLER { PrintUtils.printLog(logText: "[NATIVE] TimeUpdate listener attached to THEOplayer") }
         
         // PLAYING
         self.playingListener = player.addEventListener(type: PlayerEventTypes.PLAYING) { [weak self] event in
-            if DEBUG_THEOPLAYER_EVENTS { print("[NATIVE] Received PLAYING event from THEOplayer") }
+            if DEBUG_THEOPLAYER_EVENTS { PrintUtils.printLog(logText: "[NATIVE] Received PLAYING event from THEOplayer") }
             if let forwardedPlayingEvent = self?.onNativePlaying {
                 forwardedPlayingEvent([:])
             }
         }
-        if DEBUG_EVENTHANDLER { print("[NATIVE] Playing listener attached to THEOplayer") }
+        if DEBUG_EVENTHANDLER { PrintUtils.printLog(logText: "[NATIVE] Playing listener attached to THEOplayer") }
         
         // SEEKING
         self.seekingListener = player.addEventListener(type: PlayerEventTypes.SEEKING) { [weak self] event in
-            if DEBUG_THEOPLAYER_EVENTS { print("[NATIVE] Received SEEKING event from THEOplayer") }
+            if DEBUG_THEOPLAYER_EVENTS { PrintUtils.printLog(logText: "[NATIVE] Received SEEKING event from THEOplayer") }
             if let forwardedSeekingEvent = self?.onNativeSeeking {
                 forwardedSeekingEvent([:])
             }
         }
-        if DEBUG_EVENTHANDLER { print("[NATIVE] Seeking listener attached to THEOplayer") }
+        if DEBUG_EVENTHANDLER { PrintUtils.printLog(logText: "[NATIVE] Seeking listener attached to THEOplayer") }
         
         // SEEKED
         self.timeUpdateListener = player.addEventListener(type: PlayerEventTypes.SEEKED) { [weak self] event in
-            if DEBUG_THEOPLAYER_EVENTS { print("[NATIVE] Received SEEKED event from THEOplayer") }
+            if DEBUG_THEOPLAYER_EVENTS { PrintUtils.printLog(logText: "[NATIVE] Received SEEKED event from THEOplayer") }
             if let forwardedSeekedEvent = self?.onNativeSeeked {
                 forwardedSeekedEvent([:])
             }
         }
-        if DEBUG_EVENTHANDLER { print("[NATIVE] Seeked listener attached to THEOplayer") }
+        if DEBUG_EVENTHANDLER { PrintUtils.printLog(logText: "[NATIVE] Seeked listener attached to THEOplayer") }
         
         // ENDED
         self.endedListener = player.addEventListener(type: PlayerEventTypes.ENDED) { [weak self] event in
-            if DEBUG_THEOPLAYER_EVENTS { print("[NATIVE] Received ENDED event from THEOplayer") }
+            if DEBUG_THEOPLAYER_EVENTS { PrintUtils.printLog(logText: "[NATIVE] Received ENDED event from THEOplayer") }
             if let forwardedEndedEvent = self?.onNativeEnded {
                 forwardedEndedEvent([:])
             }
         }
-        if DEBUG_EVENTHANDLER { print("[NATIVE] Ended listener attached to THEOplayer") }
+        if DEBUG_EVENTHANDLER { PrintUtils.printLog(logText: "[NATIVE] Ended listener attached to THEOplayer") }
         
         // ERROR
         self.errorListener = player.addEventListener(type: PlayerEventTypes.ERROR) { [weak self] event in
-            if DEBUG_THEOPLAYER_EVENTS { print("[NATIVE] Received ERROR event from THEOplayer") }
+            if DEBUG_THEOPLAYER_EVENTS { PrintUtils.printLog(logText: "[NATIVE] Received ERROR event from THEOplayer") }
             if let forwardedErrorEvent = self?.onNativeError,
                let errorObject = event.errorObject
             {
@@ -253,20 +253,20 @@ public class THEOplayerRCTMainEventHandler {
                 )
             }
         }
-        if DEBUG_EVENTHANDLER { print("[NATIVE] Error listener attached to THEOplayer") }
+        if DEBUG_EVENTHANDLER { PrintUtils.printLog(logText: "[NATIVE] Error listener attached to THEOplayer") }
         
         // LOADED_DATA
         self.loadedDataListener = player.addEventListener(type: PlayerEventTypes.LOADED_DATA) { [weak self] event in
-            if DEBUG_THEOPLAYER_EVENTS { print("[NATIVE] Received LOADED_DATA event from THEOplayer") }
+            if DEBUG_THEOPLAYER_EVENTS { PrintUtils.printLog(logText: "[NATIVE] Received LOADED_DATA event from THEOplayer") }
             if let forwardedLoadedDataEvent = self?.onNativeLoadedData {
                 forwardedLoadedDataEvent([:])
             }
         }
-        if DEBUG_EVENTHANDLER { print("[NATIVE] LoadedData listener attached to THEOplayer") }
+        if DEBUG_EVENTHANDLER { PrintUtils.printLog(logText: "[NATIVE] LoadedData listener attached to THEOplayer") }
         
         // LOADED_META_DATA
         self.loadedMetadataListener = player.addEventListener(type: PlayerEventTypes.LOADED_META_DATA) { [weak self, weak player] event in
-            if DEBUG_THEOPLAYER_EVENTS { print("[NATIVE] Received LOADED_META_DATA event from THEOplayer") }
+            if DEBUG_THEOPLAYER_EVENTS { PrintUtils.printLog(logText: "[NATIVE] Received LOADED_META_DATA event from THEOplayer") }
             if let wplayer = player,
                let forwardedLoadedMetadataEvent = self?.onNativeLoadedMetadata {
                 let metadata = THEOplayerRCTTrackMetadataAggregator.aggregateTrackMetadata(player: wplayer)
@@ -274,44 +274,44 @@ public class THEOplayerRCTMainEventHandler {
                 forwardedLoadedMetadataEvent(metadata)
             }
         }
-        if DEBUG_EVENTHANDLER { print("[NATIVE] LoadedMetadata listener attached to THEOplayer") }
+        if DEBUG_EVENTHANDLER { PrintUtils.printLog(logText: "[NATIVE] LoadedMetadata listener attached to THEOplayer") }
         
         // RATE_CHANGE
         self.rateChangeListener = player.addEventListener(type: PlayerEventTypes.RATE_CHANGE) { [weak self] event in
-            if DEBUG_THEOPLAYER_EVENTS { print("[NATIVE] Received RATE_CHANGE event from THEOplayer") }
+            if DEBUG_THEOPLAYER_EVENTS { PrintUtils.printLog(logText: "[NATIVE] Received RATE_CHANGE event from THEOplayer") }
             if let forwardedRateChangeEvent = self?.onNativeRateChange {
                 forwardedRateChangeEvent(["playbackRate": event.playbackRate])
             }
         }
-        if DEBUG_EVENTHANDLER { print("[NATIVE] RateChange listener attached to THEOplayer") }
+        if DEBUG_EVENTHANDLER { PrintUtils.printLog(logText: "[NATIVE] RateChange listener attached to THEOplayer") }
         
         // WAITING
         self.waitingListener = player.addEventListener(type: PlayerEventTypes.WAITING) { [weak self] event in
-            if DEBUG_THEOPLAYER_EVENTS { print("[NATIVE] Received WAITING event from THEOplayer") }
+            if DEBUG_THEOPLAYER_EVENTS { PrintUtils.printLog(logText: "[NATIVE] Received WAITING event from THEOplayer") }
             if let forwardedWaitingEvent = self?.onNativeWaiting {
                 forwardedWaitingEvent([:])
             }
         }
-        if DEBUG_EVENTHANDLER { print("[NATIVE] Waiting listener attached to THEOplayer") }
+        if DEBUG_EVENTHANDLER { PrintUtils.printLog(logText: "[NATIVE] Waiting listener attached to THEOplayer") }
         
         // CAN_PLAY
         self.canPlayListener = player.addEventListener(type: PlayerEventTypes.CAN_PLAY) { [weak self] event in
-            if DEBUG_THEOPLAYER_EVENTS { print("[NATIVE] Received CAN_PLAY event from THEOplayer") }
+            if DEBUG_THEOPLAYER_EVENTS { PrintUtils.printLog(logText: "[NATIVE] Received CAN_PLAY event from THEOplayer") }
             if let forwardedCanPlayEvent = self?.onNativeCanPlay {
                 forwardedCanPlayEvent([:])
             }
         }
-        if DEBUG_EVENTHANDLER { print("[NATIVE] Waiting listener attached to THEOplayer") }
+        if DEBUG_EVENTHANDLER { PrintUtils.printLog(logText: "[NATIVE] Waiting listener attached to THEOplayer") }
         
         // PRESENTATION_MODE_CHANGE
         self.presentationModeChangeListener = player.addEventListener(type: PlayerEventTypes.PRESENTATION_MODE_CHANGE) { [weak self] event in
-            if DEBUG_THEOPLAYER_EVENTS || true { print("[NATIVE] Received PRESENTATION_MODE_CHANGE event from THEOplayer (to \(event.presentationMode._rawValue))") }
+            if DEBUG_THEOPLAYER_EVENTS || true { PrintUtils.printLog(logText: "[NATIVE] Received PRESENTATION_MODE_CHANGE event from THEOplayer (to \(event.presentationMode._rawValue))") }
             if let forwardedPresentationModeChangeEvent = self?.onNativePresentationModeChange,
                let presentationModeContext = self?.presentationModeContext {
                 forwardedPresentationModeChangeEvent(presentationModeContext.eventContextForNewPresentationMode(event.presentationMode))
             }
         }
-        if DEBUG_EVENTHANDLER { print("[NATIVE] PresentationModeChange listener attached to THEOplayer") }
+        if DEBUG_EVENTHANDLER { PrintUtils.printLog(logText: "[NATIVE] PresentationModeChange listener attached to THEOplayer") }
     }
     
     private func dettachListeners() {
@@ -322,115 +322,115 @@ public class THEOplayerRCTMainEventHandler {
         // PLAY
         if let playListener = self.playListener {
             player.removeEventListener(type: PlayerEventTypes.PLAY, listener: playListener)
-            if DEBUG_EVENTHANDLER { print("[NATIVE] Play listener dettached from THEOplayer") }
+            if DEBUG_EVENTHANDLER { PrintUtils.printLog(logText: "[NATIVE] Play listener dettached from THEOplayer") }
         }
         
         // PAUSE
         if let pauseListener = self.pauseListener {
             player.removeEventListener(type: PlayerEventTypes.PAUSE, listener: pauseListener)
-            if DEBUG_EVENTHANDLER { print("[NATIVE] Pause listener dettached from THEOplayer") }
+            if DEBUG_EVENTHANDLER { PrintUtils.printLog(logText: "[NATIVE] Pause listener dettached from THEOplayer") }
         }
         
         // SOURCE_CHANGE
         if let sourceChangeListener = self.sourceChangeListener {
             player.removeEventListener(type: PlayerEventTypes.SOURCE_CHANGE, listener: sourceChangeListener)
-            if DEBUG_EVENTHANDLER { print("[NATIVE] SourceChange listener dettached from THEOplayer") }
+            if DEBUG_EVENTHANDLER { PrintUtils.printLog(logText: "[NATIVE] SourceChange listener dettached from THEOplayer") }
         }
         
         // LOAD_START
         if let loadStartListener = self.loadStartListener {
             player.removeEventListener(type: PlayerEventTypes.LOAD_START, listener: loadStartListener)
-            if DEBUG_EVENTHANDLER { print("[NATIVE] LoadStart listener dettached from THEOplayer") }
+            if DEBUG_EVENTHANDLER { PrintUtils.printLog(logText: "[NATIVE] LoadStart listener dettached from THEOplayer") }
         }
         
         // READY_STATE_CHANGE
         if let readyStateChangeListener = self.readyStateChangeListener {
             player.removeEventListener(type: PlayerEventTypes.READY_STATE_CHANGE, listener: readyStateChangeListener)
-            if DEBUG_EVENTHANDLER { print("[NATIVE] ReadyStateChange listener dettached from THEOplayer") }
+            if DEBUG_EVENTHANDLER { PrintUtils.printLog(logText: "[NATIVE] ReadyStateChange listener dettached from THEOplayer") }
         }
         
         // DURATION_CHANGE
         if let durationChangeListener = self.durationChangeListener {
             player.removeEventListener(type: PlayerEventTypes.DURATION_CHANGE, listener: durationChangeListener)
-            if DEBUG_EVENTHANDLER { print("[NATIVE] DurationChange listener dettached from THEOplayer") }
+            if DEBUG_EVENTHANDLER { PrintUtils.printLog(logText: "[NATIVE] DurationChange listener dettached from THEOplayer") }
         }
         
         // PROGRESS
         if let progressListener = self.progressListener {
             player.removeEventListener(type: PlayerEventTypes.PROGRESS, listener: progressListener)
-            if DEBUG_EVENTHANDLER { print("[NATIVE] Progress listener dettached from THEOplayer") }
+            if DEBUG_EVENTHANDLER { PrintUtils.printLog(logText: "[NATIVE] Progress listener dettached from THEOplayer") }
         }
         
         // TIME_UPDATE
         if let timeUpdateListener = self.timeUpdateListener {
             player.removeEventListener(type: PlayerEventTypes.TIME_UPDATE, listener: timeUpdateListener)
-            if DEBUG_EVENTHANDLER { print("[NATIVE] TimeUpdate listener dettached from THEOplayer") }
+            if DEBUG_EVENTHANDLER { PrintUtils.printLog(logText: "[NATIVE] TimeUpdate listener dettached from THEOplayer") }
         }
         
         // PLAYING
         if let playingListener = self.playingListener {
             player.removeEventListener(type: PlayerEventTypes.PLAYING, listener: playingListener)
-            if DEBUG_EVENTHANDLER { print("[NATIVE] Playing listener dettached from THEOplayer") }
+            if DEBUG_EVENTHANDLER { PrintUtils.printLog(logText: "[NATIVE] Playing listener dettached from THEOplayer") }
         }
         
         // SEEKING
         if let seekingListener = self.seekingListener {
             player.removeEventListener(type: PlayerEventTypes.SEEKING, listener: seekingListener)
-            if DEBUG_EVENTHANDLER { print("[NATIVE] Seeking listener dettached from THEOplayer") }
+            if DEBUG_EVENTHANDLER { PrintUtils.printLog(logText: "[NATIVE] Seeking listener dettached from THEOplayer") }
         }
         
         // SEEKED
         if let seekedListener = self.seekedListener {
             player.removeEventListener(type: PlayerEventTypes.SEEKED, listener: seekedListener)
-            if DEBUG_EVENTHANDLER { print("[NATIVE] Seeked listener dettached from THEOplayer") }
+            if DEBUG_EVENTHANDLER { PrintUtils.printLog(logText: "[NATIVE] Seeked listener dettached from THEOplayer") }
         }
         
         // ENDED
         if let endedListener = self.endedListener {
             player.removeEventListener(type: PlayerEventTypes.ENDED, listener: endedListener)
-            if DEBUG_EVENTHANDLER { print("[NATIVE] Ended listener dettached from THEOplayer") }
+            if DEBUG_EVENTHANDLER { PrintUtils.printLog(logText: "[NATIVE] Ended listener dettached from THEOplayer") }
         }
         
         // ERROR
         if let errorListener = self.errorListener {
             player.removeEventListener(type: PlayerEventTypes.ERROR, listener: errorListener)
-            if DEBUG_EVENTHANDLER { print("[NATIVE] Error listener dettached from THEOplayer") }
+            if DEBUG_EVENTHANDLER { PrintUtils.printLog(logText: "[NATIVE] Error listener dettached from THEOplayer") }
         }
         
         // LOADED_DATA
         if let loadedDataListener = self.loadedDataListener {
             player.removeEventListener(type: PlayerEventTypes.LOADED_DATA, listener: loadedDataListener)
-            if DEBUG_EVENTHANDLER { print("[NATIVE] LoadedData listener dettached from THEOplayer") }
+            if DEBUG_EVENTHANDLER { PrintUtils.printLog(logText: "[NATIVE] LoadedData listener dettached from THEOplayer") }
         }
         
         // LOADED_META_DATA
         if let loadedMetadataListener = self.loadedMetadataListener {
             player.removeEventListener(type: PlayerEventTypes.LOADED_META_DATA, listener: loadedMetadataListener)
-            if DEBUG_EVENTHANDLER { print("[NATIVE] LoadedMetadata listener dettached from THEOplayer") }
+            if DEBUG_EVENTHANDLER { PrintUtils.printLog(logText: "[NATIVE] LoadedMetadata listener dettached from THEOplayer") }
         }
         
         // RATE_CHANGE
         if let rateChangeListener = self.rateChangeListener {
             player.removeEventListener(type: PlayerEventTypes.RATE_CHANGE, listener: rateChangeListener)
-            if DEBUG_EVENTHANDLER { print("[NATIVE] RateChange listener dettached from THEOplayer") }
+            if DEBUG_EVENTHANDLER { PrintUtils.printLog(logText: "[NATIVE] RateChange listener dettached from THEOplayer") }
         }
         
         // WAITING
         if let waitingListener = self.waitingListener {
             player.removeEventListener(type: PlayerEventTypes.WAITING, listener: waitingListener)
-            if DEBUG_EVENTHANDLER { print("[NATIVE] Waiting listener dettached from THEOplayer") }
+            if DEBUG_EVENTHANDLER { PrintUtils.printLog(logText: "[NATIVE] Waiting listener dettached from THEOplayer") }
         }
         
         // CAN_PLAY
         if let canPlayListener = self.canPlayListener {
             player.removeEventListener(type: PlayerEventTypes.CAN_PLAY, listener: canPlayListener)
-            if DEBUG_EVENTHANDLER { print("[NATIVE] CanPlay listener dettached from THEOplayer") }
+            if DEBUG_EVENTHANDLER { PrintUtils.printLog(logText: "[NATIVE] CanPlay listener dettached from THEOplayer") }
         }
         
         // PRESENTATION_MODE_CHANGE
         if let presentationModeChangeListener = self.presentationModeChangeListener {
             player.removeEventListener(type: PlayerEventTypes.PRESENTATION_MODE_CHANGE, listener: presentationModeChangeListener)
-            if DEBUG_EVENTHANDLER { print("[NATIVE] PresentationModeChange listener dettached from THEOplayer") }
+            if DEBUG_EVENTHANDLER { PrintUtils.printLog(logText: "[NATIVE] PresentationModeChange listener dettached from THEOplayer") }
         }
     }
 }