Develop Reference

How to automatically pass an argument to a function when it is called implicitly kotlin

maybe I phrased my question a little strange, but something became interesting to me.
Let's imagine that I have some Extension function:
fun Int.foo() {
TODO()
}
Suppose that I need to pass the context of the Fragment from which I call it to this function, in which case I would do it like this:
fun Int.foo(context: Context) {
TODO()
}
Here we are explicitly passing the Context of our Fragment to the function. However, I'm interested in the question - is it possible to somehow change this function so (or can it be called in some other way) so that I do not have to explicitly pass the Context?
I understand that I could do like this:
fun Fragment.foo() {
var context = this.context
}
...however, I need an Extension function just above Int, so this method is not suitable.
Are there any ways how this can be done?

I guess you're looking for context-dependent declarations that let you combine multiple receiver scopes:
context(Fragment)
fun Int.foo() {
check(context != null) // context is actually Fragments context
}
Keep in mind however this feature is still in experimental state so it requires opt in by adding -Xcontext-receivers to your compiler options.

The Int class is just a class for op with numbers
It doesn't make sense to contain a Context object
It is not possible to get context without passing it to the function
There are other ways, which is to create a static object for the application class
for example
class App : Application() {
companion object {
var app: App? = null
}
init {
app = this;
}
}
and then
fun Int.foo(){
val context=App.app
...
}

How to fix EpoxyModel does not work with PagingDataEpoxyController [Android(Kotlin)]

It works fine until PagingDataEpoxyController but when passing data to EpoxyModel the apk crashes. This is my code, plaese help me
#EpoxyModelClass
abstract class PostCommentModel : EpoxyModel() {
#EpoxyAttribute
lateinit var commentData : CommentData
override fun getDefaultLayout() : Int {
return R.layout.layout_comment_item
}
override fun bind(view: LayoutCommentBinding) {
super.bind(view)
view.profileName.text = commentData.username
...
}
}
class PostCommentController( private val context: Context ) : PagingDataEpoxyController<CommentData>() {
override fun buildItemModel(currentPosition: Int, item: CommentData?): EpoxyModel<*> {
return PostCommentModel()_
.id(item!!.id)
.commentData(item)
}
}
How to make Epoxymodel usable with PagingDataEpoxyController?, Thank you...

You should add your crash logs as well so that we can know for sure where the issue lies.
By the look of the code you provided, I am almost certain that you're having a NullPointerException so I will answer accordingly.
If you read the javadoc for PagingDataEpoxyController#buildItemModel, it mentions that it passes in null values as a way of telling you that you should supply your UI with some placeholders (in order to hint the users that more items are being loaded at the moment).
/**
* Builds the model for a given item. This must return a single model for each item. If you want
* to inject headers etc, you can override [addModels] function.
*
* If the `item` is `null`, you should provide the placeholder. If your [PagedList] is
* configured without placeholders, you don't need to handle the `null` case.
*/
abstract fun buildItemModel(currentPosition: Int, item: T?): EpoxyModel<*>
You're forcing a nullable value to be force-unwrapped even though Epoxy tells you that it may be null sometimes. Hence your app crashes with NullPointerException. You should never do a force-unwrap !! if you're not 100% sure that the value can not be null.
So instead of doing:
override fun buildItemModel(currentPosition: Int, item: CommentData?): EpoxyModel<*> {
return PostCommentModel()_
.id(item!!.id) // You are force unwrapping a nullable value here
.commentData(item)
}
you should be doing something like:
override fun buildItemModel(currentPosition: Int, item: CommentData?): EpoxyModel<*> {
return if (item != null) {
PostCommentModel()_
.id(item.id) // No need force-unwrapping now! We are safe from a NullPointerException
.commentData(item)
} else {
PlaceholderModel()_
.id("placeholder-$currentPosition")
}
}
Here we checked whether or not the item is null, and showed a Placeholder when it is.
I hope this helps you!

Making an abstract class in kotlin communicate its responsibilities better to its children

I've been considering a few solutions for reducing boilerplate in a large number of fragments that have the same patterns and workflows.
The best solution I've come up with is to abstract a lot of the standard tasks into an abstract class and then force the implementing fragments to override methods that determine the unique flavor for their particular context.
For the sake of providing an example, here's something I'm making up to illustrate the problem.
abstract class ContainsRepetiveBoilerPlate<T:View,U:InfoForView>:Fragment(){
fun performNinetyPercentOfTheWork(){//tedious stuff that's always the same}
val thingThatChildMightWantToAccess=mutableListOf<U>()
fun upDateUsefullThing(){//update thingThatChildMightWantToAccess}
abstract fun fullFillContractToBindViewToItsInformation(t:T,u:U)
}
Now the fragment will look like this:
class HasATTypeViewPopulatedFromAUTypeDataClass:ContainsRepetitiveBoilerplate<T,U>(){
override fun fullfillContractToBindViewToItsInformation(t:T,u:U){//for every view inside of T, give it values from u}
Setting aside just for one moment the why, of which there are many. I'm interested to know any hows for forcing the child to somehow acknowledge that it's aware of thingThatChildMightWantToAccess.
Likewise, what tools are available to force the child to call performNinetyPercentOfTheWork()?
I've seen a couple of good ideas surrounding making performNinetyPercentOfTheWork() include a call to an abstract fun. But it would be awesome if I could make the linter complain if the child never calls it.
Here's a really really stupid solution that isn't at all serious but would help you understand what I want to achieve.
abstract class ContainsRepetiveBoilerPlate<T:View,U:InfoForView>:Fragment(){
var hasBeenCalled=false
fun performNinetyPercentOfTheWork(){hasbeenCalled=true //do other stuff}
val thingThatChildMightWantToAccess=mutableListOf<U>()
fun upDateUsefullThing(){//update thingThatChildMightWantToAccess}
abstract fun fullFillContractToBindViewToItsInformation(t:T,u:U)
override fun onViewCreated(){
toBeInvokedDuringOnViewCreated()
if (!hasBeenCalled){throw Error("you need to call performNinetyPercentOfTheWork()"}
abstract fun toBeInvokedDuringOnViewCreated()
}
Ok, here's an even stupider example, solely for the sake of trying to illustrate the functionality that I want from the linter.
abstract class ContainsRepetiveBoilerPlate<T:View,U:InfoForView>:Fragment(){
var hasBeenCalled=false
fun performNinetyPercentOfTheWork(){hasbeenCalled=true //do other stuff}
val thingThatChildMightWantToAccess=mutableListOf<U>()
fun upDateUsefullThing(){//update thingThatChildMightWantToAccess}
abstract fun fullFillContractToBindViewToItsInformation(t:T,u:U)
abstract fun acknowledgeThatYouKnowAboutUsefullVariable():Boolean
}
You can see from these examples that I'm not being serious. I just really want for their to be a way for me to make my abstract class be more expressive about what it can provide to its children, and what liberties its taken to handle the child's responsibilities.

Your requirement of wanting the "linter" to complain about the fact that some code does not execute some other code (which is just another way of saying make the compiler complain) would require the compiler to know all possible paths of execution a program can take, and then you run into the halting problem.
So, the best you can hope for is run time errors or warnings. Where you implement something that checks that a particular thing has been done and if it has not error.
Or, make sure it happens with something like the template pattern.
Here is a generic inheritance example:
interface LifeCycleAware {
fun stage1()
}
abstract class LifeCycleTemplate : LifeCycleAware {
/**
* Implementations can access this state
*/
protected var stateFromStage1: String? = null
/**
* A template pattern implementation of the lifecycle hook.
*/
override fun stage1() {
startStage1()
doCustomStage1Stuff()
endStage1()
}
protected abstract fun doCustomStage1Stuff()
private fun startStage1() {
stateFromStage1 = "starting-stage-1"
}
private fun endStage1() {
stateFromStage1 = "ended-stage-1"
}
}
Or a more flexible composition example:
typealias InternalStep = (me: LifeCycleComposition) -> Unit
class LifeCycleComposition(
private val customStage1: InternalStep,
private val startStage1: InternalStep = { me -> me.stateFromStage1 = "starting-stage-1" },
private val endStage1: InternalStep = { me -> me.stateFromStage1 = "ended-stage-1" }
) : LifeCycleAware {
/**
* Implementations can access this state
*/
internal var stateFromStage1: String? = null
/**
* A template pattern implementation of the lifecycle hook.
*/
override fun stage1() {
startStage1(this)
customStage1(this)
endStage1(this)
}
}

How to test reading from/updating file in MVP?

I'm trying to change my app from having no design pattern to using MVP.
Originally I had the following code:
override fun onCreateInputView(): View {
//favoritesData is an instance variable, same with "Gson", "parser", "favorites", and "stringArrayListType"
favoritesData = File(filesDir, "favorites_data.json")
if (favoritesData.exists()) {
favorites = Gson.fromJson(parser.parse(FileReader(favoritesData)), stringArrayListType)
}
}
and
fun updateFavoritesFile() {
favoritesData.writeText(Gson.toJson(favorites))
}
After trying to use MVP I changed the code to:
class AnimeFaceKeyboardPresenter(val view : AnimeFaceKeyboardView, private val model : KeyboardModel = KeyboardModel()) : Presenter {
override fun onCreateInputView() {
model.favorites = view.loadFavoritesFile()
//At some point, call view.updateFavoritesFile(arrayListOf("test","test2"))
}
override fun onStartInputView() {
}
}
and the code in the activity itself to:
override fun loadFavoritesFile() : ArrayList<String> {
val favoritesData = File(filesDir, favoritesFileName)
var favorites = ArrayList<String>()
//"favorites" is no longer an instance variable
if (favoritesData.exists()) {
favorites = Gson.fromJson(parser.parse(FileReader(favoritesData)), stringArrayListType)
}
return favorites
}
override fun updateFavoritesFile(favorites: ArrayList<String>) {
File(filesDir, favoritesFileName).writeText(Gson.toJson(favorites))
}
override fun onCreateInputView(): View {
super.onCreateInputView()
presenter = AnimeFaceKeyboardPresenter(this)
presenter.onCreateInputView()
}
I'm not sure if I'm using MVP correctly, but if I am, how would I go about testing this code. For example - writing a test that calls updateFavoritesFile(arrayListOf("test1","test2")) and uses loadFavoritesFile() to check if the contents is as expected.

Well, you might want to relocate your file read and write to your model (they are associated with data which doesn't really belong in your view).
Then your test consists of instantiating your model object, and testing the methods which can be done without the view and presenter (simplifying the tests).
I would be very tempted to abstract your file as some form of "Repository" object that knows how to read and write strings (but you don't care where or how). You would pass the repository object to your model as a construction property. The advantage of this is that you can create a mock or fake Repository object which you can use to "feed" test data and examine written data, making testing that part of your model a little easier.
Don't forget, your view shouldn't have direct access to your model under MVP .. that would me more like MVC (one of the very few differences between MVP and MVC).

Kotlin, generics, and a function that may have no arguments

I'm trying to genericise the boilerplate around a very common pattern, and Kotlin brings me tantalisingly close.
I've built a class that serves as a listener manager, as follows:
class GenericListenerSupport <EventArgumentType, ListenerFunction: (EventArgumentType) -> Unit> {
private val listeners = mutableListOf<ListenerFunction>()
fun addListener(listener: ListenerFunction) {
listeners.add(listener)
}
fun removeListener(listener: ListenerFunction) {
listeners.remove(listener)
}
fun fireListeners(argument: EventArgumentType) {
listeners.forEach { it.invoke(argument) }
}
}
and it can be used as follows:
class ExampleWithArgument {
private val listenerSupport = GenericListenerSupport<String, (String)->Unit>()
fun exampleAdd() {
listenerSupport.addListener({ value -> System.out.println("My string: "+value)})
}
fun exampleFire() {
listenerSupport.fireListeners("Hello")
}
}
So far, so good. But what if the listener has no arguments? Or stretching even further, multiple parameters.
I can scrape through with this:
class ExampleWithNoArgument {
private val listenerSupport = GenericListenerSupport<Nothing?, (Nothing?)->Unit>()
fun exampleAdd() {
listenerSupport.addListener({ System.out.println("I've got no argument")})
}
fun exampleFiring() {
listenerSupport.fireListeners(null)
}
}
but it smells, and obviously it's no use for multiple parameters.
Is there a better way to pull this off? e.g. something supporting this concept:
private val listenerSupport = GenericListenerSupport<???, (String, Double)->Unit>()

Since your GenericListenerSupport declares a type parameter EventArgumentType and expects an instance of it in fun fireListeners(argument: EventArgumentType), I doubt you can support multiple arguments in a clean way. Instead, I'd suggest using a data class (which is not so much extra code), as a clean and type-safe way to wrap multiple values:
data class MyEvent(val id: String, val value: Double)
private val listenerSupport = GenericListenerSupport<MyEvent, (MyEvent) -> Unit>()
As to passing no value, you can also use Unit, the type that has exactly one value Unit:
listenerSupport.fireListeners(Unit)
The type system and resolution won't allow you to pass no argument where a single one is expected, but, as #Ruckus T-Boom suggested, you can make an extension to fire listeners with no value where Unit is expected:
fun GenericListenerSupport<Unit>.fireListeners() = fireListeners(Unit)
A bit off-topic, but I think you can simplify the type if you don't need custom function types and (EventArgumentType) -> Unit is sufficient:
class GenericListenerSupport<EventArgumentType> {
/* Just use `(EventArgumentType) -> Unit` inside. */
}