引言：HarmonyOS PC生态的崛起与机遇

随着HarmonyOS 5.0的全面发布，PC端应用开发迎来了革命性的变革。根据2025年第四季度数据显示，HarmonyOS PC设备全球出货量突破1500万台，同比增长320%，企业用户占比达到45%。HarmonyOS 5.0为PC应用开发带来的核心优势包括：

1. 分布式软总线技术：设备间延迟低于10ms，数据传输速率高达5Gbps

2. 统一开发框架：一次开发，多端部署，支持手机、平板、PC、智慧屏全场景

3. 安全可信执行环境：硬件级安全加密，TEE安全等级达到EAL5+

4. AI原生支持：集成昇腾AI处理器，支持本地大模型推理

5. 高性能图形渲染：支持8K分辨率显示，144Hz刷新率，专业色彩管理

本文将带领开发者从零开始，构建一个完整的分布式办公套件《HarmonyOffice》。通过这个实战项目，您将掌握HarmonyOS PC应用开发的核心技术，包括分布式架构设计、跨设备数据同步、多窗口管理、系统集成等关键技能。

一、HarmonyOS PC开发环境深度配置

1.1 专业级开发环境搭建

硬件配置要求（专业开发）：

• 处理器：Intel Core i9-14900K或AMD Ryzen 9 7950X

• 内存：64GB DDR5 6000MHz（推荐128GB，大型项目开发）

• 显卡：NVIDIA RTX 4090 24GB或AMD RX 7900 XTX

• 存储：PCIe 5.0 NVMe SSD 2TB，预留200GB开发空间

• 显示器：双4K显示器，支持HDR1000，99% Adobe RGB色域

• 网络：万兆以太网 + Wi-Fi 7，确保分布式调试流畅

软件环境专业配置：

• 操作系统：Windows 11 24H2专业工作站版或macOS Sonoma 14.5

• DevEco Studio 5.2.0专业版（支持分布式调试、性能分析）

• HarmonyOS SDK API Version 11+（PC专属API）

• 数据库工具：HarmonyDB Manager 3.0，支持分布式数据库管理

• 网络分析：Wireshark 4.2，用于分布式通信协议分析

• 性能监控：Harmony Profiler 2.0，实时监控应用性能

1.2 PC专属SDK与工具链配置

// pc-dev-config.json - PC开发环境配置文件
{
  "development_environment": {
    "ide": {
      "name": "DevEco Studio Professional",
      "version": "5.2.0.501",
      "plugins": [
        {
          "name": "distributed_debugger",
          "version": "2.1.0",
          "features": [
            "multi_device_debugging",
            "network_packet_analysis",
            "performance_monitoring",
            "memory_leak_detection"
          ]
        },
        {
          "name": "ui_designer_pro",
          "version": "3.0.0",
          "features": [
            "responsive_design",
            "multi_screen_preview",
            "design_system_management",
            "accessibility_checker"
          ]
        },
        {
          "name": "security_analyzer",
          "version": "1.5.0",
          "features": [
            "code_vulnerability_scan",
            "data_encryption_analysis",
            "permission_audit",
            "compliance_checker"
          ]
        }
      ]
    },
    "sdk_configuration": {
      "pc_sdk": {
        "version": "5.0.2.100",
        "modules": [
          {
            "name": "pc_window_manager",
            "description": "PC多窗口管理模块",
            "api_level": 11,
            "features": [
              "multi_window_support",
              "window_docking",
              "virtual_desktop",
              "snap_layouts"
            ]
          },
          {
            "name": "pc_input_system",
            "description": "PC输入设备管理",
            "api_level": 11,
            "features": [
              "keyboard_shortcuts",
              "mouse_gestures",
              "pen_input",
              "touchpad_gestures"
            ]
          },
          {
            "name": "pc_file_system",
            "description": "PC文件系统增强",
            "api_level": 11,
            "features": [
              "ntfs_integration",
              "cloud_storage_sync",
              "file_versioning",
              "encrypted_vault"
            ]
          },
          {
            "name": "pc_performance",
            "description": "PC性能优化模块",
            "api_level": 11,
            "features": [
              "gpu_acceleration",
              "memory_compression",
              "power_management",
              "thermal_control"
            ]
          }
        ]
      },
      "distributed_sdk": {
        "version": "3.0.1.50",
        "protocols": [
          {
            "name": "harmony_bus_protocol",
            "version": "2.0",
            "capabilities": [
              "low_latency_messaging",
              "high_bandwidth_transfer",
              "secure_tunnel",
              "qos_management"
            ]
          },
          {
            "name": "device_discovery",
            "version": "1.8",
            "capabilities": [
              "bluetooth_mesh",
              "wifi_direct",
              "ultra_wideband",
              "nfc_pairing"
            ]
          }
        ]
      }
    },
    "build_tools": {
      "compiler": "ark_compiler_3.0",
      "optimization_level": "O3",
      "target_architectures": ["x86_64", "arm64"],
      "bundle_optimization": true,
      "code_signing": "harmony_certificate_v2"
    }
  },
  "testing_environment": {
    "emulators": [
      {
        "name": "pc_emulator_pro",
        "specifications": {
          "cpu": "8 cores @ 3.8GHz",
          "memory": "16GB",
          "storage": "256GB SSD",
          "display": "3840x2160 @ 120Hz",
          "graphics": "RTX 3060 equivalent"
        },
        "network_simulation": true,
        "multi_device_simulation": true
      }
    ],
    "physical_devices": [
      {
        "type": "harmony_pc_pro",
        "specifications": "i7-14700H, 32GB, 1TB, RTX 4060",
        "purpose": "performance_testing"
      },
      {
        "type": "harmony_pad_pro",
        "specifications": "Snapdragon 8 Gen 3, 16GB, 512GB",
        "purpose": "cross_device_testing"
      }
    ]
  }
}

1.3 项目架构设计与初始化

在DevEco Studio中创建PC应用项目的专业流程：

1. 选择PC应用模板：

   • Template Category: PC Application

   • Template Type: Distributed Business Suite

   • Target Devices: PC (Primary), Tablet, Phone, Smart Screen

2. 高级项目配置：

   // project-config.json5
   {
     "app": {
       "bundleName": "com.harmonyoffice.suite",
       "vendor": "HarmonyTech",
       "versionCode": 100001,
       "versionName": "1.0.0",
       "minAPIVersion": 11,
       "targetAPIVersion": 11,
       "apiReleaseType": "Release",
       "compileSdkVersion": "5.0.2.100",
       "compileSdkType": "harmonyOS"
     },
     "module": {
       "name": "entry",
       "type": "entry",
       "description": "$string:module_desc",
       "mainElement": "MainAbility",
       "deviceTypes": ["pc", "tablet", "phone", "smartScreen"],
       "distributedNotification": true,
       "keepAlive": true,
       "installationFree": false,
       "virtualMachine": "ark2.0",
       "uiSyntax": "arkTS",
       "pages": "$profile:main_pages",
       "abilities": [
         {
           "name": "MainAbility",
           "srcEntry": "./ets/mainability/MainAbility.ts",
           "description": "$string:MainAbility_desc",
           "icon": "$media:icon",
           "label": "$string:MainAbility_label",
           "startWindowIcon": "$media:icon",
           "startWindowBackground": "$color:start_window_background",
           "visible": true,
           "skills": [
             {
               "actions": ["action.system.home"],
               "entities": ["entity.system.home"]
             }
           ],
           "window": {
             "designWidth": 1920,
             "autoDesignWidth": true,
             "fullScreen": false,
             "layoutInDisplayCutoutMode": "default"
           }
         }
       ]
     },
     "distributedConfig": {
       "multiDeviceCollaboration": true,
       "dataSynchronization": {
         "strategy": "real_time",
         "conflictResolution": "last_write_win",
         "encryption": "aes_256_gcm"
       },
       "deviceDiscovery": {
         "range": "local_network",
         "authentication": "mutual_certificate",
         "privacy": "user_controlled"
       }
     }
   }

3. 专业项目结构设计：

   HarmonyOffice/
   ├── entry/
   │   ├── src/
   │   │   ├── main/
   │   │   │   ├── ets/
   │   │   │   │   ├── MainAbility/
   │   │   │   │   │   ├── MainAbility.ts
   │   │   │   │   │   └── MainAbility.json5
   │   │   │   │   ├── pages/
   │   │   │   │   │   ├── index/
   │   │   │   │   │   │   ├── Index.ets
   │   │   │   │   │   │   └── Index.css
   │   │   │   │   │   └── document/
   │   │   │   │   │       ├── DocumentEditor.ets
   │   │   │   │   │       └── DocumentEditor.css
   │   │   │   │   ├── models/
   │   │   │   │   │   ├── document/
   │   │   │   │   │   │   ├── DocumentModel.ets
   │   │   │   │   │   │   └── DocumentService.ets
   │   │   │   │   │   ├── spreadsheet/
   │   │   │   │   │   │   ├── SpreadsheetModel.ets
   │   │   │   │   │   │   └── SpreadsheetService.ets
   │   │   │   │   │   └── presentation/
   │   │   │   │   │       ├── PresentationModel.ets
   │   │   │   │   │       └── PresentationService.ets
   │   │   │   │   ├── viewmodels/
   │   │   │   │   │   ├── DocumentViewModel.ets
   │   │   │   │   │   ├── SpreadsheetViewModel.ets
   │   │   │   │   │   └── PresentationViewModel.ets
   │   │   │   │   ├── components/
   │   │   │   │   │   ├── common/
   │   │   │   │   │   │   ├── Toolbar.ets
   │   │   │   │   │   │   ├── Sidebar.ets
   │   │   │   │   │   │   └── StatusBar.ets
   │   │   │   │   │   ├── document/
   │   │   │   │   │   │   ├── TextEditor.ets
   │   │   │   │   │   │   ├── FormattingPanel.ets
   │   │   │   │   │   │   └── ReviewPanel.ets
   │   │   │   │   │   └── collaboration/
   │   │   │   │   │       ├── UserPresence.ets
   │   │   │   │   │       ├── CommentThread.ets
   │   │   │   │   │       └── VersionHistory.ets
   │   │   │   │   ├── utils/
   │   │   │   │   │   ├── FileUtils.ets
   │   │   │   │   │   ├── NetworkUtils.ets
   │   │   │   │   │   └── SecurityUtils.ets
   │   │   │   │   └── constants/
   │   │   │   │       ├── AppConstants.ets
   │   │   │   │       └── ErrorCodes.ets
   │   │   │   ├── resources/
   │   │   │   │   ├── base/
   │   │   │   │   │   ├── element/
   │   │   │   │   │   │   ├── string.json
   │   │   │   │   │   │   ├── color.json
   │   │   │   │   │   │   └── float.json
   │   │   │   │   │   ├── media/
   │   │   │   │   │   │   ├── icon.png
   │   │   │   │   │   │   ├── splash.png
   │   │   │   │   │   │   └── icons/
   │   │   │   │   │   └── profile/
   │   │   │   │   │       └── main_pages.json
   │   │   │   │   └── pc/
   │   │   │   │       ├── element/
   │   │   │   │       │   └── string.json
   │   │   │   │       └── media/
   │   │   │   │           └── icons/
   │   │   │   └── module.json5
   │   │   └── test/
   │   │       └── ets/
   │   │           ├── test/
   │   │           │   └── ExampleTest.ets
   │   │           └── TestAbility.ts
   │   └── ohosTest/
   │       └── ets/
   │           └── test/
   │               └── Runner.ets
   ├── features/
   │   ├── document-editor/
   │   │   ├── src/
   │   │   └── package.json
   │   ├── spreadsheet/
   │   │   ├── src/
   │   │   └── package.json
   │   └── presentation/
   │       ├── src/
   │       └── package.json
   ├── shared/
   │   ├── libs/
   │   │   ├── database/
   │   │   ├── network/
   │   │   └── security/
   │   └── styles/
   │       ├── themes/
   │       └── components/
   ├── build-profile.json5
   ├── hvigorfile.ts
   └── package.json

二、分布式架构设计与实现

2.1 分布式数据同步引擎

// shared/libs/database/DistributedDatabase.ets
import { distributedData, data } from '@kit.DistributedDataKit';
import { relationalStore } from '@kit.RelationalStoreKit';
import { security } from '@kit.SecurityKit';

/**
 * 分布式数据库管理器
 * 支持多设备实时数据同步，冲突解决，数据加密
 */
@Observed
class DistributedDatabase {
  private static instance: DistributedDatabase;
  private store: relationalStore.RdbStore | null = null;
  private kvStore: distributedData.KVStore | null = null;
  private syncManager: SyncManager;
  private encryptionEngine: EncryptionEngine;
  
  // 数据库配置
  private readonly DB_CONFIG = {
    name: 'harmonyoffice.db',
    securityLevel: relationalStore.SecurityLevel.S2,
    encrypt: true,
    backup: true,
    version: 1
  };
  
  // 表定义
  private readonly TABLES = {
    DOCUMENTS: {
      name: 'documents',
      columns: {
        id: 'TEXT PRIMARY KEY',
        title: 'TEXT NOT NULL',
        content: 'TEXT',
        created_at: 'INTEGER',
        updated_at: 'INTEGER',
        device_id: 'TEXT',
        version: 'INTEGER DEFAULT 1',
        sync_status: 'INTEGER DEFAULT 0', // 0:未同步, 1:已同步, 2:冲突
        metadata: 'TEXT' // JSON格式的元数据
      }
    },
    COLLABORATORS: {
      name: 'collaborators',
      columns: {
        document_id: 'TEXT',
        user_id: 'TEXT',
        permission: 'INTEGER', // 1:只读, 2:编辑, 3:管理
        joined_at: 'INTEGER',
        last_active: 'INTEGER',
        PRIMARY_KEY: ['document_id', 'user_id']
      }
    },
    CHANGES: {
      name: 'changes',
      columns: {
        id: 'INTEGER PRIMARY KEY AUTOINCREMENT',
        document_id: 'TEXT',
        operation: 'TEXT', // insert, delete, update
        position: 'INTEGER',
        content: 'TEXT',
        author: 'TEXT',
        timestamp: 'INTEGER',
        applied: 'INTEGER DEFAULT 0'
      }
    }
  };
  
  static getInstance(): DistributedDatabase {
    if (!DistributedDatabase.instance) {
      DistributedDatabase.instance = new DistributedDatabase();
    }
    return DistributedDatabase.instance;
  }
  
  // 初始化数据库
  async initialize(): Promise<void> {
    try {
      // 1. 初始化关系型数据库
      await this.initRdbStore();
      
      // 2. 初始化分布式KV存储
      await this.initKVStore();
      
      // 3. 初始化同步管理器
      this.syncManager = new SyncManager(this.store, this.kvStore);
      await this.syncManager.initialize();
      
      // 4. 初始化加密引擎
      this.encryptionEngine = new EncryptionEngine();
      await this.encryptionEngine.initialize();
      
      // 5. 创建表
      await this.createTables();
      
      // 6. 启动同步服务
      await this.startSyncService();
      
      console.info('分布式数据库初始化完成');
    } catch (error) {
      console.error('分布式数据库初始化失败:', error);
      throw error;
    }
  }
  
  // 初始化关系型数据库
  private async initRdbStore(): Promise<void> {
    const config: relationalStore.StoreConfig = {
      name: this.DB_CONFIG.name,
      securityLevel: this.DB_CONFIG.securityLevel
    };
    
    this.store = await relationalStore.getRdbStore(globalThis.context, config);
    
    // 设置数据库加密
    if (this.DB_CONFIG.encrypt) {
      const key = await this.generateDatabaseKey();
      await this.store.setEncryptKey(key);
    }
  }
  
  // 初始化分布式KV存储
  private async initKVStore(): Promise<void> {
    const options: distributedData.KVManager.KVStoreOptions = {
      createIfMissing: true,
      encrypt: true,
      backup: false,
      autoSync: true,
      kvStoreType: distributedData.KVStoreType.SINGLE_VERSION,
      securityLevel: distributedData.SecurityLevel.S2
    };
    
    const kvManager = distributedData.createKVManager({
      context: globalThis.context,
      bundleName: 'com.harmonyoffice.suite'
    });
    
    this.kvStore = await kvManager.getKVStore('office_data', options);
  }
  
  // 生成数据库加密密钥
  private async generateDatabaseKey(): Promise<Uint8Array> {
    const keyAlias = 'harmonyoffice_db_key';
    
    // 检查是否已存在密钥
    try {
      const existingKey = await security.cryptoFramework.getKey(keyAlias);
      return existingKey;
    } catch {
      // 生成新密钥
      const symKeyGenerator = security.cryptoFramework.createSymKeyGenerator('AES256');
      const key = await symKeyGenerator.generateSymKey();
      
      // 保存密钥
      await security.cryptoFramework.saveKey(key, keyAlias);
      return key;
    }
  }
  
  // 创建表
  private async createTables(): Promise<void> {
    if (!this.store) return;
    
    // 创建文档表
    await this.store.executeSql(`
      CREATE TABLE IF NOT EXISTS ${this.TABLES.DOCUMENTS.name} (
        ${Object.entries(this.TABLES.DOCUMENTS.columns)
          .map(([col, def]) => `${col} ${def}`)
          .join(', ')}
      )
    `);
    
    // 创建协作者表
    await this.store.executeSql(`
      CREATE TABLE IF NOT EXISTS ${this.TABLES.COLLABORATORS.name} (
        ${Object.entries(this.TABLES.COLLABORATORS.columns)
          .filter(([col]) => col !== 'PRIMARY_KEY')
          .map(([col, def]) => `${col} ${def}`)
          .join(', ')},
        ${this.TABLES.COLLABORATORS.columns.PRIMARY_KEY 
          ? `PRIMARY KEY (${this.TABLES.COLLABORATORS.columns.PRIMARY_KEY.join(', ')})`
          : ''}
      )
    `);
    
    // 创建变更表
    await this.store.executeSql(`
      CREATE TABLE IF NOT EXISTS ${this.TABLES.CHANGES.name} (
        ${Object.entries(this.TABLES.CHANGES.columns)
          .map(([col, def]) => `${col} ${def}`)
          .join(', ')}
      )
    `);
    
    // 创建索引
    await this.createIndexes();
  }
  
  // 创建索引
  private async createIndexes(): Promise<void> {
    if (!this.store) return;
    
    // 文档表的索引
    await this.store.executeSql(`
      CREATE INDEX IF NOT EXISTS idx_documents_updated 
      ON documents(updated_at DESC)
    `);
    
    await this.store.executeSql(`
      CREATE INDEX IF NOT EXISTS idx_documents_sync 
      ON documents(sync_status, device_id)
    `);
    
    // 协作者表的索引
    await this.store.executeSql(`
      CREATE INDEX IF NOT EXISTS idx_collaborators_document 
      ON collaborators(document_id)
    `);
    
    await this.store.executeSql(`
      CREATE INDEX IF NOT EXISTS idx_collaborators_user 
      ON collaborators(user_id)
    `);
    
    // 变更表的索引
    await this.store.executeSql(`
      CREATE INDEX IF NOT EXISTS idx_changes_document 
      ON changes(document_id, timestamp)
    `);
  }
  
  // 启动同步服务
  private async startSyncService(): Promise<void> {
    // 注册设备状态监听
    distributedData.registerDeviceStatusListener({
      onDeviceOnline: (deviceInfo) => {
        console.info(`设备上线: ${deviceInfo.deviceId}`);
        this.syncManager.syncWithDevice(deviceInfo.deviceId);
      },
      onDeviceOffline: (deviceInfo) => {
        console.info(`设备离线: ${deviceInfo.deviceId}`);
      },
      onDeviceChanged: (deviceInfo) => {
        console.info(`设备状态变化: ${deviceInfo.deviceId}`);
      }
    });
    
    // 启动定期同步
    setInterval(() => {
      this.syncManager.syncAll();
    }, 30000); // 每30秒同步一次
    
    // 启动冲突检测
    setInterval(() => {
      this.detectAndResolveConflicts();
    }, 60000); // 每60秒检测一次冲突
  }
  
  // 文档操作接口
  async createDocument(title: string, content: string = ''): Promise<Document> {
    if (!this.store) throw new Error('数据库未初始化');
    
    const documentId = this.generateDocumentId();
    const now = Date.now();
    const deviceId = await this.getDeviceId();
    
    const document: Document = {
      id: documentId,
      title,
      content,
      created_at: now,
      updated_at: now,
      device_id: deviceId,
      version: 1,
      sync_status: 0,
      metadata: JSON.stringify({
        format: 'markdown',
        language: 'zh-CN',
        word_count: content.length,
        read_time: Math.ceil(content.length / 1000) // 阅读时间（分钟）
      })
    };
    
    // 插入数据库
    const valueBucket: relationalStore.ValuesBucket = {
      id: document.id,
      title: document.title,
      content: await this.encryptionEngine.encrypt(document.content),
      created_at: document.created_at,
      updated_at: document.updated_at,
      device_id: document.device_id,
      version: document.version,
      sync_status: document.sync_status,
      metadata: document.metadata
    };
    
    await this.store.insert(this.TABLES.DOCUMENTS.name, valueBucket);
    
    // 添加到同步队列
    await this.syncManager.addToSyncQueue(documentId, 'create');
    
    return document;
  }
  
  async updateDocument(documentId: string, updates: Partial<Document>): Promise<void> {
    if (!this.store) throw new Error('数据库未初始化');
    
    const now = Date.now();
    const deviceId = await this.getDeviceId();
    
    // 获取当前文档
    const predicates = new relationalStore.RdbPredicates(this.TABLES.DOCUMENTS.name);
    predicates.equalTo('id', documentId);
    
    const resultSet = await this.store.query(predicates, ['version', 'content']);
    const row = await resultSet.goToFirstRow();
    
    if (!row) throw new Error('文档不存在');
    
    const currentVersion = row.getLong(resultSet.getColumnIndex('version'));
    const newVersion = currentVersion + 1;
    
    // 构建更新数据
    const valueBucket: relationalStore.ValuesBucket = {
      updated_at: now,
      device_id: deviceId,
      version: newVersion,
      sync_status: 0
    };
    
    if (updates.title !== undefined) {
      valueBucket.title = updates.title;
    }
    
    if (updates.content !== undefined) {
      // 记录变更
      await this.recordChange(documentId, 'update', {
        position: 0,
        content: updates.content,
        author: await this.getCurrentUserId(),
        timestamp: now
      });
      
      valueBucket.content = await this.encryptionEngine.encrypt(updates.content);
    }
    
    if (updates.metadata !== undefined) {
      valueBucket.metadata = updates.metadata;
    }
    
    // 更新数据库
    await this.store.update(valueBucket, predicates);
    
    // 添加到同步队列
    await this.syncManager.addToSyncQueue(documentId, 'update');
  }
  
  async getDocument(documentId: string): Promise<Document | null> {
    if (!this.store) throw new Error('数据库未初始化');
    
    const predicates = new relationalStore.RdbPredicates(this.TABLES.DOCUMENTS.name);
    predicates.equalTo('id', documentId);
    
    const columns = [
      'id', 'title', 'content', 'created_at', 'updated_at',
      'device_id', 'version', 'sync_status', 'metadata'
    ];
    
    const resultSet = await this.store.query(predicates, columns);
    
    if (await resultSet.goToFirstRow()) {
      const document: Document = {
        id: resultSet.getString(resultSet.getColumnIndex('id')),
        title: resultSet.getString(resultSet.getColumnIndex('title')),
        content: await this.encryptionEngine.decrypt(
          resultSet.getString(resultSet.getColumnIndex('content'))
        ),
        created_at: resultSet.getLong(resultSet.getColumnIndex('created_at')),
        updated_at: resultSet.getLong(resultSet.getColumnIndex('updated_at')),
        device_id: resultSet.getString(resultSet.getColumnIndex('device_id')),
        version: resultSet.getLong(resultSet.getColumnIndex('version')),
        sync_status: resultSet.getLong(resultSet.getColumnIndex('sync_status')),
        metadata: resultSet.getString(resultSet.getColumnIndex('metadata'))
      };
      
      return document;
    }
    
    return null;
  }
  
  async listDocuments(options: ListOptions = {}): Promise<Document[]> {
    if (!this.store) throw new Error('数据库未初始化');
    
    const predicates = new relationalStore.RdbPredicates(this.TABLES.DOCUMENTS.name);
    
    // 应用过滤条件
    if (options.search) {
      predicates.contains('title', options.search);
    }
    
    if (options.syncStatus !== undefined) {
      predicates.equalTo('sync_status', options.syncStatus);
    }
    
    // 应用排序
    const orderBy = options.orderBy || 'updated_at';
    const order = options.order || 'DESC';
    predicates.orderByAsc(orderBy);
    if (order === 'DESC') {
      predicates.orderByDesc(orderBy);
    }
    
    // 应用分页
    if (options.limit) {
      predicates.limit(options.limit);
      if (options.offset) {
        predicates.offset(options.offset);
      }
    }
    
    const columns = [
      'id', 'title', 'content', 'created_at', 'updated_at',
      'device_id', 'version', 'sync_status', 'metadata'
    ];
    
    const resultSet = await this.store.query(predicates, columns);
    const documents: Document[] = [];
    
    while (await resultSet.goToNextRow()) {
      const document: Document = {
        id: resultSet.getString(resultSet.getColumnIndex('id')),
        title: resultSet.getString(resultSet.getColumnIndex('title')),
        content: await this.encryptionEngine.decrypt(
          resultSet.getString(resultSet.getColumnIndex('content'))
        ),
        created_at: resultSet.getLong(resultSet.getColumnIndex('created_at')),
        updated_at: resultSet.getLong(resultSet.getColumnIndex('updated_at')),
        device_id: resultSet.getString(resultSet.getColumnIndex('device_id')),
        version: resultSet.getLong(resultSet.getColumnIndex('version')),
        sync_status: resultSet.getLong(resultSet.getColumnIndex('sync_status')),
        metadata: resultSet.getString(resultSet.getColumnIndex('metadata'))
      };
      
      documents.push(document);
    }
    
    return documents;
  }
  
  // 协作功能
  async addCollaborator(documentId: string, userId: string, permission: Permission): Promise<void> {
    if (!this.store) throw new Error('数据库未初始化');
    
    const now = Date.now();
    
    const valueBucket: relationalStore.ValuesBucket = {
      document_id: documentId,
      user_id: userId,
      permission,
      joined_at: now,
      last_active: now
    };
    
    await this.store.insert(this.TABLES.COLLABORATORS.name, valueBucket);
    
    // 同步协作者信息
    await this.syncManager.syncCollaborators(documentId);
  }
  
  async getCollaborators(documentId: string): Promise<Collaborator[]> {
    if (!this.store) throw new Error('数据库未初始化');
    
    const predicates = new relationalStore.RdbPredicates(this.TABLES.COLLABORATORS.name);
    predicates.equalTo('document_id', documentId);
    
    const columns = ['user_id', 'permission', 'joined_at', 'last_active'];
    const resultSet = await this.store.query(predicates, columns);
    
    const collaborators: Collaborator[] = [];
    
    while (await resultSet.goToNextRow()) {
      collaborators.push({
        user_id: resultSet.getString(resultSet.getColumnIndex('user_id')),
        permission: resultSet.getLong(resultSet.getColumnIndex('permission')),
        joined_at: resultSet.getLong(resultSet.getColumnIndex('joined_at')),
        last_active: resultSet.getLong(resultSet.getColumnIndex('last_active'))
      });
    }
    
    return collaborators;
  }
  
  // 变更记录
  private async recordChange(
    documentId: string,
    operation: string,
    change: Change
  ): Promise<void> {
    if (!this.store) return;
    
    const valueBucket: relationalStore.ValuesBucket = {
      document_id: documentId,
      operation,
      position: change.position,
      content: await this.encryptionEngine.encrypt(change.content),
      author: change.author,
      timestamp: change.timestamp
    };
    
    await this.store.insert(this.TABLES.CHANGES.name, valueBucket);
  }
  
  async getDocumentChanges(documentId: string, limit: number = 100): Promise<Change[]> {
    if (!this.store) throw new Error('数据库未初始化');
    
    const predicates = new relationalStore.RdbPredicates(this.TABLES.CHANGES.name);
    predicates.equalTo('document_id', documentId);
    predicates.orderByDesc('timestamp');
    predicates.limit(limit);
    
    const columns = ['id', 'operation', 'position', 'content', 'author', 'timestamp'];
    const resultSet = await this.store.query(predicates, columns);
    
    const changes: Change[] = [];
    
    while (await resultSet.goToNextRow()) {
      changes.push({
        id: resultSet.getLong(resultSet.getColumnIndex('id')),
        operation: resultSet.getString(resultSet.getColumnIndex('operation')),
        position: resultSet.getLong(resultSet.getColumnIndex('position')),
        content: await this.encryptionEngine.decrypt(
          resultSet.getString(resultSet.getColumnIndex('content'))
        ),
        author: resultSet.getString(resultSet.getColumnIndex('author')),
        timestamp: resultSet.getLong(resultSet.getColumnIndex('timestamp'))
      });
    }
    
    return changes;
  }
  
  // 冲突检测与解决
  private async detectAndResolveConflicts(): Promise<void> {
    if (!this.store) return;
    
    // 查找有冲突的文档
    const predicates = new relationalStore.RdbPredicates(this.TABLES.DOCUMENTS.name);
    predicates.equalTo('sync_status', 2); // 冲突状态
    
    const resultSet = await this.store.query(predicates, ['id', 'version', 'device_id']);
    const conflicts: Conflict[] = [];
    
    while (await resultSet.goToNextRow()) {
      conflicts.push({
        documentId: resultSet.getString(resultSet.getColumnIndex('id')),
        version: resultSet.getLong(resultSet.getColumnIndex('version')),
        deviceId: resultSet.getString(resultSet.getColumnIndex('device_id'))
      });
    }
    
    // 解决每个冲突
    for (const conflict of conflicts) {
      await this.resolveConflict(conflict);
    }
  }
  
  private async resolveConflict(conflict: Conflict): Promise<void> {
    // 获取冲突文档的所有版本
    const versions = await this.getDocumentVersions(conflict.documentId);
    
    if (versions.length === 0) return;
    
    // 使用最后写入胜出策略
    const latestVersion = versions.reduce((latest, current) => {
      return current.timestamp > latest.timestamp ? current : latest;
    });
    
    // 更新为最新版本
    await this.updateDocumentFromVersion(conflict.documentId, latestVersion);
    
    // 标记为已解决
    await this.markConflictResolved(conflict.documentId);
  }
  
  // 工具方法
  private generateDocumentId(): string {
    return `doc_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
  }
  
  private async getDeviceId(): Promise<string> {
    const deviceInfo = await deviceInfo.getDeviceInfo();
    return deviceInfo.deviceId;
  }
  
  private async getCurrentUserId(): Promise<string> {
    // 从用户系统获取当前用户ID
    const accountManager = account.createAccountManager();
    const accounts = await accountManager.getAllAccounts();
    return accounts.length > 0 ? accounts[0].id : 'anonymous';
  }
  
  // 关闭数据库
  async close(): Promise<void> {
    if (this.store) {
      await this.store.close();
      this.store = null;
    }
    
    if (this.kvStore) {
      const kvManager = distributedData.createKVManager({
        context: globalThis.context,
        bundleName: 'com.harmonyoffice.suite'
      });
      await kvManager.closeKVStore('office_data');
      this.kvStore = null;
    }
    
    console.info('分布式数据库已关闭');
  }
}

// 同步管理器
class SyncManager {
  constructor(
    private rdbStore: relationalStore.RdbStore | null,
    private kvStore: distributedData.KVStore | null
  ) {}
  
  async initialize(): Promise<void> {
    // 初始化同步队列
    await this.initSyncQueue();
    
    // 启动同步工作线程
    this.startSyncWorker();
  }
  
  async syncWithDevice(deviceId: string): Promise<void> {
    // 同步未同步的文档
    const unsyncedDocs = await this.getUnsyncedDocuments();
    
    for (const doc of unsyncedDocs) {
      await this.syncDocument(doc.id, deviceId);
    }
    
    // 同步协作者信息
    await this.syncAllCollaborators(deviceId);
  }
  
  async syncAll(): Promise<void> {
    // 获取所有在线设备
    const onlineDevices = await this.getOnlineDevices();
    
    for (const device of onlineDevices) {
      await this.syncWithDevice(device.deviceId);
    }
  }
  
  private async syncDocument(documentId: string, targetDeviceId: string): Promise<void> {
    if (!this.rdbStore || !this.kvStore) return;
    
    // 获取文档数据
    const document = await this.getDocumentFromRdb(documentId);
    if (!document) return;
    
    // 序列化文档数据
    const serializedDoc = JSON.stringify(document);
    
    // 通过分布式KV存储同步
    await this.kvStore.put({
      key: `doc:${documentId}`,
      value: { data: serializedDoc }
    });
    
    // 标记为已同步
    await this.markDocumentSynced(documentId, targetDeviceId);
  }
  
  private async getUnsyncedDocuments(): Promise<Document[]> {
    if (!this.rdbStore) return [];
    
    const predicates = new relationalStore.RdbPredicates('documents');
    predicates.equalTo('sync_status', 0); // 未同步
    
    const resultSet = await this.rdbStore.query(predicates, ['id', 'title']);
    const documents: Document[] = [];
    
    while (await resultSet.goToNextRow()) {
      documents.push({
        id: resultSet.getString(resultSet.getColumnIndex('id')),
        title: resultSet.getString(resultSet.getColumnIndex('title'))
      } as Document);
    }
    
    return documents;
  }
}

// 加密引擎
class EncryptionEngine {
  private symKeyGenerator: security.cryptoFramework.SymKeyGenerator;
  private cipher: security.cryptoFramework.Cipher;
  
  async initialize(): Promise<void> {
    this.symKeyGenerator = security.cryptoFramework.createSymKeyGenerator('AES256');
    this.cipher = security.cryptoFramework.createCipher('AES256|GCM|PKCS7');
  }
  
  async encrypt(plaintext: string): Promise<string> {
    if (!plaintext) return '';
    
    const key = await this.getEncryptionKey();
    await this.cipher.init(security.cryptoFramework.CryptoMode.ENCRYPT_MODE, key, null);
    
    const input: security.cryptoFramework.DataBlob = {
      data: new Uint8Array(new TextEncoder().encode(plaintext))
    };
    
    const encrypted = await this.cipher.doFinal(input);
    return this.arrayBufferToBase64(encrypted.data);
  }
  
  async decrypt(ciphertext: string): Promise<string> {
    if (!ciphertext) return '';
    
    const key = await this.getEncryptionKey();
    await this.cipher.init(security.cryptoFramework.CryptoMode.DECRYPT_MODE, key, null);
    
    const input: security.cryptoFramework.DataBlob = {
      data: this.base64ToArrayBuffer(ciphertext)
    };
    
    const decrypted = await this.cipher.doFinal(input);
    return new TextDecoder().decode(decrypted.data);
  }
  
  private async getEncryptionKey(): Promise<security.cryptoFramework.SymKey> {
    const keyAlias = 'harmonyoffice_data_key';
    
    try {
      return await security.cryptoFramework.getKey(keyAlias);
    } catch {
      const key = await this.symKeyGenerator.generateSymKey();
      await security.cryptoFramework.saveKey(key, keyAlias);
      return key;
    }
  }
  
  private arrayBufferToBase64(buffer: ArrayBuffer): string {
    const bytes = new Uint8Array(buffer);
    let binary = '';
    for (let i = 0; i < bytes.byteLength; i++) {
      binary += String.fromCharCode(bytes[i]);
    }
    return btoa(binary);
  }
  
  private base64ToArrayBuffer(base64: string): ArrayBuffer {
    const binary = atob(base64);
    const bytes = new Uint8Array(binary.length);
    for (let i = 0; i < binary.length; i++) {
      bytes[i] = binary.charCodeAt(i);
    }
    return bytes.buffer;
  }
}

// 类型定义
interface Document {
  id: string;
  title: string;
  content: string;
  created_at: number;
  updated_at: number;
  device_id: string;
  version: number;
  sync_status: number;
  metadata: string;
}

interface Collaborator {
  user_id: string;
  permission: number;
  joined_at: number;
  last_active: number;
}

interface Change {
  id?: number;
  operation: string;
  position: number;
  content: string;
  author: string;
  timestamp: number;
}

interface Conflict {
  documentId: string;
  version: number;
  deviceId: string;
}

interface ListOptions {
  search?: string;
  syncStatus?: number;
  orderBy?: string;
  order?: 'ASC' | 'DESC';
  limit?: number;
  offset?: number;
}

type Permission = 1 | 2 | 3; // 1:只读, 2:编辑, 3:管理