Método de arranque estático de la actividad android en Kotlin

En java, uno puede definir un método estático inicial para una actividad. En Android Studio, incluso hay una plantilla "inicial" para él: se vería así:

public class MyActivity extends AppCompatActivity { private static final String EXTRA_FOO = "foo"; public static void start(Context caller, String bar){ Intent intent = new Intent(caller, MyActivity.class); intent.putExtra(EXTRA_FOO, bar); caller.startActivity(intent); } } 

Me estoy volviendo loco con este mismo concepto en Kotlin (en Android Studio 3.0 Canary4) y lo más parecido que se me ocurrió es este:

 class MyActivity : AppCompatActivity() { companion object { private val EXTRA_FOO = "foo" fun start(caller: Context, bar: String){ val intent = Intent(caller, MyActivity::class.java) intent.putExtra(EXTRA_FOO, bar) caller.startActivity(intent) } } } 

¿Hay una manera más concisa y elegante de hacer esto? No puedo creer que este sea el path a seguir, se ve más feo que en Java. Además, no hay una plantilla "inicial" para Kotlin.

Hay algunos enfoques que podría tomar. Soy un fan de las funciones de extensión :

 class MyActivity : AppCompatActivity() private fun Intent.extraFoo(bar : String) = putExtra("foo", bar) fun Context.startMyActivity(bar : String) = Intent(this, MyActivity::class.java).apply { extraFoo(bar) }.let(this::startActivity) 

Esto crea una extensión al Context para que pueda llamar a startMyActivity en cualquier object de Context .


Aquí está la misma function de extensión en un estilo más similar a Java, para que pueda compararlo más fácilmente con lo que ya tiene:

 private val EXTRA_FOO = "foo" fun Context.startMyActivity(bar : String) { val intent = Intent(this, MyActivity::class.java) intent.putExtra(EXTRA_FOO, bar) startActivity(intent) } 

Para agregar al enfoque de Sam, generalmente utilizo extensiones para actividades, pero en casos como fragments en los que necesitas crear una nueva instancia y pasar arguments, puedo considerar lo siguiente:

 class F : Fragment() { companion object { operator fun invoke(text: String): F { val f = F() val bundle = Bundle() bundle.putString("key", text) f.arguments = bundle return f } fun test() { //you can now initialize a fragment and put text in its bundle like so val f = F("hi") } } } 

La function de operador le permite usar la notación similar al constructor.

  • ¿Es seguro llamar a kclass.memberProperties en un object desconocido (Cualquiera)?
  • El complemento kapt no funciona con gradle-script-kotlin
  • Gradle compileKotlin includeRuntime no agrega time de ejecución para jar
  • Android: la ejecución de Kotlin falló al intentar usar Databinding
  • ¿Cómo puedo representar una relación de muchos a muchos con Android Room?
  • Combustible TimeOut Connection
  • Kotlin Android comstack
  • Anko 0.8 - reference de lparams no resuelta
  • Reglas de ProGuard para la reflexión de Kotlin
  • Android Studio (Kotlin) cómo convertir StringArray en MutableList
  • Interoperabilidad de Kotlin-JS: uso de construcciones de lenguaje