Métodos de extensão estática no Kotlin

Como você define um método de extensão estática no Kotlin? Isso é possível? Atualmente, tenho um método de extensão, como mostrado abaixo.

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

A extensão acima pode ser chamada em uma instância.

uberInstance.doMagic(context) // Instance method

mas como faço para torná-lo método estático, como mostrado abaixo.

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

Para conseguir Uber.doMagic(context), você pode gravar uma extensão no objeto complementar de Uber(a declaração do objeto complementar é necessária):

class Uber {
    companion object {}
}

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

É o que a documentação oficial diz:

Kotlin gera métodos estáticos para funções em nível de pacote. O Kotlin também pode gerar métodos estáticos para funções definidas em objetos nomeados ou objetos complementares se você anotar essas funções como @JvmStatic. Por exemplo:

Métodos estáticos de Kotlin

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

Agora, foo () é estático em Java, enquanto bar () não é:

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

Na verdade, eu tinha essa pergunta exata há 30 minutos, então comecei a procurar e não consegui encontrar nenhuma solução ou solução alternativa para isso, mas durante a pesquisa encontrei esta seção no site da Kotlinglang que afirma que:

Observe que as extensões podem ser definidas com um tipo de receptor anulável. Tais extensões podem ser chamadas em uma variável de objeto, mesmo que seu valor seja nulo.

Então, eu tive a idéia mais louca de todos os tempos: por que não definir uma função de extensão com um receptor nulo (sem realmente usá-lo) e depois chamá-lo em um objeto nulo! Então eu tentei isso, e funcionou muito bem, mas parecia tão feio. Foi assim:

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

Então, eu contornei isso criando um val no meu arquivo de extensões do tipo receptor que tinha um valor nulo e depois o usei na minha outra classe. Então, como exemplo, aqui está como eu implementei uma função de extensão "estática" para a Navigationclasse no Android: No meu arquivo 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) }
}

No código que o usa:

SNavigation.createNavigateOnClickListener(R.id.action_gameWonFragment_to_gameFragment)

Obviamente, este não é um nome de classe, é apenas uma variável do tipo de classe que possui um valor nulo. Isso é obviamente feio no lado do criador de extensões (porque eles precisam criar a variável) e no lado do desenvolvedor (porque eles precisam usar o STypeformato em vez do nome real da classe), mas é o mais próximo que pode ser alcançado agora comparado às funções estáticas reais. Felizmente, os criadores do idioma Kotlin responderão ao problema que foi criado e adicionarão esse recurso ao idioma.

Você pode criar um método estático usando o objeto Companion, como:

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

e então você pode chamar assim:

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

Recomendamos que você veja este link. Como você pode ver lá, você deve declarar o método no nível superior do pacote (arquivo):

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

Isso é igual a

package strings;

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

Com os constantes, tudo é igual. Esta declaração

val UNIX_LINE_SEPARATOR = "\n"

é igual a

public static final String UNIX_LINE_SEPARATOR = "\n";

Também gosto bastante de ter a possibilidade de adicionar métodos de extensão estática no Kotlin. Como solução alternativa, por enquanto, estou adicionando o método exntension a várias classes em vez de usar um método de extensão estática em todas elas.

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 criar um método de extensão no kotlin, você deve criar um arquivo kotlin (não uma classe) e, em seguida, declarar seu método no arquivo Por exemplo:

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

Importe a função na classe ou arquivo em que você está trabalhando e use-a.