Métodos de extensión estática en Kotlin

¿Cómo define un método de extensión estática en Kotlin? ¿Es esto posible? Actualmente tengo un método de extensión como se muestra a continuación.

public fun Uber.doMagic(context: Context) {
    // ...
}

La extensión anterior se puede invocar en una instancia.

uberInstance.doMagic(context) // Instance method

pero cómo lo hago método estático como se muestra a continuación.

Uber.doMagic(context)         // Static or class method

Para lograrlo Uber.doMagic(context), puede escribir una extensión al objeto complementario de Uber(se requiere la declaración del objeto complementario):

class Uber {
    companion object {}
}

fun Uber.Companion.doMagic(context: Context) { }

Esto es lo que dice la documentación oficial:

Kotlin genera métodos estáticos para funciones a nivel de paquete. Kotlin también puede generar métodos estáticos para funciones definidas en objetos con nombre u objetos complementarios si anota esas funciones como @JvmStatic. Por ejemplo:

Métodos estáticos de Kotlin

class C {
  companion object {
    @JvmStatic fun foo() {}
    fun bar() {}
  }
}

Ahora, foo () es estático en Java, mientras que bar () no lo es:

C.foo(); // works fine
C.bar(); // error: not a static method

De hecho, tuve esta pregunta exacta hace 30 minutos, así que comencé a investigar y no pude encontrar ninguna solución o solución para esto, PERO mientras buscaba encontré esta sección en el sitio web de Kotlinglang que dice que:

Tenga en cuenta que las extensiones se pueden definir con un tipo de receptor anulable. Dichas extensiones se pueden invocar en una variable de objeto incluso si su valor es nulo.

Entonces tuve la idea más loca de todas, ¿por qué no definir una función de extensión con un receptor anulable (sin usar ese receptor) y luego llamarlo en un objeto nulo! Así que lo intenté y funcionó bastante bien, pero se veía tan feo. Fue así:

(null as Type?).staticFunction(param1, param2)

Así que hice eso creando un val en mi archivo de extensiones del tipo de receptor que tenía un valor nulo y luego lo usé en mi otra clase. Entonces, como ejemplo, así es como implementé una función de extensión "estática" para la Navigationclase en Android: En mi archivo NavigationExtensions.kt:

val SNavigation: Navigation? = null
fun Navigation?.createNavigateOnClickListener(@IdRes resId: Int, args: Bundle? = null, navOptions: NavOptions? = null,
                                                navigationExtras: Navigator.Extras? = null) : (View) -> Unit {
    //This is just implementation details, don't worry too much about them, just focus on the Navigation? part in the method declaration
    return { view: View -> view.navigate(resId, args, navOptions, navigationExtras) }
}

En el código que lo usa:

SNavigation.createNavigateOnClickListener(R.id.action_gameWonFragment_to_gameFragment)

Obviamente, este no es un nombre de clase, es solo una variable del tipo de clase que tiene un valor nulo. Esto es obviamente feo en el lado del creador de extensiones (porque tienen que crear la variable) y en el lado del desarrollador (porque tienen que usar el STypeformato en lugar del nombre de la clase real), pero es lo más cercano que se puede lograr en este momento en comparación con las funciones estáticas reales. Con suerte, los creadores de idiomas de Kotlin responderán al problema que se creó y agregarán esa característica en el idioma.

Puede crear un método estático con el uso de objetos complementarios como:

class Foo {
    // ...
    companion object {
        public fun bar() {
            // do anything
        }
    }
}

y luego puedes llamarlo así:

class Baz {
    // ...
    private fun callBar() {
        Foo.bar()
    }
}

Te recomiendo que mires este enlace. Como puede ver allí, solo debe declarar el método en el nivel superior del paquete (archivo):

package strings
public fun joinToString(...): String { ... }

Esto es igual a

package strings;

public class JoinKt {
    public static String joinToString(...) { ... }
}

Con constantes todo es igual. Esta declaración

val UNIX_LINE_SEPARATOR = "\n"

es igual a

public static final String UNIX_LINE_SEPARATOR = "\n";

También me gusta mucho tener la posibilidad de agregar métodos de extensión estática en Kotlin. Como solución alternativa por ahora, estoy agregando el método de extensión a varias clases en lugar de usar un método de extensión estática en todas ellas.

class Util    

fun Util.isDeviceOnline(context: Context): Boolean {
    val connMgr = context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
    val networkInfo = connMgr.activeNetworkInfo
    return networkInfo != null && networkInfo.isConnected
}

fun Activity.isDeviceOnline(context: Context) = { Util().isDeviceOnline(context) }
fun OkHttpClient.isDeviceOnline(context: Context) = { Util().isDeviceOnline(context) }

Para crear un método de extensión en kotlin, debe crear un archivo kotlin (no una clase) y luego declarar su método en el archivo Por ejemplo:

public fun String.toLowercase(){
    // **this** is the string object
}

Importe la función en la clase o archivo en el que está trabajando y utilícela.