Android DEX Documentation

# Clone the repository
git clone https://github.com/Shrey113/Android-Dex.git
cd android_dex

# Install Flutter dependencies
flutter pub get

# Run the desktop app
flutter run -d windows

void main() async {
  WidgetsFlutterBinding.ensureInitialized();
  await dotenv.load(fileName: ".env");

  // Desktop window configuration
  if (Platform.isWindows || Platform.isLinux || Platform.isMacOS) {
    await windowManager.ensureInitialized();

    const windowOptions = WindowOptions(
      size: Size(480, 720),
      minimumSize: Size(400, 640),
      center: true,
      backgroundColor: Color(0xFF0D0D12),
      titleBarStyle: TitleBarStyle.hidden,
    );

    await windowManager.waitUntilReadyToShow(windowOptions, () async {
      await windowManager.show();
      await windowManager.focus();
    });
  }

  // Initialize TCP server for Android communication
  await AdbTcpServer.instance.init();

  runApp(const AndroidDexApp());
}

class AndroidDexApp extends StatelessWidget {
  const AndroidDexApp({super.key});

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'Android DEX',
      debugShowCheckedModeBanner: false,
      theme: _buildTheme(),
      home: const HomeScreen(),
    );
  }

  ThemeData _buildTheme() {
    const primaryColor = Color(0xFF7C4DFF);  // Purple accent
    const surfaceColor = Color(0xFF0D0D12); // Dark background
    const cardColor = Color(0xFF16161D);    // Card background
    // ... theme configuration
  }
}

class AdbTcpServer {
  static final AdbTcpServer instance = AdbTcpServer._internal();
  AdbTcpServer._internal();

  final int tcpPort = 8456;
  final Map<String, Socket> connectedClients = {};

  Future<bool> start() async {
    if (_isRunning) return true;
    try {
      _server = await ServerSocket.bind(InternetAddress.anyIPv4, tcpPort);
      _isRunning = true;
      _statusController.add(true);
      _listenForConnections();
      await _startMdnsService();
      return true;
    } catch (e) {
      return false;
    }
  }
}

Future<(bool, String)> startScrcpy(String ip) async {
  _process = await Process.start(scrcpyFullPath, [
    '-s', ip,                           // Target device
    '--new-display=1920x1080/280',      // Virtual display
    '--no-audio',                       // Audio handled separately
    '--start-app=com.example.androiddex', // Launch DEX app
    '--no-vd-system-decorations',       // Clean desktop look
  ], workingDirectory: scrcpyDir);
  
  _isRunning = true;
  _statusController.add(true);
  return (true, 'Display started');
}

class AdbDevice {
  final String address;      // e.g., "192.168.1.100:5555"
  final String? product;     // e.g., "CPH2447"
  final String? model;       // e.g., "CPH2447"
  final String? device;      // e.g., "OP594DL1"
  final String? transportId; // ADB transport ID

  String get displayName => model ?? device ?? address;
}

from zeroconf import Zeroconf, ServiceInfo

SERVICE_TYPE = "_httpapp._tcp.local."
HTTP_PORT = 5001

def register_mdns_service(zeroconf):
    hostname, ip = get_network_info()
    service_name = f"{ip.replace('.', '_')}_win_server._httpapp._tcp.local."
    
    device_data = {
        "status": "success",
        "device_type": "windows",
        "device_info": {
            "hostname": hostname,
            "ip": ip,
        }
    }
    
    info = ServiceInfo(
        SERVICE_TYPE,
        service_name,
        addresses=[socket.inet_aton(ip)],
        port=HTTP_PORT,
        properties={
            b"host": hostname.encode(),
            b"device_type": b"windows",
            b"ip": ip.encode(),
        },
    )
    zeroconf.register_service(info)

class SimpleAudioProcessManager {
  static final SimpleAudioProcessManager instance = SimpleAudioProcessManager._();
  
  Process? _proc;
  String? _pkg;  // Currently streaming package name

  Future<bool> start(String pkg, List<String> args) async {
    if (_pkg == pkg) return true;  // Already streaming this app
    
    // Stop existing audio stream
    if (_proc != null) {
      _proc!.kill();
      _proc = null;
    }

    // Start new audio stream
    _proc = await Process.start(args[0], args.sublist(1));
    _pkg = pkg;
    return true;
  }
}

class GlassCard extends StatelessWidget {
  final Widget child;
  final EdgeInsets padding;

  @override
  Widget build(BuildContext context) {
    return ClipRRect(
      borderRadius: BorderRadius.circular(16),
      child: BackdropFilter(
        filter: ImageFilter.blur(sigmaX: 10, sigmaY: 10),
        child: Container(
          padding: padding,
          decoration: BoxDecoration(
            color: const Color(0xFF16161D).withValues(alpha: 0.8),
            borderRadius: BorderRadius.circular(16),
            border: Border.all(color: const Color(0xFF2A2A35)),
            boxShadow: [
              BoxShadow(
                color: Colors.black.withValues(alpha: 0.2),
                blurRadius: 16,
                offset: const Offset(0, 8),
              ),
            ],
          ),
          child: child,
        ),
      ),
    );
  }
}

// In Service class
final _statusController = StreamController<bool>.broadcast();
Stream<bool> get statusStream => _statusController.stream;

// Update state
_statusController.add(true);

// In UI (initState)
_serverStatusSubscription = AdbTcpServer.instance.statusStream.listen((isRunning) {
  if (mounted) {
    setState(() => _isServerRunning = isRunning);
  }
});