How to implement a zero argument constructor base class that dynamically creates objects and classes from caller?

Question

I have 4 classes that all implement a very similar block of code. The only difference is that each one needs to instantiate a separate Object and Myclass() at runtime. The below Action classes are a simplified version (real code is much longer).

Normally I would pass in arguments to create the object and class based on what the caller provides. However, due to the callback extension (which is androids ActionCallback to be specific), I am unable to pass in any parameters to the Action class.

What would be the best way of implementing a base class (like GenericAction() below) which adapts for the different object/class each time. This would be a single source of truth and prevent the copy and paste of Action classes ABCD four times.

class ActionA : ActionCallback {
    override suspend fun onAction(context: Context, glanceId: GlanceId, parameters: ActionParameters) {
        doSomething(context, ObjectA, glanceId)
        val constructSomething = MyClassA(context)
    }
}

class ActionB : ActionCallback {
    override suspend fun onAction(context: Context, glanceId: GlanceId, parameters: ActionParameters) {
        doSomething(context, ObjectB, glanceId)
        val constructSomething = MyClassB(context)
    }
}

class ActionC : ActionCallback {
    override suspend fun onAction(context: Context, glanceId: GlanceId, parameters: ActionParameters) {
        doSomething(context, ObjectC, glanceId)
        val constructSomething = MyClassC(context)
    }
}

class ActionD : ActionCallback {
    override suspend fun onAction(context: Context, glanceId: GlanceId, parameters: ActionParameters) {
        doSomething(context, ObjectD, glanceId)
        val constructSomething = MyClassD(context)
    }
}

class GenericAction<T>(myObject: Any, myClazz: Class<T>) : ActionCallback {
    override suspend fun onAction(context: Context, glanceId: GlanceId, parameters: ActionParameters) {
        doSomething(context, myObject, glanceId)
        val constructSomething = myClazz<T>(context)
    }
}

Answer 1

You can pass in parameters to ActionCallback.onAction using ActionParameters.

First, declare your parameter keys:

val myObjectKey = ActionParameters.Key<Any>("my-object-key")
val myClassKey = ActionParameters.Key<Class<*>>("my-class")

Then you can pass the parameters when you run your action:

// e.g. for ActionA
actionRunCallback<GenericAction>(
    parameters = actionParametersOf(
        myObjectKey to Object1
        myClassKey to ClassA::class.java
    )
)

where GenericAction is:

// the type parameter here is unnecessary - Android creates this class for you at runtime, 
// so there is nothing to know about T at compile time
class GenericAction : ActionCallback {
    override suspend fun onAction(context: Context, glanceId: GlanceId, parameters: ActionParameters) {
        val myObject = parameters[myObjectKey]
        val myClass = parameters[myClassKey]
        doSomething(context, myObject, glanceId)
        val constructSomething = myClass.getConstructor(Context::class.java).newInstance(context)
    }
}

---

Alternatively, your four specific Action classes can inherit GenericAction, and GenericAction can be made abstract.

abstract class GenericAction(myObject: Any, myClass: Class<*>) : ActionCallback {
    override suspend fun onAction(context: Context, glanceId: GlanceId, parameters: ActionParameters) {
        doSomething(context, myObject, glanceId)
        val constructSomething = myClass.getConstructor(Context::class.java).newInstance(context)
    }
}

class ActionA: GenericAction(Object1, ClassA::class)
class ActionB: GenericAction(Object2, ClassB::class)
class ActionC: GenericAction(Object3, ClassC::class)
class ActionD: GenericAction(Object4, ClassD::class)

You just need to give one of the ActionX subclasses to actionRunCallback, rather than GenericAction, e.g.

actionRunCallback<ActionA>()

This will work, as ActionA does have a parameterless constructor.