Méthodes d'extension statique dans Kotlin

Comment définir une méthode d'extension statique dans Kotlin? Est-ce seulement possible? J'ai actuellement une méthode d'extension comme indiqué ci-dessous.

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

L'extension ci-dessus peut être appelée sur une instance.

uberInstance.doMagic(context) // Instance method

mais comment puis-je en faire une méthode statique comme indiqué ci-dessous.

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

Pour ce faire Uber.doMagic(context), vous pouvez écrire une extension à l' objet compagnon de Uber(la déclaration d'objet compagnon est requise):

class Uber {
    companion object {}
}

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

Voici ce que dit la documentation officielle:

Kotlin génère des méthodes statiques pour les fonctions au niveau du package. Kotlin peut également générer des méthodes statiques pour les fonctions définies dans des objets nommés ou des objets compagnons si vous annotez ces fonctions comme @JvmStatic. Par exemple:

Méthodes statiques Kotlin

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

Maintenant, foo () est statique en Java, alors que bar () ne l'est pas:

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

En fait, j'avais cette question exacte il y a 30 minutes, alors j'ai commencé à fouiller et je n'ai pas trouvé de solution ou de contournement pour cela, MAIS en cherchant, j'ai trouvé cette section sur le site Web de Kotlinglang qui indique que:

Notez que les extensions peuvent être définies avec un type de récepteur Nullable. De telles extensions peuvent être appelées sur une variable objet même si sa valeur est nulle.

Alors j'ai eu l'idée la plus folle de tous les temps, pourquoi ne pas définir une fonction d'extension avec un récepteur nullable (sans utiliser réellement ce récepteur) et l'appeler ensuite sur un objet nul! Alors j'ai essayé ça, et ça a plutôt bien marché, mais ça avait l'air si moche. C'était comme ça:

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

J'ai donc contourné cela en créant un val dans mon fichier d'extensions du type de récepteur qui avait une valeur de null, puis je l'ai utilisé dans mon autre classe. Donc, à titre d'exemple, voici comment j'ai implémenté une fonction d'extension "statique" pour la Navigationclasse sous Android: Dans mon fichier 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) }
}

Dans le code qui l'utilise:

SNavigation.createNavigateOnClickListener(R.id.action_gameWonFragment_to_gameFragment)

Evidemment, ce n'est pas un nom de classe, c'est juste une variable du type de classe qui a une valeur nulle. C'est évidemment moche du côté des fabricants d'extensions (car ils doivent créer la variable) et du côté des développeurs (car ils doivent utiliser le STypeformat au lieu du nom de classe réel), mais c'est le plus proche qui peut être atteint maintenant par rapport aux fonctions statiques réelles. Espérons que les créateurs de langage Kotlin répondront au problème qui a été créé et ajouteront cette fonctionnalité dans la langue.

Vous pouvez créer une méthode statique en utilisant un objet Companion comme:

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

et ensuite vous pouvez l'appeler comme:

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

Je vous recommande de regarder ce lien. Comme vous pouvez le voir, vous devez simplement déclarer la méthode au niveau supérieur du package (fichier):

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

C'est égal à

package strings;

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

Avec constans, tout est pareil. Cette déclaration

val UNIX_LINE_SEPARATOR = "\n"

est égal à

public static final String UNIX_LINE_SEPARATOR = "\n";

J'aime aussi beaucoup avoir la possibilité d'ajouter des méthodes d'extension statiques dans Kotlin. Comme solution de contournement pour l'instant, j'ajoute la méthode d'extension à plusieurs classes au lieu d'utiliser une seule méthode d'extension statique dans chacune d'elles.

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) }

Pour créer une méthode d'extension dans kotlin, vous devez créer un fichier kotlin (pas une classe) puis déclarer votre méthode dans le fichier Ex:

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

Importez la fonction dans la classe ou le fichier sur lequel vous travaillez et utilisez-la.