16 consejos de desarrollo para Android en Kotlin. Parte 3

Hola de nuevo En previsión del lanzamiento del curso básico sobre desarrollo de Android , compartimos la parte final del artículo "16 consejos de desarrollo para Android en el idioma Kotlin".

---

Lee la primera parte
Lee la segunda parte

LATEINIT

Una de las características principales de Kotlin es su compromiso con la seguridad cero. La declaración de lateinit proporciona una manera fácil de garantizar cero seguridad e inicializar la variable según lo requiera Android. Esta característica es excelente, sin embargo, debe acostumbrarse después de trabajar en Java. Una idea es que el campo se declare inmediatamente con la capacidad de ser nulo:

var total = 0 var toolbar: Toolbar? = null 

Esta función de lenguaje puede causar dificultades al trabajar con diseños de Android, porque no sabemos cómo declarar vistas antes de declarar el diseño, porque no está claro dónde existirán en Activity o Fragment . Esto se compensa con pruebas adicionales para la posibilidad de un valor cero en cada lugar con el que interactuamos, pero este sigue siendo hemorroides. Por lo tanto, es mejor usar el modificador lateinit :

 lateinit var toolbar: Toolbar 

Ahora, como desarrollador, no debe consultar la Barra de herramientas hasta que se haya inicializado. Esto funciona muy bien cuando se usa junto con una biblioteca como Butter Knife :

 @BindView(R.id.toolbar) lateinit var toolbar: Toolbar override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) setContentView(R.layout.activity_main) ButterKnife.bind(this) //       toolbar toolbar.setTitle("Hello There") } 

Tipo de seguridad

Algunas convenciones de Android requieren una escritura segura porque la escritura regular no excluye errores de código. Por ejemplo, una forma típica de crear un fragmento en acción implica verificar a través del FragmentManager para asegurarse de que ya existe. Y solo si no es así, lo crea y lo agrega a la acción. Cuando veas cómo escribir en Kotlin por primera vez, puedes implementar esto de la siguiente manera:

 var feedFragment: FeedFragment? = supportFragmentManager .findFragmentByTag(TAG_FEED_FRAGMENT) as FeedFragment      .  as     ,     .   : var feedFragment: FeedFragment? = supportFragmentManager .findFragmentByTag(TAG_FEED_FRAGMENT) as? FeedFragment if (feedFragment == null) { feedFragment = FeedFragment.newInstance() supportFragmentManager.beginTransaction() .replace(R.id.root_fragment, feedFragment, TAG_FEED_FRAGMENT) .commit() } 

APROVECHAMIENTO

Aprovechar let le permite ejecutar un bloque si el valor del objeto no es cero. Esto le permite evitar verificaciones nulas y hace que el código sea más legible. En Java, se ve así:

 if (currentUser != null) { text.setText(currentUser.name) }   Kotlin   : user?.let { println(it.name) } 

Este código es mucho más legible, además crea automáticamente una variable con un valor distinto de cero sin el riesgo de ponerlo a cero.

SNULLOREMPTY | ISNULLORBLANK

Tenemos que verificar los campos muchas veces durante el desarrollo de la aplicación de Android. Si logró esto sin usar Kotlin, probablemente conozca la clase TextUtils en Android. La clase TextUtils es la siguiente:

 if (TextUtils.isEmpty(name)) { //    } 

En este ejemplo, notará que el usuario puede establecer incluso solo espacios como nombre de usuario, y pasará la prueba. isNullOrEmpty e isNullOrBlank están integrados en el lenguaje Kotlin, eliminan la necesidad de TextUtils.isEmpty ( someString ) y brindan el beneficio adicional de verificar solo espacios. Si es necesario, puede usar algo como esto:

 //       ... if (number.isNullOrEmpty()) { //     } //  ... if (name.isNullOrBlank()) { //     } 

La comprobación de la corrección de completar los campos a menudo se encuentra cuando el registro es necesario en la aplicación. Estos métodos integrados son excelentes para verificar el campo y alertar al usuario si algo está mal. Para verificaciones más complejas, puede usar métodos de extensión, por ejemplo, para direcciones de correo electrónico:

 fun TextInputLayout.isValidForEmail(): Boolean { val input = editText?.text.toString() if (input.isNullOrBlank()) { error = resources.getString(R.string.required) return false } else if (emailPattern.matcher(input).matches()) { error = resources.getString(R.string.invalid_email) return false } else { error = null return true } } 

Consejos para el avanzado

¿Sabía que puede usar expresiones lambda para crear código más limpio y conciso?

Por ejemplo, cuando se trabaja en Java, es típico tener una clase de escucha simple, como:

 public interface OnClickListener { void onClick(View v); } 

Una característica distintiva de Kotlin es que realiza conversiones SAM (Método abstracto único) para clases Java. Un escucha de clics en Java que se parece a:

 textView.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View view) { // -  } });  Kotlin     : textView.setOnClickListener { view -> // -  } 

Por extraño que parezca, tal conversión no es posible para las interfaces SAM creadas en Kotlin. Esto puede sorprender e incluso decepcionar un poco a los nuevos usuarios de Kotlin. Si se definiera la misma interfaz en Kotlin, el oyente se vería así:

 view.setOnClickListener(object : OnClickListener { override fun onClick(v: View?) { // -  } }) 

Para acortar dicho código, puede escribir a sus oyentes en la clase de la siguiente manera:

 private var onClickListener: ((View) -> Unit)? = null fun setOnClickListener(listener: (view: View) -> Unit) { onClickListener = listener } //     onClickListener?.invoke(this) 

Esto lo devolverá a una sintaxis lambda simple que hace posible la conversión automática de SAM.

Conclusión

Recopilé los trucos de vida más útiles de todo lo que he aprendido desde que me interesé en el idioma Kotlin. Espero que el conocimiento de estos consejos lo ayude significativamente a desarrollar sus propios proyectos.

Eso es todo. ¡Nos vemos en el curso !