Scheme: podstata, konfigurace a spuštění v Xcode

Co je Scheme v Xcode?

Scheme v Xcode je soubor XML (s příponou .xcscheme), který popisuje posloupnost akcí a jejich parametry pro sestavení a analýzu aplikace. Každé Scheme je vázáno na jeden nebo více targetů a určuje, s jakou konfigurací (Debug, Release, AdHoc) provést každou akci. Scheme je obdoba Build Variant v Androidu, ale s flexibilnější strukturou: jedno schéma může obsahovat různé targety pro různé akce.

Xcode automaticky vytvoří schéma pro každý target při prvním otevření projektu. Výchozí název schématu se shoduje s názvem targetu. Pokud je v projektu testovací target, Xcode jej automaticky přidá do akce Test schématu hlavního targetu. U projektů s více targety (hlavní aplikace + watchOS + extension) Xcode vytvoří samostatné schéma pro každý, ale lze vytvořit i jedno schéma, které sestaví všechny targety najednou.

Schémata jsou uložena v adresáři xcshareddata/xcschemes/ (pro shared) nebo xcuserdata/<user>/xcschemes/ (pro private). Shared schémata se dostanou do Gitu a používá je celý tým. Private schémata se ukládají lokálně a nesynchronizují se. Soubor .xcscheme má formát XML s kořenovým prvkem <Scheme>. Uvnitř jsou bloky pro každou akci: BuildAction, TestAction, LaunchAction, ProfileAction, AnalyzeAction, ArchiveAction.

Struktura souboru .xcscheme

.xcscheme je soubor XML, který lze upravovat ručně nebo přes Xcode. Hlavní prvky: <BuildAction> (seznam sestavovaných targetů), <TestAction> (odkazy na testovací targety), <LaunchAction> (konfigurace spuštění), <ProfileAction>, <AnalyzeAction>, <ArchiveAction>. Každý blok obsahuje atribut buildConfiguration, který určuje, jakou konfiguraci (Debug/Release) pro danou akci použít.

Akce Scheme: Build, Run, Test, Profile, Analyze, Archive

Scheme se skládá ze šesti akcí, z nichž každou lze nakonfigurovat nezávisle. Akce Build určuje, které targety se sestavují a v jakém pořadí. Akce Run — jak se aplikace spouští: s jakými argumenty, proměnnými prostředí a s jakou konfigurací. Akce Test — které testy se provádějí a jaké možnosti code coverage jsou zapnuty. Akce Profile — spuštění s nástroji Instruments pro profilování. Akce Analyze — statická analýza kódu pomocí Clang Static Analyzer. Akce Archive — sestavení pro publikaci v App Store nebo distribuci AdHoc.

Pro každou akci lze nastavit samostatnou build configuration. Obvykle se pro Run a Test používá Debug, pro Archive — Release. Build configuration určuje sadu příznaků kompilátoru, optimalizace a informace o ladění. Xcode poskytuje dvě standardní konfigurace: Debug (bez optimalizací, se symboly pro ladění) a Release (s optimalizacemi, bez informací o ladění). Vývojář může přidávat vlastní konfigurace přes project.xcconfig.

Akce Archive je obzvláště důležitá — vytváří .xcarchive, který se poté exportuje do .ipa pro App Store nebo AdHoc. Archive Action ve výchozím nastavení používá konfiguraci Release, ale lze přepnout na AdHoc nebo Distribution. V Archive Action je k dispozici také příznak revealArchiveInOrganizer — po dokončení archivace Xcode otevře Organiser pro další práci s archivem.

<!-- Příklad .xcscheme pro iOS aplikaci -->
<Scheme
  LastUpgradeVersion = "1500"
  version = "1.7">

  <BuildAction
    parallelizeBuildables = "YES"
    buildImplicitDependencies = "YES">
    <BuildActionEntries>
      <BuildActionEntry
        buildForTesting = "YES"
        buildForRunning = "YES"
        buildForProfiling = "YES"
        buildForArchiving = "YES"
        buildForAnalyzing = "YES">
        <BuildableReference
          BuildableIdentifier = "primary"
          BlueprintIdentifier = "ABCD1234"
          BuildableName = "MyApp.app"
          BlueprintName = "MyApp"
          ReferencedContainer = "container:MyApp.xcodeproj">
        </BuildableReference>
      </BuildActionEntry>
    </BuildActionEntries>
  </BuildAction>

  <LaunchAction
    buildConfiguration = "Debug"
    selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
    enableAddressSanitizer = "YES">
  </LaunchAction>
</Scheme>

Vytvoření a konfigurace Scheme

Diagnostické sanitizery

Vytvoření nového schématu probíhá přes menu Xcode: Product → Scheme → New Scheme nebo tlačítkem „+“ na panelu Scheme (vedle tlačítka Run). Při vytváření se vybere target, pro který se schéma vytváří. Pokud je schéma vybráno jako „duplicate“, Xcode automaticky zkopíruje nastavení z existujícího schématu. Nová schémata se ve výchozím nastavení ukládají jako private — pro publikaci týmu je nutné zapnout Shared v Manage Schemes.

Okno Edit Scheme (Product → Scheme → Edit Scheme) obsahuje šest karet podle počtu akcí. Na každé kartě lze změnit build configuration, spouštěcí argumenty, proměnné prostředí a diagnostické příznaky. Na kartě Run jsou k dispozici možnosti: executable (který binární soubor spustit), wait for executable to be launched (pro ladění spouštěných procesů), debugger (LLDB nebo None), launch arguments, environment variables a rozšířené možnosti (Address Sanitizer, Thread Sanitizer, Main Thread Checker, Memory Management).

Pro diagnostiku: Address Sanitizer (ASan) — detekuje přetečení mimo hranice pole, use-after-free a další chyby paměti v kódu C/C++/ObjC. Thread Sanitizer (TSan) — detekuje závodní stavy (data races) ve vícevláknovém kódu. Undefined Behavior Sanitizer (UBSan) — odhaluje nedefinované chování, například přetečení znaménkového int. Tyto možnosti jsou dostupné v Edit Scheme → Run → Diagnostics a fungují pouze pro sestavení Debug. Zapnutí všech sanitizerů může zpomalit spuštění 2-3krát, proto se doporučuje zapínat je selektivně.

Klonování schématu pro různá prostředí

Typická praxe — vytvářet samostatná schémata pro každé prostředí: Dev, Staging, Production. Každé schéma používá stejné Build Configuration (Debug pro Dev, Release pro Production), ale různé spouštěcí argumenty: -FIRAnalyticsDebugEnabled, -com.apple.CoreData.SQLDebug 1 pro Dev a jejich absenci pro Production. Spouštěcí argumenty se předávají do UserDefaults (ProcessInfo.processInfo.arguments) a jsou k dispozici pro čtení při spuštění aplikace. To umožňuje přepínat URL serveru, úroveň logování a funkce bez změny kódu.

Shared a private schémata: správa přes Git

Shared schémata jsou uložena v <project>.xcworkspace/xcshareddata/xcschemes/ nebo <project>.xcodeproj/xcshareddata/xcschemes/ a dostanou se do repozitáře Git. Všichni vývojáři týmu tato schémata v Xcode vidí. Shared schémata jsou jediným způsobem, jak schémata v týmu šířit. Pokud vývojář vytvořil důležité schéma (např. „Staging Archive“), ale neoznačil ho jako Shared, zbytek týmu ho neuvidí, což vede ke zmatku: každý si bude vytvářet vlastní schéma s vlastním nastavením.

Private schémata jsou uložena v xcuserdata/<user>/xcschemes/ a do Gitu se nedostanou. Jsou užitečná pro osobní konfigurace: např. schéma se zapnutými všemi sanitizery pro konkrétního vývojáře. Private schémata by neměla obsahovat kritická nastavení, na kterých závisí sestavení projektu — pokud vývojář projekt opustí, jeho private schémata zmizí. Doporučení: všechna schémata používaná v CI/CD a alespoň dvěma vývojáři dělat Shared.

Správa schémat probíhá přes Manage Schemes (Product → Scheme → Manage Schemes). V okně se zobrazují všechna schémata projektu, jejich stav (Shared/Private) a tlačítka +/— pro přidání/odebrání. Zaškrtávací políčko Shared přepíná viditelnost schématu pro tým. Při konfliktu Git (změny v .xcscheme od dvou vývojářů) je třeba pečlivě vyřešit sloučení — soubory XML mohou obsahovat různé identifikátory targetů. Doporučuje se přidat .xcscheme do souborů blokovaných při merge (git lfs nebo .gitattributes).

Spouštěcí argumenty a proměnné prostředí

Arguments v Scheme jsou řetězce, které se předávají aplikaci při spuštění (ProcessInfo.processInfo.arguments), a proměnné prostředí (ProcessInfo.processInfo.environment). Argumenty se používají pro příznaky: -AppleLanguages (ru), -AppleLocale ru_RU pro simulaci ruské lokalizace nebo -FIRDebugEnabled pro zapnutí ladění Firebase. Proměnné prostředí se používají pro konfiguraci: API_BASE_URL=http://localhost:3000, LOG_LEVEL=debug.

Pro správu funkcí (feature flags) v různých prostředích se používá kombinace Arguments + Build Configuration. V Dev schématu se nastaví argument -FeatureFlagNewOnboarding YES, v Production — -FeatureFlagNewOnboarding NO (nebo argument chybí). V kódu kontrola: UserDefaults.standard.bool(forKey: "FeatureFlagNewOnboarding"). Tento přístup umožňuje postupné zapínání funkcí na staging bez změny kódu a bez commitování produkčních hodnot.

Důležité: argumenty a proměnné prostředí Scheme přepisují hodnoty z Info.plist. Pokud je v Info.plist uveden API_URL a v Scheme — API_URL=http://localhost pro Run Action, při spuštění z Xcode bude použita hodnota ze Scheme. Při spuštění ze zařízení (ne z Xcode) — hodnota z Info.plist. To je pohodlné pro lokální vývoj, ale je třeba pamatovat, že proměnné Scheme se nedostanou do sestavení — působí pouze při spuštění přes Xcode.

import Foundation

struct AppEnvironment {
    var apiBaseURL: String {
        ProcessInfo.processInfo.environment["API_BASE_URL"]
            ?? Bundle.main.object(forInfoDictionaryKey: "API_BASE_URL") as? String
            ?? "https://api.production.com"
    }

    var isDebugMode: Bool {
        ProcessInfo.processInfo.arguments.contains("-DebugModeEnabled")
    }

    var isNewOnboardingEnabled: Bool {
        UserDefaults.standard.bool(forKey: "FeatureFlagNewOnboarding")
    }
}

// Použití při spuštění
let env = AppEnvironment()
NetworkConfig.shared.configure(baseURL: env.apiBaseURL)

Scheme v CI/CD: automatizace přes xcodebuild

V CI/CD (GitHub Actions, Jenkins, GitLab CI) se Scheme používá jako hlavní argument příkazu xcodebuild. Příklad: xcodebuild -workspace MyApp.xcworkspace -scheme MyApp -configuration Release -sdk iphoneos archive. Příznak -scheme určuje, které schéma použít. xcodebuild čte všechna nastavení ze souboru .xcscheme, včetně build configuration, targetů a pořadí sestavení. To zaručuje, že CI/CD sestaví aplikaci se stejnými parametry jako lokální IDE.

Pro CI/CD jsou kritická shared schémata. Pokud schéma není Shared, xcodebuild ho v repozitáři nenajde a sestavení selže s chybou „Scheme not found“. Pravidlo: před konfigurací CI/CD se ujistěte, že všechna používaná schémata jsou označena jako Shared. Druhé pravidlo: v CI/CD nepoužívejte výchozí schéma (Xcode automaticky vybírá první schéma) — vždy předávejte název schématu explicitně přes příznak -scheme.

Pro paralelní sestavení více schémat (např. aplikace a rozšíření watchOS) lze xcodebuild spouštět sekvenčně nebo paralelně. Moderní CI systémy umožňují paralelizovat sestavení různých schémat přes matici: jedna job sestavuje iOS aplikaci, druhá — rozšíření watchOS. To snižuje celkový čas sestavení z 15 na 8 minut při dvou paralelních agentech. Na konci se artefakty spojí do jediného .xcarchive pomocí xcodebuild -exportArchive.

#!/bin/bash — CI/CD sestavení s xcodebuild
# 1. Vyčištění a sestavení
xcodebuild clean archive \
  -workspace "MyApp.xcworkspace" \
  -scheme "MyApp Production" \
  -configuration Release \
  -sdk iphoneos \
  -archivePath "build/MyApp.xcarchive" \
  CODE_SIGN_STYLE="Manual" \
  PROVISIONING_PROFILE_SPECIFIER="match AppStore"

# 2. Export do IPA
xcodebuild -exportArchive \
  -archivePath "build/MyApp.xcarchive" \
  -exportPath "build/ipa" \
  -exportOptionsPlist "ExportOptions.plist"