Dart Server Token Utils Like This needed in official documentation

```
import 'dart:convert';
import 'dart:math';
import 'dart:typed_data';
import 'package:encrypt/encrypt.dart' as encrypt;

class ZegoCloundService {
static String generateToken04(
int appID,
String userID,
String secret,
int effectiveTimeInSeconds,
String payload,
) {
if (appID == 0) {
throw ArgumentError('appID invalid');
}

if (userID.isEmpty) {
throw ArgumentError('userID invalid');
}

if (secret.length != 32) {
throw ArgumentError('secret must be a 32 byte string');
}

if (effectiveTimeInSeconds <= 0) {
throw ArgumentError('effectiveTimeInSeconds invalid');
}

final thirdToken = _makeThirdToken(appID, userID, effectiveTimeInSeconds, payload);

final strPlainText = jsonEncode(thirdToken);
final strIv = _makeRandomString(16);

final encrypted = _aesEncrypt(strPlainText, secret, strIv);
if (encrypted == null) {
throw Exception('Encryption failed');
}

final resultSize = encrypted.length + 28;
final resultBuffer = Uint8List(resultSize);

_packInt64(resultBuffer, 0, thirdToken['expire']);
_packString(resultBuffer, 8, strIv);
_packByteArray(resultBuffer, 26, encrypted);

return '04${base64Encode(resultBuffer)}';
}

static Map _makeThirdToken(
int appID, String userID, int effectiveTimeInSeconds, String payload) {
final now = DateTime.now().toUtc().millisecondsSinceEpoch ~/ 1000;
final expire = now + effectiveTimeInSeconds;
final random = Random(DateTime.now().microsecondsSinceEpoch);
final nonce = random.nextInt(0x7fffffff);

return {
'app_id': appID,
'user_id': userID,
'payload': payload,
'ctime': now,
'expire': expire,
'nonce': nonce,
};
}

static String _makeRandomString(int length) {
const chars = '0123456789abcdefghijklmnopqrstuvwxyz';
final rand = Random(DateTime.now().microsecondsSinceEpoch);
return List.generate(length, (index) => chars[rand.nextInt(chars.length)]).join();
}

static Uint8List? _aesEncrypt(String plainText, String key, String iv) {
try {
final encrypter = encrypt.Encrypter(
encrypt.AES(
encrypt.Key.fromUtf8(key),
mode: encrypt.AESMode.cbc,
padding: 'PKCS7',
),
);
final encrypted = encrypter.encrypt(
plainText,
iv: encrypt.IV.fromUtf8(iv),
);
return encrypted.bytes;
} catch (e) {
return null;
}
}

static void _packInt16(Uint8List result, int start, int value) {
final data = ByteData(2)..setInt16(0, value, Endian.big);
result.setRange(start, start + 2, data.buffer.asUint8List());
}

static void _packInt64(Uint8List result, int start, int value) {
final data = ByteData(8)..setInt64(0, value, Endian.big);
result.setRange(start, start + 8, data.buffer.asUint8List());
}

static void _packString(Uint8List result, int start, String value) {
_packInt16(result, start, value.length);
result.setRange(start + 2, start + 2 + value.length, utf8.encode(value));
}

static void _packByteArray(Uint8List result, int start, List value) {
_packInt16(result, start, value.length);
result.setRange(start + 2, start + 2 + value.length, value);
}
}

```