MiS - Nejnovější stránky [cs]

Síťové útoky

2026-02-20T10:43:37Z

Spravce: /* 6. Malware šířený sítí */ Oprava nadpisu

== DoS / DDoS útok (Denial of Service) ==

; Cíl
* Způsobit nedostupnost síťového prostředku (typicky webového serveru či připojení k internetu).

; Průběh
# Útočník si vytvoří nebo pronajme botnet (síť napadených počítačů).
#* Každé zařízení je schopné odesílat síťové požadavky na pokyn útočníka.
# Zahájení útoku
#* Botnet začne současně posílat obrovské množství datagramů nebo požadavků na server.
#* Protože se jedná o legitimní požadavky (například zobrazení webové stránky ze serveru) z různých počítačů, není jednoduché útok filtrovat na základě běžných firewallů.
#* Server má omezené prostředky a nestíhá zpracovat všechny požadavky.
# Výsledek
#* Legitimní uživatelé se nedostanou ke službě.
#* Server může úplně spadnout.

== Phishing ==

; Cíl
* Získat citlivé informace o uživateli.
* Typickým cílem jsou přihlašovací údaje do elektronického bankovnictví nebo čísla kreditních karet.

; Průběh útoku
# Příprava falešného prostředí
#* Útočník vytvoří kopii webu (např. banky).
#* Vypadá téměř identicky jako originál.
# Distribuce
#* Pošle e-mail nebo SMS s odkazem.
#* Často používá psychologický nátlak:
#** „Účet bude zablokován“
#** „Potvrďte ihned platbu“
# Získání údajů
#* Oběť zadá:
#** login
#** heslo
#** číslo karty
# Zneužití
#* Útočník se přihlásí do skutečného účtu.
#* Může převést peníze nebo ukrást data.

== Man-in-the-Middle (MITM) ==

; Cíl
* Odposlechnout údaje spojení, které měly zůstat důvěrné.
* Narušit šifrovanou komunikaci.

; Průběh útoku
# Získání pozice mezi komunikujícími
#* Útočník vytvoří falešnou Wi-Fi síť nebo provede ARP spoofing.
# Přesměrování komunikace
#* Oběť si myslí, že komunikuje přímo se serverem.
#* Ve skutečnosti data prochází přes útočníka.
# Odposlech / manipulace
#* Útočník může:
#** číst přenášená data
#** měnit obsah
#** vkládat škodlivý kód
# Nenápadnost
#* Komunikace často pokračuje bez přerušení.
#* Oběť si útoku nevšimne.

== Spoofing (podvržení identity) ==

; Průběh
# Falšování identity
#* Útočník změní identifikační údaje:
#** IP adresu
#** e-mailovou hlavičku
#** DNS záznam
# Navázání důvěry
#* Systém nebo uživatel věří, že komunikace je legitimní.
# Zneužití
#* Útočník může:
#** získat přístup
#** přesměrovat komunikaci
#** spustit další útok.

== Brute-Force útok ==

; Průběh
# Získání cíle
#* Útočník zná přihlašovací stránku nebo účet.
# Automatizované pokusy
#* Program zkouší tisíce hesel za sekundu.
#* Používají se slovníky běžných hesel.
#* Pokud je heslo slabé, je nalezeno velmi rychle.
# Převzetí účtu
#* Útočník získá plnou kontrolu nad účtem a může ho dále zneužít.

== Malware šířený sítí ==

; Průběh
# Distribuce
#* E-mailová příloha
#* stažení z webu
#* exploit zranitelnosti
# Spuštění
#* Uživatel otevře soubor nebo klikne na odkaz.
#* Malware se nainstaluje.
# Skrytá činnost
#* Běží na pozadí:
#** krade data
#** zaznamenává stisky kláves
#** šifruje soubory
# Další šíření
#* Může napadat další zařízení v síti.

== SQL Injection ==

; Průběh
# Nalezení zranitelného formuláře
* Například přihlašovací pole.
# Vložení škodlivého kódu
#* Útočník zadá SQL příkaz místo běžného textu.
# Spuštění databázového dotazu
#* Server příkaz vykoná, protože není správně ošetřen vstup.
# Získání dat
#* Útočník může:
#** zobrazit databázi
#** upravovat záznamy
#** mazat data.

== Společný průběh většiny útoků ==

Typický útok má tyto fáze:

# Průzkum (reconnaissance) – hledání zranitelností
# Proniknutí (exploitation) – využití slabiny
# Udržení přístupu – skrytá přítomnost v systému
# Zneužití – krádež dat nebo narušení služby

Flutter: Ukládání dat

2026-02-16T11:36:00Z

Spravce: /* Nastavení projektu pro Firebase */ Doplněno ověření přihlášení do firebase.

[[Category:VSE]][[Category:Informatika]][[Category:Programování]][[Category:Flutter]]

Pro trvalé uložení dat i po vypnutí aplikace můžeme data uložit:
* na lokální disk konkrétního zařízení
* do síťového úložiště (databáze, cloudové úložiště)
* můžeme rozdělit aplikaci na frontend a backend, kde data budou uložena v backendu (opět obvykle v databázi).

Následuje několik příkladů možných řešení.

== Lokální export: jsonEncode/jsonDecode ==

=== Vlastnosti ===
* Formát JSON lze zpracovávat i v dalších aplikacích – je vhodný pro výměnu dat mezi aplikacemi a je textový.
* Jednoduše lze uložit seznam objektů. Složitější vnořované struktury objektů je třeba ručně převádět.
* Není vhodné pro větší objem dat – převod na text může zvětšit objem dat.
* Vhodné zejména pro textová data: texty, celá čísla, logické hodnoty. Méně vhodné pro desetinná čísla, obrázky, ... z důvodu nutné konverze na text.
* Formát JSON neukládá datové typy.
* Výsledek je uložen lokálně – převod z mobilní aplikace na desktop apod. je třeba řešit ručně.

=== Postup zápisu ===
# Nalezení umístění souboru:
#* Využij balíček <code>path_provider</code> a metodu <code>getApplicationDocumentsDirectory()</code>.
#* Pro zápis do souboru použij třídu <code>File</code> a metodu <code>writeAsString</code>.
# Převod dat na JSON
#* Využij balíček <code>dart:convert</code>.
#* Pro parsování JSON využij metodu <code>jsonDecode(list)</code> – výsledkem bude textová reprezentace objektu ve formátu JSON.

=== Postup čtení ===
# Nalezení umístění souboru:
#* Využij balíček <code>path_provider</code> a metodu <code>getApplicationDocumentsDirectory()</code>.
#* Pro čtení souboru použij třídu <code>File</code> a metodu <code>readAsString</code>.
# Převod dat na JSON
#* Využij balíček <code>dart:convert</code>.
#* Pro ukládání využij metodu <code>jsonEncode(list)</code> – výsledkem bude textová reprezentace objektu ve formátu JSON.

=== Ukázka použití v aplikaci ===
import 'dart:io';
import 'package:flutter/material.dart';
import 'package:path_provider/path_provider.dart';
import 'dart:convert';

void main() {
runApp(const MyApp());
}

class MyApp extends StatelessWidget {
const MyApp({super.key});

@override
Widget build(BuildContext context) {
return MaterialApp(
title: 'Úložiště Demo',
home: HomePage('''storage: FileStorage()'''),
);
}
}

class Zaznam {
final String jmeno;
final int pocet;

const Zaznam({ required this.jmeno, required this.pocet, });

// Převod do JSON
'''Map<String, dynamic> toJson() => {'''
'jmeno': jmeno,
'pocet': pocet,
};

// Obnov z JSON
'''factory Zaznam.fromJson(Map<String, dynamic> json) {'''
return Zaznam(
jmeno: (json['jmeno']),
pocet: json['pocet'] as int,
);
}
}

/// Práce se soubory
'''class FileStorage {'''
'''Future<String> get _localPath''' async {
final directory = await getApplicationDocumentsDirectory();
return directory.path;
}

'''Future<File> get _localFile''' async {
final path = await _localPath;
return File('$path/data.txt');
}

'''Future<String> readFile()''' async {
final file = await _localFile;
return file.readAsString();
}

'''Future<void> writeFile(String content)''' async {
final file = await _localFile;
await file.writeAsString(content);
}
}

/// Stav aplikace včetně zápisu do souboru
class HomePage extends StatefulWidget {
final FileStorage storage;
const HomePage('''{required this.storage}''');
@override
State<HomePage> createState() => _HomePageState();
}

class _HomePageState extends State<HomePage> {
List<Zaznam> _seznam = [];

@override
void initState() {
super.initState();
'''_loadData();''' // Načtení dat při startu
}

'''Future<void> _loadData() async {'''
try {
final jsonString = await widget.storage.readFile();
final List<dynamic> decoded = jsonDecode(jsonString);
setState(() {
_seznam = decoded
.map((item) => Zaznam.fromJson(item as Map<String, dynamic>))
.toList();
});
} catch (e) {
TODO: Zobraz chybové hlášení vhodným způsobem.
}
}

'''Future<void> _saveData() async {'''
final jsonString = jsonEncode(
_seznam.map((z) => z.toJson()).toList()
);
await widget.storage.writeFile(jsonString);
}

void _addRecord() {
setState(() {
_seznam.add(Zaznam(
jmeno: 'Josef',
pocet: 1000,
));
});
'''_saveData();'''
}

@override
Widget build(BuildContext context) {
return Scaffold(
// ... vytvoř GUI
);
}
}

=== Tip ===
* Pro větší objemy dat či komplexnější data lze pro export do formátu JSON využít balíček <code>json_serializable</code>.

=== Zdroje ===
* [https://hatchjs.com/list-to-json-flutter/ HatchJS.com > How to Convert a List to JSON in Flutter]
* [https://docs.flutter.dev/data-and-backend/serialization/json Flutter Docs > JSON and serialization]
* [https://docs.flutter.dev/cookbook/persistence/reading-writing-files Flutter Docs > Read and write files]

== Lokální databáze: Hive ==

* Data ukládá binárně, ale stále na lokální zařízení.

=== Zdroje ===
* [https://medium.com/@ChanakaDev/hive-vs-shared-preferences-10353068a8a6 Medium.com: ChanakaDev > Hive vs. Shared Preferences]

== Google Firestore ==

* Cloud Firestore je cloudová NoSQL databáze od Google, která je součástí platformy Google Firebase.

=== Vlastnosti Cloud Firestore ===

; Výhody a nevýhody
* Firebase je dobře integrovaná do frameworku Flutter (Flutter také vyvíjí Google)
* Data se ukládají do cloudu – data může sdílet mobilní i webová aplikace
* Synchronizace dat v reálném čase
* Pro přístup k datům je potřeba připojení k internetu
* Pro malé projekty stačí varianta zdarma (pro větší bude třeba platit)

; Struktura dat ve Firestore
* Data se neukládají do entit jako u ER databází – spíše jako několik seznamů objektů.

Pojmy
* Dokument (Document) ... konkrétní záznam (jako jeden řádek v databázi) – například údaje o jednom uživateli.
* Pole (Field) ... konkrétní hodnota (atribut) – například jméno uživatele
* Kolekce (Collection) ... odpovídá entitě v ER databázích – je to vlastně seznam dokumentů
* Databáze (Database) ... skupina souvisejících kolekcí
* Projekt (Project) ... jeden projekt obvykle odpovídá jednomu softwarovému produktu. Může zahrnovat různé podoby jedné aplikace:
** IOS
** Android
** webová aplikace
** Unity
** Flutter multiplatformní aplikace

Příklad:
users (kolekce)
└── user1 (dokument)
├── name: "Jan"
├── age: 18
└── email: "jan@email.cz"

=== Nastavení projektu pro Firebase===

; Založení projektu na webu Firebase
#Jdi na: [https://console.firebase.google.com Console.firebase.google.com]
#Klikni na Vytvořit projekt a zadej název projektu
#Po vytvoření přidej aplikaci (Android / iOS / Web)

; Instalace FlutterFire CLI
# Nainstaluj Firebase CLI podle [https://firebase.google.com/docs/cli návodu z  Firebase.google.com > CLI]
#* Bude nejspíš vyžadovate heslo správce počítače.
# Přihlaš se: <code>firebase login</code>
#* Musíš rozhodnout, jestli budeš využívat Google Gemini v rámci Firebase a jestli může Google využívat statistická data.
#* Zvolíš účet Google, pod kterým budeš pracovat
#* Ověř funkčnost pomocí: <code>firebase projects:list</code> – mělo by vypsat seznam založených projektů
# Založ projekt ve Flutteru jako obvykle
# Ve složce projektu spusť aktivaci FlutterFire CLI:
#: <code>dart pub global activate flutterfire_cli</code>
#: <code>flutterfire configure --project='''nazev-projektu'''</code>
#: Do projektu tím přibude konfigurační soubor: <code>lib/firebase_options.dart</code>



; Inicializuj Firebase v main.dart:
import 'package:firebase_core/firebase_core.dart';
import 'firebase_options.dart';

// ...

await Firebase.initializeApp(
options: DefaultFirebaseOptions.currentPlatform,
);


; Další plug-iny importuj dle potřeby viz dále

=== Import Firestore ===

Import:

import 'package:cloud_firestore/cloud_firestore.dart';

Vytvoření instance pro přístup k databázi:

final FirebaseFirestore db = FirebaseFirestore.instance;

=== Přidání nového dokumentu ===
await db.collection('users').add({
'name': 'Jan',
'age': 18,
'email': 'jan@email.cz',
});

Tím se:
# vytvoří kolekce users (pokud neexistuje)
# přidá nový dokument s automatickým ID

; Uložení dokumentu s vlastním ID
await db.collection('users').doc('student1').set({
'name': 'Petra',
'age': 17,
});

=== Čtení dat z Firestore jednorázově===

var snapshot = await db.collection('users').get();

for (var doc in snapshot.docs) {
print(doc.data());
}

=== Čtení v reálném čase ===

Firestore umožňuje poslouchat změny. Data se pak automaticky aktualizují, pokud proběhne změna v databázi (například z jiného zařízení připojeného ke stejnému projektu):

StreamBuilder(
stream: db.collection('users').snapshots(),
builder: (context, snapshot) {
if (!snapshot.hasData) {
return CircularProgressIndicator();
}

var docs = snapshot.data!.docs;

return ListView(
children: docs.map((doc) {
return ListTile(
title: Text(doc['name']),
);
}).toList(),
);
},
);

=== Aktualizace dat===
await db.collection('users').doc('student1').update({
'age': 18,
});

=== Smazání dat===

; Smazání dokumentu
await db.collection('users').doc('student1').delete();

=== Bezpečnostní pravidla (Rules) ===

Ve Firebase konzoli nastav pravidla přístupu.

Například pouze pro přihlášené uživatele:

rules_version = '2';
service cloud.firestore {
match /databases/{database}/documents {
match /{document=**} {
allow read, write: if request.auth != null;
}
}
}

=== Zdroje ===
* Základ sekce o Firebase byl vytvořen pomocí služby [https://www.chatgpt.com ChatGPT].
* [https://console.firebase.google.com/ Console.firebase.google.com > Postup nastavení projektu]
* [https://www.youtube.com/playlist?list=PLl-K7zZEsYLluG5MCVEzXAQ7ACZBCuZgZ YouTube.com > Get to know Cloud Firebase] (seriál videí)
* [https://cloud.google.com/firestore/pricing Google Cloud > Firestore Pricing]

== Vlastní backend: ServerPod ==

* Framework, který umožňuje vytvořit projekt Flutteru se dvěma částmi: backendem a frontendem.
* Backend je následně možné spustit na svém serveru.
* Frontend běží na desktopu.

Moodle GIFT

2026-02-16T05:35:18Z

Spravce: Vytvoření kostry stránky a multichoice otázka.

[[Category:VSE]][[Category:Informatika]][[Category:Jiné]]

GIFT je otevřený formát Moodle pro popis testových otázek.

== Multichoice ==

//TODO!!!
::oblast_nazev0XY::
Vyberte správná tvrzení o ...:
[Vyber všechny správné odpovědi. Za nesprávné odpovědi dostáváš záporné body]
{
~%20%Správná A
~%40%Správná B
~%40%Správná C.#Komentář k odpovědi k zobrazení ve výsledcích
~%-20%Špatně X
~%-20%Špatně Y
}

== Zdroje ==
* [https://docs.moodle.org/501/en/GIFT_format Moodle.org > GIFT format]

Flutter: ListView

2026-01-26T09:37:17Z

Spravce: Formátování, upřesnění title a subtitle

[[Category:VSE]][[Category:Informatika]][[Category:Programování]][[Category:Flutter]]

== ListView ==
* <code>ListView</code> slouží pro zobrazení dynamického seznamu položek, kterým lze skrolovat.
* Lze ho využít například pro zobrazení položek ze seznamu či pro položky, které přidáváme postupně.

== Příklad zobrazení seznamu ==
* Pro zobrazení seznamu <code>seznam</code> můžeme použít ListView:
List<Element> seznam = ...;

Expanded(
child: ListView.builder(
itemCount: _seznam.length,
itemBuilder: (context, index) {
return ListTile(
title: Text('${_seznam[index].nazev}'),
subtitle: Text('${_seznam[index].popis}'),
);
},
),
),

== Vytvoření ListView ==

=== ListView.builder() ===
* Používá se pro delší nebo dynamické seznamy (nejčastější varianta).
* Vytváří položky až když jsou potřeba (lepší výkon)

ListView.builder(
itemCount: 10,
itemBuilder: (context, index) {
return ListTile(
title: Text('Položka $index'),
);
},
)

=== ListView(children: []) ===
* Vhodné pro krátké statické seznamy — nelze přidávat položky.

ListView(
children: [
ListTile(title: Text('Položka 1')),
ListTile(title: Text('Položka 2')),
ListTile(title: Text('Položka 3')),
],
)

== ListTile: položka seznamu ==

* Jednu položku dynamického seznamu reprezentuje widget <code>ListTile</code>

; Vlastnosti <code>ListTile</code>:
* <code>title</code> – hlavní text (nadpis položky)
* <code>subtitle</code> – doplňující popis položky
* <code>leading</code> – ikona vlevo
* <code>trailing</code> – ikona vpravo
* <code>onTap</code> – reakce na kliknutí

; Příklad použití:

ListTile(
leading: Icon(Icons.person),
title: Text('Karel Dvořák'),
subtitle: Text('místnost: 33'),
trailing: Icon(Icons.arrow_forward),
onTap: () {
_reakceNaKlik;
},
)

== Související stránky ==
* [[Flutter: Základní widgety]]
* [[Flutter: Kostra aplikace]]

Základní pojmy Linuxu

2025-09-10T05:12:24Z

Spravce: /* Úvod do Linuxu */ Oprava formátu.

[[Category:VSE]][[Category:Informatika]][[Category:Linux]]

== Úvod do Linuxu ==

* Z pohledu běžného uživatele je Linux obdobný operační systém jako každý jiný.
* Při přechodu z Windows je ale dobré seznámit se s pojmy, které ve světě Windows nejsou.

== Distribuce ==

* Linux je ve skutečnosti jádro operačního systému (''kernel'').
* Běžní uživatelé říkají, že si "nainstalovali Linux".
* Ve skutečnosti si instalují některý operační systém, založený na Linuxu, protože aby mohli jádro využívat, musí být doplněno o další nástroje a programy.
* Operační systémy, založené na Linuxu, se označují ''distribuce Linuxu''.
* Jednoduše: distribuce = jádro Linux + software + nástroje pro instalaci a správu.
* Příklady známých distribucí jsou Red Hat, Debian, Fedora, Ubuntu, Slackware a další.
* Více o distribucích viz [[Distribuce GNU/Linuxu]].

== Stažení a instalace ==

* Při hledání instalačních zdrojů možná narazíš na pojmy, které nebudeš z Windows znát.
* Konkrétní označení a nabídka se ale může lišit podle konkrétní distribuce. Některé distribuce nabízí variant více, jiné méně. Můžou také stejné věci označit jinak.

=== Live DVD vs. netinst ===

* ''Live DVD'' je instalační obraz, ze kterého jde operační systém spustit bez nutnosti instalace. Bývá větší (minimálně cca 700 MB) a obsahuje zákadní software pro běžnou práci na počítači: kancelářský software, grafický editor, uživatelské rozhraní a další.
* ''netinst'' je minimální verze instalátoru, která pouze nastartuje instalaci a samotné balíčky již stahuje z internetu. Pro běžné instalace je nejvhodnější – stáhnete si pouze to, co potřebujete. Velikost obrazu je obvykle cca 350 MB.

=== Stable vs. testing ===

* Při vývoji distribucí tvůrci obvykle nabízí možnost získat nejaktuálnější variantu, která ale ještě nemusí být dobře otestována. Obvykle se označuje jako ''testing''.
* Pro produkční servery a pro výuku začátečníků doporučujeme spíš variantu ''stable''.

=== Cílová architektura procesoru: amd64, x86, ... ===

* Při volbě instalátoru si musíš vybrat cílovou architekturu procesoru. Linux totiž neběží jen na procesorech pro architekturu IBM PC, ale i ARM a dalších.
* Pokud instaluješ Linux na běžné PC, hledej označení: ''amd64'', ''x86-64'', ''x86'' (obvykle 32bitová verze).
* Je jedno, jestli máš procesor AMD či Intel – oba výrobci používají stejnou architekturu. Označení ''amd64'' vzniklo historicky a funguje i pro procesory Intel.
* Další běžně používané architektury bývají: ''arm64''. Nabídka se může lišit pro různé distribuce.

== Grafická prostředí pro Linuxu ==

* Linux se nejčastěji ovládá z příkazového řádku, protože je to praktické pro servery.
* Pro stolní počítače ale můžeš využít grafická prostředí.
* Mezi nejběžnější grafická prostředí patří: ''GNOME'', ''KDE'', ''Xfce''.

== Odlišnosti Linuxu ==

=== Modularita ===

=== Svobodný software ===

Dart: Užitečné tipy

2025-03-11T02:33:54Z

Spravce: Doplněno trim() a toString(), lepší formátování.

[[Category:VSE]][[Category:Informatika]][[Category:Programování]][[Category:Flutter]]

== Vstup a výstup ==

=== Konec řádku ===
Platform.lineTerminator
* Ukončení řádku odpovídající použité platformě (<code>\n</code>, <code>\r\n</code> nebo <code>\r</code>).
* Je třeba naimportovat:
import 'dart:io';

=== Konverze čísel a textů ===

int.parse(''text'')
double.parse(''text'')
* Převod textového zápisu na číselnou hodnotu.

''text''.trim()
* Odstraní úvodní a závěrečné mezery z textu.

''num''.toString()
* Převede číselnou hodnotu na textový zápis.

''num''.toStringAsFixed(2)
* Převede číslo <code>num</code> na text, zaokrouhlený na zadaný počet desetinných míst.

Flutter: Základní widgety

2025-02-21T06:18:40Z

Spravce: /* Jednoduchý dialog */ Lépe struktorováno, přidány příklady dialogů, připraveno na budoucí osamostatnění.

[[Category:VSE]][[Category:Informatika]][[Category:Programování]][[Category:Flutter]]

== Uspořádání stránky ==

Center( child: ... )
* Vycentruje obsah uvnitř widgetu.

Column(
mainAxisAlignment: MainAxisAlignment.center,
children: <Widget>[ ... ]
)
* Vloží blok více prvků poskládaných pod sebe.

Padding(
padding: EdgeInsetsGeometry.all(20),
child: ...
)
* Všechny prvky budou odsazeny navzájem o 20 pixelů.

Expanded( child: ... )
* Tato část okna se bude roztahovat při zvětšování okna.

== Textová pole ==
TextField(
controller: _abcController,
decoration: const InputDecoration(
labelText: 'Nadpis pole – viditelný popisek:',
),
keyboardType: TextInputType.number, // Pokud chceme omezit vstup na číselné hodnoty
),

; Parametry widgetu

enabled:
* Aktivní/zakázané textové pole.
* Zakázané textové pole je šedivé a nejde do něj umístit kurzor.

readOnly:
* Textové pole pouze pro čtení – ale není šedivé a lze do něj umístit kurzor

onChanged: (text) { ... }
* Metoda, která se zavolá při změně obsahu tlačítka.
* Metoda musí přijímat jako parametr text.

; Kontroler textového pole
final TextEditingController _abcController = TextEditingController();
* Pro práci s obsahem textového pole slouží <code>TextEditingController</code>.

final double totalPrice = double.parse(parsedValue = _abcController.text.trim());
* Přístup k obsahu textového pole zprostředkovává atribut <code>.text</code>.
* Obdobně lze <code>int.parse(...)</code>.

_abcController.dispose()
* Při uvolňování paměti by měly být řádně uvolněny i kontrolery metodou <code>dispose()</code>.

; Nastavení vzhledu <code>InputDecoration</code>

contentPadding: EdgeInsets.all(20.0),
* Odsazení obsahu

border: OutlineInputBorder(),
* Ohraničení textového pole

labelText: 'text'
* Popiska textového pole.
* Když je pole prázdné, text je v poli.
* Jakmile uživatel pole vyplní, popiska se přesune do rámečku textového pole.

hintText: 'Text'
* Nápověda – co má uživatel zadat do pole.
* Po zadání textu do pole text zmizí.

== Tlačítka ==
ElevatedButton(
onPressed: _nazevMetodyReakce,
child: const Text('Popis tlačítka'),
),

; Vlastnosti:

onPressed:
* Název metody, která se vyvolá při stisknutí tlačítka.
* Obecně může být vložena akce i přímo

child:
* Obsah tlačítka – popis, ikona, obrázek, ...

== ListView ==
* Pro zobrazení dynamického seznamu prvků.
* Více viz samostatná stránka [[Flutter: ListView]].

== Odsazení ==
SizedBox(height: 10),

Příklad použití:
Column(
const Text('Hello'),
const Sizedbox(height: 10),
const Text('World!'),
)

== Textová popiska ==
const Text('Záznamy o tankování:',),

== Vyskakovací bublina (Toast) ==

* V mobilních aplikacích se pro stručná oznámení používá spíše vyskakovací bublina, než vyskakovací okno.

setState(() {
ScaffoldMessenger.of(context).showSnackBar(
SnackBar(
content: Text('Informace pro uživatele')
),
);
});

== Jednoduchý dialog ==

Pro vytvoření jednoduchého dialogu slouží třída <code>AlertDialog</code>.
; Parametry konstruktoru <code>AlertDialog</code>
title: const Text('Titulek dialogu')
content: const Text('Zpráva dialogu...')
actions: [ ''seznam akcí/tlačítek'' ]

; Příklad – Jednoduchý dialog s jedním tlačítkem
AlertDialog(
title: const Text('Skutečně smazat položku'),
content: const Text('Soubor neobsahuje platná data!'),
actions: [
TextButton(
onPressed: () => Navigator.pop(context),
child: const Text('OK'),
),
]
)

; Příklad – Potvrzovací dialog se dvěma tlačítky
AlertDialog(
title: const Text('Upozornění'),
content: const Text('Skutečně chcete smazat položku XYZ?'),
actions: [
'''TextButton('''
onPressed: () => {
setState(() { ''_akceSmazSkutecne();'' };);
_akceUloz();
Navigator.pop(context);
},
child: const '''Text('Smaž'),'''
'''),'''
'''TextButton('''
onPressed: () => Navigator.pop(context),
child: const '''Text('Zrušit'),'''
'''),'''
]
)

=== Vyvolání dialogu ===

; Metoda pro různá hlášení

Můžeme připravit metodu pro vyvolání obecného dialogu:
Future<void> ukazHlaseni(String messageText) => showDialog<void>(
context: context,
builder: (context) {
return AlertDialog( ''...'' );
},
);

Metodu následně voláme:
ukazHlaseni('Text');

; Volání přímo v kódu

Můžeme také dialog vytvořit a rovnou ho zavolat:
showDialog(
context: context,
builder: (context) => AlertDialog( ''...'' ),
)

Flutter: Kostra aplikace

2025-02-21T06:08:36Z

Spravce: Do uspořádání body přidáno `Padding` místo `Center` jako výchozí.

[[Category:VSE]][[Category:Informatika]][[Category:Programování]][[Category:Flutter]]

== Základní kostra aplikace s měnícím se obsahem ==

Metoda <code>main()</code> — zde se začne provádět program:

void main() {
runApp(const MainApp());
}

; StatelessWidget – neměnná část aplikace.

* Základ aplikace je neměnný. Pokud bychom měli aplikaci ``Hello World`` a podobné, stačilo by nám jejich vzhled nadefinovat v hlavní třídě.
* Části, které se musí překreslit nebo které mění obsah, jsou součásti stavu aplikace.

class MainApp extends StatelessWidget {
const MainApp({super.key});

@override
Widget build(BuildContext context) {
return const MaterialApp(
home: XyzMainPage(title: 'Název aplikace'),
);
}
}

; StatefulWidget – část UI, která se musí překreslit v průběhu životního cyklu aplikace.

class XyzMainPage extends StatefulWidget {
const XyzMainPage({super.key, required this.title});

final String title;

@override
State<XyzMainPage> createState() => _XyzMainPageState();
}

; Reprezentace aktuálního stavu aplikace – State

class _XyzMainPageState extends State<XyzMainPage> {

// Data aplikace

// Metody pro práci s daty
// Controllery tlačítek

void _akceProvadejiciZmenuStavuOkna() { // Například reakce na stisk tlačítka.
setState(() { ... });
}

@override
void dispose() { // Uvolnění případných kontrollerů, pokud jsou.
_abcController.dispose();
super.dispose();
}

@override
Widget build(BuildContext context) {
return Scaffold(
appBar: AppBar(
backgroundColor: Colors.green,
title: Text(widget.title),
),
body: Padding(
padding: const EdgeInsets.all(20.0),
child: Column(
mainAxisAlignment: MainAxisAlignment.center,
children: <Widget>[

// Widgety v hlavním okně

],
),
),
floatingActionButton: FloatingActionButton(
onPressed: _metodaProvedeniAkce,
tooltip: 'Nápověda k tlačítku',
child: const Icon(Icons.add),
),
);
}
}

== Související stránky ==
* Základní widgety pro vytvoření obsahu okna: [[Flutter: Základní widgety]].

Profesní prezentace

2025-01-12T06:44:51Z

Spravce: Přidána obecná doporučení.

[[Category:VSE]][[Category:Informatika]][[Category:Jiné]]

Nástroje pro profesní prezentaci umožňují IT profesionálovi prezentovat své možnosti potenciálním zákazníkům a zaměstnavatelům.

== LinkedIn ==

* Sociální síť, určená pro profesní prezentaci.
* Umožňuje vystavit elektronickou verzi životopisu a průběžně ji aktualizovat.
* Můžete také zadat, zda hledáte práci a filtrovat, o jakou práci máte zájem (plný nebo částečný úvazek, možnost práce z domu,..).
* Potenciálním zaměstnancům i zaměstnavatelům umožňuje filtrovat nabídky.
* V oblasti IT se jedná o běžný způsob oslovení potenciálních zaměstnavatelů a zaměstnanců.

== Doporučení pro tvorbu životopisu ==

* Životopis (anglicky ''resume'') je prvním kontaktem mezi vámi a zaměstnavatelem.
* Nikdy v životopisu nelžete! Údaje jsou snadno ověřitelné.
* Uvádějte přesné údaje (dokončení studia, začátek a konec předchozích pracovních poměrů,...).
* Kontrolujte pečlivě gramatiku a překlepy!

== Obecná doporučení ==
* Sledujte svou digitální stopu a pracujte s ní.
* Zdůrazněte, že umíte a jste připraveni růst.
* Nepředstírejte něco, co nejste.
* Znejte své přednosti a zdůrazněte je.

== Zdroje ==
* [https://www.cnbc.com/2024/11/26/biggest-resume-red-flags-from-recruiter-whos-interviewed-thousands.html Biggest resume red flags. CNBC.com]
* [https://www.linkedin.com/business/sales/blog/profile-best-practices/17-steps-to-a-better-linkedin-profile-in-2017 17 steps to a better LinkedIn profile in 2017. LinkedIn]

Dart vs. Java

2024-09-22T05:34:25Z

Spravce: Přidána syntaxe try-on-catch.

[[Category:VSE]][[Category:Informatika]][[Category:Programování]][[Category:Java]][[Category:Flutter]]

== Dart vs. Java ==

* Na této stránce shrnujeme základní rozdíly mezi programovacími jazyky Dart a Java.
* Stránka je určena pro čtenáře, kteří již znají Javu a chtějí se rychle zorientovat v jazyce Dart.

<div class="Poznamka">
Syntaxi si můžete vyzkoušet například na:
* [https://dartpad.dev/ Dartpad.dev]
* [https://www.tutorialspoint.com/execute_dart_online.php TutorialsPoint.com → Execute Dart Online]
</div>

== Hello world ==

* Pro metodu <code>main</code> nemusíme vytvářet zapouzdřující třídu.
* Parametry metody <code>main</code> jsou volitelné, pokud je nevyužíváme, nemusíme je uvádět.
* Výpis na obrazovku se řeší příkazem <code>print</code>.

main(){
print("Hello, World!");
}

== Datové typy ==

* Dart nepoužívá primitivní datové typy, všechny typy jsou objektové.
* Dart má vestavěné datové typy, pro které lze vytvářet literály (konkrétní hodnoty) přímo v kódu:
** Číselné typy: <code>int</code>, <code>double</code>
** Textové typy: <code>String</code>
** Logické hodnoty: <code>bool</code> (literály: <code>true</code>, <code>false</code>)
** Záznamy: <code>(hodnota1, hodnota2)</code>
** Kolekce: <code>List</code>, <code>Set</code>, <code>Map</code>, <code>Runes</code>, <code>Symbol</code>
** Prázdnou hodnotu: <code>Null</code>

Více viz: [https://dart.dev/language/built-in-types Dart.dev > Built-in Types].

== String ==

* Textové literály uvozujeme uvozovkami nebo apostrofy (běžněji se využívá apostrof – bohužel pro ty, kdo píší na české klávesnici).
* Víceřádkové texty lze uvozovat třemi apostrofy.
'Text'
"Text"
"""Víceřádkový
text"""
* Spojení (concatenate) textů můžete provádět pomocí operátoru <code>+</code> nebo tím, že je zapíšete za sebe:
String text = 'Dart' 'is' 'fun';
String text = 'Dart'+'is'+'fun';
* Pro vložení hodnot do textu můžete využít znak <code>$</code>, který uvozuje vloženou hodnotu. Hodnotu lze ohraničit <code>${...}</code>:

print('Seznam $data má největší prvek ${getMax(data)}');

Více o textech v Dartu: [https://api.dart.dev/stable/3.5.3/dart-core/String-class.html Dart.dev → String class].

== Práce se seznamy ==

* Do seznamu v Dartu lze vkládat i prvky primitivních datových typů.
* Lze vytvořit literál seznamu přímo v kódu pomocí znaků <code>[</code> a <code>]</code>.

List<int> ids = [1, 2, 3];
ids.add(6);

* Získání prvku ze seznamu:

print(ids[0]);

* Metoda <code>print</code> umí vypsat obsah seznamu.

print(ids);

* Počet prvků seznamu:

print(ids.length)

* Spojení prvků ze seznamu do jednoho textového řetězce:

list.join(delimiter);
ids.join(',');

* Více o práci se seznamy v Dartu viz například: [https://www.codevscolor.com/dart-insert-items-to-list CodeVsColor → Dart insert items to list].

== Zápis tříd ==

* V Dartu můžeme umístit více tříd do jednoho souboru.

=== Přístupnost vlastností tříd ===

* Dart nepoužívá modifikátory přístupu <code>public</code>, <code>private</code> a <code>protected</code>.
* Všechny vlastnosti (atributy a metody) tříd jsou přístupné v rámci jednoho souboru, případně v rámci jedné knihovny (library).
* Veřejné vlastnosti jsou přístupné i z ostatních knihoven (souborů).
* Privátní vlastnosti se odlišují tak, že jejich název začíná podtržítkem.
* Přístupové metody se označují klíčovými slovy <code>get</code> a <code>set</code>.

class A {
String first;
String _second;

String get second {
return _second;
}

void set second(String second) {
this._second = second;
}
}

void main() {
A a = new A();
a.first = 'x';
a.second = 'y';
}

Více viz: [https://www.woolha.com/tutorials/dart-using-access-modifiers-private-public Woolha.com > Dart using Access Modifiers] a [https://www.fluttersolution.com/2023/04/understanding-access-modifiers-in-dart.html FlutterSolution > Understanding Access Modifiers in Dart].

=== Zkrácený zápis metod s návratovou hodnotou ===
* Pro krátké metody můžeme využít syntaxi s <code>=></code>:
class Osoba {
String _name = "Karel";

String get name => _name;
set name(String name) => _name = name;
}

void main() {
Osoba osoba = new Osoba();
osoba.name = "Ivan";
print(osoba.name);
}
Místo delšího:
//...
String get getName {
return _name;
}
void set setName(String name) {
_name = name;
}
//...

== Parametry metod ==
* Poziční (''position'') parametry metod píšeme stejně jako v Javě:

void metoda(String text, int cislo) { ... }

metoda('Text', 30);

* Lze ale také použít pojmenované parametry (''named''). Potom nezáleží na pořadí argumentů, ale každý z argumentů musí být uvozen názvem:

void metoda({required String text, required int cislo}) { ... }

metoda(cislo: 30, text: 'Text');
metoda(text: 'Text', cislo: 30);

* Lze také uvést výchozí hodnotu parametru. Pak se jedná o volitelný (''optional'') parametr, který nemusíme uvádět.

Viz také: [https://blog.stackademic.com/dart-function-parameters-in-flutter-positional-vs-named-with-examples-fc475da97f7c StackAcademic.com > Dart Function Parameters in Flutter].

== Výjimky a jejich řešení ==

* <code>throw</code> může vyhazovat obecně libovolný datový typ. (Ne, že by byl až tak dobrý nápad vyhazovat něco, co není potomek <code>Exception</code>.)
* Odchycení výjimky:
try {
// Kód, kde může nastat chyba
} on XYException catch (ex) {
// Ošetření chyby typu XYException
} on Exception catch (ex) {
// Ošetření všech chyb, které jsou potomky Exception
} catch (error) {
// Ošetření všech ostatních chyb - nejen těch, které vyhazují Exception.
}

== Komentáře ==
* Jednořádkové a víceřádkové komentáře se píší stejně jako v Javě:
// One-line comment
/* Multi-line/inline comment */

* Dokumentační komentář se uvozuje třemi lomítky jako v C# (lze použít i notaci z Javy, ale není doporučovaná):
/// Saturated water pressure according to Antoine equation
/// Depends on outer [temperatureC] in degrees of Celsius.
double saturatedWaterPressureAntoine(double temperatureC) {
/// Compute exponent using [Math.pow()] function:
return pow(10, (8.07131 - (1730.63/(233.426 + temperatureC)))) as double;
}

== Style: konvence pojmenování ==

; PascalCase (UpperCamelCase)
* Názvy tříd
* Názvy výčtových typů

class Customer { ... }

; lowercase_with_underscores
* Názvy souborů
* Název projektu/aplikace
* Názvy prefixů pro import

Cílem je zajistit kompatibilitu s různými souborovými systémy, které nemusí rozlišovat velká a malá písmena (case-insensitive).

; camelCase (LowerCamelCase)
* Všechno ostatní ;)
* Na rozdíl od Javy se doporučuje i pro pojmenování konstant. (Z hlediska konzistence s existujícími knihovnami se povoluje i SCREAMING_CASE.)

const defaultTimeout = 1000;

Více o konvencích zápisu kódu viz: [https://dart.dev/effective-dart/style Dart.dev → Style].

== Související stránky ==
* [[Flutter: Kostra aplikace]]
* [[Flutter: Základní widgety]]
* [[Dart: Užitečné tipy]]
* Další stránky v [[:Category:Flutter|kategorii Flutter]]