Widget: co to je, widgety na iOS WidgetKit a Android

Co je Widget

Widget — je kompaktní prvek uživatelského rozhraní umístěný na domovské obrazovce mobilního zařízení pro zobrazení aktuálních informací z aplikace. Na rozdíl od plné aplikace widget nevyžaduje spuštění — uživatel vidí data ihned po odemknutí obrazovky. Koncept pochází z desktopových OS (macOS Dashboard, Windows Sidebar) a v mobilním prostředí Android zavedl podporu widgetů od svého prvního vydání (Android 1.5 Cupcake, 2009), zatímco Apple je přidal až v iOS 14.

Technická implementace se liší na platformách. iOS widget — samostatný target v Xcode, kompilovaný jako Widget Extension, běžící ve vlastním procesu. Android widget — BroadcastReceiver rozšiřující AppWidgetProvider, vykreslující rozvržení přes RemoteViews. Obě platformy ukládají přísná omezení na výkon a paměť: systém může widget odstranit při překročení limitů. iOS omezuje widget na 30–50 MB a čas vytvoření timeline na 10 sekund. Android — interval aktualizace ne častěji než 30 minut přes updatePeriodMillis a vynucené ukončení při zamrznutí onUpdate.

Smart Stack na iOS a hromádky na Android umožňují uživateli seskupit více widgetů do jednoho slotu na home screen. Zařízení automaticky přepíná zobrazený widget v závislosti na denní době, poloze nebo aktivitě uživatele. Například ráno se zobrazí kalendář, přes den — počasí, večer — poznámky. Pro vývojáře to znamená, že widget musí správně fungovat v rámci hromádky a nespoléhat se na trvalé zobrazení.

iOS WidgetKit: SwiftUI a TimelineProvider

WidgetKit — framework Apple pro vytváření widgetů na iOS 14+, iPadOS 14+ a macOS 11+. Widgety se píší ve Swift pomocí SwiftUI a mechanismu TimelineProvider pro aktualizaci obsahu. Architektura WidgetKit zahrnuje tři komponenty: TimelineProvider — zdroj dat, který tvoří časovou osu se záznamy; Widget Entry View — SwiftUI View zobrazující obsah na základě záznamu; Widget Configuration — popis typu, velikostí a rodin widgetu.

WidgetKit sám spravuje aktualizaci — vývojář nemůže vynutit aktualizaci widgetu častěji, než systém povoluje. Apple používá rozpočet aktualizací rozdělovaný mezi všechny widgety na zařízení. Minimální interval — 15–30 minut. Pro kritická data (např. stav doručení) se používá push-to-refresh — odeslání push oznámení s relevantním datem v budoucnosti, po kterém WidgetKit požádá o novou časovou osu. Od iOS 17 widgety podporují interaktivitu přes App Intents — uživatel může mačkat tlačítka uvnitř widgetu bez otevření aplikace.

Android AppWidgetProvider: RemoteViews

AppWidgetProvider — základní třída pro vytváření widgetů v Android, součást Android SDK od API level 3. Android widget — je BroadcastReceiver přijímající události aktualizace, aktivace a deaktivace od systému. Na rozdíl od iOS, kde widget kreslí SwiftUI na vlastním enginu, Android používá RemoteViews — omezenou sadu komponent View vykreslovaných v systémovém procesu (launcher). Nelze použít vlastní View, složité animace nebo UI knihovny.

Schéma fungování Android widgetu zahrnuje čtyři fáze. Konfigurace — při přidávání widgetu na obrazovku může systém spustit konfigurační Activity, kde uživatel volí nastavení. Aktualizace — systém volá onUpdate() v nastaveném intervalu (minimálně 30 minut) nebo na signál z aplikace přes WorkManager. Vykreslení — poskytovatel vytvoří RemoteViews s aktuálními daty a předá je přes AppWidgetManager. Zpracování kliknutí — widget podporuje PendingIntent pro tlačítka: po kliknutí se otevře Activity nebo se provede akce. Od Android 12 widgety získaly podporu pro zaoblené rohy, adaptivní barvy Material You a dynamickou změnu velikosti.

Vytvoření widgetu na iOS s WidgetKit

Vytvořme widget počasí ve Swift pomocí WidgetKit a SwiftUI. Projekt by měl obsahovat Widget Extension target, přidaný v Xcode přes File → New → Target → Widget Extension.

import WidgetKit
import SwiftUI

// 1. Datový model pro widget
struct WeatherEntry: TimelineEntry {
    let date: Date
    let temperature: Int
    let condition: String
}

// 2. TimelineProvider — poskytovatel dat
struct Provider: TimelineProvider {
    func placeholder(in context: Context) -> WeatherEntry {
        WeatherEntry(date: Date(), temperature: 22, condition: "Slunečno")
    }

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

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

// 3. SwiftUI View pro zobrazení
struct WeatherWidgetEntryView: View {
    var entry: WeatherEntry

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

// 4. Konfigurace widgetu
@main
struct WeatherWidget: Widget {
    var body: some WidgetConfiguration {
        StaticConfiguration(kind: "WeatherWidget", provider: Provider()) { entry in
            WeatherWidgetEntryView(entry: entry)
        }
        .configurationDisplayName("Počasí")
        .description("Zobrazuje aktuální teplotu")
        .supportedFamilies([.systemSmall, .systemMedium])
    }
}

Klíčové body: TimelineProvider určuje, kdy a jaká data zobrazit; getTimeline vytváří časovou osu s politikou aktualizace .after(nextUpdate); StaticConfiguration propojuje poskytovatele s View. Pro dynamická data se používá IntentConfiguration s uživatelskými parametry.

Vytvoření widgetu na Android s AppWidgetProvider

Implementujeme podobný widget počasí v Kotlin s AppWidgetProvider a 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 = "Zataženo"
            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 — registrace poskytovatele
<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>

Soubor widget_weather_info.xml nastavuje minimální velikosti, interval a rozvržení: minWidth 160dp, minHeight 80dp, updatePeriodMillis 3600000 (1 hodina). RemoteViews používá pouze podporované komponenty: LinearLayout, TextView, ImageView. Vlastní View a ConstraintLayout jsou dostupné od Android 5.0. GlanceLayout — experimentální přístup Compose pro RemoteViews — se objevil v Android 15.