Complete Examples

Complete App Examples

Copy-paste these complete examples to get started quickly.

---

Swift (iOS) - Complete UIKit Example

import UIKit
import OnairosSDK

class ViewController: UIViewController {
    
    override func viewDidLoad() {
        super.viewDidLoad()
        setupOnairos()
    }
    
    func setupOnairos() {
        // Initialize SDK
        Task {
            try? await OnairosSDK.shared.initializeWithApiKey("your_api_key")
            
            await MainActor.run {
                addConnectButton()
            }
        }
    }
    
    func addConnectButton() {
        let button = OnairosSDK.shared.createConnectButton { [weak self] result in
            switch result {
            case .success(let data):
                self?.handleSuccess(data)
            case .failure(let error):
                self?.handleError(error)
            }
        }
        
        view.addSubview(button)
        button.translatesAutoresizingMaskIntoConstraints = false
        NSLayoutConstraint.activate([
            button.centerXAnchor.constraint(equalTo: view.centerXAnchor),
            button.centerYAnchor.constraint(equalTo: view.centerYAnchor)
        ])
    }
    
    func handleSuccess(_ data: OnboardingData) {
        print("API URL: \(data.apiURL)")
        print("Token: \(data.token)")
        
        // Make inference request
        guard let url = URL(string: data.apiURL) else { return }
        var request = URLRequest(url: url)
        request.httpMethod = "POST"
        request.setValue("Bearer \(data.token)", forHTTPHeaderField: "Authorization")
        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
        
        let input: [String: Any] = [
            "Input": [
                "item1": ["text": "Example content", "category": "general"]
            ]
        ]
        request.httpBody = try? JSONSerialization.data(withJSONObject: input)
        
        URLSession.shared.dataTask(with: request) { data, _, error in
            if let data = data,
               let json = try? JSONSerialization.jsonObject(with: data) {
                print("Result: \(json)")
            }
        }.resume()
    }
    
    func handleError(_ error: OnairosError) {
        let alert = UIAlertController(
            title: "Error",
            message: error.localizedDescription,
            preferredStyle: .alert
        )
        alert.addAction(UIAlertAction(title: "OK", style: .default))
        present(alert, animated: true)
    }
}

---

Swift (iOS) - Complete SwiftUI Example

import SwiftUI
import OnairosSDK

@main
struct MyApp: App {
    var body: some Scene {
        WindowGroup {
            ContentView()
        }
    }
}

struct ContentView: View {
    @State private var isConnected = false
    @State private var platforms: [String] = []
    @State private var errorMessage: String?
    
    var body: some View {
        VStack(spacing: 24) {
            Text("Welcome")
                .font(.largeTitle.bold())
            
            if isConnected {
                VStack {
                    Image(systemName: "checkmark.circle.fill")
                        .font(.system(size: 60))
                        .foregroundColor(.green)
                    Text("Connected!")
                    Text(platforms.joined(separator: ", "))
                        .foregroundColor(.secondary)
                }
            } else {
                OnairosButtonWrapper { result in
                    switch result {
                    case .success(let data):
                        platforms = Array(data.connectedPlatforms.keys)
                        isConnected = true
                    case .failure(let error):
                        errorMessage = error.localizedDescription
                    }
                }
            }
        }
        .padding()
        .alert("Error", isPresented: .constant(errorMessage != nil)) {
            Button("OK") { errorMessage = nil }
        } message: {
            Text(errorMessage ?? "")
        }
        .task {
            try? await OnairosSDK.shared.initializeWithApiKey("your_api_key")
        }
    }
}

struct OnairosButtonWrapper: UIViewRepresentable {
    let onComplete: (Result<OnboardingData, OnairosError>) -> Void
    
    func makeUIView(context: Context) -> UIButton {
        OnairosSDK.shared.createConnectButton { result in
            if case .success(.success(let data)) = result {
                onComplete(.success(data))
            } else if case .failure(let error) = result {
                onComplete(.failure(error))
            }
        }
    }
    
    func updateUIView(_ uiView: UIButton, context: Context) {}
}

---

React Native - Complete Example

import React, { useState, useEffect } from 'react';
import { View, Text, StyleSheet, Alert } from 'react-native';
import { OnairosButton, initializeApiKey } from '@onairos/react-native';

export default function App() {
  const [isConnected, setIsConnected] = useState(false);
  const [userData, setUserData] = useState(null);

  useEffect(() => {
    initializeApiKey({ apiKey: 'your_api_key' });
  }, []);

  const handleComplete = async (data) => {
    console.log('API URL:', data.apiURL);
    console.log('Token:', data.token);
    
    // Make inference request
    try {
      const response = await fetch(data.apiURL, {
        method: 'POST',
        headers: {
          'Authorization': `Bearer ${data.token}`,
          'Content-Type': 'application/json',
        },
        body: JSON.stringify({
          Input: {
            item1: { text: 'Example content', category: 'general' }
          }
        }),
      });
      
      const result = await response.json();
      setUserData(result);
      setIsConnected(true);
    } catch (error) {
      Alert.alert('Error', error.message);
    }
  };

  const handleError = (error) => {
    if (error.code !== 'USER_CANCELLED') {
      Alert.alert('Error', error.message);
    }
  };

  return (
    <View style={styles.container}>
      <Text style={styles.title}>Welcome</Text>
      
      {isConnected ? (
        <View style={styles.success}>
          <Text style={styles.successText}>Connected!</Text>
          {userData && (
            <Text>{JSON.stringify(userData, null, 2)}</Text>
          )}
        </View>
      ) : (
        <OnairosButton
          AppName="MyApp"
          onResolved={handleComplete}
          onError={handleError}
          requestData={{
            personality_traits: {
              name: "Personality",
              description: "AI analysis for personalization",
              reward: "Better recommendations"
            }
          }}
        />
      )}
    </View>
  );
}

const styles = StyleSheet.create({
  container: { flex: 1, justifyContent: 'center', alignItems: 'center', padding: 20 },
  title: { fontSize: 32, fontWeight: 'bold', marginBottom: 40 },
  success: { alignItems: 'center' },
  successText: { fontSize: 24, color: 'green', marginBottom: 10 },
});

---

Flutter - Complete Example

import 'package:flutter/material.dart';
import 'package:onairos/onairos.dart';
import 'package:http/http.dart' as http;
import 'dart:convert';

void main() => runApp(MyApp());

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'Onairos Demo',
      home: HomeScreen(),
    );
  }
}

class HomeScreen extends StatefulWidget {
  @override
  _HomeScreenState createState() => _HomeScreenState();
}

class _HomeScreenState extends State<HomeScreen> {
  bool isConnected = false;
  Map<String, dynamic>? userData;

  Future<void> onResolved(String apiUrl, String token) async {
    print('API URL: $apiUrl');
    print('Token: $token');

    try {
      final response = await http.post(
        Uri.parse(apiUrl),
        headers: {
          'Authorization': 'Bearer $token',
          'Content-Type': 'application/json',
        },
        body: jsonEncode({
          'Input': {
            'item1': {'text': 'Example content', 'category': 'general'}
          }
        }),
      );

      if (response.statusCode == 200) {
        setState(() {
          userData = jsonDecode(response.body);
          isConnected = true;
        });
      }
    } catch (e) {
      ScaffoldMessenger.of(context).showSnackBar(
        SnackBar(content: Text('Error: $e')),
      );
    }
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(title: Text('Onairos Demo')),
      body: Center(
        child: isConnected
            ? Column(
                mainAxisAlignment: MainAxisAlignment.center,
                children: [
                  Icon(Icons.check_circle, size: 80, color: Colors.green),
                  SizedBox(height: 16),
                  Text('Connected!', style: TextStyle(fontSize: 24)),
                  if (userData != null)
                    Padding(
                      padding: EdgeInsets.all(16),
                      child: Text(jsonEncode(userData)),
                    ),
                ],
              )
            : OnairosButtonWrapper1(
                webpageName: 'MyApp',
                requestData: {
                  'personality_traits': {
                    'name': 'Personality',
                    'description': 'AI analysis for personalization',
                    'reward': 'Better recommendations',
                  }
                },
                returnLink: 'myapp://callback',
                autoFetch: false,
                onResolved: onResolved,
                inferenceData: {},
                proofMode: false,
                textColor: 'black',
                textLayout: 'right',
              ),
      ),
    );
  }
}