PDF - VERSÃO DE IMPRESSÃO

Lição 4 - Ambiente de Desenvolvimento Android

objetivo

Olá, estudante! Tudo bem? Relembrando o que você estudou na primeira parte desta disciplina sobre Android Studio, agora, vamos explorar os principais ambientes de desenvolvimento e frameworks disponíveis para trabalhar com Kotlin. Nesta lição, aprofundar-nos-emos no Android Studio, a principal IDE recomendada para o desenvolvimento Android, destacando como ela facilita a criação de aplicativos eficientes. Além disso, vamos conhecer bibliotecas e frameworks populares, como Ktor, para o desenvolvimento de aplicativos web, e Coroutines, para lidar com operações assíncronas de forma simples e eficiente.

Sendo assim, o objetivo desta lição é demonstrar as bases para utilizar ambientes e ferramentas modernas que otimizem o desenvolvimento com Kotlin. Ao final desta lição, você estará apto(a) a configurar um ambiente de desenvolvimento e aplicar essas ferramentas para criar projetos Kotlin modernos e produtivos.

Vamos lá?

problematização

Considere que você está desenvolvendo um aplicativo para Android que precisa se conectar a um serviço externo via internet, como uma API de dados meteorológicos ou um sistema de autenticação. O seu desafio é garantir que, enquanto os dados estão sendo carregados, a interface do usuário continue fluida e responsiva, sem travamentos ou mensagens de erro. Além disso, como desenvolvedor(a), você quer utilizar ferramentas modernas que não apenas otimizem o tempo de desenvolvimento, mas também reduzam a complexidade do código, permitindo que você foque na funcionalidade do aplicativo, ao contrário de perder tempo configurando detalhes manuais. Diante desse cenário, você saberia dizer qual seria a melhor combinação de ambiente de desenvolvimento e bibliotecas para atender a essas demandas?

Vamos nos aprofundar nesse assunto na lição de hoje. Contudo, neste momento, posso adiantar e dizer que o Android Studio, a principal IDE para desenvolvimento Android, oferece um ambiente completo e integrado que facilita o gerenciamento de dependências e a criação de aplicativos eficientes. Por outro lado, bibliotecas, como Ktor, simplificam a integração com serviços externos, enquanto Coroutines tornam o gerenciamento de tarefas assíncronas muito mais intuitivo e seguro, eliminando a necessidade de callbacks complexos.

Utilizar essas tecnologias é interessante, pois elas aumentam a produtividade e ajudam a criar aplicativos mais responsivos e de alta qualidade, atendendo às expectativas do mercado atual. Agora, sabendo disso, vamos entender melhor como elas funcionam?

case

Agora que introduzimos o tema desta lição, vamos explorar na prática o uso das tecnologias mencionadas!

Imagine uma startup fictícia chamada TechLink. Ela é especializada no desenvolvimento de aplicativos para Android. A equipe de desenvolvimento foi desafiada a criar um aplicativo que exiba informações meteorológicas obtidas de uma API externa. Um dos requisitos do projeto destacado pelo gerente era garantir uma interface do usuário sem travamentos durante o carregamento dos dados.

Para atender a essa necessidade, a equipe iniciou o desenvolvimento no Android Studio, configurando o projeto com facilidade e utilizando recursos, como autocompletar e depuração, para otimizar o trabalho. Na comunicação com a API meteorológica, o time utilizou o Ktor, que permitiu realizar requisições HTTP de forma simples e eficiente. Além disso, para garantir que a interface do aplicativo permanecesse responsiva durante a comunicação com o servidor, a equipe empregou Coroutines, gerenciando as operações assíncronas sem a complexidade de callbacks. Combinando essas ferramentas, a aplicação foi desenvolvida para exibir os dados meteorológicos de maneira rápida e eficiente, proporcionando uma experiência de uso fluida e agradável, atendendo perfeitamente às expectativas do gerente de projeto e dos futuros usuários.

Observe que a experiência da TechLink demonstra como um ambiente de desenvolvimento Android bem estruturado é essencial para o sucesso de um projeto. Utilizando o Android Studio, a equipe aproveitou ferramentas avançadas para criar um aplicativo eficiente e moderno. Além disso, com a integração de bibliotecas, como Ktor e Coroutines, foi possível otimizar o desenvolvimento e oferecer uma experiência fluida aos usuários. Agora que você sabe o quanto é essencial este conteúdo, vamos nos aprofundar?

Conceitualização

Você já foi introduzido aos conceitos de Android Studio no ano passado, mas agora o foco é mostrar que o Android Studio vai além de ser apenas um ambiente de desenvolvimento. Ele é a principal ferramenta para programar em Kotlin, a linguagem oficial para desenvolvimento Android, oferecendo integração nativa que melhora a produtividade e simplifica a escrita de código. Baseado no IntelliJ IDEA, o Android Studio é especialmente projetado para lidar com as necessidades dos desenvolvedores Android, aproveitando todo o potencial da linguagem Kotlin.

Resende (2018) justifica o uso do Android Studio, ao destacar que essa é a IDE oficial do Android. Não só, mas também enfatiza que o Android Studio oferece um editor de código avançado e uma ampla gama de ferramentas integradas que agilizam o desenvolvimento, eliminando a necessidade de utilizar outros softwares adicionais. Além disso, a interface intuitiva e as funcionalidades otimizadas tornam o processo de criação de aplicativos mais produtivo e prático.

Contudo, como o Android Studio ajuda a programar em Kotlin? Vamos conhecer algumas vantagens:

1. Autocompletar e Análise Estática de Código: ele oferece autocompletar específico para Kotlin, sugerindo métodos, classes e até corrigindo padrões comuns de erro enquanto você escreve. Isso é essencial em Kotlin, pois muitas das funcionalidades avançadas, como funções de extensão e lambdas, podem ser complexas sem o suporte de uma IDE. Um exemplo disso é quando você digita val e a IDE sugere inicializações comuns e opções de tipos automaticamente.

2. Gerenciador de Dependências Simplificado: adicionar bibliotecas, como Ktor e Coroutines, ao seu projeto é muito mais fácil graças ao suporte integrado ao Gradle. Com apenas algumas linhas no arquivo build.gradle, você configura bibliotecas essenciais para o desenvolvimento Kotlin. Visualize um exemplo do arquivo build.gradle importando as dependência na Figura 1:

Figura 1 - Importando dependências no arquivo build.gradle
Fonte: o autor.

#PraCegoVer: na primeira linha, é exibido implementation("org.jetbrains.kotlinx:kotlinx-coroutines-android:1.6.0"); já na linha 2, temos: implementation("io.ktor:ktor-client-cio:2.0.0").

3. Refatoração inteligente: o Android Studio permite refatorar código Java para Kotlin automaticamente, facilitando migrações ou uso de interoperabilidade entre linguagens. Exemplo disso é um código em Java como: String greeting = "Hello, World!"; que a IDE sugere refatorar para Kotlin como: val greeting = "Hello, World!".

4. Teste e Depuração Avançados com o Emulador Android: o emulador integrado permite testar aplicativos em dispositivos com diferentes configurações e versões do Android. Isso é essencial ao trabalhar com operações assíncronas usando Coroutines, em que o comportamento pode variar dependendo do hardware e do sistema operacional.

Ktor: integração de aplicativos com APIs e desenvolvimento multiplataforma

O Ktor, desenvolvido pela JetBrains, é um framework utilizado para criar servidores e clientes HTTP de forma simples e eficiente. Segundo Ktor (2024), ele conta com um cliente HTTP assíncrono multiplataforma que permite fazer requisições e manipular respostas. Além disso, a funcionalidade dele pode ser estendida com plugins, como autenticação, serialização JSON e outros recursos. Projetado especificamente para ser compatível com Kotlin, o Ktor é ideal para integrar aplicativos com APIs externas e construir soluções que vão além do Android, incluindo projetos multiplataforma. São características principais do Ktor:

Cliente HTTP: facilita a comunicação com APIs REST, como buscar dados de clima ou autenticar usuários.
Compatibilidade multiplataforma: pode ser usado em projetos Android, iOS e web.
Extensível: permite configurar autenticação, serialização e outros recursos com plugins.

Visualize, agora, na Figura 2, um exemplo prático de obtenção de dados meteorológicos de uma API:

Figura 2 - Obtendo dados de uma API meteorológica
Fonte: o autor.

#PraCegoVer: na linha 1, temos: import io.ktor.client.*; na linha 2, temos: import io.ktor.client.engine.cio.*; na linha 3, temos import io.ktor.client.request.*; na linha 4, temos import io.ktor.client.statement.*; na linha 5, import kotlinx.coroutines.runBlocking; na linha 7, temos fun main() = runBlocking {; na linha 8, temos val client = HttpClient(CIO); na linha 9, val uri = "https://api.weatherapi.com/v1/current.json?key=API_KEY&q=London"; na linha 10, val response: String = client.get(uri); na linha 11, println(response); na linha 12, client.close(); na linha 13, }. Na linha 6, não há conteúdo escrito.

No exemplo presente na Figura 2, o Ktor simplifica a obtenção de dados JSON, ao retornar o resultado diretamente como uma string.

Coroutines: gerenciamento simples de tarefas assíncronas

Os Coroutines são uma ferramenta poderosa para gerenciar o código assíncrono em Kotlin. Conforme descrito por Kotlinlang (2022), diferentemente de muitas outras linguagens com capacidades semelhantes, async e await não são palavras-chave em Kotlin, tampouco fazem parte da biblioteca padrão. Em Kotlin, as Coroutines permitem que operações longas (as chamadas “rede” ou “acesso ao banco de dados”) sejam realizadas sem bloquear a interface do usuário, mantendo o aplicativo responsivo. Nesse sentido, a utilização de Coroutines se destaca por:

Simplicidade: escreva um código assíncrono que parece síncrono.
Escalabilidade: gerencie milhares de tarefas simultaneamente com baixo custo.
Segurança: evite problemas comuns de concorrência, como condições de corrida.

Veja, agora, um exemplo prático de uso do framework na Figura 3.

Figura 3 - Rotina assíncrona usando Coroutines
Fonte: o autor.

#PraCegoVer: na linha 1, temos: import kotlinx.coroutines.*; na linha 3, fun main() = runBlocking {; na linha 4, launch {; na linha 5, println(“Iniciando operação…”); na linha 6, delay(2000) // simula uma tarefa long; na linha 7, println(“Operação concluída!”); na linha 8, }; na linha 9, println(“Executando enquanto a operação está em andamento.”); na linha 10, }. Na linha 2, não há conteúdo escrito.

Você consegue imaginar o resultado desse código assíncrono? Pois bem, o resultado é apresentado na Figura 4.

Figura 4 - Resultado de rotina assíncrona usando Coroutines
Fonte: o autor.

#PraCegoVer: na linha 1, temos: Executando enquanto a operação está em andamento; na linha 2, Iniciando operação…; e, na linha 3, Operação concluída!.

Coroutines e Ktor

Ao combinar Coroutines com Ktor, você pode executar chamadas de API de forma assíncrona e atualizá-las na interface do usuário. Isso é o que você pode conferir na Figura 5.

Figura 5 - Combinando Coroutines com Ktor
Fonte: o autor.

#PraCegoVer: na linha 1, temos: suspend fun fetchWeather(): String {; na linha 2, temos val client = HttpClient(CIO); na linha 3, temos val uri = "https://api.weatherapi.com/v1/current.json?key=API_KEY&q=London"; na linha 4, temos return client.get(uri); na linha 5, temos }; na linha 7, temos fun updateUI() = runBlocking {; na linha 8, temos val weatherData = fetchWeather(); na linha 9, temos println("Dados recebidos: $weatherData"); na linha 10, temos }. Na linha 11, não há conteúdo escrito.

Android Studio, Ktor e Coroutines formam um conjunto poderoso para o desenvolvimento com Kotlin. Enquanto o Android Studio facilita a escrita, o teste e a depuração do código, o Ktor integra facilmente o aplicativo a serviços externos, e as Coroutines garantem que todas essas operações sejam realizadas sem comprometer a experiência do usuário. Sendo assim, com esse conjunto de ferramentas, é possível desenvolver aplicativos modernos, escaláveis e de alta performance!

saiba aplicar

A compreensão dos ambientes e ferramentas modernas para o desenvolvimento com Kotlin é essencial para você, futuro(a) Técnico em Desenvolvimento de Sistemas, pois permite otimizar o processo de criação de software, tornando-o mais eficiente e produtivo. Com essas bases, você estará apto(a) a utilizar recursos, como o Android Studio, para desenvolver aplicativos de maneira integrada, e bibliotecas, como Ktor e Coroutines, que facilitam a implementação de funcionalidades avançadas, como comunicação com APIs e gerenciamento de tarefas assíncronas. Logo, o conteúdo estudado nesta lição te prepara para atender às demandas do mercado com soluções tecnológicas modernas e de alta qualidade.

Agora, vamos colocar a mão na massa? Neste passo a passo, você aprenderá a usar o Android Studio para criar um aplicativo em Kotlin que acessa uma API pública chamada JSONPlaceHolder (disponível clicando aqui) utilizando o Ktor para as requisições HTTP e o Coroutines para garantir que o aplicativo permaneça fluido durante as operações de rede. Para iniciar essa prática, siga os passos a seguir:

Tenha uma máquina com o Android Studio instalado (esse processo você já conhece da primeira parte da disciplina).
Crie um projeto chamado KotlinApiApp e escolha o template “Empty Views Activity”. Clique em “Next”.
Escolha a linguagem Kotlin.
Clique em “Finish” (Concluir) para criar o projeto.

Passo a passo

1. Abra o arquivo build.gradle do módulo do app. Navegue até o arquivo app/build.gradle.

2. Adicione as dependências do Ktor e Coroutines conforme a Figura 6:

Figura 6 - Importando as dependências do Ktor e Coroutines ao projeto
Fonte: o autor.

#PraCegoVer: na linha 1, temos: // Ktor dependencies; na linha 2, implementation(libs.ktor.client.core); na linha 3, implementation(libs.ktor.client.cio); na linha 4, // Coroutines dependency; na linha 5, implementation(libs.coroutines.android).

3. Clique em Sync Now, no topo da tela, para aplicar as dependências sincronizando o projeto.

4. Abra o arquivo res/layout/activity_main.xml.

5. Substitua o conteúdo do arquivo pelo conteúdo da Figura 7.

Figura 7 - Layout da aplicação
Fonte: o autor.

#PraCegoVer: na linha 1, temos: <?xml version="1.0" encoding="utf-8"?>; na linha 2, <LinearLayout; na linha 3, xmlns:android="http://schemas.android.com/apk/res/android”; na linha 4, android:layout_width="match_parent"; na linha 5, android:layout_height="match_parent"; na linha 6, android:orientation="vertical"; na linha 7, android:padding="16dp"; na linha 8, android:layout_marginTop="32dp">; na linha 10, <TextView; na linha 11, android:id="@+id/resultTextView"; na linha 12, android:layout_width="match_parent"; na linha 13, android:layout_height="wrap_content"; na linha 14, android:text="Clique no botão para carregar os dados"; na linha 15, android:textSize="18sp"; na linha 16, android:padding="8dp" />; na linha 18, <Button na linha 19 android:id="@+id/loadButton"; na linha 20, android:layout_width="wrap_content"; na linha 21, android:layout_height="wrap_content"; na linha 22, android:text="Carregar Dados"; na linha 23, android:layout_gravity="center" />; na linha 24, </LinearLayout>. Nas linhas 9 e 17, não há conteúdo escrito.

6. Implemente a lógica no Kotlin abrindo o arquivo MainActivity.kt.

7. Substitua o conteúdo do arquivo pelo conteúdo da Figura 8.

Figura 8 - Implementação da lógica em Kotlin
Fonte: o autor.

#PraCegoVer: na linha 1, temos: package com.example.kotlinapiapp; na linha 3, import android.os.Bundle; na linha 4, import android.widget.Button; na linha 5, import android.widget.TextView; na linha 6, import androidx.activity.enableEdgeToEdge; na linha 7, import androidx.appcompat.app.AppCompatActivity; na linha 8, import io.ktor.client.*; na linha 9, import io.ktor.client.engine.cio.*; na linha 10, import io.ktor.client.request.*; na linha 11, import io.ktor.client.statement.*; na linha 12, import kotlinx.coroutines.*; na linha 15, class MainActivity : AppCompatActivity() {; na linha 17, private val apiUrl = "https://jsonplaceholder.typicode.com/posts"; na linha 19, override fun onCreate(savedInstanceState: Bundle?) {; na linha 20, super.onCreate(savedInstanceState); na linha 21, enableEdgeToEdge(); na linha 22, setContentView(R.layout.activity_main); na linha 24, val resultTextView: TextView = findViewById(R.id.resultTextView); na linha 25, val loadButton: Button = findViewById(R.id.loadButton); na linha 27, loadButton.setOnClickListener {; na linha 28, CoroutineScope(Dispatchers.IO).launch {; na linha 29, val result = fetchApiData(); na linha 30, withContext(Dispatchers.Main) {; na linha 31, resultTextView.text = result; na linha 32, }; na linha 33, }; na linha 34, }; na linha 35, }; na linha 37, private suspend fun fetchApiData(): String {; na linha 38, val client = HttpClient(CIO); na linha 40, return try {; na linha 41, val response: HttpResponse = client.get(apiUrl); na linha 42, return response.bodyAsText(); na linha 43, } catch (e: Exception) {; na linha 44, "Erro ao carregar os dados: ${e.message}"; na linha 45, } finally {; na linha 46, client.close(); na linha 47, }; na linha 48, }; na linha 49, }. Nas linhas 13, 14, 23, 26, 36 e 39, não há conteúdo escrito.

Como nosso aplicativo se conecta com a internet, é importante que você informe isso para o projeto adicionando a seguinte linha dentro do arquivo AndroidManifest.xml logo depois da abertura da tag manifest <uses-permission android:name="android.permission.INTERNET" />

8. Execute o aplicativo usando um dispositivo físico ou emulador para testar o aplicativo.

9. Clique no botão “Carregar Dados”. O aplicativo fará uma requisição à API pública configurada e exibirá os dados retornados no TextView.

Ao realizar esse passo a passo, você terá utilizado o Android Studio para criar um aplicativo em Kotlin utilizando o Ktor para acessar uma API pública e o Coroutines para garantir operações assíncronas sem travar a interface do usuário. Agora, chame seus colegas e/ou professores para expandir esse conhecimento e integrar APIs complexas e criar aplicativos ainda mais robustos! Bom trabalho!

REFERÊNCIAS

KOTLIN. Coroutines guide. Kotlin, 16 fev. 2022. Disponível em: https://kotlinlang.org/docs/coroutines-guide.html. Acesso em: 15 jan. 2025.

KTOR. Create a Client Application. Ktor, 13 jun. 2024. Disponível em: https://ktor.io/docs/client-create-new-application.html. Acesso em: 15 jan. 2025.

RESENDE, K. Kotlin com android: crie aplicativos de maneira fácil e divertida. São Paulo: Casa do Código, 2018.

Page updated

Google Sites

Report abuse