HMG_QLine/README.md

# HMG_QLine

HMG_QLine is a Flutter-based application designed for efficient patient management and queue handling in healthcare environments. It features multiple screens for patient display, robust logging, and
background service integration to ensure reliability and uptime.

## Features

- Patient queue management across all screens
- Foreground service to monitor app state and auto-reopen if terminated or backgrounded
- SignalR integration for real-time updates
- Persistent logging with automatic log file rotation
- Dynamic app versioning
- Modular architecture with ViewModels and Services

## Getting Started

### Prerequisites

- Flutter SDK (>=3.0.0)
- Dart (>=2.17.0)
- Android Studio or Xcode for platform-specific builds

### Installation

1. Clone the repository:
   ```bash
   git clone https://github.com/your-org/HMG_QLine.git
   cd HMG_QLine
   ```
2. Install dependencies:
   ```bash
   flutter pub get
   ```
3. Run the app:
   ```bash
   flutter run
   ```

## Project Structure

- `lib/` - Main source code
    - `api/` - API integration
    - `config/` - Configuration files
    - `constants/` - App-wide constants
    - `models/` - Data models
    - `repositories/` - Data repositories
    - `services/` - Business logic and background services
    - `utilities/` - Utility functions
    - `view_models/` - State management
    - `views/` - UI screens
- `assets/` - Fonts, images, icons, and tones
- `android/`, `ios/`, `macos/`, `linux/`, `windows/` - Platform-specific code

## Logging

- Logs are saved in the device's external storage under `/logs/`
- Log files are rotated every 48 hours
- Each log entry includes a timestamp, source, and type

## Foreground Service

- Monitors app lifecycle
- Automatically reopens or restarts the app if terminated or sent to background
- Checks app status every minute

## SignalR Integration

- Reconnects automatically after disconnection
- Ensures real-time updates for patient queues

## Debugging

- Debuggable builds can be enabled in `android/app/build.gradle` for troubleshooting

## Contributing

Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.

## License

This project is licensed under the MIT License.







# Queuing System Shell Scripts

This repository contains a set of shell scripts for managing Android devices running the HMG QLine application in a multi-device hospital environment. The scripts automate deployment, logging, restarting, and uninstallation tasks for efficient device management.

## Features
- **Deploy APKs:** Install and launch specific versions of the QLine app on multiple devices.
- **Restart App:** Force-stop and relaunch the QLine app on all connected devices.
- **Uninstall App:** Remove the QLine app from all connected devices.
- **Extract Logs:** Pull log files from devices for troubleshooting and analysis.
- **Device Connection:** Automatically connect to devices over Wi-Fi using IP addresses.

## Folder Structure
```
queuing_system/
├── apks/                # APK files for different QLine app versions
├── logs/                # Data logs from devices
├── connect_devices.sh   # Script to connect to devices
├── deploy_qline.sh      # Script to deploy APKs
├── device_ips.txt       # List of device IP addresses
├── extract_logs.sh      # Script to extract logs from devices
├── restart_qline.sh     # Script to restart the app on devices
├── uninstall_qline.sh   # Script to uninstall the app
```

## Getting Started
1. **Clone the repository:**
   ```bash
   git clone <repo-url>
   cd queuing_system 
   ```
2. **Configure device IPs:**
    - Add device IPs to a file (e.g., `device_ips_all.txt`), one per line.
3. **Prepare APKs:**
    - Place APK files in the `apks/` folder, named as per the versioning scheme.
4. **Run scripts:**
    - Make scripts executable: `chmod +x *.sh`
    - Example: Deploy APKs
      ```bash
      ./deploy_qline.sh
      ```
    - Example: Extract logs from a device
      ```bash
      sh extract_logs.sh -ip <device_ip:port>
      ```

## Script Commands (One by One)
Use the commands below with the appropriate IP list file.

### Connect Devices
```bash
sh connect_devices.sh -ipfile device_ips_all.txt
```

### Deploy QLine APK
```bash
sh deploy_qline.sh -ipfile device_ips_all.txt -version 9.2
```

**Deploy to Single IP:**
```bash
echo "10.70.6.143" > temp_ip.txt
sh deploy_qline.sh -ipfile temp_ip.txt -version 9.2
rm temp_ip.txt
```

### Restart QLine App
```bash
sh restart_qline.sh -ipfile device_ips_all.txt
```

### Uninstall QLine App
```bash
sh uninstall_qline.sh -ipfile device_ips_all.txt
```

### Extract Logs (Single Device)
```bash
sh extract_logs.sh -ip <device_ip:port>
```

### Extract Logs (All Devices)
```bash
sh extract_all_logs.sh -ipfile device_ips_all.txt
```

### Clear Logs (Single Device)
```bash
sh clear_logs.sh -ip <device_ip:port>
```

### Clear Logs (All Devices)
```bash
sh clear_logs_all.sh -ipfile device_ips_all.txt
```

### Kill QLine App (All Devices)
```bash
sh kill_qline.sh -ipfile device_ips_all.txt
```

## Requirements
- macOS (tested)
- Android SDK Platform Tools (adb)
- Wi-Fi connection to devices

## Notes
- Ensure all devices are on the same Wi-Fi network (`Cloud Solutions`).
- APKs and logs are ignored from version control via `.gitignore`.
- Scripts are designed for hospital multi-floor deployments but can be adapted for other environments.

## License
MIT License