Skip

https://skip.tools/docs
Admin
Skip is a technology that enables developers to build native iOS and Android applications from a...
Tokens:228,511
Snippets:1,618
Trust Score:8.6
Update:8 months ago
Show doc for...
Tokens:
Raw
### Install Skip using Homebrew

Source: https://skip.tools/docs/gettingstarted

Installs the Skip tool, Android SDK, and Gradle build tool using the Homebrew package manager. This is the first step to setting up your development environment.

```bash
brew install skiptools/skip/skip
```

--------------------------------

### Check Skip Installation and Prerequisites

Source: https://skip.tools/docs/gettingstarted

Verifies that Skip and its dependencies, including Swift, Xcode, Homebrew, Gradle, and Android Debug Bridge, are correctly installed and meet the required versions. It also performs a project build and test cycle.

```bash
skip checkup
```

--------------------------------

### Create and Launch Android Emulator

Source: https://skip.tools/docs/gettingstarted

Sets up a new Android emulator for local development and provides a command to launch it. This is essential for testing Android applications without a physical device.

```bash
skip android emulator create
```

```bash
skip android emulator launch
```

--------------------------------

### Create a New Skip Project

Source: https://skip.tools/docs/gettingstarted

Initiates the creation of a new Skip project, guiding the user through choices for project type (App or Library) and mode (Skip Fuse or Skip Lite). It configures essential settings like project name, bundle identifier, and optional integrations like Git and Fastlane.

```bash
$ skip create

Welcome to Skip!


Select type of project to create:
  1: App: mobile application for Android and iOS
  2: Library: library project with one or more modules
Enter selection (default: App) [1..2] 1


Select the mode of the project:
  1: Skip Fuse: natively compiled project
  2: Skip Lite: transpiled project
Enter selection [1..2] 1


Enter the project-name for the App: hello-skip

Enter the CamelCase name of the App module: HelloSkip

Optionally enter additional module names: 

Enter the app bundle identifier: com.example.HelloSkip

Create a free open-source project? (y/n) [n]: n
Initialize git repository for the project? (y/n) [n]: n
Initialize a Fastlane configuration for the project? (y/n) [y]: y
Pre-build the project? (y/n) [y]: y
Install the Swift Android SDK? (y/n) [y]: y
Open the Xcode project after initialization? (y/n) [y]: y

[✓] Install Swift Android SDK (48.4s)
[✓] Resolve dependencies (12.12s)
[✓] Build hello-skip (53.35s)
[✓] Check project schemes (6.12s)
[✓] Archive iOS ipa (17.18s)
[✓] Assemble HelloSkip-debug.ipa 1 MB
[✓] Verifying HelloSkip-debug.ipa: 1 MB
[✓] Assembling Android apk (78.91s)
[✓] Verify HelloSkip-debug.apk: 80 MB
[✓] Opening Xcode project (0.10s)
[✓] Skip create succeeded in 168.63s
```

--------------------------------

### SwiftUI Searchable Playground Setup

Source: https://skip.tools/docs/components/searchable

Sets up a playground for demonstrating different `searchable` functionalities in SwiftUI. It includes navigation to various example views, each showcasing a specific aspect of the `searchable` modifier.

```swift
import Foundation
import SwiftUI


enum SearchablePlaygroundType: String, CaseIterable {
    case list
    case plainList
    case submit
    case isSearching


    var title: String {
        switch self {
        case .list:
            return "List"
        case .plainList:
            return "Plain style"
        case .submit:
            return "Submit"
        case .isSearching:
            return "isSearching"
        }
    }
}


struct SearchablePlayground: View {
    var body: some View {
        List(SearchablePlaygroundType.allCases, id: \.self) {
            type in
            NavigationLink(type.title, value: type)
        }
        .toolbar {
            PlaygroundSourceLink(file: "SearchablePlayground.swift")
        }
        .navigationDestination(for: SearchablePlaygroundType.self) {
            switch $0 {
            case .list:
                ListSearchablePlayground()
                    .navigationTitle($0.title)
            case .plainList:
                PlainListSearchablePlayground()
                    .navigationTitle($0.title)
            case .submit:
                SubmitSearchablePlayground()
                    .navigationTitle($0.title)
            case .isSearching:
                IsSearchingSearchablePlayground()
                    .navigationTitle($0.title)
            }
        }
    }
}
```

--------------------------------

### SwiftUI NavigationStack: Basic Setup

Source: https://skip.tools/docs/modules/skip-ui

Provides a basic example of setting up a NavigationStack in SwiftUI. It includes a ListView and sets a navigation title.

```swift
NavigationStack {
    ListView()
        .navigationTitle(Self.title)
}
```

--------------------------------

### iOS Audio Session Setup (Non-Skip)

Source: https://skip.tools/docs/components/audio

This Swift code configures the audio session for recording and playback on iOS platforms (excluding Skip/Android). It sets the audio session category to '.playAndRecord' and activates the session, handling potential errors.

```swift
#else

    func setupAudioSession() {
        let session = AVAudioSession.sharedInstance()
        do {
            try session.setCategory(.playAndRecord, mode: .default)
            try session.setActive(true)
        } catch {
            errorMessage = "Failed to setup audio session: \(error.localizedDescription)"
        }
    }
    #endif
```

--------------------------------

### Install Skip and Android SDK for Swift Package Building

Source: https://skip.tools/docs/porting

This snippet demonstrates the command-line steps to install the Skip tool and the Android SDK, followed by building a Swift package for Android. It assumes Homebrew is installed for package management.

```bash
$ brew install skiptools/skip/skip

…
skip was successfully installed!

$ skip android sdk install

[✓] Install Swift Android SDK (2.4s)

$ cd MySwiftPackage/
$ skip android build

Building for debugging...
[0/2] Write sources
…
[4/4] Emitting module DemoPackage
Build complete! (1.85s)
```

--------------------------------

### Install Skip CLI Tool

Source: https://skip.tools/docs/samples/skipapp-fireside

Installs the Skip CLI tool using Homebrew. Requires macOS 13+.

```bash
$ brew install skiptools/skip/skip
```

--------------------------------

### Example Swift Package Test Output on macOS

Source: https://skip.tools/docs/porting

Example output from running 'swift test' on a Swift package. This shows the build process and test suite results, including the number of tests executed and any failures.

```text
$ swift test
Building for debugging...
[78/78] Linking swift-algorithmsPackageTests
Build complete! (12.67s)


Test Suite 'All tests' started at 2025-01-21 19:25:03.841.
Test Suite 'swift-algorithmsPackageTests.xctest' started at 2025-01-21 19:25:03.842.
Test Suite 'AdjacentPairsTests' started at 2025-01-21 19:25:03.842.
Test Case '-[SwiftAlgorithmsTests.AdjacentPairsTests testEmptySequence]' started.
Test Case '-[SwiftAlgorithmsTests.AdjacentPairsTests testEmptySequence]' passed (0.002 seconds).
Test Case '-[SwiftAlgorithmsTests.AdjacentPairsTests testIndexTraversals]' started.
Test Case '-[SwiftAlgorithmsTests.AdjacentPairsTests testIndexTraversals]' passed (0.002 seconds).
…
Test Suite 'All tests' passed at 2025-01-21 19:25:05.718.
 Executed 212 tests, with 0 failures (0 unexpected) in 1.870 (1.876) seconds

```

--------------------------------

### Install Skip CLI using Homebrew

Source: https://skip.tools/docs/skip-cli

This command installs the Skip CLI tool and its necessary dependencies (like Gradle and Android SDK) using Homebrew. It ensures that the Skip binary is linked to your system's PATH for easy access.

```bash
% brew install skiptools/skip/skip
```

--------------------------------

### SwiftUI LazyVGrid with Padding

Source: https://skip.tools/docs/components/grid

Demonstrates a LazyVGrid with applied padding. This example shows how to add spacing around the grid content for better visual presentation.

```swift
import SwiftUI

struct LazyVGridPaddingView: View {
    var body: some View {
        ScrollView {
            LazyVGrid(columns: [GridItem(.adaptive(minimum: 80))]) {
                ForEach(0..<100) {
                    index in
                    ZStack {
                        Color.yellow
                        Text(String(describing: index))
                    }
                    .frame(height: 80)
                }
            }
            .padding()
        }
    }
}
```

--------------------------------

### Cross-Platform SwiftUI View Example

Source: https://skip.tools/docs/app-development

An example of a SwiftUI view designed for cross-platform compatibility. It demonstrates the use of @State and the requirement for default or public visibility for SwiftUI types and members on Android.

```swift
import SwiftUI


struct MyView : View {
    @State var counter = 1 // Use internal or public access for all SwiftUI types and members
    private let title = "..." // OK to use private for non-SwiftUI members
    ...


    var body: some View {
        ...
    }
}

```

--------------------------------

### SwiftUI Menu Examples in SkipUI

Source: https://skip.tools/docs/components/menu

Demonstrates various SwiftUI.Menu implementations within a SkipUI application. Includes default menus, menus with primary actions, styled menus, label-based menus, and nested menus. Assumes the existence of a `logger` object for logging actions.

```swift
import SwiftUI


struct MenuPlayground: View {
    @State var primaryActionCount = 0


    var body: some View {
        ScrollView {
            VStack(spacing: 16.0) {
                Menu("Default") {
                    Button("Option 1") { logger.log("Option 1") }
                    Button("Option 2") { logger.log("Option 2") }
                    Button("Option 3") { logger.log("Option 3") }
                }
                Menu("PrimaryAction: \(primaryActionCount)") {
                    Button("Option 1") { logger.log("Option 1") }
                    Button("Option 2") { logger.log("Option 2") }
                    Button("Option 3") { logger.log("Option 3") }
                } primaryAction: {
                    primaryActionCount += 1
                }
                Menu(".buttonStyle(.bordered)") {
                    Button("Option 1") { logger.log("Option 1") }
                    Button("Option 2") { logger.log("Option 2") }
                    Button("Option 3") { logger.log("Option 3") }
                }
                .buttonStyle(.bordered)
                Menu {
                    Button("Option 1") { logger.log("Option 1") }
                    Button("Option 2") { logger.log("Option 2") }
                    Button("Option 3") { logger.log("Option 3") }
                } label: {
                    Label("Label", systemImage: "heart.fill")
                }
                Menu("Label items") {
                    Button(action: { logger.log("Option 1") }) { Label("Option 1", systemImage: "heart.fill") }
                    Button(action: { logger.log("Option 2") }) { Label("Option 2", systemImage: "heart.fill") }
                    Button(action: { logger.log("Option 3") }) { Label("Option 3", systemImage: "heart.fill") }
                }
                Menu("Text & Divider") {
                    Text("Text")
                    Button("Option 1") { logger.log("Option 1") }
                    Divider()
                    Button("Option 2") { logger.log("Option 2") }
                    Button("Option 3") { logger.log("Option 3") }
                }
                Menu("Section") {
                    Section("Section") {
                        Button("Option 1") { logger.log("Option 1") }
                    }
                    Button("Option 2") { logger.log("Option 2") }
                    Button("Option 3") { logger.log("Option 3") }
                }
                Menu("Nested menu") {
                    Menu("Nested") {
                        Button("Option 1") { logger.log("Option 1") }
                        Button("Option 2") { logger.log("Option 2") }
                        Menu("Nested Again") {
                            Button("Option 3") { logger.log("Option 3") }
                        }
                    }
                    Button("Option 3") { logger.log("Option 3") }
                    Button("Option 4") { logger.log("Option 4") }
                }
            }
            .toolbar {
                Menu("Menu") {
                    Button("Option 1") { logger.log("Option 1") }
                    Button("Option 2") { logger.log("Option 2") }
                    Button("Option 3") { logger.log("Option 3") }
                }
            }
            .padding()
        }
        .toolbar {
            PlaygroundSourceLink(file: "LabelPlayground.swift")
        }
    }
}
```

--------------------------------

### SwiftUI Background Examples with SkipUI

Source: https://skip.tools/docs/components/background

Demonstrates various ways to apply background modifiers in SwiftUI using SkipUI. This includes setting solid colors, gradients, custom shapes, and styled backgrounds. The examples showcase different alignment options and clipping behaviors.

```swift
import SwiftUI


struct BackgroundPlayground: View {
    var body: some View {
        ScrollView {
            VStack(spacing: 16.0) {
                HStack {
                    Text(".red")
                    Spacer()
                    ZStack {
                    }
                    .frame(width: 100.0, height: 100.0)
                    .background(.red)
                }
                HStack {
                    Text(".red.gradient")
                    Spacer()
                    ZStack {
                    }
                    .frame(width: 100.0, height: 100.0)
                    .background(.red.gradient)
                }
                HStack {
                    Text("background()")
                    Spacer()
                    ZStack {
                        Text("Hello")
                            .background()
                    }
                    .frame(width: 100.0, height: 100.0)
                    .background(.red)
                }
                HStack {
                    Text(".backgroundStyle(.red)")
                    Spacer()
                    ZStack {
                        Text("Hello")
                            .background()
                    }
                    .frame(width: 100.0, height: 100.0)
                    .backgroundStyle(.red)
                }
                HStack {
                    Text(".clipShape(.capsule)")
                    Spacer()
                    Image(systemName: "heart.fill")
                        .frame(width: 100.0, height: 50.0)
                        .background(.red.gradient)
                        .clipShape(.capsule)
                }
                HStack {
                    Text("in: Capsule()")
                    Spacer()
                    Text("Hello")
                        .padding()
                        .background(.red.opacity(0.2), in: Capsule())
                }
                HStack {
                    Text("Circles")
                    Spacer()
                    Text("Hello")
                        .padding()
                        .background {
                            HStack {
                                Circle().fill(.red.opacity(0.2))
                                Circle().fill(.green.opacity(0.2))
                            }
                        }
                        .border(.blue)
                }
                HStack {
                    Text("Large circle")
                    Spacer()
                    Text("Hello")
                        .padding()
                        .background {
                            Circle()
                                .fill(.red.opacity(0.2))
                                .frame(width: 100.0, height: 100.0)
                        }
                        .border(.blue)
                }
                HStack {
                    Text(".clipped()")
                    Spacer()
                    Text("Hello")
                        .padding()
                        .background {
                            HStack {
                                Circle().fill(.red.opacity(0.2))
                                Circle().fill(.red.opacity(0.2))
                            }
                            .frame(width: 200.0, height: 100.0)
                        }
                        .clipped()
                        .border(.blue)
                }
                HStack {
                    Text("Small circle")
                    Spacer()
                    Text("Hello")
                        .padding()
                        .background {
                            Circle()
                                .fill(.red.opacity(0.2))
                                .frame(width: 20.0, height: 20.0)
                        }
                        .border(.blue)
                }
                HStack {
                    Text("alignment: .topLeading")
                    Spacer()
                    Text("Hello")
                        .padding()
                        .background(alignment: .topLeading) {
                            Circle()
                                .fill(.red.opacity(0.2))
                                .frame(width: 20.0, height: 20.0)
                        }
                        .border(.blue)
                }
                HStack {
                    Text("alignment: .bottomTrailing")
                    Spacer()
                    Text("Hello")
                        .padding()
                        .background(alignment: .bottomTrailing) {
                            Circle()
                                .fill(.red.opacity(0.2))

```

--------------------------------

### Example Swift Package Test Output on Android

Source: https://skip.tools/docs/porting

Example output from running 'skip android test'. This demonstrates the remote test execution process on an Android device or emulator, including build, connection, file transfer, and test results.

```text
% skip android test
[0/1] Planning build
Building for debugging...
…
[83/84] Linking swift-algorithmsPackageTests.xctest


Build complete! (11.68s)


[✓] Check Swift Package (0.87s)
[✓] Connecting to Android (0.18s)
[✓] Copying test files (0.88s)


Test Suite 'All tests' started at 2025-01-21 21:02:09.086
Test Suite 'swift-algorithms-1C77777B-CEC3-4075-8853-E77CECFCF30B.xctest' started at 2025-01-21 21:02:09.105
Test Suite 'AdjacentPairsTests' started at 2025-01-21 21:02:09.105
Test Case 'AdjacentPairsTests.testEmptySequence' started at 2025-01-21 21:02:09.105
Test Case 'AdjacentPairsTests.testEmptySequence' passed (0.014 seconds)
Test Case 'AdjacentPairsTests.testIndexTraversals' started at 2025-01-21 21:02:09.120
Test Case 'AdjacentPairsTests.testIndexTraversals' passed (0.004 seconds)
…
Test Suite 'All tests' passed at 2025-01-21 21:02:21.697
     Executed 212 tests, with 0 failures (0 unexpected) in 12.579 (12.579) seconds

```

--------------------------------

### Initialize and Build a Skip Project

Source: https://skip.tools/docs/gradle

Initializes a new Skip project with a specified application ID, name, and display name. It then navigates into the project directory and builds the Swift code using `swift build`. This process sets up the basic structure for a Skip application.

```bash
$ skip init --appid=com.xyz.HelloSkip hello-skip HelloSkip

Initializing Skip library hello-skip
[✓] Create project hello-skip (0.73s)
[✓] Resolve dependencies (5.89s)
[✓] Build hello-skip (15.2s)
[✓] Created module HelloSkip in ~/Desktop/hello-skip/HelloSkip.xcodeproj

$ cd hello-skip

$ swift build --build-tests

Fetched https://source.skip.tools/skip.git (0.92s)
…
[294/294] Linking libHelloSkip.dylib
Build complete! (23.13s)
```

--------------------------------

### Initialize PostHog SDK

Source: https://skip.tools/docs/modules/skip-posthog

Demonstrates the basic initialization of the PostHog SDK with an API key. Includes an example for self-hosted PostHog instances.

```swift
import SkipPostHog


PostHogSDK.shared.setup(
    PostHogConfig(apiKey: "your-api-key")
)

```

```swift
PostHogSDK.shared.setup(
    PostHogConfig(apiKey: "your-api-key", host: "https://your-posthog-instance.com")
)

```

--------------------------------

### Initialize Skipapp-hello Project

Source: https://skip.tools/docs/samples/skipapp-hello

Initializes a new Skip Lite dual-platform app project named 'skipapp-hello' with a specific application ID and name. This command sets up the basic project structure for both iOS and Android.

```bash
skip init --zero --appid=skip.hello.App skipapp-hello HelloSkip
```

--------------------------------

### Kotlin Build Error: Missing Compose Compiler Plugin

Source: https://skip.tools/docs/kotlin2-migration

This error occurs when the Jetpack Compose compiler plugin is not correctly added to the app's `build.gradle.kts` file. It indicates a backend internal error during IR lowering, often stemming from a missing dependency or incorrect configuration. Refer to the migration guide for proper setup.

```kotlin
e: org.jetbrains.kotlin.backend.common.BackendException: Backend Internal error: Exception during IR lowering
> Task :app:compileDebugKotlin FAILED
File being compiled: /opt/src/github/skiptools/skipapp-hello/Android/app/src/main/kotlin/hello/skip/Main.kt
The root cause java.lang.RuntimeException was thrown at: org.jetbrains.kotlin.backend.jvm.codegen.FunctionCodegen.generate(FunctionCodegen.kt:50)
    at org.jetbrains.kotlin.backend.common.CodegenUtil.reportBackendException(CodegenUtil.kt:253)
    at org.jetbrains.kotlin.backend.common.CodegenUtil.reportBackendException$default(CodegenUtil.kt:236)
    at org.jetbrains.kotlin.backend.common.phaser.PerformByIrFilePhase.invokeSequential(performByIrFile.kt:65)
    …
Caused by: java.lang.RuntimeException: Exception while generating code for:
FUN LOCAL_FUNCTION_FOR_LAMBDA name:PresentationRootView$lambda$1 visibility:private modality:FINAL <> (ctx:skip.ui.ComposeContext) returnType:kotlin.Unit?
  VALUE_PARAMETER name:ctx index:0 type:skip.ui.ComposeContext
  BLOCK_BODY
    VAR name:contentContext type:skip.ui.ComposeContext [val]

```

--------------------------------

### SwiftUI Button Initialization and Styling

Source: https://skip.tools/docs/components/button

This snippet showcases different ways to initialize and style SwiftUI Buttons using SkipUI. It demonstrates various initializers like `.init(action:label:)` and `.init(_ label:action:)`, along with different button roles such as `.destructive` and `.plain`. It also includes examples of applying built-in button styles like `.bordered` and `.borderedProminent`.

```swift
import SwiftUI


struct ButtonPlayground: View {
    @State var tapCount = 0


    var body: some View {
        ScrollView {
            VStack(spacing: 16.0) {
                Button(action: { tapCount += 1 }) {
                    Text(".init(action:label:): \(tapCount)")
                }
                Button(".init(_ label:action:): \(tapCount)") {
                    tapCount += 1
                }
                Button(".destructive: \(tapCount)", role: .destructive) {
                    tapCount += 1
                }
                Button(".plain: \(tapCount)") {
                    tapCount += 1
                }
                .buttonStyle(.plain)
                Button(".bordered: \(tapCount)") {
                    tapCount += 1
                }
                .buttonStyle(.bordered)
                Button(".borderedProminent: \(tapCount)") {
                    tapCount += 1
                }
                .buttonStyle(.borderedProminent)
                Button(".borderedProminent, .destructive: \(tapCount)", role: .destructive) {
                    tapCount += 1
                }
                .buttonStyle(.borderedProminent)
                Button(".disabled(true): \(tapCount)") {
                    tapCount += 1
                }
                .disabled(true)
                Button(".plain, .disabled(true): \(tapCount)") {
                    tapCount += 1
                }
                .buttonStyle(.plain)
                .disabled(true)
                Button(".bordered, .disabled(true): \(tapCount)") {
                    tapCount += 1
                }
                .buttonStyle(.bordered)
                .disabled(true)
                Button(".borderedProminent, .disabled(true): \(tapCount)") {
                    tapCount += 1
                }
                .buttonStyle(.borderedProminent)
                .disabled(true)
                Button {
                    tapCount += 1
                } label: {
                    Label("Label", systemImage: "star")
                }
                Button(".foregroundStyle(.red): \(tapCount)") {
                    tapCount += 1
                }
                .foregroundStyle(.red)
                Button(".foregroundStyle(.red), .disabled(true): \(tapCount)") {
                    tapCount += 1
                }
                .foregroundStyle(.red).disabled(true)
                Button(".tint(.red): \(tapCount)") {
                    tapCount += 1
                }
                .tint(.red)
                Button(".tint(.red), .disabled(true): \(tapCount)") {
                    tapCount += 1
                }
                .tint(.red).disabled(true)
                Button(".bordered, .foregroundStyle(.red): \(tapCount)") {
                    tapCount += 1
                }
                .buttonStyle(.bordered)
                .foregroundStyle(.red)
                Button(".bordered, .tint(.red): \(tapCount)") {
                    tapCount += 1
                }
                .buttonStyle(.bordered)
                .tint(.red)
                Button(".borderedProminent, .foregroundStyle(.red): \(tapCount)") {
                    tapCount += 1
                }
                .buttonStyle(.borderedProminent)
                .foregroundStyle(.red)
                Button(".borderedProminent, .tint(.red): \(tapCount)") {
                    tapCount += 1
                }
                .buttonStyle(.borderedProminent)
                .tint(.red)
            }
            .padding()
        }
        .toolbar {
            PlaygroundSourceLink(file: "ButtonPlayground.swift")
        }
    }
}

```

--------------------------------

### SwiftUI DatePicker Initialization and Styling

Source: https://skip.tools/docs/components/datepicker

This snippet showcases the basic usage of SwiftUI's DatePicker, demonstrating different initializers and common styling modifiers. It includes examples for setting the selection, providing string labels, hiding labels, applying button styles, disabling the picker, and changing foreground and tint colors. It also shows how to display only the date or only the time.

```swift
import SwiftUI


struct DatePickerPlayground: View {
    @State var selectedDate = Date.now


    var body: some View {
        ScrollView {
            VStack(spacing: 16.0) {
                DatePicker(selection: $selectedDate) { // Viewbuilder init
                    Text("Viewbuilder init")
                }
                DatePicker("String init", selection: $selectedDate)
                VStack {
                    Text(".labelsHidden():")
                    DatePicker("Label", selection: $selectedDate)
                }
                .labelsHidden()
                DatePicker(".buttonStyle(.plain)", selection: $selectedDate)
                    .buttonStyle(.plain)
                DatePicker(".disabled(true)", selection: $selectedDate)
                    .disabled(true)
                DatePicker(".foregroundStyle(.red)", selection: $selectedDate)
                    .foregroundStyle(.red)
                DatePicker(".tint(.red)", selection: $selectedDate)
                    .tint(.red)
                DatePicker("Date only", selection: $selectedDate, displayedComponents: .date)
                DatePicker("Time only", selection: $selectedDate, displayedComponents: .hourAndMinute)
            }
            .padding()
        }
        .toolbar {
            PlaygroundSourceLink(file: "DatePickerPlayground.swift")
        }
    }
}

```

--------------------------------

### Retrieve Android Activity in Skip Fuse

Source: https://skip.tools/docs/platformcustomization

Demonstrates how to get the current Android Activity reference within Swift code using SkipFuse extensions. This is useful for interacting with Android UI components or starting new activities.

```swift
import SwiftUI


#if os(Android)
if let activity = UIApplication.shared.dynamicAndroidActivity() {
    ...
}
#endif
```

--------------------------------

### Android Testing: Sending Deep Links via adb

Source: https://skip.tools/docs/development-topics

Provides an example of using the `adb shell am start` command to send an Android Intent for a deep link to a running emulator or device. This is a common method for testing deep link handling on Android.

```bash
% adb shell am start -W -a android.intent.action.VIEW -d "travel://cities/London"
```

--------------------------------

### SwiftUI Offset Modifier Examples

Source: https://skip.tools/docs/components/offsetposition

Demonstrates how to use the .offset modifier in SwiftUI to adjust the position of a view. It shows examples with both x and y values, and with CGSize.

```swift
import SwiftUI


struct OffsetPositionPlayground: View {
    var body: some View {
        ScrollView {
            VStack(spacing: 16) {
                HStack {
                    Text(".offset(0, 0)")
                    Spacer()
                    ZStack {
                        Color.clear
                            .frame(width: 100, height: 100)
                            .border(.primary)
                        Color.red
                            .frame(width: 20, height: 20)
                            .offset(x: 0, y: 0)
                    }
                }
                HStack {
                    Text(".offset(50, -50)")
                    Spacer()
                    ZStack {
                        Color.clear
                            .frame(width: 100, height: 100)
                            .border(.primary)
                        Color.red
                            .frame(width: 20, height: 20)
                            .offset(x: 50, y: -50)
                    }
                }
                HStack {
                    Text(".offset(-50, 50)")
                    Spacer()
                    ZStack {
                        Color.clear
                            .frame(width: 100, height: 100)
                            .border(.primary)
                        Color.red
                            .frame(width: 20, height: 20)
                            .offset(x: -50, y: 50)
                    }
                }
                HStack {
                    Text(".offset(CGSize(50, 50))")
                    Spacer()
                    ZStack {
                        Color.clear
                            .frame(width: 100, height: 100)
                            .border(.primary)
                        Color.red
                            .frame(width: 20, height: 20)
                            .offset(CGSize(width: 50, height: 50))
                    }
                }
            }
            .padding()
        }
        .toolbar {
            PlaygroundSourceLink(file: "OffsetPositionPlayground.swift")
        }
    }
}

```

--------------------------------

### SwiftUI ScrollViewReader List Example

Source: https://skip.tools/docs/components/scrollview

Presents a ScrollViewReader integrated with a SwiftUI List, allowing for scrolling to specific sections or rows. This example includes jump buttons for navigation.

```swift
import SwiftUI

private struct ScrollViewReaderListPlayground: View {
    var body: some View {
        ScrollViewReader {
            proxy in
            VStack(spacing: 16) {
                ScrollViewReaderJumpButtons(proxy: proxy)
                    .padding([.top, .bottom])
                List {
                    Section("Section 0") {
                        ForEach(0..<10, id: \.self) {
                            i in
                            Text("View: \(i)")
                        }
                    }
                    Section("Section 1") {
                        ForEach(10..<20, id: \.self) {
                            i in
                            Text("View: \(i)")
                        }
                    }
                }
            }
        }
    }
}
```

--------------------------------

### Swift Package Manager Configuration (Package.swift)

Source: https://skip.tools/docs/modes

Example `Package.swift` for a native Skip app, demonstrating dependency declarations for Skip modules (core, model, UI) and platform targeting. It includes dependencies on Skip, SkipModel, SkipFuse, and SkipFuseUI.

```swift
import PackageDescription


let package = Package(
    name: "skipapp-hiya",
    defaultLocalization: "en",
    platforms: [.iOS(.v17), .macOS(.v14), .tvOS(.v17), .watchOS(.v10), .macCatalyst(.v17)],
    products: [
        .library(name: "HiyaSkipApp", type: .dynamic, targets: ["HiyaSkip"]),
        .library(name: "HiyaSkipModel", type: .dynamic, targets: ["HiyaSkipModel"]),
        .library(name: "HiyaSkipLogic", type: .dynamic, targets: ["HiyaSkipLogic"]),
    ],
    dependencies: [
        .package(url: "https://source.skip.tools/skip.git", from: "1.2.7"),
        .package(url: "https://source.skip.tools/skip-model.git", from: "1.0.0"),
        .package(url: "https://source.skip.tools/skip-fuse.git", from: "1.0.0"),
        .package(url: "https://source.skip.tools/skip-fuse-ui.git", from: "1.0.0")
    ],
    targets: [
        .target(name: "HiyaSkip", dependencies: [
            "HiyaSkipModel",
            .product(name: "SkipFuseUI", package: "skip-fuse-ui")
        ], resources: [.process("Resources")], plugins: [.plugin(name: "skipstone", package: "skip")]),
        .target(name: "HiyaSkipModel", dependencies: [
            "HiyaSkipLogic",
            .product(name: "SkipModel", package: "skip-model"),
            .product(name: "SkipFuse", package: "skip-fuse")
        ], plugins: [.plugin(name: "skipstone", package: "skip")]),
        .testTarget(name: "HiyaSkipModelTests", dependencies: [
            "HiyaSkipModel",
            .product(name: "SkipTest", package: "skip")
        ], plugins: [.plugin(name: "skipstone", package: "skip")]),
        .target(name: "HiyaSkipLogic", dependencies: []),
    ]
)

```

--------------------------------

### SwiftUI Position Modifier Examples

Source: https://skip.tools/docs/components/offsetposition

Demonstrates how to use the .position modifier in SwiftUI to set the exact position of a view's center. It shows examples with x and y coordinates, and with CGPoint.

```swift
import SwiftUI


struct OffsetPositionPlayground: View {
    var body: some View {
        ScrollView {
            VStack(spacing: 16) {
                HStack {
                    Text(".position(0, 0)")
                    Spacer()
                    ZStack {
                        Color.red
                            .frame(width: 20, height: 20)
                            .position(x: 0, y: 0)
                    }
                    .frame(width: 100, height: 100)
                    .border(.primary)
                }
                HStack {
                    Text(".position(50, 50)")
                    Spacer()
                    ZStack {
                        Color.red
                            .frame(width: 20, height: 20)
                            .position(x: 50, y: 50)
                    }
                    .frame(width: 100, height: 100)
                    .border(.primary)
                }
                HStack {
                    Text(".position(CGPoint(75, 75))")
                    Spacer()
                    ZStack {
                        Color.red
                            .frame(width: 20, height: 20)
                            .position(CGPoint(x: 75, y: 75))
                    }
                    .frame(width: 100, height: 100)
                    .border(.primary)
                }
                NavigationLink("Push Text.position(100, 100)") {
                    Text("Over here!")
                        .background(.yellow)
                        .position(x: 100, y: 100)
                }
            }
            .padding()
        }
        .toolbar {
            PlaygroundSourceLink(file: "OffsetPositionPlayground.swift")
        }
    }
}

```

--------------------------------

### skip android sdk list: List the installed Swift Android SDKs

Source: https://skip.tools/docs/skip-cli

Lists the installed Swift Android SDKs. It can list local SDKs or remote SDKs that can be installed, including development SDKs.

```APIDOC
## GET /websites/skip_tools/android/sdk/list

### Description
Lists the installed Swift Android SDKs. This command can also list remote SDKs that are available for installation.

### Method
GET

### Endpoint
`/websites/skip_tools/android/sdk/list`

### Parameters
#### Query Parameters
- **output** (string) - Optional - Send output to the given file (stdout: -)
- **message-errout** (boolean) - Optional - Emit messages to the output rather than stderr
- **verbose** (boolean) - Optional - Whether to display verbose messages
- **quiet** (boolean) - Optional - Quiet mode: suppress output
- **json** (boolean) - Optional - Emit output as formatted JSON
- **json-compact** (boolean) - Optional - Emit output as compact JSON
- **message-plain** (boolean) - Optional - Show console messages as plain text rather than JSON
- **log-file** (string) - Optional - Send log output to the file
- **json-array** (boolean) - Optional - Wrap and delimit JSON output as an array
- **plain** (boolean) - Optional - Show no colors or progress animations
- **no-plain** (boolean) - Optional - Show colors and progress animations
- **xcodebuild** (string) - Optional - Xcode command path
- **swift** (string) - Optional - Swift command path
- **gradle** (string) - Optional - Gradle command path
- **adb** (string) - Optional - ADB command path
- **emulator** (string) - Optional - Android emulator path
- **android-home** (string) - Optional - Path to the Android SDK (ANDROID_HOME)
- **remote** (boolean) - Optional - List remote SDKs that can be installed
- **devel** (boolean) - Optional - Include development SDKs in remote list
- **help** (boolean) - Optional - Show help information.

### Response
#### Success Response (200)
- **sdks** (array) - A list of installed or available Android SDKs.
  - **name** (string) - The name of the SDK.
  - **version** (string) - The version of the SDK.
  - **path** (string) - The installation path of the SDK.

#### Response Example
```json
{
  "sdks": [
    {
      "name": "android-29",
      "version": "29.0.3",
      "path": "/path/to/android/sdk/platforms/android-29"
    }
  ]
}
```
```

--------------------------------

### Initializing a Dual-Platform Swift Framework

Source: https://skip.tools/docs/project-types

This command initializes a new Swift Package Manager (SwiftPM) project designed to function as a dual-platform framework. The `--native-model` flag ensures that the Swift API is automatically bridged to Android's ART Java runtime, facilitating cross-platform compatibility. The generated project includes targets for the module and its tests.

```bash
skip init --native-model lib-name ModuleName
```

--------------------------------

### SwiftUI Bottom Bar Example (iOS)

Source: https://skip.tools/docs/components/safearea

A SwiftUI View designed for iOS that includes a list and a bottom toolbar, presented within a NavigationStack. This example showcases how to implement a persistent bottom bar in a navigation context.

```swift
#if os(macOS)
#else
struct SafeAreaBottomBar: View {
    @Environment(\.dismiss) var dismiss


    var body: some View {
        NavigationStack {
            List(0..<40) {
                Text("Row: \(index)")
            }

```

--------------------------------

### Initialize Skip Project

Source: https://skip.tools/docs/samples/skipapp-databake

Initializes a new Skip project with specified application ID, icon color, and project name. This command sets up the basic structure for a Skip application.

```bash
skip init --appid=skip.data.bake.App --icon-color=34AADC --free skipapp-databake DataBake DataBakeModel
```

--------------------------------

### SwiftUI and Compose UI Components

Source: https://skip.tools/docs/swiftsupport

Demonstrates creating a simple UI with a text display, slider, and button in both SwiftUI (Swift) and Jetpack Compose (Kotlin). These examples showcase basic state management and UI element integration.

```swift
import SwiftUI


struct ContentView : View {
  @State var value = 0.0


  var body: some View {
    VStack {
      Text("Current value: \(value)")
      Slider(value: $value)
      Button("Reset") {
        value = 0.0
      }
    }
  }
}
```

```kotlin
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.saveable.Saver
import androidx.compose.runtime.saveable.rememberSaveable
import androidx.compose.runtime.setValue


import skip.ui.*
import skip.foundation.*
import skip.model.*


internal class ContentView: View {
    internal var value: Double
        get() = _value.wrappedValue
        set(newValue) {
            _value.wrappedValue = newValue
        }
    internal var _value: skip.ui.State<Double>


    override fun body(): View {
        return ComposeBuilder { composectx: ComposeContext ->
            VStack { ->
                ComposeBuilder { composectx: ComposeContext ->
                    Text({
                        val str = LocalizedStringKey.StringInterpolation(literalCapacity = 0, interpolationCount = 0)
                        str.appendLiteral("Current value: ")
                        str.appendInterpolation(value)
                        LocalizedStringKey(stringInterpolation = str)
                    }()).Compose(composectx)
                    Slider(value = Binding({ _value.wrappedValue }, { it -> _value.wrappedValue = it })).Compose(composectx)
                    Button(LocalizedStringKey(stringLiteral = "Reset")) { -> value = 0.0 }.Compose(composectx)
                    ComposeResult.ok
                }
            }.Compose(composectx)
        }
    }


    @Composable
    @Suppress("UNCHECKED_CAST")
    override fun Evaluate(context: ComposeContext, options: Int): kotlin.collections.List<Renderable> {
        val rememberedvalue by rememberSaveable(stateSaver = context.stateSaver as Saver<skip.ui.State<Double>, Any>) { mutableStateOf(_value) }
        _value = rememberedvalue


        return super.Evaluate(context, options)
    }


    constructor(value: Double = 0.0) {
        this._value = skip.ui.State(value)
    }
}
```

--------------------------------

### SwiftUI ScrollViewReader LazyHStack Example

Source: https://skip.tools/docs/components/scrollview

Demonstrates ScrollViewReader with a LazyHStack in SwiftUI, enabling horizontal scrolling control. It features jump buttons for navigating to specific elements.

```swift
import SwiftUI

private struct ScrollViewReaderLazyHStackPlayground: View {
    var body: some View {
        ScrollViewReader {
            proxy in
            VStack(spacing: 16) {
                ScrollViewReaderJumpButtons(proxy: proxy)
                    .padding([.top, .bottom])
                ScrollView(.horizontal) {
                    LazyHStack {
                        ForEach(0..<30, id: \.self) {
                            i in
                            Text("View: \(i)")
                                .padding()
                        }
                    }
                }
                .border(.primary, width: 1)
            }
        }
    }
}
```

--------------------------------

### Initialize SQLContext with SQLPlus Configuration

Source: https://skip.tools/docs/modules/skip-sql

Demonstrates how to initialize the SQLContext with the SQLPlus configuration, enabling advanced SQLite features. This involves importing the necessary modules and passing `.plus` to the configuration parameter.

```swift
import SkipSQLCore
import SkipSQLPlus


let dbpath = URL.applicationSupportDirectory.appendingPathComponent("db.sqlite")
let db = try SQLContext(path: dbpath.path, flags: [.create, .readWrite], configuration: .plus)
// do something with the database
db.close()

```

--------------------------------

### Bundle Initialization and Resource Access in Swift

Source: https://skip.tools/docs/modules/skip-foundation

Shows how to initialize `Bundle` objects and access resources using `Bundle` APIs in Swift. This functionality has 'High' support on Android, but note that `bundlePath` and `resourcePath` might have limitations.

```swift
let mainBundle = Bundle.main
let moduleBundle = Bundle.module
let bundleFromPath = Bundle(path: "/path/to/bundle")
let bundleFromURL = Bundle(url: URL(fileURLWithPath: "/path/to/bundle.bundle"))
let resourceURL = mainBundle.url(forResource: "image", withExtension: "png")
let localizedString = mainBundle.localizedString(forKey: "key", value: "default", table: "TableName")
```

--------------------------------

### SwiftUI Horizontal ScrollView Example

Source: https://skip.tools/docs/components/scrollview

Illustrates a horizontal ScrollView in SwiftUI, featuring an HStack with 30 text elements. This is suitable for content that needs to scroll from side to side.

```swift
import SwiftUI

private struct HorizontalScrollViewPlayground: View {
    var body: some View {
        ScrollView(.horizontal) {
            HStack {
                ForEach(0..<30) {
                    i in
                    Text("View: \(i)")
                        .padding()
                }
            }
        }
    }
}
```

--------------------------------

### SwiftUI Vertical ScrollView Example

Source: https://skip.tools/docs/components/scrollview

Demonstrates a basic vertical ScrollView in SwiftUI, containing a VStack with 30 text elements. This is useful for displaying vertically scrollable content.

```swift
import SwiftUI

private struct VerticalScrollViewPlayground: View {
    var body: some View {
        ScrollView {
            VStack {
                ForEach(0..<30) {
                    i in
                    Text("View: \(i)")
                        .padding()
                }
            }
        }
    }
}
```

--------------------------------

### Initialize and Use NFCAdapter in Swift

Source: https://skip.tools/docs/modules/skip-nfc

This Swift code demonstrates the basic usage of the NFCAdapter from the skip-nfc framework. It shows how to instantiate the adapter, start scanning for NFC tags, and stop scanning. The `startScanning` method accepts a closure to handle received messages.

```swift
let nfcAdapter: NFCAdapter = NFCAdapter()
nfcAdapter.startScanning { message in
    print("received message: \(message)")
}
nfcAdapter.stopScanning()

```

--------------------------------

### SwiftUI Scale Effect Animation

Source: https://skip.tools/docs/components/animation

Illustrates animating the scale of a view in SwiftUI using the .scaleEffect modifier. This example uses implicit animation tied to the `isOn` state.

```swift
HStack {
    Text(".scaleEffect")
    Spacer()
    Color.red
        .frame(width: 100, height: 100)
        .scaleEffect(isOn ? 0.5 : 1.0)
        .onTapGesture {
            isOn = !isOn
        }
}
```

```swift
HStack {
    Text(".scaleEffect.animation")
    Spacer()
    Color.red
        .frame(width: 100, height: 100)
        .scaleEffect(isOn ? 0.5 : 1.0)
        .animation(.default, value: isOn)
        .onTapGesture {
            isOn = !isOn
        }
}
```

--------------------------------

### Query App Installation Source with Skip Marketplace

Source: https://skip.tools/docs/modules/skip-marketplace

This Swift code snippet illustrates how to determine the source from which an app was installed using the `Marketplace.current.installationSource` property. It uses a switch statement to handle different sources like Apple App Store, Google Play Store, and others.

```swift
switch await Marketplace.current.installationSource {
case .appleAppStore: canUseNativeBillling = true
case .googlePlayStore: canUseNativeBillling = true
case .other(let id): canUseNativeBillling = false // handle other markerplaces here
default: canUseNativeBillling = false
}

```

--------------------------------

### SwiftUI ScrollViewReader LazyVStack Example

Source: https://skip.tools/docs/components/scrollview

Shows how to use ScrollViewReader with a LazyVStack in SwiftUI for programmatic scrolling. It includes jump buttons to navigate to specific items within the scrollable content.

```swift
import SwiftUI

private struct ScrollViewReaderLazyVStackPlayground: View {
    var body: some View {
        ScrollViewReader {
            proxy in
            VStack(spacing: 16) {
                ScrollViewReaderJumpButtons(proxy: proxy)
                    .padding([.top, .bottom])
                ScrollView {
                    LazyVStack {
                        ForEach(0..<30, id: \.self) {
                            i in
                            Text("View: \(i)")
                                .padding()
                        }
                    }
                }
                .border(.primary, width: 1)
            }
        }
    }
}
```
Tokens:
Raw