Skip to content

Commit f99839d

Browse files
dweinberdweinber
committed
Extract player event routing into PlayerEventDispatcher
Move the TimeChanged-vs-player routing out of BitmovinYospacePlayer's on/next/off overrides into a dedicated PlayerEventDispatcher, so the player delegates registration wholesale instead of branching inline.
1 parent da103bb commit f99839d

2 files changed

Lines changed: 96 additions & 52 deletions

File tree

‎yospace/src/main/java/com/bitmovin/player/integration/yospace/BitmovinYospacePlayer.kt‎

Lines changed: 18 additions & 52 deletions
Original file line numberDiff line numberDiff line change
@@ -41,7 +41,7 @@ import com.bitmovin.player.integration.yospace.policy.BitmovinYospacePlayerPolic
4141
import com.bitmovin.player.integration.yospace.policy.DefaultBitmovinYospacePlayerPolicy
4242
import com.bitmovin.player.integration.yospace.policy.YospacePlayerPolicy
4343
import com.bitmovin.player.integration.yospace.events.AdClickThroughReporter
44-
import com.bitmovin.player.integration.yospace.events.AdjustedTimeChangedDispatcher
44+
import com.bitmovin.player.integration.yospace.events.PlayerEventDispatcher
4545
import com.bitmovin.player.integration.yospace.events.YospaceAdStartedSnapshot
4646
import com.bitmovin.player.integration.yospace.events.YospaceEventEmitter
4747
import com.bitmovin.player.integration.yospace.events.YospacePlayerEvent
@@ -90,7 +90,7 @@ open class BitmovinYospacePlayer(
9090
private var isPlayingEventSent = false
9191
private var sourceConfig: SourceConfig? = null
9292
private var truexRenderer: BitmovinTruexAdRenderer? = null
93-
private val adjustedTimeChangedDispatcher = AdjustedTimeChangedDispatcher(player, ::getCurrentTimeMinusAd)
93+
private val playerEventDispatcher = PlayerEventDispatcher(player, ::getCurrentTimeMinusAd)
9494
private val yospacePlayerEventDispatcher = YospacePlayerEventDispatcher(yospaceEventEmitter)
9595
private val adClickThroughReporter = AdClickThroughReporter(yospaceEventEmitter)
9696

@@ -105,63 +105,29 @@ open class BitmovinYospacePlayer(
105105
yospacePlayerPolicy.playerPolicy = new
106106
}
107107

108-
override fun <E : BitmovinEvent> on(eventClass: KClass<E>, action: (E) -> Unit) {
109-
if (eventClass == PlayerEvent.TimeChanged::class) {
110-
adjustedTimeChangedDispatcher.on(eventClass, action)
111-
} else {
112-
player.on(eventClass, action)
113-
}
114-
}
108+
override fun <E : BitmovinEvent> on(eventClass: KClass<E>, action: (E) -> Unit) =
109+
playerEventDispatcher.on(eventClass, action)
115110

116-
override fun <E : BitmovinEvent> next(eventClass: KClass<E>, action: (E) -> Unit) {
117-
if (eventClass == PlayerEvent.TimeChanged::class) {
118-
adjustedTimeChangedDispatcher.next(eventClass, action)
119-
} else {
120-
player.next(eventClass, action)
121-
}
122-
}
111+
override fun <E : BitmovinEvent> next(eventClass: KClass<E>, action: (E) -> Unit) =
112+
playerEventDispatcher.next(eventClass, action)
123113

124-
override fun <E : BitmovinEvent> off(eventClass: KClass<E>, action: (E) -> Unit) {
125-
if (eventClass == PlayerEvent.TimeChanged::class) {
126-
adjustedTimeChangedDispatcher.off(eventClass, action)
127-
} else {
128-
player.off(eventClass, action)
129-
}
130-
}
114+
override fun <E : BitmovinEvent> off(eventClass: KClass<E>, action: (E) -> Unit) =
115+
playerEventDispatcher.off(eventClass, action)
131116

132-
override fun <E : BitmovinEvent> off(action: (E) -> Unit) {
133-
adjustedTimeChangedDispatcher.off(action)
134-
player.off(action)
135-
}
117+
override fun <E : BitmovinEvent> off(action: (E) -> Unit) =
118+
playerEventDispatcher.off(action)
136119

137-
override fun <E : BitmovinEvent> on(eventClass: Class<E>, eventListener: BitmovinEventListener<in E>) {
138-
if (eventClass == PlayerEvent.TimeChanged::class.java) {
139-
adjustedTimeChangedDispatcher.on(eventClass, eventListener)
140-
} else {
141-
player.on(eventClass, eventListener)
142-
}
143-
}
120+
override fun <E : BitmovinEvent> on(eventClass: Class<E>, eventListener: BitmovinEventListener<in E>) =
121+
playerEventDispatcher.on(eventClass, eventListener)
144122

145-
override fun <E : BitmovinEvent> next(eventClass: Class<E>, eventListener: BitmovinEventListener<in E>) {
146-
if (eventClass == PlayerEvent.TimeChanged::class.java) {
147-
adjustedTimeChangedDispatcher.next(eventClass, eventListener)
148-
} else {
149-
player.next(eventClass, eventListener)
150-
}
151-
}
123+
override fun <E : BitmovinEvent> next(eventClass: Class<E>, eventListener: BitmovinEventListener<in E>) =
124+
playerEventDispatcher.next(eventClass, eventListener)
152125

153-
override fun <E : BitmovinEvent> off(eventClass: Class<E>, eventListener: BitmovinEventListener<in E>) {
154-
if (eventClass == PlayerEvent.TimeChanged::class.java) {
155-
adjustedTimeChangedDispatcher.off(eventClass, eventListener)
156-
} else {
157-
player.off(eventClass, eventListener)
158-
}
159-
}
126+
override fun <E : BitmovinEvent> off(eventClass: Class<E>, eventListener: BitmovinEventListener<in E>) =
127+
playerEventDispatcher.off(eventClass, eventListener)
160128

161-
override fun <E : BitmovinEvent> off(eventListener: BitmovinEventListener<in E>) {
162-
adjustedTimeChangedDispatcher.off(eventListener)
163-
player.off(eventListener)
164-
}
129+
override fun <E : BitmovinEvent> off(eventListener: BitmovinEventListener<in E>) =
130+
playerEventDispatcher.off(eventListener)
165131

166132
@PublishedApi
167133
internal fun <E : YospacePlayerEvent> onYospacePlayerEvent(eventClass: KClass<E>, action: (E) -> Unit) =

‎yospace/src/main/java/com/bitmovin/player/integration/yospace/events/PlayerEventDispatcher.kt‎

Lines changed: 78 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,78 @@
1+
package com.bitmovin.player.integration.yospace.events
2+
3+
import com.bitmovin.player.api.Player
4+
import com.bitmovin.player.api.event.Event
5+
import com.bitmovin.player.api.event.EventListener
6+
import com.bitmovin.player.api.event.PlayerEvent
7+
import kotlin.reflect.KClass
8+
9+
/**
10+
* Routes player event registrations either to the [AdjustedTimeChangedDispatcher] (for
11+
* [PlayerEvent.TimeChanged], which is adjusted for Yospace ad time) or straight to the underlying
12+
* [Player]. Keeps the routing logic out of [com.bitmovin.player.integration.yospace.BitmovinYospacePlayer]
13+
* so it can delegate registration wholesale.
14+
*/
15+
internal class PlayerEventDispatcher(
16+
private val player: Player,
17+
currentTime: () -> Double
18+
) {
19+
private val adjustedTimeChanged = AdjustedTimeChangedDispatcher(player, currentTime)
20+
21+
fun <E : Event> on(eventClass: KClass<E>, action: (E) -> Unit) {
22+
if (eventClass == PlayerEvent.TimeChanged::class) {
23+
adjustedTimeChanged.on(eventClass, action)
24+
} else {
25+
player.on(eventClass, action)
26+
}
27+
}
28+
29+
fun <E : Event> next(eventClass: KClass<E>, action: (E) -> Unit) {
30+
if (eventClass == PlayerEvent.TimeChanged::class) {
31+
adjustedTimeChanged.next(eventClass, action)
32+
} else {
33+
player.next(eventClass, action)
34+
}
35+
}
36+
37+
fun <E : Event> off(eventClass: KClass<E>, action: (E) -> Unit) {
38+
if (eventClass == PlayerEvent.TimeChanged::class) {
39+
adjustedTimeChanged.off(eventClass, action)
40+
} else {
41+
player.off(eventClass, action)
42+
}
43+
}
44+
45+
fun <E : Event> off(action: (E) -> Unit) {
46+
adjustedTimeChanged.off(action)
47+
player.off(action)
48+
}
49+
50+
fun <E : Event> on(eventClass: Class<E>, eventListener: EventListener<in E>) {
51+
if (eventClass == PlayerEvent.TimeChanged::class.java) {
52+
adjustedTimeChanged.on(eventClass, eventListener)
53+
} else {
54+
player.on(eventClass, eventListener)
55+
}
56+
}
57+
58+
fun <E : Event> next(eventClass: Class<E>, eventListener: EventListener<in E>) {
59+
if (eventClass == PlayerEvent.TimeChanged::class.java) {
60+
adjustedTimeChanged.next(eventClass, eventListener)
61+
} else {
62+
player.next(eventClass, eventListener)
63+
}
64+
}
65+
66+
fun <E : Event> off(eventClass: Class<E>, eventListener: EventListener<in E>) {
67+
if (eventClass == PlayerEvent.TimeChanged::class.java) {
68+
adjustedTimeChanged.off(eventClass, eventListener)
69+
} else {
70+
player.off(eventClass, eventListener)
71+
}
72+
}
73+
74+
fun <E : Event> off(eventListener: EventListener<in E>) {
75+
adjustedTimeChanged.off(eventListener)
76+
player.off(eventListener)
77+
}
78+
}

0 commit comments

Comments
 (0)