保存

src/apps/index.ts

@@ -16,6 +16,7 @@ export function registerBuiltInApps() {
       icon: '🧮',
       permissions: ['storage'],
       window: {
+        title: '计算器',
         width: 400,
         height: 600,
         minWidth: 320,
@@ -46,6 +47,7 @@ export function registerBuiltInApps() {
       icon: '📝',
       permissions: ['storage', 'notification'],
       window: {
+        title: '记事本',
         width: 800,
         height: 600,
         minWidth: 400,
@@ -74,6 +76,7 @@ export function registerBuiltInApps() {
       icon: '✅',
       permissions: ['storage', 'notification'],
       window: {
+        title: '待办事项',
         width: 600,
         height: 700,
         minWidth: 400,

src/apps/types/AppManifest.ts

@@ -1,3 +1,5 @@
+import type { WindowConfig } from '@/services/WindowFormService.ts'
+
 /**
  * 内置应用清单接口
  */
@@ -33,48 +35,7 @@ export interface InternalAppManifest {
   /**
    * 窗体配置信息
    */
-  window: {
+  window: WindowConfig
-    /**
-     * 窗体宽度
-     */
-    width: number
-    /**
-     * 窗体高度
-     */
-    height: number
-    /**
-     * 窗体最小宽度
-     */
-    minWidth?: number
-    /**
-     * 窗体最小高度
-     */
-    minHeight?: number
-    /**
-     * 窗体最大宽度
-     */
-    maxWidth?: number
-    /**
-     * 窗体最大高度
-     */
-    maxHeight?: number
-    /**
-     * 是否可调整大小
-     */
-    resizable?: boolean
-    /**
-     * 是否可最小化
-     */
-    minimizable?: boolean
-    /**
-     * 是否可最大化
-     */
-    maximizable?: boolean
-    /**
-     * 是否可关闭
-     */
-    closable?: boolean
-  }
   /**
    * 应用分类
    */

src/events/IEventBuilder.ts

@@ -5,7 +5,7 @@ import type { ResourceType } from '@/services/ResourceService'
 /**
  * 窗体数据更新参数
  */
-export interface WindowFormDataUpdateParams {
+export interface IWindowFormDataUpdateParams {
   /** 窗口id */
   id: string
   /** 窗口状态 */
@@ -25,12 +25,19 @@ export interface WindowFormDataUpdateParams {
  * @interface IEventMap 事件定义 键是事件名称，值是事件处理函数
  */
 export interface IEventMap {
+  /**
+   * 事件处理函数映射
+   */
+  [key: string]: (...args: any[]) => void
+}
+
+export interface ISystemBuiltInEventMap extends IEventMap {
   // 系统就绪事件
   onSystemReady: (data: { timestamp: Date; services: string[] }) => void
 
   // 窗体相关事件
   onWindowStateChanged: (windowId: string, newState: string, oldState: string) => void
-  onWindowFormDataUpdate: (data: WindowFormDataUpdateParams) => void
+  onWindowFormDataUpdate: (data: IWindowFormDataUpdateParams) => void
   onWindowFormResizeStart: (windowId: string) => void
   onWindowFormResizing: (windowId: string, width: number, height: number) => void
   onWindowFormResizeEnd: (windowId: string) => void
@@ -42,11 +49,6 @@ export interface IEventMap {
   // 资源相关事件
   onResourceQuotaExceeded: (appId: string, resourceType: ResourceType) => void
   onPerformanceAlert: (data: { type: 'memory' | 'cpu'; usage: number; limit: number }) => void
-
-  /**
-   * 事件处理函数映射
-   */
-  [key: string]: (...args: any[]) => void
 }
 
 /**

src/services/ApplicationLifecycleManager.ts

@@ -1,9 +1,11 @@
-import { reactive } from 'vue'
+import { reactive, ref } from 'vue'
 import type { ResourceService } from './ResourceService'
 import type { ApplicationSandboxEngine } from './ApplicationSandboxEngine'
 import { v4 as uuidv4 } from 'uuid'
 import { externalAppDiscovery } from './ExternalAppDiscovery'
 import type { WindowFormService } from '@/services/WindowFormService.ts'
+import { type AppRegistration, appRegistry } from '@/apps'
+import windowManager from '@/ui/components/WindowManager.vue'
 
 /**
  * 应用状态枚举
@@ -110,13 +112,20 @@ export interface AppLifecycleEvents {
   onStateChanged: (appId: string, newState: AppLifecycleState, oldState: AppLifecycleState) => void
 }
 
+interface BuiltInWindowForm {
+  id: string
+  appId: string
+  component: any
+  props: Record<string, any>
+}
+
 /**
  * 应用生命周期管理器
  */
 export class ApplicationLifecycleManager {
   private installedApps = reactive(new Map<string, AppInstance>())
   private runningProcesses = reactive(new Map<string, AppInstance>())
-  private appFiles = new Map<string, Map<string, Blob | string>>() // 应用文件存储
+  private builtInWindowForms = reactive(new Map<string, BuiltInWindowForm>())
 
   private windowFormService: WindowFormService
   private resourceService: ResourceService
@@ -132,10 +141,65 @@ export class ApplicationLifecycleManager {
     this.sandboxEngine = sandboxEngine
   }
 
+  public getBuiltInWindowForms() {
+    return this.builtInWindowForms
+  }
+
   /**
    * 启动应用
    */
-  async startApp(appId: string, options: AppStartOptions = {}): Promise<string> {
+  async startApp(appId: string, options: AppStartOptions = {}) {
+    // 检查应用是否是内置应用
+    if (appRegistry.hasApp(appId)) {
+      await this.startBuiltInApp(appId, options)
+    } else {
+      await this.startExternalApp(appId, options)
+    }
+  }
+
+  private async startBuiltInApp(appId: string, options: AppStartOptions = {}) {
+    const appRegistration = appRegistry.getApp(appId)
+    if (!appRegistration) {
+      console.error(`内置应用 ${appId} 不存在`)
+      return
+    }
+
+    // 检查是否已在运行
+    if (this.isAppRunning(appId)) {
+      console.log(`应用 ${appRegistration.manifest.name} 已在运行`)
+      return
+    }
+
+    const windowInstance = await this.windowFormService.createWindow(appId, appRegistration.manifest.window)
+
+    // 处理异步组件加载
+    let component = appRegistration.component
+    if (typeof component === 'function') {
+      try {
+        // 如果是函数，调用它来获取组件
+        component = await component()
+      } catch (error) {
+        console.error(`加载应用组件失败: ${appId}`, error)
+        return
+      }
+    }
+
+    // 添加窗口
+    const windowForm: BuiltInWindowForm = {
+      id: windowInstance.id,
+      appId,
+      component,
+      props: {
+        windowId: windowInstance.id,
+        appId
+      }
+    }
+
+    this.builtInWindowForms.set(windowInstance.id, windowForm)
+    console.log(this.builtInWindowForms)
+  }
+
+  private async startExternalApp(appId: string, options: AppStartOptions = {}) {
     let app = this.installedApps.get(appId)
 
     console.log('-----------------------------')
@@ -344,20 +408,15 @@ export class ApplicationLifecycleManager {
    * 检查应用是否正在运行
    */
   isAppRunning(appId: string): boolean {
-    // 首先从已安装应用中查找
+    let app;
-    let app = this.installedApps.get(appId)
 
-    // 如果未找到，从运行进程列表中查找（可能是外部应用的临时实例）
+    for (const runningApp of this.runningProcesses.values()) {
-    if (!app) {
+      if (runningApp.id === appId) {
-      for (const runningApp of this.runningProcesses.values()) {
+        app = runningApp
-        if (runningApp.id === appId) {
+        break
-          app = runningApp
-          break
-        }
       }
     }
-
+    return app?.state === AppLifecycleState.RUNNING
-    return app?.state === AppLifecycleState.RUNNING || app?.state === AppLifecycleState.SUSPENDED
   }
 
   /**

src/services/IErrorHandler.ts

@@ -1,79 +0,0 @@
-/**
- * 全局错误处理器接口
- * 负责统一处理系统中的所有错误
- */
-export interface IErrorHandler {
-  /**
-   * 处理应用错误
-   * @param error 错误对象
-   * @param context 错误上下文信息
-   * @returns 是否成功处理了错误
-   */
-  handleError(error: Error | any, context?: ErrorContext): boolean
-
-  /**
-   * 处理未捕获的异常
-   */
-  setupGlobalErrorHandlers(): void
-
-  /**
-   * 获取最近的错误记录
-   * @param limit 获取的最大数量
-   */
-  getRecentErrors(limit?: number): ErrorRecord[]
-}
-
-/**
- * 错误上下文信息
- */
-export interface ErrorContext {
-  /**
-   * 错误来源组件或服务名称
-   */
-  source?: string
-  
-  /**
-   * 错误发生的操作
-   */
-  operation?: string
-  
-  /**
-   * 相关的应用ID
-   */
-  appId?: string
-  
-  /**
-   * 其他自定义信息
-   */
-  [key: string]: any
-}
-
-/**
- * 错误记录
- */
-export interface ErrorRecord {
-  /**
-   * 错误ID
-   */
-  id: string
-  
-  /**
-   * 错误对象
-   */
-  error: Error | any
-  
-  /**
-   * 错误上下文
-   */
-  context?: ErrorContext
-  
-  /**
-   * 错误发生时间
-   */
-  timestamp: Date
-  
-  /**
-   * 是否已处理
-   */
-  handled: boolean
-}

src/services/SystemServiceIntegration.ts

@@ -1,6 +1,10 @@
 import { reactive, ref } from 'vue'
 import { EventBuilderImpl } from '@/events/impl/EventBuilderImpl'
-import type { IEventBuilder, IEventMap, WindowFormDataUpdateParams } from '@/events/IEventBuilder'
+import type {
+  IEventBuilder,
+  ISystemBuiltInEventMap,
+  IWindowFormDataUpdateParams
+} from '@/events/IEventBuilder'
 import type { ResourceType } from './ResourceService'
 
 // 导入所有服务
@@ -56,7 +60,7 @@ export class SystemServiceIntegration {
   private startTime: Date
 
   // 核心服务实例
-  private eventBus: IEventBuilder<any>
+  private eventBus: IEventBuilder<ISystemBuiltInEventMap>
   private windowFormService!: WindowFormService
   private resourceService!: ResourceService
   private sandboxEngine!: ApplicationSandboxEngine
@@ -88,7 +92,7 @@ export class SystemServiceIntegration {
     }
 
     this.startTime = new Date()
-    this.eventBus = new EventBuilderImpl<any>()
+    this.eventBus = new EventBuilderImpl<ISystemBuiltInEventMap>()
 
     this.setupGlobalErrorHandling()
   }
@@ -334,7 +338,7 @@ export class SystemServiceIntegration {
     })
 
     // 监听窗体数据更新事件
-    this.eventBus.addEventListener('onWindowFormDataUpdate', (data: WindowFormDataUpdateParams) => {
+    this.eventBus.addEventListener('onWindowFormDataUpdate', (data: IWindowFormDataUpdateParams) => {
       console.log(`[SystemIntegration] 接收到窗体数据更新事件:`, data)
     })
 

src/services/WindowFormService.ts

@@ -18,9 +18,6 @@ export enum WindowState {
   ERROR = 'error'
 }
 
-/**
- * 窗体配置接口
- */
 /**
  * 窗体配置接口
  */
@@ -28,7 +25,7 @@ export interface WindowConfig {
   /**
    * 窗体标题
    */
-  title: string
+  title?: string
   /**
    * 窗体宽度(像素)
    */
@@ -570,7 +567,7 @@ export class WindowFormService {
     // 窗体标题
     const title = document.createElement('span')
     title.className = 'window-title'
-    title.textContent = windowInstance.config.title
+    title.textContent = windowInstance.config.title || ''
     title.style.cssText = `
       font-size: 14px;
       font-weight: 500;

src/services/di/IServiceContainer.ts

@@ -1,41 +0,0 @@
-/**
- * 服务容器接口
- * 负责管理和提供所有系统服务的实例
- */
-export interface IServiceContainer {
-  /**
-   * 注册服务
-   * @param id 服务唯一标识符
-   * @param factory 服务工厂函数
-   * @param dependencies 依赖的服务ID数组
-   */
-  register<T>(id: string, factory: ServiceFactory<T>, dependencies?: string[]): void
-
-  /**
-   * 获取服务实例
-   * @param id 服务唯一标识符
-   * @returns 服务实例
-   * @throws 当服务未注册时抛出错误
-   */
-  getService<T>(id: string): T
-
-  /**
-   * 检查服务是否已注册
-   * @param id 服务唯一标识符
-   * @returns 是否已注册
-   */
-  has(id: string): boolean
-
-  /**
-   * 初始化所有服务
-   * 按照依赖关系顺序初始化服务
-   */
-  initialize(): void
-}
-
-/**
- * 服务工厂函数类型
- * @param container 服务容器实例
- * @returns 服务实例
- */
-export type ServiceFactory<T> = (container: IServiceContainer) => T

src/services/di/ServiceContainerImpl.ts

@@ -1,138 +0,0 @@
-import type { IServiceContainer, ServiceFactory } from './IServiceContainer'
-
-/**
- * 服务注册信息接口
- */
-interface ServiceRegistration<T> {
-  factory: ServiceFactory<T>
-  dependencies: string[]
-  instance: T | null
-  initialized: boolean
-}
-
-/**
- * 服务容器实现
- * 使用工厂模式和依赖注入模式管理服务实例
- */
-export class ServiceContainerImpl implements IServiceContainer {
-  private services = new Map<string, ServiceRegistration<any>>()
-  private initializationStack: string[] = []
-  private initialized = false
-
-  /**
-   * 注册服务
-   * @param id 服务唯一标识符
-   * @param factory 服务工厂函数
-   * @param dependencies 依赖的服务ID数组
-   */
-  public register<T>(id: string, factory: ServiceFactory<T>, dependencies: string[] = []): void {
-    if (this.initialized) {
-      throw new Error(`无法在容器初始化后注册服务: ${id}`)
-    }
-
-    this.services.set(id, {
-      factory,
-      dependencies,
-      instance: null,
-      initialized: false
-    })
-  }
-
-  /**
-   * 获取服务实例
-   * @param id 服务唯一标识符
-   * @returns 服务实例
-   * @throws 当服务未注册或发生循环依赖时抛出错误
-   */
-  public getService<T>(id: string): T {
-    const registration = this.services.get(id)
-
-    if (!registration) {
-      throw new Error(`未注册的服务: ${id}`)
-    }
-
-    // 检测循环依赖
-    if (this.initializationStack.includes(id)) {
-      throw new Error(`检测到循环依赖: ${this.initializationStack.join(' -> ')} -> ${id}`)
-    }
-
-    // 如果服务实例尚未创建，则创建它
-    if (!registration.instance) {
-      this.initializationStack.push(id)
-
-      try {
-        // 首先确保所有依赖都已初始化
-        for (const dependencyId of registration.dependencies) {
-          this.getService(dependencyId)
-        }
-
-        // 创建服务实例
-        registration.instance = registration.factory(this)
-        registration.initialized = true
-      } finally {
-        this.initializationStack.pop()
-      }
-    }
-
-    return registration.instance
-  }
-
-  /**
-   * 检查服务是否已注册
-   * @param id 服务唯一标识符
-   * @returns 是否已注册
-   */
-  public has(id: string): boolean {
-    return this.services.has(id)
-  }
-
-  /**
-   * 初始化所有服务
-   * 按照依赖关系顺序初始化服务
-   */
-  public initialize(): void {
-    if (this.initialized) {
-      return
-    }
-
-    try {
-      // 初始化所有服务（按依赖顺序）
-      this.services.forEach((_, id) => {
-        this.getService(id)
-      })
-
-      this.initialized = true
-    } catch (error) {
-      console.error('服务容器初始化失败:', error)
-      throw error
-    }
-  }
-
-  /**
-   * 获取所有已注册服务的ID列表
-   * @returns 服务ID列表
-   */
-  public getRegisteredServices(): string[] {
-    return Array.from(this.services.keys())
-  }
-
-  /**
-   * 清除服务实例（用于测试）
-   * @param id 服务ID，如果不提供则清除所有服务
-   */
-  public clear(id?: string): void {
-    if (id) {
-      const registration = this.services.get(id)
-      if (registration) {
-        registration.instance = null
-        registration.initialized = false
-      }
-    } else {
-      this.services.forEach((registration) => {
-        registration.instance = null
-        registration.initialized = false
-      })
-      this.initialized = false
-    }
-  }
-}

src/services/di/ServiceProvider.ts

@@ -1,145 +0,0 @@
-import { ServiceRegistry, ServiceIds } from './ServiceRegistry'
-import type { IServiceContainer } from './IServiceContainer'
-import { initializePendingServices } from './decorators'
-
-/**
- * 服务提供者
- * 提供静态方法访问所有系统服务
- */
-export class ServiceProvider {
-  private static container: IServiceContainer | null = null
-  private static initialized = false
-
-  /**
-   * 初始化服务提供者
-   * 注册并初始化所有服务
-   */
-  public static initialize(): void {
-    if (this.initialized) {
-      return
-    }
-
-    const registry = ServiceRegistry.getInstance()
-    registry.registerAllServices()
-
-    this.container = registry.getContainer()
-    this.container.initialize()
-    
-    // 初始化所有使用@Service装饰器的服务
-    initializePendingServices()
-
-    this.initialized = true
-  }
-
-  /**
-   * 获取服务实例
-   * @param id 服务ID
-   * @returns 服务实例
-   */
-  public static getService<T>(id: string): T {
-    if (!this.container) {
-      throw new Error('服务提供者尚未初始化')
-    }
-    return this.container.getService<T>(id)
-  }
-
-  /**
-   * 获取资源服务
-   */
-  public static getResourceService(): any {
-    return this.getService(ServiceIds.RESOURCE_SERVICE)
-  }
-
-  /**
-   * 获取窗口表单服务
-   */
-  public static getWindowFormService(): any {
-    return this.getService(ServiceIds.WINDOW_FORM_SERVICE)
-  }
-
-  /**
-   * 获取沙箱引擎
-   */
-  public static getSandboxEngine(): any {
-    return this.getService(ServiceIds.SANDBOX_ENGINE)
-  }
-
-  /**
-   * 获取生命周期管理器
-   */
-  public static getLifecycleManager(): any {
-    return this.getService(ServiceIds.LIFECYCLE_MANAGER)
-  }
-
-  /**
-   * 获取系统服务
-   */
-  public static getSystemService(): any {
-    return this.getService(ServiceIds.SYSTEM_SERVICE)
-  }
-
-  /**
-   * 获取事件构建器
-   */
-  public static getEventBuilder(): any {
-    return this.getService(ServiceIds.EVENT_BUILDER)
-  }
-
-  /**
-   * 获取外部应用发现服务
-   */
-  public static getExternalAppDiscovery(): any {
-    return this.getService(ServiceIds.EXTERNAL_APP_DISCOVERY)
-  }
-
-  /**
-   * 获取错误处理服务
-   */
-  public static getErrorHandler(): any {
-    return this.getService(ServiceIds.ERROR_HANDLER)
-  }
-
-  /**
-   * 检查是否已初始化
-   */
-  public static isInitialized(): boolean {
-    return this.initialized
-  }
-
-  /**
-   * 获取服务容器（仅用于高级场景）
-   */
-  public static getContainer(): IServiceContainer | null {
-    return this.container
-  }
-}
-
-/**
- * 创建服务工厂函数
- * @param constructor 服务构造函数
- * @param dependencyIds 依赖的服务ID数组
- * @returns 服务工厂函数
- */
-export function createServiceFactory<T>(
-  constructor: new (...args: any[]) => T,
-  dependencyIds: string[] = []
-): (container: IServiceContainer) => T {
-  return (container: IServiceContainer) => {
-    const dependencies = dependencyIds.map((id) => container.getService(id))
-    return new constructor(...dependencies)
-  }
-}
-
-/**
- * 服务装饰器，用于标记需要注入的服务
- */
-export function Inject(serviceId: string): PropertyDecorator {
-  return (target: Object, propertyKey: string | symbol) => {
-    const descriptor = {
-      get: () => {
-        return ServiceProvider.getService(serviceId)
-      }
-    }
-    Object.defineProperty(target, propertyKey, descriptor)
-  }
-}

src/services/di/ServiceRegistry.ts

@@ -1,194 +0,0 @@
-import type { IServiceContainer, ServiceFactory } from './IServiceContainer'
-import { ServiceContainerImpl } from './ServiceContainerImpl'
-
-/**
- * 服务ID常量
- */
-export enum ServiceIds {
-  RESOURCE_SERVICE = 'resourceService',
-  WINDOW_FORM_SERVICE = 'windowFormService',
-  SANDBOX_ENGINE = 'sandboxEngine',
-  LIFECYCLE_MANAGER = 'lifecycleManager',
-  SYSTEM_SERVICE = 'systemService',
-  EVENT_BUILDER = 'eventBuilder',
-  EXTERNAL_APP_DISCOVERY = 'externalAppDiscovery',
-  ERROR_HANDLER = 'errorHandler'
-}
-
-/**
- * 服务注册表
- * 负责注册所有系统服务
- */
-export class ServiceRegistry {
-  private static instance: ServiceRegistry
-  private container: IServiceContainer
-
-  private constructor() {
-    this.container = new ServiceContainerImpl()
-  }
-
-  /**
-   * 获取服务注册表单例
-   */
-  public static getInstance(): ServiceRegistry {
-    if (!ServiceRegistry.instance) {
-      ServiceRegistry.instance = new ServiceRegistry()
-    }
-    return ServiceRegistry.instance
-  }
-
-  /**
-   * 获取服务容器实例
-   */
-  public getContainer(): IServiceContainer {
-    return this.container
-  }
-
-  /**
-   * 注册所有服务
-   * 注意：服务注册顺序应按照依赖关系排列
-   */
-  public registerAllServices(): void {
-    // 注册基本服务 - 这些服务没有其他依赖
-    this.registerEventBuilder()
-    this.registerExternalAppDiscovery()
-    this.registerResourceService()
-    this.registerErrorHandler()
-
-    // 注册核心服务 - 按照依赖关系顺序注册
-    this.registerWindowFormService()
-    this.registerSandboxEngine()
-    this.registerLifecycleManager()
-    this.registerSystemService()
-  }
-
-  /**
-   * 注册事件构建器服务
-   */
-  private registerEventBuilder(): void {
-    this.container.register(ServiceIds.EVENT_BUILDER, async () => {
-      const { EventBuilderImpl } = await import('@/events/impl/EventBuilderImpl')
-      return new EventBuilderImpl()
-    })
-  }
-
-  /**
-   * 注册外部应用发现服务
-   */
-  private registerExternalAppDiscovery(): void {
-    this.container.register(ServiceIds.EXTERNAL_APP_DISCOVERY, async () => {
-      // 延迟导入避免循环依赖
-      const { externalAppDiscovery } = await import('../ExternalAppDiscovery')
-      return externalAppDiscovery
-    })
-  }
-
-  /**
-   * 注册资源服务
-   */
-  private registerResourceService(): void {
-    this.container.register(
-      ServiceIds.RESOURCE_SERVICE,
-      async (container) => {
-        // 延迟导入避免循环依赖
-        const { ResourceService } = await import('../ResourceService')
-        return new ResourceService(container.getService(ServiceIds.EVENT_BUILDER))
-      },
-      [ServiceIds.EVENT_BUILDER]
-    )
-  }
-
-  /**
-   * 注册窗口表单服务
-   */
-  private registerWindowFormService(): void {
-    this.container.register(
-      ServiceIds.WINDOW_FORM_SERVICE,
-      async (container) => {
-        // 延迟导入避免循环依赖
-        const { WindowFormService } = await import('../WindowFormService')
-        return new WindowFormService(container.getService(ServiceIds.EVENT_BUILDER))
-      },
-      [ServiceIds.EVENT_BUILDER]
-    )
-  }
-
-  /**
-   * 注册沙箱引擎服务
-   */
-  private registerSandboxEngine(): void {
-    this.container.register(
-      ServiceIds.SANDBOX_ENGINE,
-      async (container) => {
-        // 延迟导入避免循环依赖
-        const { ApplicationSandboxEngine } = await import('../ApplicationSandboxEngine')
-        return new ApplicationSandboxEngine(
-          container.getService(ServiceIds.RESOURCE_SERVICE),
-          container
-        )
-      },
-      [ServiceIds.RESOURCE_SERVICE]
-    )
-  }
-
-  /**
-   * 注册生命周期管理器服务
-   */
-  private registerLifecycleManager(): void {
-    this.container.register(
-      ServiceIds.LIFECYCLE_MANAGER,
-      async (container) => {
-        // 延迟导入避免循环依赖
-        const { ApplicationLifecycleManager } = await import('../ApplicationLifecycleManager')
-        return new ApplicationLifecycleManager(
-          container.getService(ServiceIds.RESOURCE_SERVICE),
-          container.getService(ServiceIds.SANDBOX_ENGINE),
-          container.getService(ServiceIds.WINDOW_FORM_SERVICE)
-        )
-      },
-      [
-        ServiceIds.RESOURCE_SERVICE,
-        ServiceIds.SANDBOX_ENGINE,
-        ServiceIds.WINDOW_FORM_SERVICE,
-        ServiceIds.EXTERNAL_APP_DISCOVERY
-      ]
-    )
-  }
-
-  /**
-   * 注册系统服务集成服务
-   */
-  private registerSystemService(): void {
-    this.container.register(
-      ServiceIds.SYSTEM_SERVICE,
-      async (container) => {
-        // 延迟导入避免循环依赖
-        const { SystemServiceIntegration } = await import('../SystemServiceIntegration')
-        return new SystemServiceIntegration(container)
-      },
-      [
-        ServiceIds.RESOURCE_SERVICE,
-        ServiceIds.WINDOW_FORM_SERVICE,
-        ServiceIds.SANDBOX_ENGINE,
-        ServiceIds.LIFECYCLE_MANAGER,
-        ServiceIds.EVENT_BUILDER,
-        ServiceIds.ERROR_HANDLER
-      ]
-    )
-  }
-  
-  /**
-   * 注册错误处理服务
-   */
-  private registerErrorHandler(): void {
-    this.container.register(
-      ServiceIds.ERROR_HANDLER,
-      async () => {
-        // 延迟导入避免循环依赖
-        const { ErrorHandlerImpl } = await import('../impl/ErrorHandlerImpl')
-        return new ErrorHandlerImpl()
-      },
-      [] // 错误处理服务应尽量减少依赖，避免在错误处理过程中出现循环依赖
-    )
-  }
-}

src/services/di/SystemBootstrapper.ts

@@ -1,179 +0,0 @@
-import { ServiceRegistry } from './ServiceRegistry'
-import { ServiceProvider } from './ServiceProvider'
-import { SystemServiceIntegration } from '../SystemServiceIntegration'
-import { ServiceContainerImpl } from './ServiceContainerImpl'
-
-/**
- * 系统启动器
- * 负责初始化整个系统，包括服务容器、服务注册和启动核心服务
- */
-export class SystemBootstrapper {
-  private static instance: SystemBootstrapper
-  private serviceContainer: ServiceContainerImpl
-  private systemService: SystemServiceIntegration | null = null
-  private initialized = false
-
-  private constructor() {
-    this.serviceContainer = new ServiceContainerImpl()
-  }
-
-  /**
-   * 获取系统启动器实例
-   */
-  public static getInstance(): SystemBootstrapper {
-    if (!SystemBootstrapper.instance) {
-      SystemBootstrapper.instance = new SystemBootstrapper()
-    }
-    return SystemBootstrapper.instance
-  }
-
-  /**
-   * 启动整个系统
-   * @param config 系统配置参数
-   * @returns 启动成功返回true，失败返回false
-   */
-  public async bootstrap(config?: {
-    debug?: boolean
-    autoCleanup?: boolean
-    cleanupInterval?: number
-  }): Promise<boolean> {
-    if (this.initialized) {
-      console.warn('系统已经启动')
-      return true
-    }
-
-    try {
-      console.log('开始启动系统...', config)
-
-      // 1. 初始化服务提供者
-      this.initializeServiceProvider()
-
-      // 2. 初始化系统服务集成层
-      this.initializeSystemService(config || {})
-
-      // 3. 启动所有服务
-      await this.startAllServices()
-
-      this.initialized = true
-      console.log('系统启动成功')
-      return true
-    } catch (error) {
-      console.error('系统启动失败:', error)
-      return false
-    }
-  }
-
-  /**
-   * 初始化服务提供者
-   * 注册并初始化所有服务
-   */
-  private initializeServiceProvider(): void {
-    console.log('初始化服务提供者...')
-
-    // 初始化服务提供者，这会注册并初始化所有服务
-    ServiceProvider.initialize()
-    console.log('服务提供者初始化完成')
-  }
-
-  /**
-   * 初始化系统服务集成层
-   * 创建并配置SystemServiceIntegration实例
-   */
-  private initializeSystemService(config: {
-    debug?: boolean
-    autoCleanup?: boolean
-    cleanupInterval?: number
-  }): void {
-    console.log('初始化系统服务集成层...')
-
-    // 获取服务容器
-    const container = ServiceRegistry.getInstance().getContainer()
-
-    // 创建系统服务集成实例，使用传入的配置
-    this.systemService = new SystemServiceIntegration(container, {
-      debug: config.debug ?? true,
-      autoCleanup: config.autoCleanup ?? true,
-      cleanupInterval: config.cleanupInterval ?? 5 * 60 * 1000 // 默认5分钟
-    })
-
-    console.log('系统服务集成层初始化完成')
-  }
-
-  /**
-   * 启动所有服务
-   */
-  private async startAllServices(): Promise<void> {
-    console.log('启动所有服务...')
-
-    if (!this.systemService) {
-      throw new Error('系统服务集成层未初始化')
-    }
-
-    // 初始化系统服务
-    await this.systemService.initialize()
-
-    console.log('所有服务启动完成')
-  }
-
-  /**
-   * 获取系统服务实例
-   */
-  public getSystemService(): SystemServiceIntegration | null {
-    return this.systemService
-  }
-
-  /**
-   * 检查系统是否已初始化
-   */
-  public isInitialized(): boolean {
-    return this.initialized
-  }
-
-  /**
-   * 关闭系统
-   */
-  public async shutdown(): Promise<void> {
-    if (!this.initialized) {
-      console.warn('系统未启动')
-      return
-    }
-
-    console.log('开始关闭系统...')
-
-    try {
-      // 关闭系统服务
-      if (this.systemService) {
-        await this.systemService.shutdown()
-      }
-
-      // 重置状态
-      this.systemService = null
-      this.initialized = false
-
-      console.log('系统已关闭')
-    } catch (error) {
-      console.error('关闭系统时发生错误:', error)
-    }
-  }
-
-  /**
-   * 重启系统
-   */
-  public async restart(): Promise<boolean> {
-    console.log('重启系统...')
-
-    try {
-      await this.shutdown()
-      await new Promise((resolve) => setTimeout(resolve, 1000))
-      return await this.bootstrap()
-    } catch (error) {
-      console.error('重启系统失败:', error)
-      return false
-    }
-  }
-}
-
-/**
- * 导出系统启动器单例实例
- */
-export const systemBootstrapper = SystemBootstrapper.getInstance()

src/services/di/decorator-example.ts

@@ -1,206 +0,0 @@
-/**
- * 装饰器式依赖注入示例
- * 展示如何使用@Service和@Inject装饰器实现类似Java的自动依赖注入
- */
-
-import { Service, Inject } from './decorators'
-import { ServiceIds } from './ServiceRegistry'
-
-// 示例1: 基本的服务定义和注入
-
-/**
- * 用户服务接口
- */
-interface IUserService {
-  getUserName(): string
-  setUserName(name: string): void
-}
-
-/**
- * 用户服务实现
- * 使用@Service装饰器标记为可注入服务
- */
-@Service() // 自动使用类名"UserService"作为服务ID
-export class UserService implements IUserService {
-  private userName = 'Default User'
-
-  getUserName(): string {
-    return this.userName
-  }
-
-  setUserName(name: string): void {
-    this.userName = name
-  }
-}
-
-// 示例2: 带自定义ID和依赖的服务
-
-/**
- * 日志服务
- */
-@Service({
-  id: 'customLoggerService', // 自定义服务ID
-  dependencies: [] // 无依赖
-})
-export class LoggerService {
-  log(message: string): void {
-    console.log(`[Logger] ${new Date().toISOString()}: ${message}`)
-  }
-
-  error(message: string, error?: Error): void {
-    console.error(`[Logger] ERROR ${new Date().toISOString()}: ${message}`, error)
-  }
-}
-
-// 示例3: 具有依赖的服务
-
-/**
- * 认证服务
- * 依赖于UserService和LoggerService
- */
-@Service({
-  dependencies: [UserService, 'customLoggerService'] // 可以混合使用类和服务ID
-})
-export class AuthService {
-  // 按类型自动注入
-  @Inject()
-  private userService!: UserService
-
-  // 按服务ID注入
-  @Inject('customLoggerService')
-  private logger!: LoggerService
-
-  // 注入系统内置服务（使用ServiceIds）
-  @Inject(ServiceIds.EVENT_BUILDER)
-  private eventBuilder!: any
-
-  authenticate(userName: string): boolean {
-    this.logger.log(`尝试认证用户: ${userName}`)
-    
-    if (userName) {
-      this.userService.setUserName(userName)
-      this.logger.log(`认证成功: ${userName}`)
-      
-      // 使用事件构建器发送认证成功事件
-      if (this.eventBuilder) {
-        try {
-          this.eventBuilder.build('auth.success', { userName })
-        } catch (error) {
-          this.logger.error('发送认证事件失败', error)
-        }
-      }
-      
-      return true
-    }
-    
-    this.logger.error('认证失败: 用户名不能为空')
-    return false
-  }
-}
-
-// 示例4: 在组件或业务类中使用
-
-/**
- * 用户控制器
- * 展示如何在业务类中使用注入的服务
- */
-export class UserController {
-  // 按类型自动注入
-  @Inject()
-  private authService!: AuthService
-
-  // 按类型自动注入
-  @Inject()
-  private userService!: UserService
-
-  login(userName: string): boolean {
-    if (this.authService.authenticate(userName)) {
-      console.log(`用户控制器: ${this.userService.getUserName()} 已登录`)
-      return true
-    }
-    return false
-  }
-}
-
-// 示例5: 复杂的依赖链
-
-/**
- * 数据访问服务
- */
-@Service()
-export class DataAccessService {
-  save(data: any): void {
-    console.log('保存数据:', data)
-  }
-
-  get(id: string): any {
-    console.log(`获取数据ID: ${id}`)
-    return { id, name: '示例数据' }
-  }
-}
-
-/**
- * 用户管理服务
- * 依赖于DataAccessService、UserService和LoggerService
- */
-@Service({
-  dependencies: [DataAccessService, UserService, LoggerService]
-})
-export class UserManagementService {
-  @Inject()
-  private dataAccessService!: DataAccessService
-
-  @Inject()
-  private userService!: UserService
-
-  @Inject()
-  private loggerService!: LoggerService
-
-  updateUserProfile(userId: string, profile: any): boolean {
-    try {
-      this.loggerService.log(`更新用户${userId}的资料`)
-      const currentUser = this.userService.getUserName()
-      
-      const userData = {
-        ...profile,
-        userId,
-        updatedBy: currentUser,
-        updatedAt: new Date()
-      }
-      
-      this.dataAccessService.save(userData)
-      this.loggerService.log(`用户${userId}资料更新成功`)
-      return true
-    } catch (error) {
-      this.loggerService.error('更新用户资料失败', error)
-      return false
-    }
-  }
-}
-
-/**
- * 运行示例
- * 注意：此函数需要在ServiceProvider初始化后调用
- */
-export async function runDecoratorExample(): Promise<void> {
-  try {
-    console.log('\n=== 开始运行装饰器式DI示例 ===')
-
-    // 创建控制器实例
-    const userController = new UserController()
-    
-    // 测试登录功能
-    userController.login('张三')
-    
-    // 测试用户管理服务
-    const userManagementService = new UserManagementService()
-    userManagementService.updateUserProfile('user123', {
-      displayName: '张三',
-      email: 'zhangsan@example.com'
-    })
-    
-    console.log('=== 装饰器式DI示例运行完成 ===\n')
-  } catch (error) {
-    console.error('示例运行失败:', error)
-  }
-}

src/services/di/decorators.ts

@@ -1,203 +0,0 @@
-/**
- * 依赖注入装饰器
- * 提供类似Java的自动注入功能
- */
-
-import { ServiceProvider } from './ServiceProvider'
-import { ServiceRegistry } from './ServiceRegistry'
-import 'reflect-metadata';
-
-// 定义构造函数类型
-type Constructor<T = any> = new (...args: any[]) => T
-
-// 存储类到服务ID的映射
-const classToServiceIdMap = new Map<Constructor, string>()
-// 存储服务ID到类的映射
-const serviceIdToClassMap = new Map<string, Constructor>()
-// 存储需要延迟注册的服务
-const pendingServices: Array<{
-  serviceClass: Constructor
-  serviceId: string
-  dependencies: Array<string | Constructor>
-}> = []
-
-/**
- * 服务装饰器
- * 用于标记一个类作为可注入的服务
- * @param options 服务配置选项
- */
-export function Service(options?: {
-  /** 自定义服务ID，如果不提供则使用类名 */
-  id?: string
-  /** 服务依赖，可以是服务ID字符串或依赖类 */
-  dependencies?: Array<string | Constructor>
-  /** 是否为单例模式，默认为true */
-  singleton?: boolean
-}): ClassDecorator {
-  return (target: Function) => {
-    // 断言target为Constructor类型
-    const serviceClass = target as Constructor
-    const serviceId = options?.id || target.name
-    const dependencies = options?.dependencies || []
-    
-    // 保存映射关系
-    classToServiceIdMap.set(serviceClass, serviceId)
-    serviceIdToClassMap.set(serviceId, serviceClass)
-    
-    // 将服务添加到待注册列表
-    pendingServices.push({
-      serviceClass,
-      serviceId,
-      dependencies
-    })
-    
-    // 尝试注册服务
-    tryRegisterPendingServices()
-  }
-}
-
-/**
- * 注入装饰器
- * 用于自动注入服务实例
- * @param dependency 依赖的服务类或服务ID
- */
-export function Inject(dependency?: Function | string): PropertyDecorator {
-  return (target: Object, propertyKey: string | symbol) => {
-    // 获取属性的类型（如果使用了TypeScript）
-    const propertyType = Reflect.getMetadata('design:type', target, propertyKey)
-    
-    const descriptor = {
-      get: () => {
-        try {
-          let serviceId: string
-          
-          if (typeof dependency === 'string') {
-            // 直接使用提供的服务ID
-            serviceId = dependency
-          } else if (dependency) {
-            // 使用提供的类获取服务ID
-            serviceId = getServiceIdForClass(dependency)
-          } else if (propertyType) {
-            // 使用属性类型获取服务ID
-            serviceId = getServiceIdForClass(propertyType)
-          } else {
-            throw new Error(`无法确定属性 ${String(propertyKey)} 的注入类型`)
-          }
-          
-          return ServiceProvider.getService(serviceId)
-        } catch (error) {
-          console.error(`注入服务失败: ${String(propertyKey)}`, error)
-          throw error
-        }
-      }
-    }
-    
-    Object.defineProperty(target, propertyKey, descriptor)
-  }
-}
-
-/**
- * 获取类对应的服务ID
- * @param cls 服务类
- */
-function getServiceIdForClass(cls: Function): string {
-  const serviceId = classToServiceIdMap.get(cls)
-  if (!serviceId) {
-    throw new Error(`类 ${cls.name} 未注册为服务`)
-  }
-  return serviceId
-}
-
-/**
- * 尝试注册所有待注册的服务
- */
-function tryRegisterPendingServices(): void {
-  if (pendingServices.length === 0) {
-    return
-  }
-  
-  try {
-    const registry = ServiceRegistry.getInstance()
-    const container = registry.getContainer()
-    
-    // 处理所有待注册的服务
-    for (const pendingService of pendingServices.slice()) {
-      // 解析依赖的服务ID
-      const resolvedDependencies: string[] = []
-      for (const dep of pendingService.dependencies) {
-        if (typeof dep === 'string') {
-          resolvedDependencies.push(dep)
-        } else if (typeof dep === 'function') {
-          const depServiceId = classToServiceIdMap.get(dep)
-          if (depServiceId) {
-            resolvedDependencies.push(depServiceId)
-          } else {
-            // 依赖尚未注册，跳过当前服务
-            continue
-          }
-        }
-      }
-      
-      // 检查所有依赖是否都已注册
-      const allDependenciesRegistered = resolvedDependencies.every(depId => 
-        container.has(depId)
-      )
-      
-      if (allDependenciesRegistered) {
-        // 注册服务
-        container.register(
-          pendingService.serviceId,
-          (container) => {
-            // 创建服务实例
-            const ServiceClass = pendingService.serviceClass
-            // 使用依赖注入创建实例
-            const instance = new ServiceClass()
-            return instance
-          },
-          resolvedDependencies
-        )
-        
-        // 从待注册列表中移除
-        const index = pendingServices.indexOf(pendingService)
-        if (index > -1) {
-          pendingServices.splice(index, 1)
-        }
-      }
-    }
-  } catch (error) {
-    // 服务注册表可能尚未初始化，稍后再试
-    console.debug('服务注册暂时失败，将在初始化时重试:')
-  }
-}
-
-/**
- * 初始化所有待注册的服务
- * 在ServiceProvider初始化后调用
- */
-export function initializePendingServices(): void {
-  // 重试注册所有剩余的服务
-  while (pendingServices.length > 0) {
-    const beforeCount = pendingServices.length
-    tryRegisterPendingServices()
-    
-    // 如果没有服务被注册，可能存在循环依赖，跳出循环
-    if (beforeCount === pendingServices.length) {
-      console.warn('以下服务无法注册，可能存在循环依赖:', 
-        pendingServices.map(s => s.serviceId).join(', '))
-      break
-    }
-  }
-}
-
-/**
- * 获取所有已注册的服务信息
- */
-export function getRegisteredServices(): Array<{
-  serviceId: string
-  serviceClass: Function
-}> {
-  return Array.from(classToServiceIdMap.entries()).map(([cls, id]) => ({
-    serviceId: id,
-    serviceClass: cls
-  }))
-}

src/services/di/example.ts

@@ -1,94 +0,0 @@
-/**
- * 依赖注入系统使用示例
- */
-
-// 1. 系统启动示例 - 通常在应用入口文件中使用
-import { systemBootstrapper } from './SystemBootstrapper'
-import { ServiceProvider, Inject } from './ServiceProvider'
-import { ServiceIds } from './ServiceRegistry'
-
-// 启动系统（通常在应用入口点调用一次）
-async function startApplication() {
-  try {
-    console.log('正在启动应用...')
-
-    // 启动整个系统，包括初始化服务容器和所有服务
-    const success = await systemBootstrapper.bootstrap()
-
-    if (!success) {
-      throw new Error('系统启动失败')
-    }
-
-    console.log('应用启动成功！')
-
-    // 应用初始化完成后，可以开始使用各种服务
-    initializeApplication()
-  } catch (error) {
-    console.error('应用启动失败:', error)
-  }
-}
-
-// 应用初始化
-function initializeApplication() {
-  // 2. 使用静态服务提供者访问服务
-  const windowService = ServiceProvider.getWindowFormService()
-  const resourceService = ServiceProvider.getResourceService()
-
-  console.log('访问服务示例:', {
-    windowServiceAvailable: !!windowService,
-    resourceServiceAvailable: !!resourceService
-  })
-
-  // 3. 创建并初始化一个使用依赖注入的组件
-  const appComponent = new ApplicationComponent()
-  appComponent.initialize()
-}
-
-// 4. 在组件中使用依赖注入
-class ApplicationComponent {
-  // 使用装饰器自动注入服务
-  @Inject(ServiceIds.WINDOW_FORM_SERVICE)
-  private windowFormService: any
-
-  @Inject(ServiceIds.RESOURCE_SERVICE)
-  private resourceService: any
-
-  @Inject(ServiceIds.LIFECYCLE_MANAGER)
-  private lifecycleManager: any
-
-  initialize() {
-    console.log('组件初始化，服务已注入:', {
-      windowFormService: !!this.windowFormService,
-      resourceService: !!this.resourceService,
-      lifecycleManager: !!this.lifecycleManager
-    })
-
-    // 使用注入的服务
-    this.setupComponent()
-  }
-
-  private setupComponent() {
-    // 示例：使用窗口服务创建一个新窗口
-    // 注意：这只是示例代码，实际使用时需要根据具体服务API调整
-    console.log('组件正在使用注入的服务设置UI...')
-  }
-}
-
-// 5. 动态获取服务示例
-function dynamicServiceExample(serviceId: string) {
-  // 使用get方法动态获取服务
-  try {
-    const service = ServiceProvider.getService(serviceId as any)
-    console.log(`动态获取服务[${serviceId}]:`, !!service)
-    return service
-  } catch (error) {
-    console.error(`无法获取服务[${serviceId}]:`, error)
-    return null
-  }
-}
-
-// 导出示例函数供其他文件使用
-export { startApplication, dynamicServiceExample, ApplicationComponent }
-
-// 注意：在实际应用中，你会在main.ts或应用入口文件中调用startApplication()
-// startApplication(); // 取消注释以启动应用

src/services/di/types.d.ts

@@ -1,105 +0,0 @@
-import { IServiceContainer } from './IServiceContainer'
-import { ServiceIds } from './ServiceRegistry'
-
-/**
- * 定义所有服务类型映射
- * 这个接口用于在ServiceProvider中提供强类型的服务访问
- */
-export interface ServiceTypeMap {
-  [ServiceIds.RESOURCE_SERVICE]: any // ResourceService
-  [ServiceIds.WINDOW_FORM_SERVICE]: any // WindowFormService
-  [ServiceIds.SANDBOX_ENGINE]: any // ApplicationSandboxEngine
-  [ServiceIds.LIFECYCLE_MANAGER]: any // ApplicationLifecycleManager
-  [ServiceIds.SYSTEM_SERVICE]: any // SystemServiceIntegration
-  [ServiceIds.EVENT_BUILDER]: any // IEventBuilder<any>
-  [ServiceIds.EXTERNAL_APP_DISCOVERY]: any // 外部应用发现服务
-  [ServiceIds.ERROR_HANDLER]: any // 错误处理服务
-}
-
-/**
- * 扩展IServiceContainer接口，提供强类型的get方法
- */
-declare module './IServiceContainer' {
-  export interface IServiceContainer {
-    /**
-     * 获取服务实例（带类型支持）
-     * @param id 服务ID
-     * @returns 服务实例，类型根据服务ID自动推断
-     */
-    getService<T extends keyof ServiceTypeMap>(id: T): ServiceTypeMap[T]
-  }
-}
-
-/**
- * 扩展ServiceProvider类的静态方法类型
- */
-declare module './ServiceProvider' {
-  // 仅扩展现有ServiceProvider类，不重新声明
-  interface ServiceProvider {
-    /**
-     * 获取服务实例（带类型支持）
-     * @param id 服务ID
-     * @returns 服务实例，类型根据服务ID自动推断
-     */
-    static getService<T extends keyof ServiceTypeMap>(id: T): ServiceTypeMap[T]
-
-    /**
-     * 获取资源服务
-     */
-    static getResourceService(): ServiceTypeMap[typeof ServiceIds.RESOURCE_SERVICE]
-
-    /**
-     * 获取窗口表单服务
-     */
-    static getWindowFormService(): ServiceTypeMap[typeof ServiceIds.WINDOW_FORM_SERVICE]
-
-    /**
-     * 获取沙箱引擎
-     */
-    static getSandboxEngine(): ServiceTypeMap[typeof ServiceIds.SANDBOX_ENGINE]
-
-    /**
-     * 获取生命周期管理器
-     */
-    static getLifecycleManager(): ServiceTypeMap[typeof ServiceIds.LIFECYCLE_MANAGER]
-
-    /**
-     * 获取系统服务
-     */
-    static getSystemService(): ServiceTypeMap[typeof ServiceIds.SYSTEM_SERVICE]
-
-    /**
-     * 获取事件构建器
-     */
-    static getEventBuilder(): ServiceTypeMap[typeof ServiceIds.EVENT_BUILDER]
-
-    /**
-     * 获取外部应用发现服务
-     */
-    static getExternalAppDiscovery(): ServiceTypeMap[typeof ServiceIds.EXTERNAL_APP_DISCOVERY]
-
-    /**
-     * 获取错误处理服务
-     */
-    static getErrorHandler(): ServiceTypeMap[typeof ServiceIds.ERROR_HANDLER]
-  }
-}
-
-/**
- * 声明Inject装饰器类型
- */
-declare function Inject<T extends keyof ServiceTypeMap>(serviceId: T): PropertyDecorator
-
-/**
- * 声明新的Inject装饰器类型，支持类注入
- */
-declare function Inject<T>(dependency?: Function | string): PropertyDecorator
-
-/**
- * 声明Service装饰器类型
- */
-declare function Service(options?: {
-  id?: string
-  dependencies?: Array<string | Function>
-  singleton?: boolean
-}): ClassDecorator

src/services/example/ErrorHandlerExample.ts

@@ -1,103 +0,0 @@
-import { ServiceProvider } from '../di/ServiceProvider'
-import { ServiceIds } from '../di/ServiceRegistry'
-import type { IErrorHandler, ErrorContext } from '../IErrorHandler'
-
-/**
- * 错误处理服务使用示例
- */
-export class ErrorHandlerExample {
-  private errorHandler: IErrorHandler
-
-  constructor() {
-    // 通过服务提供者获取错误处理器实例
-    this.errorHandler = ServiceProvider.getService<IErrorHandler>(ServiceIds.ERROR_HANDLER)
-  }
-
-  /**
-   * 演示不同类型错误的处理
-   */
-  public demonstrateErrorHandling(): void {
-    console.log('=== 开始演示错误处理服务 ===')
-
-    // 1. 处理标准Error对象
-    try {
-      throw new Error('这是一个标准错误')
-    } catch (error) {
-      const context: ErrorContext = {
-        source: 'ErrorHandlerExample',
-        operation: 'demonstrateStandardError',
-        appId: 'example-app-123'
-      }
-      this.errorHandler.handleError(error, context)
-    }
-
-    // 2. 处理类型错误
-    try {
-      const obj: any = null
-      obj.method() // 这会抛出TypeError
-    } catch (error) {
-      this.errorHandler.handleError(error, {
-        source: 'ErrorHandlerExample',
-        operation: 'demonstrateTypeError',
-        additionalInfo: '尝试在null上调用方法'
-      })
-    }
-
-    // 3. 处理未捕获的Promise错误
-    console.log('演示未捕获的Promise错误...')
-    // 注意：这个错误会被全局错误处理器捕获
-    Promise.reject(new Error('这是一个未处理的Promise错误'))
-
-    // 4. 获取最近的错误记录
-    setTimeout(() => {
-      const recentErrors = this.errorHandler.getRecentErrors(2)
-      console.log('\n=== 最近的错误记录 ===')
-      recentErrors.forEach(record => {
-        console.log(`错误ID: ${record.id}`)
-        console.log(`时间: ${record.timestamp.toISOString()}`)
-        console.log(`处理状态: ${record.handled ? '已处理' : '未处理'}`)
-        console.log(`上下文:`, record.context)
-      })
-    }, 100)
-  }
-}
-
-/**
- * 在组件或服务中使用错误处理器的示例
- */
-export function useErrorHandlerInComponent() {
-  const errorHandler = ServiceProvider.getService<IErrorHandler>(ServiceIds.ERROR_HANDLER)
-  
-  // 在组件方法中使用
-  function performRiskyOperation() {
-    try {
-      // 执行可能失败的操作
-      if (Math.random() > 0.5) {
-        throw new Error('操作随机失败')
-      }
-      return '操作成功'
-    } catch (error) {
-      // 使用错误处理器记录和处理错误
-      errorHandler.handleError(error, {
-        source: 'MyComponent',
-        operation: 'performRiskyOperation',
-        componentProps: { /* 组件属性信息 */ }
-      })
-      
-      // 可以选择返回一个默认值或重新抛出
-      return '操作失败，但已正确处理'
-    }
-  }
-  
-  return { performRiskyOperation }
-}
-
-// 导出一个立即执行的示例函数，方便直接测试
-export function runErrorHandlerExample() {
-  try {
-    const example = new ErrorHandlerExample()
-    example.demonstrateErrorHandling()
-  } catch (error) {
-    console.error('示例执行失败:', error)
-  }
-}

src/services/impl/ErrorHandlerImpl.ts

@@ -1,154 +0,0 @@
-import type { IErrorHandler, ErrorContext, ErrorRecord } from '../IErrorHandler'
-import { v4 as uuidv4 } from 'uuid'
-
-/**
- * 全局错误处理器实现
- */
-export class ErrorHandlerImpl implements IErrorHandler {
-  private errorRecords: ErrorRecord[] = []
-  private maxRecords = 100
-  private isGlobalHandlersSetup = false
-
-  constructor() {
-    // 初始化时可以设置全局错误处理器
-    this.setupGlobalErrorHandlers()
-  }
-
-  /**
-   * 处理应用错误
-   * @param error 错误对象
-   * @param context 错误上下文信息
-   * @returns 是否成功处理了错误
-   */
-  public handleError(error: Error | any, context: ErrorContext = {}): boolean {
-    try {
-      // 创建错误记录
-      const errorRecord: ErrorRecord = {
-        id: uuidv4(),
-        error,
-        context,
-        timestamp: new Date(),
-        handled: false
-      }
-
-      // 保存错误记录
-      this.addErrorRecord(errorRecord)
-
-      // 根据错误类型进行处理
-      if (error instanceof Error) {
-        this.logError(error, context)
-        this.reportError(error, context)
-      } else {
-        // 非标准错误对象
-        this.logUnknownError(error, context)
-      }
-
-      errorRecord.handled = true
-      return true
-    } catch (handlerError) {
-      console.error('错误处理器自身出错:', handlerError)
-      return false
-    }
-  }
-
-  /**
-   * 处理未捕获的异常
-   */
-  public setupGlobalErrorHandlers(): void {
-    if (this.isGlobalHandlersSetup) {
-      return
-    }
-
-    // 捕获未处理的Promise错误
-    window.addEventListener('unhandledrejection', (event) => {
-      this.handleError(event.reason, {
-        source: 'unhandledrejection',
-        operation: 'Promise处理'
-      })
-    })
-
-    // 捕获全局错误
-    window.addEventListener('error', (event) => {
-      const error = event.error || new Error(event.message)
-      this.handleError(error, {
-        source: 'window.error',
-        operation: event.filename || window.location.pathname,
-        lineNumber: event.lineno,
-        columnNumber: event.colno
-      })
-    })
-
-    // Vue应用的错误处理可以在main.ts中配置
-
-    this.isGlobalHandlersSetup = true
-  }
-
-  /**
-   * 获取最近的错误记录
-   * @param limit 获取的最大数量
-   */
-  public getRecentErrors(limit: number = 10): ErrorRecord[] {
-    return this.errorRecords
-      .slice()
-      .sort((a, b) => b.timestamp.getTime() - a.timestamp.getTime())
-      .slice(0, limit)
-  }
-
-  /**
-   * 添加错误记录到历史
-   */
-  private addErrorRecord(record: ErrorRecord): void {
-    this.errorRecords.unshift(record)
-    
-    // 限制记录数量
-    if (this.errorRecords.length > this.maxRecords) {
-      this.errorRecords = this.errorRecords.slice(0, this.maxRecords)
-    }
-  }
-
-  /**
-   * 记录标准错误
-   */
-  private logError(error: Error, context: ErrorContext): void {
-    console.error(`[错误处理] ${context.source || '未知来源'}: ${error.message}`, {
-      error,
-      stack: error.stack,
-      context
-    })
-  }
-
-  /**
-   * 记录未知类型错误
-   */
-  private logUnknownError(error: any, context: ErrorContext): void {
-    console.error(`[错误处理] ${context.source || '未知来源'}: 发生未知类型错误`, {
-      error,
-      context
-    })
-  }
-
-  /**
-   * 报告错误（可以扩展为发送到错误监控服务）
-   */
-  private reportError(error: Error, context: ErrorContext): void {
-    // 在实际项目中，这里可以将错误发送到远程监控服务
-    // 例如：sentry、logrocket等
-    // 现在只是记录到控制台
-    console.debug('[错误报告] 准备发送错误信息...')
-    
-    // 模拟异步错误报告
-    setTimeout(() => {
-      console.debug(`[错误报告] 错误已记录，ID: ${context.source || 'unknown'}`)
-    }, 0)
-  }
-}
-
-// 创建单例实例
-let instance: ErrorHandlerImpl | null = null
-
-export function getErrorHandlerInstance(): ErrorHandlerImpl {
-  if (!instance) {
-    instance = new ErrorHandlerImpl()
-  }
-  return instance
-}

src/ui/components/AppRenderer.vue

@@ -1,289 +0,0 @@
-<template>
-  <div class="app-renderer" :class="`app-${appId}`">
-    <!-- 内置Vue应用 - 立即渲染，无加载状态 -->
-    <component 
-      v-if="isBuiltInApp && appComponent"
-      :is="appComponent"
-      :key="appId"
-    />
-    
-    <!-- 外部iframe应用 -->
-    <iframe 
-      v-else-if="!isBuiltInApp && iframeUrl"
-      :src="iframeUrl"
-      :sandbox="sandboxAttributes"
-      class="external-app-iframe"
-      @load="onIframeLoad"
-      @error="onIframeError"
-    />
-    
-    <!-- 加载中状态（仅用于外部应用） -->
-    <div v-else-if="!isBuiltInApp && isLoading" class="loading-state">
-      <div class="loading-spinner"></div>
-      <p>正在加载应用...</p>
-    </div>
-    
-    <!-- 错误状态 -->
-    <div v-else-if="hasError" class="error-state">
-      <div class="error-icon">⚠️</div>
-      <h3>应用加载失败</h3>
-      <p>{{ errorMessage }}</p>
-      <button @click="retry" class="retry-btn">重试</button>
-    </div>
-    
-    <!-- 内置应用未找到的后备显示 -->
-    <div v-else-if="isBuiltInApp && !appComponent" class="error-state">
-      <div class="error-icon">📱</div>
-      <h3>应用不存在</h3>
-      <p>内置应用 "{{ appId }}" 未找到</p>
-    </div>
-  </div>
-</template>
-
-<script setup lang="ts">
-import { ref, computed, onMounted, onUnmounted, inject, watch } from 'vue'
-import { appRegistry } from '@/apps'
-import { externalAppDiscovery } from '@/services/ExternalAppDiscovery'
-import type { SystemServiceIntegration } from '@/services/SystemServiceIntegration'
-
-const props = defineProps<{
-  appId: string
-  windowId?: string
-}>()
-
-const emit = defineEmits<{
-  loaded: []
-  error: [error: Error]
-}>()
-
-const systemService = inject<SystemServiceIntegration>('systemService')
-
-// 检查是否为内置应用
-const isBuiltInApp = computed(() => {
-  return appRegistry.hasApp(props.appId)
-})
-
-// 检查是否为外置应用
-const isExternalApp = computed(() => {
-  return externalAppDiscovery.hasApp(props.appId)
-})
-
-// 内置应用组件 - 立即获取，无需异步
-const appComponent = computed(() => {
-  if (isBuiltInApp.value) {
-    const appRegistration = appRegistry.getApp(props.appId)
-    return appRegistration?.component
-  }
-  return null
-})
-
-// 外部应用相关状态
-const isLoading = ref(false)  // 默认不loading，只有外部应用需要
-const hasError = ref(false)
-const errorMessage = ref('')
-const iframeUrl = ref('')
-
-// 沙箱属性（仅用于外部应用）
-const sandboxAttributes = computed(() => {
-  return 'allow-scripts allow-forms allow-popups'
-})
-
-// 初始化应用
-const initializeApp = async () => {
-  try {
-    if (isBuiltInApp.value) {
-      // 内置应用立即可用，无需异步加载
-      if (appComponent.value) {
-        emit('loaded')
-      } else {
-        hasError.value = true
-        errorMessage.value = '内置应用未找到'
-        emit('error', new Error('内置应用未找到'))
-      }
-    } else if (isExternalApp.value) {
-      // 外置应用需要异步加载
-      isLoading.value = true
-      hasError.value = false
-      errorMessage.value = ''
-      await loadExternalApp()
-    } else {
-      throw new Error(`应用 ${props.appId} 未找到（不是内置也不是外置应用）`)
-    }
-  } catch (error) {
-    console.error('应用初始化失败:', error)
-    hasError.value = true
-    errorMessage.value = (error as Error).message
-    isLoading.value = false
-    emit('error', error as Error)
-  }
-}
-
-// 加载外部应用
-const loadExternalApp = async () => {
-  try {
-    console.log(`[AppRenderer] 加载外置应用: ${props.appId}`)
-    
-    // 直接从外置应用发现服务获取应用信息
-    const externalApp = externalAppDiscovery.getApp(props.appId)
-    if (!externalApp) {
-      throw new Error('外置应用未找到')
-    }
-    
-    // 直接使用外置应用的入口路径
-    iframeUrl.value = externalApp.entryPath
-    console.log(`[AppRenderer] 外置应用加载路径: ${iframeUrl.value}`)
-    
-  } catch (error) {
-    console.error(`[AppRenderer] 外置应用加载失败:`, error)
-    throw new Error(`外部应用加载失败: ${(error as Error).message}`)
-  }
-}
-
-// iframe加载完成
-const onIframeLoad = () => {
-  isLoading.value = false
-  emit('loaded')
-}
-
-// iframe加载错误
-const onIframeError = (event: Event) => {
-  hasError.value = true
-  errorMessage.value = '外部应用加载失败'
-  isLoading.value = false
-  emit('error', new Error('iframe加载失败'))
-}
-
-// 重试加载
-const retry = () => {
-  initializeApp()
-}
-
-// 监听内置应用组件的可用性，立即发送loaded事件
-watch(appComponent, (newComponent) => {
-  if (isBuiltInApp.value && newComponent) {
-    emit('loaded')
-  }
-}, { immediate: true })
-
-onMounted(() => {
-  // 内置应用无需额外初始化，只处理外部应用
-  if (!isBuiltInApp.value) {
-    if (isExternalApp.value) {
-      initializeApp()
-    } else {
-      // 应用不存在
-      hasError.value = true
-      errorMessage.value = `应用 ${props.appId} 未找到`
-      emit('error', new Error('应用未找到'))
-    }
-  } else if (!appComponent.value) {
-    // 内置应用不存在
-    hasError.value = true
-    errorMessage.value = '内置应用未找到'
-    emit('error', new Error('内置应用未找到'))
-  }
-})
-
-onUnmounted(() => {
-  // 清理iframe URL（只有当是blob URL时才需要清理）
-  if (iframeUrl.value && iframeUrl.value.startsWith('blob:')) {
-    URL.revokeObjectURL(iframeUrl.value)
-  }
-})
-</script>
-
-<style scoped>
-.app-renderer {
-  width: 100%;
-  height: 100%;
-  display: flex;
-  flex-direction: column;
-  background: white;
-  position: relative;
-}
-
-.external-app-iframe {
-  width: 100%;
-  height: 100%;
-  border: none;
-  background: white;
-}
-
-.loading-state {
-  display: flex;
-  flex-direction: column;
-  align-items: center;
-  justify-content: center;
-  height: 100%;
-  color: #6c757d;
-  gap: 16px;
-}
-
-.loading-spinner {
-  width: 40px;
-  height: 40px;
-  border: 4px solid #f3f3f3;
-  border-top: 4px solid #007bff;
-  border-radius: 50%;
-  animation: spin 1s linear infinite;
-}
-
-.error-state {
-  display: flex;
-  flex-direction: column;
-  align-items: center;
-  justify-content: center;
-  height: 100%;
-  text-align: center;
-  padding: 40px;
-  color: #6c757d;
-}
-
-.error-icon {
-  font-size: 48px;
-  margin-bottom: 16px;
-}
-
-.error-state h3 {
-  margin-bottom: 8px;
-  color: #dc3545;
-}
-
-.error-state p {
-  margin-bottom: 16px;
-  font-size: 14px;
-}
-
-.retry-btn {
-  padding: 8px 16px;
-  background: #007bff;
-  color: white;
-  border: none;
-  border-radius: 4px;
-  cursor: pointer;
-  font-size: 14px;
-  transition: background 0.2s;
-}
-
-.retry-btn:hover {
-  background: #0056b3;
-}
-
-/* 应用特定样式 */
-.app-calculator {
-  background: #f8f9fa;
-}
-
-.app-notepad {
-  background: white;
-}
-
-.app-todo {
-  background: #f8f9fa;
-}
-
-@keyframes spin {
-  0% { transform: rotate(0deg); }
-  100% { transform: rotate(360deg); }
-}
-</style>

src/ui/components/WindowManager.vue

@@ -1,139 +1,22 @@
 <template>
   <div class="window-manager">
     <!-- 所有已打开的内置应用窗口 -->
-    <teleport v-for="window in builtInWindows" :key="window.id" :to="`#app-container-${window.appId}`">
+    <teleport v-for="window in builtInWindows?.values()" :key="window.id" :to="`#app-container-${window.appId}`">
-      <component :is="window.component" :key="window.id" v-bind="window.props" @close="closeWindow(window.id)" />
+      <component :is="window.component" :key="window.id" v-bind="window.props" />
     </teleport>
   </div>
 </template>
 
 <script setup lang="ts">
-import { ref, inject, onMounted, onUnmounted } from 'vue'
+import { inject } from 'vue'
 import type { SystemServiceIntegration } from '@/services/SystemServiceIntegration'
-import { appRegistry } from '@/apps'
-
-interface BuiltInWindow {
-  id: string
-  appId: string
-  component: any
-  props: Record<string, any>
-}
-
-// 存储所有已打开的内置应用窗口
-const builtInWindows = ref<BuiltInWindow[]>([])
 
 // 注入系统服务
 const systemService = inject<SystemServiceIntegration>('systemService')
 
-// 添加内置应用窗口
+// 存储所有已打开的内置应用窗口
-const addBuiltInWindow = async (windowId: string, appId: string) => {
+const builtInWindows = systemService?.getLifecycleManager().getBuiltInWindowForms()
-  // 检查应用是否存在
-  const appRegistration = appRegistry.getApp(appId)
-  if (!appRegistration) {
-    console.error(`内置应用 ${appId} 不存在`)
-    return
-  }
 
-  // 检查窗口是否已存在
-  const existingWindow = builtInWindows.value.find(w => w.id === windowId)
-  if (existingWindow) {
-    console.warn(`窗口 ${windowId} 已存在`)
-    return
-  }
-
-  // 处理异步组件加载
-  let component = appRegistration.component
-  if (typeof component === 'function') {
-    try {
-      // 如果是函数，调用它来获取组件
-      component = await component()
-    } catch (error) {
-      console.error(`加载应用组件失败: ${appId}`, error)
-      return
-    }
-  }
-
-  // 添加窗口
-  const window: BuiltInWindow = {
-    id: windowId,
-    appId,
-    component,
-    props: {
-      windowId,
-      appId
-    }
-  }
-
-  builtInWindows.value.push(window)
-  console.log(`[WindowManager] 添加内置应用窗口: ${appId} (${windowId})`)
-}
-
-// 关闭内置应用窗口
-const closeWindow = (windowId: string) => {
-  const index = builtInWindows.value.findIndex(w => w.id === windowId)
-  if (index > -1) {
-    const window = builtInWindows.value[index]
-    builtInWindows.value.splice(index, 1)
-    console.log(`[WindowManager] 关闭内置应用窗口: ${window.appId} (${windowId})`)
-
-    // 通知系统服务关闭窗口
-    if (systemService) {
-      const windowService = systemService.getWindowFormService()
-      windowService.destroyWindow(windowId)
-    }
-  }
-}
-
-// 移除内置应用窗口（不关闭系统窗口）
-const removeBuiltInWindow = (windowId: string) => {
-  const index = builtInWindows.value.findIndex(w => w.id === windowId)
-  if (index > -1) {
-    const window = builtInWindows.value[index]
-    builtInWindows.value.splice(index, 1)
-    console.log(`[WindowManager] 移除内置应用窗口: ${window.appId} (${windowId})`)
-  }
-}
-
-// 移除事件监听相关代码
-// let eventUnsubscriber: (() => void) | null = null
-
-// onMounted(() => {
-// 移除事件服务相关代码
-// if (systemService) {
-//   const eventService = systemService.getEventService()
-
-//   // 监听内置应用窗口创建事件
-//   const subscriberId = eventService.subscribe('system', 'built-in-window-created', async (message) => {
-//     const { windowId, appId } = message.payload
-//     await addBuiltInWindow(windowId, appId)
-//   })
-
-//   // 监听内置应用窗口关闭事件
-//   const closeSubscriberId = eventService.subscribe('system', 'built-in-window-closed', (message) => {
-//     const { windowId } = message.payload
-//     removeBuiltInWindow(windowId)
-//   })
-
-//   eventUnsubscriber = () => {
-//     eventService.unsubscribe(subscriberId)
-//     eventService.unsubscribe(closeSubscriberId)
-//   }
-// }
-// })
-
-// onUnmounted(() => {
-// 移除事件服务相关代码
-// if (eventUnsubscriber) {
-//   eventUnsubscriber()
-// }
-// })
-
-// 暴露给全局使用
-defineExpose({
-  addBuiltInWindow,
-  removeBuiltInWindow,
-  closeWindow
-})
 </script>
 
 <style scoped>

src/ui/desktop-container/DesktopContainer.vue

@@ -28,7 +28,7 @@ import { useDynamicAppIcons, getAppIdFromIcon } from '@/ui/desktop-container/use
 import type { SystemServiceIntegration } from '@/services/SystemServiceIntegration'
 import type { SystemStatus } from '@/services/SystemServiceIntegration'
 import { appRegistry } from '@/apps'
-import { externalAppDiscovery } from '@/services/ExternalAppDiscovery'
+import { externalAppDiscovery } from '@/services/ExternalAppDiscovery.ts'
 
 const { appIconsRef, gridStyle, gridTemplate } = useDesktopContainerInit('.desktop-icons-container')
 const { getAppIconsWithPositions, saveIconPositions, refreshApps } = useDynamicAppIcons()
@@ -98,52 +98,7 @@ const startApp = async (appId: string) => {
 
   try {
     const lifecycleManager = systemService.getLifecycleManager()
-
+    await lifecycleManager.startApp(appId)
-    // 检查是否为内置应用
-    if (appRegistry.hasApp(appId)) {
-      // 内置应用：使用主应用的窗口管理器
-      const appRegistration = appRegistry.getApp(appId)!
-
-      // 检查是否已在运行
-      if (lifecycleManager.isAppRunning(appId)) {
-        console.log(`应用 ${appRegistration.manifest.name} 已在运行`)
-        return
-      }
-
-      // 创建窗口
-      const windowService = systemService.getWindowFormService()
-      const windowConfig = {
-        title: appRegistration.manifest.name,
-        width: appRegistration.manifest.window.width,
-        height: appRegistration.manifest.window.height,
-        minWidth: appRegistration.manifest.window.minWidth,
-        minHeight: appRegistration.manifest.window.minHeight,
-        resizable: appRegistration.manifest.window.resizable !== false
-      }
-
-      const windowInstance = await windowService.createWindow(appId, windowConfig)
-
-      // 使用主应用的窗口管理器来渲染内置应用
-      if (windowManager?.value) {
-        await windowManager.value.addBuiltInWindow(windowInstance.id, appId)
-        console.log(`[主应用] 使用窗口管理器渲染内置应用: ${appId}`)
-      } else {
-        console.error('窗口管理器未初始化')
-      }
-
-    } else if (externalAppDiscovery.hasApp(appId)) {
-      // 外置应用：直接使用ApplicationLifecycleManager
-      console.log(`启动外置应用: ${appId}`)
-
-      if (!lifecycleManager.isAppRunning(appId)) {
-        await lifecycleManager.startApp(appId)
-        console.log(`外置应用 ${appId} 启动成功`)
-      } else {
-        console.log(`外置应用 ${appId} 已在运行`)
-      }
-    } else {
-      console.error(`未知的应用: ${appId}`)
-    }
   } catch (error) {
     console.error('启动应用失败:', error)
   }

src/ui/desktop-container/useDynamicAppIcons.ts

@@ -1,7 +1,6 @@
 import { computed, watch } from 'vue'
 import type { IDesktopAppIcon } from '@/ui/types/IDesktopAppIcon.ts'
 import { appRegistry } from '@/apps'
-import { externalAppDiscovery } from '@/services/ExternalAppDiscovery'
 
 /**
  * 动态应用图标管理
@@ -31,20 +30,20 @@ export function useDynamicAppIcons() {
     }
     
     // 添加外置应用
-    const externalApps = externalAppDiscovery.getDiscoveredApps()
+    // const externalApps = []
-    for (const app of externalApps) {
+    // for (const app of externalApps) {
-      const x = ((position - 1) % 4) + 1
+    //   const x = ((position - 1) % 4) + 1
-      const y = Math.floor((position - 1) / 4) + 1
+    //   const y = Math.floor((position - 1) / 4) + 1
-      
+    //
-      icons.push({
+    //   icons.push({
-        name: app.manifest.name,
+    //     name: app.manifest.name,
-        icon: app.manifest.icon || '📱', // 默认图标
+    //     icon: app.manifest.icon || '📱', // 默认图标
-        path: app.manifest.id,
+    //     path: app.manifest.id,
-        x,
+    //     x,
-        y
+    //     y
-      })
+    //   })
-      position++
+    //   position++
-    }
+    // }
     
     // 添加系统状态应用
     icons.push({
@@ -111,12 +110,6 @@ export function useDynamicAppIcons() {
   const refreshApps = async () => {
     try {
       // 只有在系统服务已启动的情况下才刷新
-      if (externalAppDiscovery['hasStarted']) {
-        await externalAppDiscovery.refresh()
-        console.log('[DynamicAppIcons] 应用列表已刷新')
-      } else {
-        console.log('[DynamicAppIcons] 系统服务未启动，跳过刷新')
-      }
     } catch (error) {
       console.error('[DynamicAppIcons] 刷新应用列表失败:', error)
     }