ModuleBase.define("Invite",["Error"],function(Error) {
/**
* @desc 邀请Invite构造函数。
* @constructor
* @alias Invite
* @param {String} fromUserId - 邀请发起方用户id
* @param {String} toUserId - 邀请接受方用户id
* @param {Object} options- 参数
*/
var Invite = function(fromUserId,toUserId,options) {
/**
* Invite级别回调的枚举
* @readonly
* @enum {string}
*/
this.InviteCallbackEnum = {
CALL_ACCEPT_NOTIFY: 'call.accept.notify',
CALL_REJECT_NOTIFY: 'call.reject.notify',
CALL_TIMEOUT_NOTIFY: 'call.timeout.notify',
CALL_RINGING_NOTIFY: 'call.ringing.notify',
CALL_CANCEL_NOTIFY: 'call.cancel.notify',
RESPONSE_CALL_TIMEOUT_NOTIFY: 'response.call.timeout.notify',
CALL_CLOSE_NOTIFY: 'call.close.notify',
};
this.eventEmitter = new EventEmitter();
this.inviteId = ++ Task_Id;
this.fromUserId = fromUserId;
this.toUserId = toUserId;
this.options = options;
this.callTimeout = 60000; //发启邀请超时时长(毫秒),默认设置60秒;如收到振铃Ringing后清零重新开始计时
this.callBaseTime = null; //发启邀请超时逻辑处理的基线时间
this.callTimeoutIntervalId = null; //发启邀请超时逻辑处理的setIntervald值
this.onCallTimeout = 55000; //收到邀请超时时长(毫秒),默认设置60秒;如收到振铃Ringing后清零重新开始计时
this.onCallBaseTime = null; //收到邀请超时逻辑处理的基线时间
this.onCallTimeoutIntervalId = null; //收到邀请超时逻辑处理的setIntervald值
};
/*
* @desc 开启邀请
* @ignore
*/
Invite.prototype.callInner = function (){
console.debug("===invite.callInner()");
var self = this;
if(self.callBaseTime == null) {
self.callBaseTime = new Date();
}
self.callTimeoutIntervalId = setInterval(function(){
var currentTime = new Date();
var duration = currentTime - self.callBaseTime;
if(duration >= self.callTimeout) {
self.clearanceInner();
//通知到应用层
self.eventEmitter.emit(self.InviteCallbackEnum.CALL_TIMEOUT_NOTIFY, self.toUserId);
}
}, 500);
var deferred = when.defer();
signalClient.rtmServer.sendInviteCall(self.inviteId,self.fromUserId,self.toUserId,self.options).then(function() {
deferred.resolve();
}).otherwise(function(error) {
deferred.reject(error);
});
return deferred.promise;
};
/*
* @desc 收到邀请，不做处理的超时处理
* @ignore
*/
Invite.prototype.onCallTimeOutInner = function (){
console.debug("===invite.onCallTimeOutInner()");
var self = this;
if(self.onCallBaseTime == null) {
self.onCallBaseTime = new Date();
}
self.onCallTimeoutIntervalId = setInterval(function(){
var currentTime = new Date();
var duration = currentTime - self.onCallBaseTime;
if(duration >= self.onCallTimeout) {
self.clearanceInnerOnCall();
//通知到应用层
self.eventEmitter.emit(self.InviteCallbackEnum.RESPONSE_CALL_TIMEOUT_NOTIFY, self.fromUserId);
}
}, 500);
};
/*
* @desc 清场处理
* @ignore
*/
Invite.prototype.clearanceInner = function(){
clearInterval(this.callTimeoutIntervalId);
this.callTimeoutIntervalId = null;
this.callBaseTime = null;
};
/*
* @desc 清场处理
* @ignore
*/
Invite.prototype.clearanceInnerOnCall = function(){
clearInterval(this.onCallTimeoutIntervalId);
this.onCallTimeoutIntervalId = null;
this.onCallBaseTime = null;
};
/**
* @desc 取消邀请
*/
Invite.prototype.cancel = function (){
var deferred = when.defer();
var self = this;
signalClient.rtmServer.sendInviteCancel(self.inviteId,self.fromUserId,self.toUserId).then(function() {
self.clearanceInner();
deferred.resolve();
}).otherwise(function(error) {
deferred.reject(error);
});
return deferred.promise;
};
/**
* @desc 发送振铃
*/
Invite.prototype.ringing = function (){
var deferred = when.defer();
signalClient.rtmServer.sendInviteRinging(this.inviteId,this.fromUserId,this.toUserId).then(function() {
deferred.resolve();
}).otherwise(function(error) {
deferred.reject(error);
});
return deferred.promise;
};
/**
* @desc 接受邀请
* @param {Object} options,接受方发送的参数，也可以不填
*/
Invite.prototype.accept = function (options){
var self = this;
var deferred = when.defer();
signalClient.rtmServer.sendInviteAccept(self.inviteId,self.fromUserId,self.toUserId,options).then(function() {
self.clearanceInnerOnCall();
deferred.resolve();
}).otherwise(function(error) {
deferred.reject(error);
});
return deferred.promise;
};
/**
* @desc 拒绝邀请
* @param {String} reson 拒绝原因
*/
Invite.prototype.reject = function (reson){
var self = this;
var deferred = when.defer();
signalClient.rtmServer.sendInviteReject(self.inviteId,self.fromUserId,self.toUserId,reson).then(function() {
self.clearanceInnerOnCall();
deferred.resolve();
}).otherwise(function(error) {
deferred.reject(error);
});
return deferred.promise;
};
/**
* @desc 关闭
* @param reson 关闭原因
*/
Invite.prototype.close = function(reson){
var self = this;
var deferred = when.defer();
signalClient.rtmServer.sendInviteClose(self.inviteId,self.fromUserId,self.toUserId,reson).then(function() {
self.clearanceInner();
self.clearanceInnerOnCall();
deferred.resolve();
}).otherwise(function(error) {
deferred.reject(error);
});
return deferred.promise;
};
/**
*@desc 取消邀请回调通知
*@ignore
*/
Invite.prototype.emitCallCancelNotify = function(){
this.eventEmitter.emit(this.InviteCallbackEnum.CALL_CANCEL_NOTIFY,this.toUserId);
};
/**
*@desc 响铃回调通知
*@ignore
*/
Invite.prototype.emitCallRingingNotify = function(){
this.callBaseTime = new Date();
this.eventEmitter.emit(this.InviteCallbackEnum.CALL_RINGING_NOTIFY,this.toUserId);
};
/**
*@desc 邀请接受回调通知
*@ignore
*/
Invite.prototype.emitCallAcceptNotify = function(options){
console.log('options: ', options)
this.clearanceInner();
var optionsObj = null;
if(options){
optionsObj = JSON.parse(JSON.stringify(options));
}
this.eventEmitter.emit(this.InviteCallbackEnum.CALL_ACCEPT_NOTIFY,this.toUserId,optionsObj);
}
/**
*@desc 邀请拒绝回调通知
*@ignore
*/
Invite.prototype.emitCallRejectNotify = function(reson) {
this.clearanceInner();
this.eventEmitter.emit(this.InviteCallbackEnum.CALL_REJECT_NOTIFY,this.toUserId,reson);
}
/**
*@desc 邀请关闭回调通知
*@ignore
*/
Invite.prototype.emitCallCloseNotify = function(reson) {
this.clearanceInner();
this.clearanceInnerOnCall();
this.eventEmitter.emit(this.InviteCallbackEnum.CALL_CLOSE_NOTIFY,this.toUserId,reson);
}
/**
* @desc 邀请级别的回调
* @param {UserCallback} type - 回调枚举标识
* @param {Object} callback -回调方法名,可以自定义
*
* @example
* invite.addCallback(Invite.InviteCallbackEnum.CALL_ACCEPT_NOTIFY, onCallAccept);
* invite.addCallback(Invite.InviteCallbackEnum.CALL_REJECT_NOTIFY, onCallReject);
* invite.addCallback(Invite.InviteCallbackEnum.CALL_TIMEOUT_NOTIFY, onCallTimeout);
* invite.addCallback(Invite.InviteCallbackEnum.CALL_RINGING_NOTIFY, onCallRinging);
*
* invite.addCallback(Invite.InviteCallbackEnum.CALL_CANCEL_NOTIFY, onCallCancel);
* invite.addCallback(Invite.InviteCallbackEnum.RESPONSE_CALL_TIMEOUT_NOTIFY, onResponseCallTimeout);
*
* invite.addCallback(Invite.InviteCallbackEnum.CALL_CLOSE_NOTIFY, onCallClose);
* 邀请请求已被接受的回调
* param:toUserId － 邀请接收者用户ID
* param:options － 邀请参数，json对象
* function onCallAccept(toUserId,options){
* }
*
* 邀请请求已被拒绝的回调
* param:toUserId － 邀请接收者用户ID
* param:reason － 拒绝原因
* function onCallReject(toUserId,reson){
* }
*
* 邀请请求无响应，超时回调
* param:toUserId － 邀请接收者用户ID
* function onCallTimeout(toUserId){
* }
*
* 邀请请求响铃回调
* param:toUserId － 邀请接收者用户ID
* function onCallRinging(toUserId){
* }
*
* 邀请发启者取消邀请的回调
* param:fromUserId － 邀请发启用户ID
* function onCallCancel(fromUserId) {
*
* }
*
* 接收邀请者无响应，超时回调
* param:fromUserId － 邀请发启用户ID
* function onResponseCallTimeout(fromUserId){
*
* }
*
* 邀请关闭
* param:toUserId － 关闭发启用户ID
* param:reason － 关闭原因
* function onCallClose(fromUserId,reson){
*
* }
*/
Invite.prototype.addCallback = function(type, callback){
this.eventEmitter.on(type, callback);
}
return Invite;
});