You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
627 lines
24 KiB
627 lines
24 KiB
import 'dart:developer';
|
|
import 'dart:io';
|
|
|
|
import 'package:flutter/services.dart';
|
|
import 'package:flutter_openim_sdk/flutter_openim_sdk.dart';
|
|
import 'package:flutter_openim_sdk/src/logger.dart';
|
|
|
|
class IMManager {
|
|
MethodChannel _channel;
|
|
late ConversationManager conversationManager;
|
|
late FriendshipManager friendshipManager;
|
|
late MessageManager messageManager;
|
|
late GroupManager groupManager;
|
|
late UserManager userManager;
|
|
|
|
// late OfflinePushManager offlinePushManager;
|
|
late SignalingManager signalingManager;
|
|
|
|
// late WorkMomentsManager workMomentsManager;
|
|
// late OrganizationManager organizationManager;
|
|
|
|
late OnConnectListener _connectListener;
|
|
OnListenerForService? _listenerForService;
|
|
OnPutFileListener? _putFileListener;
|
|
late String userID;
|
|
late UserInfo userInfo;
|
|
bool isLogined = false;
|
|
String? token;
|
|
String? _objectStorage;
|
|
|
|
IMManager(this._channel) {
|
|
conversationManager = ConversationManager(_channel);
|
|
friendshipManager = FriendshipManager(_channel);
|
|
messageManager = MessageManager(_channel);
|
|
groupManager = GroupManager(_channel);
|
|
userManager = UserManager(_channel);
|
|
// offlinePushManager = OfflinePushManager(_channel);
|
|
signalingManager = SignalingManager(_channel);
|
|
// workMomentsManager = WorkMomentsManager(_channel);
|
|
// organizationManager = OrganizationManager(_channel);
|
|
_addNativeCallback(_channel);
|
|
}
|
|
|
|
void _addNativeCallback(MethodChannel _channel) {
|
|
_channel.setMethodCallHandler((call) {
|
|
try {
|
|
Logger.print('Flutter : $call');
|
|
if (call.method == ListenerType.connectListener) {
|
|
String type = call.arguments['type'];
|
|
switch (type) {
|
|
case 'onConnectFailed':
|
|
int? errCode = call.arguments['errCode'];
|
|
String? errMsg = call.arguments['errMsg'];
|
|
_connectListener.connectFailed(errCode, errMsg);
|
|
break;
|
|
case 'onConnecting':
|
|
_connectListener.connecting();
|
|
break;
|
|
case 'onConnectSuccess':
|
|
_connectListener.connectSuccess();
|
|
break;
|
|
case 'onKickedOffline':
|
|
_connectListener.kickedOffline();
|
|
break;
|
|
case 'onUserTokenExpired':
|
|
_connectListener.userTokenExpired();
|
|
break;
|
|
}
|
|
} else if (call.method == ListenerType.userListener) {
|
|
String type = call.arguments['type'];
|
|
dynamic data = call.arguments['data'];
|
|
switch (type) {
|
|
case 'onSelfInfoUpdated':
|
|
userInfo = Utils.toObj(data, (map) => UserInfo.fromJson(map));
|
|
userManager.listener.selfInfoUpdated(userInfo);
|
|
break;
|
|
}
|
|
} else if (call.method == ListenerType.groupListener) {
|
|
String type = call.arguments['type'];
|
|
dynamic data = call.arguments['data'];
|
|
switch (type) {
|
|
case 'onGroupApplicationAccepted':
|
|
final i = Utils.toObj(
|
|
data, (map) => GroupApplicationInfo.fromJson(map));
|
|
groupManager.listener.groupApplicationAccepted(i);
|
|
break;
|
|
case 'onGroupApplicationAdded':
|
|
final i = Utils.toObj(
|
|
data, (map) => GroupApplicationInfo.fromJson(map));
|
|
groupManager.listener.groupApplicationAdded(i);
|
|
break;
|
|
case 'onGroupApplicationDeleted':
|
|
final i = Utils.toObj(
|
|
data, (map) => GroupApplicationInfo.fromJson(map));
|
|
groupManager.listener.groupApplicationDeleted(i);
|
|
break;
|
|
case 'onGroupApplicationRejected':
|
|
final i = Utils.toObj(
|
|
data, (map) => GroupApplicationInfo.fromJson(map));
|
|
groupManager.listener.groupApplicationRejected(i);
|
|
break;
|
|
case 'onGroupDismissed':
|
|
final i = Utils.toObj(data, (map) => GroupInfo.fromJson(map));
|
|
groupManager.listener.groupDismissed(i);
|
|
break;
|
|
case 'onGroupInfoChanged':
|
|
final i = Utils.toObj(data, (map) => GroupInfo.fromJson(map));
|
|
groupManager.listener.groupInfoChanged(i);
|
|
break;
|
|
case 'onGroupMemberAdded':
|
|
final i =
|
|
Utils.toObj(data, (map) => GroupMembersInfo.fromJson(map));
|
|
groupManager.listener.groupMemberAdded(i);
|
|
break;
|
|
case 'onGroupMemberDeleted':
|
|
final i =
|
|
Utils.toObj(data, (map) => GroupMembersInfo.fromJson(map));
|
|
groupManager.listener.groupMemberDeleted(i);
|
|
break;
|
|
case 'onGroupMemberInfoChanged':
|
|
final i =
|
|
Utils.toObj(data, (map) => GroupMembersInfo.fromJson(map));
|
|
groupManager.listener.groupMemberInfoChanged(i);
|
|
break;
|
|
case 'onJoinedGroupAdded':
|
|
final i = Utils.toObj(data, (map) => GroupInfo.fromJson(map));
|
|
groupManager.listener.joinedGroupAdded(i);
|
|
break;
|
|
case 'onJoinedGroupDeleted':
|
|
final i = Utils.toObj(data, (map) => GroupInfo.fromJson(map));
|
|
groupManager.listener.joinedGroupDeleted(i);
|
|
break;
|
|
}
|
|
} else if (call.method == ListenerType.advancedMsgListener) {
|
|
var type = call.arguments['type'];
|
|
// var id = call.arguments['data']['id'];
|
|
switch (type) {
|
|
case 'onMsgDeleted':
|
|
var value = call.arguments['data']['message'];
|
|
final msg = Utils.toObj(value, (map) => Message.fromJson(map));
|
|
messageManager.msgListener.msgDeleted(msg);
|
|
break;
|
|
case 'onNewRecvMessageRevoked':
|
|
var value = call.arguments['data']['messageRevoked'];
|
|
var info = Utils.toObj(value, (map) => RevokedInfo.fromJson(map));
|
|
messageManager.msgListener.newRecvMessageRevoked(info);
|
|
break;
|
|
case 'onRecvC2CReadReceipt':
|
|
var value = call.arguments['data']['msgReceiptList'];
|
|
var list =
|
|
Utils.toList(value, (map) => ReadReceiptInfo.fromJson(map));
|
|
messageManager.msgListener.recvC2CReadReceipt(list);
|
|
break;
|
|
case 'onRecvGroupReadReceipt':
|
|
var value = call.arguments['data']['groupMsgReceiptList'];
|
|
var list =
|
|
Utils.toList(value, (map) => ReadReceiptInfo.fromJson(map));
|
|
messageManager.msgListener.recvGroupReadReceipt(list);
|
|
break;
|
|
case 'onRecvMessageExtensionsAdded':
|
|
var msgID = call.arguments['data']['msgID'];
|
|
var value = call.arguments['data']['reactionExtensionList'];
|
|
var list = Utils.toList(value, (map) => KeyValue.fromJson(map));
|
|
messageManager.msgListener
|
|
.recvMessageExtensionsAdded(msgID, list);
|
|
break;
|
|
case 'onRecvMessageExtensionsChanged':
|
|
var msgID = call.arguments['data']['msgID'];
|
|
var value = call.arguments['data']['reactionExtensionList'];
|
|
var list = Utils.toList(value, (map) => KeyValue.fromJson(map));
|
|
messageManager.msgListener
|
|
.recvMessageExtensionsChanged(msgID, list);
|
|
break;
|
|
case 'onRecvMessageExtensionsDeleted':
|
|
var msgID = call.arguments['data']['msgID'];
|
|
var value = call.arguments['data']['reactionExtensionKeyList'];
|
|
var list = Utils.toList(value, (map) => '$map');
|
|
messageManager.msgListener
|
|
.recvMessageExtensionsDeleted(msgID, list);
|
|
break;
|
|
|
|
case 'onRecvNewMessage':
|
|
var value = call.arguments['data']['message'];
|
|
final msg = Utils.toObj(value, (map) => Message.fromJson(map));
|
|
messageManager.msgListener.recvNewMessage(msg);
|
|
break;
|
|
case 'onRecvOfflineNewMessages':
|
|
var value = call.arguments['data']['messageList'];
|
|
final list = Utils.toList(value, (map) => Message.fromJson(map));
|
|
messageManager.msgListener.recvOfflineNewMessages(list);
|
|
break;
|
|
}
|
|
} else if (call.method == ListenerType.msgSendProgressListener) {
|
|
String type = call.arguments['type'];
|
|
dynamic data = call.arguments['data'];
|
|
String msgID = data['clientMsgID'] ?? '';
|
|
int progress = data['progress'] ?? 100;
|
|
switch (type) {
|
|
case 'onProgress':
|
|
messageManager.msgSendProgressListener?.progress(
|
|
msgID,
|
|
progress,
|
|
);
|
|
break;
|
|
}
|
|
} else if (call.method == ListenerType.conversationListener) {
|
|
String type = call.arguments['type'];
|
|
dynamic data = call.arguments['data'];
|
|
switch (type) {
|
|
case 'onSyncServerStart':
|
|
conversationManager.listener.syncServerStart();
|
|
break;
|
|
case 'onSyncServerFinish':
|
|
conversationManager.listener.syncServerFinish();
|
|
break;
|
|
|
|
case 'onSyncServerFailed':
|
|
conversationManager.listener.syncServerFailed();
|
|
break;
|
|
case 'onNewConversation':
|
|
var list =
|
|
Utils.toList(data, (map) => ConversationInfo.fromJson(map));
|
|
conversationManager.listener.newConversation(list);
|
|
break;
|
|
case 'onConversationChanged':
|
|
var list =
|
|
Utils.toList(data, (map) => ConversationInfo.fromJson(map));
|
|
conversationManager.listener.conversationChanged(list);
|
|
break;
|
|
case 'onTotalUnreadMessageCountChanged':
|
|
conversationManager.listener
|
|
.totalUnreadMessageCountChanged(data ?? 0);
|
|
break;
|
|
}
|
|
} else if (call.method == ListenerType.friendListener) {
|
|
String type = call.arguments['type'];
|
|
dynamic data = call.arguments['data'];
|
|
|
|
switch (type) {
|
|
case 'onBlackAdded':
|
|
final u = Utils.toObj(data, (map) => BlacklistInfo.fromJson(map));
|
|
friendshipManager.listener.blackAdded(u);
|
|
break;
|
|
case 'onBlackDeleted':
|
|
final u = Utils.toObj(data, (map) => BlacklistInfo.fromJson(map));
|
|
friendshipManager.listener.blackDeleted(u);
|
|
break;
|
|
case 'onFriendAdded':
|
|
final u = Utils.toObj(data, (map) => FriendInfo.fromJson(map));
|
|
friendshipManager.listener.friendAdded(u);
|
|
break;
|
|
case 'onFriendApplicationAccepted':
|
|
final u = Utils.toObj(
|
|
data, (map) => FriendApplicationInfo.fromJson(map));
|
|
friendshipManager.listener.friendApplicationAccepted(u);
|
|
break;
|
|
case 'onFriendApplicationAdded':
|
|
final u = Utils.toObj(
|
|
data, (map) => FriendApplicationInfo.fromJson(map));
|
|
friendshipManager.listener.friendApplicationAdded(u);
|
|
break;
|
|
case 'onFriendApplicationDeleted':
|
|
final u = Utils.toObj(
|
|
data, (map) => FriendApplicationInfo.fromJson(map));
|
|
friendshipManager.listener.friendApplicationDeleted(u);
|
|
break;
|
|
case 'onFriendApplicationRejected':
|
|
final u = Utils.toObj(
|
|
data, (map) => FriendApplicationInfo.fromJson(map));
|
|
friendshipManager.listener.friendApplicationRejected(u);
|
|
break;
|
|
case 'onFriendDeleted':
|
|
final u = Utils.toObj(data, (map) => FriendInfo.fromJson(map));
|
|
friendshipManager.listener.friendDeleted(u);
|
|
break;
|
|
case 'onFriendInfoChanged':
|
|
final u = Utils.toObj(data, (map) => FriendInfo.fromJson(map));
|
|
friendshipManager.listener.friendInfoChanged(u);
|
|
break;
|
|
}
|
|
} else if (call.method == ListenerType.signalingListener) {
|
|
String type = call.arguments['type'];
|
|
dynamic data = call.arguments['data'];
|
|
dynamic info;
|
|
switch (type) {
|
|
case 'onRoomParticipantConnected':
|
|
case 'onRoomParticipantDisconnected':
|
|
info = Utils.toObj(data, (map) => RoomCallingInfo.fromJson(map));
|
|
break;
|
|
case 'onStreamChange':
|
|
info =
|
|
Utils.toObj(data, (map) => MeetingStreamEvent.fromJson(map));
|
|
break;
|
|
case 'onReceiveCustomSignal':
|
|
info = Utils.toObj(data, (map) => CustomSignaling.fromJson(map));
|
|
break;
|
|
default:
|
|
info = Utils.toObj(data, (map) => SignalingInfo.fromJson(map));
|
|
break;
|
|
}
|
|
switch (type) {
|
|
case 'onInvitationCancelled':
|
|
signalingManager.listener.invitationCancelled(info);
|
|
break;
|
|
case 'onInvitationTimeout':
|
|
signalingManager.listener.invitationTimeout(info);
|
|
break;
|
|
case 'onInviteeAccepted':
|
|
signalingManager.listener.inviteeAccepted(info);
|
|
break;
|
|
case 'onInviteeRejected':
|
|
signalingManager.listener.inviteeRejected(info);
|
|
break;
|
|
case 'onReceiveNewInvitation':
|
|
signalingManager.listener.receiveNewInvitation(info);
|
|
break;
|
|
case 'onInviteeAcceptedByOtherDevice':
|
|
signalingManager.listener.inviteeAcceptedByOtherDevice(info);
|
|
break;
|
|
case 'onInviteeRejectedByOtherDevice':
|
|
signalingManager.listener.inviteeRejectedByOtherDevice(info);
|
|
break;
|
|
case 'onHangUp':
|
|
signalingManager.listener.hangup(info);
|
|
break;
|
|
case 'onRoomParticipantConnected':
|
|
signalingManager.listener.roomParticipantConnected(info);
|
|
break;
|
|
case 'onRoomParticipantDisconnected':
|
|
signalingManager.listener.roomParticipantDisconnected(info);
|
|
break;
|
|
case 'onStreamChange':
|
|
signalingManager.listener.streamChangedEvent(info);
|
|
break;
|
|
case 'onReceiveCustomSignal':
|
|
signalingManager.listener.receiveCustomSignal(info);
|
|
break;
|
|
}
|
|
}
|
|
/*else if (call.method == ListenerType.workMomentsListener) {
|
|
String type = call.arguments['type'];
|
|
switch (type) {
|
|
case 'OnRecvNewNotification':
|
|
workMomentsManager.listener.recvNewNotification();
|
|
break;
|
|
}
|
|
} else if (call.method == ListenerType.organizationListener) {
|
|
String type = call.arguments['type'];
|
|
switch (type) {
|
|
case 'onOrganizationUpdated':
|
|
organizationManager.listener.organizationUpdated();
|
|
break;
|
|
}
|
|
}*/
|
|
else if (call.method == ListenerType.customBusinessListener) {
|
|
String type = call.arguments['type'];
|
|
String data = call.arguments['data'];
|
|
switch (type) {
|
|
case 'onRecvCustomBusinessMessage':
|
|
messageManager.customBusinessListener
|
|
?.recvCustomBusinessMessage(data);
|
|
break;
|
|
}
|
|
} else if (call.method == ListenerType.messageKvInfoListener) {
|
|
String type = call.arguments['type'];
|
|
String data = call.arguments['data'];
|
|
switch (type) {
|
|
case 'onMessageKvInfoChanged':
|
|
final list =
|
|
Utils.toList(data, (map) => MessageKv.fromJson(map)).toList();
|
|
messageManager.messageKvInfoListener?.messageKvInfoChanged(list);
|
|
break;
|
|
}
|
|
} else if (call.method == ListenerType.listenerForService) {
|
|
String type = call.arguments['type'];
|
|
String data = call.arguments['data'];
|
|
switch (type) {
|
|
case 'onFriendApplicationAccepted':
|
|
final u = Utils.toObj(
|
|
data, (map) => FriendApplicationInfo.fromJson(map));
|
|
_listenerForService?.friendApplicationAccepted(u);
|
|
break;
|
|
case 'onFriendApplicationAdded':
|
|
final u = Utils.toObj(
|
|
data, (map) => FriendApplicationInfo.fromJson(map));
|
|
_listenerForService?.friendApplicationAdded(u);
|
|
break;
|
|
case 'onGroupApplicationAccepted':
|
|
final i = Utils.toObj(
|
|
data, (map) => GroupApplicationInfo.fromJson(map));
|
|
_listenerForService?.groupApplicationAccepted(i);
|
|
break;
|
|
case 'onGroupApplicationAdded':
|
|
final i = Utils.toObj(
|
|
data, (map) => GroupApplicationInfo.fromJson(map));
|
|
_listenerForService?.groupApplicationAdded(i);
|
|
break;
|
|
case 'onRecvNewMessage':
|
|
final msg = Utils.toObj(data, (map) => Message.fromJson(map));
|
|
_listenerForService?.recvNewMessage(msg);
|
|
break;
|
|
}
|
|
} else if (call.method == ListenerType.putFileListener) {
|
|
String type = call.arguments['type'];
|
|
dynamic data = call.arguments['data'];
|
|
switch (type) {
|
|
case 'hashComplete':
|
|
String putID = data['putID'];
|
|
String hash = data['hash'];
|
|
int total = data['total'];
|
|
_putFileListener?.hashComplete(putID, hash, total);
|
|
break;
|
|
case 'hashProgress':
|
|
String putID = data['putID'];
|
|
int current = data['current'];
|
|
int total = data['total'];
|
|
_putFileListener?.hashProgress(putID, current, total);
|
|
break;
|
|
case 'open':
|
|
String putID = data['putID'];
|
|
int size = data['size'];
|
|
_putFileListener?.open(putID, size);
|
|
break;
|
|
case 'putComplete':
|
|
String putID = data['putID'];
|
|
int putType = data['putType'];
|
|
int total = data['total'];
|
|
_putFileListener?.putComplete(putID, putType, total);
|
|
break;
|
|
case 'putProgress':
|
|
String putID = data['putID'];
|
|
int save = data['save'];
|
|
int current = data['current'];
|
|
int total = data['total'];
|
|
_putFileListener?.putProgress(putID, save, current, total);
|
|
break;
|
|
case 'putStart':
|
|
String putID = data['putID'];
|
|
int current = data['current'];
|
|
int total = data['total'];
|
|
_putFileListener?.putStart(putID, current, total);
|
|
break;
|
|
}
|
|
}
|
|
} catch (error, stackTrace) {
|
|
Logger.print(
|
|
"回调失败了。${call.method} ${call.arguments['type']} ${call.arguments['data']} $error $stackTrace");
|
|
}
|
|
return Future.value(null);
|
|
});
|
|
}
|
|
|
|
/// 初始化SDK
|
|
/// [platform] 平台编号[IMPlatform]
|
|
/// [apiAddr] SDK api地址
|
|
/// [wsAddr] SDK websocket地址
|
|
/// [dataDir] SDK数据库存储目录
|
|
/// [objectStorage] 存储对象 cos/minio
|
|
/// [logLevel] 日志 1不打印
|
|
/// [enabledEncryption] true：加密
|
|
/// [enabledCompression] true：压缩
|
|
Future<dynamic> initSDK({
|
|
required int platformID,
|
|
required String apiAddr,
|
|
required String wsAddr,
|
|
required String dataDir,
|
|
required OnConnectListener listener,
|
|
int logLevel = 6,
|
|
String objectStorage = 'cos',
|
|
String? encryptionKey,
|
|
bool isNeedEncryption = false,
|
|
bool isCompression = false,
|
|
bool isExternalExtensions = false,
|
|
bool isLogStandardOutput = true,
|
|
String? logFilePath,
|
|
String? operationID,
|
|
}) {
|
|
this._connectListener = listener;
|
|
this._objectStorage = objectStorage;
|
|
return _channel.invokeMethod(
|
|
'initSDK',
|
|
_buildParam(
|
|
{
|
|
"platformID": platformID,
|
|
"apiAddr": apiAddr,
|
|
"wsAddr": wsAddr,
|
|
"dataDir": dataDir,
|
|
"logLevel": logLevel,
|
|
"objectStorage": objectStorage,
|
|
"encryptionKey": encryptionKey,
|
|
"isNeedEncryption": isNeedEncryption,
|
|
"isCompression": isCompression,
|
|
"isExternalExtensions": isExternalExtensions,
|
|
"isLogStandardOutput": isLogStandardOutput,
|
|
"logFilePath": logFilePath,
|
|
"operationID": Utils.checkOperationID(operationID),
|
|
},
|
|
));
|
|
}
|
|
|
|
/// 登录
|
|
/// [uid] 用户id
|
|
/// [token] 登录token，从业务服务器上获取
|
|
/// [defaultValue] 获取失败后使用的默认值
|
|
Future<UserInfo> login({
|
|
required String userID,
|
|
required String token,
|
|
String? operationID,
|
|
Future<UserInfo> Function()? defaultValue,
|
|
}) async {
|
|
await _channel.invokeMethod(
|
|
'login',
|
|
_buildParam({
|
|
'userID': userID,
|
|
'token': token,
|
|
'operationID': Utils.checkOperationID(operationID),
|
|
}),
|
|
);
|
|
this.isLogined = true;
|
|
this.userID = userID;
|
|
this.token = token;
|
|
try {
|
|
return this.userInfo = await userManager.getSelfUserInfo();
|
|
} catch (error, stackTrace) {
|
|
log('login e: $error s: $stackTrace');
|
|
if (null != defaultValue) {
|
|
return this.userInfo = await (defaultValue.call());
|
|
}
|
|
return Future.error(error, stackTrace);
|
|
}
|
|
// return uInfo;
|
|
}
|
|
|
|
/// 登出
|
|
Future<dynamic> logout({String? operationID}) async {
|
|
var value = await _channel.invokeMethod(
|
|
'logout',
|
|
_buildParam({
|
|
'operationID': Utils.checkOperationID(operationID),
|
|
}));
|
|
this.isLogined = false;
|
|
this.token = null;
|
|
return value;
|
|
}
|
|
|
|
/// 获取登录状态
|
|
Future<int?> getLoginStatus() =>
|
|
_channel.invokeMethod<int>('getLoginStatus', _buildParam({}));
|
|
|
|
/// 获取当前登录用户id
|
|
Future<String> getLoginUserID() async => userID;
|
|
|
|
/// 获取当前登录用户信息
|
|
Future<UserInfo> getLoginUserInfo() async => userInfo;
|
|
|
|
///
|
|
Future putFile({
|
|
required String putID,
|
|
required String filePath,
|
|
required String fileName,
|
|
String? operationID,
|
|
}) =>
|
|
_channel.invokeMethod(
|
|
'putFile',
|
|
_buildParam({
|
|
'putID': putID,
|
|
'filePath': filePath,
|
|
'name': fileName,
|
|
'operationID': Utils.checkOperationID(operationID),
|
|
}));
|
|
|
|
/// 更新firebase客户端注册token
|
|
/// [fcmToken] firebase token
|
|
Future updateFcmToken({
|
|
required String fcmToken,
|
|
String? operationID,
|
|
}) =>
|
|
_channel.invokeMethod(
|
|
'updateFcmToken',
|
|
_buildParam({
|
|
'fcmToken': fcmToken,
|
|
'operationID': Utils.checkOperationID(operationID),
|
|
}));
|
|
|
|
/// 标记app处于后台
|
|
// Future setAppBackgroundStatus({
|
|
// required bool isBackground,
|
|
// String? operationID,
|
|
// }) =>
|
|
// _channel.invokeMethod(
|
|
// 'setAppBackgroundStatus',
|
|
// _buildParam({
|
|
// 'isBackground': isBackground,
|
|
// 'operationID': Utils.checkOperationID(operationID),
|
|
// }));
|
|
|
|
/// 网络改变
|
|
// Future networkStatusChanged({
|
|
// String? operationID,
|
|
// }) =>
|
|
// _channel.invokeMethod(
|
|
// 'networkStatusChanged',
|
|
// _buildParam({
|
|
// 'operationID': Utils.checkOperationID(operationID),
|
|
// }));
|
|
|
|
void setPutFileListener(OnPutFileListener listener) {
|
|
_putFileListener = listener;
|
|
}
|
|
|
|
///
|
|
Future setListenerForService(OnListenerForService listener) {
|
|
if (Platform.isAndroid) {
|
|
this._listenerForService = listener;
|
|
return _channel.invokeMethod('setListenerForService', _buildParam({}));
|
|
} else {
|
|
throw UnsupportedError("only supprot android platform");
|
|
}
|
|
}
|
|
|
|
MethodChannel get channel => _channel;
|
|
|
|
static Map _buildParam(Map param) {
|
|
param["ManagerName"] = "imManager";
|
|
return param;
|
|
}
|
|
}
|
|
|