Cross-Device Sync Ecosystem

A Flutter-based cross-device ecosystem app that syncs clipboard, controls media, and supports file transfer and screen sharing across macOS, Windows, and Android.

🏗️ Architecture

This project follows Clean Architecture principles with a monorepo structure:

cross_device_sync/
├── apps/
│   ├── mobile/          # Android app
│   └── desktop/         # macOS/Windows app
├── packages/
│   ├── core/           # Shared utilities & models
│   ├── clipboard_sync/ # Clipboard synchronization
│   ├── media_control/  # Media control (future)
│   ├── file_transfer/  # File transfer (future)
│   └── networking/     # WebSocket + Firebase (future)
└── melos.yaml          # Monorepo management

Clean Architecture Layers

Each feature module follows Clean Architecture:

• Domain Layer: Business logic, entities, use cases, repository interfaces
• Data Layer: Repository implementations, data sources (local/remote)
• Presentation Layer: UI widgets, state management (Riverpod)
• Platform Layer: Platform channels for native functionality

🚀 Features

✅ Implemented

• Clipboard Sync: Real-time clipboard synchronization across devices
• Clean Architecture: Modular, testable, maintainable code structure
• Dual Sync Modes: Local (WebSocket + mDNS) and Cloud (Firebase)
• Cross-Platform: Flutter apps for mobile and desktop
• State Management: Riverpod for reactive state management
• Unit Tests: Comprehensive test coverage

🔄 Coming Soon

• Media Control: Control media playback across devices
• File Transfer: WebRTC-based file sharing
• Screen Share: Real-time screen sharing with WebRTC + FFmpeg
• Device Discovery: Automatic device discovery via mDNS

🛠️ Tech Stack

• Framework: Flutter 3.10+
• Language: Dart 3.0+
• State Management: Riverpod
• Architecture: Clean Architecture
• Networking: WebSocket (local) + Firebase (cloud)
• Code Generation: Freezed, JSON Serializable
• Testing: Unit tests with Mockito
• Linting: Very Good Analysis

📦 Getting Started

Prerequisites

• Flutter 3.10+
• Dart 3.0+
• Melos (for monorepo management)

Installation

1. Clone the repository

   git clone <repository-url>
   cd cross_device_sync

2. Install Melos

   dart pub global activate melos

3. Bootstrap the project

   melos bootstrap

4. Generate code

   melos run build_runner

Running the Apps

Mobile App (Android)

cd apps/mobile
flutter run

Desktop App (macOS/Windows)

cd apps/desktop
flutter run -d macos  # or -d windows

🧪 Testing

Run all tests:

melos run test

Run tests for specific package:

cd packages/clipboard_sync
flutter test

📱 Usage Example

Clipboard Sync Widget

import 'package:flutter/material.dart';
import 'package:flutter_riverpod/flutter_riverpod.dart';
import 'package:clipboard_sync/clipboard_sync.dart';

class MyApp extends ConsumerWidget {
  @override
  Widget build(BuildContext context, WidgetRef ref) {
    return MaterialApp(
      home: Scaffold(
        body: ClipboardSyncWidget(), // Ready-to-use widget
      ),
    );
  }
}

Manual Clipboard Control

// Start monitoring clipboard changes
final controller = ref.read(clipboardControllerProvider.notifier);
await controller.startMonitoring();

// Sync current clipboard
await controller.syncCurrentClipboard();

// Set clipboard content
await controller.setClipboard("Hello from another device!");

// Listen to clipboard stream
ref.listen(clipboardStreamProvider, (previous, next) {
  next.when(
    data: (content) => print('New clipboard: ${content.content}'),
    loading: () => print('Loading...'),
    error: (error, _) => print('Error: $error'),
  );
});

🏛️ Module Structure

Clipboard Sync Module

packages/clipboard_sync/
├── lib/
│   ├── src/
│   │   ├── domain/
│   │   │   ├── entities/           # ClipboardContent
│   │   │   ├── repositories/       # Abstract interfaces
│   │   │   └── usecases/          # Business logic
│   │   ├── data/
│   │   │   ├── repositories/       # Repository implementations
│   │   │   └── datasources/       # Local/Remote data sources
│   │   ├── presentation/
│   │   │   ├── providers/         # Riverpod providers
│   │   │   └── widgets/           # UI components
│   │   └── platform/
│   │       └── clipboard_platform_channel.dart
│   └── clipboard_sync.dart        # Public API
└── test/                          # Unit tests

🔧 Platform Channels

Each platform requires native implementation:

Android (android/app/src/main/kotlin/)

// TODO: Implement clipboard monitoring
class ClipboardPlugin : MethodCallHandler {
    override fun onMethodCall(call: MethodCall, result: Result) {
        when (call.method) {
            "getClipboard" -> getClipboard(result)
            "setClipboard" -> setClipboard(call, result)
            "startMonitoring" -> startMonitoring(result)
            "stopMonitoring" -> stopMonitoring(result)
        }
    }
}

macOS (macos/Runner/)

// TODO: Implement clipboard monitoring
class ClipboardPlugin: NSObject, FlutterPlugin {
    static func register(with registrar: FlutterPluginRegistrar) {
        // Implementation
    }
}

🚦 Development Workflow

1. Create Feature Branch

   git checkout -b feature/media-control

2. Create New Module

   mkdir -p packages/media_control
   # Follow clipboard_sync structure

3. Add to Melos

   # melos.yaml already configured for packages/**

4. Implement Clean Architecture

   • Domain layer (entities, repositories, use cases)
   • Data layer (repository impl, data sources)
   • Presentation layer (providers, widgets)
   • Platform layer (platform channels)

5. Write Tests

   cd packages/media_control
   flutter test

6. Update Apps

   • Add dependency to apps/mobile/pubspec.yaml
   • Add dependency to apps/desktop/pubspec.yaml
   • Import and use in UI

🔮 Future Roadmap

Phase 2: Media Control

• Spotify-style media source switching
• Play/pause/skip controls
• Volume control
• Now playing information sync

Phase 3: File Transfer

• WebRTC peer-to-peer file transfer
• Drag & drop support
• Progress tracking
• Resume interrupted transfers

Phase 4: Screen Share

• Real-time screen sharing
• WebRTC + FFmpeg integration
• Remote control capabilities
• Multi-monitor support

🤝 Contributing

1. Fork the repository
2. Create a feature branch
3. Follow Clean Architecture principles
4. Write comprehensive tests
5. Submit a pull request

📄 License

This project is licensed under the MIT License - see the LICENSE file for details.

🙏 Acknowledgments

• Flutter team for the amazing framework
• Riverpod for excellent state management
• Clean Architecture principles by Uncle Bob
• Very Good Ventures for analysis rules