Multiplatformní vývoj - Web, iOS i Android z jednotného vývojového prostředí

React Native

React Native framework od Meta (Facebook) umožňuje vytvářet nativní mobilní aplikace pomocí technologií známých z webového prostředí – Reactu a JavaScriptu (nebo TypeScriptu). Cílem je psát většinu logiky a komponent jednou a nasadit je na iOS, Android i web.

Architektura	Výstup	Použití
React Native (JS → native bridge)	JavaScript běží v JS VM (Hermes / JSC) a komunikuje s nativním UI přes bridge	iOS, Android
React Native Web	Překlad React Native komponent do DOM elementů (div, span…)	Webové aplikace (DOM, s možností SSR)

Základní myšlenkou React Native je využít stejné Reactové paradigma (komponenty, stav, JSX) k tvorbě nativních rozhraní. Místo HTML se používají univerzální komponenty jako <View>, <Text> nebo <Image>, které jsou při kompilaci mapovány na skutečné nativní UI prvky každé platformy.

🧩 Architektura

React Native běží ve dvou hlavních vláknech:

• JavaScript Thread – vykonává aplikační logiku a React komponenty,
• Native Thread – obsluhuje skutečné UI a nativní API.

Mezi nimi probíhá komunikace přes JSI / Fabric (od verze 0.73) + TurboModules, které zajišťuje synchronizaci mezi React stromy a nativními views. Díky tomu se zachovává nativní výkon a přístup k platformním API, i když aplikační logika běží v JavaScriptu.

🌐 React Native Web a Next.js

Pomocí knihovny react-native-web lze stejný kód používat i pro web. Komponenty jako <View> nebo <Text> jsou mapovány na standardní HTML elementy (<div>, <span> apod.), takže se aplikace chová jako klasický React web.

Pro plnohodnotné webové nasazení se React Native Web často kombinuje s frameworkem Next.js, který přidává:

• SSR (Server-Side Rendering) – generování HTML na serveru pro SEO a rychlé načtení,
• Routing – systém stránek (pages/ nebo app/ router),
• Optimalizaci výkonu – lazy loading, image optimization, cache revalidaci, apod.

Tato kombinace umožňuje vyvíjet projekt, kde se o UI komponenty stará React Native, logika se sdílí mezi mobilními i webovými verzemi a Next.js zajišťuje SEO-ready webový rendering.

Renderování	SSR / SEO	Výhody	Omezení
🧩 DOM (react-native-web)	✅ S Next.js (jinak CSR)	Jednotný React ekosystém (web + mobil) Silná komunita, rozsáhlý ekosystém knihoven Podpora TypeScriptu, Fast Refresh, Hot Reload Možnost SSR a SEO optimalizace přes Next.js	Bez Next.js chybí SSR (client-side rendering) Vyžaduje ruční mapování některých nativních API Výkon nižší než čistě nativní aplikace

📦 Struktura projektu

/src/
├── components/       ← sdílené UI komponenty (React Native)
├── screens/          ← logika jednotlivých obrazovek
├── hooks/            ← sdílené React hooky
├── app/              ← Next.js App Router (pro web)
├── android/          ← Android nativní projekt
├── ios/              ← iOS nativní projekt
└── package.json      ← společné závislosti (React, RN, Next.js)

Typická kombinace pro multiplatformní projekt dnes bývá:

• React Native – mobilní aplikace (Android, iOS)
• React Native Web + Next.js – webová verze (SSR, SEO)
• Expo / React Native CLI – build nástroje pro vývoj a nasazení

Tato kombinace umožňuje sdílet až 90 % kódu mezi webem a mobilem při zachování nativního uživatelského zážitku. React Native je tak ideální pro projekty, které chtějí jednotný React stack, vysokou flexibilitu a efektivní multiplatformní vývoj.

Kotlin Multiplatform

Kotlin je jazyk, který se prostřednictvím Kotlin compiler (kotlinc) překládá do několika jazyků / architektur:

Kompilátor	Výstup	Použití
Kotlin/JVM	Překládá do Java bytecode (.class)	Android, backend (Spring, Ktor)
Kotlin/JS	Překládá do JavaScriptu (ES5/ES6)	Web aplikace (přes React wrappers)
Kotlin/Native	Překládá do nativního strojového kódu (.exe, .a, .so)	iOS, macOS, Linux, Windows, embedded

Kotlin Multiplatform (KMP) je tool navržený tak, aby sdílel business logiku, datové modely, API klienty a utilitní kód mezi platformami Android, iOS, Web a Desktop. Vývojář si poté určuje, co se má sdílet a co má být platform-specific.

/shared         ← společná logika (Kotlin Common code)
/androidApp     ← Android UI (Compose)
/iosApp         ← iOS UI (SwiftUI)

🌐 Kotlin a Web

Kotlin Multiplatform umí dodat logiku na web, ovšem "neumí" web vykreslit (neposkytuje webové UI frameworky) – UI se musí dělat zvlášť.

• Kotlin/JS - Kotlin/JS překládá Kotlin kód do JavaScriptu (ES5/ES6). Pro tvorbu webového UI je možné využít React wrappers (kotlin-wrappers), které umožňují psát React komponenty v Kotlinu. Nicméně, používá se málo (většina vývojářů zůstává u TS/JS).
• Jetpack Compose for Web - JetBrains (tvůrce Kotlin) rozšiřuje Jetpack Compose pro web, kdy vykreslení webu funguje podobně jako Flutter Web – všechno se renderuje do Canvasu (WebGL), ne do DOMu. Zatím jde o experimentální, neplnohodnotné, řešení pro produkční weby.

Flutter

Flutter je open-source framework vyvíjený společností Google. Je postaven na jazyce Dart a umožňuje kompilaci do nativního ARM kódu pro mobilní zařízení i do JavaScriptu pro web.

Architektura	Výstup	Použití
Flutter (Dart → ARM)	Kompiluje se do nativního ARM / x64 kódu	Android, iOS, Windows, macOS, Linux
Flutter Web (Dart → JS)	Kompiluje se do JavaScriptu s vlastní renderovací vrstvou	Webové aplikace (Canvas / WebGL)

Flutter používá vlastní renderovací engine (Skia), který zajišťuje, že aplikace vypadá a chová se stejně na všech platformách. Namísto využívání nativních UI komponent (jako u React Native nebo MAUI) Flutter vykresluje každý pixel sám – texty, tlačítka, animace i layout.

🌐 Flutter a Web

Při cílení na web Flutter nepoužívá HTML ani DOM. Celé uživatelské rozhraní se renderuje do jednoho <canvas> prvku, kde je pomocí CanvasKit (WebGL) vykreslován obsah. Prohlížeč tedy nevidí žádný HTML text, pouze výsledný obraz aplikace.

Renderování	SEO / SSR	Výhody	Omezení
🎨 Canvas / WebGL	❌ Neindexovatelné (žádný HTML DOM, bez SSR)	Stejný vzhled napříč platformami Vysoký výkon (nativní vykreslování) Hot reload a rychlý vývoj Silná komunita a podpora od Google	Větší velikost výsledného balíčku Horší SEO a indexace Vyšší nároky na GPU a výkon prohlížeče

📦 Struktura projektu

/lib              ← hlavní Dart kód (společný)
/web              ← webové entry pointy (main.dart.js)
/android, /ios    ← platform-specific konfigurace
/assets           ← obrázky, fonty, statické zdroje

Jedním kódem tak lze vytvořit aplikaci pro mobilní zařízení, desktop i web. Flutter je ideální volbou pro startupy a projekty, které potřebují rychle vyvíjet vizuálně jednotné a interaktivní aplikace napříč platformami, bez nutnosti psát nativní kód pro každou platformu zvlášť.

.NET MAUI

.NET MAUI (Multi-platform App UI) je framework vyvíjený společností Microsoft jako nástupce Xamarin.Forms. Umožňuje vytvářet nativní aplikace pro iOS, Android, Windows a macOS pomocí jazyka C# a frameworku .NET z jediné codebase.

Architektura	Výstup	Použití
.NET MAUI (C# → nativní kód)	Kompiluje do nativního kódu přes .NET runtime	iOS, Android, Windows, macOS
Blazor Hybrid (C# + Razor)	Kombinuje nativní aplikaci s webovým obsahem (WebView)	Hybridní appky s webovým UI v MAUI shellu
Blazor WebAssembly	Překládá .NET kód do WebAssembly (běží v prohlížeči)	Web aplikace (DOM, bez SSR)

MAUI sjednocuje přístup k nativním API a komponentám napříč platformami. Pro tvorbu uživatelského rozhraní používá jazyk XAML (deklarativní popis UI) nebo čistý C#. K dispozici je i Blazor Hybrid, který umožňuje kombinovat nativní logiku a webové rozhraní v jedné aplikaci.

🌐 MAUI a Web (Blazor)

Pro webové aplikace využívá MAUI technologii Blazor, která může běžet ve dvou režimech:

• Blazor Server – HTML se generuje na serveru (podporuje SSR), UI se aktualizuje přes SignalR spojení.
• Blazor WebAssembly – kód běží kompletně v prohlížeči, renderuje do DOMu, ale bez SSR (využívá client-side rendering).

Renderování	SSR / SEO	Výhody	Omezení
🧩 DOM (HTML, Blazor)	✅ Server (Blazor Server) ⚠️ Bez SSR v WebAssembly režimu	Jednotný .NET ekosystém Možnost kombinovat nativní a webové UI Silné nástroje ve Visual Studio	Vyšší paměťová zátěž ve WebAssembly Omezené SEO u CSR Menší komunita než Flutter / React Native

📦 Struktura projektu

/MauiProgram.cs    ← inicializace aplikace
/MainPage.xaml      ← definice UI v XAML
/Platforms/
├── Android       ← konkrétní nastavení pro Android
├── iOS           ← konkrétní nastavení pro iOS
└── Windows       ← WinUI projekt
/wwwroot/          ← Blazor HTML a statické soubory

.NET MAUI je vhodné zejména pro vývojáře, kteří již znají ekosystém .NET a chtějí vytvářet multiplatformní aplikace z jediného prostředí. Přináší silnou integraci s Visual Studio, jednotné API pro nativní komponenty a možnost kombinovat C# logiku s webovým rozhraním pomocí Blazoru.

Unity

Unity je multiplatformní herní engine, který umožňuje vytvářet 3D i 2D aplikace pro široké spektrum platforem — od mobilních zařízení přes web až po VR a AR. Primárním jazykem je C# a logika se kompiluje do nativního kódu pomocí IL2CPP (Intermediate Language to C++).

Architektura	Výstup	Použití
Unity (C# → IL2CPP)	Kompilace do C++ a následně do nativního kódu (ARM / x64)	Android, iOS, Windows, macOS, Linux, konzole, VR/AR
Unity WebGL	Kompilace do WebAssembly + JavaScript loader	Webové aplikace (Canvas / WebGL)

Unity poskytuje vlastní renderovací engine, fyzikální simulaci, animace, UI systém a pokročilé nástroje pro vizuální efekty. Aplikace jsou kompilovány do nativního kódu, díky čemuž poskytují vysoký výkon, ale také vyšší nároky na hardware a velikost výsledných buildů.

🌐 Unity a Web (WebGL export)

Při exportu na web Unity převádí projekt do WebAssembly a JavaScript loaderu, který inicializuje běhové prostředí v prohlížeči. Veškeré vykreslování probíhá přes <canvas> element a WebGL, takže obsah není založen na HTML elementech, ale na rasterizovaném výstupu. Tento přístup poskytuje vysoký výkon, ale bez možnosti SEO a SSR.

Renderování	SSR / SEO	Výhody	Omezení
🎮 Canvas / WebGL	❌ Neindexovatelné (čistě klientské)	Plná 3D grafika a fyzika Výborný výkon díky nativní kompilaci Podpora VR / AR, simulací a vizualizací Rozsáhlý Asset Store a pluginy	Žádný SSR, nulové SEO Vyšší velikost buildů (desítky MB) Delší načítání ve webových aplikacích Slabší integrace s klasickým webovým UI

📦 Struktura projektu

/Assets/           ← herní scény, modely, skripty (C#)
/ProjectSettings/   ← konfigurace projektu
/Packages/          ← knihovny a moduly Unity
/Builds/            ← exportované buildy (např. WebGL, Android, Windows)

Unity je ideální volbou pro hry, simulace, VR/AR projekty nebo interaktivní vizualizace, kde je klíčový výkon a vizuální kvalita. Pro klasické webové aplikace ale není vhodné, protože nepoužívá HTML DOM a neumožňuje SSR ani SEO optimalizaci.

Výkonové srovnání

Výkon aplikace ovlivňuje několik faktorů – způsob vykonávání kódu, technologie pro renderování uživatelského rozhraní a to, kde probíhá zpracování dat. Každý framework přistupuje k těmto oblastem jinak. Zatímco React Native používá běhové prostředí JavaScriptu a propojuje se s nativními komponentami přes JSI (JavaScript Interface), Flutter i Kotlin Multiplatform překládají kód přímo do nativních binárek.

⚙️ Obecné principy výkonu

Webové aplikace běží uvnitř prohlížeče v sandboxovaném prostředí, které je omezené bezpečnostními pravidly a strukturou DOMu (Document Object Model). Výkon je zde závislý na efektivitě JavaScriptového enginu a prohlížeče.

Naproti tomu nativní aplikace (včetně React Native, Flutter nebo Kotlin Multiplatform) běží přímo v prostředí operačního systému a mají přístup k nativním vláknům, GPU a systémovým rozhraním. To umožňuje efektivnější využití hardwaru a zajišťuje plynulejší animace, rychlejší odezvu a stabilní FPS.

🌐 Výkon v prohlížeči (web)

Při běhu v prohlížeči jsou všechny technologie omezeny stejným základem – JavaScriptovým enginem (V8, SpiderMonkey, WebKit) a strukturou DOM. Každá změna v rozhraní znamená manipulaci s HTML elementy, což je náročné na CPU i paměť. Frameworky jako Flutter či React Native pro web tento problém obcházejí tím, že renderují do Canvas nebo WebAssembly místo DOMu.

Technologie	Prostředí běhu	Renderování	FPS / Odezva	Poznámka
React / Next.js	Prohlížeč (V8 / WebKit)	HTML + CSS (DOM)	⭐️⭐️⭐️☆ (30–60 FPS)	Rychlé při SSR, ale limitované DOMem
React Native Web	Prohlížeč (V8 / WebKit)	DOM přes adaptér react-native-web	⭐️⭐️⭐️ (nižší výkon kvůli překladové vrstvě)	Výhoda sdílení kódu, mírná ztráta výkonu
Flutter Web	Dart → WebAssembly	Canvas (Skia-like rendering)	⭐️⭐️⭐️⭐️ (plynulý rendering)	Nezávislé na DOMu, GPU akcelerace
Kotlin Multiplatform (Web)	Kotlin → JavaScript / WASM	Compose Web (DOM / Canvas)	⭐️⭐️⭐️ (experimentální)	Vhodné pro jednotný kód, nižší stabilita

➡️ Na webu je největším limitem DOM a JavaScript runtime. Každý re-render nebo animace prochází vrstvou interpretace a bezpečnostních kontrol. Technologie, které používají Canvas nebo WebAssembly (např. Flutter Web), mají díky tomu vyšší FPS a nižší latenci.

📱 Výkon v aplikaci (nativní běh)

Při spuštění jako nativní aplikace už žádný prohlížeč ani DOM neexistuje. Kód běží v prostředí operačního systému (Android, iOS, Windows, macOS) a komunikuje přímo s GPU. React Native používá Hermes VM a JSI pro propojení JavaScriptu s nativními API, Flutter využívá Skia engine a Dart runtime pro přímé vykreslení, a Kotlin Multiplatform kompiluje do LLVM / JVM bytecode.

Technologie	Běhové prostředí	Renderování	FPS / Odezva	Poznámka
React Native	Hermes VM + C++ bridge (JSI)	Nativní komponenty (UIKit / View)	⭐️⭐️⭐️⭐️ (60 FPS stabilně)	Fabric + JSI
Flutter	Dart → ARM / WebAssembly	Canvas (Skia, GPU)	⭐️⭐️⭐️⭐️⭐️ (až 120 FPS)	Vlastní engine, nezávislý na nativním UI
Kotlin Multiplatform	Kotlin → LLVM / JVM	Nativní UI (Compose / SwiftUI)	⭐️⭐️⭐️⭐️⭐️	Stejný výkon jako nativní Swift/Kotlin app
.NET MAUI	.NET runtime (AOT / JIT)	Nativní komponenty (XAML / native)	⭐️⭐️⭐️⭐️	Dobrá integrace, ale větší runtime footprint

➡️ Všechny frameworky vykreslují přímo do GPU nebo nativní vrstvy systému. Výkon je srovnatelný s nativními aplikacemi – nejlépe si vedou Flutter (vlastní rendering engine) a Kotlin Multiplatform (přímý nativní kód). React Native se díky nové architektuře (JSI + Fabric) výkonnostně přibližuje nativním řešením.

🔬 Proč je výkon rozdílný

• DOM overhead (web): Každý vizuální prvek je HTML element s vlastním stromem stylů a událostí. Manipulace s DOMem je největší brzda výkonu.
• Sandbox prohlížeče: JavaScript nemá přímý přístup k systému ani GPU – musí vše řešit přes API prohlížeče.
• Nativní rendering (app): Frameworky jako React Native, Flutter nebo Kotlin vykreslují přímo na GPU, bez prostředníků.
• Multithreading: Nativní runtime může běžet na více vláknech, zatímco web běží převážně jednovláknově (Main Thread + Web Workers).
• Hermes, JSI, Skia: Nové runtime vrstvy (React Native Hermes, Flutter Skia) minimalizují overhead a maximalizují FPS.

⚡ Výkon logiky a zpracování dat

Výkon samotného vykreslení je jen část příběhu. V moderních aplikacích často většinu práce dělá server – výpočty, AI modely, filtrování a agregace dat. Klient pak slouží především jako vizualizační vrstva. Rozdíly ve výkonu se proto nejvíce projeví v rychlosti renderování a odezvě uživatelského rozhraní, nikoli ve výpočetní logice.

💡 Kde probíhá zpracování dat

Moderní architektura aplikací odděluje zpracování dat od prezentace. Ať už jde o React Native, Flutter nebo Kotlin, ve většině případů je ideální provádět veškeré výpočty, AI logiku a transformace dat na serveru, a na klienta posílat už jen hotová nebo agregovaná data. Tím se dosáhne konzistentního výkonu napříč platformami.

Technologie	Zpracování dat	Server-side podpora	Komentář
React / Next.js	Server (SSR / API routes)	✅ Přirozená součást frameworku	Ideální pro datové i AI aplikace
React Native	Primárně klient (JS runtime)	✅ Lze přesunout na server (GraphQL / REST / WS)	Nejlepší sdílený stack web + mobil
Flutter	Klient (Dart VM / nativní kód)	✅ Volání API / WebSocket	UI výpočty rychlé, těžká logika patří na server
Kotlin Multiplatform	Klient (nativní kód)	✅ Sdílený networking layer	Hybridní – můžeš volit, co běží kde
.NET MAUI / Blazor	Klient / Server (dle režimu)	✅ Silná integrace s backendem	Možnost přenést logiku do .NET serveru

🚀 Proč zpracovávat data na serveru

• 💾 Konzistentní výkon – nezáleží na výkonu uživatelského zařízení.
• 🔐 Bezpečnost – citlivé výpočty a AI modely nejsou distribuovány klientům.
• ⚙️ Jednodušší aktualizace logiky – měníš backend, nepublikuješ nové buildy.
• 📊 Predikovatelné výsledky – stejný výpočetní model pro všechny platformy.
• ⚡ Rychlejší UX – klient jen vizualizuje data, nepočítá je.

🧠 Server-driven architektura

Moderní přístup označovaný jako Server-driven UI posouvá hranici mezi frontendem a backendem – server nejen poskytuje data, ale i informace o tom, jak je má klient zobrazit. To umožňuje dynamicky měnit vzhled nebo strukturu rozhraní bez nutnosti aktualizovat aplikaci.

[ Databáze / AI Modely ]
			↓
[ Backend API (Next.js / Node.js) ]
			↓
🔄 GraphQL / REST / WebSocket
			↓
[ React Native / Flutter / Web klient ]
			↓
Prezentace dat (grafy, texty, chaty)

Tento model se v praxi osvědčuje zejména u datových a AI aplikací, kde klienty (mobilní i webové) pouze interpretují výsledky z backendu. Výkon i bezpečnost tak zůstávají plně pod kontrolou serveru.

🧩 Shrnutí

Přístup	Výkon	UX	Udržitelnost	Vhodné pro
Výpočty na klientovi	⚠️ Závislé na zařízení	⚠️ Kolísavé	❌ Nutnost častých aktualizací	Malé offline aplikace
Výpočty na serveru	✅ Stabilní a škálovatelné	✅ Konzistentní	✅ Snadná správa a verzování	Datové a AI aplikace, dashboardy
Hybridní (část lokálně)	✅ Dobré při správném řízení	✅ Offline podpora	⚙️ Vyšší komplexita	Mobilní aplikace s cache / offline režimem

Přístup k hardwaru a systémovým datům

Schopnost aplikace pracovat s nativními senzory, úložišti a daty systému je zásadní rozdíl mezi webovou aplikací a nativním řešením. Zatímco web je omezen bezpečnostním sandboxem prohlížeče, nativní aplikace (React Native, Flutter, Kotlin Multiplatform nebo .NET MAUI) mají přímý přístup k rozhraním systému a mohou využívat kamery, GPS, Bluetooth, biometrické senzory či lokální databáze.

🌐 Webové aplikace

Webové aplikace jsou provozovány v sandboxovaném prostředí prohlížeče, které z bezpečnostních důvodů omezí přímý přístup k systémovým zdrojům. Přístup je umožněn jen k vybraným rozhraním přes tzv. Web API. Tato API poskytují standardizovaný, ale omezený přístup k některým funkcím zařízení.

Typ přístupu	Podpora ve webu	API	Poznámka
Kamera / mikrofon	✅ Ano	navigator.mediaDevices.getUserMedia()	Vyžaduje souhlas uživatele, omezené možnosti nastavení
GPS / poloha	✅ Ano	navigator.geolocation	Přesnost a frekvence měření limitována prohlížečem
Bluetooth / USB	⚠️ Částečně	Web Bluetooth / WebUSB	Experimentální API, nefunguje ve všech prohlížečích
Notifikace	✅ Ano	Notification API	Vyžaduje HTTPS a povolení uživatele
Lokální úložiště	✅ Omezeně	localStorage / IndexedDB	Vhodné pro menší data, žádný přímý přístup k souborům
Kotakty, Apple Health...	❌ Ne	—	Nedostupné z webu (chráněné API)

Webové technologie tedy pokrývají základní interakce, ale nemají přístup k systémovým datům jiných aplikací ani k chráněným rozhraním, jako jsou zdravotní údaje, kontakty nebo senzorické přístroje (např. gyroskop, HRM, NFC). Tyto možnosti jsou dostupné až z nativní vrstvy.

📱 Nativní aplikace (React Native, Flutter, Kotlin, .NET MAUI)

Nativní aplikace běží mimo sandbox prohlížeče a mají přímý přístup k Native API dané platformy. Všechny multiplatformní frameworky zprostředkovávají tento přístup buď přímo (Flutter, Kotlin), nebo pomocí bridge vrstev (React Native, .NET MAUI).

Komponenta / Služba	React Native	Flutter	Kotlin Multiplatform	.NET MAUI	Poznámka
Kamera / mikrofon	✅ react-native-camera	✅ camera	✅ nativní přístup (Swift/Android API)	✅ MediaPicker	Přímý přístup k nativním driverům
GPS / poloha	✅ react-native-geolocation	✅ location	✅ Ktor Location API	✅ Geolocation	Plná přesnost, možnost běhu na pozadí
Bluetooth / NFC	✅ react-native-ble-plx	✅ flutter_blue	✅ nativní rozhraní	✅ Essentials.Bluetooth	Komunikace s IoT, senzory, wearables
Notifikace / push	✅ react-native-push-notification	✅ firebase_messaging	✅ FCM, APNS nativní	✅ NotificationManager	Podpora i offline doručení
Lokální úložiště	✅ AsyncStorage / SQLite	✅ shared_preferences / hive	✅ Local DB (SQLDelight)	✅ SQLite / Preferences	Možnost ukládat větší data, cache, tokeny
Apple Health / Google Fit	✅ Přes nativní bridge (HealthKit API)	✅ health_kit_reporter	✅ Přes KMM interop	⚙️ Přes nativní .NET wrapper	Vyžaduje autorizaci uživatele a API klíče

Tyto frameworky tedy dokážou nabídnout plnohodnotný přístup ke komponentám zařízení – od kamer a mikrofonu až po přímou integraci s Apple Health, Google Fit nebo senzory v chytrých hodinkách. React Native využívá pro propojení JSI (JavaScript Interface), Flutter komunikuje přímo přes MethodChannels, a Kotlin Multiplatform sdílí nativní API mezi platformami pomocí expect/actual konstrukcí.

🧠 Bezpečnost a oprávnění

Každá interakce s hardwarem podléhá oprávněním uživatele. Webová aplikace musí žádat o povolení (např. přístup ke kameře), ale prohlížeč tato oprávnění striktně hlídá a odepírá dlouhodobé přístupy. Naproti tomu nativní aplikace může žádat o trvalé oprávnění (např. sledování polohy na pozadí), což je zásadní pro funkce jako notifikace, fitness tracking nebo IoT senzory.

Typ oprávnění	Web	Nativní aplikace	Rozdíl
Přístup ke kameře / mikrofonu	✅ Po potvrzení (jednorázově)	✅ Po potvrzení (možnost trvalého přístupu)	Nativní může uchovat oprávnění
Přístup k poloze	⚠️ Aktivní jen během relace	✅ Možnost běhu na pozadí	Web neumí trvalé sledování
Zdravotní data (Apple Health, Google Fit)	❌ Nepřístupné	✅ Přes nativní API	Pouze nativní app mohou požádat o HealthKit/Health Connect oprávnění
Souborový systém	⚠️ Jen přes FilePicker API	✅ Plný přístup (sandbox app)	Web nevidí strukturu úložiště

🧩 Shrnutí

Přístup	Web (Next.js / React)	React Native	Flutter	Kotlin Multiplatform	.NET MAUI
Hardware (kamera, GPS, BT)	⚠️ Omezený (Web API)	✅ Přes bridge moduly	✅ Přes MethodChannels	✅ Přímý přístup	✅ Přímý přístup
Data jiných aplikací	❌ Ne	✅ Přes nativní SDK (HealthKit, Contacts)	✅ Přes nativní pluginy	✅ Přes interop	✅ Přes .NET API
Trvalá oprávnění	⚠️ Jednorázová	✅ Možná	✅ Možná	✅ Možná	✅ Možná
Bezpečnostní kontrola	✅ Silná (sandbox)	✅ Řízená OS	✅ Řízená OS	✅ Řízená OS	✅ Řízená OS