yzyCli/u3d/Lua/game/common/BaseView.lua

BaseView = BaseView or BaseClass(UIPartical)

local BaseView = BaseView
local LuaViewManager = LuaViewManager
local lua_viewM = lua_viewM
local GlobalTimerQuest = GlobalTimerQuest
local SetLocalScale = SetLocalScale
local destroy = destroy
local GameObject = GameObject
local UiFactory = UiFactory
local UIZDepth = UIZDepth
local GlobalEventSystem = GlobalEventSystem
local AddClickEvent = AddClickEvent
local EventSystem = EventSystem
local GetChildTransforms = GetChildTransforms
local GetChildGameObjects = GetChildGameObjects
local GetChildImages = GetChildImages
local GetChildTexts = GetChildTexts

BaseView.Class_Type = "BaseView"
BaseView.OpenEvent = "BaseView.OpenEvent"
BaseView.CloseEvent = "BaseView.CloseEvent"
BaseView.DestroyEvent = "BaseView.DestroyEvent"
BaseView.CreateView = "BaseView.CreateView"
BaseView.ChangeVisible = "BaseView.ChangeVisible"

--3D模型背景资源
BaseView.ModelBgRes = {
	[1] = "effect_beibao_1_1",	--蓝色网格
	[2] = "effect_beibao_1_2",	--青色网格
	[3] = "effect_beibao_1_3",	--紫色网格
	[4] = "effect_beibao_2_1",	--青色方块
	[5] = "effect_beibao_3_1",	--蓝色线条
	[6] = "effect_beibao_3_2",	--紫色线条
}

--界面打开/关闭界面缩放参数
BaseView.OpenCloseScaleCfg = 
{
	--打开界面缩放动画参数
	[1] = {start_scale = 0.9, end_scale = 1, time = 0.3},

	--关闭界面缩放动画参数
	[2] = {start_scale = 1, end_scale = 0.9, time = 0.3},
}

OpenMode = {
	OpenOnly = 1,
	OpenToggle = 2,

	OpenDefault = 1,
}

BaseView.LittleMoveDir =
{
	Top = 1,
	Bottom = 2,
	Left = 3,
	Right = 4,
}

CloseMode = {
	CloseVisible = 1,
	CloseDestroy = 2,

	CloseDefault = 2,
}
BaseView.ShowAnimType = {
	Fading = 1, -- 淡入淡出
	-- BlackScreen = 2, -- 黑屏切换
}
function BaseView:__init()
	GlobalEventSystem:FireNextFrame(BaseView.CreateView,self)
end

function BaseView:__defineVar()
	return {
		_class_type = self,						-- 界面类型，通过判断_class_type.Class_Type识别baseview baseitem
		_iid = _in_obj_ins_id,					-- 界面对象标识id
		_use_delete_method = false,				-- 是否调用过delete函数
		_need_wait_blur_bg_loaded = false, 		-- 是否需要等待模糊背景加载完毕
		base_file = ""	,						-- 模块资源名称
		layout_file = "",						-- 界面预设名字
		preLoad_list = false,					-- 打开界面之前需要预加载的资源,除了本模块UI资源外的
		hide_maincancas = false,				-- 是否隐藏主界面
		use_background = false,					-- 窗口背景,用灰色半透明背景
		background_alpha = 0.85,					-- 窗口背景的透明度
		click_bg_toClose = false,				-- 点击背景是否关闭该窗口
		background_wnd = false,					-- 背景蒙版窗口
		destroy_imm = true,						-- 销毁窗口时采用立即销毁模式
		delay_delete_time = 3,  				-- 非立即销毁的界面，关闭后延迟销毁的等待时间
		change_scene_close = false,				-- 切换场景是否关闭
		reenter_scene_close = false,			-- 重新进入场景是否关闭
		change_scene_hide = false, 				-- 切换场景是否隐藏(不与change_scene_close、reenter_scene_close同时使用)
		preparing_res = false,					-- 异步加载进行中
		is_delete = false	,					-- 是否已经删除
		is_set_order_sorting = true, 			-- 是否需要设置深度,自动管理 canvas.sortingOrder
		is_set_zdepth = false, 					-- 是否设置z深度，当需要盖住下层的UI界面上的模型时，要设true
		open_mode = OpenMode.OpenDefault,		-- 打开模式
		close_mode = CloseMode.CloseDefault,	-- 关闭模式
		hide_item_use_view = false, 			-- 打开的时候是否关闭itemuseview
		isPop = false,							-- 是否可见
		wait_for_hide = false,					-- 等待加载完隐藏
		layer_name = "UI",						-- 窗口层次
		append_to_ctl_queue = false,    		-- 添加进入控制队列，打开下层界面时自动关闭上层，关闭下层自动打开上层
		is_delay_callback = true,   			-- 是否延迟调用load_callback和open_callback
		load_callback = false,					-- 加载的回调函数
		open_callback = false,					-- 窗口打开时回调
		close_callback = false,					-- 窗口关闭时回调
		destroy_callback = false,				-- 销毁的回调函数
		show_loading = false,					-- 是否显示加载界面
		is_loaded = false,						-- 是否已经加载完
		cache_findChild = false,				-- 缓存FindChild的接口
		gameObject = false,						-- ugui窗口对象
		transform = false,						-- 窗口transform
		use_local_view = false,   				-- 使用本地界面模式，将预设挂接在编辑器对应的canva层次上才能开启
		is_guide_module = false,				--是否是新手引导模块
		is_hide_skill_black_bg = false,			--是否隐藏羁绊技能的黑色遮罩
		ReOpen_callback = nil, --重新打开界面,刷新事件
		close_fog = nil, --开启界面的时候是否关闭场景FOG效果（如果出现场景中模型or特效和UI上效果显示不一样，开启）使用时候需要 use_background == true 
		blur_activity_bg = false, -- UI背景遮罩的高斯模糊效果
		blur_camera_type = false, -- 模糊背景的摄像机类型
		blur_screenshot = nil, -- 模糊背景截图 nil：使用通用黑色蒙版 false:等待渲染返回 成功会返回Texture图片，而不是Sprite
		blur_anim_time = 0.2, -- 模糊动画时间
		full_screen = false,   --全屏模式
		-- 界面打开后的内部布局动画
		ani_right = false,	   --右侧动画
		ani_left = false,	   --左侧动画 
		adjust_mid = false,	   --中间布局调整 
		ani_list = false,
		-- 打开/关闭界面时的展示动画
		use_show_anim = false, --是否启用打开界面的切换动画
		use_hide_anim = false, --是否启用关闭界面的切换动画
		ignore_use_anim = false, --是否忽略动换动画
		do_show_animation = false , --当前已经处理过了动画的状态，true表示处理过show动画， false表示处理过close动画
		-------------------------
		mask_open_sound = false,--是否屏蔽开界面声音
		mask_close_sound = false,--是否屏蔽关界面声音

		move_node_list = false,	--移动到背景节点列表
		show_back_camera = false,	--打开后渲染摄像机
		back_item_contaner_list = false, --处理view下面的item的back ui 显示和隐藏
		fire_change_visible_event = false, --用于界面显示隐藏通知，常用于模型动作修正
		need_movie_type = true, 		   -- 是否需要播放开启关闭界面动画（针对非黑屏大界面的）
		jump_close = false,--用于某些界面跳转了之后就需要关掉界面

		model_activity_bg = false,		 -- 3d背景模式,带镜面反射,一级全屏界面才需要
		model_activity_bg_pos = false,   -- 3d背景的偏移坐标，默认是居中的，如果你的模型不是居中的话就要调整坐标
		model_activity_bg_type = 2,		 -- 3d背景的默认样式类型

		little_move_tween_list = false,			--界面4方向缓动动画数组
		little_move_event = false,			--界面4方向缓事件监听
		little_move_table = false,			--界面4方向缓动动画数据
		little_move_load_view_time_id = false,	--界面打开时，缓动处理延时定时器
		little_move_is_show_anim = false,	--界面打开时，是否已经显示过进入动画

		hide_clear_role_model = true, --隐藏时删除模型

		need_culling_mask_ground = false, --打开界面是否需要摄像机剔除ground层（加载模型较多的界面可加上，取消渲染ground稍微增加性能）
		force_no_ctl_queue = false,--强制不加入堆栈

		open_guide_close = false,		--打开引导界面时(功能开放界面)，是否关闭界面（复用change_scene_close的设置）		
	}
end

--打开界面之前需要预加载的资源
function BaseView:AddPreLoadList(abName, assetNameList, type)
	if not self.preLoad_list then
		self.preLoad_list = {}
	end
	table.insert(self.preLoad_list,{type, abName, assetNameList})
end

--[[
获取子对象的transform
特别注意此方法是从根节点开始搜寻子对象 所以要写全路径 比如："input/Text"
]]
function BaseView:GetChild(name)
	if self.cache_findChild and self.transform then
		return self.cache_findChild(self.transform,name)
	end
end

function BaseView:GetChildComponent(name,com)
	return self:GetChild(name):GetComponent(com)
end

--获取多个孩子transform
function BaseView:GetChildTransforms(names)
	return GetChildTransforms(self.transform, names)
end

--获取多个孩子go
function BaseView:GetChildGameObjects(names)
	return GetChildGameObjects(self.transform, names)
end

--获取多个孩子image
function BaseView:GetChildImages(names)
	return GetChildImages(self.transform, names)
end

--获取多个孩子text
function BaseView:GetChildTexts(names)
	return GetChildTexts(self.transform, names)
end

--是否真正打开  判断依据是调用了open以及资源加载已经完成
function BaseView:HasOpen()
	return self.isPop and self.is_loaded and not self.wait_for_hide
end

function BaseView:Open()
	print("[ BaseView Open ]: source = ",self._class_type._source, "layout_file = ",self.layout_file)
	self.isPop = true
	self.wait_for_hide = false
	self.is_in_close_anim = false
	self._use_delete_method = false
	self:RemoveDestroyTimer()
	-- -- 如果设备不支持高斯模糊后处理，则强制不渲染
	-- if self.blur_activity_bg then
	-- 	if MainCamera.Instance:GetRenderSupport() then
	-- 		self.blur_screenshot = false
	-- 		local function blur_screenshot_callback(screenshot)
	-- 			self.blur_screenshot = screenshot
	-- 			self:SetBackgroundWnd()
	-- 		end
	-- 		MainCamera.Instance:GetCameraBlurScreenShot(blur_screenshot_callback, self.blur_camera_type)
	-- 	else
	-- 		self.blur_screenshot = false
	-- 		self.blur_activity_bg = false
	-- 	end
	-- end
	if self.open_mode == OpenMode.OpenOnly then
		BaseView.OpenOnly(self)
		
	elseif self.open_mode == OpenMode.OpenToggle then
		BaseView.OpenToggle(self)
	end
	local auto_close_view = function()
		self:Close()
	end

	local auto_change_scene_close_view = function()
		if SceneManager:getInstance():IsDailyCircleDungeon() then--如果现实进入镜像场景，则关掉该界面
			self.is_in_daily_circle_dungeon = true
		elseif self.is_in_daily_circle_dungeon then  --如果当前场景不是镜像场景，并且又是镜像场景出来的。也不关掉界面
			self.is_in_daily_circle_dungeon = false
		else
			self:Close()		
		end		
	end	
	if self.change_scene_close and not self.change_scene_close_event_id then
		self.change_scene_close_event_id = EventSystem.Bind(GlobalEventSystem,SceneEventType.SCENE_CHANGED,auto_change_scene_close_view)
	end

	--复用切场景关闭的设置(或者是有背景的界面， 或者是全屏界面)
	self.open_guide_close = ( self.use_background and self.open_guide_close ~= nil)  or  self.open_guide_close or (self.open_guide_close ~= nil and self.change_scene_close or false)
	if self.open_guide_close and not self.open_guide_close_id then
		self.open_guide_close_id = EventSystem.Bind(GlobalEventSystem,EventName.OPEN_GUIDE_CLOSE_VIEW,auto_close_view)
	end

	if self.reenter_scene_close and not self.reenter_close_event_id then
		self.reenter_close_event_id = EventSystem.Bind(GlobalEventSystem,SceneEventType.SCENE_REENTER,auto_close_view)
	end

	if not self.change_scene_close and not self.change_scene_close and self.change_scene_hide and not self.change_scene_hide_event_id and not self.change_scene_complete_event_id then
		local auto_hide_view = function()
			self:Hide()
		end

		local auto_show_view = function()
			self:CancelHide()
		end

		self.change_scene_hide_event_id = EventSystem.Bind(GlobalEventSystem,SceneEventType.OPEN_SCENE_LOAD_VIEW,auto_hide_view)
		self.change_scene_complete_event_id = EventSystem.Bind(GlobalEventSystem,EventName.SCENE_LOAD_VIEW_COMPLETE,auto_show_view)
	end

	if self.use_background and self.hide_maincancas and not self.all_close_event_id then
		self.all_close_event_id = EventSystem.Bind(GlobalEventSystem,EventName.CLOSE_ALL_VIEW,auto_close_view)
	end
	local function on_jump_close()
		if self._use_delete_method then return end
		self:Close()
	end
	if self.jump_close and not self.jump_close_event_id then
		self.jump_close_event_id = EventSystem.Bind(GlobalEventSystem,EventName.JUMP_CLOSE_EVENT,on_jump_close)
	end

	local function onOrientationChange(  )
		self:SetIpxMode()
	end
	if not self.orientation_change_id then
		self.orientation_change_id = GlobalEventSystem:Bind(EventName.ORIENTATION_DID_CHANGE, onOrientationChange)	
	end

	if self.is_guide_module and not self.trigger_guide_id then
		local function onTriggerGuideHandler()
			if not self.is_loaded then
				return
			end
			if self.AddToStageHandler then
				self:AddToStageHandler()
			end
		end
		self.trigger_guide_id = EventSystem.Bind(GlobalEventSystem,EventName.TRIGGER_GUIDE_TYPE,onTriggerGuideHandler)
	end

	EventSystem.Fire(GlobalEventSystem,BaseView.OpenEvent, self.layer_name, self)	

	-- if (self.key_back_to_close == true or (self.use_background and self.hide_maincancas)) and self.key_back_to_close_id == nil then
	-- 	local function on_force_close(  )
	-- 		if BaseView.LastTabIndex and BaseView.LastTabIndex > 0 then
	-- 			GlobalEventSystem:Fire(EventName.KEY_BACK_CHANGE)
	-- 		else
	-- 			self:Close()
	-- 		end
	-- 	end
	-- 	BaseView.KeyBackWinCount = BaseView.KeyBackWinCount and BaseView.KeyBackWinCount + 1 or 1
	-- 	self.key_back_to_close_id = GlobalEventSystem:Bind(EventName.KEY_BACK_CLOSE, on_force_close)
	-- end
end

function BaseView:OpenOnly()
	self.is_delete = false
	if self.preparing_res then
		return
	end

	-- 打开的时候界面还在缓存中
	if self.gameObject then
		BaseView.AfterOpen(self)
		if not self.destroy_imm then --如果是非立即销毁的界面，要重新设置父节点
			self.transform:SetParent(panelMgr:GetParent(self.layer_name))
		end
		return
	end
	self:AsnycLoadLayout()

	if self.layer_name ~= "Main" and not self.mask_open_sound then
		lua_soundM:PlayUIEffectSound(LuaSoundManager.SOUND_UI.OPEN)
	end
end

function BaseView:AsnycLoadLayout()
	local preLoad_index = 0
	local preLoad_list_len = 0

	if self.show_loading then
		LuaViewManager.AddLoadingView(lua_viewM, self._iid)
	end

	local function preLoadCallback()
		preLoad_index = preLoad_index + 1
		if preLoad_list_len == 0 or preLoad_index == preLoad_list_len then
			local res_load_finish = function(obj)
				self:DoCreateWindowIndeed(obj)
			end

			if self.base_file == "" then
				-- 没有预设体的界面，直接创建空对象
				local go = UiFactory.createChild(panelMgr:GetParent(self.layer_name), UIType.EmptyObject, LuaMemManager.GetLastStr(self._class_type._source,"/"))
				res_load_finish(go)
			else
				LuaViewManager.LoadView(lua_viewM, self,self.base_file, self.layout_file, self.layer_name, res_load_finish)
			end
		end
	end

	-- 先加载额外的依赖资源包
	self.preparing_res = true
	self.is_loaded = false
	if self.load_time_out_id then
		TimerQuest.CancelQuest(GlobalTimerQuest, self.load_time_out_id)
		self.load_time_out_id = nil
	end

	local function onCheckTimeOut()
		if self.layer_name == "UI" then
			self.preparing_res = false
			self:Close()
		end
	end
	-- 15秒都打不开界面则自动触发关闭流程，避免影响后续操作
	self.load_time_out_id = TimerQuest.AddDelayQuest(GlobalTimerQuest, onCheckTimeOut, 15)

	if self.preLoad_list then
		local vo = nil
		preLoad_list_len = #self.preLoad_list
		for i = 1, preLoad_list_len do
			vo = self.preLoad_list[i]
 			lua_resM:LoadRes(self, vo[1], vo[2], vo[3], preLoadCallback)
		end
		self.preLoad_list = nil
	else
		preLoadCallback()
	end

end

function BaseView:DoCreateWindowIndeed(obj)
	
	--iphone低端机强制设立即销毁
	if SystemMemoryLevel.Cur == SystemMemoryLevel.Low and SystemRuntimePlatform.IsIphone() then
		self.destroy_imm = true
	end

	if self.load_time_out_id then
		TimerQuest.CancelQuest(GlobalTimerQuest, self.load_time_out_id)
		self.load_time_out_id = false
	end

	--资源下载或加载失败
	if obj == nil then
		self.preparing_res = false
		self:Close()
		return
	end

	self.gameObject = obj
	if self.isPop == false then --如果加载回来时,外部已经调用了关闭流程,则直接销毁界面
		self:Destroy()
		return
	end

	-- 缓存频繁访问的对象
	self.transform = obj.transform
	self.cache_findChild = self.transform.Find

	--统一处理是否显示界面打开/关闭动画
	self.use_show_anim = not self.ignore_use_anim and (self.use_background and not self.model_activity_bg) or self.use_show_anim
	self.use_hide_anim = not self.ignore_use_anim and (self.use_background and not self.model_activity_bg) or self.use_hide_anim	
	if not ClientConfig.view_scale_ani_mode then
		self.use_show_anim = false
		self.use_hide_anim = false
	end
	if self.use_show_anim then
		local cfg = BaseView.OpenCloseScaleCfg[1]
		SetLocalScale(self.transform, cfg.start_scale, cfg.start_scale, cfg.start_scale)
	else
		SetLocalScale(self.transform)
	end
	
	self:InitViewAnimation()
	if self.show_loading then
		LuaViewManager.RemoveLoadingView(lua_viewM, self._iid)
	end

	-- 设置背景的逻辑封装成一个函数
	self:SetBackgroundWnd()

	if self.show_back_camera then
		self:ShowBackModeCamera()
	end

	self.base_view_closeBtn = self.transform:Find("Window/windowCloseBtn") or self.transform:Find("Window2/windowCloseBtn")
	if self.base_view_closeBtn then
		self.base_view_closeBtn:GetComponent("Image"):SetNativeSize()
		local function onCloseHandler()
			self:Close()
		end
		AddClickEvent(self.base_view_closeBtn.gameObject,onCloseHandler, nil, true )

		self.base_view_titleText = self.transform:Find("Window/windowTitleCon/windowTitleText") or self.transform:Find("Window2/windowTitleCon/windowTitleText")
	end

	-- self.base_view_bg = self.transform:Find("Window") or self.transform:Find("Window2")
	-- if self.base_view_bg then
	-- 	local img = self.base_view_bg:GetComponent("Image")
	-- 	if img then
	-- 		img.raycastTarget = true
	-- 	end
	-- end

	-- --main层的UI都挂在main_cancas_con，以实现显示隐藏修改的需要
	-- if self.layer_name == "Main" and not self.hide_maincancas then
	-- 	LuaViewManager.PuskMainCanvasCon(lua_viewM, self.transform)
	-- end
	if not self._need_wait_blur_bg_loaded then
		BaseView.CreateMainWindow(self)
		self.preparing_res = false
	end
end

function BaseView:SetBackgroundWnd(  )
	-- 未加载完则不处理
	if not self.gameObject then 
		return 
	end
	
	self.blur_activity_bg = false

	if self.use_background and self.model_activity_bg then
		self.close_fog = true
	end

	local function create_background_wnd()
		if self.blur_screen_time_out_id then
			TimerQuest.CancelQuest(GlobalTimerQuest, self.blur_screen_time_out_id)
			self.blur_screen_time_out_id = nil
		end
		if self.model_activity_bg then
			local function on_delay(  )
				self:UpdateModelBg()	
			end
			setTimeout(on_delay, 0.1)
		else
			self.background_wnd = self.background_wnd or UiFactory.createChild(self.transform, UIType.Background,"activity_bg")
			self.background_wnd_raw = self.background_wnd:GetComponent("RawImageExtend")
			if self.blur_screenshot == nil then -- 不使用模糊背景
				self.background_wnd_raw.alpha = self.background_alpha
			elseif self.blur_screenshot == false then -- 等待模糊背景返回
				self.background_wnd_raw.alpha = 0
			elseif self.blur_screenshot then
				self.background_wnd_raw.color = ColorUtilValue.BLURGRAY
				self.background_wnd_raw.texture = self.blur_screenshot
			end
		
			if self.use_show_anim then
				local cfg = BaseView.OpenCloseScaleCfg[1] 
				if cfg and cfg.start_scale ~= 0 then
					self.background_wnd.transform.sizeDelta = Vector2(SrcScreenWidth / cfg.start_scale, ScreenHeight/cfg.start_scale)
				else
					self.background_wnd.transform.sizeDelta = Vector2(SrcScreenWidth, ScreenHeight)	
				end		
			else
				self.background_wnd.transform.sizeDelta = Vector2(SrcScreenWidth, ScreenHeight)
			end

			self.background_wnd.transform:SetAsFirstSibling()
			SetAnchoredPosition(self.background_wnd.transform, 0, 0)

			if self.background_wnd and self.click_bg_toClose then
				local function onClickHandler()
					self:Close()
				end
				AddClickEvent(self.background_wnd,onClickHandler,nil,false)
			end
		end
		-- 不管有没有模糊都要尝试执行这块逻辑，这种写法也包含了模糊逻辑超时之后打开界面的处理
		if self._need_wait_blur_bg_loaded then
			BaseView.CreateMainWindow(self)
			self.preparing_res = false
		end
	end

	if self.use_background then
		if self.model_activity_bg then
			self.blur_activity_bg = false
		end
		self.on_blur_screen_finish = false --记录高斯模糊完成标识，超时的话则创建普通背景，避免异常情况界面无法关闭
		-- 如果设备不支持高斯模糊后处理，则强制不渲染
		-- if self.blur_activity_bg then
		-- 	if MainCamera.Instance:GetRenderSupport() then
		-- 		self.blur_screenshot = false
		-- 		-- 需要等待模糊图返回才打开界面
		-- 		self._need_wait_blur_bg_loaded = true
		-- 		-- 如果要使用打开或关闭动画，则需要动态添加CanvasGroup组件
		-- 		if self.use_show_anim or self.use_hide_anim then
		-- 			local canvas_group = self.gameObject:GetComponent(typeof(UnityEngine.CanvasGroup))
		-- 			if not canvas_group then
		-- 				canvas_group = self.gameObject:AddComponent(typeof(UnityEngine.CanvasGroup))
		-- 			end
		-- 			canvas_group.alpha = 0
		-- 		end
		-- 		-- 创建回调用来接收RenderTexture
		-- 		local function blur_screenshot_callback(renderTexture)
		-- 			self.on_blur_screen_finish = true
		-- 			self.blur_screenshot = renderTexture
		-- 			if self._use_delete_method then -- 如果已经在执行销毁了，则立即回收rt
		-- 				MainCamera.Instance:ClearScreenShotCache(self.blur_screenshot)
		-- 				return 
		-- 			end
		-- 			create_background_wnd()
		-- 			if self.bg_back_func then--背景放到后面回调 具体参考EquipGemstoneAutoUpView
		-- 				self.bg_back_func()
		-- 			end
		-- 		end
		-- 		MainCamera.Instance:GetCameraBlurScreenShot(blur_screenshot_callback, self.blur_camera_type)

		-- 		if self.click_bg_toClose then
		-- 			local function onBlurTimeout(  )
		-- 				if not self.on_blur_screen_finish then
		-- 					self.blur_activity_bg = false
		-- 					create_background_wnd()
		-- 				end
		-- 			end
		-- 			if self.blur_screen_time_out_id then
		-- 				TimerQuest.CancelQuest(GlobalTimerQuest, self.blur_screen_time_out_id)
		-- 				self.blur_screen_time_out_id = nil
		-- 			end
		-- 			self.blur_screen_time_out_id = TimerQuest.AddDelayQuest(GlobalTimerQuest, onBlurTimeout, 3)
		-- 		end
		-- 	else
		-- 		self.blur_activity_bg = nil
		-- 		create_background_wnd()
		-- 	end
		-- else
			create_background_wnd()
		-- end
	end
end

-- 更新3D模型背景
function BaseView:UpdateModelBg( bg_type )
	if IsNull(self.gameObject) then
		return
	end

	self.model_activity_bg_type = bg_type or self.model_activity_bg_type
	--过滤重复
	if self.last_model_bg_type and self.last_model_bg_type == self.model_activity_bg_type then
		return
	end
	self.last_model_bg_type = self.model_activity_bg_type

	--先从缓存池取
	self.model_activity_bg_objs = self.model_activity_bg_objs or {}
	for k,v in pairs(self.model_activity_bg_objs) do
		local obj = v.obj
		if not IsNull(obj) then
			obj:SetActive(false)
		end
	end
	local cache_model_bg = self.model_activity_bg_objs[self.model_activity_bg_type]
	if cache_model_bg and cache_model_bg.obj and not IsNull(cache_model_bg.obj) then
		cache_model_bg.obj:SetActive(false)
		cache_model_bg.obj:SetActive(true)
		return
	end
	
	--再去加载
	local cur_res_name = BaseView.ModelBgRes[self.model_activity_bg_type] or BaseView.ModelBgRes[1]
	local function load_finish_func(objs, is_gameObject)
		if self._use_delete_method then
			return
		end
    	if not objs or not objs[0] then
			return
		end
		local go = is_gameObject and objs[0] or newObject(objs[0])
		local go_name = go.name
		local new_res_type, new_res_name = self:GetModelBgName(go_name)
		if new_res_name ~= cur_res_name then --当前加载完成的不是最新的，则回收
			self:DeleteModelBg(new_res_name, go)
			return
		end
		self.model_activity_bg_objs = self.model_activity_bg_objs or {}
		if self.model_activity_bg_objs[new_res_type] then
			destroy(go)
			return
		end
		self.model_activity_bg_objs[new_res_type] = {name = new_res_name, obj = go}
		go.transform:SetParent(self.transform) 
		go:SetActive(false)
		go:SetActive(true)
		if self.model_activity_bg_pos then
			SetLocalPosition(go.transform, self.model_activity_bg_pos.x, self.model_activity_bg_pos.y, -50000)
		else
	    	SetLocalPosition(go.transform, 0, 0, -50000)
	    end		            
		SetLocalRotation(go.transform)
		SetLocalScale(go.transform, 100)
    end
    local function bg_load_delay_func( ... )
		lua_resM:loadPrefab(self, cur_res_name, cur_res_name, load_finish_func, false, ASSETS_LEVEL.HIGHT)
    end
    self.model_bg_time_id = setTimeout(bg_load_delay_func,0.01)
end

function BaseView:GetModelBgName( obj_name )
	local res_type, res_name 
	for k,v in pairs(BaseView.ModelBgRes) do
		if string.find(obj_name, v, 1, true) then
			res_type = k
			res_name = v
			break
		end
	end
	return res_type, res_name
end

function BaseView:DeleteModelBg( name, obj )
	--指定回收
	if name and not IsNull(obj) then
		lua_resM:AddObjToPool(self, name, name, obj)
		return
	end
	--全部回收
	if self.model_activity_bg_objs then
		for k,v in pairs(self.model_activity_bg_objs) do
			local temp_name, temp_obj = v.name, v.obj
			if not IsNull(temp_obj) then
				lua_resM:AddObjToPool(self, temp_name, temp_name, temp_obj)
			end
		end
		self.model_activity_bg_objs = false
	end
end

function BaseView:CreateMainWindow()

	if self.is_delay_callback and self.hide_maincancas then --大界面才需要延迟callback
		local function onLoad()
			self.is_loaded = true
			self:BeforeLoad()
			if self.load_callback and not self.is_delete and self.gameObject then
				self.load_callback()
			end
		end

		if self._base_delay_load_id then
			LuaViewManager.RemoveDelayQueue(lua_viewM, self._base_delay_load_id)
			self._base_delay_load_id = false
		end
		self._base_delay_load_id = LuaViewManager.AddDelayQueue(lua_viewM, onLoad)
	else
		self.is_loaded = true
		self:BeforeLoad()
		if self.load_callback then
			self.load_callback()
		end
	end
	-- 重置等待变量
	self._need_wait_blur_bg_loaded = false
	BaseView.AfterOpen(self)
end

function BaseView:AfterOpen()
	if not self.gameObject then
		return
	end

	if self.isPop then
		BaseView.PlayOpenMovie(self)
		local function onOpen()
			if self.open_callback then
				self.open_callback()
			end
			if self.use_background and self.close_fog == true then
				Scene.Instance:ChangeFogEnable(false)
			end
			if self.is_guide_module then
				if self.AddToStageHandler then
					self:AddToStageHandler()
				end
			end
			if self.hide_item_use_view then
				LuaViewManager.Fire(lua_viewM, LuaViewManager.HIDE_ITEM_USE_VIEW, true)
			end
			if self.is_hide_skill_black_bg then
				SkillManager:getInstance():AddHideBlackViews(self.layout_file)
				HideBlackGround()
			end
			if self.change_scene_hide and not Scene:getInstance():IsSceneProloadFinish() then
				self:Hide()
			end

			self:DoOpenAni()
			--self:DoShowViewAnimation(true)
			self:DoShowViewScaleAnimation(true)
		end
		if self.wait_for_hide then
			self.gameObject:SetActive(false)
			if self.is_set_zdepth then
				UIZDepth.ResetUIZDepth(self)
			end
			if self.hide_maincancas then
				LuaViewManager.Fire(lua_viewM, LuaViewManager.CHANGE_MAIN_CANVAS_VISIBLE, self, true )
			end
		elseif self.wait_for_hide == false then
			if self.hide_maincancas then
				LuaViewManager.Fire(lua_viewM, LuaViewManager.CHANGE_MAIN_CANVAS_VISIBLE, self, false)
			end
			if not self.gameObject.activeSelf then
				self.gameObject:SetActive(true)
			end
		end
		self.wait_for_hide = false
		if self.is_set_order_sorting then 
			self:SetUIDepth(self.gameObject)
		end		
		local curr_zdepth_count = nil
		if self.is_set_zdepth then 
			curr_zdepth_count = self:AddUIZDepth()
		end
		if self.layer_name == "Main" and not lua_viewM.main_cancas_last_visible then
			LuaViewManager.PuskMainCanvasCon(lua_viewM, self.transform)
		end
		if self.is_delay_callback and self.hide_maincancas then --大界面才需要延迟callback
			local function onDelayOpen()
				if not self.is_delete and self.isPop and self.gameObject then
					onOpen()
					if curr_zdepth_count then
						UIZDepth.SetUIZDepth(self, curr_zdepth_count)
					end
				end
			end

			if self.delay_open_id then
				LuaViewManager.RemoveDelayQueue(lua_viewM, self.delay_open_id)
				self.delay_open_id = false
			end
			self.delay_open_id = LuaViewManager.AddDelayQueue(lua_viewM, onDelayOpen)
		else
			onOpen()
		end

		LuaViewManager.OpenView(lua_viewM, self)
	else
		self:Close()
	end
end

function BaseView:AfterClose()
	if self.layout_file ~= "GuidePromptView" then
		LuaViewManager.CloseView(lua_viewM, self)
	end	
	--下面这句话要放在clse_callback前面 因为有些是在close_callback 关掉界面 会导致重新调用cancelhide 导致主界面被隐藏
	-- LuaViewManager.CloseView(lua_viewM, self)
	UIPartical.ClearAllEffect(self)
	if self.close_callback and self.is_loaded then
		self.close_callback()
	end
	-- if self.use_background and self.close_fog == true and not self.append_to_ctl_queue then --改到 luaViewManager 中开启
	-- 	Scene.Instance:ChangeFogEnable(true)
	-- end
end

function BaseView:OpenToggle()
	if self.gameObject and self.isPop then
		self:Close()
	else
		self:OpenOnly()
	end
end

function BaseView:Close(called_by_mgr)
	self.isPop = false
	local function close_callback()
		if self.close_mode == CloseMode.CloseVisible then
			BaseView.CloseVisible(self)
		elseif self.close_mode == CloseMode.CloseDestroy then
			BaseView.CloseDestroy(self)
		end
	end
	if self.use_hide_anim then		
		-- if not self.is_in_close_anim then
			--self:DoShowViewAnimation(false)		
			self:DoShowViewScaleAnimation(false, close_callback)
			-- self.is_in_close_anim = true
		-- else
			-- close_callback()
		-- end		
	else
		close_callback()
	end
	-------------------------
	if self.layer_name ~= "Main" and not self.mask_close_sound then
		lua_soundM:PlayUIEffectSound(LuaSoundManager.SOUND_UI.CLOSE)
	end
	-------------------------
end

--隐藏
function BaseView:Hide()
	if self.gameObject then
		if self.hide_maincancas then
			LuaViewManager.Fire(lua_viewM, LuaViewManager.CHANGE_MAIN_CANVAS_VISIBLE, self, true)
		end
		self.gameObject:SetActive(false)
		self.wait_for_hide = nil
		self:SetBackUIVisible(false)
		if self.fire_change_visible_event then
	 		GlobalEventSystem:Fire(BaseView.ChangeVisible, false)
	 	end
	else
		self.wait_for_hide = true
	end
	if self.HideChangeCall then
		--有的界面需要在显隐的时候调用函数
		self:HideChangeCall(false)
	end
end

--取消隐藏
function BaseView:CancelHide()
	self.isPop = true
	self.wait_for_hide = false
	BaseView.RemoveDestroyTimer(self)
	if self.hide_maincancas then
		LuaViewManager.Fire(lua_viewM, LuaViewManager.CHANGE_MAIN_CANVAS_VISIBLE, self, false)
	end
	-- -- 重新添加背景模糊特效
	-- if self.blur_activity_bg then
	-- 	MainCamera.Instance:EnableBlurEffect(self.blur_camera_type, self.blur_anim_time)
	-- end
	--self:DoShowViewAnimation(true)
	--self:DoShowViewScaleAnimation(true)
	self:SetBackUIVisible(true)


	if self.gameObject then
		if IsNull(self.gameObject) then
			local str = "base view CancelHide is nil  " .. tostring(self.layout_file)		
			GameError.Instance:SendErrorMsg(str)
		else
			self.gameObject:SetActive(true)
			if self.ReOpen_callback then
				self:ReOpen_callback()
			end
			if self.fire_change_visible_event then
		 		GlobalEventSystem:Fire(BaseView.ChangeVisible, true)
		 	end
		end			
	end		


	local cache_model_bg = self.model_activity_bg_objs and self.model_activity_bg_objs[self.model_activity_bg_type]
	if cache_model_bg and cache_model_bg.obj and not IsNull(cache_model_bg.obj) then
		cache_model_bg.obj:SetActive(false)
		cache_model_bg.obj:SetActive(true)
		return
	end
	if self.HideChangeCall then
		--有的界面需要在显隐的时候调用函数
		self:HideChangeCall(true)
	end
end

function BaseView:CloseVisible()
	if self.gameObject then
		if IsNull(self.gameObject) or IsNull(self.transform) then
			if self.layout_file ~= "GuidePromptView" then
				local str = "base view CloseVisible is nil  " .. tostring(self.layout_file)
				GameError.Instance:SendErrorMsg(str)
			end			
		else
			if self.close_mode == CloseMode.CloseDestroy and self.destroy_imm and not self.use_local_view then
				self.transform:SetParent(UiFactory.GetSceneCanvas())
			else
				self.gameObject:SetActive(false)
			end	
		end	
	end

	self:StopLittleMoveAnim()

	if self.key_back_to_close_id then
		if BaseView.KeyBackWinCount and BaseView.KeyBackWinCount > 0 then
			BaseView.KeyBackWinCount = BaseView.KeyBackWinCount - 1			
		end
		GlobalEventSystem:UnBind(self.key_back_to_close_id)
		self.key_back_to_close_id=nil
	end

	if self.change_scene_close_event_id then
		EventSystem.UnBind(GlobalEventSystem,self.change_scene_close_event_id)
		self.change_scene_close_event_id=nil
	end

	if self.open_guide_close_id then
		EventSystem.UnBind(GlobalEventSystem,self.open_guide_close_id)
		self.open_guide_close_id=nil
	end

	if self.change_scene_hide_event_id then
		EventSystem.UnBind(GlobalEventSystem,self.change_scene_hide_event_id)
		self.change_scene_hide_event_id=nil
	end

	if self.change_scene_complete_event_id then
		EventSystem.UnBind(GlobalEventSystem,self.change_scene_complete_event_id)
		self.change_scene_complete_event_id=nil
	end

	if self.all_close_event_id then
		EventSystem.UnBind(GlobalEventSystem,self.all_close_event_id)
		self.all_close_event_id = nil
	end

	if self.jump_close_event_id then
		EventSystem.UnBind(GlobalEventSystem,self.jump_close_event_id)
		self.jump_close_event_id = nil
	end

	if self.orientation_change_id then
		EventSystem.UnBind(GlobalEventSystem,self.orientation_change_id)
		self.orientation_change_id = nil
	end

	if self.reenter_close_event_id then
		EventSystem.UnBind(GlobalEventSystem,self.reenter_close_event_id)
		self.reenter_close_event_id = nil
	end

	if self.delay_open_id then
		LuaViewManager.RemoveDelayQueue(lua_viewM, self.delay_open_id)
		self.delay_open_id = nil
	end

	if self.load_time_out_id then
		TimerQuest.CancelQuest(GlobalTimerQuest, self.load_time_out_id)
		self.load_time_out_id = nil
	end

	if self.is_hide_skill_black_bg then
		SkillManager:getInstance():RemoveHideBlackViews(self.layout_file)
	end

	if self.hide_maincancas then
		LuaViewManager.Fire(lua_viewM,LuaViewManager.CHANGE_MAIN_CANVAS_VISIBLE, self, true)
	end

	self:ClearOpenMovieId()

	if self.hide_item_use_view then
		LuaViewManager.Fire(lua_viewM, LuaViewManager.HIDE_ITEM_USE_VIEW, false)
	end
	--隐藏时自动删掉挂接的模型,需要在对应界面的opencallback后重新创建
	if self.hide_clear_role_model then
		lua_resM:clearRoleMode(self)
	end
	if self.is_set_zdepth and not IsNull(self.transform) then
		UIZDepth.ResetUIZDepth(self)
	end
	-- 如果存在模糊背景图，则需要传到C#中销毁
	if self.blur_screenshot then 
		MainCamera.Instance:ClearScreenShotCache(self.blur_screenshot)
	end

	if self.blur_screen_time_out_id then
		TimerQuest.CancelQuest(GlobalTimerQuest, self.blur_screen_time_out_id)
		self.blur_screen_time_out_id = nil
	end
	BaseView.AfterClose(self)
end

function BaseView:CloseDestroy()
	self:CloseVisible()

	if self.destroy_imm then
		BaseView.Destroy(self)
	else
		BaseView.AddDestroyTimer(self)
	end
end

function BaseView:RemoveDestroyTimer()
	if self.destroy_timer then
		TimerQuest.CancelQuest(GlobalTimerQuest, self.destroy_timer)
		self.destroy_timer = false
	end
end

function BaseView:AddDestroyTimer()
	BaseView.RemoveDestroyTimer(self)

	local destroy_callback = function()
		self.destroy_timer = false
		self:Destroy()
	end
	self.destroy_timer = TimerQuest.AddDelayQuest(GlobalTimerQuest, destroy_callback, self.delay_delete_time)
end

function BaseView:Destroy()
	if self.is_delete or not self.gameObject then return end

	if self.model_bg_time_id then
		GlobalTimerQuest:CancelQuest(self.model_bg_time_id)
		self.model_bg_time_id = nil
	end

	if self._base_delay_load_id then
		LuaViewManager.RemoveDelayQueue(lua_viewM, self._base_delay_load_id)
		self._base_delay_load_id = false
	end

	if self.trigger_guide_id then
		EventSystem.UnBind(GlobalEventSystem, self.trigger_guide_id)
		self.trigger_guide_id = false
	end

	if self.orientation_id then
		EventSystem.UnBind(GlobalEventSystem, self.orientation_id)
		self.orientation_id = false
	end

	if self.ui_camera_flag_change_id then
		EventSystem.UnBind(GlobalEventSystem, self.ui_camera_flag_change_id)
		self.ui_camera_flag_change_id = false
	end
	-- -- 去除模糊效果
	-- if self.blur_activity_bg then
	-- 	MainCamera.Instance:DisableBlurEffect(self.blur_anim_time)
	-- end
	-- 确认清除掉了界面动画效果
	if self.fading_anim_id then
		TweenLite.Stop(self.fading_anim_id)
		self.fading_anim_id = nil
	end

	if self.scale_anim_id then
		TweenLite.Stop(self.scale_anim_id)
		self.scale_anim_id = nil
	end		
	if self.autoDeleteList then
		for i,v in ipairs(self.autoDeleteList) do
			if v ~= nil then
				v:DeleteMe()
			end
		end
		self.autoDeleteList = nil
	end
	self.is_delete = true

	UI.BindEventComp.UnBindAll(self)
	if self.action_nodes then
		for k,v in pairs(self.action_nodes) do
			cc.ActionManager:getInstance():removeAllActionsFromTarget(v)
		end
		self.action_nodes = nil
	end

	if self.effect_nodes then
		for k,v in pairs(self.effect_nodes) do
			self:ClearUIEffect(v)
		end
	end

	self:AfterDestroy()

	BaseView.RemoveDestroyTimer(self)
	if self.destroy_callback and self.is_loaded then
		self.destroy_callback()
	end

	if self.show_loading then
		LuaViewManager.RemoveLoadingView(lua_viewM, self._iid)
	end
	self.preparing_res = false
	self.is_loaded = false
	self.popChild = nil
	self.parent_wnd = nil
	self.transform = nil
	self.cache_findChild = nil
	self.preLoad_list = nil
	self.back_item_contaner_list = false

	self:DeleteModelBg()

	self:DeleteMe()
	LuaViewManager.DestroyView(lua_viewM,self.gameObject)
	self.gameObject = nil
	EventSystem.Fire(GlobalEventSystem,BaseView.DestroyEvent,self)
end

function BaseView:__delete()
	self:RemoveUIFromBack()
	if not self.is_delete then
		self:CloseDestroy()
	end
end

-- 显示子窗口
function BaseView:PopUpChild(win)
	if win then
	 	if self.popChild ~= nil and self.popChild ~= win then
	 		self.popChild:SetVisible(false, true)
	 	end
	 	self.popChild = win
	 	self.popChild:SetVisible(true, true)
	 	if self.fire_change_visible_event then
	 		GlobalEventSystem:Fire(BaseView.ChangeVisible, true)
	 	end
	 end
 end

function BaseView:GetBaseFile()
	return self.base_file
end

function BaseView:GetChildren( names )
	GetChildren(self, names)
end

--自销毁事件
function BaseView:BindEvent( bindDispather, eventName, handleFunc )
	return UI.BindEventComp.BindEvent(self, bindDispather, eventName, handleFunc)
end

--关闭界面时销毁该节点
function BaseView:AutoDelete( deleteNode )
	self.autoDeleteList = self.autoDeleteList or {}
	table.insert(self.autoDeleteList, deleteNode)
end

--自销毁节点
function BaseView:CreateItem( class_name, parent, layer_name, ...  )
	if class_name and parent then
		local item = class_name.New(parent, nil, layer_name, ... )
		self:AutoDelete( item )
		return item
	end
end

--自销毁动作
function BaseView:AddAction( action, node )
	self.action_nodes = self.action_nodes or {}
	self.action_nodes[node] = node
	--table.insert(self.action_nodes, node)
	cc.ActionManager:getInstance():addAction(action, node)
end

--自销毁特效
function BaseView:CreateUIEffect( config )
	if not config or not config.uiTranform then return end
	self.effect_nodes = self.effect_nodes or {}
	self:AddUIEffectConfig( config )
	table.insert(self.effect_nodes, config.uiTranform)
end


--移出屏幕（隐藏，用于频繁调用显示隐藏的对象，减少setActive的调用次数）
function BaseView:MoveOutOfScreen( transform )
	transform = transform or self.transform
	if transform then
		self.base_move_from_pos_y = self.base_move_from_pos_y or GetLocalPositionY(transform)
		SetLocalPositionY(transform, -99999)
	end
end

--移回屏幕（显示，用于频繁调用显示隐藏的对象，减少setActive的调用次数）
function BaseView:MoveInToScreen( transform )
	transform = transform or self.transform
	if transform and self.base_move_from_pos_y then
		SetLocalPositionY(transform, self.base_move_from_pos_y)
		self.base_move_from_pos_y = false
	end
end

function BaseView:InitViewAnimation()
	if self.full_screen or self.ani_left or self.ani_right then

		--处理刘海屏的位移偏移		
		local width, offset = self:GetIpxOffset()		
		--右侧
		self.ani_right_trans = self:GetChild("right")
		if self.ani_right_trans then
			self.ani_right_obj = self:GetChild("right").gameObject
			self.old_ani_right_pos = self.ani_right_trans.anchoredPosition		
			if self.ani_right and ClientConfig.view_ani_mode == true then				
				SetAnchoredPosition(self.ani_right_trans, self.old_ani_right_pos.x + 600, self.old_ani_right_pos.y)
			else
				SetAnchoredPosition(self.ani_right_trans, self.old_ani_right_pos.x + offset, self.old_ani_right_pos.y)
			end
		end		
		--左侧
		self.ani_left_trans = self:GetChild("left")
		if self.ani_left_trans then
			self.ani_left_obj = self:GetChild("left").gameObject	
			self.old_ani_left_pos = self.ani_left_trans.anchoredPosition								
			if self.ani_left and ClientConfig.view_ani_mode == true then				
				SetAnchoredPosition(self.ani_left_trans, self.old_ani_left_pos.x - 600 , self.old_ani_left_pos.y)
			else
				SetAnchoredPosition(self.ani_left_trans, self.old_ani_left_pos.x + offset , self.old_ani_left_pos.y)	
			end				
		end
		--中间
		self:ResetMidNode()

		--设置界面大小
		local MaxScreenWidth =  math.min(SrcScreenWidth - width, 1560 - width) 
		local rt = self.gameObject:GetComponent("RectTransform")		
		rt.sizeDelta = Vector2(MaxScreenWidth, ScreenHeight)

	end
end

--播放界面入场动画
function BaseView:DoOpenAni(tab_id)
	tab_id = tab_id or 1	
	self.ani_list = self.ani_list or {}
	if not self.is_loaded or self.ani_list[tab_id] then return end	
	self.ani_list[tab_id] = true
	self:DoOpenViewAnimation()
end

--处理界面动画
function BaseView:DoOpenViewAnimation()
	local width, offset = self:GetIpxOffset()
	if self.ani_right and self.ani_right_trans and ClientConfig.view_ani_mode == true then
		cc.ActionManager:getInstance():removeAllActionsFromTarget(self.ani_right_trans)
		SetAnchoredPosition(self.ani_right_trans, self.old_ani_right_pos.x + self.ani_right - offset, self.old_ani_right_pos.y)
		local moveActionRight = cc.MoveTo.createAnchoredType(1, self.old_ani_right_pos.x - offset,  self.ani_right_trans.anchoredPosition.y)
		moveActionRight = cc.EaseExponentialOut.New(moveActionRight)
		self:AddAction(moveActionRight, self.ani_right_trans)
	end

	if self.ani_left and self.ani_left_trans and ClientConfig.view_ani_mode == true then
		cc.ActionManager:getInstance():removeAllActionsFromTarget(self.ani_left_trans)
		SetAnchoredPosition(self.ani_left_trans, self.old_ani_left_pos.x + self.ani_left + offset, self.old_ani_left_pos.y)
		local moveActionLeft = cc.MoveTo.createAnchoredType(1, self.old_ani_left_pos.x + offset, self.ani_left_trans.anchoredPosition.y)
		moveActionLeft = cc.EaseExponentialOut.New(moveActionLeft)
		self:AddAction(moveActionLeft, self.ani_left_trans)
	end
end

--获取刘海屏位移
function BaseView:GetIpxOffset()
	local width, offset = 0, 0
	if ClientConfig.iphone_x_offset_left ~= 0 then
		offset = ClientConfig.iphone_x_offset_left /2
		width = ClientConfig.iphone_x_offset_left
	elseif ClientConfig.iphone_x_offset_right then
		offset = -ClientConfig.iphone_x_offset_right /2
		width = ClientConfig.iphone_x_offset_right
	end 
	return width, offset
end

--处理中间节点
function BaseView:ResetMidNode()
	if self.adjust_mid then
		local width, offset = self:GetIpxOffset()	
		local MaxScreenWidth =  math.min(SrcScreenWidth - width, 1560 - width) 
		self.mid_trans = self:GetChild("mid")
		if self.mid_trans then
			self.adjust_mid.left = self.adjust_mid.left or 0
			self.adjust_mid.right = self.adjust_mid.right or 0
			local x = MaxScreenWidth - self.adjust_mid.left - self.adjust_mid.right
			x = x / 2
			SetAnchoredPosition(self.mid_trans, - (MaxScreenWidth / 2) + self.adjust_mid.left + x + offset, self.mid_trans.anchoredPosition.y)
		end
	end
end

--处理刘海屏，旋转屏幕
function BaseView:SetIpxMode()
	self:ResetMidNode()

	local width, offset = self:GetIpxOffset()		
	if self.ani_right_trans then
		cc.ActionManager:getInstance():removeAllActionsFromTarget(self.ani_right_trans)
		SetAnchoredPosition(self.ani_right_trans, self.old_ani_right_pos.x + offset, self.old_ani_right_pos.y)
	end

	if self.ani_left_trans then
		cc.ActionManager:getInstance():removeAllActionsFromTarget(self.ani_left_trans)
		SetAnchoredPosition(self.ani_left_trans, self.old_ani_left_pos.x + offset, self.old_ani_left_pos.y)
	end	
end

-- 进行打开界面的展示动画(淡入淡出)
-- close_callback:关闭界面的关闭回调
function BaseView:DoShowViewAnimation(show, close_callback, open_callback)
	-- if not self.use_show_anim then return end
	if not self.gameObject or not self.background_wnd_raw then return end

	if (show and not self.use_show_anim) or (not show and not self.use_hide_anim) then 
		-- canvas_group.alpha = show and 1 or 0
		return
	end

	local time = show and 0.1 or 0.1
	self.background_wnd_raw.alpha = show and 0 or self.background_alpha
	local target_alpha = show and self.background_alpha or 0

	local function fading_anim_callback()

	end

	-- 关闭回调覆盖
	if not show and close_callback then
		fading_anim_callback = close_callback
	end
	self.fading_anim_id = TweenLite.to(self, self.background_wnd_raw, TweenLite.UiAnimationType.ALPHA, target_alpha, time, fading_anim_callback)
end

-- 进行打开界面的展示动画(缩放)
-- close_callback:关闭界面的关闭回调
function BaseView:DoShowViewScaleAnimation(show, close_callback, open_callback)
	if self.do_show_animation == show then
		if show then
			if open_callback then
				open_callback()
			end
		else
			if close_callback then
				close_callback()
			end
		end
		return
	end
	self.do_show_animation = show

	if not self.gameObject then return end

	if (show and not self.use_show_anim) or (not show and not self.use_hide_anim) then 
		return
	end
	local function scale_anim_callback()
		if show and self.background_wnd then
			self.background_wnd.transform.sizeDelta = Vector2(SrcScreenWidth, ScreenHeight)
		end

	end
	local tween_type = show and TweenFunc.EASE_OUT_BACK or TweenFunc.EASE_IN_BACK
	local cfg = show and BaseView.OpenCloseScaleCfg[1] or BaseView.OpenCloseScaleCfg[2]
	local cur_scale = Vector3.New(cfg.start_scale, cfg.start_scale, cfg.start_scale)
	local target_scale = Vector3.New(cfg.end_scale, cfg.end_scale, cfg.end_scale)
	local time = cfg.time
	if self.background_wnd then		
		local scale = show and cfg.start_scale or cfg.end_scale
		if scale ~= 0 then
			self.background_wnd.transform.sizeDelta = Vector2(SrcScreenWidth / scale, ScreenHeight/scale)
		end		
	end	
	SetLocalScale(self.gameObject.transform, cur_scale.x, cur_scale.y, cur_scale.z)
	-- 关闭回调覆盖
	if not show and close_callback then
		scale_anim_callback = close_callback
	end
	if self.scale_anim_id then
		TweenLite.Stop(self.scale_anim_id)
		self.scale_anim_id = nil
	end		
	self.scale_anim_id = TweenLite.to(self, self.gameObject.transform, TweenLite.UiAnimationType.SCALE, target_scale, time, scale_anim_callback, tween_type)
	
	if not show then
		GlobalEventSystem:Fire(EventName.BASEVIEW_DO_VIEW_ANIM, show, self)
	end	
end

--把界面的UI节点移动到背景层
function BaseView:MoveUIToBack(node, args, camera_args,activity_args)
	self.move_node_list = self.move_node_list or {}

	if self.background_wnd and not self.blur_activity_bg then--没有高斯模糊才这样设置
		--self.background_wnd:GetComponent("RawImageExtend").alpha = 0
	end
	if node then
		local t = {node = node, args = args, parent = node.transform.parent, sibling_idx = node.transform:GetSiblingIndex()}		
		table.insert(self.move_node_list, t)
		LuaViewManager:getInstance():ShowBackData({
			target = self, 
			node_list ={[1] = t}, 
			camera_args = camera_args,
			activity = activity_args,
		})
		if #self.move_node_list == 1 and self.use_show_anim then
			GlobalEventSystem:Fire(EventName.BASEVIEW_DO_VIEW_ANIM, true, self)
		end		
	end
end

--显示后模型摄像机
function BaseView:ShowBackModeCamera(camera_args)
	if self.background_wnd and not self.blur_activity_bg then--没有高斯模糊才这样设置
		self.background_wnd:GetComponent("RawImageExtend").alpha = 0
	end
	camera_args = camera_args or LuaViewManager.CameraArgs.DepthZero
	self.show_back_camera = true
	LuaViewManager:getInstance():ShowBackData({
		target = self, 
		camera_args = camera_args,
	})
end

--把界面的UI节点从背景层中移除
function BaseView:RemoveUIFromBack()
	self.move_node_list = self.move_node_list or {}
	if #self.move_node_list > 0 or self.show_back_camera then
		LuaViewManager:getInstance():HideBackData(self)
	end
end

--根据界面状态显示隐藏在背景层中的UI
function BaseView:SetBackUIVisible(state)
	if self.move_node_list then
		for k,v in pairs(self.move_node_list) do
			if state == true then
				if v.is_hide_form_view then
					v.node.gameObject:SetActive(true)
					v.is_hide_form_view = nil
				end				
			else
				if v.node.gameObject and v.node.gameObject.activeSelf == true then
					v.node.gameObject:SetActive(false)
					v.is_hide_form_view = true
				end							
			end			
		end		
	end	
	if self.back_item_contaner_list then
		for k,v in pairs(self.back_item_contaner_list) do
			v:SetBackUIVisible(state, true)
		end
	end
end

--设置界面的子页签(针对挂模型的界面)
function BaseView:AppendToBackContainer(child_item)
	if child_item then
		self.back_item_contaner_list = self.back_item_contaner_list or {}
		table.insert(self.back_item_contaner_list, child_item)		
	end	
end

--做界面打开动画(缩放动画)
function BaseView:PlayOpenMovie()
	do return false end
	-- print("huangcong:BaseView当前帧率", SceneManager and SceneManager:getInstance().curr_frame_rate or 0)
	-- print("huangcong:BaseView帧率上限 :", lua_settingM:GetFrameRate())
	-- print("huangcong:BaseView是否开启开启界面动画 :", self.need_movie_type)
	-- print("huangcong:BaseView是否销毁监听:",self.open_tween_id_2)
	if (SceneManager and SceneManager:getInstance().curr_frame_rate > 52) --当前帧率
		and lua_settingM:GetFrameRate() > 51 --帧率上限
		and self.transform and self.use_background and self.hide_maincancas
		and (self.need_movie_type or lua_viewM.main_cancas_last_visible) 
		and not self.open_tween_id_2 then
		
		self.has_played_open_movie = true
		SetLocalScale(self.transform, 0.90, 0.90, 0.90)
		
		local function onComplete()
			self.open_tween_id_2 = nil
		end
		self.open_tween_id_2 = TweenLite.to(self, self.transform, TweenLite.UiAnimationType.SCALE, Vector3.one ,0.1, onComplete)
	end
end

function BaseView:ClearOpenMovieId()
	if self.open_tween_id_1 then
		TweenLite.Stop(self.open_tween_id_1)
		self.open_tween_id_1 = nil
	end	
	if self.open_tween_id_2 then
		TweenLite.Stop(self.open_tween_id_2)
		self.open_tween_id_2 = nil
	end	
end

--做界面关闭动画(暂时不需要)
function BaseView:PlayCloseMovie()
	do return false end
	if self.transform and self.has_played_open_movie and not self.close_tween_id_1 then

		self.has_played_open_movie = false
		LuaViewManager.Fire(lua_viewM, LuaViewManager.CHANGE_MAIN_CANVAS_VISIBLE, self, true)
		local function onComplete()
			self:ClearCloseMovieId()
			self:CloseVisible()
			if self.destroy_imm then
				self:Destroy()
			else
				BaseView.AddDestroyTimer(self)
			end
		end
		if lua_viewM:GetViewNum() >= 2 or (SceneManager and SceneManager:getInstance().curr_frame_rate < 50) then
			onComplete()
			return
		end
		if not self.close_tween_id_1 then
			--先清理模型
			if self.popChild then
				lua_resM:clearRoleMode(self.popChild)
			end
			local canvas_group = self.transform:GetComponent("CanvasGroup")
			if not canvas_group then
				canvas_group = self.gameObject:AddComponent(typeof(UnityEngine.CanvasGroup))
			end

			self.close_tween_id_1 = TweenLite.to(self, canvas_group, TweenLite.UiAnimationType.ALPHA, 0.1, 0.13)
			self.close_tween_id_2 = TweenLite.to(self, self.transform, TweenLite.UiAnimationType.SCALE, Vector3.one * 0.88, 0.14, onComplete)
		end
		return true
	else
		return false
	end
end

function BaseView:ClearCloseMovieId()
	if self.close_tween_id_1 then
		TweenLite.Stop(self.close_tween_id_1)
		self.close_tween_id_1 = nil
	end				
	if self.close_tween_id_2 then
		TweenLite.Stop(self.close_tween_id_2)
		self.close_tween_id_2 = nil
	end					
end

function BaseView:BindLittleMove(node_trans, dir, target_pos)

	if not node_trans or not dir or not target_pos then return end
	if not self.little_move_event then
		self.little_move_event = true		
	    local function onLittleMove(is_out)
	    	if not self.little_move_is_show_anim and not is_out then
	    		self.little_move_is_show_anim = true
	    	end
	        self:BaseViewLittleMove(is_out)
	        self.is_out = is_out
	    end
	    self:BindEvent(GlobalEventSystem, EventName.PLAY_MAINUI_MOVIE_EVENT, onLittleMove)		
	end

	self.little_move_table = self.little_move_table or {}
	table.insert(self.little_move_table, {node_trans = node_trans, dir = dir, target_pos = target_pos})


	--如果不做动画，则直接调整刘海适配
	if not ClientConfig.can_little_move then
		local function onOrientationChange()
			if self.is_loaded and not self._use_delete_method then
				self:BaseViewOrientationChange()
			end
		end
		if not self.orientation_id then
		    self.orientation_id = self:BindEvent(GlobalEventSystem, EventName.ORIENTATION_DID_CHANGE, onOrientationChange)
		end
		local x, y = GetAnchoredPosition( node_trans)
		if dir == BaseView.LittleMoveDir.Left  then
			node_trans.anchoredPosition = Vector2( target_pos + ClientConfig.iphone_x_offset_left , y)
		elseif dir == BaseView.LittleMoveDir.Right then    			     			
			node_trans.anchoredPosition = Vector2( target_pos - ClientConfig.iphone_x_offset_right, y)
		elseif dir == BaseView.LittleMoveDir.Top then    			     			
			 node_trans.anchoredPosition = Vector2( x, target_pos)
		else
			node_trans.anchoredPosition = Vector2( x, target_pos)
		end   		
		return
	end

	--初始化节点的位置
	local x, y = GetAnchoredPosition(node_trans)
	if dir == BaseView.LittleMoveDir.Left  then
		node_trans.anchoredPosition = Vector2(target_pos + ClientConfig.iphone_x_offset_left-MainUIModel.LITTLE_MOVE_DIST, y)
	elseif dir == BaseView.LittleMoveDir.Right then    			     			
		node_trans.anchoredPosition = Vector2(target_pos - ClientConfig.iphone_x_offset_right+MainUIModel.LITTLE_MOVE_DIST , y)
	elseif dir == BaseView.LittleMoveDir.Top then    			     			
		node_trans.anchoredPosition = Vector2( x,target_pos+MainUIModel.LITTLE_MOVE_DIST)
	else
		node_trans.anchoredPosition = Vector2( x,target_pos-MainUIModel.LITTLE_MOVE_DIST)
	end  

	if self.little_move_load_view_time_id then
		TimerQuest.CancelQuest(GlobalTimerQuest, self.little_move_load_view_time_id)
		self.little_move_load_view_time_id = false
	end
	local function open_view_little_move_func()		
		if not self.little_move_is_show_anim then
			self:BaseViewLittleMove()
		end		
	end
	self.little_move_is_show_anim = false
	self.little_move_load_view_time_id = TimerQuest.AddDelayQuest(GlobalTimerQuest, open_view_little_move_func, 0.1)


	local function onOrientationChange()
		if self.is_loaded and not self._use_delete_method and self.littleMove_is_anim then
			self:BaseViewLittleMoveOrientationChange()
		end
	end
	if not self.orientation_id then
	    self.orientation_id = self:BindEvent(GlobalEventSystem, EventName.ORIENTATION_DID_CHANGE, onOrientationChange)
	end
end

function BaseView:StopLittleMoveAnim()
	if self.little_move_tween_list and  #self.little_move_tween_list > 0 then
		for i,v in ipairs(self.little_move_tween_list) do
  			TweenLite.Stop(v)
		end
		self.little_move_tween_list = false
	end
	if self.little_move_load_view_time_id then
		TimerQuest.CancelQuest(GlobalTimerQuest, self.little_move_load_view_time_id)
		self.little_move_load_view_time_id = false
	end	
end

--屏幕翻转
function BaseView:BaseViewLittleMoveOrientationChange(  )

	if self.is_out then
		for i,v in ipairs(self.little_move_table) do
			local x, y = GetAnchoredPosition( v.node_trans)
			if v.dir == BaseView.LittleMoveDir.Left  then
				v.node_trans.anchoredPosition = Vector2( v.target_pos + ClientConfig.iphone_x_offset_left - MainUIModel.LITTLE_MOVE_OUT_DIST, y)
			elseif v.dir == BaseView.LittleMoveDir.Right then    			     			
				v.node_trans.anchoredPosition = Vector2( v.target_pos - ClientConfig.iphone_x_offset_right + MainUIModel.LITTLE_MOVE_OUT_DIST, y)
			elseif v.dir == BaseView.LittleMoveDir.Top then    			     			
				 v.node_trans.anchoredPosition = Vector2( x, v.target_pos + MainUIModel.LITTLE_MOVE_OUT_DIST)
			else
				v.node_trans.anchoredPosition = Vector2( x, v.target_pos - MainUIModel.LITTLE_MOVE_OUT_DIST)
			end    		
		end
	else
		self:BaseViewOrientationChange()
	end
end

--屏幕翻转时，位置纠正
function BaseView:BaseViewOrientationChange(  )
	for i,v in ipairs(self.little_move_table) do
		local x, y = GetAnchoredPosition( v.node_trans)
		if v.dir == BaseView.LittleMoveDir.Left  then
			v.node_trans.anchoredPosition = Vector2( v.target_pos + ClientConfig.iphone_x_offset_left , y)
		elseif v.dir == BaseView.LittleMoveDir.Right then    			     			
			v.node_trans.anchoredPosition = Vector2( v.target_pos - ClientConfig.iphone_x_offset_right, y)
		elseif v.dir == BaseView.LittleMoveDir.Top then    			     			
			 v.node_trans.anchoredPosition = Vector2( x, v.target_pos)
		else
			v.node_trans.anchoredPosition = Vector2( x, v.target_pos)
		end   
	end
end

function BaseView:BaseViewLittleMove( is_out )	
	if not self.little_move_table or #self.little_move_table <= 0 then return end
	self:StopLittleMoveAnim()
	self.little_move_tween_list = {}
	self.littleMove_is_anim = true
	local function end_func( ... )
		self.littleMove_is_anim = false
	end
    if is_out then
    	for i,v in ipairs(self.little_move_table) do
    		local x, y = GetAnchoredPosition( v.node_trans)
    		if v.dir == BaseView.LittleMoveDir.Left  then
    			v.node_trans.anchoredPosition = Vector2( v.target_pos + ClientConfig.iphone_x_offset_left, y)
    			self.little_move_tween_list[i] = TweenLite.to(self, v.node_trans, TweenLite.UiAnimationType.ANCHORED_POSX, v.target_pos + ClientConfig.iphone_x_offset_left - MainUIModel.LITTLE_MOVE_OUT_DIST, MainUIModel.LITTLE_MOVE_OUT_TIME, end_func)      
    		elseif v.dir == BaseView.LittleMoveDir.Right then    			     			
    			v.node_trans.anchoredPosition = Vector2( v.target_pos - ClientConfig.iphone_x_offset_right, y)
    			self.little_move_tween_list[i] = TweenLite.to(self, v.node_trans, TweenLite.UiAnimationType.ANCHORED_POSX, v.target_pos - ClientConfig.iphone_x_offset_right + MainUIModel.LITTLE_MOVE_OUT_DIST, MainUIModel.LITTLE_MOVE_OUT_TIME,end_func)      
    		elseif v.dir == BaseView.LittleMoveDir.Top then    			     			
    			 v.node_trans.anchoredPosition = Vector2( x, v.target_pos)
    			 self.little_move_tween_list[i] = TweenLite.to(self, v.node_trans, TweenLite.UiAnimationType.ANCHORED_POSY, v.target_pos + MainUIModel.LITTLE_MOVE_OUT_DIST, MainUIModel.LITTLE_MOVE_OUT_TIME,end_func)      
   			else
   				v.node_trans.anchoredPosition = Vector2( x, v.target_pos)
   				self.little_move_tween_list[i] = TweenLite.to(self, v.node_trans, TweenLite.UiAnimationType.ANCHORED_POSY, v.target_pos - MainUIModel.LITTLE_MOVE_OUT_DIST, MainUIModel.LITTLE_MOVE_OUT_TIME,end_func)      
    		end    		
    	end

    else
    	for i,v in ipairs(self.little_move_table) do
    		local x, y = GetAnchoredPosition( v.node_trans)
    		if v.dir == BaseView.LittleMoveDir.Left  then
    			v.node_trans.anchoredPosition = Vector2( v.target_pos + ClientConfig.iphone_x_offset_left-MainUIModel.LITTLE_MOVE_DIST, y)
    			self.little_move_tween_list[i] = TweenLite.to(self, v.node_trans, TweenLite.UiAnimationType.ANCHORED_POSX, v.target_pos + ClientConfig.iphone_x_offset_left , MainUIModel.LITTLE_MOVE_TIME,end_func)      
    		elseif v.dir == BaseView.LittleMoveDir.Right then    			     			
    			v.node_trans.anchoredPosition = Vector2( v.target_pos - ClientConfig.iphone_x_offset_right+MainUIModel.LITTLE_MOVE_DIST , y)
    			self.little_move_tween_list[i] = TweenLite.to(self, v.node_trans, TweenLite.UiAnimationType.ANCHORED_POSX, v.target_pos - ClientConfig.iphone_x_offset_right, MainUIModel.LITTLE_MOVE_TIME,end_func)      
    		elseif v.dir == BaseView.LittleMoveDir.Top then    			     			
    			 v.node_trans.anchoredPosition = Vector2( x, v.target_pos+MainUIModel.LITTLE_MOVE_DIST)
    			 self.little_move_tween_list[i] = TweenLite.to(self, v.node_trans, TweenLite.UiAnimationType.ANCHORED_POSY, v.target_pos , MainUIModel.LITTLE_MOVE_TIME,end_func)      
   			else
   				v.node_trans.anchoredPosition = Vector2( x, v.target_pos-MainUIModel.LITTLE_MOVE_DIST)
   				self.little_move_tween_list[i] = TweenLite.to(self, v.node_trans, TweenLite.UiAnimationType.ANCHORED_POSY, v.target_pos , MainUIModel.LITTLE_MOVE_TIME,end_func)      
    		end   
    	end
    end         
end

-- 绑定主界面聊天UI的展开（展开时被遮挡的UI绑定这个事件后会隐藏掉UI）
function BaseView:BindMainUIExpandEvent( con_tran )
	if not con_tran or (not con_tran.gameObject) then return end
	self.main_ui_func_btn_con_list = self.main_ui_func_btn_con_list or {}
	if TableSize(self.main_ui_func_btn_con_list) <= 0 then
    	local function set_func_btn_show()
    	    self:SetFuncBtnShow()
    	end
    	self:BindEvent(GlobalEventSystem, EventName.MAIN_UI_CON_EXPAND, set_func_btn_show)
	end

	table.insert(self.main_ui_func_btn_con_list, con_tran)
    -- 初始化一次
    self:SetFuncBtnShow()
end

-- 设置fun_btn的显示状态
function BaseView:SetFuncBtnShow(  )
    local main_ui_is_expand = MainUIModel:getInstance():MainChatUIIsExpand()
    for k,v in pairs(self.main_ui_func_btn_con_list) do
    	v.gameObject:SetActive(not main_ui_is_expand)  
    end
end