public virtual Task <Message> SendVoiceAsync(VoiceMessage message,
CancellationToken cancellationToken = default)
{
return(Client.SendVoiceAsync(message.ChatId, message.InputOnlineFile, message.Caption, message.ParseMode,
message.Duration,
message.DisableNotification, message.ReplyToMessageId, message.ReplyMarkup, cancellationToken));
}
public async Task <HttpResponseMessage> SendVoiceMessage(VoiceMessage voiceMessage)
{
ResponseBase <IList <MMPro.MM.UploadVoiceResponse> > response = new ResponseBase <IList <MMPro.MM.UploadVoiceResponse> >();
try
{
IList <MMPro.MM.UploadVoiceResponse> list = new List <MMPro.MM.UploadVoiceResponse>();
byte[] buffer = await FileStorageHelper.DownloadToBufferAsync(voiceMessage.ObjectName);
foreach (var item in voiceMessage.ToWxIds)
{
var result = wechat.SendVoiceMessage(voiceMessage.WxId, item, buffer, voiceMessage.FileName.GetVoiceType(), voiceMessage.VoiceSecond * 100);
list.Add(result);
}
response.Data = list;
}
catch (ExpiredException ex)
{
response.Success = false;
response.Code = "401";
response.Message = ex.Message;
}
catch (Exception ex)
{
response.Success = false;
response.Code = "500";
response.Message = ex.Message;
}
return(await response.ToHttpResponseAsync());
}
public void SendVoiceMessageCollection_RestClientReturnsNull_ReturnsNull()
{
// Arrange
VoiceMessage message = new VoiceMessage("recipients", "body", "accountReference");
VoiceMessageCollection messages = new VoiceMessageCollection(message);
string serialisedMessage = "serialisedMessage";
RestResource resource = new MessageDispatcherResource(serialisedMessage, false);
RestResponse response = null;
mockSerialiser
.Setup(s => s.Serialise(messages))
.Returns(serialisedMessage);
mockRestClient
.Setup(rc => rc.Post(resource))
.Returns(response);
// Act
MessagingResult actualResult = service.SendMessages(messages);
// Assert
Assert.IsNull(actualResult);
}
/// <summary>
/// Reply to a message with a voice message
/// </summary>
/// <param name="msg">The message to reply to</param>
/// <param name="data">The voice message data</param>
/// <param name="onResponse">The response to the message</param>
public void Reply(Message msg, VoiceMessage data, rs onResponse = null)
{
msg.MimeType = "Audio/speex";
DoMessage(new Message(msg.ReturnAddress,
msg.MesgType, DataType.VoiceMessage,
data), onResponse);
}
private void soundPlayer_PlaybackStopped(object sender, EventArgs e)
{
lock (voiceMessageQueue)
{
if (voiceMessageQueue.Count > 0) // voicemessage data are in queue
{
VoiceMessage voiceMessage = voiceMessageQueue.Dequeue();
executeCodeOnUIThread(() => {
showVoiceMessageReceivedBallonTip(voiceMessage);
try
{
soundPlayer.Play(voiceMessage.Data);
}
catch (Exception ex)
{
Logger.log.Error(ex);
MessageBoxManager.ShowMessageBoxError(ERROR_PLAYING_VOICEMESSAGE_STRING);
}
});
}
else
{
soundPlayer.Stop();
soundPlayer = null;
}
}
}
private void handleVoiceMessage(VoiceMessage voiceMessage, TcpClient sender, NetworkMessageReader networkMessageReader)
{
if (voiceMessage.Sender.Id.HasValue && existsClientInClientListByTcpClientAndId(sender, voiceMessage.Sender.Id.Value))
{
Logger.log.Info($"Voicemessage received from {getServerBroadcastClientByTcpClient(sender)}");
var clientsToRemove = new List <TcpClient>();
foreach (ServerBroadcastClient client in clients.Where(client => !client.Client.Id.Value.Equals(voiceMessage.Sender.Id.Value)).ToList())
{
// sendBroadcast
try
{
NetworkMessageWriter messageWriter = new NetworkMessageWriter(client.TcpClient);
messageWriter.WriteError += (_ob, _e) => { Logger.log.Error(_e); };
messageWriter.WriteAsync(voiceMessage);
}
catch (Exception ex)
{
// connection error? client is offline?
Logger.log.Error(ex);
clientsToRemove.Add(client.TcpClient);
}
}
removeClientsFromListByTcpClients(clientsToRemove);
}
}
public async Task TestPublishVoiceMessage()
{
string[] messageUserIds = { "userId2", "userid3", "userId4" };
VoiceMessage msg = new VoiceMessage("hello", "helloExtra", 20L);
var result = await _client.Message.PublishPrivate("userId1", messageUserIds, msg, "thisisapush", "exit", "4", 0, 0, 0);
Assert.Equal(result.Code, 200);
}
public void Operation_Not_Supported()
{
//arrange
var message = new VoiceMessage();
//act+assert
Assert.Throws <OperationNotSupportedException>(() => SUT.Send(message));
}
public void VoiceFromAddressIsNotModified()
{
string result = "test";
VoiceMessage voiceMessage = new VoiceMessage();
voiceMessage.FromAddress = result;
Assert.AreEqual(result, voiceMessage.FromAddress);
}
public void VoiceVoiceIsNotModified()
{
string stringParam = "test";
byte[] result = Encoding.ASCII.GetBytes(stringParam);
VoiceMessage voiceMessage = new VoiceMessage();
voiceMessage.Voice = result;
Assert.AreEqual(result, voiceMessage.Voice);
}
static void Main(string[] args)
{
VoiceMessage mess1 = new VoiceMessage();
mess1.Send();
EmailMessage mess2 = new EmailMessage();
mess2.Send();
Console.ReadLine();
}
public VoiceMessage SendVoiceMessage(string body, long[] msisdns, VoiceMessageOptionalArguments optionalArguments = null)
{
ParameterValidator.IsNotNullOrWhiteSpace(body, "body");
ParameterValidator.ContainsAtLeast(msisdns, 1, "msisdns");
var recipients = new Recipients(msisdns);
var voiceMessage = new VoiceMessage(body, recipients, optionalArguments);
var voiceMessages = new VoiceMessages(voiceMessage);
var result = restClient.Create(voiceMessages);
return result.Object as VoiceMessage;
}
public void DeserializeRecipientsAsMsisdnsArray()
{
var recipients = new Recipients();
recipients.AddRecipient(31612345678);
var voiceMessage = new VoiceMessage("Welcome to MessageBird", recipients);
var voiceMessages = new VoiceMessages(voiceMessage);
string serializedMessage = voiceMessages.Serialize();
voiceMessages.Deserialize(serializedMessage);
}
public VoiceMessage SendVoiceMessage(string body, long[] msisdns, VoiceMessageOptionalArguments optionalArguments = null)
{
ParameterValidator.IsNotNullOrWhiteSpace(body, "body");
ParameterValidator.ContainsAtLeast(msisdns, 1, "msisdns");
var recipients = new Recipients(msisdns);
var voiceMessage = new VoiceMessage(body, recipients, optionalArguments);
var voiceMessages = new VoiceMessages(voiceMessage);
var result = restClient.Create(voiceMessages);
return(result.Object as VoiceMessage);
}
public void SendFrame(byte[] data, int length)
{
if (MagicOnionNetwork.IsJoined)
{
VoiceMessage message = new VoiceMessage();
message.SenderActorNumber = MagicOnionNetwork.LocalPlayer.ActorNumber;
message.SenderPlayerName = MagicOnionNetwork.LocalPlayer.Name;
message.EncodedData = data;
message.DataLength = length;
_voiceChatHubClient.SendMessageExceptSelfAsync(message);
}
}
public void VoiceMessage_DefaultConstructor()
{
// Arrange
var retries = 1;
var language = VoiceMessageLanguage.en_GB;
// Act
var messageInstance = new VoiceMessage();
// Assert
Assert.AreEqual(retries, messageInstance.Retries);
Assert.AreEqual(language, messageInstance.Language);
}
public void DeserializeRecipientsAsMsisdnsArray()
{
var recipients = new Recipients();
recipients.AddRecipient(31612345678);
var voiceMessage = new VoiceMessage("Welcome to MessageBird", recipients);
var voiceMessages = new VoiceMessages(voiceMessage);
string serializedMessage = voiceMessages.Serialize();
voiceMessages.Deserialize(serializedMessage);
}
public async System.Threading.Tasks.Task <ServiceMessage> InvorkAsync(ServiceMessage message)
{
VoiceMessage yaInMsg = new VoiceMessage()
{
Id = message.Id,
Language = EnumsConvertor.StringToLanguage(message.Language),
Vioce = message.Voice
};
var yaOutMsg = await _yandexStt.ProcessAsync(yaInMsg);
message.Text = yaOutMsg.Text;
return(message);
}
/// <summary>
/// Reply to a message asynchronously with a voice message
/// </summary>
/// <param name="msg"></param>
/// <param name="data"></param>
/// <returns></returns>
public async Task <Response> Reply(Message msg, VoiceMessage data)
{
var tsc = new TaskCompletionSource <Response>();
Reply(msg, data, (re) =>
{
try
{
tsc.TrySetResult(re);
}
catch { }
});
return(await tsc.Task);
}
/// <summary>
/// Send a group message asynchronously containing image bytes
/// </summary>
/// <param name="id"></param>
/// <param name="data"></param>
/// <returns></returns>
public async Task <Response> GroupMessage(int id, VoiceMessage data)
{
var tcs = new TaskCompletionSource <Response>();
GroupMessage(id, data, (re) =>
{
try
{
tcs.TrySetResult(re);
}
catch { }
});
return(await tcs.Task);
}
void IVoiceChatHubReceiver.OnReceivedMessage(VoiceMessage msg)
{
Speaker remoteVoice;
_remoteVoices.TryGetValue(msg.SenderActorNumber, out remoteVoice);
if (remoteVoice != null)
{
remoteVoice.ReceiveBytes(msg.EncodedData, msg.DataLength);
}
else
{
InstantiateSpeakerObject(msg.SenderActorNumber, msg.SenderPlayerName);
}
}
public void ReportUrl()
{
var recipients = new Recipients();
recipients.AddRecipient(31612345678);
var optionalArguments = new VoiceMessageOptionalArguments
{
ReportUrl = "https://example.com/voice-status",
};
var voiceMessage = new VoiceMessage("Body", recipients, optionalArguments);
Assert.AreEqual(voiceMessage.ReportUrl, "https://example.com/voice-status");
}
public void SendVoice()
{
var expectedJson = GetJsonPayload("/messaging/messagingApi/sendVoice.json");
var restRequest = MockRestResponse(expectedJson);
var now = DateTime.Now;
var message = new VoiceMessage()
{
CallerPhoneNumber = "1234567890",
Name = "test broadcast",
VoiceFile = "voice.wav",
VoiceSource = "http://yoursite.com/voice.mp3",
PhoneNumbers = new List <string> {
"1234567890", "2345678900", "3456789000"
},
Groups = new List <string> {
"group1", "group2", "group3"
},
StampToSend = now
};
var response = Client.MessagingApi.Send(message);
EzTextingResponse <VoiceMessage> ezResponse = new EzTextingResponse <VoiceMessage>("Success", 201, response);
Assert.That(Serializer.Serialize(ezResponse), Is.EqualTo(expectedJson));
Assert.AreEqual(Method.POST, restRequest.Value.Method);
Assert.IsTrue(restRequest.Value.Parameters.Count > 0);
var bodyParam = restRequest.Value.Parameters[0];
Assert.AreEqual(ClientConstants.FormEncodedContentType, bodyParam.ContentType);
Assert.AreEqual(ParameterType.RequestBody, bodyParam.Type);
Assert.That(bodyParam.Value, Is.StringContaining("User=login"));
Assert.That(bodyParam.Value, Is.StringContaining("Password=password"));
Assert.That(bodyParam.Value, Is.StringContaining("CallerPhonenumber=1234567890"));
Assert.That(bodyParam.Value, Is.StringContaining("Groups[]=group1"));
Assert.That(bodyParam.Value, Is.StringContaining("Groups[]=group2"));
Assert.That(bodyParam.Value, Is.StringContaining("Groups[]=group3"));
Assert.That(bodyParam.Value, Is.StringContaining("PhoneNumbers[]=1234567890"));
Assert.That(bodyParam.Value, Is.StringContaining("PhoneNumbers[]=2345678900"));
Assert.That(bodyParam.Value, Is.StringContaining("PhoneNumbers[]=3456789000"));
Assert.That(bodyParam.Value, Is.StringContaining("Name=" + "test broadcast".UrlEncode()));
Assert.That(bodyParam.Value, Is.StringContaining("VoiceFile=voice.wav"));
Assert.That(bodyParam.Value, Is.StringContaining("VoiceSource="
+ "http://yoursite.com/voice.mp3".UrlEncode()));
Assert.That(bodyParam.Value, Is.StringContaining("VoiceFile=voice.wav"));
Assert.That(bodyParam.Value, Is.StringContaining("StampToSend=" + ClientUtils.ToUnixTime(now) / 1000));
}
/// <summary>
/// xml字符串解析为消息
/// </summary>
/// <param name="xml"></param>
/// <returns></returns>
public PushBase XmlToMessage(string xml)
{
XmlUtils deserialize = new XmlUtils(xml);
string msgtype = deserialize.GetValue("/xml/MsgType").ToLower();
PushBase message = null;
switch (msgtype)
{
//普通消息
case "text":
message = new TextMessage();
break;
case "image":
message = new ImageMessage();
break;
case "voice":
message = new VoiceMessage();
break;
case "video":
message = new VideoMessage();
break;
case "shortvideo":
message = new ShortVideoMessage();
break;
case "location":
message = new LocationMessage();
break;
case "link":
message = new LinkMessage();
break;
//事件推送
case "event":
message = GetEventModel(deserialize);
break;
default:
return(null);
}
deserialize.FillModel(message);
return(message);
}
public void BuildMessage_VoiceJSON_TelegramVoiceMessage()
{
var expected = new VoiceMessage
{
From = _user,
Voice = _voice
};
AttachGeneralProperties(expected);
var actual = MessageBuilder.BuildMessage <VoiceMessage>(_messageToken);
var compareLogic = new CompareLogic(_config);
var comparisonResult = compareLogic.Compare(expected, actual);
Assert.IsTrue(comparisonResult.AreEqual, comparisonResult.DifferencesString);
}
private void showVoiceMessageReceivedBallonTip(VoiceMessage voiceMessage)
{
disposeVoiceMessageReceivedBallonTip();
// new balloon ...
voiceMessageReceivedBallonTip = new NotifyIcon();
voiceMessageReceivedBallonTip.BalloonTipClosed += VoiceMessageReceivedBallonTip_BalloonTipClosed;
voiceMessageReceivedBallonTip.BalloonTipClicked += VoiceMessageReceivedBallonTip_BalloonTipClosed;
voiceMessageReceivedBallonTip.Icon = Properties.Resources.appIcon;
voiceMessageReceivedBallonTip.Visible = true;
var message = $"Von {voiceMessage.Sender.Name} empfangen";
voiceMessageReceivedBallonTip.ShowBalloonTip(2000, "Broadcast", message, ToolTipIcon.Info);
}
public void SendScheduledMessages_WithVoiceMessage_ReturnsBatchIdResult()
{
// Arrange
DateTime timestamp = DateTime.UtcNow;
VoiceMessage message = new VoiceMessage("recipients", "body", "accountReference");
VoiceMessageCollection messages = new VoiceMessageCollection(message)
{
SendAt = timestamp
};
string serialisedMessage = "serialisedMessage";
RestResource resource = new MessageDispatcherResource(serialisedMessage, false);
RestResponse response = new RestResponse()
{
StatusCode = HttpStatusCode.OK,
Content = "serialisedResponse"
};
MessagingResult expectedResult = new MessagingResult()
{
BatchId = Guid.NewGuid(),
MessageIds = new List <ResourceLink>()
};
mockSerialiser
.Setup(s => s.Serialise(messages))
.Returns(serialisedMessage);
mockRestClient
.Setup(rc => rc.Post(resource))
.Returns(response);
mockSerialiser
.Setup(s => s.Deserialise <MessagingResult>(response.Content))
.Returns(expectedResult);
// Act
MessagingResult actualResult = service.SendScheduledMessages(messages, timestamp);
// Assert
Assert.IsNotNull(actualResult);
Assert.AreEqual(expectedResult.BatchId, actualResult.BatchId);
Assert.AreEqual(0, actualResult.MessageIds.Count());
}
public void SendVoice()
{
var msg = new VoiceMessage
{
Name = "voice broadcast",
CallerPhoneNumber = "2132212384",
VoiceSource = "https://eztxting.s3.amazonaws.com/188814/mms/train_1449507791.mp3",
PhoneNumbers = new List <string> {
"2132212384", "2132212384"
},
StampToSend = DateTime.Now.AddMinutes(5)
};
var response = Client.MessagingApi.Send(msg);
Console.WriteLine("send voice message response: " + response);
}
void ReceiveData(object sender, HoldingVariable e)
{
if (connected == false)
{
return;
}
Test data = null;
string temp = "";
if (e.File.Length == 0)
{
temp = string.Format("{0} by user {1}: {2}", e.Time, e.Name, e.Message);
data = new NormalMessage()
{
SpecialMessage = "Normal", Name = temp
};
}
else if (e.FileName.Contains(".exe"))
{
file = e.File;
temp = string.Format("{0} {1} send file {2} with message {3}", e.Time, e.Name, e.FileName, e.Message);
data = new GotFile()
{
SpecialMessage = "File", Name = temp, File = e.File
};
}
else if (e.FileName.Contains("sound"))
{
file = e.File;
temp = string.Format("{0} {1} send voice message {2} with message {3}", e.Time, e.Name, e.FileName, e.Message);
data = new VoiceMessage()
{
SpecialMessage = "Voice", Name = temp, File = e.File
};
}
// Update list from another thread
OutputMessage.Dispatcher.BeginInvoke(new Action(delegate()
{
// Insert item on top of the list
lock (_lock)
OutputMessage.Items.Insert(0, data);
}));
}
public void VoiceMessageCollection_DefaultDIConstructor_WithNullMessage()
{
// Arrange
VoiceMessage message = null;
// Act
try
{
var messageInstances = new VoiceMessageCollection(message);
Assert.Fail();
}
// Assert
catch (ArgumentNullException ex)
{
Assert.AreEqual("message", ex.ParamName);
}
}
public async System.Threading.Tasks.Task <VoiceMessage> ProcessAsync(TextMessage message)
{
switch (message.Language)
{
case Core.Enums.Language.English:
this._language = SynthesisLanguage.English;
break;
case Core.Enums.Language.Russian:
this._language = SynthesisLanguage.Russian;
break;
default:
throw new Exceptions.InvalidMessageException(message.Id, "Invalid Language: " + message.Language.ToString());
}
var apiSetttings = new SpeechKitClientOptions($"{YandexCompmnentConfig.YandexSpeechApiKey}", "MashaWebApi", Guid.Empty, "server");
using (var client = new SpeechKitClient(apiSetttings))
{
var options = new SynthesisOptions(message.Text, YandexCompmnentConfig.Speed)
{
AudioFormat = SynthesisAudioFormat.Wav,
Language = _language,
Emotion = Emotion.Good,
Quality = SynthesisQuality.High,
Speaker = Speaker.Omazh
};
using (var textToSpechResult = await client.TextToSpeechAsync(options, cancellationToken).ConfigureAwait(false))
{
if (textToSpechResult.TransportStatus != TransportStatus.Ok || textToSpechResult.ResponseCode != HttpStatusCode.OK)
{
throw new Exception("YandexSpeechKit error: " + textToSpechResult.ResponseCode.ToString());
}
VoiceMessage result = new VoiceMessage
{
Id = message.Id,
Language = message.Language,
Vioce = textToSpechResult.Result.ToByteArray()
};
return(result);
}
}
}
public void VoiceMessageCollection_ConstructorWithVoiceMessage()
{
// Arrange
var recipients = "recipients";
var body = "body";
var accountReference = "accountReference";
var retries = 1;
var language = VoiceMessageLanguage.en_GB;
var message = new VoiceMessage(recipients, body, accountReference);
// Act
var messagesInstance = new VoiceMessageCollection(message);
// Assert
Assert.AreEqual(message, messagesInstance.Items.ElementAt(0));
Assert.AreEqual(language, messagesInstance.Language);
Assert.AreEqual(retries, messagesInstance.Retries);
}
public void DeserializeAndSerialize()
{
const string JsonResultFromCreateVoiceMessageExample = @"{
'id':'955c3130353eb3dcd090294a42643365',
'href':'https:\/\/rest.messagebird.com\/voicemessages\/955c3130353eb3dcd090294a42643365',
'body':'This is a test message. The message is converted to speech and the recipient is called on his mobile.',
'reference':null,
'language':'en-gb',
'voice':'female',
'repeat':1,
'ifMachine':'continue',
'scheduledDatetime':null,
'createdDatetime':'2014-08-13T10:28:29+00:00',
'recipients':{
'totalCount':1,
'totalSentCount':1,
'totalDeliveredCount':0,
'totalDeliveryFailedCount':0,
'items':[
{
'recipient':31612345678,
'status':'calling',
'statusDatetime':'2014-08-13T10:28:29+00:00'
}
]
}
}";
var recipients = new Recipients();
var voiceMessage = new VoiceMessage("", recipients);
var voiceMessages = new VoiceMessages(voiceMessage);
voiceMessages.Deserialize(JsonResultFromCreateVoiceMessageExample);
var voiceMessageResult = voiceMessages.Object as VoiceMessage;
string voiceMessageResultString = voiceMessageResult.ToString();
JsonConvert.DeserializeObject<VoiceMessage>(voiceMessageResultString); // check if Deserialize/Serialize cycle works.
}
public abstract int Insert(VoiceMessage voiceMessage);
// For non-data messages, msgBytes is null, and byteCount is zero
public void SendAllocMessage(byte voiceNumber, VoiceOpcode opcode, long oid)
{
allocsSentCounter.Inc();
// Put the header plus the bytes into one array
byte msgSize = voiceMsgSize[(int)opcode];
IncSeqNum();
VoiceMessage msg = new VoiceMessage(msgSize, sequenceNumber, opcode, voiceNumber, oid);
voiceMgr.SendMessageToServer(msg.Bytes);
}
protected void SendAggregatedDataMessage(byte voiceNumber, List<byte[]> dataFrames)
{
int totalLen = voiceMsgSize[(int)VoiceOpcode.AggregatedData];
foreach (byte[] dataFrame in dataFrames)
totalLen += dataFrame.Length + 1;
IncSeqNum();
VoiceMessage msg = new VoiceMessage(totalLen, sequenceNumber, VoiceOpcode.AggregatedData, voiceNumber);
msg.WriteByte((byte)dataFrames.Count);
foreach (byte[] dataFrame in dataFrames)
msg.WriteSubDataFrame(dataFrame);
voiceMgr.SendMessageToServer(msg.Bytes);
aggregatedDataSentCounter.Inc();
// Increment the sequence number such that every
// aggregated voice frame gets it's own sequence
// number.
IncSeqNum(dataFrames.Count - 1);
}
// For non-data messages, msgBytes is null, and byteCount is zero
protected void SendMessage(byte voiceNumber, VoiceOpcode opcode, byte[] msgBytes, int byteCount)
{
// Put the header plus the bytes into one array
int headerSize = voiceMsgSize[(int)opcode];
byte length = (byte)(headerSize + byteCount);
IncSeqNum();
VoiceMessage msg = new VoiceMessage(length, sequenceNumber, opcode, (byte)voiceNumber);
if (byteCount > 0)
msg.WriteBytes(msgBytes, byteCount);
voiceMgr.SendMessageToServer(msg.Bytes);
}
public void SendDeallocMessage(byte voiceNumber)
{
deallocsSentCounter.Inc();
if (usingDataFrameAggregation)
dataFrameAggregator.ForceSendingDataFrames();
byte msgSize = voiceMsgSize[(int)VoiceOpcode.Deallocate];
IncSeqNum();
VoiceMessage msg = new VoiceMessage(msgSize, sequenceNumber, VoiceOpcode.Deallocate, voiceNumber);
voiceMgr.SendMessageToServer(msg.Bytes);
}
public abstract void Update(VoiceMessage voiceMessage);
public VoiceMessages(VoiceMessage voiceMessage) :
base("voicemessages", voiceMessage)
{
Object = voiceMessage;
}
