Como Conseguir Emprego com Kotlin: Guia Completo | Kotlin Brasil

// Jetpack Compose - Obrigatorio para vagas Android modernas
@Composable
fun LoginScreen(
    viewModel: LoginViewModel = hiltViewModel()
) {
    val uiState by viewModel.uiState.collectAsStateWithLifecycle()

    Column(
        modifier = Modifier
            .fillMaxSize()
            .padding(24.dp),
        verticalArrangement = Arrangement.Center
    ) {
        var email by remember { mutableStateOf("") }
        var senha by remember { mutableStateOf("") }

        OutlinedTextField(
            value = email,
            onValueChange = { email = it },
            label = { Text("E-mail") },
            modifier = Modifier.fillMaxWidth(),
            keyboardOptions = KeyboardOptions(
                keyboardType = KeyboardType.Email
            )
        )

        Spacer(modifier = Modifier.height(16.dp))

        OutlinedTextField(
            value = senha,
            onValueChange = { senha = it },
            label = { Text("Senha") },
            visualTransformation = PasswordVisualTransformation(),
            modifier = Modifier.fillMaxWidth()
        )

        Spacer(modifier = Modifier.height(24.dp))

        Button(
            onClick = { viewModel.login(email, senha) },
            modifier = Modifier.fillMaxWidth(),
            enabled = !uiState.loading
        ) {
            if (uiState.loading) {
                CircularProgressIndicator(modifier = Modifier.size(20.dp))
            } else {
                Text("Entrar")
            }
        }
    }
}

// Spring Boot - Stack mais pedida para backend
@Service
class ProductService(
    private val repository: ProductRepository,
    private val cacheService: CacheService
) {
    suspend fun findById(id: String): Product? {
        return cacheService.get("product:$id")
            ?: repository.findById(id)?.also { product ->
                cacheService.set("product:$id", product, ttl = 5.minutes)
            }
    }

    @Transactional
    suspend fun create(request: CreateProductRequest): Product {
        val product = Product(
            id = UUID.randomUUID().toString(),
            nome = request.nome,
            preco = request.preco,
            descricao = request.descricao,
            criadoEm = Instant.now()
        )
        return repository.save(product)
    }
}

// Exemplo de API bem estruturada para portfolio
// Mostra que voce entende arquitetura e boas praticas

@RestController
@RequestMapping("/api/v1/tasks")
class TaskController(private val taskService: TaskService) {

    @GetMapping
    suspend fun listAll(
        @RequestParam(defaultValue = "1") page: Int,
        @RequestParam(defaultValue = "20") size: Int,
        @RequestParam(required = false) status: TaskStatus?
    ): ResponseEntity<PagedResponse<TaskDTO>> {
        val tasks = taskService.list(page, size, status)
        return ResponseEntity.ok(tasks)
    }

    @PostMapping
    suspend fun create(
        @Valid @RequestBody request: CreateTaskRequest
    ): ResponseEntity<TaskDTO> {
        val task = taskService.create(request)
        return ResponseEntity
            .created(URI("/api/v1/tasks/${task.id}"))
            .body(task)
    }

    @PutMapping("/{id}")
    suspend fun update(
        @PathVariable id: String,
        @Valid @RequestBody request: UpdateTaskRequest
    ): ResponseEntity<TaskDTO> {
        val task = taskService.update(id, request)
        return ResponseEntity.ok(task)
    }
}

// Null safety - Tema frequente em entrevistas
// Explique a diferenca entre ?, !!, ?., ?:
val nome: String? = getNome()

// Safe call
val tamanho = nome?.length  // Int? - pode ser null

// Elvis operator
val tamanhoOuZero = nome?.length ?: 0  // Int - nunca null

// Not-null assertion (evitar em producao)
val tamanhoForced = nome!!.length  // Lanca exception se null

// Smart cast
if (nome != null) {
    println(nome.length)  // Aqui, nome e String (nao nullable)
}

// Coroutines - Outro tema frequente
// Explique suspend functions, dispatchers, structured concurrency

suspend fun exemploCoroutines() = coroutineScope {
    // launch - fire and forget
    launch { tarefaAssincrona() }

    // async - retorna resultado
    val resultado = async { calcularAlgo() }
    println(resultado.await())

    // withContext - trocar dispatcher
    val dados = withContext(Dispatchers.IO) {
        carregarDoBancoDeDados()
    }
}

// Exemplo tipico de live coding
// "Agrupe pedidos por status e calcule o total de cada grupo"
fun agruparPedidos(pedidos: List<Pedido>): Map<String, ResumoGrupo> {
    return pedidos
        .groupBy { it.status }
        .mapValues { (status, pedidosGrupo) ->
            ResumoGrupo(
                status = status,
                quantidade = pedidosGrupo.size,
                valorTotal = pedidosGrupo.sumOf { it.valor },
                ticketMedio = pedidosGrupo.map { it.valor }.average()
            )
        }
}