https://github.com/alexcmgit/simple-socket
A simple library to work with Dart sockets.
https://github.com/alexcmgit/simple-socket
dart library package real socket tcp time
Last synced: 9 months ago
JSON representation
A simple library to work with Dart sockets.
- Host: GitHub
- URL: https://github.com/alexcmgit/simple-socket
- Owner: alexrintt
- License: mit
- Created: 2023-02-01T22:20:24.000Z (over 3 years ago)
- Default Branch: master
- Last Pushed: 2023-09-11T06:59:56.000Z (almost 3 years ago)
- Last Synced: 2024-12-29T23:53:16.430Z (over 1 year ago)
- Topics: dart, library, package, real, socket, tcp, time
- Language: Dart
- Homepage:
- Size: 14.6 KB
- Stars: 4
- Watchers: 2
- Forks: 0
- Open Issues: 1
-
Metadata Files:
- Readme: README.md
- Changelog: CHANGELOG.md
- License: LICENSE
Awesome Lists containing this project
README
# Simple socket library for Dart
A simple library to work with Dart sockets.
The [socket-io NodeJS port for Dart](https://github.com/rikulo/socket.io-client-dart) is pretty good but it has missing type definitions and I don't like to work with `dynamic` data type. Also, it is pretty heavy, I don't need all that stuff, all I want is to make sure I have a minimal intuitive library that I can work on top of Dart socket classes without worrying about leaking the memory because I forgot the 9th Stream listener opened.
Current implemented features:
- Server-side supported.
- Client-side supported.
- Message-framing through `send` APIs.
- Fully-typed API although optional.
- Lightweight: less than 400 lines of code.
- Event-driven callbacks.
- Custom event types.
Basic usage:
```dart
final SimpleServerSocket server = await SimpleServerSocket.bind();
server.on('connection', (SimpleSocket client) {
// or: client.sendMessage('hello', 'Hi, client.');
client.sendSignal('hello');
client.on('bye', (_) => server.destroy());
});
server.listen();
// On client-side:
final SimpleSocket socket =
await SimpleSocket.connect('localhost', server.port);
socket.on('hello', (_) => socket.replyWithSignal('bye'));
```
Using messages:
```dart
final SimpleServerSocket server = await SimpleServerSocket.bind();
server.on('connection', (SimpleSocket client) {
client.sendMessage('greetings', 'Sup client!');
client.on>('bye', (List data) {
print(String.fromCharCodes(data)); // Bye bye...
server.destroy();
});
});
server.listen();
// On client-side:
final SimpleSocket socket =
await SimpleSocket.connect('localhost', server.port);
socket.on>('greetings', (List data) {
print(String.fromCharCodes(data)); // Sup client!
socket.reply('bye', 'Bye bye...');
});
```
That's what looks like working with raw Dart sockets.
```dart
final ServerSocket server =
await ServerSocket.bind(InternetAddress.anyIPv4, 0);
late final StreamSubscription onNewClientListener;
Future closeServer() async {
await onNewClientListener.cancel();
await server.close();
}
onNewClientListener = server.listen(
(Socket client) {
late final StreamSubscription onNewMessageListener;
Future cancelListener() async {
await onNewMessageListener.cancel();
}
client.write('Sup client!');
onNewMessageListener = client.map(String.fromCharCodes).listen(
// No TCP messaging-frame support!
(String message) {
print(message);
if (message == 'bye') {
client.close();
closeServer();
}
},
cancelOnError: true,
onDone: cancelListener,
onError: (_) => cancelListener(),
);
},
cancelOnError: true,
onDone: closeServer,
onError: (_) => closeServer(),
);
// On client-side.
final Socket socket = await Socket.connect('localhost', server.port);
late final StreamSubscription onNewServerMessageListener;
Future cancelListener() async {
socket.destroy();
await socket.close();
await onNewServerMessageListener.cancel();
}
onNewServerMessageListener = socket.map(String.fromCharCodes).listen(
// No TCP messaging-frame support!
(String message) {
if (message.startsWith('Sup')) {
print(message);
socket.write('bye');
}
},
cancelOnError: true,
onDone: cancelListener,
onError: (_) => cancelListener(),
);
```
## Further reading
- Message Framing - .
- How to create TCP message framing for the stream - .
- Dart TCP socket concatenates all 'write' sync calls as a single packet - .
Open Source
Copyright © 2023-present, Alex Rintt.
Simple Socket is MIT licensed 💖
