Prg_ZhangXuheng
/
NLDClient-yudde
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
NLDClient-yudde/ProjectNLD/Assets/Code/Scripts/Framework/UI/UIManager.cs

643 lines
20 KiB
C#
Raw Normal View History

【工程】迁移
2023-08-22 19:08:45 +08:00
using System;
using System.Collections;
using System.Collections.Generic;
using Cysharp.Threading.Tasks;
using Framework;
【工程】from p4
2023-10-19 15:00:19 +08:00
using PhxhSDK;
【工程】迁移
2023-08-22 19:08:45 +08:00
using UnityEngine;
【工程】from p4
2023-10-19 15:00:19 +08:00
public partial class UIManager : Singlenton<UIManager>, IInitable
【工程】迁移
2023-08-22 19:08:45 +08:00
{
public const string UI_PREFAB_PATH = "Assets/Art/UI/Prefab/{0}.prefab";
public Dictionary<string, UIWindow> mMemoryWindows = new Dictionary<string, UIWindow>();
public Stack<UIWindow> mStackWindows = new Stack<UIWindow>();
private Dictionary<int, LinkedList<UIWindow>> _layerList = new Dictionary<int, LinkedList<UIWindow>>(16);
private ScreenOrientation _currentOrientation;
private Dictionary<string, string> _openingWindows = new Dictionary<string, string>();
public void Init()
{
_AllWindowMeta();
if (DeviceHelper.IsFullScreenIOS())
{
SetFullScreenIOS();
}
}
public void Release()
{
}
/// <summary>
/// 打开一个UI
/// UIManager.Instance.OpenWindow("Common/GameUI")
/// </summary>
public async UniTask<UIWindow> OpenWindow(string path)
{
string uipath = path;
UIWindow window = null;
//if (windowType != UIWindowType.Fixed && ConflictDialogManager.Instance.CheckConflict(uipath, mMemoryWindows))
//{
// return window;
//}
WindowInfo wInfo;
if (!_windowsInfo.ContainsKey(uipath))
{
//if (_windowsInfo.TryGetValue(uipath, out wInfo))
{
【工程】from p4
2023-10-19 15:00:19 +08:00
DebugUtil.LogError("Create ui fail: {0}, no windows info inited", uipath);
【工程】迁移
2023-08-22 19:08:45 +08:00
return window;
}
}
wInfo = _windowsInfo[uipath];
var windowType = wInfo.windowType;
var uiWindowLayer = wInfo.windowLayer;
if (!mMemoryWindows.TryGetValue(uipath, out window))
{
if (_openingWindows.ContainsKey(uipath))
{
return window;
}
_openingWindows.Add(uipath, uipath);
window = await UIRoot.Instance.CreateWindow(uipath, windowType);
_openingWindows.Remove(uipath);
if (window != null)
{
mMemoryWindows[uipath] = window;
window.WindowName = uipath;
window.m_WindowType = windowType;
window.uiWindowLayer = uiWindowLayer;
}
else
{
【工程】from p4
2023-10-19 15:00:19 +08:00
DebugUtil.LogError("Create ui fail: {0}", uipath);
【工程】迁移
2023-08-22 19:08:45 +08:00
return window;
}
}
if (windowType != UIWindowType.Fixed && !mMemoryWindows.TryGetValue(uipath, out window))//不是常显UI
{
if (!mStackWindows.Contains(window))// 不在打开队列里
{
if (windowType == UIWindowType.Normal)//对于Normal类型的UI，需要在打开的时候，将前面打开的UI关闭掉
{
if (mStackWindows.Count > 0)
{
UIWindow stackWindow = mStackWindows.Peek();
if (stackWindow != null)
{
//List<string> friends = ConflictDialogManager.Instance.GetFrinends(uipath);
//if (!friends.Contains(stackWindow.WindowName))//如果不在白名单里, 则关闭
{
CloseWindow(stackWindow.WindowName, true);
}
}
}
}
mStackWindows.Push(window);//添加到打开队列
}
else
{
if (mStackWindows.Count > 0)
{
try
{
UIWindow currentWindow = mStackWindows.Peek();
while (!currentWindow.Equals(window))
{
CloseWindow(currentWindow.WindowName, true);
currentWindow = mStackWindows.Peek();
}
}
catch (Exception e)
{
DebugUtil.LogError(e.Message);
}
}
}
}
else
{
//常显UI，单独处理
}
LayerListInsertWindow(window);
window.OpenWindow();
return window;
}
//重载一下，传参的Open
public async UniTask<UIWindow> OpenWindow(string path, object data)
{
string uipath = path;
UIWindow window = null;
//if (windowType != UIWindowType.Fixed && ConflictDialogManager.Instance.CheckConflict(uipath, mMemoryWindows))
//{
// return window;
//}
WindowInfo wInfo;
if (!_windowsInfo.ContainsKey(uipath))
{
//if (_windowsInfo.TryGetValue(uipath, out wInfo))
{
【工程】from p4
2023-10-19 15:00:19 +08:00
DebugUtil.LogError("Create ui fail: {0}, no windows info inited", uipath);
【工程】迁移
2023-08-22 19:08:45 +08:00
return window;
}
}
wInfo = _windowsInfo[uipath];
var windowType = wInfo.windowType;
var uiWindowLayer = wInfo.windowLayer;
if (!mMemoryWindows.TryGetValue(uipath, out window))
{
window = await UIRoot.Instance.CreateWindow(uipath, windowType);
if (window != null)
{
mMemoryWindows[uipath] = window;
window.WindowName = uipath;
window.m_WindowType = windowType;
window.uiWindowLayer = uiWindowLayer;
}
else
{
【工程】from p4
2023-10-19 15:00:19 +08:00
DebugUtil.LogError("Create ui fail: {0}", uipath);
【工程】迁移
2023-08-22 19:08:45 +08:00
return window;
}
}
if (windowType != UIWindowType.Fixed && !mMemoryWindows.TryGetValue(uipath, out window))//不是常显UI
{
if (!mStackWindows.Contains(window))// 不在打开队列里
{
if (windowType == UIWindowType.Normal)//对于Normal类型的UI，需要在打开的时候，将前面打开的UI关闭掉
{
if (mStackWindows.Count > 0)
{
UIWindow stackWindow = mStackWindows.Peek();
if (stackWindow != null)
{
//List<string> friends = ConflictDialogManager.Instance.GetFrinends(uipath);
//if (!friends.Contains(stackWindow.WindowName))//如果不在白名单里, 则关闭
{
CloseWindow(stackWindow.WindowName, true);
}
}
}
}
mStackWindows.Push(window);//添加到打开队列
}
else
{
if (mStackWindows.Count > 0)
{
try
{
UIWindow currentWindow = mStackWindows.Peek();
while (!currentWindow.Equals(window))
{
CloseWindow(currentWindow.WindowName, true);
currentWindow = mStackWindows.Peek();
}
}
catch (Exception e)
{
DebugUtil.LogError(e.Message);
}
}
}
}
else
{
//常显UI，单独处理
}
LayerListInsertWindow(window);
【工程】from p4
2023-10-19 15:00:19 +08:00
if (window)
{
window.OpenWindow(data);
}
【工程】迁移
2023-08-22 19:08:45 +08:00
return window;
}
【工程】from p4
2023-10-19 15:00:19 +08:00
【工程】迁移
2023-08-22 19:08:45 +08:00
public bool Back()
{
if (mMemoryWindows == null || mMemoryWindows.Count <= 0)
{
return false;
}
foreach (var key in mMemoryWindows.Keys)
{
if (mMemoryWindows[key] != null && mMemoryWindows[key].m_WindowType != UIWindowType.Fixed)
{
return mMemoryWindows[key].OnBack();
}
}
return false;
}
public bool CloseWindow(string wName, bool destroy = false)
{
string windowName = wName;
bool result = false;
UIWindow window;
if (mMemoryWindows.TryGetValue(windowName, out window))
{
window.CloseWindow(destroy);
if (destroy)
{
LayerListRemoveWindow(window);
mMemoryWindows.Remove(windowName);
}
if (mStackWindows.Count > 0)
{
if (mStackWindows.Peek().Equals(window))
{
mStackWindows.Pop();
//只有是普通界面 才刷新 2018.12.20 wwc 注释 原因:购买道具，弹出商店界面，需要关闭后刷新后面的UI，更新道具数量
//if (window.m_WindowType == UIWindowType.Normal)
//{
//2018.12.20.17:25 qu 移除栈顶的已经destroy掉的, 因为前面的窗口有可能destroy了 (窗口关闭有延时, 导致关闭时不一定被pop出去)
while (mStackWindows.Count > 0 && !mMemoryWindows.ContainsKey(mStackWindows.Peek().WindowName))
{
mStackWindows.Pop();
}
if (mStackWindows.Count > 0)
{
mStackWindows.Peek().ReloadWindow();
}
//}
}
}
result = true;
}
//var fsName = FSModel.Instance.GetFSWindowName(windowName);
//if (!fsName.Equals(windowName))
//{
// CloseWindow(fsName, destroy);
//}
return result;
}
public T GetOpenedWindowByPath<T>(string uipath) where T : UIWindow
{
if (mMemoryWindows.ContainsKey(uipath))
{
var window = (T)(mMemoryWindows[uipath]);
return window.gameObject.activeSelf ? window : null;
}
return default(T);
}
void LayerListInsertWindow(UIWindow window)
{
try
{
if (window != null)
{
LinkedList<UIWindow> currentLayerWindows;
if (_layerList.TryGetValue((int) window.uiWindowLayer, out currentLayerWindows)
&& currentLayerWindows != null
&& currentLayerWindows.Count > 0)
{
if (currentLayerWindows.Remove(window))
{
}
currentLayerWindows.AddLast(window);
【工程】from p4
2023-10-19 15:00:19 +08:00
//DebugUtil.Log($"{window.WindowName} sibling index is {window.transform.GetSiblingIndex()}");
【工程】迁移
2023-08-22 19:08:45 +08:00
//return;
}
else
{
if (currentLayerWindows == null)
{
currentLayerWindows = new LinkedList<UIWindow>();
_layerList.Add((int) window.uiWindowLayer, currentLayerWindows);
}
currentLayerWindows.AddLast(window);
}
int siblingIndex = 5; // 让出loading其他想挂在canvas下的奇怪东西
LinkedList<UIWindow> layerWindows;
for (int i = 0; i <= (int) UIWindowLayer.Max; i++)
{
if (_layerList.TryGetValue(i, out layerWindows) && layerWindows != null)
{
if (layerWindows.Count > 0)
{
var e = layerWindows.GetEnumerator();
while (e.MoveNext())
{
选关
2023-10-26 20:20:11 +08:00
var currWindow = e.Current;
if (currWindow != null)
currWindow.transform?.SetSiblingIndex(siblingIndex++);
【工程】迁移
2023-08-22 19:08:45 +08:00
}
}
}
}
var index = window.transform.GetSiblingIndex();
【工程】from p4
2023-10-19 15:00:19 +08:00
//DebugUtil.Log($"{window.WindowName} sibling index is {index}");
【工程】迁移
2023-08-22 19:08:45 +08:00
}
}
catch (Exception e)
{
DebugUtil.LogError(e);
【工程】from p4
2023-10-19 15:00:19 +08:00
DebugUtil.LogError("{0}.LayerListInsertWindow error, window name = {1}", GetType(), window.name);
【工程】迁移
2023-08-22 19:08:45 +08:00
}
}
void LayerListRemoveWindow(UIWindow window)
{
try
{
if (window != null)
{
LinkedList<UIWindow> currentLayerWindows;
if (_layerList.TryGetValue((int)window.uiWindowLayer, out currentLayerWindows))
{
currentLayerWindows?.Remove(window);
}
}
}
catch (Exception e)
{
DebugUtil.LogError(e);
}
}
public bool GetTopWindow(out UIWindow window, out UIWindowLayer layer, int banLayerMask)
{
for (int i = (int)UIWindowLayer.Max; i >= 0; i--)
{
if (((1 << i) & banLayerMask) == 0)
{
LinkedList<UIWindow> highLayerWindows;
if (_layerList.TryGetValue(i, out highLayerWindows))
{
if (highLayerWindows.Count > 0)
{
window = highLayerWindows.Last.Value;
if (window != null)
{
layer = (UIWindowLayer)i;
return true;
}
}
}
}
}
window = null;
layer = UIWindowLayer.Max;
return false;
}
public int LayerMask(UIWindowLayer layer)
{
return 1 << ((int)layer);
}
async void SetFullScreenIOS()
{
await UniTask.Delay(670);
// while (true)
// {
// var screenOrientation = DragonNativeBridge.GetScreenOrientation();
// if (screenOrientation != _currentOrientation)
// {
// _currentOrientation = screenOrientation;
// EventDispatcher.Instance.DispatchEvent(new ScreenOrientationChangedEvent(_currentOrientation));
// }
// yield return wait;
// }
}
public async UniTask LoadNormalUI(string path, bool isActive = false)
{
//var windows = OpenWindow(path);
string uipath = path;
UIWindow window = null;
//if (windowType != UIWindowType.Fixed && ConflictDialogManager.Instance.CheckConflict(uipath, mMemoryWindows))
//{
// return window;
//}
WindowInfo wInfo;
if (!_windowsInfo.ContainsKey(uipath))
{
//if (_windowsInfo.TryGetValue(uipath, out wInfo))
{
【工程】from p4
2023-10-19 15:00:19 +08:00
DebugUtil.LogError("Create ui fail: {0}, no windows info inited", uipath);
【工程】迁移
2023-08-22 19:08:45 +08:00
return;
}
}
wInfo = _windowsInfo[uipath];
var windowType = wInfo.windowType;
var uiWindowLayer = wInfo.windowLayer;
if (!mMemoryWindows.TryGetValue(uipath, out window))
{
window = await UIRoot.Instance.CreateWindow(uipath, windowType);
if (window != null)
{
mMemoryWindows[uipath] = window;
window.WindowName = uipath;
window.m_WindowType = windowType;
window.uiWindowLayer = uiWindowLayer;
}
else
{
【工程】from p4
2023-10-19 15:00:19 +08:00
DebugUtil.LogError("Create ui fail: {0}", uipath);
【工程】迁移
2023-08-22 19:08:45 +08:00
return;
}
}
if (windowType != UIWindowType.Fixed && !mMemoryWindows.TryGetValue(uipath, out window))//不是常显UI
{
if (!mStackWindows.Contains(window))// 不在打开队列里
{
if (windowType == UIWindowType.Normal)//对于Normal类型的UI，需要在打开的时候，将前面打开的UI关闭掉
{
if (mStackWindows.Count > 0)
{
UIWindow stackWindow = mStackWindows.Peek();
if (stackWindow != null)
{
//List<string> friends = ConflictDialogManager.Instance.GetFrinends(uipath);
//if (!friends.Contains(stackWindow.WindowName))//如果不在白名单里, 则关闭
{
CloseWindow(stackWindow.WindowName, true);
}
}
}
}
mStackWindows.Push(window);//添加到打开队列
}
else
{
if (mStackWindows.Count > 0)
{
try
{
UIWindow currentWindow = mStackWindows.Peek();
while (!currentWindow.Equals(window))
{
CloseWindow(currentWindow.WindowName, true);
currentWindow = mStackWindows.Peek();
}
}
catch (Exception e)
{
DebugUtil.LogError(e.Message);
}
}
}
}
else
{
//常显UI，单独处理
}
LayerListInsertWindow(window);
if (!window)
{
【工程】from p4
2023-10-19 15:00:19 +08:00
DebugUtil.LogError("Create ui fail: {0}", uipath);
【工程】迁移
2023-08-22 19:08:45 +08:00
return;
}
if (!isActive)
{
window.HideWindow();
}
else
{
window.OpenWindow();
}
}
//展示全部已加载的NormalUI
public void OpenLoadedNormalUI(string uiName)
{
WindowInfo wInfo;
wInfo = _windowsInfo[uiName];
if (mMemoryWindows.ContainsKey(uiName))
{
mMemoryWindows[uiName].OpenWindow();
}
}
public void CloseAllUI(bool destroy)
{
foreach (var kv in mMemoryWindows)
{
var window = kv.Value;
window.CloseWindow(destroy);
if (destroy)
{
LayerListRemoveWindow(window);
}
}
if (destroy)
{
mMemoryWindows.Clear();
mStackWindows.Clear();
_layerList.Clear();
}
}
public async void ShowUITips(string uiName, string content, int showTime = 1500)
{
//放到最上层
if (!_windowsInfo.ContainsKey(uiName))
{
return;
}
WindowInfo wInfo = _windowsInfo[uiName];
if (wInfo.windowType != UIWindowType.PopupTip)
{
【工程】from p4
2023-10-19 15:00:19 +08:00
DebugUtil.LogError("UI弹窗注册有误，uiName: {0}", uiName);
【工程】迁移
2023-08-22 19:08:45 +08:00
return;
}
OpenWindow(uiName, content);
await UniTask.Delay(showTime);
CloseWindow(uiName);
}
public async void ShowClickShield(string uiPath, int time = 0)
{
//放到最上层
if (!_windowsInfo.ContainsKey(uiPath))
{
return;
}
WindowInfo wInfo = _windowsInfo[uiPath];
if (wInfo.windowType != UIWindowType.PopupTip)
{
【工程】from p4
2023-10-19 15:00:19 +08:00
DebugUtil.LogError("UI遮挡弹窗注册有误，uiName: {0}", uiPath);
【工程】迁移
2023-08-22 19:08:45 +08:00
return;
}
OpenWindow(uiPath);
UIWindow window;
if (mMemoryWindows.TryGetValue(uiPath, out window))
{
if (window.isOpen)
{
window.transform.SetAsLastSibling();
}
}
if (time > 0)
{
await UniTask.Delay(time);
CloseWindow(uiPath);
}
}
public void CloseClickShield(string uiPath)
{
if (mMemoryWindows.ContainsKey(uiPath))
{
if (mMemoryWindows[uiPath].isOpen)
{
CloseWindow(uiPath);
}
}
}
public bool IsWindowOpening(string uiPath)
{
string windowName;
if (_openingWindows.TryGetValue(uiPath, out windowName))
{
if (windowName != null)
{
return true;
}
}
return false;
}
}