chore: remove markdown docs

BaseCommon/Sources/BaseCommon/Common/SocketIO/README.md

@@ -1,172 +0,0 @@
-# Socket.IO 服务使用说明
-
-## 概述
-
-`SocketIOManager` 是 BaseCommon 提供的 Socket.IO 统一封装管理器，与 `AuthManager`、`VersionUpdateManager` 类似，提供统一的 Socket.IO 通信能力。
-
-## 特性
-
-✅ **自动处理连接**：包括 Token 刷新  
-✅ **自动处理重连**：连接断开后自动重连  
-✅ **简单易用**：外部只需要订阅即可  
-✅ **统一封装**：与 HTTP API 封装保持一致  
-
-## 使用方式
-
-### 1. 初始化（在 Application 中）
-
-```swift
-import BaseCommon
-
-@main
-struct MyApp: App {
-    init() {
-        Task {
-            // 初始化 Socket.IO 服务（会自动连接）
-            await SocketIOManager.shared.initialize()
-        }
-    }
-    
-    var body: some Scene {
-        WindowGroup {
-            ContentView()
-        }
-    }
-}
-```
-
-### 2. 订阅消息（在 ViewModel 中）
-
-```swift
-import BaseCommon
-import SwiftUI
-
-class CommunityViewModel: ObservableObject {
-    @Published var messages: [String] = []
-    
-    init() {
-        // 订阅社区消息
-        Task {
-            for await message in SocketIOManager.shared.subscribe("community_message") {
-                await MainActor.run {
-                    messages.append(message.data)
-                }
-            }
-        }
-    }
-}
-```
-
-### 3. 订阅系统消息
-
-```swift
-class SystemViewModel: ObservableObject {
-    @Published var systemMessages: [SocketIOResponse] = []
-    
-    init() {
-        // 订阅系统消息
-        Task {
-            for await message in SocketIOManager.shared.subscribe("system_message") {
-                await MainActor.run {
-                    systemMessages.append(message)
-                }
-            }
-        }
-    }
-}
-```
-
-### 4. 订阅车辆消息
-
-```swift
-class VehicleViewModel: ObservableObject {
-    @Published var vehicleAlarms: [SocketIOResponse] = []
-    
-    init() {
-        // 订阅车辆报警
-        Task {
-            for await message in SocketIOManager.shared.subscribe("vehicle_alarm") {
-                await MainActor.run {
-                    vehicleAlarms.append(message)
-                }
-            }
-        }
-    }
-}
-```
-
-### 5. 发送消息
-
-```swift
-// 发送车辆控制指令
-Task {
-    let command = [
-        "command": "find_vehicle",
-        "vehicleId": 1,
-        "timestamp": Int64(Date().timeIntervalSince1970 * 1000)
-    ] as [String: Any]
-    
-    SocketIOManager.shared.emit("vehicle_control", data: command)
-}
-```
-
-### 6. 监听连接状态（使用 Combine）
-
-```swift
-import Combine
-
-class ConnectionViewModel: ObservableObject {
-    @Published var isConnected = false
-    private var cancellables = Set<AnyCancellable>()
-    
-    init() {
-        SocketIOManager.shared.connectionStatePublisher
-            .receive(on: DispatchQueue.main)
-            .assign(to: &$isConnected)
-    }
-}
-```
-
-## 架构说明
-
-### 与 Android 保持一致
-
-- **Android**: Socket.IO 封装在 `base-common/common/network/SocketIOService.kt`
-- **iOS**: Socket.IO 封装在 `BaseCommon/Common/SocketIO/SocketIOManager.swift`
-
-### 自动处理
-
-- ✅ **Token 刷新**：使用 `AuthManager.refreshTokenIfNeeded()`
-- ✅ **自动重连**：连接断开后自动重连
-- ✅ **服务器地址**：从 `ServerConfigManager` 自动获取
-
-### 依赖关系
-
-```
-BaseCommon
-├── BaseCore (基础设施)
-├── Socket.IO Client (外部依赖)
-└── AuthManager (同模块，可直接使用)
-```
-
-## 注意事项
-
-1. **初始化时机**：建议在 Application 启动时初始化
-2. **订阅时机**：可以在 ViewModel 的 `init()` 中订阅
-3. **线程安全**：所有操作都是线程安全的
-4. **自动重连**：连接断开后会自动重连，无需手动处理
-
-## 事件类型
-
-常见的事件类型：
-
-- `connect` - 连接成功
-- `disconnect` - 断开连接
-- `connect_error` - 连接错误
-- `vehicle_status` - 车辆状态更新
-- `vehicle_control` - 车辆控制响应
-- `vehicle_alarm` - 车辆报警
-- `community_message` - 社区消息
-- `system_message` - 系统消息
-- `inbox_message` - 站内信
-

CapabilityPush/README.md

@@ -1,164 +0,0 @@
-# CapabilityPush - iOS 推送能力层
-
-推送能力层模块，提供推送消息接收和处理能力，可独立打包为 SDK。
-
-## 📦 模块结构
-
-```
-CapabilityPush/
-├── Package.swift              # Swift Package 配置
-├── Sources/
-│   └── CapabilityPush/
-│       ├── CapabilityPush.swift      # 模块入口
-│       └── Push/
-│           ├── Model/
-│           │   └── PushConfig.swift  # 推送配置模型
-│           ├── Impl/
-│           │   └── PushServiceImpl.swift  # 推送服务实现
-│           └── Factory/
-│               └── PushServiceFactory.swift  # 推送服务工厂
-└── Tests/
-    └── CapabilityPushTests/
-```
-
-## 🔗 依赖关系
-
-- **BaseCore**: 依赖本地 BaseCore 模块（提供 IPushService 接口和 ILog）
-
-## 📝 使用方式
-
-### 1. 在 Xcode 项目中添加依赖
-
-```swift
-// Package.swift 或 Xcode Package Dependencies
-dependencies: [
-    .package(path: "../CapabilityPush"),
-    .package(path: "../BaseCore")
-]
-```
-
-### 2. 初始化推送服务
-
-```swift
-import CapabilityPush
-import BaseCore
-
-// 在 AppDelegate 中初始化
-func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
-    PushServiceFactory.initialize(
-        appKey: "your-jpush-appkey",
-        channel: "App Store",
-        debugMode: false
-    )
-    return true
-}
-```
-
-### 3. 使用推送服务
-
-```swift
-let pushService = PushServiceFactory.create()
-
-// 设置别名
-pushService.setAlias("user123")
-
-// 设置标签
-pushService.setTags(["vip", "premium"])
-
-// 设置消息监听
-pushService.setMessageListener { title, content, extras, messageId in
-    print("收到消息: \(title) - \(content)")
-}
-
-// 注册推送
-pushService.register()
-```
-
-## 📦 单独打包 SDK
-
-### 方式一：使用 Swift Package Manager
-
-1. **本地打包**：
-```bash
-cd CapabilityPush
-swift build
-```
-
-2. **发布到 Git**：
-```bash
-git tag 1.0.0
-git push origin 1.0.0
-```
-
-3. **在其他项目中使用**：
-```swift
-dependencies: [
-    .package(url: "https://github.com/your-org/CapabilityPush.git", from: "1.0.0")
-]
-```
-
-### 方式二：使用 Xcode Archive
-
-1. 在 Xcode 中打开 `CapabilityPush` 项目
-2. Product → Archive
-3. 导出为 Framework 或 XCFramework
-
-### 方式三：使用 CocoaPods（可选）
-
-创建 `CapabilityPush.podspec`：
-```ruby
-Pod::Spec.new do |s|
-  s.name             = 'CapabilityPush'
-  s.version          = '1.0.0'
-  s.summary          = '推送能力层模块'
-  s.homepage         = 'https://github.com/your-org/CapabilityPush'
-  s.license          = { :type => 'MIT' }
-  s.author           = { 'Your Name' => 'your@email.com' }
-  s.source           = { :git => 'https://github.com/your-org/CapabilityPush.git', :tag => s.version }
-  s.ios.deployment_target = '15.0'
-  s.source_files = 'Sources/CapabilityPush/**/*.swift'
-  s.dependency 'BaseCore'
-end
-```
-
-## 🔧 集成第三方 SDK
-
-### 集成 JPush iOS SDK
-
-1. 在 `Package.swift` 中添加依赖：
-```swift
-dependencies: [
-    .package(url: "https://github.com/jpush/jpush-ios-sdk.git", from: "5.0.0")
-]
-```
-
-2. 在 `PushServiceImpl.swift` 中实现具体逻辑：
-```swift
-import JPush
-
-// 初始化
-JPush.setup(withOption: launchOptions, appKey: appKey, channel: channel, apsForProduction: !debugMode)
-
-// 注册设备 Token
-JPush.registerDeviceToken(deviceToken)
-
-// 设置别名
-JPush.setAlias(alias) { (iResCode, iAlias, seq) in
-    // 处理结果
-}
-```
-
-## 📋 注意事项
-
-1. **依赖管理**：确保 BaseCore 已正确配置
-2. **权限配置**：在 `Info.plist` 中配置推送权限说明
-3. **AppDelegate 集成**：需要在 AppDelegate 中处理 APNs 回调
-4. **测试**：集成 JPush SDK 后需要真机测试
-
-## 🏗️ 架构说明
-
-- **接口定义**：在 BaseCore 中定义 `IPushService` 接口
-- **实现类**：在 CapabilityPush 中实现 `PushServiceImpl`
-- **解耦设计**：通过接口实现 BaseCore 与 CapabilityPush 的解耦
-- **独立打包**：每个能力层都是独立的 Swift Package，可以单独打包和发布
-

CapabilityQRCode/使用说明.md

@@ -1,144 +0,0 @@
-# 二维码扫码功能使用说明（iOS）
-
-## 功能特点
-
-- ✅ 使用华为 Scan Kit 实现二维码扫描功能
-- ✅ 自动处理相机权限
-- ✅ 全屏沉浸式体验
-- ✅ 支持二维码生成和图片识别
-- ✅ **超简洁的 API，业务层只需一行代码**
-- ✅ 单例模式，统一管理
-
-## 快速开始
-
-### 调用方式
-
-```swift
-import CapabilityQRCode
-
-let qrCodeService = QRCodeServiceFactory.getInstance()
-qrCodeService.scanQRCode(viewController: self) { response in
-    if response.success {
-        // 扫码成功
-        let qrCodeContent = response.data
-        print("扫码结果: \(qrCodeContent ?? "")")
-    } else {
-        // 扫码失败或取消
-        let error = response.errorMessage
-        print("扫码失败: \(error ?? "")")
-    }
-}
-```
-
-### 完整示例
-
-```swift
-import UIKit
-import CapabilityQRCode
-
-class ViewController: UIViewController {
-    
-    private let qrCodeService = QRCodeServiceFactory.getInstance()
-    
-    @IBAction func scanButtonTapped(_ sender: UIButton) {
-        qrCodeService.scanQRCode(viewController: self) { response in
-            self.handleScanResult(response)
-        }
-    }
-    
-    private func handleScanResult(_ response: QRCodeResponse) {
-        if response.success {
-            guard let content = response.data else { return }
-            // 处理扫码结果
-            processQRCode(content)
-        } else {
-            // 处理错误
-            showError(response.errorMessage)
-        }
-    }
-    
-    private func processQRCode(_ content: String) {
-        // 业务逻辑处理
-        print("二维码内容: \(content)")
-    }
-    
-    private func showError(_ message: String?) {
-        let alert = UIAlertController(
-            title: "扫码失败",
-            message: message ?? "未知错误",
-            preferredStyle: .alert
-        )
-        alert.addAction(UIAlertAction(title: "确定", style: .default))
-        present(alert, animated: true)
-    }
-}
-```
-
-## API 说明
-
-### QRCodeService 接口
-
-```swift
-public protocol QRCodeService {
-    /// 生成二维码
-    func generateQRCode(content: String, size: CGFloat) -> UIImage?
-    
-    /// 扫描二维码
-    func scanQRCode(viewController: UIViewController, callback: @escaping (QRCodeResponse) -> Void)
-    
-    /// 识别图片中的二维码
-    func recognizeQRCode(image: UIImage, callback: @escaping (QRCodeResponse) -> Void)
-}
-```
-
-### QRCodeResponse 响应模型
-
-```swift
-public struct QRCodeResponse {
-    public let success: Bool          // 是否成功
-    public let data: String?          // 二维码内容
-    public let errorCode: Int?        // 错误码
-    public let errorMessage: String?  // 错误消息
-    public let timestamp: Int64       // 时间戳
-}
-```
-
-## 集成华为 Scan Kit
-
-### 前置条件
-
-1. 在项目中集成华为 Scan Kit Framework
-   - 将 `ScanKitFrameWork.framework` 和 `ScanKitFrameWorkBundle.bundle` 添加到项目
-   - 在 Build Phases > Link Binary With Libraries 中添加框架
-   - 在 Build Settings > Framework Search Paths 中添加框架路径
-
-2. 配置 Info.plist
-   - 添加相机权限说明：`NSCameraUsageDescription`
-
-### 权限配置
-
-在 `Info.plist` 中添加：
-
-```xml
-<key>NSCameraUsageDescription</key>
-<string>需要相机权限来扫描二维码</string>
-```
-
-## 注意事项
-
-1. **华为 Scan Kit Framework**：如果项目中没有集成华为 Scan Kit Framework，代码会自动降级使用系统原生 AVFoundation 实现
-
-2. **权限处理**：扫码功能会自动请求相机权限，如果用户拒绝权限，会返回相应的错误信息
-
-3. **线程安全**：所有回调都在主线程执行，可以直接更新 UI
-
-4. **单例模式**：QRCodeService 是单例，多个界面可以共享同一个服务实例
-
-## 降级方案
-
-如果没有集成华为 Scan Kit Framework，代码会自动使用系统原生 AVFoundation 实现扫码功能，确保功能可用。
-
-## 参考文档
-
-- [华为 Scan Kit iOS 开发指南](https://developer.huawei.com/consumer/cn/doc/development/HMSCore-Guides/ios-scan-kit-introduction-0000001050042021)
-

CapabilitySocketIO/README.md

@@ -1,144 +0,0 @@
-# CapabilitySocketIO
-
-SocketIO 能力层，提供 Socket.IO 实时通信能力。
-
-## 功能特性
-
-- ✅ WebSocket 长连接
-- ✅ 事件订阅和取消订阅
-- ✅ 事件发送
-- ✅ 自动重连（可选）
-- ✅ Token 认证
-- ✅ 单例模式（全局共享连接）
-
-## 依赖
-
-- **BaseCore**: 基础核心模块（日志等）
-- **Socket.IO-Client-Swift**: Socket.IO 客户端库（16.0.0+）
-
-## 使用方式
-
-### 1. 获取服务实例
-
-```swift
-import CapabilitySocketIO
-
-let socketService = SocketIOServiceFactory.getInstance()
-```
-
-### 2. 连接服务器
-
-```swift
-socketService.connect(serverUrl: "http://server:9090", token: "your_jwt_token")
-```
-
-### 3. 订阅事件
-
-```swift
-socketService.on(event: "vehicle_status") { response in
-    print("接收到事件: \(response.event)")
-    print("数据: \(response.data)")
-    print("时间戳: \(response.timestamp)")
-    
-    // 解析 JSON 数据
-    if let jsonData = response.data.data(using: .utf8),
-       let json = try? JSONSerialization.jsonObject(with: jsonData) as? [String: Any] {
-        // 处理数据
-    }
-}
-```
-
-### 4. 发送事件
-
-```swift
-let data: [String: Any] = [
-    "action": "unlock",
-    "vehicleId": "12345"
-]
-
-socketService.emit(event: "vehicle_control", data: data)
-```
-
-### 5. 取消订阅事件
-
-```swift
-socketService.off(event: "vehicle_status")
-```
-
-### 6. 断开连接
-
-```swift
-socketService.disconnect()
-```
-
-### 7. 检查连接状态
-
-```swift
-if socketService.isConnected() {
-    print("已连接")
-} else {
-    print("未连接")
-}
-```
-
-## 完整示例
-
-```swift
-import CapabilitySocketIO
-
-class VehicleController {
-    private let socketService = SocketIOServiceFactory.getInstance()
-    
-    func startMonitoring() {
-        // 连接服务器
-        socketService.connect(serverUrl: "http://api.example.com:9090", token: "your_token")
-        
-        // 订阅车辆状态事件
-        socketService.on(event: "vehicle_status") { [weak self] response in
-            self?.handleVehicleStatus(response)
-        }
-        
-        // 订阅车辆控制事件
-        socketService.on(event: "vehicle_control") { [weak self] response in
-            self?.handleVehicleControl(response)
-        }
-    }
-    
-    func unlockVehicle(vehicleId: String) {
-        let data: [String: Any] = [
-            "action": "unlock",
-            "vehicleId": vehicleId
-        ]
-        socketService.emit(event: "vehicle_control", data: data)
-    }
-    
-    private func handleVehicleStatus(_ response: SocketIOResponse) {
-        // 处理车辆状态更新
-    }
-    
-    private func handleVehicleControl(_ response: SocketIOResponse) {
-        // 处理车辆控制响应
-    }
-    
-    deinit {
-        socketService.off(event: "vehicle_status")
-        socketService.off(event: "vehicle_control")
-    }
-}
-```
-
-## 注意事项
-
-1. **单例模式**: SocketIO 服务是单例，多个界面共享同一个连接
-2. **Token 认证**: 连接时会自动在 HTTP Headers 和查询参数中添加 Token
-3. **自动重连**: 默认禁用自动重连，需要手动处理重连逻辑
-4. **线程安全**: 所有操作都是线程安全的
-5. **事件监听器**: 在连接建立前注册的事件监听器会在连接成功后自动注册
-
-## 架构说明
-
-- **SocketIOService**: 服务接口定义
-- **SocketIOServiceImpl**: 服务实现类（单例）
-- **SocketIOServiceFactory**: 工厂类，提供统一的获取实例方式
-- **SocketIOResponse**: 响应模型
-

SDK打包完整指南.md

@@ -1,307 +0,0 @@
-# iOS SDK 打包完整指南
-
-## ✅ 哪些可以打包为 SDK？
-
-**所有 Swift Package 都可以打包为 SDK！**
-
-从 `Package.swift` 中的 `products` 配置可以看到：
-
-```swift
-products: [
-    .library(
-        name: "BaseCore",        // ✅ 可以打包
-        targets: ["BaseCore"]
-    )
-]
-```
-
-### 可打包的模块
-
-| 模块 | 类型 | 可打包 | 说明 |
-|------|------|--------|------|
-| **BaseCore** | 基础核心层 | ✅ | 基础接口和实现 |
-| **BaseCommon** | 业务封装层 | ✅ | 业务通用功能 |
-| **CapabilityPush** | 能力层 | ✅ | 推送能力 SDK |
-| **CapabilityShare** | 能力层 | ✅ | 分享能力 SDK（待创建） |
-| **CapabilitySocketIO** | 能力层 | ✅ | SocketIO 能力 SDK（待创建） |
-
-## 📦 打包方式
-
-### 方式一：Swift Package Manager（推荐，最简单）
-
-#### 1. 本地打包（用于开发测试）
-
-```bash
-cd /Users/Zhuanz/Documents/code/xindazhou/xdz_ios/BaseCore
-swift build                    # 编译
-swift test                     # 运行测试
-```
-
-#### 2. 发布到 Git（用于分发）
-
-```bash
-cd /Users/Zhuanz/Documents/code/xindazhou/xdz_ios/BaseCore
-
-# 1. 提交代码
-git add .
-git commit -m "Release BaseCore 1.0.0"
-
-# 2. 打标签
-git tag 1.0.0
-git push origin main
-git push origin 1.0.0
-
-# 3. 在其他项目中使用
-# 在 Package.swift 或 Xcode 中添加：
-# .package(url: "https://github.com/your-org/BaseCore.git", from: "1.0.0")
-```
-
-#### 3. 本地路径依赖（用于开发）
-
-```swift
-// 在其他项目的 Package.swift 中
-dependencies: [
-    .package(path: "../BaseCore")  // 本地路径
-]
-```
-
-### 方式二：XCFramework（用于分发二进制 SDK）
-
-#### 1. 使用 xcodebuild 构建
-
-```bash
-cd /Users/Zhuanz/Documents/code/xindazhou/xdz_ios/BaseCore
-
-# 创建临时 Xcode 项目（如果需要）
-# 或者直接使用 Swift Package
-
-# 构建 XCFramework
-xcodebuild archive \
-  -scheme BaseCore \
-  -destination "generic/platform=iOS" \
-  -archivePath "./build/BaseCore-iOS.xcarchive" \
-  SKIP_INSTALL=NO \
-  BUILD_LIBRARY_FOR_DISTRIBUTION=YES
-
-# 创建 XCFramework
-xcodebuild -create-xcframework \
-  -archive "./build/BaseCore-iOS.xcarchive" \
-  -framework "BaseCore.framework" \
-  -output "./build/BaseCore.xcframework"
-```
-
-#### 2. 分发 XCFramework
-
-将生成的 `BaseCore.xcframework` 打包分发：
-
-```bash
-cd build
-zip -r BaseCore.xcframework.zip BaseCore.xcframework
-```
-
-### 方式三：CocoaPods（可选）
-
-如果需要支持 CocoaPods，创建 `.podspec` 文件：
-
-```ruby
-# BaseCore.podspec
-Pod::Spec.new do |s|
-  s.name             = 'BaseCore'
-  s.version          = '1.0.0'
-  s.summary          = '基础核心层 SDK'
-  s.homepage         = 'https://github.com/your-org/BaseCore'
-  s.license          = { :type => 'MIT' }
-  s.author           = { 'Your Name' => 'your@email.com' }
-  s.source           = { :git => 'https://github.com/your-org/BaseCore.git', :tag => s.version }
-  s.ios.deployment_target = '15.0'
-  s.source_files = 'Sources/BaseCore/**/*.swift'
-end
-```
-
-## 🎯 能力层打包示例（CapabilityPush）
-
-### 步骤 1：确保 Package.swift 配置正确
-
-```swift
-// CapabilityPush/Package.swift
-let package = Package(
-    name: "CapabilityPush",
-    products: [
-        .library(
-            name: "CapabilityPush",  // ✅ 定义为 library，可以打包
-            targets: ["CapabilityPush"]
-        )
-    ],
-    dependencies: [
-        .package(path: "../BaseCore")  // 依赖 BaseCore
-    ],
-    // ...
-)
-```
-
-### 步骤 2：本地测试打包
-
-```bash
-cd /Users/Zhuanz/Documents/code/xindazhou/xdz_ios/CapabilityPush
-
-# 编译测试
-swift build
-
-# 运行测试
-swift test
-```
-
-### 步骤 3：发布到 Git
-
-```bash
-cd /Users/Zhuanz/Documents/code/xindazhou/xdz_ios/CapabilityPush
-
-# 1. 初始化 Git（如果还没有）
-git init
-git add .
-git commit -m "Initial commit: CapabilityPush 1.0.0"
-
-# 2. 添加远程仓库
-git remote add origin https://github.com/your-org/CapabilityPush.git
-
-# 3. 打标签并推送
-git tag 1.0.0
-git push origin main
-git push origin 1.0.0
-```
-
-### 步骤 4：在其他项目中使用
-
-```swift
-// 其他项目的 Package.swift
-dependencies: [
-    .package(url: "https://github.com/your-org/CapabilityPush.git", from: "1.0.0"),
-    .package(url: "https://github.com/your-org/BaseCore.git", from: "1.0.0")
-]
-```
-
-## 📋 打包检查清单
-
-### 打包前检查
-
-- [ ] `Package.swift` 中定义了 `.library` product
-- [ ] 版本号已更新
-- [ ] 所有依赖已正确配置
-- [ ] 代码编译通过：`swift build`
-- [ ] 测试通过：`swift test`
-- [ ] README.md 已更新使用说明
-
-### 打包后验证
-
-- [ ] 可以正常导入：`import CapabilityPush`
-- [ ] 所有公开 API 可用
-- [ ] 依赖关系正确（BaseCore 自动传递）
-
-## 🔧 快速打包脚本
-
-创建 `build_sdk.sh`：
-
-```bash
-#!/bin/bash
-# 快速打包 SDK 脚本
-
-PACKAGE_NAME=$1
-VERSION=$2
-
-if [ -z "$PACKAGE_NAME" ] || [ -z "$VERSION" ]; then
-    echo "用法: ./build_sdk.sh <PackageName> <Version>"
-    echo "示例: ./build_sdk.sh CapabilityPush 1.0.0"
-    exit 1
-fi
-
-cd "$PACKAGE_NAME"
-
-echo "=== 打包 $PACKAGE_NAME v$VERSION ==="
-
-# 1. 编译
-echo "1. 编译..."
-swift build
-if [ $? -ne 0 ]; then
-    echo "❌ 编译失败"
-    exit 1
-fi
-
-# 2. 测试
-echo "2. 运行测试..."
-swift test
-if [ $? -ne 0 ]; then
-    echo "❌ 测试失败"
-    exit 1
-fi
-
-# 3. 打标签（如果使用 Git）
-if [ -d ".git" ]; then
-    echo "3. 创建 Git 标签..."
-    git tag "$VERSION"
-    git push origin main
-    git push origin "$VERSION"
-    echo "✅ 标签已创建: $VERSION"
-fi
-
-echo "✅ $PACKAGE_NAME v$VERSION 打包完成！"
-```
-
-使用方法：
-
-```bash
-chmod +x build_sdk.sh
-./build_sdk.sh CapabilityPush 1.0.0
-```
-
-## 📊 各模块打包说明
-
-### BaseCore
-- **类型**：基础核心层
-- **依赖**：无（只依赖系统框架）
-- **打包方式**：Swift Package 或 XCFramework
-- **使用场景**：其他模块的基础依赖
-
-### BaseCommon
-- **类型**：业务封装层
-- **依赖**：BaseCore（传递依赖）
-- **打包方式**：Swift Package 或 XCFramework
-- **使用场景**：业务通用功能
-
-### CapabilityPush
-- **类型**：能力层 SDK
-- **依赖**：BaseCore（传递依赖）
-- **打包方式**：Swift Package 或 XCFramework
-- **使用场景**：独立的推送能力 SDK，可以单独分发
-
-## 🎯 最佳实践
-
-1. **版本管理**：使用语义化版本（Semantic Versioning）
-   - 主版本号：不兼容的 API 修改
-   - 次版本号：向下兼容的功能性新增
-   - 修订号：向下兼容的问题修正
-
-2. **依赖管理**：
-   - 能力层只依赖 BaseCore（不依赖 BaseCommon）
-   - BaseCommon 依赖 BaseCore
-   - 业务项目依赖 BaseCommon 和所需的能力层
-
-3. **文档**：每个 SDK 都应该有：
-   - README.md（使用说明）
-   - API 文档（代码注释）
-   - 示例代码
-
-4. **测试**：确保每个 SDK 都有完整的测试
-
-## 💡 总结
-
-**所有模块都可以打包为 SDK：**
-- ✅ BaseCore - 基础核心 SDK
-- ✅ BaseCommon - 业务封装 SDK
-- ✅ CapabilityPush - 推送能力 SDK
-- ✅ 其他能力层 - 都可以打包
-
-**推荐打包方式：**
-1. **开发阶段**：使用本地路径依赖
-2. **内部使用**：发布到私有 Git 仓库
-3. **对外分发**：使用 XCFramework 或 CocoaPods
-

ScanKitFrameWork.framework/README.md

@@ -1,33 +0,0 @@
-# ScanKit iOS SDK
-
-ScanKit  Huawei code scanning service（Scan Kit）Provide convenient barcode and QR code scanning, parsing, generation capabilities, help you quickly build the scanning function in the application.
-
-Thanks to Huawei's ability to accumulate in the field of computer vision, Scan Kit can realize the detection and automatic amplification of long-distance code or small code. At the same time, it makes targeted identification optimization for common complex code scanning scenes (such as reflection, dark light, stain, blur, cylinder), so as to improve the success rate of code scanning and user experience.
-
-## SDK Access
-
-### Add SDK
-
-1. Open a command line window and 'cd' to the location of the Xcode project.
-2. Create a 'Podfile' file. If it already exists, skip this step.
-```
-cd project-directory 
-pod init
-```
-3. Add the pod of SDK to podfile. The currently supported services are shown in the following table.
-```
-pod 'ScanKitFrameWork', '~> 1.0.1.300'
-```
-|service|collocation method|
-|----|-----|
-|Certification services|pod ‘ScanKitFrameWork’|
-
-4. install pod，Then open it .xcworkspace file add view the project。
-```
-pod install
-```
-
-## LICENSE
-
-see[Huawei License file](./LICENSE)
-

SwiftPackage依赖机制说明.md

@@ -1,227 +0,0 @@
-# Swift Package 依赖机制说明
-
-## 🔍 BaseCommon 如何依赖 BaseCore？
-
-### 关键配置在 `BaseCommon/Package.swift`
-
-```swift
-let package = Package(
-    name: "BaseCommon",
-    // ...
-    dependencies: [
-        .package(path: "../BaseCore")  // 👈 第1步：声明依赖 BaseCore 包
-    ],
-    targets: [
-        .target(
-            name: "BaseCommon",
-            dependencies: [
-                .product(name: "BaseCore", package: "BaseCore")  // 👈 第2步：在 Target 中使用 BaseCore
-            ]
-        )
-    ]
-)
-```
-
-### 两步配置
-
-#### 第1步：在 `dependencies` 中声明包依赖
-```swift
-dependencies: [
-    .package(path: "../BaseCore")  // 告诉 Swift Package Manager：BaseCommon 依赖 BaseCore 这个包
-]
-```
-
-#### 第2步：在 `targets` 中使用这个包
-```swift
-targets: [
-    .target(
-        name: "BaseCommon",
-        dependencies: [
-            .product(name: "BaseCore", package: "BaseCore")  // 告诉编译器：BaseCommon Target 需要使用 BaseCore 这个 product
-        ]
-    )
-]
-```
-
-## 🔗 传递依赖（Transitive Dependencies）机制
-
-### 什么是传递依赖？
-
-当 A 依赖 B，B 依赖 C 时，A 会自动获得对 C 的访问权限，这就是**传递依赖**。
-
-### 实际例子
-
-```
-xdz 项目
-  └── 依赖 BaseCommon
-        └── 依赖 BaseCore  ✅ (传递依赖)
-```
-
-### 工作原理
-
-1. **xdz 项目添加 BaseCommon 依赖**
-   ```swift
-   // 在 Xcode 中添加 BaseCommon 包依赖
-   ```
-
-2. **Swift Package Manager 自动解析依赖树**
-   ```
-   xdz 需要 BaseCommon
-   → 检查 BaseCommon 的 Package.swift
-   → 发现 BaseCommon 依赖 BaseCore
-   → 自动将 BaseCore 也添加到依赖树中
-   ```
-
-3. **结果**
-   - xdz 可以直接使用 BaseCommon
-   - xdz 也可以直接使用 BaseCore（因为传递依赖）
-   - 不需要手动添加 BaseCore
-
-## 📝 代码中的体现
-
-### BaseCommon 中使用 BaseCore
-
-在 `BaseCommon/Sources/BaseCommon/Common/Network/NetworkHelper.swift` 中：
-
-```swift
-import BaseCore  // ✅ 可以导入，因为 Package.swift 中配置了依赖
-
-public class NetworkHelper {
-    // 可以使用 BaseCore 中的类型
-    private let networkManager: NetworkManager  // NetworkManager 来自 BaseCore
-}
-```
-
-### xdz 项目中使用 BaseCommon（自动包含 BaseCore）
-
-在 `xdz/xdz/xdzApp.swift` 中：
-
-```swift
-import BaseCommon  // ✅ 导入 BaseCommon
-
-// 因为传递依赖，BaseCore 也被自动引入了
-// 所以可以直接使用 BaseCore 的类型（如果需要）
-import BaseCore    // ✅ 可选，因为已经通过 BaseCommon 传递了
-```
-
-## 🎯 完整依赖链示例
-
-### 场景：xdz 项目使用 BaseCommon 的 NetworkHelper
-
-```swift
-// xdz/xdz/SomeFile.swift
-import BaseCommon  // 只导入 BaseCommon
-
-func someFunction() {
-    // 使用 BaseCommon 的 NetworkHelper
-    let helper = NetworkHelper.shared  // ✅ 来自 BaseCommon
-    
-    // NetworkHelper 内部使用了 BaseCore 的 NetworkManager
-    // 虽然我们没有直接 import BaseCore，但传递依赖让它可用
-}
-```
-
-### 依赖解析过程
-
-```
-1. xdz 导入 BaseCommon
-   ↓
-2. Swift Package Manager 检查 BaseCommon 的依赖
-   ↓
-3. 发现 BaseCommon 依赖 BaseCore
-   ↓
-4. 自动将 BaseCore 添加到编译依赖中
-   ↓
-5. xdz 可以访问 BaseCommon 和 BaseCore
-```
-
-## 🔧 验证传递依赖
-
-### 方法 1：查看依赖树
-
-在终端运行：
-
-```bash
-cd xdz_ios/xdz
-swift package show-dependencies  # 如果项目支持 SPM
-```
-
-### 方法 2：在 Xcode 中查看
-
-1. 选择项目 `xdz`
-2. 选择 Target `xdz`
-3. 点击 **"Build Phases"** 标签
-4. 展开 **"Link Binary With Libraries"**
-5. 你会看到：
-   - BaseCommon.framework ✅
-   - BaseCore.framework ✅ (自动传递)
-
-### 方法 3：代码验证
-
-在 `xdz/xdz/xdzApp.swift` 中：
-
-```swift
-import SwiftUI
-import BaseCommon  // 只导入 BaseCommon
-
-@main
-struct xdzApp: App {
-    var body: some Scene {
-        WindowGroup {
-            ContentView()
-        }
-    }
-    
-    init() {
-        // 测试：使用 BaseCommon（需要 BaseCore）
-        let helper = NetworkHelper.shared  // ✅ 来自 BaseCommon
-        // NetworkHelper 内部使用了 BaseCore，但不需要直接导入
-    }
-}
-```
-
-如果编译通过，说明传递依赖正常工作！
-
-## 📊 依赖关系图
-
-```
-┌─────────────┐
-│   BaseCore  │  (基础层，不依赖其他)
-└──────┬──────┘
-       │
-       │ 依赖
-       │
-┌──────▼──────────┐
-│   BaseCommon    │  (依赖 BaseCore)
-└──────┬──────────┘
-       │
-       │ 依赖（传递）
-       │
-┌──────▼──────────┐
-│  CapabilityPush │  (依赖 BaseCore)
-└──────┬──────────┘
-       │
-       │ 依赖（传递）
-       │
-┌──────▼──────┐
-│     xdz     │  (业务项目)
-│             │  - 依赖 BaseCommon → 自动获得 BaseCore ✅
-│             │  - 依赖 CapabilityPush → 自动获得 BaseCore ✅
-└─────────────┘
-```
-
-## 💡 关键点总结
-
-1. **Package.swift 中的 `dependencies`**：声明包级别的依赖
-2. **Package.swift 中的 `targets[].dependencies`**：声明 Target 级别的依赖
-3. **传递依赖**：Swift Package Manager 自动处理，无需手动配置
-4. **xdz 项目**：只需要添加 BaseCommon 和 CapabilityPush，BaseCore 会自动传递
-
-## 🎓 类比理解
-
-就像：
-- 你买了一本书（BaseCommon）
-- 这本书引用了另一本书（BaseCore）
-- 当你使用这本书时，你自动获得了引用书的访问权限
-- 不需要单独购买引用书（不需要单独添加 BaseCore）
-

Xcode配置指南-详细步骤.md

@@ -1,173 +0,0 @@
-# Xcode 配置指南 - 详细步骤
-
-## 🎯 目标
-
-在 Xcode 中正确配置 Swift Package 依赖关系，让所有模块都能正常打开和使用。
-
-## 📋 当前问题
-
-1. **BaseCommon 依赖 BaseCore** - Package.swift 已配置，但需要在 Xcode 中添加
-2. **CapabilityPush 依赖 BaseCore** - Package.swift 已配置，但需要在 Xcode 中添加
-3. **xdz 项目依赖所有模块** - 需要在 Xcode 项目中添加
-
-## 🔧 解决方案：在 Xcode 中添加本地包依赖
-
-### 步骤 1：打开 Xcode 项目
-
-```bash
-cd /Users/Zhuanz/Documents/code/xindazhou/xdz_ios/xdz
-open xdz.xcodeproj
-```
-
-### 步骤 2：添加 BaseCommon 依赖
-
-1. 在 Xcode 左侧导航栏，点击最顶部的 **"xdz"** 项目（蓝色图标）
-2. 在中间面板，选择 **"xdz"** Target（不是 Tests）
-3. 点击顶部的 **"General"** 标签
-4. 向下滚动到 **"Frameworks, Libraries, and Embedded Content"** 部分
-5. 点击左下角的 **"+"** 按钮
-6. 在弹出的窗口中，点击左下角的 **"Add Other..."**
-7. 选择 **"Add Package Dependency..."**
-8. 在顶部输入框旁边，点击 **"Add Local..."**
-9. 导航到：`/Users/Zhuanz/Documents/code/xindazhou/xdz_ios/BaseCommon`
-10. 点击 **"Add Package"**
-11. 在 "Add Package" 对话框中，确保 **"BaseCommon"** 被选中
-12. 点击 **"Add Package"**
-
-**重要**：BaseCommon 已经依赖了 BaseCore，所以添加 BaseCommon 后，BaseCore 会自动作为传递依赖被引入，**不需要单独添加 BaseCore**！
-
-### 步骤 3：添加 CapabilityPush 依赖
-
-重复步骤 2，但这次选择 `CapabilityPush` 目录。
-
-**重要**：CapabilityPush 已经依赖了 BaseCore，所以添加 CapabilityPush 后，BaseCore 也会自动作为传递依赖被引入。
-
-### 步骤 4：验证依赖
-
-在 `xdz/xdz/xdzApp.swift` 中添加：
-
-```swift
-import SwiftUI
-import BaseCommon      // 直接导入 BaseCommon（会自动包含 BaseCore）
-import CapabilityPush  // 直接导入 CapabilityPush（会自动包含 BaseCore）
-
-@main
-struct xdzApp: App {
-    var body: some Scene {
-        WindowGroup {
-            ContentView()
-        }
-    }
-}
-```
-
-**注意**：
-- 不需要直接 `import BaseCore`，因为 BaseCommon 和 CapabilityPush 已经包含了
-- 如果确实需要直接使用 BaseCore 的接口，也可以 `import BaseCore`（可选）
-
-如果编译通过，说明依赖配置成功！
-
-## 🔍 验证依赖关系
-
-### 检查 BaseCommon 是否正确依赖 BaseCore
-
-1. 在 Xcode 中，打开 `BaseCommon/Sources/BaseCommon/Common/Network/NetworkHelper.swift`
-2. 查看文件顶部是否有 `import BaseCore`
-3. 如果 Xcode 没有报错，说明依赖正确
-
-### 检查 CapabilityPush 是否正确依赖 BaseCore
-
-1. 在 Xcode 中，打开 `CapabilityPush/Sources/CapabilityPush/Push/Impl/PushServiceImpl.swift`
-2. 查看文件顶部是否有 `import BaseCore`
-3. 如果 Xcode 没有报错，说明依赖正确
-
-## 🐛 常见问题解决
-
-### 问题 1：Xcode 找不到包
-
-**现象**：添加包时，Xcode 提示找不到 Package.swift
-
-**解决方案**：
-1. 确保所有 Package.swift 文件都在正确的目录中：
-   - `BaseCore/Package.swift` ✅
-   - `BaseCommon/Package.swift` ✅
-   - `CapabilityPush/Package.swift` ✅
-
-2. 检查相对路径是否正确：
-   ```swift
-   // BaseCommon/Package.swift
-   .package(path: "../BaseCore")  // ✅ 正确
-   
-   // CapabilityPush/Package.swift
-   .package(path: "../BaseCore")  // ✅ 正确
-   ```
-
-3. 在 Xcode 中：**File → Packages → Reset Package Caches**
-
-### 问题 2：编译错误 "No such module 'BaseCore'"
-
-**现象**：代码中 `import BaseCore` 报错
-
-**解决方案**：
-1. 确保在 Target 的 **"Build Phases"** → **"Link Binary With Libraries"** 中添加了依赖
-2. 清理构建：**Product → Clean Build Folder** (Shift+Cmd+K)
-3. 重新构建：**Product → Build** (Cmd+B)
-4. 如果还不行，删除 DerivedData：
-   ```bash
-   rm -rf ~/Library/Developer/Xcode/DerivedData
-   ```
-
-### 问题 3：Swift Package 在 Xcode 中显示为红色
-
-**现象**：左侧导航栏中，包显示为红色（找不到）
-
-**解决方案**：
-1. 确保包路径正确
-2. 在 Xcode 中：**File → Packages → Resolve Package Versions**
-3. 如果还不行，删除并重新添加包依赖
-
-## 📝 快速验证脚本
-
-运行以下命令检查配置：
-
-```bash
-cd /Users/Zhuanz/Documents/code/xindazhou/xdz_ios
-./check_dependencies.sh
-```
-
-## 🎓 理解依赖关系
-
-```
-xdz (业务项目)
-  ├── 依赖 BaseCommon (业务封装)
-  │       └── 依赖 BaseCore ✅ (传递依赖，自动引入)
-  └── 依赖 CapabilityPush (推送能力)
-          └── 依赖 BaseCore ✅ (传递依赖，自动引入)
-```
-
-**关键点**：
-- **BaseCore** 是基础，不依赖其他模块
-- **BaseCommon** 依赖 BaseCore
-- **CapabilityPush** 依赖 BaseCore
-- **xdz 项目** 只需要依赖 BaseCommon 和 CapabilityPush
-  - BaseCore 会通过传递依赖自动引入，**不需要直接添加**！
-
-**为什么不需要直接依赖 BaseCore？**
-- Swift Package Manager 支持传递依赖
-- 当 xdz 依赖 BaseCommon 时，BaseCommon 的依赖（BaseCore）会自动传递
-- 当 xdz 依赖 CapabilityPush 时，CapabilityPush 的依赖（BaseCore）也会自动传递
-- 这样可以避免重复依赖，保持依赖关系清晰
-
-## 💡 提示
-
-1. **首次添加包依赖后**，Xcode 会自动解析依赖关系
-2. **如果修改了 Package.swift**，Xcode 会自动更新依赖
-3. **建议使用 Workspace**（可选），但直接添加包依赖更简单
-
-## 📚 下一步
-
-配置完成后，你可以：
-1. 在 `xdz` 项目中导入并使用这些模块
-2. 单独打开 `BaseCore`、`BaseCommon`、`CapabilityPush` 进行开发
-3. 单独打包 `CapabilityPush` 为 SDK
-

Xcode配置指南.md

@@ -1,217 +0,0 @@
-# Xcode 配置指南 - Swift Package 依赖
-
-## 📋 问题说明
-
-在 Xcode 中，Swift Package 需要通过以下方式添加依赖：
-1. **BaseCommon 依赖 BaseCore**
-2. **能力层（CapabilityPush）依赖 BaseCore**
-3. **业务项目（xdz）依赖所有模块**
-
-## 🔧 配置步骤
-
-### 方法一：在 Xcode 项目中添加本地包依赖（推荐）
-
-#### 1. 打开 Xcode 项目
-
-```bash
-cd xdz_ios/xdz
-open xdz.xcodeproj
-```
-
-#### 2. 添加 BaseCommon 依赖
-
-1. 在 Xcode 中，选择项目 `xdz`（左侧导航栏最顶部）
-2. 选择 Target `xdz`
-3. 点击 **"General"** 标签
-4. 找到 **"Frameworks, Libraries, and Embedded Content"** 部分
-5. 点击 **"+"** 按钮
-6. 选择 **"Add Other..."** → **"Add Package Dependency..."**
-7. 选择 **"Add Local..."**
-8. 导航到 `../BaseCommon` 目录并选择
-9. 点击 **"Add Package"**
-
-**注意**：BaseCommon 已经依赖了 BaseCore，所以添加 BaseCommon 后会自动传递依赖 BaseCore，不需要单独添加 BaseCore！
-
-#### 3. 添加 CapabilityPush 依赖
-
-重复步骤 2，但这次选择 `../CapabilityPush` 目录。
-
-**注意**：CapabilityPush 已经依赖了 BaseCore，所以添加 CapabilityPush 后也会自动传递依赖 BaseCore。
-
-### 方法二：使用 Package.swift（如果项目支持）
-
-如果你的 `xdz` 项目也使用 Swift Package Manager，可以创建 `Package.swift`：
-
-```swift
-// swift-tools-version: 5.9
-import PackageDescription
-
-let package = Package(
-    name: "xdz",
-    platforms: [
-        .iOS(.v15)
-    ],
-    dependencies: [
-        // 只需要依赖 BaseCommon 和 CapabilityPush
-        // BaseCore 会通过传递依赖自动引入
-        .package(path: "../BaseCommon"),
-        .package(path: "../CapabilityPush")
-    ],
-    targets: [
-        .executableTarget(
-            name: "xdz",
-            dependencies: [
-                // BaseCommon 已经依赖了 BaseCore，所以会自动传递
-                .product(name: "BaseCommon", package: "BaseCommon"),
-                // CapabilityPush 已经依赖了 BaseCore，所以会自动传递
-                .product(name: "CapabilityPush", package: "CapabilityPush")
-            ]
-        )
-    ]
-)
-```
-
-### 方法三：使用 Xcode Workspace（推荐用于多模块项目）
-
-#### 1. 创建 Workspace
-
-```bash
-cd xdz_ios
-xcodebuild -workspace xdz.xcworkspace -list 2>/dev/null || \
-  mkdir -p xdz.xcworkspace/xcshareddata/swiftpm && \
-  cat > xdz.xcworkspace/contents.xcworkspacedata << 'EOF'
-<?xml version="1.0" encoding="UTF-8"?>
-<Workspace
-   version = "1.0">
-   <FileRef
-      location = "self:xdz.xcodeproj">
-   </FileRef>
-   <FileRef
-      location = "self:BaseCore">
-   </FileRef>
-   <FileRef
-      location = "self:BaseCommon">
-   </FileRef>
-   <FileRef
-      location = "self:CapabilityPush">
-   </FileRef>
-</Workspace>
-EOF
-```
-
-#### 2. 打开 Workspace
-
-```bash
-open xdz.xcworkspace
-```
-
-## 📝 验证依赖关系
-
-### 1. 检查 BaseCommon 是否正确依赖 BaseCore
-
-在 `BaseCommon/Sources/BaseCommon/Common/Network/NetworkHelper.swift` 中：
-
-```swift
-import BaseCore  // 应该可以正常导入
-```
-
-### 2. 检查 CapabilityPush 是否正确依赖 BaseCore
-
-在 `CapabilityPush/Sources/CapabilityPush/Push/Impl/PushServiceImpl.swift` 中：
-
-```swift
-import BaseCore  // 应该可以正常导入
-```
-
-### 3. 检查 xdz 项目是否正确依赖所有模块
-
-在 `xdz/xdz/xdzApp.swift` 中：
-
-```swift
-import BaseCommon      // 直接导入 BaseCommon（会自动包含 BaseCore）
-import CapabilityPush  // 直接导入 CapabilityPush（会自动包含 BaseCore）
-
-// 如果需要直接使用 BaseCore 的接口，也可以导入
-import BaseCore        // 可选，因为 BaseCommon 已经包含了
-```
-
-## 🐛 常见问题
-
-### 问题 1：Xcode 找不到包
-
-**解决方案**：
-1. 确保所有 Package.swift 文件都在正确的目录中
-2. 在 Xcode 中：File → Packages → Reset Package Caches
-3. 重新添加包依赖
-
-### 问题 2：依赖关系错误
-
-**解决方案**：
-1. 检查 `Package.swift` 中的路径是否正确（相对路径）
-2. 确保所有包都在同一层级目录中：
-   ```
-   xdz_ios/
-   ├── BaseCore/
-   ├── BaseCommon/
-   ├── CapabilityPush/
-   └── xdz/
-   ```
-
-### 问题 3：编译错误 "No such module 'BaseCore'"
-
-**解决方案**：
-1. 确保在 Target 的 "Build Phases" → "Link Binary With Libraries" 中添加了依赖
-2. 清理构建：Product → Clean Build Folder (Shift+Cmd+K)
-3. 重新构建：Product → Build (Cmd+B)
-
-## 🔍 快速检查脚本
-
-创建一个检查脚本：
-
-```bash
-#!/bin/bash
-# check_dependencies.sh
-
-cd "$(dirname "$0")"
-
-echo "=== 检查 Swift Package 结构 ==="
-echo ""
-
-echo "1. BaseCore Package.swift:"
-if [ -f "BaseCore/Package.swift" ]; then
-    echo "   ✅ 存在"
-    grep -q "name: \"BaseCore\"" BaseCore/Package.swift && echo "   ✅ 名称正确" || echo "   ❌ 名称错误"
-else
-    echo "   ❌ 不存在"
-fi
-
-echo ""
-echo "2. BaseCommon Package.swift:"
-if [ -f "BaseCommon/Package.swift" ]; then
-    echo "   ✅ 存在"
-    grep -q "BaseCore" BaseCommon/Package.swift && echo "   ✅ 依赖 BaseCore" || echo "   ❌ 未依赖 BaseCore"
-else
-    echo "   ❌ 不存在"
-fi
-
-echo ""
-echo "3. CapabilityPush Package.swift:"
-if [ -f "CapabilityPush/Package.swift" ]; then
-    echo "   ✅ 存在"
-    grep -q "BaseCore" CapabilityPush/Package.swift && echo "   ✅ 依赖 BaseCore" || echo "   ❌ 未依赖 BaseCore"
-else
-    echo "   ❌ 不存在"
-fi
-
-echo ""
-echo "=== 检查目录结构 ==="
-ls -d BaseCore BaseCommon CapabilityPush xdz 2>/dev/null | while read dir; do
-    echo "✅ $dir"
-done
-```
-
-## 📚 参考
-
-- [Apple 官方文档：Adding Package Dependencies to Your App](https://developer.apple.com/documentation/xcode/adding-package-dependencies-to-your-app)
-- [Swift Package Manager 文档](https://www.swift.org/package-manager/)
-

iOS能力层打包说明.md

@@ -1,192 +0,0 @@
-# iOS 能力层打包说明
-
-## 📦 架构设计
-
-iOS 的能力层使用 **Swift Package Manager (SPM)** 来管理，每个能力都是一个独立的 Swift Package，可以单独打包为 SDK。
-
-### 目录结构
-
-```
-xdz_ios/
-├── BaseCore/              # 基础核心层（Swift Package）
-├── BaseCommon/            # 业务封装层（Swift Package）
-├── CapabilityPush/        # 推送能力层（独立的 Swift Package）✅
-├── CapabilityShare/       # 分享能力层（独立的 Swift Package）
-├── CapabilitySocketIO/    # SocketIO 能力层（独立的 Swift Package）
-└── xdz/                   # 业务层（Xcode 项目，依赖所有能力层）
-```
-
-## 🔧 创建能力层模块
-
-### 1. 创建目录结构
-
-```bash
-mkdir -p CapabilityPush/Sources/CapabilityPush
-mkdir -p CapabilityPush/Tests/CapabilityPushTests
-```
-
-### 2. 创建 Package.swift
-
-```swift
-// swift-tools-version: 5.9
-import PackageDescription
-
-let package = Package(
-    name: "CapabilityPush",
-    platforms: [
-        .iOS(.v15)
-    ],
-    products: [
-        .library(
-            name: "CapabilityPush",
-            targets: ["CapabilityPush"]
-        )
-    ],
-    dependencies: [
-        // 依赖 BaseCore（本地路径）
-        .package(path: "../BaseCore")
-    ],
-    targets: [
-        .target(
-            name: "CapabilityPush",
-            dependencies: [
-                .product(name: "BaseCore", package: "BaseCore")
-            ]
-        ),
-        .testTarget(
-            name: "CapabilityPushTests",
-            dependencies: ["CapabilityPush"]
-        )
-    ]
-)
-```
-
-### 3. 实现接口
-
-在 `CapabilityPush` 中实现 `BaseCore` 中定义的接口（如 `IPushService`）。
-
-## 📦 单独打包 SDK
-
-### 方式一：Swift Package Manager（推荐）
-
-#### 1. 本地开发
-
-```bash
-cd CapabilityPush
-swift build                    # 编译
-swift test                     # 运行测试
-```
-
-#### 2. 发布到 Git
-
-```bash
-# 打标签
-git tag 1.0.0
-git push origin 1.0.0
-
-# 在其他项目中使用
-dependencies: [
-    .package(url: "https://github.com/your-org/CapabilityPush.git", from: "1.0.0")
-]
-```
-
-#### 3. 本地路径依赖
-
-```swift
-// 在 xdz 项目的 Package.swift 中
-dependencies: [
-    .package(path: "../CapabilityPush"),
-    .package(path: "../BaseCore")
-]
-```
-
-### 方式二：XCFramework（用于分发）
-
-#### 1. 使用 xcodebuild
-
-```bash
-# 构建 XCFramework
-xcodebuild archive \
-  -scheme CapabilityPush \
-  -destination "generic/platform=iOS" \
-  -archivePath "./build/CapabilityPush-iOS.xcarchive" \
-  SKIP_INSTALL=NO \
-  BUILD_LIBRARY_FOR_DISTRIBUTION=YES
-
-# 创建 XCFramework
-xcodebuild -create-xcframework \
-  -archive "./build/CapabilityPush-iOS.xcarchive" \
-  -framework "CapabilityPush.framework" \
-  -output "./build/CapabilityPush.xcframework"
-```
-
-#### 2. 分发 XCFramework
-
-将生成的 `CapabilityPush.xcframework` 打包分发，其他项目可以直接导入使用。
-
-### 方式三：CocoaPods（可选）
-
-如果需要支持 CocoaPods，可以创建 `CapabilityPush.podspec`：
-
-```ruby
-Pod::Spec.new do |s|
-  s.name             = 'CapabilityPush'
-  s.version          = '1.0.0'
-  s.summary          = '推送能力层模块'
-  s.homepage         = 'https://github.com/your-org/CapabilityPush'
-  s.license          = { :type => 'MIT' }
-  s.author           = { 'Your Name' => 'your@email.com' }
-  s.source           = { :git => 'https://github.com/your-org/CapabilityPush.git', :tag => s.version }
-  s.ios.deployment_target = '15.0'
-  s.source_files = 'Sources/CapabilityPush/**/*.swift'
-  s.dependency 'BaseCore'
-end
-```
-
-## 🔗 在业务项目中使用
-
-### 在 Xcode 项目中添加依赖
-
-1. 打开 `xdz.xcodeproj`
-2. File → Add Package Dependencies
-3. 选择 "Add Local..."
-4. 选择 `CapabilityPush` 目录
-5. 完成
-
-### 在代码中使用
-
-```swift
-import CapabilityPush
-import BaseCore
-
-// 使用推送服务
-let pushService = PushServiceFactory.create()
-pushService.initialize(appKey: "your-key", channel: "App Store", debugMode: false)
-```
-
-## 📋 能力层列表
-
-| 能力层 | 说明 | 状态 |
-|--------|------|------|
-| CapabilityPush | 推送能力（JPush） | ✅ 已创建示例 |
-| CapabilityShare | 分享能力（友盟分享） | ⏳ 待创建 |
-| CapabilitySocketIO | SocketIO 能力 | ⏳ 待创建 |
-| CapabilityBLE | 蓝牙能力 | ⏳ 待创建 |
-| CapabilityNFC | NFC 能力 | ⏳ 待创建 |
-| CapabilityQRCode | 二维码能力 | ⏳ 待创建 |
-
-## 🎯 优势
-
-1. **独立打包**：每个能力层都是独立的 Swift Package，可以单独打包和发布
-2. **版本管理**：每个能力层可以独立版本管理
-3. **依赖解耦**：通过接口实现 BaseCore 与能力层的解耦
-4. **灵活集成**：业务项目可以选择性集成需要的能力层
-5. **易于测试**：每个能力层可以独立测试
-
-## 📝 注意事项
-
-1. **依赖顺序**：能力层依赖 BaseCore，业务层依赖能力层
-2. **接口定义**：接口定义在 BaseCore 中，实现类在能力层中
-3. **版本兼容**：确保 BaseCore 版本与能力层版本兼容
-4. **第三方 SDK**：第三方 SDK（如 JPush）在能力层中集成，不暴露给业务层
-

iOS项目结构说明.md

@@ -1,178 +0,0 @@
-# iOS 项目结构说明
-
-## 📁 当前结构
-
-```
-xdz_ios/
-├── BaseCore/              # Swift Package（已创建）
-│   └── Sources/
-├── xdz/                   # Xcode 项目
-│   ├── xdz.xcodeproj
-│   ├── xdz/               # 应用源代码
-│   ├── xdzTests/
-│   └── xdzUITests/
-└── iOS移植方案.md
-```
-
-## ✅ 推荐方案：Swift Package 作为本地包（与项目平级）
-
-这是 **iOS 项目的最佳实践**，原因：
-1. ✅ 模块独立，便于维护
-2. ✅ 可以在多个项目中复用
-3. ✅ 符合 Swift Package Manager 规范
-4. ✅ 与 Android/HarmonyOS 架构保持一致
-
-### 最终目录结构
-
-```
-xdz_ios/
-├── BaseCore/                    # Swift Package
-│   ├── Package.swift
-│   ├── Sources/
-│   │   └── BaseCore/
-│   │       ├── Core/
-│   │       │   ├── Log/
-│   │       │   ├── Storage/
-│   │       │   ├── Network/
-│   │       │   └── ...
-│   │       └── BaseCore.swift
-│   └── Tests/
-│
-├── BaseCommon/                   # Swift Package
-│   ├── Package.swift
-│   ├── Sources/
-│   │   └── BaseCommon/
-│   │       ├── Common/
-│   │       │   ├── Auth/
-│   │       │   ├── Network/
-│   │       │   ├── UI/
-│   │       │   └── ...
-│   │       └── BaseCommon.swift
-│   └── Tests/
-│
-├── CapabilityPush/               # Swift Package
-│   ├── Package.swift
-│   └── Sources/
-│
-├── CapabilityShare/              # Swift Package
-│   ├── Package.swift
-│   └── Sources/
-│
-└── xdz/                          # Xcode 项目（主应用）
-    ├── xdz.xcodeproj
-    ├── xdz/                      # 应用源代码
-    │   ├── xdzApp.swift
-    │   ├── ContentView.swift
-    │   └── ...
-    ├── xdzTests/
-    └── xdzUITests/
-```
-
-## 🔧 在 Xcode 中添加本地 Swift Package
-
-### 方法 1：通过 Xcode UI（推荐）
-
-1. 打开 `xdz/xdz.xcodeproj`
-2. 选择项目 → 选择 Target "xdz" → 切换到 "Package Dependencies" 标签
-3. 点击 "+" 按钮
-4. 选择 "Add Local..." 
-5. 选择 `BaseCore` 目录
-6. 重复步骤添加 `BaseCommon` 和其他模块
-
-### 方法 2：直接编辑 project.pbxproj（不推荐）
-
-Xcode 会自动管理，不需要手动编辑。
-
-## 📝 Package.swift 配置示例
-
-### BaseCore/Package.swift
-
-```swift
-// swift-tools-version: 5.9
-import PackageDescription
-
-let package = Package(
-    name: "BaseCore",
-    platforms: [
-        .iOS(.v15)
-    ],
-    products: [
-        .library(
-            name: "BaseCore",
-            targets: ["BaseCore"]
-        )
-    ],
-    dependencies: [
-        // 基础依赖，尽量使用系统原生
-    ],
-    targets: [
-        .target(
-            name: "BaseCore",
-            dependencies: []
-        ),
-        .testTarget(
-            name: "BaseCoreTests",
-            dependencies: ["BaseCore"]
-        )
-    ]
-)
-```
-
-### BaseCommon/Package.swift
-
-```swift
-// swift-tools-version: 5.9
-import PackageDescription
-
-let package = Package(
-    name: "BaseCommon",
-    platforms: [
-        .iOS(.v15)
-    ],
-    products: [
-        .library(
-            name: "BaseCommon",
-            targets: ["BaseCommon"]
-        )
-    ],
-    dependencies: [
-        .package(path: "../BaseCore")  // 本地路径依赖
-    ],
-    targets: [
-        .target(
-            name: "BaseCommon",
-            dependencies: [
-                .product(name: "BaseCore", package: "BaseCore")
-            ]
-        )
-    ]
-)
-```
-
-### xdz 项目中的 Package.swift（可选）
-
-如果使用 Xcode 项目，不需要 Package.swift，直接在 Xcode 中添加依赖即可。
-
-## ⚠️ 注意事项
-
-1. **路径问题**：使用相对路径 `../BaseCore` 时，确保目录结构正确
-2. **Xcode 版本**：需要 Xcode 11+ 支持本地 Swift Package
-3. **编译顺序**：Xcode 会自动处理依赖关系
-4. **版本控制**：每个 Swift Package 可以独立版本控制
-
-## 🚀 验证步骤
-
-1. 创建 BaseCore/Package.swift
-2. 在 Xcode 中添加 BaseCore 作为本地包依赖
-3. 在 xdz 项目中 `import BaseCore`
-4. 编译运行，确认可以正常使用
-
-## 📚 参考
-
-- [Apple: Adding Package Dependencies to Your App](https://developer.apple.com/documentation/xcode/adding-package-dependencies-to-your-app)
-- [Swift Package Manager: Local Packages](https://www.swift.org/package-manager/)
-
----
-
-**结论**：当前的结构（BaseCore 与 xdz 平级）是**正确的**，符合 iOS 项目最佳实践！
-

依赖配置详解.md

@@ -1,254 +0,0 @@
-# 依赖配置详解 - BaseCommon 如何依赖 BaseCore
-
-## 🔍 关键配置位置
-
-### BaseCommon/Package.swift
-
-```swift
-let package = Package(
-    name: "BaseCommon",
-    // ...
-    dependencies: [
-        .package(path: "../BaseCore")  // 👈 这里声明：BaseCommon 依赖 BaseCore 这个包
-    ],
-    targets: [
-        .target(
-            name: "BaseCommon",
-            dependencies: [
-                .product(name: "BaseCore", package: "BaseCore")  // 👈 这里使用：BaseCommon Target 使用 BaseCore 这个 product
-            ]
-        )
-    ]
-)
-```
-
-## 📝 两步配置详解
-
-### 第1步：声明包依赖（Package Level）
-
-```swift
-dependencies: [
-    .package(path: "../BaseCore")  // 告诉 Swift Package Manager：BaseCommon 这个包依赖 BaseCore 包
-]
-```
-
-**作用**：
-- 告诉 Swift Package Manager：BaseCommon 需要 BaseCore
-- 指定 BaseCore 的位置（相对路径 `../BaseCore`）
-- 这是**包级别**的依赖声明
-
-### 第2步：在 Target 中使用（Target Level）
-
-```swift
-targets: [
-    .target(
-        name: "BaseCommon",
-        dependencies: [
-            .product(name: "BaseCore", package: "BaseCore")  // 告诉编译器：BaseCommon Target 需要使用 BaseCore 这个 product
-        ]
-    )
-]
-```
-
-**作用**：
-- 告诉编译器：BaseCommon Target 的代码可以使用 BaseCore
-- 这样代码中才能 `import BaseCore`
-- 这是**Target 级别**的依赖使用
-
-## 💻 代码中的体现
-
-### BaseCommon 的代码中使用 BaseCore
-
-在 `BaseCommon/Sources/BaseCommon/Common/Network/NetworkHelper.swift` 中：
-
-```swift
-import Foundation
-import BaseCore  // ✅ 可以导入，因为 Package.swift 中配置了依赖
-
-public class NetworkHelper {
-    private let networkManager: NetworkManager  // ✅ NetworkManager 来自 BaseCore
-    
-    public init(networkManager: NetworkManager = NetworkManager.shared) {
-        self.networkManager = networkManager
-    }
-}
-```
-
-**为什么可以 `import BaseCore`？**
-- 因为 `Package.swift` 中配置了依赖
-- Swift Package Manager 会自动处理依赖关系
-
-## 🔗 传递依赖机制
-
-### 什么是传递依赖？
-
-当 A 依赖 B，B 依赖 C 时，A 会自动获得对 C 的访问权限。
-
-### 实际例子
-
-```
-xdz 项目
-  └── 依赖 BaseCommon
-        └── 依赖 BaseCore  ✅ (自动传递)
-```
-
-### 工作原理
-
-1. **xdz 项目添加 BaseCommon 依赖**
-   - 在 Xcode 中添加 `../BaseCommon` 包
-
-2. **Swift Package Manager 自动解析**
-   ```
-   xdz 需要 BaseCommon
-   → 读取 BaseCommon/Package.swift
-   → 发现 dependencies: [.package(path: "../BaseCore")]
-   → 自动将 BaseCore 也添加到依赖树中
-   ```
-
-3. **结果**
-   - xdz 可以直接使用 BaseCommon ✅
-   - xdz 也可以直接使用 BaseCore ✅（传递依赖）
-   - **不需要手动添加 BaseCore**
-
-## 🎯 完整示例
-
-### 场景：xdz 项目使用 BaseCommon
-
-```swift
-// xdz/xdz/xdzApp.swift
-import SwiftUI
-import BaseCommon  // 只导入 BaseCommon
-
-@main
-struct xdzApp: App {
-    var body: some Scene {
-        WindowGroup {
-            ContentView()
-        }
-    }
-    
-    init() {
-        // 使用 BaseCommon 的 NetworkHelper
-        let helper = NetworkHelper.shared  // ✅ 来自 BaseCommon
-        
-        // NetworkHelper 内部使用了 BaseCore 的 NetworkManager
-        // 虽然我们没有直接 import BaseCore，但传递依赖让它可用
-    }
-}
-```
-
-### 依赖解析过程
-
-```
-1. xdz 导入 BaseCommon
-   ↓
-2. Swift Package Manager 检查 BaseCommon/Package.swift
-   ↓
-3. 发现 dependencies: [.package(path: "../BaseCore")]
-   ↓
-4. 自动将 BaseCore 添加到编译依赖中
-   ↓
-5. xdz 可以访问 BaseCommon 和 BaseCore ✅
-```
-
-## 📊 依赖关系图
-
-```
-┌─────────────┐
-│   BaseCore  │  (基础层，不依赖其他)
-│             │
-│ Package.swift: │
-│ dependencies: [] │
-└──────┬──────┘
-       │
-       │ .package(path: "../BaseCore")
-       │
-┌──────▼──────────┐
-│   BaseCommon    │  (业务封装层)
-│                 │
-│ Package.swift:  │
-│ dependencies: [ │
-│   .package(     │
-│     path:       │
-│     "../BaseCore"│
-│   )             │
-│ ]               │
-│                 │
-│ targets: [      │
-│   .target(      │
-│     dependencies:│
-│     [.product(  │
-│       name:     │
-│       "BaseCore"│
-│     )]          │
-│   )             │
-│ ]               │
-└──────┬──────────┘
-       │
-       │ 传递依赖
-       │
-┌──────▼──────┐
-│     xdz     │  (业务项目)
-│             │  - 添加 BaseCommon 依赖
-│             │  - 自动获得 BaseCore ✅
-└─────────────┘
-```
-
-## 🔧 验证方法
-
-### 方法 1：查看 Package.swift
-
-```bash
-cat BaseCommon/Package.swift
-```
-
-你会看到：
-- `dependencies: [.package(path: "../BaseCore")]` ✅
-- `targets[].dependencies: [.product(name: "BaseCore", package: "BaseCore")]` ✅
-
-### 方法 2：查看代码中的使用
-
-```bash
-grep -r "import BaseCore" BaseCommon/Sources/
-```
-
-你会看到多个文件都 `import BaseCore`，说明依赖配置成功。
-
-### 方法 3：在 Xcode 中验证
-
-1. 添加 BaseCommon 依赖后
-2. 在 Xcode 左侧导航栏，展开 "Package Dependencies"
-3. 你会看到：
-   - BaseCommon ✅
-   - BaseCore ✅ (自动传递)
-
-## 💡 总结
-
-**BaseCommon 依赖 BaseCore 的配置：**
-
-1. **Package.swift 的 `dependencies`**：声明包依赖
-   ```swift
-   dependencies: [
-       .package(path: "../BaseCore")
-   ]
-   ```
-
-2. **Package.swift 的 `targets[].dependencies`**：在 Target 中使用
-   ```swift
-   targets: [
-       .target(
-           name: "BaseCommon",
-           dependencies: [
-               .product(name: "BaseCore", package: "BaseCore")
-           ]
-       )
-   ]
-   ```
-
-3. **代码中使用**：`import BaseCore`
-
-**传递依赖机制：**
-- Swift Package Manager 自动处理
-- xdz 添加 BaseCommon 后，BaseCore 自动传递
-- 不需要手动添加 BaseCore
-

各模块打包说明.md

@@ -1,144 +0,0 @@
-# 各模块打包说明
-
-## ✅ 所有模块都可以打包为 SDK
-
-从 `Package.swift` 中的配置可以看到，所有模块都定义了 `.library` product，这意味着它们都可以打包为独立的 SDK。
-
-## 📦 可打包的模块
-
-### 1. BaseCore - 基础核心 SDK
-
-**位置**：`BaseCore/`
-
-**特点**：
-- ✅ 不依赖其他模块（只依赖系统框架）
-- ✅ 可以作为独立 SDK 分发
-- ✅ 其他模块的基础依赖
-
-**打包命令**：
-```bash
-cd BaseCore
-swift build
-swift test
-```
-
-**使用场景**：
-- 作为其他 SDK 的基础依赖
-- 单独提供给需要基础功能的项目
-
-### 2. BaseCommon - 业务封装 SDK
-
-**位置**：`BaseCommon/`
-
-**特点**：
-- ✅ 依赖 BaseCore（传递依赖）
-- ✅ 包含业务通用功能（Auth、Version、Network 等）
-- ✅ 可以作为独立 SDK 分发
-
-**打包命令**：
-```bash
-cd BaseCommon
-swift build
-swift test
-```
-
-**使用场景**：
-- 提供给需要业务通用功能的项目
-- 包含完整的 MVVM 架构支持
-
-### 3. CapabilityPush - 推送能力 SDK
-
-**位置**：`CapabilityPush/`
-
-**特点**：
-- ✅ 依赖 BaseCore（传递依赖）
-- ✅ 独立的推送能力
-- ✅ **最适合单独打包分发**
-
-**打包命令**：
-```bash
-cd CapabilityPush
-swift build
-swift test
-```
-
-**使用场景**：
-- 单独提供给只需要推送功能的项目
-- 可以作为独立的产品 SDK 分发
-
-## 🎯 打包方式对比
-
-| 方式 | 优点 | 缺点 | 适用场景 |
-|------|------|------|----------|
-| **Swift Package** | 简单、自动依赖管理 | 需要 Git 仓库 | 开发、内部使用 |
-| **XCFramework** | 二进制分发、保护源码 | 需要构建脚本 | 对外分发 |
-| **CocoaPods** | 传统 iOS 开发熟悉 | 需要维护 podspec | 兼容旧项目 |
-
-## 📝 快速打包示例
-
-### 打包 CapabilityPush
-
-```bash
-cd /Users/Zhuanz/Documents/code/xindazhou/xdz_ios
-
-# 使用打包脚本
-./build_sdk.sh CapabilityPush 1.0.0
-
-# 或者手动打包
-cd CapabilityPush
-swift build
-swift test
-git tag 1.0.0
-git push origin 1.0.0
-```
-
-### 在其他项目中使用
-
-```swift
-// Package.swift
-dependencies: [
-    .package(url: "https://github.com/your-org/CapabilityPush.git", from: "1.0.0")
-]
-```
-
-## 🔍 验证打包结果
-
-### 方法 1：检查编译
-
-```bash
-cd CapabilityPush
-swift build
-# 如果成功，说明可以打包
-```
-
-### 方法 2：检查 Product 定义
-
-```bash
-grep -A 3 "products:" CapabilityPush/Package.swift
-# 应该看到 .library 定义
-```
-
-### 方法 3：测试导入
-
-在其他项目中：
-```swift
-import CapabilityPush  // 如果编译通过，说明打包成功
-```
-
-## 💡 总结
-
-**所有模块都可以打包为 SDK：**
-- ✅ BaseCore - 基础核心 SDK
-- ✅ BaseCommon - 业务封装 SDK  
-- ✅ CapabilityPush - 推送能力 SDK
-- ✅ 其他能力层 - 都可以打包
-
-**推荐打包顺序：**
-1. 先打包 BaseCore（基础）
-2. 再打包 BaseCommon（业务封装）
-3. 最后打包能力层（CapabilityPush 等）
-
-**打包工具：**
-- 使用 `build_sdk.sh` 脚本快速打包
-- 或手动使用 `swift build` 和 `swift test`
-