Tworzenie aplikacji (Desktop i Mobile)

<LinearLayout
  android:layout_width="match_parent"
  android:layout_height="match_parent"
  android:orientation="vertical"
  android:padding="16dp">

  <TextView
      android:id="@+id/etykietaLogin"
      android:layout_width="wrap_content"
      android:layout_height="wrap_content"
      android:text="Login uzytkownika" />

  <EditText
      android:id="@+id/poleLogin"
      android:layout_width="match_parent"
      android:layout_height="wrap_content"
      android:inputType="text" />

  <CheckBox
      android:id="@+id/polePamietaj"
      android:layout_width="wrap_content"
      android:layout_height="wrap_content"
      android:text="Zapamietaj mnie" />

  <Button
      android:id="@+id/przyciskZaloguj"
      android:layout_width="match_parent"
      android:layout_height="wrap_content"
      android:text="Zaloguj" />

</LinearLayout>

• Układ liniowy (LinearLayout, StackPanel, BoxLayout) — kontrolki jedna za drugą, w pionie albo w poziomie.
• Układ siatkowy (GridLayout, TableLayout) — wiersze i kolumny, idealny do formularzy „etykieta + pole".
• Układ brzegowy (BorderLayout, DockPanel) — pięć obszarów: góra, dół, lewo, prawo, środek. Typowy dla okna z paskiem narzędzi i paskiem stanu.
• Układ względny (RelativeLayout, ConstraintLayout) — pozycję określa się przez relacje: „pod polem tekstowym", „wyrównaj do prawej krawędzi rodzica". Najelastyczniejszy i zalecany w Androidzie.
• Kotwiczenie i dokowanie (właściwości Anchor i Dock w WinForms) — kontrolka trzyma się wybranych krawędzi okna przy zmianie jego rozmiaru.

• Spójność — ta sama czynność wygląda i nazywa się tak samo na każdym ekranie. Przycisk zatwierdzający zawsze po tej samej stronie, ikona zapisu zawsze ta sama, konsekwentne nazewnictwo (albo wszędzie „Usuń", albo wszędzie „Skasuj").
• Czytelność — wystarczający kontrast tekstu do tła, czcionka odpowiedniej wielkości, grupowanie powiązanych pól, odstępy zamiast ramek wszędzie. Na ekranie dotykowym obszar klikalny nie mniejszy niż mniej więcej 48 dp, żeby dało się trafić palcem.
• Informacja zwrotna — użytkownik musi wiedzieć, że system przyjął jego akcję: przycisk zmienia wygląd po naciśnięciu, przy długiej operacji pojawia się pasek postępu, po zapisie krótki komunikat. Milczący interfejs użytkownik klika drugi raz i tworzy duplikat rekordu.
• Zapobieganie błędom — lepiej nie dopuścić do błędu, niż go potem zgłaszać. Data wybierana z kalendarza zamiast wpisywana ręcznie, pole numeryczne z klawiaturą numeryczną, przycisk „Zapisz" nieaktywny, dopóki formularz jest niekompletny, pytanie o potwierdzenie przed nieodwracalnym usunięciem i możliwość cofnięcia operacji.
• Czytelne komunikaty błędów — komunikat mówi, co jest źle i co zrobić („PESEL musi mieć 11 cyfr"), a nie „Error 0x8004".
• Dostępność — opisy tekstowe kontrolek dla czytników ekranu (w Androidzie atrybut contentDescription), obsługa całego interfejsu z klawiatury, sensowna kolejność przechodzenia tabulatorem, brak przekazywania informacji wyłącznie kolorem — dodaj ikonę albo podpis, bo osoba z zaburzeniem widzenia barw koloru nie odróżni.
• Responsywność — układ dopasowuje się do rozmiaru i orientacji ekranu. W Androidzie służą do tego osobne katalogi zasobów (na przykład layout-land dla orientacji poziomej i warianty według szerokości ekranu), w aplikacjach webowych — zapytania medialne CSS i siatki elastyczne.

zbuduj okno i kontrolki
zarejestruj procedury obslugi zdarzen

dopoki aplikacja dziala:
  zdarzenie = pobierz_z_kolejki()      // klik, klawisz, dotyk, timer
  jesli zdarzenie == ZAMKNIJ_OKNO:
      przerwij petle
  procedura = znajdz_obsluge(zdarzenie.zrodlo, zdarzenie.typ)
  jesli procedura istnieje:
      procedura(zdarzenie)             // TU wykonuje sie TWOJ kod
  odrysuj to, co sie zmienilo

zwolnij zasoby i zakoncz proces

// C# / WinForms - podpiecie metody do zdarzenia Click
przyciskZaloguj.Click += PrzyciskZaloguj_Click;

private void PrzyciskZaloguj_Click(object sender, EventArgs e)
{
  if (poleLogin.Text.Trim() == "")
  {
      MessageBox.Show("Podaj login.");
      return;
  }
  etykietaStatus.Text = "Zalogowano jako " + poleLogin.Text;
}

// Java / Android - nasluchiwacz jako klasa anonimowa
przyciskZaloguj.setOnClickListener(new View.OnClickListener() {
  @Override
  public void onClick(View v) {
      String login = poleLogin.getText().toString().trim();
      if (login.isEmpty()) {
          Toast.makeText(kontekst, "Podaj login", Toast.LENGTH_SHORT).show();
          return;
      }
      etykietaStatus.setText("Zalogowano jako " + login);
  }
});

// JavaScript - ten sam wzorzec w aplikacji webowej
document.getElementById("przyciskZaloguj")
      .addEventListener("click", function (e) {
          e.preventDefault();       // wstrzymuje domyslna akcje przegladarki
          console.log("Kliknieto", e.target.id);
      });

// ZLE - cala robota w watku interfejsu
private void PrzyciskPobierz_Click(object sender, EventArgs e)
{
  string json = KlientHttp.Pobierz("https://api.szkola.pl/uczniowie");
  // okno jest zamrozone az do konca pobierania:
  // nie reaguje na klikniecia, nie odswieza sie, kursor "myslacy"
  listaUczniow.DataSource = Parsuj(json);
}

// DOBRZE - operacja poza watkiem interfejsu, wynik wraca do niego
private async void PrzyciskPobierz_Click(object sender, EventArgs e)
{
  przyciskPobierz.Enabled = false;      // blokada podwojnego klikniecia
  pasekPostepu.Visible = true;          // informacja zwrotna dla uzytkownika
  try
  {
      string json = await KlientHttp.PobierzAsync("https://api.szkola.pl/uczniowie");
      listaUczniow.DataSource = Parsuj(json);   // jestesmy juz z powrotem w UI
  }
  catch (Exception ex)
  {
      MessageBox.Show("Blad pobierania: " + ex.Message);
  }
  finally
  {
      pasekPostepu.Visible = false;
      przyciskPobierz.Enabled = true;
  }
}

• Model — dane i reguły ich przetwarzania; nie wie nic o wyglądzie.
• Widok (View) — prezentacja danych modelu użytkownikowi.
• Kontroler (Controller) — przyjmuje akcje użytkownika, zmienia model i wybiera widok do pokazania.

/aplikacja
  /model
      Uczen.cs                  klasa danych: imie, nazwisko, klasa, srednia
      RepozytoriumUczniow.cs    odczyt i zapis do bazy (warstwa danych)
  /widok
      OknoListyUczniow.xaml     tylko uklad kontrolek
      OknoEdycji.xaml
  /kontroler
      KontrolerUczniow.cs       obsluga akcji: dodaj, usun, zapisz

// Kontroler laczy jedno z drugim:
public void DodajUcznia(string imie, string nazwisko, double srednia)
{
  if (srednia < 1.0 || srednia > 6.0)                     // regula logiki
      throw new ArgumentException("Srednia poza zakresem 1-6");

  Uczen u = new Uczen(imie, nazwisko, srednia);            // model
  repozytorium.Zapisz(u);                                  // warstwa danych
  widok.OdswiezListe(repozytorium.PobierzWszystkich());    // prezentacja
}

                    uruchomienie aplikacji
                           |
                           v
                     +-----------+
                     | onCreate  |  utworzenie aktywnosci
                     +-----------+
                           |
                           v
                     +-----------+ <--------------------+
                     | onStart   |  ekran staje sie      |
                     +-----------+  widoczny             |
                           |                             |
                           v                             |
                     +-----------+ <-------+       +-----------+
                     | onResume  |         |       | onRestart |
                     +-----------+         |       +-----------+
                           |               |             ^
                 AKTYWNOSC NA WIERZCHU     |             |
                 (uzytkownik pracuje)      |             |
                           |               |             |
                           v               |             |
                     +-----------+         |             |
                     | onPause   | --------+             |
                     +-----------+  powrot z okna        |
                           |        dialogowego          |
                           v                             |
                     +-----------+                       |
                     | onStop    | ----------------------+
                     +-----------+  powrot do aplikacji
                           |
                           v
                     +-----------+
                     | onDestroy |  zwolnienie zasobow
                     +-----------+
                           |
                           v
                    koniec aktywnosci


Scenariusze do zapamietania:

start aplikacji ......... onCreate -> onStart -> onResume
czesciowe zaslonienie ... onPause                  (np. okno dialogowe)
przejscie w tlo ......... onPause -> onStop
powrot z tla ............ onRestart -> onStart -> onResume
zamkniecie ekranu ....... onPause -> onStop -> onDestroy
obrot ekranu ............ onPause -> onStop -> onDestroy ->
                          onCreate -> onStart -> onResume

public class GlownaAktywnosc extends AppCompatActivity {

  private int licznik = 0;
  private TextView etykietaLicznik;

  @Override
  protected void onCreate(Bundle savedInstanceState) {
      super.onCreate(savedInstanceState);
      setContentView(R.layout.activity_glowna);

      etykietaLicznik = findViewById(R.id.etykietaLicznik);
      Button przycisk = findViewById(R.id.przyciskDodaj);

      // odtworzenie stanu po obrocie ekranu
      if (savedInstanceState != null) {
          licznik = savedInstanceState.getInt("licznik", 0);
      }
      etykietaLicznik.setText(String.valueOf(licznik));

      przycisk.setOnClickListener(v -> {
          licznik++;
          etykietaLicznik.setText(String.valueOf(licznik));
      });
  }

  @Override
  protected void onSaveInstanceState(Bundle outState) {
      super.onSaveInstanceState(outState);
      outState.putInt("licznik", licznik);   // stan tymczasowy -> Bundle
  }

  @Override
  protected void onStop() {
      super.onStop();
      // dane, ktore musza przetrwac wylaczenie aplikacji -> zapis trwaly
      getSharedPreferences("ustawienia", MODE_PRIVATE)
          .edit()
          .putInt("ostatniLicznik", licznik)
          .apply();
  }
}

<!-- AndroidManifest.xml -->
<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.CAMERA" />
<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />

// Kod: sprawdzenie i prosba o uprawnienie niebezpieczne
if (ContextCompat.checkSelfPermission(this, Manifest.permission.CAMERA)
      != PackageManager.PERMISSION_GRANTED) {
  ActivityCompat.requestPermissions(
      this,
      new String[]{Manifest.permission.CAMERA},
      KOD_ZADANIA_APARAT);
} else {
  uruchomAparat();
}

// Odpowiedz uzytkownika wraca do metody zwrotnej
@Override
public void onRequestPermissionsResult(int kod, String[] uprawnienia,
                                     int[] wyniki) {
  if (kod == KOD_ZADANIA_APARAT
          && wyniki.length > 0
          && wyniki[0] == PackageManager.PERMISSION_GRANTED) {
      uruchomAparat();
  } else {
      // aplikacja MUSI dzialac dalej mimo odmowy - tylko w wezszym zakresie
      pokazKomunikat("Bez zgody na aparat nie zeskanujesz kodu.");
  }
}

-- Utworzenie tabeli przy pierwszym uruchomieniu aplikacji
CREATE TABLE IF NOT EXISTS zadania (
  id       INTEGER PRIMARY KEY AUTOINCREMENT,
  tresc    TEXT    NOT NULL,
  termin   TEXT,                 -- SQLite nie ma typu DATE, data jako TEXT
  wykonane INTEGER DEFAULT 0     -- ani typu BOOLEAN, 0/1 jako INTEGER
);

-- Typowe operacje CRUD
INSERT INTO zadania (tresc, termin) VALUES ('Powtorka INF.04', '2026-08-20');
SELECT id, tresc, termin FROM zadania WHERE wykonane = 0 ORDER BY termin;
UPDATE zadania SET wykonane = 1 WHERE id = 3;
DELETE FROM zadania WHERE id = 3;

HTTP/1.1 200 OK
Content-Type: application/json; charset=utf-8

{
"status": "ok",
"liczbaWynikow": 3,
"uczniowie": [
  {
    "id": 12,
    "imie": "Anna",
    "nazwisko": "Kowalska",
    "klasa": "3A",
    "srednia": 4.75,
    "aktywny": true,
    "przedmioty": ["bazy danych", "programowanie"]
  },
  {
    "id": 13,
    "imie": "Piotr",
    "nazwisko": "Nowak",
    "klasa": "3A",
    "srednia": 3.9,
    "aktywny": true,
    "przedmioty": ["sieci komputerowe"]
  },
  {
    "id": 14,
    "imie": "Maria",
    "nazwisko": "Zielinska",
    "klasa": "3B",
    "srednia": 5.1,
    "aktywny": false,
    "przedmioty": []
  }
]
}

private void pobierzUczniow() {
  pasekPostepu.setVisibility(View.VISIBLE);

  executor.execute(() -> {                      // WATEK ROBOCZY
      try {
          URL adres = new URL("https://api.szkola.pl/uczniowie");
          HttpURLConnection polaczenie = (HttpURLConnection) adres.openConnection();
          polaczenie.setRequestMethod("GET");
          polaczenie.setRequestProperty("Accept", "application/json");
          polaczenie.setConnectTimeout(10000);

          int kod = polaczenie.getResponseCode();
          if (kod != 200) {
              pokazBladNaUI("Serwer zwrocil kod " + kod);
              return;
          }

          String tresc = czytajStrumien(polaczenie.getInputStream());
          polaczenie.disconnect();

          // parsowanie JSON-a na liste obiektow
          List<Uczen> lista = new ArrayList<>();
          JSONObject korzen = new JSONObject(tresc);
          JSONArray tablica = korzen.getJSONArray("uczniowie");

          for (int i = 0; i < tablica.length(); i++) {
              JSONObject o = tablica.getJSONObject(i);
              Uczen u = new Uczen();
              u.id       = o.getInt("id");
              u.imie     = o.getString("imie");
              u.nazwisko = o.getString("nazwisko");
              u.klasa    = o.getString("klasa");
              u.srednia  = o.getDouble("srednia");
              u.aktywny  = o.optBoolean("aktywny", true);  // opt = wartosc domyslna
              lista.add(u);
          }

          // POWROT NA WATEK INTERFEJSU - tylko stad wolno ruszac kontrolki
          runOnUiThread(() -> {
              adapter.ustawDane(lista);
              adapter.notifyDataSetChanged();
              pasekPostepu.setVisibility(View.GONE);
              etykietaLicznik.setText("Znaleziono: " + lista.size());
          });

      } catch (Exception e) {
          pokazBladNaUI("Brak polaczenia z serwerem.");
      }
  });
}

async function wypelnijListe() {
  const lista = document.getElementById("listaUczniow");
  lista.innerHTML = "<li>Wczytywanie...</li>";

  try {
      const odpowiedz = await fetch("https://api.szkola.pl/uczniowie", {
          method: "GET",
          headers: { "Accept": "application/json" }
      });

      if (!odpowiedz.ok) {                    // ok = kod z zakresu 200-299
          throw new Error("Kod odpowiedzi: " + odpowiedz.status);
      }

      const dane = await odpowiedz.json();    // JSON -> obiekt JavaScript
      lista.innerHTML = "";

      dane.uczniowie.forEach(function (u) {
          const pozycja = document.createElement("li");
          pozycja.textContent = u.nazwisko + " " + u.imie +
                                " (" + u.klasa + ") srednia: " + u.srednia;
          lista.appendChild(pozycja);
      });
  } catch (blad) {
      lista.innerHTML = "<li>Nie udalo sie pobrac danych.</li>";
      console.error(blad);
  }
}

• Testy jednostkowe — sprawdzają pojedynczą metodę lub klasę bez uruchamiania interfejsu (JUnit, NUnit). To kolejny powód, dla którego logika ma siedzieć poza oknem.
• Testy integracyjne — sprawdzają współpracę modułów, na przykład warstwy logiki z bazą albo z API.
• Testy interfejsu — automat klika w kontrolki i weryfikuje wyświetlane teksty (w Androidzie Espresso).
• Testy funkcjonalne i akceptacyjne — czy program robi to, co zapisano w wymaganiach; te ostatnie odbiera klient.
• Testy wydajnościowe i obciążeniowe — czas reakcji, zużycie pamięci i baterii, zachowanie przy dużej liczbie rekordów.
• Testy alfa i beta — alfa wewnątrz zespołu, beta na ograniczonej grupie użytkowników zewnętrznych; sklepy udostępniają na to osobne kanały testowe.
• Testy regresji — powtórzenie wcześniejszych testów po zmianach, żeby sprawdzić, czy poprawka nie zepsuła działającej funkcji.

// fragment konfiguracji projektu Android
android {
  defaultConfig {
      applicationId "pl.szkola.dziennik"   // unikalny identyfikator w sklepie
      minSdk        24                     // najstarszy obslugiwany system
      targetSdk     34                     // wersja, pod ktora aplikacje testowano
      versionCode   17                     // liczba calkowita, rosnie z KAZDYM wydaniem
      versionName   "2.3.1"                // wersja pokazywana uzytkownikowi
  }
}

Wersjonowanie semantyczne (SemVer):   GLOWNA . POMNIEJSZA . POPRAWKA
                                      2    .     3      .    1

GLOWNA     - zmiany niezgodne wstecz, przebudowa aplikacji
POMNIEJSZA - nowa funkcja, zgodna ze starszymi wersjami
POPRAWKA   - wylacznie naprawa bledow

• Kompilacja wydania — wersja release, bez kodu diagnostycznego, z włączonym zmniejszaniem i zaciemnianiem kodu.
• Podpis cyfrowy — plik aplikacji podpisuje się kluczem. Utrata klucza uniemożliwia wydanie aktualizacji tej samej aplikacji, więc kopia zapasowa klucza jest obowiązkowa.
• Format pakietu — Android: APK do bezpośredniej instalacji, AAB (Android App Bundle) do publikacji w Google Play; iOS: IPA wysyłane do App Store; komputer: instalator EXE, MSI, DEB, RPM albo obraz DMG.
• Karta w sklepie — nazwa, opis, zrzuty ekranu, ikona, kategoria wiekowa i informacja o przetwarzanych danych. Aplikacja przechodzi weryfikację przed publikacją.
• Wydanie etapowe — udostępnienie najpierw niewielkiemu odsetkowi użytkowników, żeby wychwycić awarie, zanim dotkną wszystkich.
• Po publikacji — monitorowanie raportów o awariach i ocen użytkowników, poprawki w kolejnych wersjach. Aktualizacja aplikacji desktopowej wymaga własnego mechanizmu aktualizacji albo ponownej instalacji.