### Handle SignalR Connection Status Changes in Dart

Source: https://context7.com/as-devs/signalr_flutter/llms.txt

This example demonstrates how to monitor and react to different SignalR connection states. It includes a callback function that handles states such as connecting, connected, reconnecting, disconnected, slow connection, and errors, providing specific actions for each status.

```dart
import 'dart:async';

class SignalRManager {
  late SignalR signalR;
  ConnectionStatus? currentStatus;

  Future<void> initialize() async {
    signalR = SignalR(
      'https://your-server.com/signalr',
      'notificationHub',
      hubMethods: ['onNotification', 'onAlert'],
      statusChangeCallback: _handleStatusChange,
      hubCallback: _handleHubMessage,
      connectionErrorCallback: _handleConnectionError,
    );

    await signalR.connect();
  }

  void _handleStatusChange(ConnectionStatus? status) {
    currentStatus = status;

    switch (status) {
      case ConnectionStatus.connecting:
        print('Establishing connection...');
        break;
      case ConnectionStatus.connected:
        print('Connected successfully');
        _onConnected();
        break;
      case ConnectionStatus.reconnecting:
        print('Attempting to reconnect...');
        break;
      case ConnectionStatus.disconnected:
        print('Disconnected from server');
        _onDisconnected();
        break;
      case ConnectionStatus.connectionSlow:
        print('Connection is experiencing delays');
        break;
      case ConnectionStatus.connectionError:
        print('Connection error occurred');
        break;
      default:
        print('Unknown status');
    }
  }

  void _handleHubMessage(String methodName, String message) {
    print('Hub method called: $methodName');
    if (methodName == 'onNotification') {
      _processNotification(message);
    } else if (methodName == 'onAlert') {
      _processAlert(message);
    }
  }

  void _handleConnectionError(String? errorMessage) {
    print('Connection error details: $errorMessage');
    // Implement retry logic or error reporting
  }

  void _onConnected() {
    // Send any queued messages or sync state
  }

  void _onDisconnected() {
    // Queue messages or update UI
  }

  void _processNotification(String message) {
    // Handle notification logic
  }

  void _processAlert(String message) {
    // Handle alert logic
  }
}
```

--------------------------------

### Configure SignalR Transport Methods in Dart

Source: https://context7.com/as-devs/signalr_flutter/llms.txt

This example demonstrates how to configure the transport mechanism for SignalR connections in Flutter. It shows how to use the default 'auto' transport, explicitly set 'server-sent-events', and force 'long-polling' based on application requirements.

```dart
import 'package:signalr_flutter/signalr_api.dart';

// Use auto transport (default - tries best available)
SignalR autoTransport = SignalR(
  'https://your-server.com/signalr',
  'chatHub',
  transport: Transport.auto,
  statusChangeCallback: (status) => print(status?.name),
  hubCallback: (method, msg) => print(msg),
);

// Force server-sent events
SignalR sseTransport = SignalR(
  'https://your-server.com/signalr',
  'chatHub',
  transport: Transport.serverSentEvents,
  statusChangeCallback: (status) => print(status?.name),
  hubCallback: (method, msg) => print(msg),
);

// Force long polling (most compatible but less efficient)
SignalR longPollingTransport = SignalR(
  'https://your-server.com/signalr',
  'chatHub',
  transport: Transport.longPolling,
  statusChangeCallback: (status) => print(status?.name),
  hubCallback: (method, msg) => print(msg),
);

await autoTransport.connect();
```

--------------------------------

### Stop SignalR Connection Gracefully in Dart

Source: https://context7.com/as-devs/signalr_flutter/llms.txt

This snippet shows how to properly disconnect from a SignalR server and clean up resources. It includes a basic try-catch block for error handling during the stop operation and an example within a Flutter widget's dispose method to ensure the connection is closed when the widget is no longer needed.

```dart
// Disconnect when done
try {
  await signalR.stop();
  print('Successfully disconnected from SignalR server');
} catch (e) {
  print('Error stopping connection: $e');
}

// Example: Stop connection when widget is disposed
class ChatWidget extends StatefulWidget {
  @override
  _ChatWidgetState createState() => _ChatWidgetState();
}

class _ChatWidgetState extends State<ChatWidget> {
  late SignalR signalR;

  @override
  void initState() {
    super.initState();
    signalR = SignalR(
      'https://your-server.com/signalr',
      'chatHub',
      hubMethods: ['onMessage'],
      statusChangeCallback: (status) => print(status?.name),
      hubCallback: (method, message) => print(message),
    );
    signalR.connect();
  }

  @override
  void dispose() {
    signalR.stop();
    super.dispose();
  }

  @override
  Widget build(BuildContext context) {
    return Container();
  }
}
```

--------------------------------

### Initialize and Connect SignalR in Flutter

Source: https://context7.com/as-devs/signalr_flutter/llms.txt

Initializes a SignalR client instance with configuration options such as server URL, hub name, query strings, custom headers, and hub methods. It then establishes a connection to the SignalR server. This is crucial for setting up real-time communication.

```dart
import 'package:signalr_flutter/signalr_flutter.dart';
import 'package:signalr_flutter/signalr_api.dart';

// Initialize SignalR with full configuration
SignalR signalR = SignalR(
  'https://your-server.com/signalr',
  'chatHub',
  queryString: 'user=john&room=lobby',
  headers: {
    'Authorization': 'Bearer your-token-here',
    'X-Custom-Header': 'custom-value'
  },
  hubMethods: ['onMessageReceived', 'onUserJoined', 'onUserLeft'],
  statusChangeCallback: (ConnectionStatus? status) {
    print('Connection status: ${status?.name}');
    if (status == ConnectionStatus.connected) {
      print('Successfully connected to SignalR server');
    } else if (status == ConnectionStatus.connectionError) {
      print('Connection failed');
    }
  },
  hubCallback: (String methodName, String message) {
    print('Method: $methodName, Message: $message');
    // Handle different hub methods
    if (methodName == 'onMessageReceived') {
      // Process incoming chat message
    }
  },
  connectionErrorCallback: (String? errorMessage) {
    print('Connection error: $errorMessage');
  },
);

// Connect to the server
try {
  String? connectionId = await signalR.connect();
  print('Connected with ID: $connectionId');
} catch (e) {
  print('Connection failed: $e');
}
```

--------------------------------

### Initialize and Connect SignalR in Flutter

Source: https://github.com/as-devs/signalr_flutter/blob/master/README.md

Initializes the SignalR client with server URL, hub name, and optional hub methods. It also sets up callbacks for status changes and incoming hub messages. This is the primary step to establish a connection to a SignalR server from a Flutter application.

```dart
SignalR signalR = SignalR(
        '<Your server url here>',
        "<Your hub name here>",
        hubMethods: ["<Your Hub Method Names>"]
        statusChangeCallback: (status) => print(status),
        hubCallback: (methodName, message) => print('MethodName = $methodName, Message = $message'));
signalR.connect();
```

--------------------------------

### Invoke Server Methods with SignalR in Flutter

Source: https://context7.com/as-devs/signalr_flutter/llms.txt

Demonstrates how to invoke server-side hub methods from a Flutter application. It covers invoking methods with no arguments, multiple arguments, and parsing JSON responses from the server. This enables client-initiated actions on the server.

```dart
// Invoke method without arguments
try {
  String result = await signalR.invokeMethod('getServerTime');
  print('Server time: $result');
} catch (e) {
  print('Method invocation failed: $e');
}

// Invoke method with multiple arguments
try {
  String response = await signalR.invokeMethod(
    'sendMessage',
    arguments: ['Hello from Flutter!', 'john', 'lobby']
  );
  print('Server response: $response');
} catch (e) {
  print('Failed to send message: $e');
}

// Invoke method and parse JSON response
try {
  String jsonResult = await signalR.invokeMethod('getUserData', arguments: ['user123']);
  // Parse JSON string to object
  Map<String, dynamic> userData = jsonDecode(jsonResult);
  print('User name: ${userData['name']}');
  print('User email: ${userData['email']}');
} catch (e) {
  print('Error: $e');
}
```

--------------------------------

### Flutter SignalR Chat App Implementation

Source: https://context7.com/as-devs/signalr_flutter/llms.txt

This Dart code implements a SignalR client in a Flutter application. It handles connection management, message sending, and receiving, updating the UI in real-time. Dependencies include flutter, signalr_flutter, and signalr_api. It takes no direct input but interacts with a SignalR server endpoint.

```dart
import 'package:flutter/material.dart';
import 'package:signalr_flutter/signalr_flutter.dart';
import 'package:signalr_flutter/signalr_api.dart';

void main() => runApp(MyApp());

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'SignalR Flutter Demo',
      home: ChatPage(),
    );
  }
}

class ChatPage extends StatefulWidget {
  @override
  _ChatPageState createState() => _ChatPageState();
}

class _ChatPageState extends State<ChatPage> {
  late SignalR signalR;
  String connectionStatus = 'Disconnected';
  List<String> messages = [];
  TextEditingController messageController = TextEditingController();

  @override
  void initState() {
    super.initState();
    _initializeSignalR();
  }

  void _initializeSignalR() {
    signalR = SignalR(
      'https://your-server.com/signalr',
      'chatHub',
      queryString: 'username=FlutterUser',
      headers: {'Authorization': 'Bearer token123'},
      hubMethods: ['receiveMessage', 'userConnected', 'userDisconnected'],
      statusChangeCallback: (ConnectionStatus? status) {
        if (mounted) {
          setState(() {
            connectionStatus = status?.name ?? 'Unknown';
          });
        }
      },
      hubCallback: (String methodName, String message) {
        if (mounted) {
          setState(() {
            messages.add('[$methodName] $message');
          });
        }
      },
      connectionErrorCallback: (String? error) {
        print('Connection error: $error');
      },
    );
  }

  Future<void> _toggleConnection() async {
    bool connected = await signalR.isConnected();
    if (!connected) {
      try {
        String? connectionId = await signalR.connect();
        print('Connected: $connectionId');
      } catch (e) {
        print('Connection failed: $e');
      }
    } else {
      await signalR.stop();
    }
  }

  Future<void> _sendMessage() async {
    if (messageController.text.isEmpty) return;

    try {
      String result = await signalR.invokeMethod(
        'sendMessage',
        arguments: [messageController.text, 'FlutterUser'],
      );
      messageController.clear();
      print('Message sent: $result');
    } catch (e) {
      print('Failed to send message: $e');
    }
  }

  @override
  void dispose() {
    signalR.stop();
    messageController.dispose();
    super.dispose();
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: Text('SignalR Chat'),
        actions: [
          Center(
            child: Padding(
              padding: EdgeInsets.only(right: 16.0),
              child: Text(
                connectionStatus,
                style: TextStyle(fontSize: 14),
              ),
            ),
          ),
        ],
      ),
      body: Column(
        children: [
          Expanded(
            child: ListView.builder(
              itemCount: messages.length,
              itemBuilder: (context, index) {
                return ListTile(
                  title: Text(messages[index]),
                );
              },
            ),
          ),
          Padding(
            padding: EdgeInsets.all(8.0),
            child: Row(
              children: [
                Expanded(
                  child: TextField(
                    controller: messageController,
                    decoration: InputDecoration(
                      hintText: 'Type a message...', 
                      border: OutlineInputBorder(),
                    ),
                  ),
                ),
                SizedBox(width: 8),
                ElevatedButton(
                  onPressed: _sendMessage,
                  child: Text('Send'),
                ),
              ],
            ),
          ),
        ],
      ),
      floatingActionButton: FloatingActionButton(
        onPressed: _toggleConnection,
        child: Icon(Icons.power_settings_new),
        tooltip: 'Toggle Connection',
      ),
    );
  }
}

```

--------------------------------

### Invoke Server Method using SignalR in Flutter

Source: https://github.com/as-devs/signalr_flutter/blob/master/README.md

Invokes a specified method on the SignalR server with provided arguments. This allows clients to send data or trigger actions on the server-side through the SignalR connection.

```dart
signalR.invokeMethod("<Your method name here>", arguments: ["argument1", "argument2"]);
```

--------------------------------

### Enable Cleartext Traffic for HTTP in Android Manifest

Source: https://github.com/as-devs/signalr_flutter/blob/master/README.md

Configures the Android application to allow cleartext network traffic. This is necessary when connecting to a SignalR server using an HTTP URL, as per Android's Network Security Configuration guidelines.

```xml
<application
        android:usesCleartextTraffic="true">
</application>
```

--------------------------------

### Keep SignalR Classes for R8/ProGuard in Android

Source: https://github.com/as-devs/signalr_flutter/blob/master/README.md

Specifies rules for R8 or ProGuard to prevent the stripping of essential SignalR client classes during release builds on Android. This ensures that the SignalR functionality remains intact in the compiled application.

```proguard
-keep class microsoft.aspnet.signalr.client.hubs.** { *; }
```

--------------------------------

### Check and Reconnect SignalR Connection in Flutter

Source: https://context7.com/as-devs/signalr_flutter/llms.txt

Checks the current connection status of the SignalR client and provides functionality to attempt reconnection if the connection is lost. This ensures a robust real-time communication channel.

```dart
// Check if currently connected
bool isConnected = await signalR.isConnected();

if (isConnected) {
  print('SignalR is connected');
  // Safe to invoke methods or send data
} else {
  print('SignalR is disconnected');
  // Attempt to reconnect
  try {
    String? connectionId = await signalR.reconnect();
    print('Reconnected with ID: $connectionId');
  } catch (e) {
    print('Reconnection failed: $e');
  }
}
```

--------------------------------

### Auto-Reconnect SignalR on Disconnection in Flutter

Source: https://context7.com/as-devs/signalr_flutter/llms.txt

Configures the SignalR client to automatically attempt reconnection when the connection is lost. It utilizes the `statusChangeCallback` to detect disconnections and initiate a reconnect sequence after a short delay. This ensures persistent real-time updates.

```dart
// Monitor connection and auto-reconnect
SignalR signalR = SignalR(
  'https://your-server.com/signalr',
  'chatHub',
  statusChangeCallback: (ConnectionStatus? status) async {
    if (status == ConnectionStatus.disconnected) {
      print('Connection lost, attempting to reconnect...');
      await Future.delayed(Duration(seconds: 2));
      try {
        String? newConnectionId = await signalR.reconnect();
        print('Reconnected with ID: $newConnectionId');
      } catch (e) {
        print('Reconnection failed: $e');
      }
    } else if (status == ConnectionStatus.connectionSlow) {
      print('Connection is slow');
    }
  },
  hubCallback: (String methodName, String message) {
    print('Received: $methodName - $message');
  },
);

await signalR.connect();
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.