This document explains the project architecture of the Pinqponq Chat SDK and how different customer types can integrate it based on their platform and development needs. After reading this document, developers will understand the SDK's modular structure, available components, and integration approaches for various platforms.

The Pinqponq Chat SDK is built using Kotlin Multiplatform technology, providing a unified codebase that compiles to multiple platforms while maintaining platform-specific optimizations.

pinqponq-chat-kmp/
├── pinqponqchat-core/          # Core business logic (Kotlin Multiplatform)
├── pinqponqchat-ui/            # Internal UI components (used by core)
├── pinqponqchat/               # Full SDK (Core + UI integrated)
├── sample/                     # Sample applications
├── vanilla-ios/                # Native iOS integration examples (SPM)
└── vanilla-web/                # Web integration examples (Not supported, working on it)

1. Core Layer (pinqponqchat-core)

   • Business logic and data models
   • Platform-agnostic chat functionality
   • Compiles to: Android, iOS, Desktop (Compose Multiplatform), Web (Compose Multiplatform WASM)

2. UI Layer (pinqponqchat-ui) - Internal Only

   • Compose Multiplatform UI components
   • Used internally by the core module
   • Not directly accessible to customers

3. Full SDK (pinqponqchat)

   • Complete solution with integrated UI
   • Ready-to-use chat functionality
   • Platform-specific optimizations
   • Uses UI layer internally

You have a Kotlin Multiplatform project targeting Android, iOS, Desktop, and/or Web (WASM). You want to add chat functionality while maintaining code sharing across platforms.

The SDK integrates seamlessly with your existing KMP architecture, providing shared business logic and UI components that work across all your target platforms.

• pinqponqchat → Full SDK (Complete UI + Business Logic)
• pinqponqchat-core → Core SDK (Business Logic Only)

Note: UI components are integrated within the Full SDK and not available as a separate module.

Full SDK Integration:

// In your commonMain module
import pinqponqchat.PinqponqChat
import pinqponqchat.PinqponqChatConfig

class ChatFeature {
    fun initializeChat() {
        PinqponqChat.init(PinqponqChatConfig(
            apiKey = "your-api-key",
            // other configuration
        ))
    }
    
    @Composable
    fun ChatScreen() {
        PinqponqChat.screens.ChatScreen()
    }
}

Core SDK Integration:

// In your commonMain module
import pinqponqchat.core.PinqponqChatCore

class CustomChatManager {
    fun initialize() {
        PinqponqChatCore.init(apiKey = "your-api-key")
    }
    
    fun getMessages(): List<ChatMessage> {
        return PinqponqChatCore.getChatMessages()
    }
    
    fun sendMessage(text: String) {
        PinqponqChatCore.sendMessage(text)
    }
}

• Full SDK: Rapid development with pre-built, platform-optimized UI components
• Core SDK: Maximum flexibility for custom UI while sharing business logic across platforms
• Code Sharing: Single codebase for chat functionality across all platforms
• Platform Optimization: Each platform gets native-optimized implementations

You have a native Android project using Kotlin, targeting Android devices only. You want to add chat functionality with either pre-built UI or custom implementation.

The SDK provides Android-specific optimizations while maintaining the same API surface as the multiplatform version. You can choose between complete UI solutions or just the business logic layer.

• pinqponqchat → Full SDK (Complete UI + Business Logic)
• pinqponqchat-core → Core SDK (Business Logic Only)

Note: UI components are integrated within the Full SDK and not available as a separate module.

Full SDK Integration (Jetpack Compose):

// In your Android Activity/Fragment
import pinqponqchat.PinqponqChat
import pinqponqchat.PinqponqChatConfig

class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        
        // Initialize the SDK
        PinqponqChat.init(PinqponqChatConfig(
            apiKey = "your-api-key",
            context = this
        ))
        
        setContent {
            MyAppTheme {
                PinqponqChat.screens.ChatScreen()
            }
        }
    }
}

Core SDK Integration (Custom UI):

// In your Android project
import pinqponqchat.core.PinqponqChatCore

class ChatViewModel : ViewModel() {
    private val _messages = MutableLiveData<List<ChatMessage>>()
    val messages: LiveData<List<ChatMessage>> = _messages
    
    init {
        PinqponqChatCore.init(apiKey = "your-api-key")
        loadMessages()
    }
    
    fun sendMessage(text: String) {
        PinqponqChatCore.sendMessage(text)
        loadMessages()
    }
    
    private fun loadMessages() {
        _messages.value = PinqponqChatCore.getChatMessages()
    }
}

• Full SDK: Drop-in chat screens with native Android optimizations
• Core SDK: Integrate chat logic into existing Android apps, games, or custom UI frameworks
• Native Performance: Optimized for Android platform specifics
• Flexible Integration: Works with Jetpack Compose, traditional Views, or custom rendering

You have a native iOS project using Swift, targeting iOS devices. You want to integrate chat functionality while maintaining full control over the iOS-native user experience.

The SDK provides the core business logic as a Kotlin/Native framework that integrates with your Swift project via Swift Package Manager. You build your own UI using SwiftUI or UIKit.

• pinqponqchat-core → Core SDK (Business Logic Only) via Swift Package Manager

Note: Only the Core SDK is available for iOS. UI components are not accessible on iOS platform.

Swift Package Manager Integration:

// In your iOS project
import PinqponqChatCore

class ChatManager: ObservableObject {
    @Published var messages: [ChatMessage] = []
    @Published var isInitialized = false
    
    private let core = PinqponqChatCore()
    
    func initialize(apiKey: String) {
        core.initialize(apiKey: apiKey)
        isInitialized = true
        loadMessages()
    }
    
    func sendMessage(_ text: String) {
        core.sendMessage(text)
        loadMessages()
    }
    
    private func loadMessages() {
        messages = core.getChatMessages().map { text in
            ChatMessage(text: text, timestamp: Date())
        }
    }
}

SwiftUI Integration:

import SwiftUI
import PinqponqChatCore

struct ChatView: View {
    @StateObject private var chatManager = ChatManager()
    
    var body: some View {
        VStack {
            // Your custom chat UI
            ScrollView {
                LazyVStack {
                    ForEach(chatManager.messages) { message in
                        MessageBubble(message: message)
                    }
                }
            }
            
            // Your custom input
            MessageInput(chatManager: chatManager)
        }
        .onAppear {
            chatManager.initialize(apiKey: "your-api-key")
        }
    }
}

• Native iOS Experience: Full control over UI/UX using SwiftUI or UIKit
• Shared Business Logic: Leverage the same chat logic across platforms
• Swift Package Manager: Easy integration and dependency management
• Performance: Native iOS optimizations without Compose overhead
• Customization: Complete freedom to match your app's design system

Note: UI is provided within the pinqponqchat module for Compose Multiplatform and Kotlin projects. UI SDK is internal and not directly accessible to customers. Desktop and Web platforms are only supported within Compose Multiplatform projects. Web JS export is not currently supported due to Kotlin/JS export limitations.

Note: UI is provided within the pinqponqchat module for Compose Multiplatform and Kotlin projects. Desktop and Web platforms are only supported within Compose Multiplatform projects. Web JS export is not currently supported due to Kotlin/JS export limitations.

We are actively monitoring the latest developments in Kotlin/JS export capabilities and JavaScript interoperability. While Web JS export is not currently supported due to technical limitations, we are following:

• Kotlin/JS IR Backend improvements
• JavaScript export enhancements in Kotlin Multiplatform
• Compose Web compatibility with JS export
• NPM package distribution capabilities

When these limitations are resolved, we plan to add full Web JS export support with NPM package distribution. Stay updated by following our repository for announcements.

• You want rapid development with pre-built UI
• You're building a new project or major feature
• You need consistent UI across platforms
• You want to minimize custom development

• You have existing UI that needs chat functionality
• You want complete control over user experience
• You're building a game or custom rendering system
• You need platform-specific UI optimizations