Widget: o que é, widgets no iOS WidgetKit e Android

O que é um Widget

Widget é um elemento compacto de interface do usuário colocado na tela inicial de um dispositivo móvel para exibir informações relevantes de um aplicativo. Diferente de um aplicativo completo, um widget não requer inicialização — o usuário vê os dados imediatamente após desbloquear a tela. O conceito originou-se de sistemas operacionais de desktop (macOS Dashboard, Windows Sidebar), e no ambiente móvel, o Android introduziu suporte a widgets desde seu primeiro lançamento (Android 1.5 Cupcake, 2009), enquanto a Apple os adicionou apenas no iOS 14.

A implementação técnica difere entre plataformas. Um widget iOS é um target separado no Xcode, compilado como Widget Extension, executando em seu próprio processo. Um widget Android é um BroadcastReceiver que estende AppWidgetProvider, renderizando o layout via RemoteViews. Ambas as plataformas impõem restrições estritas de desempenho e memória: o sistema pode remover o widget se os limites forem excedidos. O iOS limita widgets a 30–50 MB e tempo de geração do timeline a 10 segundos. Android — intervalo de atualização não superior a 30 minutos via updatePeriodMillis e encerramento forçado se onUpdate travar.

Smart Stack no iOS e pilhas no Android permitem que o usuário agrupe vários widgets em um slot da tela inicial. O dispositivo alterna automaticamente o widget exibido com base na hora do dia, localização ou atividade do usuário. Por exemplo, pela manhã é mostrado o calendário, durante o dia — o clima, à noite — as notas. Para desenvolvedores, isso significa que o widget deve funcionar corretamente como parte de uma pilha e não depender de exibição constante.

iOS WidgetKit: SwiftUI e TimelineProvider

WidgetKit é o framework da Apple para criar widgets no iOS 14+, iPadOS 14+ e macOS 11+. Os widgets são escritos em Swift usando SwiftUI e o mecanismo TimelineProvider para atualização de conteúdo. A arquitetura do WidgetKit inclui três componentes: TimelineProvider — uma fonte de dados que forma uma linha do tempo com entradas; Widget Entry View — uma View SwiftUI que exibe conteúdo com base em uma entrada; Widget Configuration — uma descrição do tipo, tamanhos e famílias do widget.

WidgetKit gerencia atualizações automaticamente — o desenvolvedor não pode forçar uma atualização do widget com mais frequência do que o sistema permite. A Apple usa um orçamento de atualizações distribuído entre todos os widgets no dispositivo. O intervalo mínimo é de 15 a 30 minutos. Para dados críticos (por exemplo, status de entrega), é usado push-to-refresh — envio de uma notificação push com uma data futura relevante, após a qual o WidgetKit solicita um novo timeline. A partir do iOS 17, os widgets suportam interatividade via App Intents — os usuários podem pressionar botões dentro de um widget sem abrir o aplicativo.

Android AppWidgetProvider: RemoteViews

AppWidgetProvider é a classe base para criar widgets no Android, parte do Android SDK desde API level 3. Um widget Android é um BroadcastReceiver que recebe eventos de atualização, ativação e desativação do sistema. Diferente do iOS, onde o widget é renderizado com SwiftUI em seu próprio mecanismo, o Android usa RemoteViews — um conjunto limitado de componentes View renderizados no processo do sistema (launcher). Views personalizadas, animações complexas ou bibliotecas de UI não podem ser usadas.

O fluxo de trabalho do widget Android inclui quatro estágios. Configuração — ao adicionar um widget à tela, o sistema pode iniciar uma Activity de configuração onde o usuário seleciona as configurações. Atualização — o sistema chama onUpdate() em um intervalo definido (mínimo 30 minutos) ou por um sinal do aplicativo via WorkManager. Renderização — o provedor cria RemoteViews com dados atuais e os passa através do AppWidgetManager. Manipulação de toque — o widget suporta PendingIntent para botões: clicar abre uma Activity ou executa uma ação. A partir do Android 12, os widgets ganharam suporte para cantos arredondados, cores adaptáveis do Material You e alteração dinâmica de tamanho.

Criar um widget no iOS com WidgetKit

Vamos criar um widget de clima em Swift usando WidgetKit e SwiftUI. O projeto deve incluir um target Widget Extension, adicionado no Xcode através de File → New → Target → Widget Extension.

import WidgetKit
import SwiftUI

// 1. Modelo de dados para o widget
struct WeatherEntry: TimelineEntry {
    let date: Date
    let temperature: Int
    let condition: String
}

// 2. TimelineProvider — provedor de dados
struct Provider: TimelineProvider {
    func placeholder(in context: Context) -> WeatherEntry {
        WeatherEntry(date: Date(), temperature: 22, condition: "Ensolarado")
    }

    func getSnapshot(in context: Context, completion: @escaping (WeatherEntry) -> Void) {
        let entry = WeatherEntry(date: Date(), temperature: 22, condition: "Ensolarado")
        completion(entry)
    }

    func getTimeline(in context: Context, completion: @escaping (Timeline<WeatherEntry>) -> Void) {
        let now = Date()
        let entry = WeatherEntry(date: now, temperature: 20, condition: "Nublado")
        let nextUpdate = Calendar.current.date(byAdding: .hour, value: 3, to: now)!
        let timeline = Timeline(entries: [entry], policy: .after(nextUpdate))
        completion(timeline)
    }
}

// 3. View SwiftUI para exibição
struct WeatherWidgetEntryView: View {
    var entry: WeatherEntry

    var body: some View {
        VStack(alignment: .leading) {
            Text("Clima").font(.caption).foregroundColor(.secondary)
            HStack {
                Text("\(entry.temperature)°").font(.largeTitle).fontWeight(.bold)
                Spacer()
                Text(entry.condition).font(.body)
            }
        }.padding()
    }
}

// 4. Configuração do widget
@main
struct WeatherWidget: Widget {
    var body: some WidgetConfiguration {
        StaticConfiguration(kind: "WeatherWidget", provider: Provider()) { entry in
            WeatherWidgetEntryView(entry: entry)
        }
        .configurationDisplayName("Clima")
        .description("Mostra a temperatura atual")
        .supportedFamilies([.systemSmall, .systemMedium])
    }
}

Pontos-chave: TimelineProvider determina quando e quais dados mostrar; getTimeline cria uma linha do tempo com a política de atualização .after(nextUpdate); StaticConfiguration conecta o provedor à View. Para dados dinâmicos, é usado IntentConfiguration com parâmetros personalizados.

Criar um widget no Android com AppWidgetProvider

Vamos implementar um widget de clima similar em Kotlin com AppWidgetProvider e RemoteViews.

// WeatherWidgetProvider.kt
class WeatherWidgetProvider : AppWidgetProvider() {

    override fun onUpdate(
        context: Context,
        appWidgetManager: AppWidgetManager,
        appWidgetIds: IntArray
    ) {
        for (appWidgetId in appWidgetIds) {
            updateAppWidget(context, appWidgetManager, appWidgetId)
        }
    }

    override fun onAppWidgetOptionsChanged(
        context: Context,
        appWidgetManager: AppWidgetManager,
        appWidgetId: Int,
        newOptions: Bundle
    ) {
        updateAppWidget(context, appWidgetManager, appWidgetId)
    }

    companion object {
        fun updateAppWidget(
            context: Context,
            appWidgetManager: AppWidgetManager,
            appWidgetId: Int
        ) {
            val temperature = 20
            val condition = "Nublado"
            val views = RemoteViews(
                context.packageName, R.layout.widget_weather
            ).apply {
                setTextViewText(R.id.tv_temperature, "$temperature°")
                setTextViewText(R.id.tv_condition, condition)
                setOnClickPendingIntent(
                    R.id.widget_root, PendingIntent.getActivity(
                        context, 0,
                        Intent(context, MainActivity::class.java),
                        PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
                    )
                )
            }
            appWidgetManager.updateAppWidget(appWidgetId, views)
        }
    }
}

// AndroidManifest — registro do provedor
<receiver android:name=".WeatherWidgetProvider" android:exported="true">
    <intent-filter>
        <action android:name="android.appwidget.action.APPWIDGET_UPDATE" />
    </intent-filter>
    <meta-data
        android:name="android.appwidget.provider"
        android:resource="@xml/widget_weather_info" />
</receiver>

O arquivo widget_weather_info.xml define tamanhos mínimos, intervalo e layout: minWidth 160dp, minHeight 80dp, updatePeriodMillis 3600000 (1 hora). RemoteViews usa apenas componentes suportados: LinearLayout, TextView, ImageView. Views personalizadas e ConstraintLayout estão disponíveis desde Android 5.0. GlanceLayout — uma abordagem experimental baseada em Compose para RemoteViews — apareceu no Android 15.