Alin B.
07/26/2018, 12:02 PMclass Event(val actionId:Int, arg1:String, arg2: Int, arg3:MyClass, arg4:String)
but when I use the class, most likely I'll need Event(actionID, oneOfTheArgs)
Lucas Ł
07/26/2018, 12:06 PMclass Event<T> (val actionId:Int, val arg:T)
for more arguments
class Event<T1, T2> (val actionId:Int, val arg1:T1, val arg2:T2)
etc...Alin B.
07/26/2018, 12:11 PMclass Event(actionId, bundle)
Lucas Ł
07/26/2018, 12:12 PMAlin B.
07/26/2018, 12:12 PMclass Event(val actionId:Int, val args:ActionArgs)
Lucas Ł
07/26/2018, 12:14 PMAlin B.
07/26/2018, 12:20 PMopen class Event<out T>(val action:Int, val arg:T)
?Can Orhan
07/26/2018, 12:22 PMAlin B.
07/26/2018, 12:23 PMCan Orhan
07/26/2018, 12:25 PMdata class User(val userId: Int)
sealed class Event(actionId: Int) {
data class EventA(val name: String): Event(1)
data class EventB(val user: User, val someString: String): Event(2)
}
Alin B.
07/26/2018, 12:29 PMwhen(actionId){
id1-> read params and do something
id2 -> read params and do something
}
Can Orhan
07/26/2018, 12:32 PMval event:Event = Event.EventA("fas")
when(event) {
is Event.EventA -> {
event.name
}
is Event.EventB -> {
event.user.userId
}
}
Alin B.
07/26/2018, 12:32 PMBundle
is the simplest way as it can have any number of params, but as mentioned above by Lukasz, there are keys that I need to rememberCan Orhan
07/26/2018, 12:33 PMAlin B.
07/26/2018, 12:34 PMCan Orhan
07/26/2018, 12:35 PMAlin B.
07/26/2018, 12:35 PMCan Orhan
07/26/2018, 1:06 PMAlin B.
07/26/2018, 1:07 PMopen class Interaction<out T>(...
which is used like private val interactions= MutableLiveData<Interaction<Event>>()
then, I can't pass Event.EventA
to Interaction as it expects Event
typeCan Orhan
07/26/2018, 1:10 PMdata class User(val userId: Int)
sealed class Event(actionId: Int) {
data class EventA(val name: String): Event(1)
data class EventB(val user: User, val someString: String): Event(2)
}
class Interaction<out T>(val thing: T)
val event:Event = Event.EventA("fas")
val interaction = Interaction<Event>(Event.EventA("Test"))
Are you use your events are extending the base event?data class EventA(val name: String): Event(1)
Alin B.
07/26/2018, 1:18 PMdata class EventC():Event(3)
? Isn't this more resource intensive as it uses a empty class?Lucas Ł
07/26/2018, 1:19 PMEvent
instead (if actionId is always required)Can Orhan
07/26/2018, 1:20 PMAlin B.
07/26/2018, 1:21 PMclass Event(actionId, bundle)
Can Orhan
07/26/2018, 1:24 PMAlin B.
07/26/2018, 1:24 PMCan Orhan
07/26/2018, 1:25 PMEvent(actionId, null)
CtaClickEvent()
and CloseClickEvent()
instead of Event(747)
and Event(2112)
Alin B.
07/26/2018, 6:25 PMEvent(Actions.TAKE_PICTURE)
so it's more readable. However, I agree, Event(actionId, null)
does not look that well. I'll go on this path since it does indeed become very readable and does not depend on bundle.Can Orhan
07/26/2018, 6:29 PMEvent(Actions.TAKE_PICTURE)
Is certainly readable when creating the event but let's take the scenario where you want act on a list of different events. Suddenly, your simple when
statement is going to have a case for Event(Int)` with an if statement over the different `actionId`sAlin B.
07/26/2018, 6:34 PMCan Orhan
07/26/2018, 8:06 PMdata class User(val userId: Int)
sealed class Event(val actionId: Int) {
data class EventA(val name: String): Event(1)
data class EventB(val user: User, val someString: String): Event(2)
class GenericEvent: Event(3)
}
val user = User(3)
val eventsList = listOf(Event.EventA("Foo"), Event.EventB(user, "Bar"))
fun actOnEventUsingWith(event: Event) {
when(event){
is Event.EventA -> {
//Do something
}
is Event.EventB -> {
//Do something else
}
is Event.GenericEvent -> {
if (event.actionId == 4) {
//Hmmm
} else if (event.actionId == 5) {
//Hmmmmmmmm
}
}
}
}
fun actOnEventUsingWith(event: Event) {
when(event){
is Event.EventA -> {
//Do something
}
is Event.EventB -> {
//Do something else
}
is Event.BoringEvent -> {
}
is Event.AnotherEvent -> {
}
}
}
Alin B.
07/27/2018, 8:27 AM