应用概述

基于HarmonyOS 5和仓颉编程语言的医院手术叫号系统，主要功能包括：

• 实时手术状态展示
• 患者手术叫号通知
• 手术进度可视化
• 多终端同步显示
• 紧急情况预警

技术架构

1. ​​前端​​：仓颉语言开发HarmonyOS应用
2. ​​实时通信​​：WebSocket长连接
3. ​​数据存储​​：HarmonyOS轻量级数据库
4. ​​UI组件​​：ArkUI仓颉适配组件

核心功能实现

1. 数据模型定义

// 手术室数据模型
class OperatingRoom {
    id: number;
    name: string; // 如"第一手术室"
    status: 'idle' | 'preparing' | 'in_progress' | 'cleaning';
    currentCase?: SurgeryCase;
}

// 手术病例模型
class SurgeryCase {
    id: number;
    patientName: string;
    patientId: string;
    surgeryType: string;
    surgeon: string;
    anesthetist: string;
    nurse: string;
    plannedStartTime: string;
    actualStartTime?: string;
    endTime?: string;
    status: 'waiting' | 'pre_op' | 'in_surgery' | 'post_op' | 'completed';
    urgency: 'routine' | 'urgent' | 'emergency';
}

2. 主叫号界面实现

@Component
struct SurgeryCallPage {
    @State rooms: OperatingRoom[] = [];
    @State announcements: string[] = [];
    private socket: WebSocket;
    
    build() {
        Column() {
            // 顶部医院信息
            HospitalHeader()
            
            // 手术室状态看板
            SurgeryRoomDashboard({
                rooms: this.rooms,
                onRoomSelect: (room) => this.showRoomDetail(room)
            })
            
            // 叫号通知区域
            AnnouncementBoard({
                messages: this.announcements
            })
            
            // 控制按钮区
            ControlPanel({
                onEmergency: this.handleEmergency,
                onCallNext: this.callNextPatient
            })
        }
        .height('100%')
        .backgroundColor('#f5f5f5')
    }
    
    aboutToAppear() {
        this.initWebSocket();
        this.loadInitialData();
    }
    
    // 初始化WebSocket连接
    initWebSocket() {
        this.socket = new WebSocket('ws://your-hospital-server/surgery-call');
        
        this.socket.onOpen(() => {
            console.log('WebSocket连接已建立');
        });
        
        this.socket.onMessage((event) => {
            const data = JSON.parse(event.data);
            this.handleServerMessage(data);
        });
        
        this.socket.onClose(() => {
            console.log('WebSocket连接已关闭');
        });
    }
    
    // 处理服务器消息
    handleServerMessage(data: any) {
        switch(data.type) {
            case 'room_update':
                this.rooms = data.rooms;
                break;
            case 'announcement':
                this.announcements = [data.message, ...this.announcements].slice(0, 5);
                break;
            case 'emergency':
                this.showEmergencyAlert(data.message);
                break;
        }
    }
    
    // 加载初始数据
    async loadInitialData() {
        try {
            const response = await http.get('/api/surgery/rooms');
            this.rooms = response.data;
        } catch (error) {
            console.error('加载手术室数据失败:', error);
        }
    }
    
    // 显示手术室详情
    showRoomDetail(room: OperatingRoom) {
        router.push({ 
            url: 'pages/RoomDetail', 
            params: { roomId: room.id } 
        });
    }
    
    // 处理紧急情况
    handleEmergency() {
        this.socket.send(JSON.stringify({
            type: 'emergency',
            roomId: this.rooms[0].id // 示例：默认第一个手术室
        }));
    }
    
    // 叫号下一个患者
    callNextPatient() {
        const nextCase = this.findNextWaitingCase();
        if (nextCase) {
            this.socket.send(JSON.stringify({
                type: 'call_next',
                caseId: nextCase.id
            }));
        }
    }
    
    // 查找下一个等待中的病例
    findNextWaitingCase(): SurgeryCase | undefined {
        for (const room of this.rooms) {
            if (room.currentCase && room.currentCase.status === 'waiting') {
                return room.currentCase;
            }
        }
        return undefined;
    }
}

3. 手术室状态看板组件

@Component
struct SurgeryRoomDashboard {
    @Prop rooms: OperatingRoom[];
    @Prop onRoomSelect: (room: OperatingRoom) => void;
    
    build() {
        Grid() {
            ForEach(this.rooms, (room) => {
                GridItem() {
                    SurgeryRoomCard({
                        room: room,
                        onClick: () => this.onRoomSelect(room)
                    })
                }
                .columnSpan(2)
            })
        }
        .columnsTemplate('1fr 1fr 1fr 1fr')
        .rowsTemplate('1fr 1fr')
        .height('60%')
    }
}

@Component
struct SurgeryRoomCard {
    @Prop room: OperatingRoom;
    @Prop onClick: () => void;
    
    build() {
        Column() {
            Text(this.room.name)
                .fontSize(18)
                .fontWeight(FontWeight.Bold)
            
            // 状态指示灯
            StatusLight(this.room.status)
            
            if (this.room.currentCase) {
                Text(this.room.currentCase.patientName)
                    .fontSize(16)
                Text(this.room.currentCase.surgeryType)
                    .fontSize(14)
                Text(this.getStatusText(this.room.currentCase.status))
                    .fontSize(12)
                    .fontColor(this.getStatusColor(this.room.currentCase.status))
            } else {
                Text('空闲中')
                    .fontSize(16)
            }
        }
        .padding(10)
        .borderRadius(8)
        .backgroundColor('#fff')
        .shadow({ radius: 2, color: '#ddd' })
        .onClick(this.onClick)
    }
    
    getStatusText(status: string): string {
        const statusMap = {
            'waiting': '等待中',
            'pre_op': '术前准备',
            'in_surgery': '手术中',
            'post_op': '术后恢复',
            'completed': '已完成'
        };
        return statusMap[status] || status;
    }
    
    getStatusColor(status: string): ResourceColor {
        const colorMap = {
            'waiting': '#1890ff',
            'pre_op': '#faad14',
            'in_surgery': '#f5222d',
            'post_op': '#13c2c2',
            'completed': '#52c41a'
        };
        return colorMap[status] || '#000';
    }
}

// 状态指示灯组件
@Component
struct StatusLight {
    @Prop status: string;
    
    build() {
        Circle()
            .width(12)
            .height(12)
            .margin({ top: 5, bottom: 5 })
            .fillColor(this.getStatusColor())
    }
    
    getStatusColor(): ResourceColor {
        const colorMap = {
            'idle': '#52c41a',        // 空闲-绿色
            'preparing': '#faad14',   // 准备-黄色
            'in_progress': '#f5222d', // 进行中-红色
            'cleaning': '#1890ff'     // 清洁中-蓝色
        };
        return colorMap[this.status] || '#d9d9d9';
    }
}

4. 叫号通知组件

@Component
struct AnnouncementBoard {
    @Prop messages: string[];
    
    build() {
        Column() {
            Text('最新通知')
                .fontSize(16)
                .fontWeight(FontWeight.Bold)
                .margin({ bottom: 8 })
            
            Divider()
            
            Column() {
                ForEach(this.messages, (msg, index) => {
                    Text(`${index + 1}. ${msg}`)
                        .fontSize(14)
                        .margin({ bottom: 5 })
                })
            }
        }
        .padding(10)
        .backgroundColor('#fff')
        .borderRadius(8)
        .margin({ top: 10, bottom: 10 })
        .shadow({ radius: 2, color: '#ddd' })
    }
}

5. WebSocket服务封装

class SurgeryCallService {
    private static instance: SurgeryCallService;
    private socket: WebSocket | null = null;
    private listeners: ((data: any) => void)[] = [];
    
    private constructor() {}
    
    static getInstance(): SurgeryCallService {
        if (!SurgeryCallService.instance) {
            SurgeryCallService.instance = new SurgeryCallService();
        }
        return SurgeryCallService.instance;
    }
    
    connect(url: string) {
        this.socket = new WebSocket(url);
        
        this.socket.onOpen(() => {
            console.log('手术叫号服务连接已建立');
        });
        
        this.socket.onMessage((event) => {
            const data = JSON.parse(event.data);
            this.notifyListeners(data);
        });
        
        this.socket.onClose(() => {
            console.log('手术叫号服务连接已关闭');
        });
    }
    
    addListener(listener: (data: any) => void) {
        this.listeners.push(listener);
    }
    
    removeListener(listener: (data: any) => void) {
        this.listeners = this.listeners.filter(l => l !== listener);
    }
    
    private notifyListeners(data: any) {
        this.listeners.forEach(listener => listener(data));
    }
    
    sendCallNext(caseId: number) {
        this.socket?.send(JSON.stringify({
            type: 'call_next',
            caseId
        }));
    }
    
    sendEmergency(roomId: number) {
        this.socket?.send(JSON.stringify({
            type: 'emergency',
            roomId
        }));
    }
    
    disconnect() {
        this.socket?.close();
        this.socket = null;
    }
}

项目结构

surgery-call-app/
├── entry/
│   ├── src/
│   │   ├── main/
│   │   │   ├── ets/
│   │   │   │   ├── pages/
│   │   │   │   │   ├── SurgeryCallPage.ets    # 主叫号页面
│   │   │   │   │   ├── RoomDetailPage.ets     # 手术室详情页
│   │   │   │   │   └── ControlPanelPage.ets   # 控制面板页
│   │   │   │   ├── components/
│   │   │   │   │   ├── SurgeryRoomCard.ets    # 手术室卡片
│   │   │   │   │   ├── AnnouncementBoard.ets  # 通知公告板
│   │   │   │   │   ├── StatusLight.ets        # 状态指示灯
│   │   │   │   │   └── HospitalHeader.ets     # 医院标题头
│   │   │   │   ├── model/
│   │   │   │   │   ├── OperatingRoom.ets      # 手术室模型
│   │   │   │   │   └── SurgeryCase.ets        # 手术病例模型
│   │   │   │   ├── services/
│   │   │   │   │   └── SurgeryCallService.ets # 叫号服务
│   │   │   │   ├── app.ets                    # 应用入口
│   │   │   │   └── resources/                 # 资源文件
│   │   │   └── module.json5                   # 模块配置

扩展功能建议

1. ​​多屏互动​​：手术室、等候区、护士站多终端同步
2. ​​语音播报​​：重要通知语音提示
3. ​​家属等候区显示​​：简化版信息展示
4. ​​手术进度预测​​：基于历史数据的智能预测
5. ​​设备状态集成​​：显示手术室设备状态
6. ​​数据统计​​：手术室利用率统计报表

注意事项

1. ​​实时性保障​​：确保WebSocket连接稳定
2. ​​异常处理​​：网络中断时的降级方案
3. ​​数据安全​​：患者信息脱敏处理
4. ​​高可用性​​：7×24小时稳定运行
5. ​​权限控制​​：不同角色操作权限区分

这个手术叫号小程序使用仓颉语言开发，充分利用了HarmonyOS的UI组件和实时通信能力，界面清晰直观，能够有效提升医院手术室管理效率。可根据实际医院需求进行定制化调整。