Flutter会话管理插件sessionful的使用

Flutter会话管理插件sessionful的使用

Sessionful

什么是它？

这是一个库，允许你通过单一字节流创建多个通信通道。这使得可以创建独立于彼此的小型上下文会话。会话对象与负载无关。编码和解码负载超出了此包的范围。

支持的功能

API非常简单且仅限于我所需的功能。将来可能会（或可能不会）扩展，如果您有任何建议，欢迎在GitHub上提交PR或FR。

• 使用自动生成的会话ID创建会话。
• 检测传入的新会话。
• 能够按需终止会话（发送方和接收方都可以）。
• 推拉支持（发送并请求响应）。
• 推+拉支持（发送时不等待响应，随时读取响应）。
• 检查会话中是否有任何等待的数据。

如何使用

请参考示例以了解其基本工作原理。单元测试提供了更多使用示例。

示例代码

import 'dart:convert';
import 'dart:typed_data';

import 'package:sessionful/sessionful.dart';

class Client {
  final String name;
  late final SessionsDispatcher dispatcher;
  final List<Session> sessions = [];

  Client(this.name, AttachableSink incomingData, AttachableSink outgoingData) {
    dispatcher = SessionsDispatcher(
        outputSink: outgoingData,
        onNewSessionDiscovered: (session) {
          print("[$name] new session with id ${session.sessionId}");
          sessions.add(session);
        },
        onSessionTerminated: (session) {
          print("[$name] Terminate session with id ${session.sessionId}");
          sessions.removeWhere((e) => e.sessionId == session.sessionId);
        });
    incomingData.destination = dispatcher;
  }

  /// Try to send in specified session, if session not exist create new one (id will be generated)
  int sendInSession(int sessionId, String data) {
    Session? session = _getSessionById(sessionId);
    if (session == null) {
      session = dispatcher.createSession();
      sessions.add(session);
    }
    final payload = utf8.encoder.convert(data);
    session.push([payload]);
    return session.sessionId;
  }

  String? readFromSession(int sessionId) {
    String? result;
    Session? session = _getSessionById(sessionId);
    final payload = session?.maybePull();
    if (payload != null) {
      result = utf8.decoder.convert(payload);
    }
    return result;
  }

  /// Get session by its id
  Session? _getSessionById(int sessionId) {
    Session? session;
    for (var s in sessions) {
      if (s.sessionId == sessionId) {
        session = s;
        break;
      }
    }
    return session;
  }
}

/// A sink that can be attached to another sink.
class AttachableSink implements Sink<Uint8List> {
  Sink<Uint8List>? destination;

  [@override](/user/override)
  void add(Uint8List data) => destination?.add(data);

  [@override](/user/override)
  void close() => destination?.close();
}

/// A class representing a transport mechanism.
class Transport {
  final AttachableSink fromClientAToB = AttachableSink();
  final AttachableSink fromClientBToA = AttachableSink();
}

void main() {
  final transport = Transport();
  final clientA = Client("A", transport.fromClientAToB, transport.fromClientBToA);
  final clientB = Client("B", transport.fromClientBToA, transport.fromClientAToB);

  // 发送数据到两个不同的会话
  final sessionId1 = clientA.sendInSession(-1, "This text is send in session 1");
  final sessionId2 = clientA.sendInSession(-1, "This text is send in session 2");

  // 客户端B读取来自客户端A的数据
  for (Session s in clientB.sessions) {
    final incomingText = clientB.readFromSession(s.sessionId);
    print("ClientB [Session ${s.sessionId}] got text: $incomingText");
  }

  // 客户端B向客户端A发送响应
  clientB.sendInSession(clientB.sessions.first.sessionId, "This is response");

  // 客户端A读取响应
  final incomingText = clientA.readFromSession(sessionId1);
  print("ClientA [Session $sessionId1] got response: $incomingText");
}