/// <summary>
/// Upload the received data to blob and returns the address
/// </summary>
private async Task HandleMediaAsync(EventMessageType type, string replyToken, string messageId, string blobDirectoryName, string blobName)
{
var stream = await messagingClient.GetContentStreamAsync(messageId);
var ext = GetFileExtension(stream.ContentHeaders.ContentType.MediaType);
var uri = await blobStorage.UploadFromStreamAsync(stream, blobDirectoryName, blobName + ext);
ISendMessage reply = null;
switch (type)
{
case EventMessageType.Audio:
reply = new AudioMessage(uri.ToString(), 100);
break;
case EventMessageType.Image:
reply = new ImageMessage(uri.ToString(), uri.ToString());
break;
case EventMessageType.Video:
reply = new VideoMessage(uri.ToString(), "https://linetestbot123.blob.core.windows.net/linebotcontainer/User_U21d2cd1795be4caa1a32d069fe7b323f/7015056697532.jpeg");
break;
case EventMessageType.File:
reply = new TextMessage(uri.ToString());
break;
}
await messagingClient.ReplyMessageAsync(replyToken, new List <ISendMessage> {
reply
});
//await messagingClient.ReplyMessageAsync(replyToken, uri.ToString());
}
public Response SendAudio(AudioMessage message)
{
string url = baseUrl + "sendAudio";
MultipartFormDataContent multiContent = new MultipartFormDataContent
{
{ new StringContent(message.ChatId.ToString()), "chat_id" },
{ new StringContent(message.Caption), "caption" },
{ new StringContent(message.Title), "title" },
};
if (message.ReplyToMessageId != null)
{
multiContent.Add(new StringContent("reply_to_message_id"), message.ReplyToMessageId?.ToString());
}
ByteArrayContent audioContent = new ByteArrayContent(message.Audio);
audioContent.Headers.ContentType = new MediaTypeHeaderValue("audio/mpeg");
multiContent.Add(audioContent, "audio");
HttpResponseMessage response = client.PostAsync(url, multiContent).Result;
if (response.StatusCode == System.Net.HttpStatusCode.OK)
{
Response result = Utils.Deserialize <Response>(response.Content.ReadAsStringAsync().Result);
return(result);
}
return(new Response());
}
public void ShouldSetTheProperties()
{
var message = new AudioMessage(new Uri("https://foo.url"), 1000);
Assert.AreEqual("https://foo.url/", message.Url.ToString());
Assert.AreEqual(1000, message.Duration);
}
public void ShouldConvertStringUrl()
{
var message = new AudioMessage("https://foo.url", 1000);
Assert.AreEqual("https://foo.url/", message.Url.ToString());
Assert.AreEqual(1000, message.Duration);
}
public void SendMessage_Audio()
{
NeedsAudio = false;
float[] AudioSignalOut = new float[AudioMessage.AudioSliceSize];
//Aggregate NonMuted Classmates
{
foreach (var client in ClientsList)
{
int offset = (client.NextSliceToWrite + (ChunksPerSecond / 2)) % ChunksPerSecond;
for (int i = 0; i < AudioMessage.AudioSliceSize; i++)
{
AudioSignalOut[i] += client.audioData_Float[(i + AudioChunkOffsets[offset]) % SampleRate];
}
}
}
var audioMessageToClient = new AudioMessage();
int samplesPerChunk = SampleRate / ChunksPerSecond; //todo: this should be static like in client for consistency
audioMessageToClient.data = new byte[samplesPerChunk * sizeof(float)];
Buffer.BlockCopy(AudioSignalOut, 0, audioMessageToClient.data, 0, samplesPerChunk * sizeof(float));
audioMessageToClient.header.messageType = MessageHeader.MessageType.audioMessage; //audio data = we need an enum I guess
audioMessageToClient.header.ClientID = 255; //null userid
audioMessageToClient.header.dataByte = (byte)NextSliceToWrite; //which audio slice we're using
WriteBytesToStream(audioMessageToClient.GetBytes(), networkStream);
}
public virtual Task <Message> SendAudioAsync(AudioMessage message,
CancellationToken cancellationToken = default)
{
return(Client.SendAudioAsync(message.ChatId, message.InputOnlineFile, message.Caption, message.ParseMode,
message.Duration, message.Performer, message.Title,
message.DisableNotification, message.ReplyToMessageId, message.ReplyMarkup, cancellationToken));
}
/// <summary>
/// 启动录音
/// </summary>
/// <param name="reciverID">接收者id，私聊就用用户id，频道聊天就用频道id</param>
/// <param name="chatType">私聊消息还是频道消息</param>
/// <param name="extraMsg">附带自定义文本消息内容</param>
/// <param name="recognizeText">是否开启语音转文字识别功能</param>
/// <param name="callback">语音消息发送回调通知，会通知多次，通过AudioMessage的sendStatus属性可以判断是哪个状态的回调</param>
/// <returns></returns>
public AudioMessage StartRecordAudio(string reciverID, ChatType chatType, string extraMsg, bool recognizeText, Action <StatusCode, AudioMessage> callback)
{
ulong reqID = 0;
YIMEngine.ErrorCode code = 0;
if (recognizeText)
{
code = IMAPI.Instance().SendAudioMessage(reciverID, (YIMEngine.ChatType)chatType, ref reqID);
}
else
{
code = IMAPI.Instance().SendOnlyAudioMessage(reciverID, (YIMEngine.ChatType)chatType, ref reqID);
}
var msg = new AudioMessage(GetCurrentUserID().UserID, reciverID, chatType, extraMsg, false);
if (code == YIMEngine.ErrorCode.Success)
{
msg.requestID = reqID;
msg.sendStatus = SendStatus.NotStartSend;
lastRecordAudioMessage = msg;
MessageCallbackObject callbackObj = new MessageCallbackObject(msg, MessageBodyType.Voice, callback);
IMInternalManager.Instance.AddMessageCallback(reqID, callbackObj);
}
else
{
msg.sendStatus = SendStatus.Fail;
Log.e("Start Record Fail! code:" + code.ToString());
if (callback != null)
{
callback(Conv.ErrorCodeConvert(code), msg);
}
}
return(msg);
}
/// <summary>
/// 结束录音并发送语音消息
/// </summary>
/// <returns>false表示启动发送失败，true表示启动发送成功</returns>
public bool StopRecordAndSendAudio()
{
if (lastRecordAudioMessage == null)
{
return(false);
}
var audioMsg = lastRecordAudioMessage;
if (audioMsg.sendStatus == SendStatus.Fail)
{
Log.e("StopRecordAndSendAudio Fail! SendStatus is Fail!");
lastRecordAudioMessage = null;
return(false);
}
YIMEngine.ErrorCode code = IMAPI.Instance().StopAudioMessage(audioMsg.extraParam);
lastRecordAudioMessage = null;
if (code == YIMEngine.ErrorCode.Success)
{
return(true);
}
else
{
Log.e("StopRecordAndSendAudio Fail! code:" + code.ToString());
return(false);
}
}
public AudioForm(AudioMessage am,bool isFrom)
{
InitializeComponent();
image.Source = new BitmapImage(new Uri(imageSouce, UriKind.Relative));
image.Stretch = Stretch.Fill;
this.am = am;
this.isFrom = isFrom;
Member from=am.from as Member;
Member to =am.to as Member;
this.Closed += AudioForm_Closed;
///语音发起者
if (isFrom)
{
btnAccept.Visibility = Visibility.Collapsed;
grid.ColumnDefinitions.RemoveAt(4);
this.Width = 240;
this.role = am.to;
nickName.Text = to.nickName;
DataUtil.AudioForms.Add(to.id, this);
}
///语音接受者
else
{
this.role = am.from;
nickName.Text = from.nickName;
DataUtil.AudioForms.Add(from.id, this);
}
timer.Interval = TimeSpan.FromSeconds(1);
timer.Tick += timer_Tick;
}
private void HandleNonObsStream(AbstractRtmpMediaMessage msg)
{
if (msg is VideoMessage)
{
VideoMessage vm = (VideoMessage)msg;
if (vm.Timestamp != null)
{
vm.TimestampDelta = (vm.Timestamp - _videoTimestamp);
_videoTimestamp = vm.Timestamp.Value;
}
else if (vm.TimestampDelta != null)
{
_videoTimestamp += vm.TimestampDelta.Value;
vm.Timestamp = _videoTimestamp;
}
}
if (msg is AudioMessage)
{
AudioMessage am = (AudioMessage)msg;
if (am.Timestamp != null)
{
am.TimestampDelta = (am.Timestamp - _audioTimestamp);
_audioTimestamp = am.Timestamp.Value;
}
else if (am.TimestampDelta != null)
{
_audioTimestamp += am.TimestampDelta.Value;
am.Timestamp = _audioTimestamp;
}
}
}
public void Constructor_SerializedCorrectly()
{
AudioMessage message = new AudioMessage("https://foo.url", 10000);
string serialized = JsonConvert.SerializeObject(message);
Assert.AreEqual(@"{""type"":""audio"",""originalContentUrl"":""https://foo.url"",""duration"":10000}", serialized);
}
private static string EVENT_AudioMsg(string Message, ref List <MessageBase> response)
{
string sURL = "https://203146b5091e8f0aafda-15d41c68795720c6e932125f5ace0c70.ssl.cf1.rackcdn.com/530000063.ogg";
var Msg = new AudioMessage(new Uri(sURL), 17000);
response.Add(Msg);
return("");
}
public void Url_Null_ThrowsException()
{
AudioMessage message = new AudioMessage();
ExceptionAssert.Throws <InvalidOperationException>("The url cannot be null.", () =>
{
message.Url = null;
});
}
public void Duration_MoreThan59999Milliseconds_ThrowsException()
{
AudioMessage message = new AudioMessage();
ExceptionAssert.Throws <InvalidOperationException>("The duration cannot be longer than 1 minute.", () =>
{
message.Duration = 60000;
});
}
public void ShouldThrowExceptionWhenValueIsMoreThan59999()
{
AudioMessage message = new AudioMessage();
ExceptionAssert.Throws <InvalidOperationException>("The duration cannot be longer than 1 minute.", () =>
{
message.Duration = 60000;
});
}
public void ShouldThrowExceptionWhenValueIsZero()
{
AudioMessage message = new AudioMessage();
ExceptionAssert.Throws <InvalidOperationException>("The duration should be at least 1 millisecond.", () =>
{
message.Duration = 0;
});
}
public void Url_NotHttps_ThrowsException()
{
AudioMessage message = new AudioMessage();
ExceptionAssert.Throws <InvalidOperationException>("The url should use the https scheme.", () =>
{
message.Url = new Uri("http://foo.bar");
});
}
private void HandleAudioMessage(AudioMessage audioData)
{
if (AACConfigureRecord == null && audioData.Data.Length >= 2)
{
AACConfigureRecord = audioData;
return;
}
OnAudioMessage?.Invoke(audioData);
}
public void Url_MoreThan1000Chars_ThrowsException()
{
AudioMessage message = new AudioMessage();
ExceptionAssert.Throws <InvalidOperationException>("The url cannot be longer than 1000 characters.", () =>
{
message.Url = new Uri("https://foo.bar/" + new string('x', 985));
});
}
public void ShouldThrowExceptionWhenValueIsMoreThan1000Chars()
{
var message = new AudioMessage();
ExceptionAssert.Throws <InvalidOperationException>("The url cannot be longer than 1000 characters.", () =>
{
message.Url = new Uri("https://foo.bar/" + new string('x', 985));
});
}
public void ShouldThrowExceptionWhenValueIsNotHttps()
{
var message = new AudioMessage();
ExceptionAssert.Throws <InvalidOperationException>("The url should use the https scheme.", () =>
{
message.Url = new Uri("http://foo.bar");
});
}
public void ShouldThrowExceptionWhenValueIsNull()
{
var message = new AudioMessage();
ExceptionAssert.Throws <InvalidOperationException>("The url cannot be null.", () =>
{
message.Url = null;
});
}
public void Duration_MinusOne_ThrowsException()
{
AudioMessage message = new AudioMessage();
ExceptionAssert.Throws <InvalidOperationException>("The duration should be at least 1 millisecond.", () =>
{
message.Duration = -1;
});
}
public void ShouldNotThrowExceptionWhenValid()
{
ISendMessage message = new AudioMessage()
{
Duration = 10000,
Url = new Uri("https://foo.url")
};
message.Validate();
}
public void SendMessage_Audio()
{
//todo: science - allocating every time is surely not performance-friendly, but sitting setting and resetting the same data seems error-prone
var audioMessageToServer = new AudioMessage();
audioMessageToServer.data = AudioManager.instance.GetChunk_FloatBytes();
audioMessageToServer.header.messageType = MessageHeader.MessageType.audioMessage;
StreamUtils.WriteMessageToStream(audioMessageToServer, networkStream);
}
public void ShouldConvertCustomIAudioMessageToAudioMessage()
{
var message = new TestAudioMessage();
var audioMessage = AudioMessage.Convert(message);
Assert.AreNotEqual(message, audioMessage);
Assert.AreEqual(new Uri("https://foo.url"), audioMessage.Url);
Assert.AreEqual(1000, audioMessage.Duration);
}
public void ShouldNotThrowExceptionWhenUrlIs59999Milliseconds()
{
int value = 59999;
AudioMessage message = new AudioMessage()
{
Duration = value
};
Assert.AreEqual(value, message.Duration);
}
public void Duration_59999Milliseconds_ThrowsException()
{
int value = 59999;
AudioMessage message = new AudioMessage()
{
Duration = value
};
Assert.AreEqual(value, message.Duration);
}
public async Task <IList <IRequestMessage> > GetReplyMessagesAsync()
{
var msg = new AudioMessage("https://www.soundhelix.com/examples/mp3/SoundHelix-Song-1.mp3");
await Task.CompletedTask;
return(new List <IRequestMessage>
{
msg
});
}
public void ShouldNotThrowExceptionWhenUrlIs1000Chars()
{
var value = new Uri("https://foo.bar/" + new string('x', 984));
var message = new AudioMessage()
{
Url = value
};
Assert.AreEqual(value, message.Url);
}
public void Url_1000Chars_ThrowsNoException()
{
Uri value = new Uri("https://foo.bar/" + new string('x', 984));
AudioMessage message = new AudioMessage()
{
Url = value
};
Assert.AreEqual(value, message.Url);
}
void MyMenu_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
{
if (this.baseRole is Member)
{
Member member = this.baseRole as Member;
if (member.status == MemberStatus.Offline)
{
return;
}
switch(messageType)
{
case MessageType.File:
{
OpenFileDialog ofd = new OpenFileDialog();
ofd.RestoreDirectory = true;
ofd.ShowDialog();
FileMessage fm = new FileMessage();
fm.from = DataUtil.Member;
fm.to = this.baseRole;
fm.Path = ofd.FileName;
if (!File.Exists(fm.Path))
return;
fm.FileName = ofd.SafeFileName;
fm.Size = ofd.OpenFile().Length;
fm.sendTime = DateTime.Now;
fm.Guid = Guid.NewGuid().ToString();
DataUtil.Transfer.SendFile(fm);
break;
}
case MessageType.Audio:
{
this.IsEnabled = false;
AudioMessage am = new AudioMessage();
am.from = DataUtil.Member;
am.to = this.baseRole;
DataUtil.Client.SendMesg(am);
AudioForm af = new AudioForm(am, true);
af.Show();
af.Closed += new EventHandler((obj, args) =>
{
this.IsEnabled = true;
});
break;
}
}
}
}
