diff options
| author | chai <chaifix@163.com> | 2021-01-25 14:28:30 +0800 |
|---|---|---|
| committer | chai <chaifix@163.com> | 2021-01-25 14:28:30 +0800 |
| commit | 6eb915c129fc90c6f4c82ae097dd6ffad5239efc (patch) | |
| tree | 7dd2be50edf41f36b60fac84696e731c13afe617 /Client/Assets/Scripts/XMainClient/XChatIFlyMgr.cs | |
+scripts
Diffstat (limited to 'Client/Assets/Scripts/XMainClient/XChatIFlyMgr.cs')
| -rw-r--r-- | Client/Assets/Scripts/XMainClient/XChatIFlyMgr.cs | 1221 |
1 files changed, 1221 insertions, 0 deletions
diff --git a/Client/Assets/Scripts/XMainClient/XChatIFlyMgr.cs b/Client/Assets/Scripts/XMainClient/XChatIFlyMgr.cs new file mode 100644 index 00000000..1ee5f80a --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/XChatIFlyMgr.cs @@ -0,0 +1,1221 @@ +using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Text;
+using KKSG;
+using UnityEngine;
+using XMainClient.UI;
+using XMainClient.UI.UICommon;
+using XUpdater;
+using XUtliPoolLib;
+
+namespace XMainClient
+{
+ internal class XChatIFlyMgr : XSingleton<XChatIFlyMgr>
+ {
+ public bool IsAutoPlayEnable
+ {
+ get
+ {
+ return this._enable_auto_play;
+ }
+ }
+
+ public IXIFlyMgr IFLYMGR
+ {
+ get
+ {
+ return this._ifly_mgr;
+ }
+ }
+
+ public Dictionary<ulong, string> LocalAudio
+ {
+ get
+ {
+ return this._local_audio;
+ }
+ }
+
+ public List<ChatInfo> AutoPlayAudioList
+ {
+ get
+ {
+ bool flag = this.m_lAutoPlayAudioList == null;
+ if (flag)
+ {
+ this.m_lAutoPlayAudioList = new List<ChatInfo>();
+ }
+ return this.m_lAutoPlayAudioList;
+ }
+ set
+ {
+ this.m_lAutoPlayAudioList = value;
+ }
+ }
+
+ private static readonly float MIN_RECORD_LENGTH = 0.3f;
+
+ private static readonly float AUDIO_TIME_OUT = 10f;
+
+ private static int CLEAR_AUDIO_COUNT = 20;
+
+ private IXIFlyMgr _ifly_mgr = null;
+
+ private string audiotxt = "";
+
+ private VoiceUsage _usage = VoiceUsage.CHAT;
+
+ private string _upload_file = "";
+
+ private float _record_start = 0f;
+
+ private float _record_length = 0f;
+
+ private string cachePath = "";
+
+ private ChatChannelType _channel_type = ChatChannelType.DEFAULT;
+
+ private ChatInfo _download_audio = null;
+
+ private uint _auto_play_timer = 0u;
+
+ private uint _record_timer = 0u;
+
+ private uint _translate_timer = 0u;
+
+ private uint _prepare_record_time = 0u;
+
+ private bool _is_recording = false;
+
+ private bool _enable_auto_play = false;
+
+ private EndRecordCallBack _callback = null;
+
+ private float _try_trans_start_time = 0f;
+
+ private uint _txt_length_limit;
+
+ private uint _windows_audio_token;
+
+ private bool[] _auto_play_enable_channel = new bool[XFastEnumIntEqualityComparer<ChatChannelType>.ToInt(ChatChannelType.ChannelNum)];
+
+ private List<ChatInfo> m_lAutoPlayAudioList;
+
+ private Dictionary<ulong, string> _local_audio = new Dictionary<ulong, string>();
+
+ private List<ChatInfo> _auto_play_list = new List<ChatInfo>();
+
+ private int MAX_DELETE_CNT = 100;
+
+ private UpLoadAudioRes lastAudoRes;
+
+ private static ulong lastFileID = 0UL;
+
+ public XChatIFlyMgr()
+ {
+ for (int i = 0; i < XFastEnumIntEqualityComparer<ChatChannelType>.ToInt(ChatChannelType.ChannelNum); i++)
+ {
+ bool flag = i == XFastEnumIntEqualityComparer<ChatChannelType>.ToInt(ChatChannelType.Group);
+ if (flag)
+ {
+ this._auto_play_enable_channel[i] = false;
+ }
+ else
+ {
+ this._auto_play_enable_channel[i] = true;
+ }
+ }
+ }
+
+ public void InitFlyMgr()
+ {
+ bool flag = this._ifly_mgr == null;
+ if (flag)
+ {
+ this._ifly_mgr = (XUpdater.XUpdater.XGameRoot.GetComponent("XIFlyMgr") as IXIFlyMgr);
+ }
+ bool flag2 = this._ifly_mgr != null;
+ if (flag2)
+ {
+ this._ifly_mgr.SetCallback(new Action<string>(this.RecoganizeCallback));
+ this._ifly_mgr.SetVoiceCallback(new Action<string>(this.VoiceVolumeCallback));
+ }
+ XChatDocument specificDocument = XDocuments.GetSpecificDocument<XChatDocument>(XChatDocument.uuID);
+ this._txt_length_limit = specificDocument.GetRawData(ChatChannelType.World).length / 3u;
+ }
+
+ public bool NeedClear()
+ {
+ try
+ {
+ string audioCachePath = this.GetAudioCachePath();
+ bool flag = Directory.Exists(audioCachePath);
+ if (flag)
+ {
+ DirectoryInfo directoryInfo = new DirectoryInfo(audioCachePath);
+ FileInfo[] files = directoryInfo.GetFiles();
+ bool flag2 = files != null;
+ if (flag2)
+ {
+ bool flag3 = files.Length > XChatIFlyMgr.CLEAR_AUDIO_COUNT;
+ if (flag3)
+ {
+ return true;
+ }
+ }
+ }
+ string persistentDataPath = Application.persistentDataPath;
+ bool flag4 = Directory.Exists(persistentDataPath);
+ if (flag4)
+ {
+ DirectoryInfo directoryInfo2 = new DirectoryInfo(persistentDataPath);
+ FileInfo[] files2 = directoryInfo2.GetFiles();
+ bool flag5 = files2 != null;
+ if (flag5)
+ {
+ bool flag6 = files2.Length > XChatIFlyMgr.CLEAR_AUDIO_COUNT;
+ if (flag6)
+ {
+ return true;
+ }
+ }
+ }
+ }
+ catch
+ {
+ }
+ return false;
+ }
+
+ public void ClearAudioCache()
+ {
+ string audioCachePath = this.GetAudioCachePath();
+ bool flag = Directory.Exists(audioCachePath);
+ if (flag)
+ {
+ DirectoryInfo directoryInfo = new DirectoryInfo(audioCachePath);
+ FileInfo[] files = directoryInfo.GetFiles();
+ bool flag2 = files != null;
+ if (flag2)
+ {
+ int num = Mathf.Min(this.MAX_DELETE_CNT, files.Length);
+ for (int i = 0; i < num; i++)
+ {
+ string extension = files[i].Extension;
+ bool flag3 = !extension.Equals(".mp3") && !extension.Equals(".sound");
+ if (!flag3)
+ {
+ XSingleton<XDebug>.singleton.AddLog("delete: ", files[i].Name, " ext: ", extension, null, null, XDebugColor.XDebug_None);
+ try
+ {
+ this.RemoveLocalAudio(files[i].Name);
+ File.Delete(files[i].FullName);
+ }
+ catch
+ {
+ XSingleton<XDebug>.singleton.AddErrorLog("Delete file error, ", files[i].FullName, null, null, null, null);
+ }
+ }
+ }
+ }
+ }
+ string persistentDataPath = Application.persistentDataPath;
+ bool flag4 = Directory.Exists(persistentDataPath);
+ if (flag4)
+ {
+ DirectoryInfo directoryInfo2 = new DirectoryInfo(persistentDataPath);
+ FileInfo[] files2 = directoryInfo2.GetFiles();
+ bool flag5 = files2 != null;
+ if (flag5)
+ {
+ int num2 = Mathf.Min(this.MAX_DELETE_CNT, files2.Length);
+ for (int j = 0; j < num2; j++)
+ {
+ string extension2 = files2[j].Extension;
+ bool flag6 = !extension2.Equals(".mp3") && !extension2.Equals(".sound");
+ if (!flag6)
+ {
+ XSingleton<XDebug>.singleton.AddLog("delete: ", files2[j].Name, " ext: ", extension2, null, null, XDebugColor.XDebug_None);
+ try
+ {
+ this.RemoveLocalAudio(files2[j].Name);
+ File.Delete(files2[j].FullName);
+ }
+ catch
+ {
+ XSingleton<XDebug>.singleton.AddErrorLog("Delete apollo file error, ", files2[j].FullName, null, null, null, null);
+ }
+ }
+ }
+ }
+ }
+ }
+
+ private void RemoveLocalAudio(string name)
+ {
+ ulong key = 0UL;
+ ulong.TryParse(name, out key);
+ bool flag = this._local_audio.ContainsKey(key);
+ if (flag)
+ {
+ this._local_audio.Remove(key);
+ }
+ }
+
+ public void RemoveOldRecordFile()
+ {
+ string audioCachePath = this.GetAudioCachePath();
+ bool flag = Directory.Exists(audioCachePath);
+ if (flag)
+ {
+ DirectoryInfo directoryInfo = new DirectoryInfo(audioCachePath);
+ FileInfo[] files = directoryInfo.GetFiles();
+ bool flag2 = files != null;
+ if (flag2)
+ {
+ for (int i = 0; i < files.Length; i++)
+ {
+ string a = files[i].Name.Substring(files[i].Name.LastIndexOf(".") + 1);
+ bool flag3 = a != "pcm";
+ if (!flag3)
+ {
+ try
+ {
+ files[i].Delete();
+ }
+ catch
+ {
+ XSingleton<XDebug>.singleton.AddLog("Delete file failed: ", files[i].Name, null, null, null, null, XDebugColor.XDebug_None);
+ }
+ break;
+ }
+ }
+ }
+ }
+ }
+
+ public void GenerateAudioFiles(int num)
+ {
+ string text = this.GetAudioCachePath();
+ bool flag = Directory.Exists(text);
+ if (flag)
+ {
+ DirectoryInfo directoryInfo = new DirectoryInfo(text);
+ FileInfo[] files = directoryInfo.GetFiles();
+ bool flag2 = files != null;
+ if (flag2)
+ {
+ for (int i = 0; i < files.Length; i++)
+ {
+ string a = files[i].Name.Substring(files[i].Name.LastIndexOf(".") + 1);
+ bool flag3 = a == "mp3";
+ if (flag3)
+ {
+ for (int j = 0; j < num; j++)
+ {
+ string text2 = text + "/" + j.ToString() + ".mp3";
+ bool flag4 = !File.Exists(text2);
+ if (flag4)
+ {
+ File.Copy(files[i].FullName, text2);
+ }
+ }
+ break;
+ }
+ }
+ }
+ }
+ text = Application.persistentDataPath;
+ bool flag5 = Directory.Exists(text);
+ if (flag5)
+ {
+ DirectoryInfo directoryInfo2 = new DirectoryInfo(text);
+ FileInfo[] files2 = directoryInfo2.GetFiles();
+ bool flag6 = files2 != null;
+ if (flag6)
+ {
+ for (int k = 0; k < files2.Length; k++)
+ {
+ string a2 = files2[k].Name.Substring(files2[k].Name.LastIndexOf(".") + 1);
+ bool flag7 = a2 == "sound";
+ if (flag7)
+ {
+ for (int l = 0; l < num; l++)
+ {
+ string text3 = text + "/" + l.ToString() + ".sound";
+ bool flag8 = !File.Exists(text3);
+ if (flag8)
+ {
+ File.Copy(files2[k].FullName, text3);
+ }
+ }
+ break;
+ }
+ }
+ }
+ }
+ }
+
+ public bool IsIFlyListening()
+ {
+ bool flag = this._ifly_mgr != null;
+ return flag && this._ifly_mgr.IsIFlyListening();
+ }
+
+ public bool IsRecording()
+ {
+ return this._is_recording;
+ }
+
+ public void EnableAutoPlay(bool enable)
+ {
+ XRadioDocument specificDocument = XDocuments.GetSpecificDocument<XRadioDocument>(XRadioDocument.uuID);
+ bool flag = specificDocument != null && specificDocument.roomState == XRadioDocument.BigRoomState.InRoom && enable;
+ if (!flag)
+ {
+ XSingleton<XDebug>.singleton.AddLog("Enable auto play: ", enable.ToString(), null, null, null, null, XDebugColor.XDebug_None);
+ this._enable_auto_play = enable;
+ }
+ }
+
+ public void SetBackMusicOn(bool on)
+ {
+ XAudioOperationArgs @event = XEventPool<XAudioOperationArgs>.GetEvent();
+ @event.IsAudioOn = on;
+ @event.Firer = XSingleton<XGame>.singleton.Doc;
+ XSingleton<XEventMgr>.singleton.FireEvent(@event);
+ }
+
+ public void SetChannelAutoPlay(ChatChannelType type, bool auto)
+ {
+ bool flag = XFastEnumIntEqualityComparer<ChatChannelType>.ToInt(type) >= this._auto_play_enable_channel.Length;
+ if (!flag)
+ {
+ this._auto_play_enable_channel[XFastEnumIntEqualityComparer<ChatChannelType>.ToInt(type)] = auto;
+ }
+ }
+
+ public bool IsChannelAutoPlayEnable(ChatChannelType type)
+ {
+ bool flag = XFastEnumIntEqualityComparer<ChatChannelType>.ToInt(type) >= this._auto_play_enable_channel.Length;
+ return !flag && this._auto_play_enable_channel[XFastEnumIntEqualityComparer<ChatChannelType>.ToInt(type)];
+ }
+
+ private void setRadioOn(bool on)
+ {
+ XRadioDocument specificDocument = XDocuments.GetSpecificDocument<XRadioDocument>(XRadioDocument.uuID);
+ bool flag = specificDocument != null;
+ if (flag)
+ {
+ specificDocument.MuteSounds(!on);
+ }
+ }
+
+ public void StartRecord(VoiceUsage usage = VoiceUsage.CHAT, EndRecordCallBack callback = null)
+ {
+ bool flag = this._ifly_mgr == null || !this._ifly_mgr.IsInited();
+ if (flag)
+ {
+ XSingleton<UiUtility>.singleton.ShowSystemTip(XSingleton<XStringTable>.singleton.GetString("CHAT_INIT_FAILED"), "fece00");
+ }
+ else
+ {
+ bool isBroadcast = DlgBase<BroadMiniDlg, BroadcastMiniBehaviour>.singleton.isBroadcast;
+ if (isBroadcast)
+ {
+ XSingleton<UiUtility>.singleton.ShowSystemTip(XStringDefineProxy.GetString("FM_VOICE_BROAD"), "fece00");
+ }
+ else
+ {
+ XRadioDocument specificDocument = XDocuments.GetSpecificDocument<XRadioDocument>(XRadioDocument.uuID);
+ bool flag2 = specificDocument.isHosting();
+ if (flag2)
+ {
+ XSingleton<UiUtility>.singleton.ShowSystemTip(XStringDefineProxy.GetString("FM_VOICE_RADIO"), "fece00");
+ }
+ else
+ {
+ this.StopAutoPlay();
+ this._ifly_mgr.Cancel();
+ this.SetBackMusicOn(false);
+ this.setRadioOn(false);
+ this.RemoveOldRecordFile();
+ XSingleton<XTimerMgr>.singleton.KillTimer(this._translate_timer);
+ this._translate_timer = 0u;
+ DlgBase<XChatVoiceStatusView, XChatVoiceStatusBehaviour>.singleton.SetVisible(true, true);
+ this._usage = usage;
+ this._callback = callback;
+ XSingleton<XDebug>.singleton.AddLog("Record StartTime: ", Time.time.ToString(), null, null, null, null, XDebugColor.XDebug_None);
+ RuntimePlatform platform = Application.platform;
+ if ((int)platform != 8 && (int)platform != 11)
+ {
+ this.audiotxt = DateTime.Now.ToString();
+ this._windows_audio_token = XSingleton<XTimerMgr>.singleton.SetTimer(0.2f, new XTimerMgr.ElapsedEventHandler(this.RefreshWindowsVoice), null);
+ }
+ else
+ {
+ this.audiotxt = "";
+ }
+ bool flag3 = usage == VoiceUsage.CHAT;
+ if (flag3)
+ {
+ this._prepare_record_time = XSingleton<XTimerMgr>.singleton.SetTimer(0.15f, new XTimerMgr.ElapsedEventHandler(this.DoStartRecord), null);
+ }
+ else
+ {
+ this.DoStartRecord(null);
+ }
+ }
+ }
+ }
+ }
+
+ private void DoStartRecord(object obj)
+ {
+ this._is_recording = true;
+ this._record_start = Time.realtimeSinceStartup;
+ bool flag = this._ifly_mgr != null;
+ if (flag)
+ {
+ try
+ {
+ this._ifly_mgr.StartRecord();
+ }
+ catch
+ {
+ XSingleton<XDebug>.singleton.AddErrorLog("IFly Start record error", null, null, null, null, null);
+ }
+ }
+ this._record_timer = XSingleton<XTimerMgr>.singleton.SetTimer(10.5f, new XTimerMgr.ElapsedEventHandler(this.RecordTimeOut), null);
+ }
+
+ private void RefreshWindowsVoice(object obj)
+ {
+ DlgBase<XChatVoiceStatusView, XChatVoiceStatusBehaviour>.singleton.OnSetVolume((uint)XSingleton<XCommon>.singleton.RandomInt(0, 7));
+ this._windows_audio_token = XSingleton<XTimerMgr>.singleton.SetTimer(0.2f, new XTimerMgr.ElapsedEventHandler(this.RefreshWindowsVoice), null);
+ }
+
+ public void RecoganizeCallback(string txt)
+ {
+ bool flag = (long)this.audiotxt.Length <= (long)((ulong)this._txt_length_limit);
+ if (flag)
+ {
+ bool flag2 = (long)(this.audiotxt.Length + txt.Length) <= (long)((ulong)this._txt_length_limit);
+ if (flag2)
+ {
+ this.audiotxt += txt;
+ }
+ else
+ {
+ bool flag3 = this._txt_length_limit - (uint)(this.audiotxt.Length + 1) > 0u;
+ if (flag3)
+ {
+ this.audiotxt += txt.Substring(0, (int)(this._txt_length_limit - (uint)(this.audiotxt.Length + 1)));
+ }
+ }
+ }
+ }
+
+ public void VoiceVolumeCallback(string volume)
+ {
+ uint num = 0u;
+ uint.TryParse(volume, out num);
+ DlgBase<XChatVoiceStatusView, XChatVoiceStatusBehaviour>.singleton.OnSetVolume((num * 7u + 3u) / 25u);
+ }
+
+ public void StopRecord(bool cancel)
+ {
+ bool flag = this._ifly_mgr == null || !this._ifly_mgr.IsInited();
+ if (!flag)
+ {
+ DlgBase<XChatVoiceStatusView, XChatVoiceStatusBehaviour>.singleton.SetVisible(false, true);
+ XSingleton<XTimerMgr>.singleton.KillTimer(this._windows_audio_token);
+ bool flag2 = this._prepare_record_time > 0u;
+ if (flag2)
+ {
+ XSingleton<XTimerMgr>.singleton.KillTimer(this._prepare_record_time);
+ this._prepare_record_time = 0u;
+ }
+ this.SetBackMusicOn(true);
+ this.setRadioOn(true);
+ bool flag3 = !this._is_recording;
+ if (!flag3)
+ {
+ bool flag4 = this._record_timer > 0u;
+ if (flag4)
+ {
+ XSingleton<XTimerMgr>.singleton.KillTimer(this._record_timer);
+ this._record_timer = 0u;
+ }
+ bool flag5 = !cancel;
+ if (flag5)
+ {
+ this._ifly_mgr.StopRecord();
+ this._record_length = Time.realtimeSinceStartup - this._record_start;
+ this._record_length = ((this._record_length > 10f) ? 10f : this._record_length);
+ XSingleton<XDebug>.singleton.AddLog("Record StopTime: ", Time.time.ToString(), null, null, null, null, XDebugColor.XDebug_None);
+ bool flag6 = this._record_length <= XChatIFlyMgr.MIN_RECORD_LENGTH;
+ if (flag6)
+ {
+ XSingleton<UiUtility>.singleton.ShowSystemTip(XStringDefineProxy.GetString("CHAT_RECORD_TOO_SHORT"), "fece00");
+ }
+ else
+ {
+ string param = string.Format("{0:D2}{1:D2}{2:D2}", DateTime.Now.Hour, DateTime.Now.Minute, DateTime.Now.Second);
+ this._translate_timer = XSingleton<XTimerMgr>.singleton.SetTimer(0.1f, new XTimerMgr.ElapsedEventHandler(this.DelayTransMp3), param);
+ this._try_trans_start_time = Time.time;
+ }
+ }
+ this._is_recording = false;
+ }
+ }
+ }
+
+ private void RecordTimeOut(object obj)
+ {
+ bool flag = !this._is_recording;
+ if (!flag)
+ {
+ this.StopRecord(false);
+ bool flag2 = this._callback != null;
+ if (flag2)
+ {
+ this._callback();
+ }
+ }
+ }
+
+ public void DelayTransMp3(object obj)
+ {
+ string text = obj as string;
+ bool flag = Time.time - this._try_trans_start_time >= 0.3f;
+ if (flag)
+ {
+ this.StartTransMp3(text);
+ }
+ else
+ {
+ bool flag2 = this._ifly_mgr != null && (this._ifly_mgr.IsIFlyListening() || !this._ifly_mgr.IsRecordFileExist());
+ if (flag2)
+ {
+ this._translate_timer = XSingleton<XTimerMgr>.singleton.SetTimer(0.1f, new XTimerMgr.ElapsedEventHandler(this.DelayTransMp3), text);
+ }
+ else
+ {
+ this.StartTransMp3(text);
+ }
+ }
+ }
+
+ public void StartTransMp3(string destFileName)
+ {
+ string filePath = "";
+ RuntimePlatform platform = Application.platform;
+ if ((int)platform != 8 && (int)platform != 11)
+ {
+ filePath = "Assets/Editor/Mp3Sample/sample.mp3";
+ }
+ else
+ {
+ bool flag = this._ifly_mgr != null;
+ if (flag)
+ {
+ bool flag2 = !this._ifly_mgr.IsRecordFileExist();
+ if (flag2)
+ {
+ XSingleton<XDebug>.singleton.AddErrorLog("Record busy, can't record", null, null, null, null, null);
+ return;
+ }
+ filePath = this._ifly_mgr.StartTransMp3(destFileName);
+ }
+ }
+ this.StartUpLoadMp3(filePath);
+ }
+
+ public void StartUpLoadMp3(string filePath)
+ {
+ XSingleton<XDebug>.singleton.AddLog("Will start upload mp3, txt:", this.audiotxt, null, null, null, null, XDebugColor.XDebug_None);
+ RpcC2T_UpLoadAudioToGate rpcC2T_UpLoadAudioToGate = new RpcC2T_UpLoadAudioToGate();
+ rpcC2T_UpLoadAudioToGate.oArg.audio = File.ReadAllBytes(filePath);
+ rpcC2T_UpLoadAudioToGate.oArg.text = Encoding.UTF8.GetBytes(this.audiotxt);
+ rpcC2T_UpLoadAudioToGate.oArg.srctype = 0u;
+ this._upload_file = filePath;
+ XSingleton<XDebug>.singleton.AddLog("The audio length: ", rpcC2T_UpLoadAudioToGate.oArg.audio.Length.ToString(), null, null, null, null, XDebugColor.XDebug_None);
+ XSingleton<XClientNetwork>.singleton.Send(rpcC2T_UpLoadAudioToGate);
+ }
+
+ public void UpLoadMp3Res(UpLoadAudioRes res)
+ {
+ uint num = (uint)(this._record_length * 1000f) + 1u;
+ XSingleton<XDebug>.singleton.AddLog("Will upload res mp3, usage: ", null, null, null, null, null, XDebugColor.XDebug_None);
+ bool flag = this._usage == VoiceUsage.CHAT;
+ if (flag)
+ {
+ this._local_audio[res.audiodownuid] = this._upload_file;
+ this.lastAudoRes = res;
+ bool flag2 = DlgBase<XChatView, XChatBehaviour>.singleton.CheckWorldSendMsg(true, null, ChatChannelType.DEFAULT);
+ if (flag2)
+ {
+ bool flag3 = num >= 9000u && this.audiotxt.Length <= (int)(num / 2000u);
+ if (!flag3)
+ {
+ XSingleton<XDebug>.singleton.AddLog("Will Do send world chat", null, null, null, null, null, XDebugColor.XDebug_None);
+ DlgBase<XChatView, XChatBehaviour>.singleton.SendVoiceChat(this.audiotxt, DlgBase<XChatView, XChatBehaviour>.singleton.activeChannelType, res.audiodownuid, num * 1f);
+ }
+ }
+ }
+ else
+ {
+ bool flag4 = this._usage == VoiceUsage.ANSWER;
+ if (flag4)
+ {
+ XVoiceQADocument specificDocument = XDocuments.GetSpecificDocument<XVoiceQADocument>(XVoiceQADocument.uuID);
+ XSingleton<XDebug>.singleton.AddLog("Will Do send answer chat", null, null, null, null, null, XDebugColor.XDebug_None);
+ specificDocument.SendAnswer(this.audiotxt, res.audiodownuid, num);
+ }
+ else
+ {
+ bool flag5 = this._usage == VoiceUsage.FLOWER_REPLY;
+ if (flag5)
+ {
+ this._local_audio[res.audiodownuid] = this._upload_file;
+ this.lastAudoRes = res;
+ DlgBase<XChatView, XChatBehaviour>.singleton.SendVoiceChat(this.audiotxt, ChatChannelType.Friends, res.audiodownuid, num * 1f);
+ }
+ else
+ {
+ bool flag6 = this._usage == VoiceUsage.MENTORHIP;
+ if (flag6)
+ {
+ this._local_audio[res.audiodownuid] = this._upload_file;
+ this.lastAudoRes = res;
+ }
+ else
+ {
+ bool flag7 = this._usage == VoiceUsage.GUILDCOLLECT;
+ if (flag7)
+ {
+ XExchangeItemDocument specificDocument2 = XDocuments.GetSpecificDocument<XExchangeItemDocument>(XExchangeItemDocument.uuID);
+ XSingleton<XDebug>.singleton.AddLog("Will Do send voice chat in guild collect", null, null, null, null, null, XDebugColor.XDebug_None);
+ specificDocument2.SendChat(this.audiotxt, res.audiodownuid, num);
+ }
+ }
+ }
+ }
+ }
+ }
+
+ public void ResendLastWorldChat()
+ {
+ bool useApollo = XChatDocument.UseApollo;
+ if (useApollo)
+ {
+ XSingleton<XChatApolloMgr>.singleton.ResendLastWorldChat();
+ }
+ else
+ {
+ uint num = (this._record_length >= 1f) ? ((uint)this._record_length) : 1u;
+ bool flag = this.lastAudoRes != null;
+ if (flag)
+ {
+ DlgBase<XChatView, XChatBehaviour>.singleton.SendVoiceChat(this.audiotxt, DlgBase<XChatView, XChatBehaviour>.singleton.activeChannelType, this.lastAudoRes.audiodownuid, num * 1f);
+ }
+ }
+ }
+
+ public void DownloadMp3(ChatInfo info)
+ {
+ XSingleton<XDebug>.singleton.AddLog("Will Download mp3", null, null, null, null, null, XDebugColor.XDebug_None);
+ this._download_audio = info;
+ RpcC2A_GetAudioListReq rpcC2A_GetAudioListReq = new RpcC2A_GetAudioListReq();
+ rpcC2A_GetAudioListReq.oArg.audioUidList.Add(info.mAudioId);
+ XSingleton<XClientNetwork>.singleton.Send(rpcC2A_GetAudioListReq);
+ }
+
+ public void DownloadMp3Res(GetAudioListRes res)
+ {
+ bool flag = res.dataList == null || res.dataList.Count == 0;
+ if (flag)
+ {
+ XSingleton<XDebug>.singleton.AddLog("Download res error", null, null, null, null, null, XDebugColor.XDebug_None);
+ this.DoStartAutoPlay(null);
+ }
+ else
+ {
+ AudioBrief audioBrief = res.dataList[0];
+ string text = this.GetAudioCachePath() + "/" + audioBrief.audioUid.ToString() + ".mp3";
+ bool flag2 = this._download_audio.mChannelId != ChatChannelType.DEFAULT;
+ if (flag2)
+ {
+ text = this.GetAudioCachePath() + "/" + audioBrief.audioUid.ToString() + ".sound";
+ }
+ File.WriteAllBytes(text, audioBrief.audio);
+ this._local_audio[this._download_audio.mAudioId] = text;
+ XSingleton<XDebug>.singleton.AddLog("Download OK, will start play mp3, audiotime: ", this._download_audio.mAudioTime.ToString(), null, null, null, null, XDebugColor.XDebug_None);
+ this.StartPlayMp3(text, this._download_audio.mAudioTime, this._download_audio);
+ this.ChatShowInfo(this._download_audio);
+ }
+ }
+
+ public void DownLoadMp3Error()
+ {
+ this.DoStartAutoPlay(null);
+ }
+
+ public void StartPlayMp3(string filepath, uint audiotime, ChatInfo info)
+ {
+ IApolloManager xapolloManager = XSingleton<XUpdater.XUpdater>.singleton.XApolloManager;
+ xapolloManager.SetApolloMode(2);
+ XOptionsDocument specificDocument = XDocuments.GetSpecificDocument<XOptionsDocument>(XOptionsDocument.uuID);
+ int @int = XSingleton<XGlobalConfig>.singleton.GetInt("SetSpeakerVolume");
+ xapolloManager.SetMusicVolum((int)((float)@int * specificDocument.voiceVolme));
+ RuntimePlatform platform = Application.platform;
+ if ((int)platform != 8 && (int)platform != 11)
+ {
+ XSingleton<XChatApolloMgr>.singleton.StartPlayVoice(filepath);
+ }
+ else
+ {
+ bool flag = File.Exists(filepath);
+ if (!flag)
+ {
+ XSingleton<XDebug>.singleton.AddLog("File not found, ", filepath, null, null, null, null, XDebugColor.XDebug_None);
+ XSingleton<XTimerMgr>.singleton.KillTimer(this._auto_play_timer);
+ this._auto_play_timer = XSingleton<XTimerMgr>.singleton.SetGlobalTimer(0.1f, new XTimerMgr.ElapsedEventHandler(this.DoStartAutoPlay), null);
+ return;
+ }
+ try
+ {
+ XSingleton<XChatApolloMgr>.singleton.StartPlayVoice(filepath);
+ }
+ catch (Exception ex)
+ {
+ XSingleton<XDebug>.singleton.AddLog("StartPlayMp3, Find play exception, ", ex.ToString(), null, null, null, null, XDebugColor.XDebug_None);
+ }
+ }
+ XSingleton<XTimerMgr>.singleton.KillTimer(this._auto_play_timer);
+ bool flag2 = audiotime <= 1000u;
+ if (flag2)
+ {
+ audiotime = 1000u;
+ }
+ this._auto_play_timer = XSingleton<XTimerMgr>.singleton.SetGlobalTimer((audiotime + 10u) * 1f / 1000f, new XTimerMgr.ElapsedEventHandler(this.DoStartAutoPlay), null);
+ XSingleton<XDebug>.singleton.AddLog("Will start time autoplay, time: ", audiotime.ToString(), null, null, null, null, XDebugColor.XDebug_None);
+ this.DeleteAudio(info.mAudioId);
+ }
+
+ public void DoStartPlayChatInfo(ChatInfo info)
+ {
+ this.StopAutoPlay();
+ this.StartPlayInfo(info);
+ }
+
+ public void StartPlayInfo(ChatInfo info)
+ {
+ bool is_recording = this._is_recording;
+ if (is_recording)
+ {
+ XSingleton<XDebug>.singleton.AddLog("StartPlayInfo, isrecord will return", null, null, null, null, null, XDebugColor.XDebug_None);
+ }
+ else
+ {
+ bool flag = this._local_audio.ContainsKey(info.mAudioId) && File.Exists(this._local_audio[info.mAudioId]);
+ if (flag)
+ {
+ this.ChatShowInfo(info);
+ this.StartPlayMp3(this._local_audio[info.mAudioId], info.mAudioTime, info);
+ }
+ else
+ {
+ this.DownloadMp3(info);
+ }
+ }
+ }
+
+ private void DeleteAudio(ulong audioid)
+ {
+ bool flag = XChatIFlyMgr.lastFileID == 0UL || XChatIFlyMgr.lastFileID == audioid;
+ if (flag)
+ {
+ XChatIFlyMgr.lastFileID = audioid;
+ }
+ else
+ {
+ RuntimePlatform platform = Application.platform;
+ bool flag2 = (int)platform == 8;
+ if (flag2)
+ {
+ string path = string.Concat(new object[]
+ {
+ Application.temporaryCachePath,
+ "/",
+ XChatIFlyMgr.lastFileID,
+ ".mp3"
+ });
+ this.DeleteFile(path);
+ string path2 = string.Concat(new object[]
+ {
+ Application.temporaryCachePath,
+ "/",
+ XChatIFlyMgr.lastFileID,
+ ".sound"
+ });
+ this.DeleteFile(path2);
+ }
+ else
+ {
+ string path3 = string.Concat(new object[]
+ {
+ Application.persistentDataPath,
+ "/",
+ XChatIFlyMgr.lastFileID,
+ ".sound"
+ });
+ this.DeleteFile(path3);
+ string path4 = string.Concat(new object[]
+ {
+ Application.persistentDataPath,
+ "/",
+ XChatIFlyMgr.lastFileID,
+ ".mp3"
+ });
+ this.DeleteFile(path4);
+ }
+ XChatIFlyMgr.lastFileID = audioid;
+ }
+ }
+
+ private void DeleteFile(string path)
+ {
+ XSingleton<XDebug>.singleton.AddLog("delete: ", path, null, null, null, null, XDebugColor.XDebug_None);
+ try
+ {
+ bool flag = !string.IsNullOrEmpty(path);
+ if (flag)
+ {
+ bool flag2 = File.Exists(path);
+ if (flag2)
+ {
+ File.Delete(path);
+ }
+ }
+ }
+ catch
+ {
+ XSingleton<XDebug>.singleton.AddWarningLog("delete fail" + path, null, null, null, null, null);
+ }
+ }
+
+ public void StartPlayAudioId(ulong audioid)
+ {
+ this.StartPlayInfo(new ChatInfo
+ {
+ mAudioId = audioid,
+ mChannelId = ChatChannelType.DEFAULT
+ });
+ }
+
+ public void ClearPlayList()
+ {
+ this._auto_play_list.Clear();
+ }
+
+ public void DoStartAutoPlay(object obj)
+ {
+ bool enable_auto_play = this._enable_auto_play;
+ if (enable_auto_play)
+ {
+ this.StartAutoPlay(true, true);
+ }
+ else
+ {
+ IApolloManager xapolloManager = XSingleton<XUpdater.XUpdater>.singleton.XApolloManager;
+ xapolloManager.SetApolloMode(0);
+ this.SetBackMusicOn(true);
+ this.setRadioOn(true);
+ this._auto_play_timer = 0u;
+ }
+ }
+
+ public void StartAutoPlay(bool rank = true, bool clearTimeout = true)
+ {
+ if (clearTimeout)
+ {
+ this.ClearTimeOutInfo();
+ }
+ if (rank)
+ {
+ this.RankAutoPlayList();
+ }
+ XSingleton<XDebug>.singleton.AddLog("StartAutoPlay, num:", this._auto_play_list.Count.ToString(), null, null, null, null, XDebugColor.XDebug_None);
+ bool flag = this._auto_play_list.Count == 0;
+ if (flag)
+ {
+ IApolloManager xapolloManager = XSingleton<XUpdater.XUpdater>.singleton.XApolloManager;
+ xapolloManager.SetApolloMode(0);
+ this.SetBackMusicOn(true);
+ this.setRadioOn(true);
+ XSingleton<XDebug>.singleton.AddLog("StartAutoplay setback music on", null, null, null, null, null, XDebugColor.XDebug_None);
+ this._auto_play_timer = 0u;
+ }
+ else
+ {
+ XSingleton<XDebug>.singleton.AddLog("StartAutoplay setback music off", null, null, null, null, null, XDebugColor.XDebug_None);
+ this.SetBackMusicOn(false);
+ this.setRadioOn(false);
+ bool flag2 = this._auto_play_list.Count > 0;
+ if (flag2)
+ {
+ this.StartPlayInfo(this._auto_play_list[0]);
+ this._auto_play_list.RemoveAt(0);
+ }
+ }
+ }
+
+ public void StopAutoPlay()
+ {
+ XSingleton<XTimerMgr>.singleton.KillTimer(this._auto_play_timer);
+ this._auto_play_timer = 0u;
+ XSingleton<XChatApolloMgr>.singleton.StopPlayVoice();
+ }
+
+ public void InsertAutoPlayList(ChatInfo info, bool clearTimeOut = true)
+ {
+ this._auto_play_list.Insert(0, info);
+ this.StopAutoPlay();
+ IApolloManager xapolloManager = XSingleton<XUpdater.XUpdater>.singleton.XApolloManager;
+ xapolloManager.SetApolloMode(2);
+ try
+ {
+ this.StartAutoPlay(false, clearTimeOut);
+ }
+ catch (Exception ex)
+ {
+ XSingleton<XDebug>.singleton.AddLog("InsertAutoPlayList exception, ", ex.ToString(), null, null, null, null, XDebugColor.XDebug_None);
+ }
+ }
+
+ public bool AddAutoPlayList(ChatInfo info)
+ {
+ bool flag = !XSingleton<XClientNetwork>.singleton.IsWifiEnable() && this.IsChannelAutoPlayEnable(ChatChannelType.ZeroChannel);
+ bool result;
+ if (flag)
+ {
+ result = false;
+ }
+ else
+ {
+ bool flag2 = !this.IsChannelAutoPlayEnable(info.mChannelId);
+ if (flag2)
+ {
+ result = false;
+ }
+ else
+ {
+ bool flag3 = this._channel_type != ChatChannelType.DEFAULT && info.mChannelId != this._channel_type;
+ if (flag3)
+ {
+ result = false;
+ }
+ else
+ {
+ bool flag4 = XSingleton<XScene>.singleton.SceneID == 100u || (XSingleton<XAttributeMgr>.singleton.XPlayerData.Level < 10u && DlgBase<BattleMain, BattleMainBehaviour>.singleton.IsVisible());
+ if (flag4)
+ {
+ result = false;
+ }
+ else
+ {
+ this._auto_play_list.Add(info);
+ bool flag5 = this._auto_play_timer == 0u && this._enable_auto_play && !this.IsRecording();
+ if (flag5)
+ {
+ this.StartAutoPlay(true, true);
+ }
+ result = true;
+ }
+ }
+ }
+ }
+ return result;
+ }
+
+ public void RankAutoPlayList()
+ {
+ }
+
+ private void ChatShowInfo(ChatInfo info)
+ {
+ bool isAudioPlayed = info.isAudioPlayed;
+ if (!isAudioPlayed)
+ {
+ bool flag = info.mChannelId == ChatChannelType.DEFAULT;
+ if (!flag)
+ {
+ info.isAudioPlayed = true;
+ XChatDocument specificDocument = XDocuments.GetSpecificDocument<XChatDocument>(XChatDocument.uuID);
+ specificDocument.ReceiveChatInfo(info);
+ }
+ }
+ }
+
+ public void ClearTimeOutInfo()
+ {
+ List<ChatInfo> list = new List<ChatInfo>();
+ for (int i = 0; i < this._auto_play_list.Count; i++)
+ {
+ bool flag = (DateTime.Now - this._auto_play_list[i].mTime).TotalSeconds <= (double)XChatIFlyMgr.AUDIO_TIME_OUT;
+ if (flag)
+ {
+ list.Add(this._auto_play_list[i]);
+ }
+ else
+ {
+ this.ChatShowInfo(this._auto_play_list[i]);
+ }
+ }
+ this._auto_play_list = list;
+ }
+
+ public void SetAutoPlayChannel(ChatChannelType type)
+ {
+ bool flag = type != ChatChannelType.DEFAULT;
+ if (flag)
+ {
+ List<ChatInfo> list = new List<ChatInfo>();
+ for (int i = 0; i < this._auto_play_list.Count; i++)
+ {
+ bool flag2 = this._auto_play_list[i].mChannelId == type;
+ if (flag2)
+ {
+ list.Add(this._auto_play_list[i]);
+ }
+ else
+ {
+ this.ChatShowInfo(this._auto_play_list[i]);
+ }
+ }
+ this._auto_play_list = list;
+ }
+ this._channel_type = type;
+ }
+
+ private string GetString(string path)
+ {
+ bool flag = string.IsNullOrEmpty(path);
+ string result;
+ if (flag)
+ {
+ result = path;
+ }
+ else
+ {
+ result = path.Replace('\\', '/');
+ }
+ return result;
+ }
+
+ public string GetAudioCachePath()
+ {
+ bool flag = string.IsNullOrEmpty(this.cachePath);
+ if (flag)
+ {
+ RuntimePlatform platform = Application.platform;
+ if ((int)platform != 8)
+ {
+ if ((int)platform != 11)
+ {
+ this.cachePath = Application.persistentDataPath;
+ }
+ else
+ {
+ this.cachePath = Application.persistentDataPath;
+ }
+ }
+ else
+ {
+ this.cachePath = Application.temporaryCachePath;
+ }
+ }
+ return this.cachePath;
+ }
+
+ public void OnOpenWebView()
+ {
+ bool flag = this._ifly_mgr != null;
+ if (flag)
+ {
+ this._ifly_mgr.OnOpenWebView();
+ }
+ }
+
+ public void OnCloseWebView()
+ {
+ bool flag = this._ifly_mgr != null;
+ if (flag)
+ {
+ this._ifly_mgr.OnCloseWebView();
+ }
+ }
+
+ public void OnWebViewScreenLock(bool islock)
+ {
+ XSingleton<XDebug>.singleton.AddLog("Webview islock: ", islock.ToString(), null, null, null, null, XDebugColor.XDebug_None);
+ bool flag = this._ifly_mgr != null;
+ if (flag)
+ {
+ this._ifly_mgr.OnScreenLock(islock);
+ }
+ }
+
+ public void OnEvalWebViewJs(string script)
+ {
+ bool flag = this._ifly_mgr != null;
+ if (flag)
+ {
+ this._ifly_mgr.OnEvalJsScript(script);
+ }
+ }
+
+ public void OnRefreshWebViewShow(bool show)
+ {
+ bool flag = this._ifly_mgr != null;
+ if (flag)
+ {
+ this._ifly_mgr.RefershWebViewShow(show);
+ }
+ }
+
+ public void RefreshWebViewConfig()
+ {
+ bool flag = XSingleton<XEntityMgr>.singleton.Player == null;
+ if (!flag)
+ {
+ int num = int.Parse(XSingleton<XGlobalConfig>.singleton.GetValue("HideWebView"));
+ bool flag2 = num == 1;
+ if (!flag2)
+ {
+ bool flag3 = this._ifly_mgr != null;
+ if (flag3)
+ {
+ int platform = 0;
+ XAuthorizationChannel channel = XSingleton<XLoginDocument>.singleton.Channel;
+ if (channel != XAuthorizationChannel.XAuthorization_QQ)
+ {
+ if (channel == XAuthorizationChannel.XAuthorization_WeChat)
+ {
+ platform = 1;
+ }
+ }
+ else
+ {
+ platform = 0;
+ }
+ this._ifly_mgr.OnInitWebViewInfo(platform, XSingleton<XLoginDocument>.singleton.OpenID, XSingleton<XClientNetwork>.singleton.ServerID.ToString(), XSingleton<XEntityMgr>.singleton.Player.PlayerAttributes.RoleID.ToString(), XSingleton<XAttributeMgr>.singleton.XPlayerData.Name);
+ }
+ }
+ }
+ }
+ }
+}
|