kivyforge 3.0.0.dev0__py3-none-any.whl

kivyforge/platforms/base.py

@@ -0,0 +1,157 @@
+"""The ``Platform`` backend interface (common design doc 05).
+
+A platform backend describes one build target (``ios``, ``macos``, ...) and owns
+its verb behavior: metadata, host mapping, host-capability, package formats, and
+the ``build``/``run``/``package``/``doctor`` implementations. The ``cli`` verbs
+resolve the target and dispatch to these methods, so adding a platform is a
+matter of registering one ``Platform`` subclass — the verbs stay backend-agnostic
+(see ``docs/design/common/05-platform-architecture.md``).
+
+Each verb method lazily imports its backend's implementation module
+(``platforms/<os>/cli.py`` / ``doctor.py``) so importing the backend class stays
+cheap and cycle-free (registry -> backend -> bundler/lock/cli is only paid when a
+verb actually runs).
+"""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+    from kivyforge.doctor.result import CheckResult
+
+
+class HostCapabilityError(Exception):
+    """The current host cannot build for this target (e.g. iOS off macOS)."""
+
+
+class Platform(ABC):
+    """Describes a single build target and its host requirements."""
+
+    #: Canonical platform name, e.g. ``"ios"``. Also the ``pylock.<name>.toml``
+    #: infix and the ``[tool.kivy.<name>]`` overlay key.
+    name: str
+
+    #: Accepted CLI/env aliases in addition to ``name``.
+    aliases: tuple[str, ...] = ()
+
+    #: The ``platform.system()`` value for which this platform is the *host
+    #: default* (resolution-chain step 3). Desktop targets set their own OS
+    #: (macOS -> ``"Darwin"``); cross-compiled targets (iOS, Android) set
+    #: ``None`` because no host maps to them — they always need explicit
+    #: selection.
+    host_system: str | None = None
+
+    #: Distributable artifact shapes for ``package -f`` (first = default).
+    package_formats: tuple[str, ...] = ()
+
+    @property
+    def default_package_format(self) -> str | None:
+        return self.package_formats[0] if self.package_formats else None
+
+    @property
+    def selectors(self) -> tuple[str, ...]:
+        """All names that select this platform (``name`` + ``aliases``)."""
+        return (self.name, *self.aliases)
+
+    @abstractmethod
+    def check_host_capability(self, *, host_system: str | None = None) -> None:
+        """Raise :class:`HostCapabilityError` if this host cannot build the target.
+
+        ``host_system`` defaults to the real host (``platform.system()``); it is
+        injectable so the check is unit-testable off the target host.
+        """
+        raise NotImplementedError
+
+    # -- verb dispatch ----------------------------------------------------- #
+    #
+    # Default implementations raise so an unimplemented verb surfaces clearly.
+    # Every registered backend overrides the verbs it supports; the ``cli`` verbs
+    # pass the full option superset and each backend takes what it needs.
+    #
+    # Options that only one platform acts on (``debug``/``fmt``/``abi`` and the
+    # Android keystore overrides) are keyword-with-default: the CLI rejects them
+    # for the platforms they do not apply to, so those backends accept and
+    # ignore them rather than each verb growing a per-platform call shape.
+
+    def build(
+        self,
+        project_root: Path,
+        *,
+        target: str | None,
+        arch: str | None,
+        no_verify_lock: bool,
+        no_cache: bool,
+        team_id: str | None,
+        signing_identity: str | None,
+        export_method: str,
+        debug: bool = False,
+        fmt: str | None = None,
+        abi: str | None = None,
+    ) -> None:
+        raise NotImplementedError(f"build is not supported for {self.name!r}.")
+
+    def run(
+        self,
+        project_root: Path,
+        *,
+        target: str,
+        arch: str | None,
+        destination: str | None,
+        no_build: bool,
+    ) -> None:
+        raise NotImplementedError(f"run is not supported for {self.name!r}.")
+
+    def package(
+        self,
+        project_root: Path,
+        *,
+        fmt: str,
+        arch: str | None,
+        team_id: str | None,
+        signing_identity: str | None,
+        export_method: str,
+        notarize: bool | None,
+        notary_profile: str | None,
+        no_verify_lock: bool,
+        no_cache: bool,
+        abi: str | None = None,
+        keystore: str | None = None,
+        key_alias: str | None = None,
+    ) -> None:
+        raise NotImplementedError(f"package is not supported for {self.name!r}.")
+
+    def open_project(self, project_root: Path) -> None:
+        from kivyforge.cli._common import ToolchainError
+
+        raise ToolchainError(
+            f"`open` is an iOS/Xcode command; {self.name} has no project to open."
+        )
+
+    def status(self, project_root: Path) -> None:
+        raise NotImplementedError(f"status is not supported for {self.name!r}.")
+
+    def doctor(
+        self, cwd: Path, *, kivyforge_version: str, offline: bool
+    ) -> list[CheckResult]:
+        raise NotImplementedError(f"doctor is not supported for {self.name!r}.")
+
+    def reject_ios_only_target(self, target: str | None) -> None:
+        """Desktop backends reject the iOS-only ``--simulator/--device/--release``."""
+        if target is None:
+            return
+        from kivyforge.cli._common import ToolchainError
+
+        artifact = {"macos": ".app", "linux": "AppDir", "windows": "onedir folder"}.get(
+            self.name, "bundle"
+        )
+        raise ToolchainError(
+            f"--{target} is an iOS target; {self.name} has no simulator/device/"
+            "release targets.\n"
+            f"  Use `kivyforge build -p {self.name}` (optionally --arch) to build "
+            f"the {artifact}, or `kivyforge package -p {self.name}` for the "
+            "distributable."
+        )

kivyforge/platforms/ios/__init__.py

@@ -0,0 +1,129 @@
+"""iOS platform backend: metadata, host capability, and verb dispatch.
+
+The iOS build/run/package/open/status/doctor logic lives in ``.cli`` and
+``.doctor``; the verb methods here lazily import them so importing the backend
+class stays cheap and cycle-free.
+"""
+
+from __future__ import annotations
+
+import platform as _platform
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from ..base import HostCapabilityError, Platform
+
+if TYPE_CHECKING:
+    from kivyforge.doctor.result import CheckResult
+
+
+class IosPlatform(Platform):
+    name = "ios"
+    # iOS is cross-compiled from macOS: no host maps to it, so it is never a
+    # host default and must be selected explicitly (-p ios / KIVYFORGE_PLATFORM).
+    host_system = None
+    # The distributable is the Xcode-built app / .ipa (App Store submission is
+    # external). Only one shape today, so `-f` defaults to it.
+    package_formats = ("ipa",)
+
+    def check_host_capability(self, *, host_system: str | None = None) -> None:
+        host = host_system if host_system is not None else _platform.system()
+        if host != "Darwin":
+            raise HostCapabilityError(
+                "building for iOS requires macOS with Xcode; "
+                f"this host is {host!r}.\n"
+                "  iOS wheels and the Python.xcframework are cross-built on a "
+                "macOS host — there is no on-device or off-macOS build path.\n"
+                "  Run `kivyforge doctor -p ios` on a Mac to check Xcode setup."
+            )
+
+    def build(
+        self,
+        project_root: Path,
+        *,
+        target: str | None,
+        arch: str | None,
+        no_verify_lock: bool,
+        no_cache: bool,
+        team_id: str | None,
+        signing_identity: str | None,
+        export_method: str,
+        debug: bool = False,
+        fmt: str | None = None,
+        abi: str | None = None,
+    ) -> None:
+        from .cli import ios_build
+
+        ios_build(
+            project_root,
+            target=target,
+            arch=arch,
+            no_verify_lock=no_verify_lock,
+            no_cache=no_cache,
+            team_id=team_id,
+            signing_identity=signing_identity,
+            export_method=export_method,
+        )
+
+    def run(
+        self,
+        project_root: Path,
+        *,
+        target: str,
+        arch: str | None,
+        destination: str | None,
+        no_build: bool,
+    ) -> None:
+        from .cli import ios_run
+
+        ios_run(
+            project_root,
+            target=target,
+            destination=destination,
+            no_build=no_build,
+        )
+
+    def package(
+        self,
+        project_root: Path,
+        *,
+        fmt: str,
+        arch: str | None,
+        team_id: str | None,
+        signing_identity: str | None,
+        export_method: str,
+        notarize: bool | None,
+        notary_profile: str | None,
+        no_verify_lock: bool,
+        no_cache: bool,
+        abi: str | None = None,
+        keystore: str | None = None,
+        key_alias: str | None = None,
+    ) -> None:
+        from .cli import ios_package
+
+        ios_package(
+            project_root,
+            team_id=team_id,
+            signing_identity=signing_identity,
+            export_method=export_method,
+            no_verify_lock=no_verify_lock,
+            no_cache=no_cache,
+        )
+
+    def open_project(self, project_root: Path) -> None:
+        from .cli import ios_open
+
+        ios_open(project_root)
+
+    def status(self, project_root: Path) -> None:
+        from .cli import ios_status
+
+        ios_status(project_root)
+
+    def doctor(
+        self, cwd: Path, *, kivyforge_version: str, offline: bool
+    ) -> list[CheckResult]:
+        from .doctor import ios_doctor
+
+        return ios_doctor(cwd, kivyforge_version=kivyforge_version, offline=offline)

kivyforge/platforms/ios/assets.py

@@ -0,0 +1,193 @@
+"""Generate iOS app icons, splash assets, and launch screen (spec 01 / 06).
+
+Uses Xcode 14+ single-size ``AppIcon`` (1024x1024; Xcode scales at build time)
+and a ``LaunchScreen.storyboard`` with an optional ``Splash`` image set — not the
+deprecated ``LaunchImage.launchimage`` catalog.
+"""
+
+from __future__ import annotations
+
+import json
+import re
+import shutil
+from pathlib import Path
+
+from kivyforge.config.icons import validate_icon_source
+from kivyforge.config.model import Config
+
+_DEFAULT_SPLASH_BACKGROUND = "#ffffff"
+_HEX_COLOR = re.compile(r"^#([0-9a-fA-F]{3}|[0-9a-fA-F]{6})$")
+
+
+def catalog_needed(config: Config) -> bool:
+    """True when ``Assets.xcassets`` should be emitted."""
+    ios = config.ios
+    return bool(ios and (ios.icons.source or ios.splash.source))
+
+
+def launch_screen_needed(config: Config) -> bool:
+    """True when ``LaunchScreen.storyboard`` should be emitted."""
+    ios = config.ios
+    return bool(ios and (ios.splash.source or ios.splash.background))
+
+
+def generate_asset_catalog(
+    config: Config, resources_dir: str | Path, *, project_root: Path | None = None
+) -> Path | None:
+    """Create ``Assets.xcassets`` when icons and/or splash image are configured.
+
+    Returns the catalog path, or None when no catalog entries are needed.
+    """
+    if not catalog_needed(config):
+        return None
+
+    assert config.ios is not None
+    root = project_root or Path.cwd()
+    catalog = Path(resources_dir) / "Assets.xcassets"
+    catalog.mkdir(parents=True, exist_ok=True)
+    _write_catalog_root(catalog)
+
+    if config.ios.icons.source:
+        _generate_app_icon(catalog, (root / config.ios.icons.source).resolve())
+    if config.ios.splash.source:
+        _generate_splash_imageset(catalog, (root / config.ios.splash.source).resolve())
+    return catalog
+
+
+def write_launch_screen(
+    config: Config, project_dir: str | Path, *, project_root: Path | None = None
+) -> Path | None:
+    """Write ``LaunchScreen.storyboard`` when splash is configured."""
+    if not launch_screen_needed(config):
+        return None
+
+    assert config.ios is not None
+    project_dir = Path(project_dir)
+    background = config.ios.splash.background or _DEFAULT_SPLASH_BACKGROUND
+    rgb = _parse_hex_color(background)
+    has_image = bool(config.ios.splash.source)
+
+    path = project_dir / "LaunchScreen.storyboard"
+    path.write_text(_launch_screen_xml(rgb=rgb, has_image=has_image), encoding="utf-8")
+    return path
+
+
+def _write_catalog_root(catalog: Path) -> None:
+    (catalog / "Contents.json").write_text(
+        json.dumps({"info": {"author": "kivyforge", "version": 1}}, indent=2),
+        encoding="utf-8",
+    )
+
+
+def _generate_app_icon(catalog: Path, source: Path) -> None:
+    validate_icon_source(source)
+
+    appicon_dir = catalog / "AppIcon.appiconset"
+    appicon_dir.mkdir(parents=True, exist_ok=True)
+
+    contents = {
+        "images": [
+            {
+                "filename": "AppIcon.png",
+                "idiom": "universal",
+                "platform": "ios",
+                "size": "1024x1024",
+            }
+        ],
+        "info": {"author": "xcode", "version": 1},
+    }
+    (appicon_dir / "Contents.json").write_text(
+        json.dumps(contents, indent=2), encoding="utf-8"
+    )
+    shutil.copy2(source, appicon_dir / "AppIcon.png")
+
+
+def _generate_splash_imageset(catalog: Path, source: Path) -> None:
+    imageset = catalog / "Splash.imageset"
+    imageset.mkdir(parents=True, exist_ok=True)
+    # Single unscaled "universal" image (one high-res asset Xcode scales as
+    # needed), matching the AppIcon set. Declaring 1x/2x/3x slots but filling
+    # only 1x left empty 2x/3x slots in Xcode.
+    contents = {
+        "images": [
+            {
+                "filename": "Splash.png",
+                "idiom": "universal",
+            }
+        ],
+        "info": {"author": "xcode", "version": 1},
+    }
+    (imageset / "Contents.json").write_text(
+        json.dumps(contents, indent=2), encoding="utf-8"
+    )
+    shutil.copy2(source, imageset / "Splash.png")
+
+
+def _parse_hex_color(value: str) -> tuple[float, float, float]:
+    if not _HEX_COLOR.match(value):
+        raise ValueError(f"invalid hex color {value!r}; expected #rrggbb or #rgb")
+    digits = value[1:]
+    if len(digits) == 3:
+        digits = "".join(ch * 2 for ch in digits)
+    return (
+        int(digits[0:2], 16) / 255.0,
+        int(digits[2:4], 16) / 255.0,
+        int(digits[4:6], 16) / 255.0,
+    )
+
+
+def _launch_screen_xml(*, rgb: tuple[float, float, float], has_image: bool) -> str:
+    r, g, b = rgb
+    color = (
+        f'<color key="backgroundColor" red="{r:.6f}" green="{g:.6f}" '
+        f'blue="{b:.6f}" alpha="1" colorSpace="custom" customColorSpace="sRGB"/>'
+    )
+    image_block = ""
+    image_constraints = ""
+    resources_block = ""
+    if has_image:
+        image_block = """
+                            <imageView clipsSubviews="YES" userInteractionEnabled="NO" contentMode="scaleAspectFit" horizontalHuggingPriority="251" verticalHuggingPriority="251" image="Splash" translatesAutoresizingMaskIntoConstraints="NO" id="splash-image">
+                                <rect key="frame" x="0.0" y="0.0" width="393" height="852"/>
+                            </imageView>"""
+        image_constraints = """
+                            <constraint firstItem="splash-image" firstAttribute="centerX" secondItem="Ze5-6b-2t3" secondAttribute="centerX" id="c1"/>
+                            <constraint firstItem="splash-image" firstAttribute="centerY" secondItem="Ze5-6b-2t3" secondAttribute="centerY" id="c2"/>
+                            <constraint firstItem="splash-image" firstAttribute="width" relation="lessThanOrEqual" secondItem="Ze5-6b-2t3" secondAttribute="width" id="c3"/>
+                            <constraint firstItem="splash-image" firstAttribute="height" relation="lessThanOrEqual" secondItem="Ze5-6b-2t3" secondAttribute="height" id="c4"/>"""
+        resources_block = """
+    <resources>
+        <image name="Splash" width="128" height="128"/>
+    </resources>"""
+
+    return f"""<?xml version="1.0" encoding="UTF-8"?>
+<document type="com.apple.InterfaceBuilder3.CocoaTouch.Storyboard.XIB" version="3.0" toolsVersion="21701" targetRuntime="iOS.CocoaTouch" propertyAccessControl="none" useAutolayout="YES" launchScreen="YES" useTraitCollections="YES" useSafeAreas="YES" colorMatched="YES" initialViewController="01J-lp-oVM">
+    <device id="retina6_12" orientation="portrait" appearance="light"/>
+    <dependencies>
+        <deployment identifier="iOS"/>
+        <plugIn identifier="com.apple.InterfaceBuilder.IBCocoaTouchPlugin" version="21678"/>
+        <capability name="Safe area layout guides" minToolsVersion="9.0"/>
+        <capability name="documents saved in the Xcode 8 format" minToolsVersion="8.0"/>
+    </dependencies>
+    <scenes>
+        <scene sceneID="EHf-IW-A2E">
+            <objects>
+                <viewController id="01J-lp-oVM" sceneMemberID="viewController">
+                    <view key="view" contentMode="scaleToFill" id="Ze5-6b-2t3">
+                        <rect key="frame" x="0.0" y="0.0" width="393" height="852"/>
+                        <autoresizingMask key="autoresizingMask" widthSizable="YES" heightSizable="YES"/>
+                        <subviews>{image_block}
+                        </subviews>
+                        <viewLayoutGuide key="safeArea" id="safe-area"/>
+                        {color}
+                        <constraints>{image_constraints}
+                        </constraints>
+                    </view>
+                </viewController>
+                <placeholder placeholderIdentifier="IBFirstResponder" id="iYj-Kq-Ea1" userLabel="First Responder" sceneMemberID="firstResponder"/>
+            </objects>
+            <point key="canvasLocation" x="53" y="375"/>
+        </scene>
+    </scenes>{resources_block}
+</document>
+"""

kivyforge/platforms/ios/buildsettings.py

@@ -0,0 +1,128 @@
+"""Toolchain-managed Xcode build settings (spec 06 §"Toolchain-managed build settings")."""
+
+from __future__ import annotations
+
+from kivyforge.config.model import Config
+
+from .staging import StagingLayout
+
+BUILD_PYTHON_SCRIPT = (
+    "set -e\n"
+    'UTILS="$PROJECT_DIR/Python.xcframework/build/build_utils.sh"\n'
+    'if [ ! -f "$UTILS" ]; then UTILS="$PROJECT_DIR/Python.xcframework/build/utils.sh"; fi\n'
+    'source "$UTILS"\n'
+    "# Copy the platform-appropriate pip-deps slice into the app bundle so\n"
+    "# that device and simulator builds never share compiled extension modules.\n"
+    'if [ "$EFFECTIVE_PLATFORM_NAME" = "-iphonesimulator" ]; then\n'
+    '    PIP_DEPS_SRC="$PROJECT_DIR/pip-deps-simulator"\n'
+    '    COLLECT_HINT="kivyforge build --simulator"\n'
+    "else\n"
+    '    PIP_DEPS_SRC="$PROJECT_DIR/pip-deps-device"\n'
+    '    COLLECT_HINT="kivyforge build --device"\n'
+    "fi\n"
+    "# Fail loudly if this platform's slice was never collected. Only one slice\n"
+    "# is populated per `kivyforge build/run <target>`, but Xcode picks the slice\n"
+    "# from its own destination -- switching the destination to an uncollected\n"
+    "# target would otherwise ship an app with no dependencies (crash at launch).\n"
+    "# The `.collected` marker is written by collect (kivyforge build/run); it,\n"
+    "# not directory emptiness, is the signal -- an empty slice WITH the marker is\n"
+    "# valid (an app with no third-party dependencies).\n"
+    'if [ ! -f "${PIP_DEPS_SRC}.collected" ]; then\n'
+    '    echo "error: ${PIP_DEPS_SRC} was never collected for this '
+    "platform. Run '$COLLECT_HINT' (or 'kivyforge run') first, then rebuild.\"\n"
+    "    exit 1\n"
+    "fi\n"
+    'mkdir -p "$CODESIGNING_FOLDER_PATH/pip-deps"\n'
+    'rsync -a --delete "$PIP_DEPS_SRC/" "$CODESIGNING_FOLDER_PATH/pip-deps/"\n'
+    "install_python Python.xcframework app pip-deps\n"
+)
+
+
+def managed_settings(
+    config: Config, *, configuration: str, layout: StagingLayout | None = None
+) -> dict[str, str]:
+    """Return the managed build settings for a given configuration (Debug/Release).
+
+    ``ENABLE_TESTABILITY`` and ``DEBUG_INFORMATION_FORMAT`` are per-configuration
+    (spec 06); the rest are constant across configs.
+    """
+    ios = config.ios
+    assert ios is not None
+    is_release = configuration.lower() == "release"
+
+    settings: dict[str, str] = {
+        "PRODUCT_BUNDLE_IDENTIFIER": ios.bundle_id,
+        "PRODUCT_NAME": "$(TARGET_NAME)",
+        "IPHONEOS_DEPLOYMENT_TARGET": ios.deployment_target,
+        "TARGETED_DEVICE_FAMILY": "1,2",
+        "SDKROOT": "iphoneos",
+        "INFOPLIST_FILE": f"{config.app_slug}-Info.plist",
+        "ENABLE_USER_SCRIPT_SANDBOXING": "NO",
+        "ENABLE_TESTABILITY": "NO" if is_release else "YES",
+        "DEBUG_INFORMATION_FORMAT": "dwarf-with-dsym" if is_release else "dwarf",
+        "FRAMEWORK_SEARCH_PATHS": "$(PROJECT_DIR)",
+        "HEADER_SEARCH_PATHS": _header_search_paths(layout),
+        # Embedded dynamic frameworks (Python.xcframework, the SDL3/ANGLE family,
+        # wheel-embedded and SPM frameworks) are loaded via @rpath at runtime.
+        # Manage the runpath explicitly rather than relying on pbxproj embedding
+        # side effects, so any embed path resolves under .app/Frameworks/.
+        "LD_RUNPATH_SEARCH_PATHS": "$(inherited) @executable_path/Frameworks",
+        # UIKit is always required: SDL apps use it transitively through
+        # SDL3.framework; pure-Python apps call UIApplicationMain directly.
+        "OTHER_LDFLAGS": "-framework UIKit",
+        "GCC_WARN_QUOTED_INCLUDE_IN_FRAMEWORK_HEADER": "NO",
+        "ALWAYS_SEARCH_USER_PATHS": "NO",
+        # The SDL3 family and Python frameworks ship ad-hoc code-signed; Xcode's
+        # built-in default COPY_PHASE_STRIP=YES tries to strip them on embed and
+        # warns "not stripping binary because it is signed". Disable it (Xcode's
+        # own project templates also default this to NO).
+        "COPY_PHASE_STRIP": "NO",
+    }
+
+    if ios.icons.source:
+        # Designate the AppIcon set in Assets.xcassets as the app icon. Without
+        # this the catalog still compiles, but Xcode assigns no icon — the
+        # generated AppIcon.appiconset is silently ignored.
+        settings["ASSETCATALOG_COMPILER_APPICON_NAME"] = "AppIcon"
+
+    if ios.entitlements:
+        settings["CODE_SIGN_ENTITLEMENTS"] = f"{config.app_slug}.entitlements"
+
+    return settings
+
+
+def _header_search_paths(layout: StagingLayout | None) -> str:
+    paths = ["$(BUILT_PRODUCTS_DIR)/Python.framework/Headers"]
+    if layout is not None:
+        sdl_xc = layout.frameworks / "SDL3.xcframework"
+        if sdl_xc.is_dir():
+            for slice_name in ("ios-arm64_x86_64-simulator", "ios-arm64"):
+                paths.append(
+                    f"$(PROJECT_DIR)/Frameworks/SDL3.xcframework/"
+                    f"{slice_name}/SDL3.framework/Headers"
+                )
+    return " ".join(f'"{path}"' for path in paths)
+
+
+def signing_settings(config: Config) -> dict[str, str]:
+    """Map [tool.kivy.ios.signing] to CODE_SIGN_* build settings (spec 06)."""
+    ios = config.ios
+    assert ios is not None
+    signing = ios.signing
+    settings: dict[str, str] = {
+        "CODE_SIGN_STYLE": "Automatic" if signing.auto_signing else "Manual",
+    }
+    if signing.team_id:
+        settings["DEVELOPMENT_TEAM"] = signing.team_id
+    if signing.identity:
+        settings["CODE_SIGN_IDENTITY"] = signing.identity
+    if signing.provisioning_profile:
+        settings["PROVISIONING_PROFILE_SPECIFIER"] = signing.provisioning_profile
+    return settings
+
+
+def user_build_settings(config: Config) -> dict[str, str]:
+    """Free-form [tool.kivy.ios.xcode.build_settings] (reserved keys already rejected)."""
+    if not config.ios:
+        return {}
+    return dict(config.ios.build_settings)