signalr_client

Description:

signalr client

signalr_client #

A Flutter SignalR Client for ASP.NET Core.
ASP.NET Core SignalR is an open-source library that simplifies adding real-time web functionality to apps. Real-time web functionality enables server-side code to push content to clients instantly.
The client is able to invoke server side hub functions (including streaming functions) and to receive method invocations issued by the server.
The client supports the following transport protocols:

WebSocket
Service Side Events
Long Polling

The client supports the following hub protocols:

Json
MessagePack - Since I can't find a MessagePack library that support the current flutter version.

Examples #

Chat client/server - A simple client/server chat application.
Integration test app - To see how a client calls various types of hub functions.

Getting Started #
Add signalr_client to your pubspec.yaml dependencies:
...
dependencies:
flutter:
sdk: flutter

signalr_client:
...
copied to clipboard
Usage #
Let's demo some basic usages:
1. Create a hub connection:
// Import the library.
import 'package:signalr_client/signalr_client.dart';

// The location of the SignalR Server.
final serverUrl = "192.168.10.50:51001";
// Creates the connection by using the HubConnectionBuilder.
final hubConnection = HubConnectionBuilder().withUrl(serverUrl).build();
// When the connection is closed, print out a message to the console.
final hubConnection.onclose( (error) => print("Connection Closed"));

copied to clipboard
Logging is supported via the dart logging package:
// Import theses libraries.
import 'package:logging/logging.dart';
import 'package:signalr_client/signalr_client.dart';

// Configer the logging
Logger.root.level = Level.ALL;
// Writes the log messages to the console
Logger.root.onRecord.listen((LogRecord rec) {
print('${rec.level.name}: ${rec.time}: ${rec.message}');
});

// If you want only to log out the message for the higer level hub protocol:
final hubProtLogger = Logger("SignalR - hub");
// If youn want to also to log out transport messages:
final transportProtLogger = Logger("SignalR - transport");

// The location of the SignalR Server.
final serverUrl = "192.168.10.50:51001";
final connectionOptions = HttpConnectionOptions
final httpOptions = new HttpConnectionOptions(logger: transportProtLogger);
//final httpOptions = new HttpConnectionOptions(logger: transportProtLogger, transport: HttpTransportType.WebSockets); // default transport type.
//final httpOptions = new HttpConnectionOptions(logger: transportProtLogger, transport: HttpTransportType.ServerSentEvents);
//final httpOptions = new HttpConnectionOptions(logger: transportProtLogger, transport: HttpTransportType.LongPolling);

// If you need to authorize the Hub connection than provide a an async callback function that returns
// the token string (see AccessTokenFactory typdef) and assigned it to the accessTokenFactory parameter:
// final httpOptions = new HttpConnectionOptions( .... accessTokenFactory: () async => await getAccessToken() );

// Creates the connection by using the HubConnectionBuilder.
final hubConnection = HubConnectionBuilder().withUrl(serverUrl, options: httpOptions).configureLogging(hubProtLogger).build();
// When the connection is closed, print out a message to the console.
final hubConnection.onclose( (error) => print("Connection Closed"));

copied to clipboard
2. Connect to a Hub:
Calling following method starts handshaking and connects the client to SignalR server
await hubConnection.start();
copied to clipboard
3. Calling a Hub function:
Assuming there is this hub function:
public string MethodOneSimpleParameterSimpleReturnValue(string p1)
{
Console.WriteLine($"'MethodOneSimpleParameterSimpleReturnValue' invoked. Parameter value: '{p1}");
return p1;
}
copied to clipboard
The client can invoke the function by using:

final result = await hubConnection.invoke("MethodOneSimpleParameterSimpleReturnValue", args: <Object>["ParameterValue"]);
logger.log(LogLevel.Information, "Result: '$result");

copied to clipboard
4. Calling a client function:
Assuming the server calls a function "aClientProvidedFunction":
await Clients.Caller.SendAsync("aClientProvidedFunction", null);
copied to clipboard
The Client provides the function like this:

hubConnection.on("aClientProvidedFunction", _handleAClientProvidedFunction);

// To unregister the function use:
// a) to unregister a specific implementation:
// hubConnection.off("aClientProvidedFunction", method: _handleServerInvokeMethodNoParametersNoReturnValue);
// b) to unregister all implementations:
// hubConnection.off("aClientProvidedFunction");
...
void _handleAClientProvidedFunction(List<Object> parameters) {
logger.log(LogLevel.Information, "Server invoked the method");
}

copied to clipboard
A note about the parameter types #
All function parameters and return values are serialized/deserialized into/from JSON by using the dart:convert package (json.endcode/json.decode). Make sure that you:

use only simple parameter types

or

use objects that implements toJson() since that method is used by the dart:convert package to serialize an object.

Flutter Json 101:

flutter.io
json.encode
json.decode