请合并最新代码，优化绑定信息

xm

2020-05-08 6bca8fcd37a48808a0b9c9342fc1be0adddfece6

请合并最新代码，优化绑定信息

 ZigbeeApp/GateWay.Droid/Assets/Language.ini

@@ -244,7 +244,7 @@
238=长按5秒（按键）
239=长按图示按键5秒以上，指示灯变绿、闪烁{0}进入配网状态。绿灯熄灭则配网成功
;三按键面板入网操作指示
241=设置常开模式后，您的门锁将始终{0}处于打开状态，确认开启？
241=设置常开模式后，您的门锁将始终{0}处于打开状态，确认开启？ 
242=电量
243=常开模式已开启
244=失效设置
@@ -265,10 +265,10 @@
259=失效时间不合法，请重写设置
260=音量设置失败
261=音量设置成功
262=当前时区
262=当前时区 
263=区
264=东
265=西
265=西 
266=当前设备不在线
267=获取音量失败
268=确定取消该成员的远程开锁权限
@@ -583,7 +583,7 @@
5390=失效设置
5391=小时
5392=门锁始终打开
5393=设置常开模式后，您的门锁将始终{0}处于打开状态，确认开启？
5393=设置常开模式后，您的门锁将始终{0}处于打开状态，确认开启？ 
5394=不能小于1小时
5395=大于12小时
5396=或
@@ -2072,4 +2072,4 @@
70023=中继器
70024=智能空开
70025=吸顶燃气传感器
70026=PM2.5空气质量传感器
70026=PM2.5空气质量传感器

 ZigbeeApp/GateWay.Droid/GateWay.Droid.csproj

@@ -2166,4 +2166,4 @@
  <Import Project="..\packages\Xamarin.Android.Support.Fragment.25.4.0.1\build\MonoAndroid70\Xamarin.Android.Support.Fragment.targets" Condition="Exists('..\packages\Xamarin.Android.Support.Fragment.25.4.0.1\build\MonoAndroid70\Xamarin.Android.Support.Fragment.targets')" />

  <Import Project="..\packages\Xamarin.Android.Support.v4.25.4.0.1\build\MonoAndroid70\Xamarin.Android.Support.v4.targets" Condition="Exists('..\packages\Xamarin.Android.Support.v4.25.4.0.1\build\MonoAndroid70\Xamarin.Android.Support.v4.targets')" />

  <Import Project="..\packages\NETStandard.Library.2.0.0\build\netstandard2.0\NETStandard.Library.targets" Condition="Exists('..\packages\NETStandard.Library.2.0.0\build\netstandard2.0\NETStandard.Library.targets')" />

</Project>

</Project>

 ZigbeeApp/GateWay.Droid/Properties/AndroidManifest.xml

@@ -167,4 +167,4 @@
        <!-- 设置高德地图key -->
        <meta-data android:name="com.amap.api.v2.apikey" android:value="1f753413955012c9594c5df69eaa0aff" />
    </application>
</manifest>
</manifest>

 ZigbeeApp/GateWay.Droid/Resources/Resource.designer.cs

Diff too large

 ZigbeeApp/Home.Ios/AppDelegate.cs

@@ -25,6 +25,7 @@

        public override bool FinishedLaunching(UIApplication application, NSDictionary launchOptions)
        {
            Shared.Application.IsGpsEnable = false;
            Shared.Application.IsMusicEnable = false;
            base.FinishedLaunching(application, launchOptions);
            Shared.Application.FontSize = 12;

 ZigbeeApp/Home.Ios/Home.IOS.csproj

@@ -1025,4 +1025,4 @@
    </ItemGroup>
    <Import Project="..\Shared\Shared.projitems" Label="Shared" Condition="Exists('..\Shared\Shared.projitems')" />
    <Import Project="$(MSBuildExtensionsPath)\Xamarin\iOS\Xamarin.iOS.CSharp.targets" />
</Project>
</Project>

 ZigbeeApp/Home.Ios/Resources/Language.ini

@@ -237,12 +237,13 @@
231=接近感应
232=接近感应功能设置置失败
233=获取接近感应功能失败
235=按住面板模式（Mode)和风速（Fan)按键{0}绿色指示灯亮起。则配网成功
235=按住面板模式按键5秒，绿色指示灯闪烁{0}进入配网状态；闪烁停止{0}指示灯变白色表示配网成功 
236=绿色指示灯闪烁
237=指示灯
238=长按5秒（按键）
239=长按图示按键5秒以上，指示灯变绿、闪烁{0}进入配网状态。绿灯熄灭则配网成功
241=设置常开模式后，您的门锁将始终{0}处于打开状态，确认开启？
;三按键面板入网操作指示
241=设置常开模式后，您的门锁将始终{0}处于打开状态，确认开启？ 
242=电量
243=常开模式已开启
244=失效设置
@@ -263,10 +264,10 @@
259=失效时间不合法，请重写设置
260=音量设置失败
261=音量设置成功
262=当前时区
262=当前时区 
263=区
264=东
265=西
265=西 
266=当前设备不在线
267=获取音量失败
268=确定取消该成员的远程开锁权限
@@ -314,6 +315,7 @@
311=手动
312= 背光灯颜色
313=长按图示按键5秒以上，信号图标{0}快闪， 进入配网状态。信号图标常亮则配网成功
314=自动模式不支持操作

5097=取消
5098=确定
@@ -581,7 +583,7 @@
5390=失效设置
5391=小时
5392=门锁始终打开
5393=设置常开模式后，您的门锁将始终{0}处于打开状态，确认开启？
5393=设置常开模式后，您的门锁将始终{0}处于打开状态，确认开启？ 
5394=不能小于1小时
5395=大于12小时
5396=或
@@ -1838,95 +1840,95 @@
16115=常开自动化手动取消
16116=游客体验

;★★★★下面这些是接口的返回信息翻译,从18000开始★★★★

18004=指定网关已经被绑定

18005=用户不存在于此住宅

18006=账号已经存在于此住宅

18009=操作权限不足

18010=被绑定的子账号不存在，请注册后再试

18011=操作的子账号不存在

18012=解除绑定的子账号不存在

18013=验证码发送失败

18015=账号已经存在

18016=验证码错误

18017=验证码已失效

18018=绑定的账号不存在

18019=指定账号已存在

18022=验证码发送失败

18024=指定账号不存在

18025=原密码和新密码相同

18026=原密码错误

18034=账号未注册

18035=请求参数错误

18036=无效的登录密匙

18039=当前编辑的住宅名称已经存在

18040=当前添加的住宅名称已经存在

18041=指定的住宅不存在

18042=当前备份不属于您当前的住宅

18043=备注名称已经存在,请更换后重试！

18044=指定的网关ID并不存在

18045=当前住宅下并没有绑定指定的网关

18046=当前住宅还存在着未解除绑定的网关

18047=共享数据不存在

18048=分享的目标账号不存在

18049=分享数据操作失败

18050=不能把自己添加为成员

18051=不能把主账号添加为成员





;★★★★下面这些是设备的入网步骤,从21000开始★★★★

;智能门锁入网操作指示

21000=唤醒门锁，输入“*”、“#”、“管理员密码”{0}按语音提示，输入“4”选择功能菜单{0}输入“1”，确认设备入网

;3路继电器入网操作指示

21001=长按图示按键5秒以上，指示灯变绿、闪烁{0}进入配网状态。绿灯熄灭则配网成功

;1路调光器小模块入网操作指示

21002=长按图示按键5秒以上，指示灯变绿、闪烁{0}进入配网状态。绿灯熄灭则配网成功

;二按键面板入网操作指示

21003=长按图示按键5秒以上，指示灯变绿、闪烁{0}进入配网状态。绿灯快闪3秒则配网成功

;三按键面板入网操作指示

21004=长按图示按键5秒以上，指示灯变绿、闪烁{0}进入配网状态。绿灯快闪3秒则配网成功

;四按键面板入网操作指示

21005=长按图示按键5秒以上，指示灯变绿、闪烁{0}进入配网状态。绿灯快闪3秒则配网成功

;Zigbee智能开合帘电机入网操作指示

21006=长按图示按键5秒以上，指示灯{0}变绿闪烁，则进入配网状态{0}绿灯熄灭则配网成功

;Zigbee智能管状电机入网操作指示

21007=长按图示按键5秒以上，指示灯{0}变绿闪烁，则进入配网状态{0}绿灯熄灭则配网成功

;红外传感器入网操作指示

21008=长按图示按键5秒以上，绿色快闪{0}进入配网状态，绿灯常亮则入网成功

;门窗传感器入网操作指示

21009=长按图示按键5秒以上，绿色快闪{0}进入配网状态，绿灯常亮则入网成功

;燃气传感器入网操作指示

21010=长按图示按键5秒以上，绿色快闪{0}进入配网状态，绿灯常亮则入网成功

;烟雾传感器入网操作指示

21011=长按图示按键5秒以上，绿色快闪{0}进入配网状态，绿灯常亮则入网成功

;水浸传感器入网操作指示

21012=长按图示按键5秒以上，绿色快闪{0}进入配网状态，绿灯常亮则入网成功

;空气开关入网操作指示

21013=按键从工作模式拨到配对模式,5秒后红灯{0}慢闪烁时拨回工作模式,{0}进入配网模式,红灯常亮则配网成功

;中继器入网操作指示

21014=长按图示按键5秒以上，指示灯变绿闪烁{0}进入配网状态，绿灯熄灭则入网成功

;空调入网操作指示

21015=长按图示按键5秒以上，指示灯{0}变绿闪烁,进入配网状态{0}绿灯每5秒闪烁一次则入网成功

;pir传感器入网操作指示

21016=长按图示按键5秒以上，指示灯变绿、{0}闪烁进入配网状态。绿灯熄灭则配网成功

;温湿度传感器入网操作指示

21017=长按图示按键5秒以上，信号图标{0}快闪， 进入配网状态。图标常亮则配网成功

;方悦2按键轻触式面板入网操作指示

21018=按住面板左上角按键，所有按键指示灯{0}亮起，则配网成功

;方悦4按键轻触式面板入网操作指示

21019=按住面板左上角按键，所有按键指示灯{0}亮起，则配网成功

;方悦8按键轻触式面板入网操作指示

21020=按住面板左上角按键，所有按键指示灯{0}亮起，则配网成功

;方悦环境面板入网操作指示

21021=按住面板功能(function)按键，所有按键{0}指示灯亮起，则配网成功

;窗帘面板的入网操作指示

21022=长按面板左上角按键，所有按键{0}指示灯亮起，则配网成功

;吸顶燃气传感器的入网操作指示

21023=长按图示按键5秒以上，绿色快闪{0}进入配网状态，绿灯常亮则入网成功



;★★★★下面这些是模块ID的官方名字,从30000开始★★★★

30000=紧急按钮

30001=燃气传感器

;★★★★下面这些是接口的返回信息翻译,从18000开始★★★★
18004=指定网关已经被绑定
18005=用户不存在于此住宅
18006=账号已经存在于此住宅
18009=操作权限不足
18010=被绑定的子账号不存在，请注册后再试
18011=操作的子账号不存在
18012=解除绑定的子账号不存在
18013=验证码发送失败
18015=账号已经存在
18016=验证码错误
18017=验证码已失效
18018=绑定的账号不存在
18019=指定账号已存在
18022=验证码发送失败
18024=指定账号不存在
18025=原密码和新密码相同
18026=原密码错误
18034=账号未注册
18035=请求参数错误
18036=无效的登录密匙
18039=当前编辑的住宅名称已经存在
18040=当前添加的住宅名称已经存在
18041=指定的住宅不存在
18042=当前备份不属于您当前的住宅
18043=备注名称已经存在,请更换后重试！
18044=指定的网关ID并不存在
18045=当前住宅下并没有绑定指定的网关
18046=当前住宅还存在着未解除绑定的网关
18047=共享数据不存在
18048=分享的目标账号不存在
18049=分享数据操作失败
18050=不能把自己添加为成员
18051=不能把主账号添加为成员


;★★★★下面这些是设备的入网步骤,从21000开始★★★★
;智能门锁入网操作指示
21000=唤醒门锁，输入“*”、“#”、“管理员密码”{0}按语音提示，输入“4”选择功能菜单{0}输入“1”，确认设备入网
;3路继电器入网操作指示
21001=长按图示按键5秒以上，指示灯变绿、闪烁{0}进入配网状态。绿灯熄灭则配网成功
;1路调光器小模块入网操作指示
21002=长按图示按键5秒以上，指示灯变绿、闪烁{0}进入配网状态。绿灯熄灭则配网成功
;二按键面板入网操作指示
21003=长按图示按键5秒以上，指示灯变绿、闪烁{0}进入配网状态。绿灯快闪3秒则配网成功
;三按键面板入网操作指示
21004=长按图示按键5秒以上，指示灯变绿、闪烁{0}进入配网状态。绿灯快闪3秒则配网成功
;四按键面板入网操作指示
21005=长按图示按键5秒以上，指示灯变绿、闪烁{0}进入配网状态。绿灯快闪3秒则配网成功
;Zigbee智能开合帘电机入网操作指示
21006=长按图示按键5秒以上，指示灯{0}变绿闪烁，则进入配网状态{0}绿灯熄灭则配网成功
;Zigbee智能管状电机入网操作指示
21007=长按图示按键5秒以上，指示灯{0}变绿闪烁，则进入配网状态{0}绿灯熄灭则配网成功
;红外传感器入网操作指示
21008=长按图示按键5秒以上，绿色快闪{0}进入配网状态，绿灯常亮则入网成功
;门窗传感器入网操作指示
21009=长按图示按键5秒以上，绿色快闪{0}进入配网状态，绿灯常亮则入网成功
;燃气传感器入网操作指示
21010=长按图示按键5秒以上，绿色快闪{0}进入配网状态，绿灯常亮则入网成功
;烟雾传感器入网操作指示
21011=长按图示按键5秒以上，绿色快闪{0}进入配网状态，绿灯常亮则入网成功
;水浸传感器入网操作指示
21012=长按图示按键5秒以上，绿色快闪{0}进入配网状态，绿灯常亮则入网成功
;空气开关入网操作指示
21013=按键从工作模式拨到配对模式,5秒后红灯{0}慢闪烁时拨回工作模式,{0}进入配网模式,红灯常亮则配网成功
;中继器入网操作指示
21014=长按图示按键5秒以上，指示灯变绿闪烁{0}进入配网状态，绿灯熄灭则入网成功
;空调入网操作指示
21015=长按图示按键5秒以上，指示灯{0}变绿闪烁,进入配网状态{0}绿灯每5秒闪烁一次则入网成功
;pir传感器入网操作指示
21016=长按图示按键5秒以上，指示灯变绿、{0}闪烁进入配网状态。绿灯熄灭则配网成功
;温湿度传感器入网操作指示
21017=长按图示按键5秒以上，信号图标{0}快闪， 进入配网状态。图标常亮则配网成功
;方悦2按键轻触式面板入网操作指示
21018=长按BUTTON1按键5秒，所有指示灯{0}变为绿色并闪烁，进入配网状态
;方悦4按键轻触式面板入网操作指示
21019=长按BUTTON1按键5秒，所有指示灯{0}变为绿色并闪烁，进入配网状态
;方悦8按键轻触式面板入网操作指示
21020=长按BUTTON1按键5秒，所有指示灯{0}变为绿色并闪烁，进入配网状态
;方悦环境面板入网操作指示
21021=按住面板功能(function)按键，所有按键{0}指示灯亮起，则配网成功
;窗帘面板的入网操作指示
21022=长按面板左上角按键，所有按键{0}指示灯亮起，则配网成功
;吸顶燃气传感器的入网操作指示
21023=长按图示按键5秒以上，绿色快闪{0}进入配网状态，绿灯常亮则入网成功

;★★★★下面这些是模块ID的官方名字,从30000开始★★★★
30000=紧急按钮
30001=燃气传感器
30002=烟雾传感器
30003=水侵传感器
30004=钥匙扣
@@ -1965,6 +1967,7 @@
30037=S-one
30038=方悦新风小模块
30039=Zigbee吸顶燃气传感器
30040=PM2.5空气质量传感器

;★★★★下面这些是设备所属种类的翻译名字,从40000开始★★★★
40000=遮阳
@@ -1987,9 +1990,9 @@
40017=干接点
40018=新风

;★★★★下面这些是模块ID的设备默认备注名字,从50000开始.注:它并不需要再R.cs文件中定义★★★★

50000=紧急按钮

50001=Zigbee燃气传感器

;★★★★下面这些是模块ID的设备默认备注名字,从50000开始.注:它并不需要再R.cs文件中定义★★★★
50000=紧急按钮
50001=Zigbee燃气传感器
50002=Zigbee燃气传感器
50003=Zigbee水浸传感器
50004=钥匙扣
@@ -2028,8 +2031,9 @@
50037=Zigbee智能门锁
50038=新风控制小模块
50039=Zigbee吸顶燃气传感器
30040=PM2.5空气质量传感器

;★★★★下面这些是模块ID的设备类型名字,从60000开始.注:它并不需要再R.cs文件中定义★★★★

;★★★★下面这些是模块ID的设备类型名字,从60000开始.注:它并不需要再R.cs文件中定义★★★★
60000=传感器
60001=开关模块
60002=遮阳模块
@@ -2041,7 +2045,7 @@
60008=转换器
60009=空调模块
60010=智能门锁
60011=新风模块
60011=新风模块 

;//★★★★下面这些是添加新设备界面那里显示的名字,从70000开始★★★★
70000=2按键面板
@@ -2070,4 +2074,4 @@
70023=中继器
70024=智能空开
70025=吸顶燃气传感器
70026=PM2.5空气质量传感器
70026=PM2.5空气质量传感器

 ZigbeeApp/Home.Ios/Resources/Phone/Device/SensorPMTwoPointFive.png

 ZigbeeApp/Home.Ios/Resources/Phone/Instruct/SensorPMTwoPointFive.png

 ZigbeeApp/Shared/Common/CommonPage.cs

@@ -57,7 +57,7 @@
        /// <summary>
        /// 版本号
        /// </summary>
        public static string CodeIDString = "1.0.20050601";
        public static string CodeIDString = "1.0.20050701";
        /// <summary>
        /// 注册来源(0:HDL On 1:Zigbee)
        /// </summary>

 ZigbeeApp/Shared/Common/Device.cs

@@ -271,7 +271,7 @@
                //添加缓存

                this.AddDeviceToMemory(ref device);



                //移除存在的设备内存

                //移除存在的设备内存 
                string maikey = this.GetDeviceMainKeys(device);

                if (dicExist.ContainsKey(maikey) == true)

                {

@@ -2079,8 +2079,8 @@
            list.Add(DeviceBeloneType.A传感器);



            //其他的看着办呗,都是排在后面的,都归为这个属性

            list.Add(DeviceBeloneType.A未知设备);



            list.Add(DeviceBeloneType.A未知设备);

            return list;

        }



@@ -2095,7 +2095,7 @@
        /// <returns></returns>

        public bool CheckDeviceIsOnline(CommonDevice i_device)

        {

            //0:离线 1:在线 2:正在刷新状态

            //0:离线 1:在线 2:正在刷新状态 
            return i_device.IsOnline == 1 || i_device.IsOnline == 2;

        }



@@ -2673,6 +2673,9 @@
            this.dicDeviceModelIdEnum["MBU01/M-ZB.10"] = "1305-1200-60000";//紧急按键

            this.dicDeviceModelIdEnum["MGCD01/ZB.10"] = "1306-1200-60000";//吸顶燃气传感器



            //PM2.5空气质量传感器 【该设备属于第三方设备，没有镜像ID】

            this.dicDeviceModelIdEnum["SZ_PM100"] = "1307-1200-60000";//PM2.5空气质量传感器 


            //=========★★继电器类(2300-2499)★★=========

            this.dicDeviceModelIdEnum["MPR0310-ZB.10"] = "2300-2300-60001";//3路继电器小模块

            this.dicDeviceModelIdEnum["MFA01-ZB.10"] = "2310-2300-60011";//方悦新风小模块

@@ -2862,7 +2865,12 @@
        /// <summary>

        /// 吸顶燃气传感器

        /// </summary>

        Sensor_CeilingGas = 1306,

        Sensor_CeilingGas = 1306,
        /// <summary>
        /// PM2.5空气质量传感器
        /// </summary>
        Sensor_PMTwoPointFive = 1307,


        /// <summary>

        /// 运动传感器

        /// </summary>

@@ -2896,9 +2904,9 @@
        /// <summary>

        /// 方悦新风小模块 镜像id：2310

        /// </summary>

        Relay_FangyueFreshAirModul = 2310,



        //=========★★调光器类(2500-2799)★★=========

        Relay_FangyueFreshAirModul = 2310,

        //=========★★调光器类(2500-2799)★★=========
        /// <summary>

        /// 调光器

        /// </summary>


 ZigbeeApp/Shared/Phone/Category/CategoryMainForm.cs

old mode 100755
new mode 100644
@@ -131,7 +131,7 @@
            //应该是body吧

            this.bodyFrameLayout = new FrameLayout();

            bodyFrameLayout.Y = topFrameLayout.Bottom;

            bodyFrameLayout.Height = Application.GetRealHeight(1549);

            bodyFrameLayout.Height = this.Height - topFrameLayout.Bottom;

            bodyFrameLayout.BackgroundColor = ZigbeeColor.Current.GXCGrayBackgroundColor;

            this.AddChidren(bodyFrameLayout);



@@ -316,7 +316,7 @@
            functionSceneBodyView.Height = functionSceneAutoBodyView.Height - roomSwitchContr.Bottom;

            functionSceneAutoBodyView.AddChidren(functionSceneBodyView);



            //执行初始化

            //执行初始化 
            roomSwitchContr.InitControl();

        }



@@ -529,7 +529,11 @@
                    {

                        cardContr = new Controls.DeviceFreshAirRowControl();

                    }

                    //彩灯(调光器)

                    // PM2.5

                    else if (device.Type == DeviceType.PMSensor)

                    {
                    }
                    //彩灯(调光器)
                    else if (device.Type == DeviceType.DimmableLight)

                    {

                        cardContr = new Controls.DeviceColorLightRowControl();

@@ -639,8 +643,8 @@
            {

                listview2 = new VerticalListControl();

                functionSceneBodyView.AddChidren(listview2);

            }



            }

            foreach (var scene in listScene)

            {

                //场景卡片控件


 ZigbeeApp/Shared/Phone/Category/Controls/DeviceRow/Base/DeviceRowCommon.cs

@@ -104,7 +104,7 @@
            btnDeviceName.Text = Common.LocalDevice.Current.GetDeviceEpointName(i_device);

            btnDeviceName.SelectedTextColor = Common.ZigbeeColor.Current.GXCTextSelectedColor;

            this.frameTable.AddChidren(btnDeviceName, ChidrenBindMode.BindEventOnly);



            
            if (this.hadStatuFunction == false)

            {

                //没有状态功能,则把设备名字控件中

@@ -358,7 +358,7 @@
                }

            }

            else

            {

            {   
                //如果这个设备改变了房间的话,回调卡片被删除的函数

                var nowRoom = HdlRoomLogic.Current.GetRoomByDevice(device);

                if (nowRoom == null || nowRoom.Id != HdlRoomLogic.Current.CurrentRoom.Id)


 ZigbeeApp/Shared/Phone/Device/Logic/LogicView/TipView.cs

@@ -270,26 +270,27 @@
            {
                if (string.IsNullOrEmpty(editTime.Text))
                {
                    ShowTip(Language.StringByID(R.MyInternationalizationString.timeNull),true);
                    ShowErrorTip(Language.StringByID(R.MyInternationalizationString.timeNull),true);
                    return;
                }
                if (int.Parse(editTime.Text) < 1 || int.Parse(editTime.Text) > 12)
                {  ///限制输入数字范围;
                    string str = Language.StringByID(R.MyInternationalizationString.less) + Language.StringByID(R.MyInternationalizationString.or) + Language.StringByID(R.MyInternationalizationString.more);
                    ShowTip(str, true);
                    ShowErrorTip(str, true);
                    return;


                }
                dialog.Close();
                action(editTime.Text);
           };

            };

        }
        /// <summary>
        /// 提示框
        ///  错误提示框
        /// </summary>
        public static void ShowTip(string tipText,bool _if )
        public static void ShowErrorTip(string tipText,bool _if )
        {
            ///主控件
            Dialog dialog = new Dialog();
@@ -411,5 +412,71 @@
                dialog.Close();
            };
        }

        /// <summary>
        ///  闪错提示框
        /// </summary>
        public static void ShowFlashTip(string tipText,int timeValue=1)
        {
            ///主控件
            Dialog dialog = new Dialog();
            dialog.Show();
            ///背景的父控件
            FrameLayout fLayout = new FrameLayout { BackgroundColor = ZigbeeColor.Current.LogicTranslucentColor };
            dialog.AddChidren(fLayout);
            fLayout.MouseUpEventHandler += (sender,e) => {
                dialog.Close();

            };
            ///弹框父控件
            FrameLayout tipFLayout = new FrameLayout
            {
                X = Application.GetRealWidth(230),
                Y = Application.GetRealHeight(717),
                Width = Application.GetRealWidth(622),
                Height = Application.GetRealHeight(317),
                BackgroundColor = ZigbeeColor.Current.LogicBlankBackgroundColor,
                Radius = (uint)Application.GetRealHeight(17)
            };
            fLayout.AddChidren(tipFLayout);

            ///提示控件
            Button tipBtn = new Button
            {
                Y = Application.GetRealHeight(58),
                X = Application.GetRealWidth(150),
                Height = Application.GetRealHeight(63),
                Width = Application.GetRealWidth(622 - 300),
                TextID = R.MyInternationalizationString.tip,
                TextAlignment = TextAlignment.Center,
                TextColor = ZigbeeColor.Current.LogicTipColor,
                TextSize = 16,

            };
            tipFLayout.AddChidren(tipBtn);
            ///文本控件
            Button Text1Btn = new Button
            {
                Y = Application.GetRealHeight(156),
                X = Application.GetRealWidth(50),
                Height = Application.GetRealHeight(58),
                Width = Application.GetRealWidth(622 - 100),
                Text = tipText,
                TextAlignment = TextAlignment.Center,
                TextColor = ZigbeeColor.Current.LogicBtnCancelColor,
                TextSize = 14,
            };
            tipFLayout.AddChidren(Text1Btn);
           
            new System.Threading.Thread(() =>
            {
                System.Threading.Thread.Sleep(timeValue*1000);
                Application.RunOnMainThread(() =>
                {
                    dialog.Close();
                });
            })
            { IsBackground = true }.Start();
        }
    }
}

 ZigbeeApp/Shared/Phone/Device/Logic/Method.cs

@@ -702,7 +702,11 @@
                    Common.Logic.CurrentLogic.LogicIsCustomPushText = 0;
                    pushview.lineBtn.BackgroundColor = ZigbeeColor.Current.LogicBlankBackgroundColor;
                }
                Send.Zj(LogicView.IfString.Tag, Common.Logic.CurrentLogic);
                if (!Config.Instance.Home.IsVirtually)
                {
                    Send.Zj(LogicView.IfString.Tag, Common.Logic.CurrentLogic);

                }
            };

            if (Common.Logic.CurrentLogic.LogicIsCustomPushText == 0)
@@ -759,43 +763,94 @@
            bool succeed = false;
            //判断是新添加逻辑(默认0)还是修改逻辑
            CommonPage.Loading.Start();
            if (CurrentLogic.LogicId == 0)
            {
                //发送添加逻辑命令
                var logicifon = await Send.AddModifyLogic(CurrentLogic);
                if (logicifon != null && logicifon.LogicId != 0)
                {
                    succeed = true;
                    CurrentLogic.LogicId = logicifon.LogicId;
                    if (LogicView.IfString._Logic == if_logic || LogicView.IfString._SoneLogic == if_logic)
                    {
                        //自动化逻辑列表
                        Common.Logic.LogicList.Add(CurrentLogic);
                    }
                    if (LogicView.IfString._LockLogic == if_logic)
                    {
                        //门锁联动事件逻辑列表
                        Common.Logic.LockLogicList.Add(CurrentLogic);
                    }
                    if (LogicView.IfString._SoneLogic == if_logic)
                    {
                        //Sone门锁联动事件逻辑列表
                        Common.Logic.SoneLogicList.Add(CurrentLogic);

                    }
                    if (tag)
                    {
                        Send.Zj(tag, CurrentLogic);
                    }
            if (Config.Instance.Home.IsVirtually)
            {
                if (Common.Logic.LogicList.Count == 0)
                {
                    CurrentLogic.LogicId = 1;
                    Common.Logic.LogicList.Add(CurrentLogic);
                }

                if (CurrentLogic.LogicId == 0)
                {
                    bool d = false;
                    for (int i = 1; i < 50; i++)
                    {
                       
                        for (int j = 0; j < Common.Logic.LogicList.Count; j++)
                        {
                            if (i != Common.Logic.LogicList[j].LogicId)
                            {
                                CurrentLogic.LogicId = i;
                                Common.Logic.LogicList.Add(CurrentLogic);
                                d = true;
                                break;
                            }
                        }
                        if (d)
                        {
                            break;
                        }
                    }

                }
                else
                {
                    for (int j = 0; j < Common.Logic.LogicList.Count; j++)
                    {
                        if (CurrentLogic.LogicId == Common.Logic.LogicList[j].LogicId)
                        {
                            Common.Logic.LogicList.RemoveAt(j);
                            Common.Logic.LogicList.Insert(j,CurrentLogic);
                            break;
                        }
                    }

                }

                //自动化逻辑列表
            }
            else
            {
                //发送修改逻辑命令；
                //修改命令不需要等待回复；
                Send.AddModifyLogic(CurrentLogic);
                //编辑默认成功（不考虑网络情况）；
                succeed = true;
                if (CurrentLogic.LogicId == 0)
                {
                    //发送添加逻辑命令
                    var logicifon = await Send.AddModifyLogic(CurrentLogic);
                    if (logicifon != null && logicifon.LogicId != 0)
                    {
                        succeed = true;
                        CurrentLogic.LogicId = logicifon.LogicId;
                        if (LogicView.IfString._Logic == if_logic || LogicView.IfString._SoneLogic == if_logic)
                        {
                            //自动化逻辑列表
                            Common.Logic.LogicList.Add(CurrentLogic);
                        }
                        if (LogicView.IfString._LockLogic == if_logic)
                        {
                            //门锁联动事件逻辑列表
                            Common.Logic.LockLogicList.Add(CurrentLogic);
                        }
                        if (LogicView.IfString._SoneLogic == if_logic)
                        {
                            //Sone门锁联动事件逻辑列表
                            Common.Logic.SoneLogicList.Add(CurrentLogic);

                        }
                        if (tag)
                        {
                            Send.Zj(tag, CurrentLogic);
                        }
                    }
                }
                else
                {
                    //发送修改逻辑命令；
                    //修改命令不需要等待回复；
                    Send.AddModifyLogic(CurrentLogic);
                    //编辑默认成功（不考虑网络情况）；
                    succeed = true;
                }
            }
            CommonPage.Loading.Hide();


 ZigbeeApp/Shared/Phone/Device/Logic/SkipView.cs

@@ -20,10 +20,8 @@
            {
                case 0:
                    {


                        ////new一个新逻辑对象；
                        ////新增正常自动化入口
                        //new一个新逻辑对象；
                        //新增正常自动化入口
                        Common.Logic.CurrentLogic = new Common.Logic();
                        Common.Logic.CurrentLogic.IsEnable = 1;//默认为开
                        Common.Logic.CurrentLogic.LogicType = 0;//标记逻辑类型
@@ -62,12 +60,12 @@
                        doorLockLogicList.Show();
                    }
                    break;

              
            }

        }


       
        #region ◆ 自动化__________________________
        /// <summary>
        /// 自动化功能代码入口
@@ -263,34 +261,37 @@
            CommonPage.Loading.Start();
            try
            {
                if (Common.Logic.LogicList.Count == 0)
                if (!Config.Instance.Home.IsVirtually)//虚拟的不获取网关逻辑列表
                {
                    var Idlist1 = await Send.GetLogicId(0);//
                    var Idlist2 = await Send.GetLogicId(2);//门锁常开模式
                    if (Idlist1.Count != 0)
                    if (Common.Logic.LogicList.Count == 0)
                    {
                        var listlogic1 = await Send.ReadList(Idlist1.Count, 0);
                        for (int j = 0; j < listlogic1.Count; j++)
                        var Idlist1 = await Send.GetLogicId(0);//
                        var Idlist2 = await Send.GetLogicId(2);//门锁常开模式
                        if (Idlist1.Count != 0)
                        {
                            var logic = listlogic1[j];
                            if (logic.LogicType != 0)
                            var listlogic1 = await Send.ReadList(Idlist1.Count, 0);
                            for (int j = 0; j < listlogic1.Count; j++)
                            {
                                continue;
                                var logic = listlogic1[j];
                                if (logic.LogicType != 0)
                                {
                                    continue;
                                }
                                Common.Logic.LogicList.Add(logic);
                            }
                            Common.Logic.LogicList.Add(logic);
                        }
                    }
                    if (Idlist2.Count != 0)
                    {
                        var listlogic2 = await Send.ReadList(Idlist2.Count, 2);
                        for (int j = 0; j < listlogic2.Count; j++)
                        if (Idlist2.Count != 0)
                        {
                            var logic = listlogic2[j];
                            if (logic.LogicType != 2)
                            var listlogic2 = await Send.ReadList(Idlist2.Count, 2);
                            for (int j = 0; j < listlogic2.Count; j++)
                            {
                                continue;
                                var logic = listlogic2[j];
                                if (logic.LogicType != 2)
                                {
                                    continue;
                                }
                                Common.Logic.LogicList.Add(logic);
                            }
                            Common.Logic.LogicList.Add(logic);
                        }
                    }
                }
@@ -310,6 +311,7 @@
        /// <param name="refresview">Refresview.</param>
        private static async void Automationview(VerticalRefreshLayout refresview, bool no)
        {
            
            refresview.RemoveAll();
            if (Common.Logic.LogicList.Count == 0 && no == false)
            {
@@ -398,7 +400,7 @@
                    //实现android显示逻辑列表的圆角;
                    fLayout.SetCornerWithSameRadius(Application.GetRealHeight(58), HDLUtils.RectCornerTopLeft);
                    logicRowlayout.SetCornerWithSameRadius(Application.GetRealHeight(58), HDLUtils.RectCornerTopLeft);

                   
                }
                i++;
                var logicnameBtn = new Button
@@ -441,7 +443,10 @@
                        logic.IsEnable = 0;
                        StatusColor(logic, logicRowlayout, 0);
                    }
                    Send.LogicControlSwitch(logic);
                    if (!Config.Instance.Home.IsVirtually)
                    {
                        Send.LogicControlSwitch(logic);
                    }
                    //Logic.Send.AddModifyLogic(logic);
                };
                if (logic.IsEnable == 1)
@@ -503,7 +508,10 @@
                    {
                        Common.Logic.LogicList.Remove(logic);
                        Automationview(refresview, no);
                        Send.DelLogic(logic.LogicId);
                        if (!Config.Instance.Home.IsVirtually)
                        {
                            Send.DelLogic(logic.LogicId);
                        }
                    };

                };
@@ -780,6 +788,7 @@
            }
            return _if;
        }

       
    }
}


 ZigbeeApp/Shared/Phone/Device/Logic/SoneLogicList.cs

old mode 100755
new mode 100644
@@ -16,11 +16,7 @@
        {
            Tag = "SoneLogic";
        }
        /// <summary>
        ///
        /// </summary>
        /// <param name="action">给徐梅刷新界面用的</param>
        /// <param name="bool_If"></param>
        /// 给徐梅刷新界面用的
        public Action<bool> action;
        public async void Show()
        {
@@ -33,13 +29,11 @@
            view.clickBtn.MouseDownEventHandler += (sender, e) =>
            {
                UserView.HomePage.Instance.ScrollEnabled = true;
                RemoveFromParent();
                if (action != null)
                {
                    action(Send.CurrentDoorLock.IsDoorLockNormallyMode);
                }

                RemoveFromParent();

            };

            var middle = new FrameLayout
@@ -67,8 +61,6 @@
                Y = Application.GetRealHeight(92),
                Width = Application.GetMinRealAverage(294),
                Height = Application.GetMinRealAverage(294),
                UnSelectedImagePath = "ZigeeLogic/noMode.png",
                SelectedImagePath = "ZigeeLogic/openMode.png",
            };
            fLayout.AddChidren(modeIconBtn);

@@ -78,7 +70,7 @@
                var logic = await SkipView.GetLogicIfon();

                fLayout.Height = Application.GetRealHeight(780);//改变高度
                modeIconBtn.IsSelected = true;//改变图标状态
                modeIconBtn.UnSelectedImagePath = "ZigeeLogic/openMode.png";//改变图标状态
                ///第二级父控件
                var openModeFl = new FrameLayout
                {
@@ -116,11 +108,12 @@
                        var soneLogicList = new SoneLogicList();
                        UserView.HomePage.Instance.AddChidren(soneLogicList);
                        UserView.HomePage.Instance.PageIndex += 1;
                        soneLogicList.Show();

                        soneLogicList.Show();
                        soneLogicList.action = action;

                    }
                    else
                    {
                        ///提示失败
                        LogicView.TipView.ShowFlashTip("关闭失败");
                    }

                };
@@ -129,8 +122,8 @@
                var timeTextBtn = new Button
                {
                    Y = Application.GetRealHeight(127 + 69),
                    X = Application.GetRealWidth(225),
                    Width = Application.GetRealWidth(634),
                    X = Application.GetRealWidth(125),
                    Width = Application.GetRealWidth(634 + 200),
                    Height = Application.GetRealHeight(60),
                    TextSize = 15,
                    TextColor = ZigbeeColor.Current.LogicTextBlackColor,
@@ -152,7 +145,8 @@
                    var timeInt = int.Parse(logic.Conditions[0]["DoorLockOpenDelayTime"]);
                    int dayInt = (h + timeInt) / 24;//算出几天后执行
                    int hour = (h + timeInt) % 24;//算出几天后那个时间执行
                    timeTextBtn.Text = "时效性常开设置" + y + "年" + m + "月" + d + dayInt + "号" + timeInt + "时" + "执行";
                    int days = int.Parse(d) + dayInt;
                    timeTextBtn.Text = "时效性常开设置" + y + "年" + m + "月" + days.ToString() + "号" + hour.ToString() + "时" + "执行";
                }
                catch { }

@@ -160,7 +154,7 @@
            else
            {
                fLayout.Height = Application.GetRealHeight(645);//改变高度
                modeIconBtn.IsSelected = false;//改变图标状态
                modeIconBtn.UnSelectedImagePath = "ZigeeLogic/noMode.png";//改变图标状态
                ///第二级父控件
                var modeFl = new FrameLayout
                {
@@ -195,58 +189,65 @@
                    Height = Application.GetMinRealAverage(104),
                    X = Application.GetRealWidth(861),
                    Y = Application.GetRealHeight(17),
                    UnSelectedImagePath = "ZigeeLogic/next.png",
                    UnSelectedImagePath = "ZigeeLogic/nextIconSone.png",
                };
                modeFl.AddChidren(nextIconBtn);



                nextIconBtn.MouseUpEventHandler += (sender, e) =>
                 {
                     LogicView.TipView.ShowConfrimTip(() =>
                     {///再次确认
                       LogicView.TipView.ShowInputTip(true, async (str) =>
                         {///确认发送命令
                           try
                             {
                               ///xm
                               var result = await UserCenter.DoorLock.DoorLockCommonInfo.SetNormallyOpenModeFuncAsync(Send.CurrentDoorLock);
                                 if (!result)
                                 {
                                     Application.RunOnMainThread(() =>
                                     {
                                       ///提示失败
                                   });
                                     return;
                                 }
                                 else
                                 {
                                   ///因为有常开模式下才可以创建失效逻辑；
                                   SkipView.GetLogicAll();//删除之前所有失效逻辑
                                   var addResult = await SkipView.LockAddModifyLogic(int.Parse(str), Send.CurrentDoorLock);//添加一条失效逻辑
                                   if (!addResult)
                                     {
                                       ///提示失败
                                       return;
                                     }

                                     Send.CurrentDoorLock.IsDoorLockNormallyMode = true;
                                     this.RemoveFromParent();
                                     var soneLogicList = new SoneLogicList();
                                     UserView.HomePage.Instance.AddChidren(soneLogicList);
                                     UserView.HomePage.Instance.PageIndex += 1;
                                     soneLogicList.Show();
                {

                                 }
                             }
                             catch
                             {
                    LogicView.TipView.ShowConfrimTip(() =>

                             }
                         });
                    {///再次确认
                        LogicView.TipView.ShowInputTip(true, async (str) =>
                        {///确认发送命令
                            try
                            {
                                ///xm
                                var result = await UserCenter.DoorLock.DoorLockCommonInfo.SetNormallyOpenModeFuncAsync(Send.CurrentDoorLock);
                                if (!result)
                                {
                                    LogicView.TipView.ShowFlashTip("开启失败");
                                    return;
                                }
                                else
                                {
                                    ///因为有常开模式下才可以创建失效逻辑；
                                    SkipView.GetLogicAll();//删除之前所有失效逻辑
                                    var addResult = await SkipView.LockAddModifyLogic(int.Parse(str), Send.CurrentDoorLock);//添加一条失效逻辑
                                    if (!addResult)
                                    {
                                        ///提示失败
                                        LogicView.TipView.ShowFlashTip("添加失败");
                                        return;
                                    }
                                    Send.CurrentDoorLock.IsDoorLockNormallyMode = true;
                                    this.RemoveFromParent();
                                    var soneLogicList = new SoneLogicList();
                                    UserView.HomePage.Instance.AddChidren(soneLogicList);
                                    UserView.HomePage.Instance.PageIndex += 1;
                                    soneLogicList.Show();
                                    soneLogicList.action = action;
                                    //soneLogicList.action += (c) => {
                                    //    if (action != null)
                                    //    {
                                    //        action(Send.CurrentDoorLock.IsDoorLockNormallyMode);
                                    //    }
                                    //};

                     });
                                }
                            }
                            catch
                            {

                 };
                            }
                        });

                    });

                };
            }

            #endregion
@@ -397,10 +398,11 @@
        /// 加载自动化列表
        /// </summary>
        /// <param name="verticalRefresh"></param>
        RowLayout selectedRow = new RowLayout() { Tag = "0" };//记录左滑状态
        int a = 1;
        private void RefreshView(VerticalRefreshLayout verticalRefresh)
        {
            verticalRefresh.RemoveAll();

            foreach (var logic in Common.Logic.SoneLogicList)
            {
                #region  自动化布局View
@@ -417,17 +419,19 @@
                    LineColor = ZigbeeColor.Current.LogicBackgroundColor,
                    BackgroundColor = ZigbeeColor.Current.LogicBackgroundColor,
                    SubViewWidth = Application.GetRealWidth(184),//改变编辑控件宽度多少；
                    Tag = a.ToString(),
                };
                fLayout.AddChidren(logicRow);
                //左滑菜单事件
                logicRow.OpenMenuAction += () =>
                {
                    //if (selectedRow.Tag.ToString() != logicRowlayout.Tag.ToString())
                    //{   //保留左滑只有一个;
                    //    selectedRow.HideMenu();//
                    //}
                    //selectedRow = logicRowlayout;
                    if (selectedRow.Tag.ToString() != logicRow.Tag.ToString())
                    {   //保留左滑只有一个;
                        selectedRow.HideMenu();//
                    }
                    selectedRow = logicRow;
                };
                a++;
                ///显示逻辑名称的控件

                var nameBtn = new Button
                {

 ZigbeeApp/Shared/Phone/MainPage/ControlForm/DeviceFreshAirDetailCardForm.cs

@@ -32,10 +32,9 @@
        /// <summary>

        /// 设备名称控件

        /// </summary>

        private NormalViewControl btnDeviceName = null;



        #endregion
        private NormalViewControl btnDeviceName = null;

        #endregion

        #region ■ 初始化_____________________________
        public override void InitMiddleFrameAfter(FrameLayout frameWhiteBack)
@@ -129,6 +128,13 @@
            this.listControl.Add(btnHighSpeed);

            btnHighSpeed.ButtonClickEvent += (sender, e) =>

            {

                if (FreshAirDev.currentFanMode == 15)
                {
                    var msgContr = new ShowMsgControl(ShowMsgType.Tip, Language.StringByID(R.MyInternationalizationString.AutoModeForbiddenOperate));
                    msgContr.Show();
                    return;
                }

                if (!btnHighSpeed.IsSelected)
                {
                    this.SetFanComand(3);
@@ -166,6 +172,12 @@
            this.listControl.Add(btnLowSpeed);

            btnLowSpeed.ButtonClickEvent += (sender, e) =>

            {
                if (FreshAirDev.currentFanMode == 15)
                {
                    var msgContr = new ShowMsgControl(ShowMsgType.Tip, Language.StringByID(R.MyInternationalizationString.AutoModeForbiddenOperate));
                    msgContr.Show();
                    return;
                }
                if (!btnLowSpeed.IsSelected)
                {
                    this.SetFanComand(1);

 ZigbeeApp/Shared/Phone/MainPage/Controls/DeviceCard/DeviceFreshAirCardControl.cs

old mode 100644
new mode 100755

 ZigbeeApp/Shared/Phone/MainPage/HomeMainPageForm.cs

old mode 100644
new mode 100755

 ZigbeeApp/Shared/Phone/UserCenter/CommonBase/Controls/RowLayoutControls/DeviceFunctionTypeRowControl.cs

old mode 100644
new mode 100755
@@ -30,7 +30,7 @@
        /// </summary>

        public bool SetCanSelect

        {

            set

            set 
            {

                m_SetCanSelect = value;

            }


 ZigbeeApp/Shared/Phone/UserCenter/CommonBase/Logic/HdlDevicePanelLogic.cs

old mode 100644
new mode 100755
@@ -89,7 +89,7 @@
        public async Task<Panel.KeyColorData> GetPanelColorInfo(Panel panel)

        {

            panel.DeviceEpoint = 1;

            Panel.KeyNum keyNum = (Panel.KeyNum)panel.DeviceEpoint;
            Panel.KeyNum keyNum = (Panel.KeyNum)panel.DeviceEpoint;

            var result = await panel.GetPanelColorInfoAsync(keyNum);

            //共通错误检测

            string error = HdlCheckLogic.Current.CheckCommonErrorCode(result);

@@ -118,7 +118,7 @@
        public async Task<bool> SetPanelEpointColorInfo(Panel panel, Panel.KeyColorData colorData)

        {

            var keyNum = new Panel.KeyNumStatus();

            Type type = keyNum.GetType();
            Type type = keyNum.GetType();

            type.InvokeMember("Key" + panel.DeviceEpoint, System.Reflection.BindingFlags.SetField, null, keyNum, new object[] { true });



            var result = await panel.SetPanelColorInfoAsync(colorData, keyNum);

@@ -173,7 +173,7 @@
        }



        #endregion




        #region ■ 亮度调节___________________________

        /// <summary>

        /// 获取设备亮度配置（ui叫亮度调节,使用返回值的panelDirectionsLevel）

@@ -302,7 +302,7 @@
        /// 配置接近传感

        /// </summary>

        /// <param name="device">设备对象</param>

        /// <para>sensorEnable:传感器使能</para>

        /// <para>sensorEnable:传感器使能</para> 
        /// <returns></returns>

        public async Task<bool> SetProximitySensorStatus(CommonDevice device, bool sensorEnable)

        {

@@ -576,15 +576,15 @@
        /// </summary>

        /// <param name="panel">按键面板的某一个回路</param>

        /// <param name="parameter">

        /// <para>方法1：当int[]传空，返回值是“面板具有的功能大类,即返回“第一级别。1024:灯类，256:按键类，768:PIR类</para>
        /// <para>方法1：当int[]传空，返回值是“面板具有的功能大类,即返回“第一级别。1024:灯类，256:按键类，768:PIR类</para> 
        /// <para>方法2：、当int[]值为第一级别PrivateFuncTypeFir中选择一个。</para>
        /// <para>返回值是“面按键发送功能类”，即返回“第二级别。</para>
        /// <para>100:Switch,开关（按键类）;200:Dimmer,调光（按键类）;300:Curtain,窗帘（按键类）</para>
        /// <para>0:EnergySavingMode,节能模式（灯类）;1:SleepMode,睡眠模式（灯类）;100:WhiteBalance,白平衡（灯类）;101:RGBColor,RGB指示灯颜色（灯类）;102:RGBLevel,RGB指示灯亮度（灯类）</para>
        /// <para>方法3：当int[]值为第一级别PrivateFuncTypeFir中选择一个，接着再选第二级别PrivateFunTypeSec中选择一个 </para>
        /// <para>返回值是“面按键具体功能配置”，即返回“第二级别。</para>
        /// <para>100:SwitchOpen,开关开（按键类）;101:SwitchClose,开关关（按键类）;102:SwitchChange,开关切换（按键类）</para>
        /// <para>200:DimmerStepUp,增大调光（按键类）;201:DimmerStepDown,降低调光（按键类）;202:DimmerStepChange,调光切换（按键类）</para>
        /// <para>100:SwitchOpen,开关开（按键类）;101:SwitchClose,开关关（按键类）;102:SwitchChange,开关切换（按键类）</para> 
        /// <para>200:DimmerStepUp,增大调光（按键类）;201:DimmerStepDown,降低调光（按键类）;202:DimmerStepChange,调光切换（按键类）</para> 
        /// <para>300:CurtainOpen,窗帘开（按键类）;301:CurtainClose,窗帘关（按键类）;302:CurtainStop,窗帘停;303:CurtainUpStop,窗帘上升停;304:CurtainDownstop,窗帘下降停</para>

        /// </param>

        /// <returns></returns>


 ZigbeeApp/Shared/Phone/UserCenter/CommonBase/Logic/HdlExperienceAccountLogic.cs

@@ -561,6 +561,7 @@
                //1个传感器

                var device = new IASZone() { DeviceAddr = "DeviceAddr" + this.DeviceNumber, DeviceEpoint = 1 };

                device.IasDeviceType = 13;

                device.DeviceID = 1026;

                //设置设备的基本信息

                this.SetBaseDataToDevice(device, 1200, 1200, "MSPIR01-ZB.10", i_RoomId);



@@ -581,6 +582,7 @@
            {

                var device = new IASZone() { DeviceAddr = "DeviceAddr" + this.DeviceNumber, DeviceEpoint = 1 };

                device.IasDeviceType = 43;

                device.DeviceID = 1026;

                //设置设备的基本信息

                this.SetBaseDataToDevice(device, 1300, 1300, "MSG01/M-ZB.10", i_RoomId);



@@ -594,6 +596,7 @@
            {

                var device = new IASZone() { DeviceAddr = "DeviceAddr" + this.DeviceNumber, DeviceEpoint = 1 };

                device.IasDeviceType = 43;

                device.DeviceID = 1026;

                //设置设备的基本信息

                this.SetBaseDataToDevice(device, 1300, 1300, "MGCD01/ZB.10", i_RoomId);



@@ -607,6 +610,7 @@
            {

                var device = new IASZone() { DeviceAddr = "DeviceAddr" + this.DeviceNumber, DeviceEpoint = 1 };

                device.IasDeviceType = 21;

                device.DeviceID = 1026;

                //设置设备的基本信息

                this.SetBaseDataToDevice(device, 1301, 1301, "MSDC01/M-ZB.10", i_RoomId);



@@ -620,6 +624,7 @@
            {

                var device = new IASZone() { DeviceAddr = "DeviceAddr" + this.DeviceNumber, DeviceEpoint = 1 };

                device.IasDeviceType = 40;

                device.DeviceID = 1026;

                //设置设备的基本信息

                this.SetBaseDataToDevice(device, 1301, 1301, "MSS01/M-ZB.10", i_RoomId);



@@ -633,6 +638,7 @@
            {

                var device = new IASZone() { DeviceAddr = "DeviceAddr" + this.DeviceNumber, DeviceEpoint = 1 };

                device.IasDeviceType = 13;

                device.DeviceID = 1026;

                //设置设备的基本信息

                this.SetBaseDataToDevice(device, 1303, 1303, "MSPIR01/M-ZB.10", i_RoomId);



@@ -646,6 +652,7 @@
            {

                var device = new IASZone() { DeviceAddr = "DeviceAddr" + this.DeviceNumber, DeviceEpoint = 1 };

                device.IasDeviceType = 42;

                device.DeviceID = 1026;

                //设置设备的基本信息

                this.SetBaseDataToDevice(device, 1304, 1304, "MSW01/M-ZB.10", i_RoomId);



@@ -659,6 +666,7 @@
            {

                var device = new IASZone() { DeviceAddr = "DeviceAddr" + this.DeviceNumber, DeviceEpoint = 1 };

                device.IasDeviceType = 44;

                device.DeviceID = 1026;

                //设置设备的基本信息

                this.SetBaseDataToDevice(device, 1305, 1305, "MBU01/M-ZB.10", i_RoomId);




 ZigbeeApp/Shared/Phone/UserCenter/CommonBase/Logic/HdlGatewayReceiveLogic.cs

old mode 100644
new mode 100755
@@ -546,7 +546,7 @@
                    {

                        HdlThreadLogic.Current.RunThread(async () =>

                        {

                            //温居城的要网关中是否有逻辑存在

                            //温居城的要网关中是否有逻辑存在 
                            //参数:2-常开自动化;3-失效时间自动化

                            var result = await Shared.Phone.Device.Logic.SkipView.Exist(2);

                            HdlThreadLogic.Current.RunMain(() =>

@@ -571,7 +571,7 @@
        /// 设备在线状态更新反馈

        /// </summary>

        /// <param name="receiveData"></param>

        private void DeviceOnlineChangePush(JObject receiveData)

        private void DeviceOnlineChangePush (JObject receiveData)

        {

            if (this.dicDeviceEvent.Count == 0)

            {


 ZigbeeApp/Shared/Phone/UserCenter/CommonBase/Logic/UserCenterLogic.cs

@@ -940,6 +940,7 @@
        /// </summary>

        private static void InitUserCenterMenmoryByVirtualHome()

        {

            UserCenterResourse.AccountOption.OldHomeStringId = Common.Config.Instance.Home.Id;

            //清空所有成员缓存

            ClearAllMemberMemory();

            //预创建个人中心全部的文件夹

@@ -975,6 +976,11 @@
            UserCenterResourse.ResidenceOption.HomeMainPageSwitchIndex = 1;

            //当前分类,场景和功能所选择的分支 0:场景 1:功能 2:自动化

            UserCenterResourse.ResidenceOption.CategoryPageSwitchIndex = 0;



            //切换住宅清除之前逻辑缓存数据;

            Common.Logic.LogicList.Clear();

            Common.Logic.LockLogicList.Clear();

            Common.Logic.SoneLogicList.Clear();

        }



        #endregion


 ZigbeeApp/Shared/Phone/UserCenter/Device/Bind/BindInfo.cs

old mode 100644
new mode 100755

 ZigbeeApp/Shared/Phone/UserCenter/Device/Bind/BindTargetsPage.cs

old mode 100644
new mode 100755
@@ -88,8 +88,11 @@
                {
                    localDeviceList.Clear();
                    scList.Clear();
                    //获取本地设备列表 
                    localDeviceList = Shared.Common.LocalDevice.Current.listAllDevice;
                    //获取本地设备列表
                    foreach (var dev in Shared.Common.LocalDevice.Current.listAllDevice)
                    {
                        localDeviceList.Add(dev);
                    }
                    //获取本地场景列表
                    scList = HdlSceneLogic.Current.GetAllRoomSceneList();
                    //获取网关场景表

 ZigbeeApp/Shared/Phone/UserCenter/Device/DeviceSearchForm.cs

@@ -213,7 +213,7 @@
                //添加设备的缓存

                device.IsOnline = 1;

                Common.LocalDevice.Current.AddDeviceToMemory(ref device);



 
                if (this.dicNewDevice.ContainsKey(device.DeviceAddr) == false)

                {

                    this.dicNewDevice[device.DeviceAddr] = new List<CommonDevice>();


 ZigbeeApp/Shared/Phone/UserCenter/Device/Direction/AddDeviceTypeListForm.cs

old mode 100644
new mode 100755
@@ -182,11 +182,6 @@
            unSelectPic = "Device/SensorPMTwoPointFive.png";
            this.AddMenuRow(objectText, unSelectPic, "SensorPMTwoPointFiveForm");


            //PM2.5空气质量传感器

            objectText = Language.StringByID(R.MyInternationalizationString.uDeviceDirectionName26);
            unSelectPic = "Device/SensorPMTwoPointFive.png";
            this.AddMenuRow(objectText, unSelectPic, "SensorPMTwoPointFiveForm");



            //中继器

            objectText = Language.StringByID(R.MyInternationalizationString.uDeviceDirectionName24);
            unSelectPic = "Device/RepeaterZigbee.png";

 ZigbeeApp/Shared/Phone/UserCenter/Device/Direction/PanelFangyueFreshAirDirectionForm.cs

old mode 100755
new mode 100644
@@ -51,8 +51,9 @@
            btnSecond.TextID = R.MyInternationalizationString.uPressAndHoldThisKey;
            framePic.AddChidren(btnSecond);

            //长按图示按键5秒以上，指示灯变绿、闪烁
            //进入配网状态。绿灯快闪3秒则配网成功
            //按住面板模式按键5秒，绿色指示灯闪烁
            //进入配网状态；闪烁停止
            //指示灯变白色表示配网成功
            string[] msgArry = Language.StringByID(R.MyInternationalizationString.AddFreshAirPanelMsg).Split(new string[] { "{0}" }, StringSplitOptions.RemoveEmptyEntries);

            var msg1 = new NormalViewControl(bodyFrameLayout.Width, Application.GetRealHeight(60), false);
@@ -61,6 +62,7 @@
            msg1.TextColor = UserCenterColor.Current.TextGrayColor3;
            msg1.TextAlignment = TextAlignment.Center;
            bodyFrameLayout.AddChidren(msg1);

            var msg2 = new NormalViewControl(bodyFrameLayout.Width, Application.GetRealHeight(60), false);
            msg2.Y = msg1.Bottom;
            if (msgArry.Length > 1)
@@ -70,6 +72,17 @@
            msg2.TextColor = UserCenterColor.Current.TextGrayColor3;
            msg2.TextAlignment = TextAlignment.Center;
            bodyFrameLayout.AddChidren(msg2);

            var msg3 = new NormalViewControl(bodyFrameLayout.Width, Application.GetRealHeight(60), false);
            msg3.Y = msg2.Bottom;
            if (msgArry.Length > 1)
            {
                msg3.Text = msgArry[2];
            }
            msg3.TextColor = UserCenterColor.Current.TextGrayColor3;
            msg3.TextAlignment = TextAlignment.Center;
            bodyFrameLayout.AddChidren(msg3);

        }
        #endregion
    }

 ZigbeeApp/Shared/Phone/UserCenter/Device/Direction/PanelFangyueFreshAirModulDirectionForm.cs

old mode 100644
new mode 100755

 ZigbeeApp/Shared/Phone/UserCenter/Device/Direction/SensorPMTwoPointFiveForm.cs

old mode 100644
new mode 100755

 ZigbeeApp/Shared/Phone/UserCenter/Device/DoorLock/DoorLockHistoryLogForm.cs

@@ -660,6 +660,10 @@
                    {

                        continue;

                    }

                    if (data.CloudAccountId == null)

                    {

                        data.CloudAccountId = string.Empty;

                    }

                    listLog.Add(data);

                }




 ZigbeeApp/Shared/Phone/UserCenter/Device/Panel/PanelBackLighWithSensorForm.cs

old mode 100644
new mode 100755

 ZigbeeApp/Shared/Phone/UserCenter/Device/Panel/PanelFangyueFreshAirBackLightSettionForm.cs

old mode 100644
new mode 100755
@@ -98,7 +98,7 @@


        #endregion



        #region ■ 屏幕亮度级别_______________________

        #region ■ 屏幕亮度级别_______________________ 
        /// <summary>

        /// 添加屏幕亮度级别控件

        /// </summary>

@@ -306,7 +306,7 @@
            int B1 = Convert.ToInt32(this.keyColorData.OpenColorB, 16);

            uint backColor = this.GetColorByRGB((byte)R1, (byte)G1, (byte)B1);



            //颜色外框

            //颜色外框 
            var btnColorLine = new FrameLayoutStatuControl();

            btnColorLine.Width = Application.GetRealHeight(79);

            btnColorLine.Height = this.GetPictrueRealSize(79);

@@ -350,7 +350,7 @@


        #endregion



        #region ■ 节能模式行_________________________

        #region ■ 节能模式行_________________________ 
        /// <summary>

        ///  添加节能模式行

        /// </summary>

@@ -575,7 +575,7 @@
        }

        #endregion



        #region ■ 补充容器___________________________

        #region ■ 补充容器___________________________ 
        /// <summary>

        /// 行数超过容器时，补一个空白FrameLayout，使之能滑动

        /// </summary>


 ZigbeeApp/Shared/Phone/UserCenter/Device/Panel/PanelFangyueFreshAirButtonSettionForm.cs

@@ -37,6 +37,22 @@
        /// PM目标名字
        /// </summary>
        private string bindPmName = string.Empty;
        /// <summary>
        /// 被绑目标是新风
        /// </summary>
        private CommonDevice bindFreshAirDev;
        /// <summary>
        /// 被绑目标是温度
        /// </summary>
        private CommonDevice bindTemperatureDev;
        /// <summary>
        /// 被绑目标是湿度
        /// </summary>
        private CommonDevice bindHumidityDev;
        /// <summary>
        /// 被绑目标是PM2.5
        /// </summary>
        private CommonDevice bindPMDev;

        #endregion

@@ -122,7 +138,7 @@
        }
        #endregion

        #region ■ 初始化数据_________________________
        #region ■ 初始化数据_________________________ 

        /// <summary>
        /// 初始化数据
@@ -164,7 +180,7 @@
        }
        #endregion


        #region ■ 新风目标_________________________
        #region ■ 新风目标_________________________ 
        /// <summary>
        ///  新风目标行
        /// </summary>
@@ -188,7 +204,7 @@

            rowNewWind.ButtonClickEvent += (sender, e) =>

            {

                var addDevicePage = new Shared.Phone.UserCenter.DeviceBind.PanelFangyueFreshAirTargetsForm(this.deviceObj, 1);
                var addDevicePage = new Shared.Phone.UserCenter.DeviceBind.PanelFangyueFreshAirTargetsForm(this.deviceObj, bindFreshAirDev, 1);
                Shared.Phone.UserView.HomePage.Instance.AddChidren(addDevicePage);
                Shared.Phone.UserView.HomePage.Instance.PageIndex += 1;
                addDevicePage.Show();
@@ -208,8 +224,6 @@
                    });
                };

                //var form = new PanelFangyueFreshAirTargetForm();
                //form.AddForm(this.deviceObj, string.Empty, 3);
            };
        }
        #endregion
@@ -242,26 +256,39 @@
                            continue;
                        }
                        bindFreshAirName = device.DeviceEpointName;
                        bindFreshAirDev = device;
                    }
                    if (device.Type == DeviceType.TemperatureSensor)
                    {
                        bindTemperatureName = device.DeviceEpointName;
                        var bD = device as TemperatureSensor;
                        if (bD.SensorDiv == 1)
                        {
                            bindTemperatureName = device.DeviceEpointName;
                            bindTemperatureDev = device;
                        }
                        if (bD.SensorDiv == 2)
                        {
                            bindHumidityName = device.DeviceEpointName;
                            bindHumidityDev = device;
                        }
                    }
                    if (device.Type == DeviceType.FreshAirHumiditySensor)
                    {
                        bindHumidityName = device.DeviceEpointName;
                        bindHumidityDev = device;
                    }
                    //if (device.Type == DeviceType.FreshAir)
                    //{
                    //    bindPmName  = device.DeviceEpointName;
                    //}
                    if (device.Type == DeviceType.PMSensor)
                    {
                        bindPmName = device.DeviceEpointName;
                        bindPMDev = device;
                    }
                }
                result = true;
            }
            return result;
        }

        #region ■ PM2.5来源_________________________
        #region ■ PM2.5来源_________________________ 
        /// <summary>
        ///  PM2.5来源行
        /// </summary>
@@ -283,7 +310,7 @@
            var btnPMStatu = rowPM.AddMostRightView(msg, 700);
            rowPM.ButtonClickEvent += (sender, e) =>
            {
                var addDevicePage = new Shared.Phone.UserCenter.DeviceBind.PanelFangyueFreshAirTargetsForm(this.deviceObj, 4);
                var addDevicePage = new Shared.Phone.UserCenter.DeviceBind.PanelFangyueFreshAirTargetsForm(this.deviceObj, bindPMDev, 4);
                Shared.Phone.UserView.HomePage.Instance.AddChidren(addDevicePage);
                Shared.Phone.UserView.HomePage.Instance.PageIndex += 1;
                addDevicePage.Show();
@@ -306,7 +333,7 @@
        }
        #endregion

        #region ■ 温度来源_________________________
        #region ■ 温度来源_________________________ 
        /// <summary>
        ///  温度来源行
        /// </summary>
@@ -328,7 +355,7 @@
            var btnTemperatureStatu = rowTemPerature.AddMostRightView(msg, 700);
            rowTemPerature.ButtonClickEvent += (sender, e) =>
            {
                var addDevicePage = new Shared.Phone.UserCenter.DeviceBind.PanelFangyueFreshAirTargetsForm(this.deviceObj, 2);
                var addDevicePage = new Shared.Phone.UserCenter.DeviceBind.PanelFangyueFreshAirTargetsForm(this.deviceObj, bindTemperatureDev, 2);
                Shared.Phone.UserView.HomePage.Instance.AddChidren(addDevicePage);
                Shared.Phone.UserView.HomePage.Instance.PageIndex += 1;
                addDevicePage.Show();
@@ -351,7 +378,7 @@
        }
        #endregion

        #region ■ 湿度来源_________________________
        #region ■ 湿度来源_________________________ 
        /// <summary>
        ///  湿度来源行
        /// </summary>
@@ -373,7 +400,7 @@
            var btnHumidityStatu = rowHumidity.AddMostRightView(msg, 700);
            rowHumidity.ButtonClickEvent += (sender, e) =>
            {
                var addDevicePage = new Shared.Phone.UserCenter.DeviceBind.PanelFangyueFreshAirTargetsForm(this.deviceObj, 3);
                var addDevicePage = new Shared.Phone.UserCenter.DeviceBind.PanelFangyueFreshAirTargetsForm(this.deviceObj, bindHumidityDev, 3);
                Shared.Phone.UserView.HomePage.Instance.AddChidren(addDevicePage);
                Shared.Phone.UserView.HomePage.Instance.PageIndex += 1;
                addDevicePage.Show();
@@ -396,7 +423,7 @@
        }
        #endregion

        #region ■ 亮度调节_________________________
        #region ■ 亮度调节_________________________ 
        /// <summary>
        ///  亮度调节行
        /// </summary>
@@ -423,7 +450,7 @@
        }
        #endregion


        #region ■ 右上角菜单_________________________
        #region ■ 右上角菜单_________________________ 
        /// <summary>

        /// 初始化右上角菜单

        /// </summary>


 ZigbeeApp/Shared/Phone/UserCenter/Device/Panel/PanelFangyueFreshAirTargetsForm.cs

@@ -16,23 +16,25 @@
        /// 构造函数
        /// </summary>
        /// <param name="device"></param>
        /// <param name="deviceBindType">1:新风;2:温度传感器;3:湿度传感器</param>
        public PanelFangyueFreshAirTargetsForm(CommonDevice device, int deviceBindType)
        /// <param name="deviceBindType">1:新风;2:温度传感器;3:湿度传感器;4:PM2.5传感器</param>
        /// <param name="bindDev">绑定目标 </param>
        public PanelFangyueFreshAirTargetsForm(CommonDevice device, CommonDevice bindDev, int deviceBindType)
        {
            this.curControlDev = device as FreshAir;
            this.curBindDevice = bindDev;
            this.curDeviceBindType = deviceBindType;
        }
        #endregion

        #region  变量申明
        /// <summary>
        /// 当前控制设备
        /// </summary>
        //CommonDevice currentControlDevice;
        #region  变量申明 
        /// <summary>
        /// 当前新风面板【控制设备】
        /// </summary>
        FreshAir curControlDev;
        /// <summary>
        /// 当前被绑设备
        /// </summary>
        CommonDevice curBindDevice;
        /// <summary>
        /// 显示被绑定设备或场景的view
        /// </summary>
@@ -318,6 +320,19 @@
                    curentOldRoom = btnRoom;
                    curentOldRoomFrameLayout = btnRoomFrameLayout;
                }

                //被绑定的目标还未分配区域，默认是第一个
                if (string.IsNullOrEmpty(curControlDev.currentSelectRoomId))
                {
                    if (index == 0)
                    {
                        btnRoomFrameLayout.BackgroundImagePath = "Item/RoomIconBackgroundSelected.png";
                        btnRoom.TextColor = Shared.Common.ZigbeeColor.Current.XMWhite;
                        curentOldRoom = btnRoom;
                        curentOldRoomFrameLayout = btnRoomFrameLayout;
                    }
                }

                EventHandler<MouseEventArgs> eHandlerRoom = (sender, e) =>
                {
                    if (!btnRoom.IsSelected)
@@ -450,6 +465,21 @@
                    line2.Visible = false;
                }

                switch (curDeviceBindType)
                {
                    case 1:
                        devicePic.UnSelectedImagePath = "Device/FreshAirEpoint.png";
                        break;
                    case 2:
                        devicePic.UnSelectedImagePath = "Device/SensorTemperature.png";
                        break;
                    case 3:
                        devicePic.UnSelectedImagePath = "Device/SensorHumidity.png";
                        break;
                    case 4:
                        devicePic.UnSelectedImagePath = "Device/FreshAirEpoint.png";
                        break;
                }
                #endregion

                string mianKey = device.DeviceAddr + device.DeviceEpoint;
@@ -608,7 +638,7 @@
                    btnFloorText.Text = dicFloorList[floorId];

                    //获取楼层中房间列表 
                    supportRoomList = GetFloorRoomList(curFloorId);
                    supportRoomList = GetFloorRoomList();
                    if (!btnMethodText.IsSelected)
                    {
                        if (oldbutton != null)
@@ -665,11 +695,13 @@
                    {
                        CommonPage.Loading.Start("");
                    });
                    //获取被绑目标等信息
                    BindDevInfo(curBindDevice);

                    //获取楼层
                    dicFloorList = HdlRoomLogic.Current.GetFloorSortList();
                    //获取楼层中房间列表
                    supportRoomList = GetFloorRoomList(curControlDev.currentSelectFloorId);
                    supportRoomList = GetFloorRoomList();

                    //获取所有房间中匹配的能绑的目标
                    currentPanelSupportBindDeviceList = GetAllRoomSupportDeviceList();
@@ -725,11 +757,24 @@
                                        case 2:
                                            if (device.Type == DeviceType.TemperatureSensor)
                                            {
                                                targetList.Add(device);
                                                oldTargetList.Add(device);
                                                var bDev = device as TemperatureSensor;
                                                if (bDev.SensorDiv == 1)
                                                {
                                                    targetList.Add(device);
                                                    oldTargetList.Add(device);
                                                }
                                            }
                                            break;
                                        case 3:
                                            if (device.Type == DeviceType.TemperatureSensor)
                                            {
                                                var bDev = device as TemperatureSensor;
                                                if (bDev.SensorDiv == 2)
                                                {
                                                    targetList.Add(device);
                                                    oldTargetList.Add(device);
                                                }
                                            }
                                            if (device.Type == DeviceType.FreshAirHumiditySensor)
                                            {
                                                targetList.Add(device);
@@ -759,6 +804,7 @@
                        if (targetList.Count == 0)
                        {
                            curControlDev.currentSelectFloorId = BindInfo.GetCurrentSelectFloorId();
                            curControlDev.currentSelectRoomId = null;
                            if (BindInfo.GetCurrentSelectFloorIdName() != null)
                            {
                                Application.RunOnMainThread(() =>
@@ -1141,6 +1187,31 @@
        }

        /// <summary>
        /// 当前被绑定设备所属楼层和房间
        /// </summary>
        /// <param name="bindDev"></param>
        void BindDevInfo(CommonDevice bindDev)
        {
            if (bindDev == null)
            {
                return;
            }
            //获取本地设备列表 
            var localDeviceList = Shared.Common.LocalDevice.Current.listAllDevice;
            var tempDev = localDeviceList.Find(obj => obj.DeviceAddr == bindDev.DeviceAddr && obj.DeviceEpoint == bindDev.DeviceEpoint);
            if (tempDev != null)
            {
                //获取设备所属房间
                var tempDevRoom = HdlRoomLogic.Current.GetRoomByDevice(tempDev);
                if (tempDevRoom != null)
                {
                    curControlDev.currentSelectRoomId = tempDevRoom.Id;
                    curControlDev.currentSelectFloorId = tempDevRoom.FloorId;
                }
            }
        }

        /// <summary>
        /// 检测目标是否被绑定过
        /// </summary>
        /// <returns></returns>
@@ -1211,19 +1282,10 @@
                            }
                            break;
                        case 2:
                            foreach (var de in room.ListDevice)
                            {
                                var device = LocalDevice.Current.GetDevice(de);
                                if (device != null)
                                {
                                    if (device.Type == DeviceType.TemperatureSensor)
                                    {
                                        roomIncludeMatchDevice.Add(device);
                                    }
                                }
                            }
                            roomIncludeMatchDevice = GetMatchTemperatureSensorDevice(room);
                            break;
                        case 3:
                            roomIncludeMatchDevice = GetMatchHumiditySensorDevice(room);
                            foreach (var de in room.ListDevice)
                            {
                                var device = LocalDevice.Current.GetDevice(de);
@@ -1244,30 +1306,80 @@
                    {
                        continue;
                    }
                }

                if (!string.IsNullOrEmpty(room.FloorId))
                {
                    //有楼层
                    if (room.FloorId == curControlDev.currentSelectFloorId)
                    if (!string.IsNullOrEmpty(room.FloorId))
                    {
                        //有楼层
                        if (room.FloorId == curControlDev.currentSelectFloorId)
                        {
                            roomTempList.Add(room);
                        }
                    }
                    else
                    {
                        //没有楼层
                        roomTempList.Add(room);
                    }
                }
                else
                {
                    //没有楼层
                    roomTempList.Add(room);
                }
            }
            return roomTempList;
        }

        /// <summary>
        /// 匹配温度传感器
        /// </summary>
        /// <param name="room"></param>
        List<CommonDevice> GetMatchTemperatureSensorDevice(Room room)
        {
            List<CommonDevice> roomIncludeMatchTempDevice = new List<CommonDevice>();
            foreach (var de in room.ListDevice)
            {
                var device = LocalDevice.Current.GetDevice(de);
                if (device != null)
                {
                    if (device.Type == DeviceType.TemperatureSensor)
                    {
                        var dev = device as TemperatureSensor;
                        if (dev.SensorDiv == 1)
                        {
                            roomIncludeMatchTempDevice.Add(device);
                        }
                    }
                }
            }
            return roomIncludeMatchTempDevice;
        }

        /// <summary>
        /// 匹配湿度传感器
        /// </summary>
        /// <param name="room"></param>
        List<CommonDevice> GetMatchHumiditySensorDevice(Room room)
        {
            List<CommonDevice> roomIncludeMatchHumpDevice = new List<CommonDevice>();
            foreach (var de in room.ListDevice)
            {
                var device = LocalDevice.Current.GetDevice(de);
                if (device != null)
                {
                    if (device.Type == DeviceType.TemperatureSensor)
                    {
                        var dev = device as TemperatureSensor;
                        if (dev.SensorDiv == 2)
                        {
                            roomIncludeMatchHumpDevice.Add(device);
                        }
                    }
                }
            }
            return roomIncludeMatchHumpDevice;
        }

        /// <summary>
        /// 获取楼层对应的房间列表
        /// </summary>
        /// <returns></returns>
        private List<Room> GetFloorRoomList(string floorId)
        private List<Room> GetFloorRoomList()
        {
            supportRoomList.Clear();
            var supportRoomListTemp = new List<Room>();
@@ -1279,10 +1391,6 @@
                {
                    if (string.IsNullOrEmpty(room.FloorId))
                    {
                        if (room.FloorId != floorId)
                        {
                            continue;
                        }
                        if (room.IsLove)
                        {
                            continue;
@@ -1350,16 +1458,10 @@
                        {
                            continue;
                        }
                        foreach (var deviceKeys in r.ListDevice)
                        var deviceListTemp = GetMatchTemperatureSensorDevice(r);
                        foreach (var dev in deviceListTemp)
                        {
                            var device = LocalDevice.Current.GetDevice(deviceKeys);
                            if (device != null)
                            {
                                if (device.Type == DeviceType.TemperatureSensor)
                                {
                                    currentPanelBindSupportDeviceListTemp.Add(device);
                                }
                            }
                            currentPanelBindSupportDeviceListTemp.Add(dev);
                        }
                    }
                    break;
@@ -1369,6 +1471,11 @@
                        if (r.ListDevice.Count == 0)
                        {
                            continue;
                        }
                        var deviceListTemp = GetMatchHumiditySensorDevice(r);
                        foreach (var dev in deviceListTemp)
                        {
                            currentPanelBindSupportDeviceListTemp.Add(dev);
                        }
                        foreach (var deviceKeys in r.ListDevice)
                        {
@@ -1420,19 +1527,10 @@
                    }
                    break;
                case 2:
                    foreach (var deviceKeys in curRoom.ListDevice)
                    {
                        var device = LocalDevice.Current.GetDevice(deviceKeys);
                        if (device != null)
                        {
                            if (device.Type == DeviceType.TemperatureSensor)
                            {
                                curRoomDeviceListTemp.Add(device);
                            }
                        }
                    }
                    curRoomDeviceListTemp = GetMatchTemperatureSensorDevice(curRoom);
                    break;
                case 3:
                    curRoomDeviceListTemp = GetMatchHumiditySensorDevice(curRoom);
                    foreach (var deviceKeys in curRoom.ListDevice)
                    {
                        var device = LocalDevice.Current.GetDevice(deviceKeys);

 ZigbeeApp/Shared/Phone/UserCenter/DoorLock/DoorLockCommonInfo.cs

@@ -101,10 +101,10 @@

        #region 常开模式 API
        /// <summary>
        /// 获取当前门锁的常开模式
        /// 获取当前门锁的常开模式 
        /// </summary>
        /// <param name="doorLock:当前门锁"></param>
        /// <returns>null:没有回复  ； true:门锁常开；false：门锁常关</returns>
        /// <param name="doorLock:当前门锁"></param> 
        /// <returns>null:没有回复  ； true:门锁常开；false：门锁常关</returns> 
        public static async System.Threading.Tasks.Task<bool?> GetNormallyOpenMode(ZigBee.Device.DoorLock doorLock)
        {
            bool? IsDoorLockNormallyMode = null;
@@ -131,8 +131,8 @@
        /// <summary>
        /// 门锁是否支持常开[这里暂时只有S-One门锁支持，H06C不支持, 后期通过能力值支持]
        /// </summary>
        /// <param name="doorLock:当前门锁"></param>
        /// <returns>true:支持常开；false： 不支持常开</returns>
        /// <param name="doorLock:当前门锁"></param> 
        /// <returns>true:支持常开；false： 不支持常开</returns> 
        public static bool CanNormallyOpen(ZigBee.Device.DoorLock doorLock)
        {
            var listDevice = new List<CommonDevice> { };
@@ -165,7 +165,7 @@
        /// <param name="doorLockMessType">导致门锁失效的操作类型</param>
        /// <param name="haveLogic">网关中是否存在逻辑常开模式</param>
        /// <param name="action">回调处理更新内容</param>
        public static async void NomallyOpenModeInvalidDialog(ZigBee.Device.DoorLock doorLock, DoorLockMessType doorLockMessType, bool haveLogic, Action action = null)
        public static async void NomallyOpenModeInvalidDialog(ZigBee.Device.DoorLock doorLock, DoorLockMessType doorLockMessType, bool haveLogic, Action<bool> action = null)
        {
            //常开模式只能主人操作
            if (UserCenterResourse.UserInfo.AuthorityNo != 1)
@@ -194,7 +194,7 @@
            {
                if (doorLockMessType == DoorLockMessType.DeviceReport || doorLockMessType == DoorLockMessType.ServicePush)
                {
                    //上报“常开模式”已被取消，app默认了“常开模式”被取消
                    //上报“常开模式”已被取消，app默认了“常开模式”被取消 
                    DoorLockCommonInfo.NormallyOpenModeValue(doorLock, false);
                }
                else
@@ -202,7 +202,8 @@
                    //保持常开
                    NormallyOpenModeValue(doorLock, true);
                }
                action?.Invoke();
                action?.Invoke(doorLock.IsDoorLockNormallyMode);
                action = null;
            };

            alert.CancelClickEvent += async () =>
@@ -226,7 +227,8 @@
                            NormallyOpenModeValue(doorLock, false);
                            CommonPage.Loading.Hide();
                        });
                        action?.Invoke();
                        action?.Invoke(doorLock.IsDoorLockNormallyMode);
                        action = null;
                        return;
                    }
                    if (result.defaultControlResponseData.status != 0)
@@ -238,12 +240,13 @@
                            NormallyOpenModeValue(doorLock, false);
                            CommonPage.Loading.Hide();
                        });
                        action?.Invoke();
                        action?.Invoke(doorLock.IsDoorLockNormallyMode);
                        action = null;
                        return;
                    }
                    else
                    {
                        //创建常开模式的特殊逻辑
                        //创建常开模式的特殊逻辑 
                        var resu = await Shared.Phone.Device.Logic.SkipView.LockAddModifyLogic(DoorLockCommonInfo.NormallyOpenModeInvalidTime, doorLock);
                        Application.RunOnMainThread(() =>
                        {
@@ -256,10 +259,11 @@
                }
                else
                {
                    //app操作不取消“常开模式”
                    //app操作不取消“常开模式” 
                    DoorLockCommonInfo.NormallyOpenModeValue(doorLock, true);
                }
                action?.Invoke();
                action?.Invoke(doorLock.IsDoorLockNormallyMode);
                action = null;
            };

            alert.ConfirmClickEvent += async () =>
@@ -285,7 +289,8 @@
                            ShowTipMsg(Language.StringByID(R.MyInternationalizationString.GwResponseOvertime));
                            CommonPage.Loading.Hide();
                        });
                        action?.Invoke();
                        action?.Invoke(doorLock.IsDoorLockNormallyMode);
                        action = null;
                        return;
                    }
                    if (result.defaultControlResponseData.status != 0)
@@ -296,21 +301,22 @@
                            ShowTipMsg(msg1);
                            CommonPage.Loading.Hide();
                        });
                        action?.Invoke();
                        action?.Invoke(doorLock.IsDoorLockNormallyMode);
                        action = null;
                        return;
                    }
                    else
                    {
                        //添加App开启常开模式的历史记录
                        HdlDeviceDoorLockLogic.Current.AddDoorHistoryLog(doorLock, 9002, string.Empty);
                        //app确认取消“常开模式”成功
                        //app确认取消“常开模式”成功 
                        NormallyOpenModeValue(doorLock, false);
                        //删除设置常开模式创建的逻辑
                        if (haveLogic)
                        {
                            var resTemp1 = await Shared.Phone.Device.Logic.SkipView.Exist(3);
                            //温居城方法？？？
                            //此处是否要删除温居城的特殊逻辑
                            //此处是否要删除温居城的特殊逻辑 
                        }
                        Application.RunOnMainThread(() =>
                        {
@@ -320,7 +326,8 @@
                        });
                    }
                }
                action?.Invoke();
                action?.Invoke(doorLock.IsDoorLockNormallyMode);
                action = null;
            };
        }

@@ -332,7 +339,7 @@
        /// <returns></returns>

        public static async System.Threading.Tasks.Task<bool> DelNormallyOpenMode(ZigBee.Device.DoorLock doorLock, Action action = null)

        {

            //app操作取消“常开模式”

            //app操作取消“常开模式” 
            var result = await doorLock.SetNormallyOpenModeFuncAsync(false);

            if (result == null || result.defaultControlResponseData == null || result.defaultControlResponseData.status != 0)

            {

@@ -342,7 +349,7 @@


            if (result.defaultControlResponseData.status == 0)

            {

                //app确认取消“常开模式”成功

                //app确认取消“常开模式”成功 
                NormallyOpenModeValue(doorLock, false);

                action?.Invoke();

                return true;

@@ -358,8 +365,8 @@
        /// <returns></returns>

        public static async System.Threading.Tasks.Task<bool> SetNormallyOpenModeFuncAsync(ZigBee.Device.DoorLock doorLock)

        {

            //app设置“常开模式”失败

            var result = await doorLock.SetNormallyOpenModeFuncAsync(false);

            //app设置“常开模式”失败 
            var result = await doorLock.SetNormallyOpenModeFuncAsync(true);

            if (result == null || result.defaultControlResponseData == null || result.defaultControlResponseData.status != 0)

            {

                return false;

@@ -367,7 +374,7 @@


            if (result.defaultControlResponseData.status == 0)

            {

                //app设置“常开模式”成功

                //app设置“常开模式”成功  
                NormallyOpenModeValue(doorLock, false);

                return true;

            }

@@ -392,7 +399,7 @@
                return;
            }

            //设置常开模式后，您的门锁将始终处于打开状态，确认开启？
            //设置常开模式后，您的门锁将始终处于打开状态，确认开启？ 
            string msg = Language.StringByID(R.MyInternationalizationString.SetDoorLockNomallyOpen).Replace("{0}", "\r\n");
            var confirm = Language.StringByID(R.MyInternationalizationString.Confrim);
            var alert = new ShowDoorLockMsgControl(ShowDoorLockMsgControl.DoorLockMsgType.Confirm, msg, confirm);
@@ -409,7 +416,7 @@
        /// </summary>
        public static async void NomallyOpenModeInvalidTimeDialog(ZigBee.Device.DoorLock doorLock, Action action)
        {
            //失效设置
            //失效设置 
            string msgTimeInValidSetting = Language.StringByID(R.MyInternationalizationString.DoorLockOpenAllTheTime);
            var timeConfrim = Language.StringByID(R.MyInternationalizationString.Confrim);
            var alertTimeInValidSetting = new ShowDoorLockMsgControl(ShowDoorLockMsgControl.DoorLockMsgType.InValid, msgTimeInValidSetting, timeConfrim);
@@ -465,8 +472,8 @@
        /// <summary>
        /// 门锁是否支持音量[这里暂时只有S-One门锁支持，H06C不支持，后期通过能力值支持]
        /// </summary>
        /// <param name="doorLock:当前门锁"></param>
        /// <returns></returns>
        /// <param name="doorLock:当前门锁"></param> 
        /// <returns></returns> 
        public static bool CanVolume(ZigBee.Device.DoorLock doorLock)
        {
            var listDevice = new List<CommonDevice> { };
@@ -481,7 +488,7 @@

        #endregion

        #region 从云端获取的方法
        #region 从云端获取的方法 
        /// <summary>
        /// 获取当前账户门锁操作权限（是否被冻结）
        /// </summary>
@@ -633,7 +640,7 @@
                    }


                    //2、读取云端门锁信息
                    //2、读取云端门锁信息  
                    var getDoorLockInfoAllList = new List<ZigBee.Device.DoorLock.CloudDoorLockObj> { };
                    var getDoorLockInfoList = await Shared.Phone.UserCenter.DoorLock.DoorLockCommonInfo.GetDoorLockAllAccountInfolist(doorLock);
                    if (getDoorLockInfoList != null)
@@ -1119,7 +1126,7 @@
        /// <returns></returns>
        public static DateTime GetDoorLockZoneTime()
        {
            //通过经度获取时区
            //通过经度获取时区 
            var gwZone = int.Parse(CaculateTimeZone(Common.Config.Instance.Home.Longitude));
            //将本地时间转换成世界时
            var utc = DateTime.Now.AddHours(-gwZone);
@@ -1133,7 +1140,7 @@
        }

        /// <summary>
        ///  获取时区
        ///  获取时区 
        /// </summary>
        /// <param name="currentLon">currentLon:"+"为东区，“-”为西区</param>
        /// <returns></returns>
@@ -1194,7 +1201,7 @@

        #endregion

        #region 一般方法
        #region 一般方法 
        /// <summary>
        /// 显示错误信息窗口
        /// </summary>
@@ -1221,6 +1228,6 @@
            });
        }

        #endregion
        #endregion 
    }
}

 ZigbeeApp/Shared/Phone/UserCenter/DoorLock/FunctionSetting.cs

old mode 100755
new mode 100644
@@ -73,7 +73,7 @@
            EventHandler<MouseEventArgs> eHandlerBack = (sender, e) =>
            {
                RemoveFromParent();

                UserDoorLockPage.canShowDialog = true;
                //暂时不考虑下级界面等推送导致常开模式失效的问题
                //var userDoorLockPage = new UserDoorLockPage(currentRoom, deviceUI);
                //HomePage.Instance.AddChidren(userDoorLockPage);

 ZigbeeApp/Shared/Phone/UserCenter/DoorLock/MasterManagementPage.cs

@@ -28,7 +28,7 @@
        #endregion

        /// <summary>

        /// UI显示

        /// UI显示 
        /// </summary>
        public void Show()
        {
@@ -145,4 +145,4 @@
            }
        }
    }
}
}

 ZigbeeApp/Shared/Phone/UserCenter/DoorLock/ShowDoorLockMsgControl.cs

old mode 100644
new mode 100755
@@ -236,7 +236,7 @@
        /// <param name="frameBack"></param>

        private void InitInValidTimeDialog(FrameLayout frameBack)

        {

            //消息

            //消息 
            string[] msgArray = msgText.Split(new string[] { "{0}" }, StringSplitOptions.RemoveEmptyEntries);

            var btnMsg1 = new Button()

            {


 ZigbeeApp/Shared/Phone/UserCenter/DoorLock/UserDoorLockPage.cs

@@ -41,7 +41,13 @@
        /// <summary>
        /// 逻辑中是否有常开模式

        /// </summary>
        private bool HaveLogicNormallyOpenMode = false;

        private bool haveLogicNormallyOpenMode = false;



        /// <summary>
        /// 门锁深度控制上报窗口是否弹出

        /// </summary>
        public static bool canShowDialog = true;



        /// <summary>
        /// 当前电量
        /// </summary>
@@ -182,7 +188,7 @@
        #endregion

        /// <summary>

        /// UI显示

        /// UI显示 
        /// </summary>
        public void Show()
        {

@@ -510,7 +516,7 @@
                TextAlignment = TextAlignment.CenterLeft,
            };
            btnCurrentFrameLayout.AddChidren(btnCurrentRoomName);
            #endregion
            #endregion 
        }

        #region 音量弹窗
@@ -565,7 +571,7 @@
                ThumbImagePath = "DoorLock/UnLockButton.png",//进度条按钮图标
                ThumbImageHeight = Application.GetRealHeight(81),//进度条按钮图标的高度（默认正方形：宽和高一样）
                ProgressTextColor = ZigbeeColor.Current.LogicBtnCancelColor,
                ProgressTextSize = 12,//显示百分比字体大小
                ProgressTextSize = 12,//显示百分比字体大小 
                SeekBarViewHeight = Application.GetRealHeight(17),//进度条的宽度
                Progress = currentVolume,
            };
@@ -609,7 +615,14 @@
                        {

                            if (canOpenNormallyMode)
                            {
                                Application.RunOnMainThread(() => { NomallyOpenModeInvalidDialog(true); });
                                Application.RunOnMainThread(() =>
                                {
                                    Action<bool> action = (obj) =>
                                    {
                                        UpdateNomallyOpenStatus();
                                    };
                                    DoorLockCommonInfo.NomallyOpenModeInvalidDialog(doorLock, DoorLockCommonInfo.DoorLockMessType.ServicePush, haveLogicNormallyOpenMode, action);
                                });
                            }
                        }
                    }
@@ -687,11 +700,11 @@
                                var resTemp = await Shared.Phone.Device.Logic.SkipView.Exist(2);
                                if (resTemp == 1)
                                {
                                    HaveLogicNormallyOpenMode = true;
                                    haveLogicNormallyOpenMode = true;
                                }
                                else if (resTemp == 0)
                                {
                                    HaveLogicNormallyOpenMode = false;
                                    haveLogicNormallyOpenMode = false;
                                }
                            });
                        }
@@ -708,7 +721,7 @@
                    canVolume = DoorLockCommonInfo.CanVolume(doorLock);
                    if (canVolume)
                    {
                        //读取音量
                        //读取音量 
                        var resultRes = await doorLock.GetVolumeAsync();
                        if (resultRes == null || resultRes.volumeResponseData == null)
                        {
@@ -764,9 +777,9 @@

        #endregion

        #region 公共事件处理
        #region 公共事件处理 
        /// <summary>
        /// 事件处理
        /// 事件处理 
        /// </summary>
        public void ClickHandle()
        {
@@ -784,14 +797,11 @@
            //设置
            EventHandler<MouseEventArgs> btnFuncSetHander = (sender, e) =>
            {
                //打开其他界面时前移除【暂时不移除】
                //RemoveFromParent();

                var functionSetting = new Shared.Phone.UserCenter.DoorLock.FunctionSetting(currentRoom, doorLock);
                Shared.Phone.UserView.HomePage.Instance.AddChidren(functionSetting);
                Shared.Phone.UserView.HomePage.Instance.PageIndex += 1;
                functionSetting.Show();

                canShowDialog = false;
                functionSetting.devicNameAction += (deviceRename) =>
                {
                    if (!string.IsNullOrEmpty(deviceRename))
@@ -822,6 +832,7 @@
                //历史记录 ----   stan
                var form = new DeviceDoorLock.DoorLockHistoryLogForm();
                form.AddForm(this.doorLock.DeviceAddr);
                canShowDialog = false;
            };
            btnRecordFrameLayout.MouseDownEventHandler += handerRecord;
            btnRecord.MouseDownEventHandler += handerRecord;
@@ -832,11 +843,11 @@
                btnCollect.IsSelected = !btnCollect.IsSelected;
                if (btnCollect.IsSelected)
                {
                    HdlRoomLogic.Current.AddLoveDevice(deviceUI);//收藏
                    HdlRoomLogic.Current.AddLoveDevice(deviceUI);//收藏 
                }
                else
                {
                    HdlRoomLogic.Current.DeleteLoveDevice(deviceUI);//取消收藏
                    HdlRoomLogic.Current.DeleteLoveDevice(deviceUI);//取消收藏 
                }
            };
            btnCollectFrameLayout.MouseDownEventHandler += handerCollect;
@@ -848,8 +859,15 @@
                if (doorLock.IsDoorLockNormallyMode)
                {
                    if (canOpenNormallyMode)

                    {

                        NomallyOpenModeInvalidDialog(false);

                    {
                        Application.RunOnMainThread(() =>
                        {
                            Action<bool> action = (obj) =>
                            {
                                UpdateNomallyOpenStatus();
                            };
                            DoorLockCommonInfo.NomallyOpenModeInvalidDialog(doorLock, DoorLockCommonInfo.DoorLockMessType.AppOperate, haveLogicNormallyOpenMode, action);
                        });
                    }
                    else
                    {
@@ -875,7 +893,14 @@
                {
                    if (doorLock.IsDoorLockNormallyMode)
                    {
                        NomallyOpenModeInvalidDialog();
                        Application.RunOnMainThread(() =>
                        {
                            Action<bool> action = (obj) =>
                            {
                                UpdateNomallyOpenStatus();
                            };
                            DoorLockCommonInfo.NomallyOpenModeInvalidDialog(doorLock, DoorLockCommonInfo.DoorLockMessType.AppOperate, haveLogicNormallyOpenMode, action);
                        });
                    }
                }
                else
@@ -943,7 +968,7 @@
        }
        #endregion

        #region 音量
        #region 音量 
        /// <summary>
        /// 更新音量
        /// </summary>
@@ -1018,7 +1043,7 @@
        }
        #endregion

        #region 常开模式
        #region 常开模式  
        /// <summary>
        /// 常开模式处理
        /// </summary>
@@ -1040,84 +1065,32 @@
            action = () =>
            {
                //系统密码支持操作门锁后，调用温居城的界面【常开自动化】
                var functionSetting = new Shared.Phone.UserCenter.DoorLock.FunctionSetting(currentRoom, doorLock);
                Shared.Phone.UserView.HomePage.Instance.AddChidren(functionSetting);
                Shared.Phone.UserView.HomePage.Instance.PageIndex += 1;
                functionSetting.Show();
                // functionSetting.aaaAction = () =>
                //{
                //    UpdateNomallyOpenStatus();
                //};
                if (doorLock == null)

                {

                    ///防止抛异常
                    return;

                }

                ///备注：WJC的

                Shared.Phone.Device.Logic.Send.CurrentDoorLock = doorLock;

                ///进来刷新一次设备列表；

                Common.Logic.LogicDviceList.Clear();

                if (Common.Logic.LogicDviceList.Count == 0)

                {

                    Common.Logic.LogicDviceList.AddRange(LocalDevice.Current.listAllDevice.ToArray());

                }

                var addLogicPage = new Shared.Phone.Device.Logic.SoneLogicList();

                UserView.HomePage.Instance.AddChidren(addLogicPage);

                UserView.HomePage.Instance.PageIndex += 1;

                addLogicPage.Show();

                addLogicPage.action += (w) =>

                {

                    doorLock.IsDoorLockNormallyMode = w;

                    ///留给徐梅用的

                    UpdateNomallyOpenStatus();

                };
            };
            HdlCheckLogic.Current.CheckSecondarySecurity(action);
            #endregion

            #region 暂时版本 (最终去掉）
            if (!btnNormallyOpen.IsSelected)
            {
                if (UserCenterResourse.UserInfo.AuthorityNo != 1)
                {
                    this.ShowMassage(ShowMsgType.Tip, Language.StringByID(R.MyInternationalizationString.OnlyMasterOperate));
                    return;
                }

                if (!UserCenterResourse.AccountOption.DoorUnLockByRemote)
                {
                    SystemSecondAuthentication();
                    return;
                }

                action = () =>
                {
                    string msg = Language.StringByID(R.MyInternationalizationString.SetDoorLockNomallyOpen).Replace("{0}", "\r\n");
                    var confirm = Language.StringByID(R.MyInternationalizationString.Confrim);
                    var alert = new ShowDoorLockMsgControl(ShowDoorLockMsgControl.DoorLockMsgType.Confirm, msg, confirm);
                    alert.Show();

                    alert.ConfirmClickEvent += async () =>
                    {
                        Application.RunOnMainThread(() => { CommonPage.Loading.Start(""); });
                        var result = await doorLock.SetNormallyOpenModeFuncAsync(true);
                        if (result == null || result.defaultControlResponseData == null)
                        {
                            string msg0 = Language.StringByID(R.MyInternationalizationString.GwResponseOvertime);
                            this.ShowTipMsg(msg0);
                            return;
                        }
                        if (result.defaultControlResponseData.status != 0)
                        {
                            string msg1 = Language.StringByID(R.MyInternationalizationString.OpenNormallyOpenModeFailed);
                            this.ShowTipMsg(msg1);
                            return;
                        }
                        else
                        {
                            //添加App开启常开模式的历史记录
                            HdlDeviceDoorLockLogic.Current.AddDoorHistoryLog(this.doorLock, 9001, string.Empty);

                            //每次重新设置常开，默认时间都是12小时
                            DoorLockCommonInfo.NormallyOpenModeInvalidTime = 12;
                            DoorLockCommonInfo.NormallyOpenModeValue(doorLock, true);
                            Application.RunOnMainThread(() =>
                            {
                                UpdateNomallyOpenStatus();
                                CommonPage.Loading.Hide();
                            });

                            //常开模式开启提示
                            AlreadyOpenNormallyMode();
                        }
                    };

                };
                HdlCheckLogic.Current.CheckSecondarySecurity(action);
            }
            else
            {
                NomallyOpenModeInvalidDialog();
            }

            #endregion
            #endregion 
        }

        /// <summary>
@@ -1125,6 +1098,11 @@
        /// </summary>
        public void NomallyOpenModeInvalidDialog(bool IsFromReport = false)
        {
            if (!canShowDialog)
            {
                return;
            }

            if (UserCenterResourse.UserInfo.AuthorityNo != 1)
            {
                this.ShowMassage(ShowMsgType.Tip, Language.StringByID(R.MyInternationalizationString.OnlyMasterOperate));
@@ -1133,7 +1111,7 @@
            string msg = Language.StringByID(R.MyInternationalizationString.NomallyModeIsCanceled).Replace("{0}", "\r\n");
            var confirm = Language.StringByID(R.MyInternationalizationString.SureCancel);
            var alert = new ShowDoorLockMsgControl(ShowDoorLockMsgControl.DoorLockMsgType.NomallyOpenMode, msg, confirm);
            if (HaveLogicNormallyOpenMode)
            if (haveLogicNormallyOpenMode)
            {
                //有逻辑设置的弹窗
                alert = new ShowDoorLockMsgControl(ShowDoorLockMsgControl.DoorLockMsgType.CancelNomallyOpenModeWithLogic, msg, confirm);
@@ -1144,14 +1122,14 @@
            {
                if (IsFromReport)
                {
                    //上报“常开模式”已被取消，app默认了“常开模式”被取消
                    //上报“常开模式”已被取消，app默认了“常开模式”被取消 
                    DoorLockCommonInfo.NormallyOpenModeValue(doorLock, false);
                    Application.RunOnMainThread(() =>
                    {
                        UpdateNomallyOpenStatus();
                    });
                    //删除已经失效的“常开模式”的逻辑
                    if (HaveLogicNormallyOpenMode)
                    if (haveLogicNormallyOpenMode)
                    {
                        var resTemp = await Shared.Phone.Device.Logic.SkipView.Exist(3);
                        //if (resTemp == 3)
@@ -1163,7 +1141,7 @@
                }
                else
                {
                    //app默认“常开模式”还是开启
                    //app默认“常开模式”还是开启 
                    DoorLockCommonInfo.NormallyOpenModeValue(doorLock, true);
                    Application.RunOnMainThread(() =>
                    {
@@ -1179,7 +1157,7 @@
                    //上报“常开模式”已被取消
                    Application.RunOnMainThread(() => { CommonPage.Loading.Start(""); });
                    //先删除已失效的“常开模式”的逻辑
                    if (HaveLogicNormallyOpenMode)
                    if (haveLogicNormallyOpenMode)
                    {
                        var resTemp = await Shared.Phone.Device.Logic.SkipView.Exist(3);
                        //if (resTemp == 3)
@@ -1215,14 +1193,14 @@
                    }
                    else
                    {
                        //保持“常开成功”
                        //保持“常开成功” 
                        DoorLockCommonInfo.NormallyOpenModeValue(doorLock, true);
                        Application.RunOnMainThread(() =>
                        {
                            UpdateNomallyOpenStatus();
                        });

                        //创建常开模式的特殊逻辑
                        //创建常开模式的特殊逻辑 
                        var resu = await Shared.Phone.Device.Logic.SkipView.LockAddModifyLogic(DoorLockCommonInfo.NormallyOpenModeInvalidTime, doorLock);
                        //if (!resu)
                        //{
@@ -1235,7 +1213,7 @@
                }
                else
                {
                    //app操作不取消“常开模式”
                    //app操作不取消“常开模式” 
                    DoorLockCommonInfo.NormallyOpenModeValue(doorLock, true);
                    Application.RunOnMainThread(() =>
                    {
@@ -1248,7 +1226,7 @@
            {
                if (IsFromReport)
                {
                    //上报门锁“常开模式”已经取消，现在app确认“常开模式”取消
                    //上报门锁“常开模式”已经取消，现在app确认“常开模式”取消 
                    DoorLockCommonInfo.NormallyOpenModeValue(doorLock, false);
                    Application.RunOnMainThread(() =>
                    {
@@ -1256,7 +1234,7 @@
                    });

                    //删除已经失效的“常开模式”的逻辑
                    if (HaveLogicNormallyOpenMode)
                    if (haveLogicNormallyOpenMode)
                    {
                        var resTemp = await Shared.Phone.Device.Logic.SkipView.Exist(3);
                        //if (resTemp == 3)
@@ -1288,14 +1266,14 @@
                        //添加App开启常开模式的历史记录

                        HdlDeviceDoorLockLogic.Current.AddDoorHistoryLog(this.doorLock, 9002, string.Empty);

                        //app确认取消“常开模式”成功
                        //app确认取消“常开模式”成功 
                        DoorLockCommonInfo.NormallyOpenModeValue(doorLock, false);
                        Application.RunOnMainThread(() =>
                        {
                            UpdateNomallyOpenStatus();
                        });
                        //删除设置常开模式创建的逻辑
                        if (HaveLogicNormallyOpenMode)
                        if (haveLogicNormallyOpenMode)
                        {
                            var resTemp = await Shared.Phone.Device.Logic.SkipView.Exist(3);
                            //因为目前机制问题，逻辑经常失败，所以不提示，后期机制要改，重新做一个这个界面
@@ -1329,7 +1307,7 @@
            alertNomallyModeIsTurnOn.Show();
            alertNomallyModeIsTurnOn.MsgControlClickEvent += async () =>
            {
                //默认创建常开模式的特殊逻辑
                //默认创建常开模式的特殊逻辑 
                var res = await Shared.Phone.Device.Logic.SkipView.LockAddModifyLogic(DoorLockCommonInfo.NormallyOpenModeInvalidTime, doorLock);
                //if (!res)
                //{
@@ -1357,7 +1335,7 @@
        /// </summary>
        private void NomallyOpenModeInvalidTimeDialog()
        {
            //失效设置
            //失效设置 
            string msgTimeInValidSetting = Language.StringByID(R.MyInternationalizationString.DoorLockOpenAllTheTime);
            var timeConfrim = Language.StringByID(R.MyInternationalizationString.Confrim);
            var alertTimeInValidSetting = new ShowDoorLockMsgControl(ShowDoorLockMsgControl.DoorLockMsgType.InValid, msgTimeInValidSetting, timeConfrim);
@@ -1368,7 +1346,7 @@
                 //常开模式失效时间设置成功
                 var temp = int.Parse(obj);
                 DoorLockCommonInfo.NormallyOpenModeInvalidTime = temp;
                 //默认创建常开模式的特殊逻辑
                 //默认创建常开模式的特殊逻辑 
                 var res = await Shared.Phone.Device.Logic.SkipView.LockAddModifyLogic(DoorLockCommonInfo.NormallyOpenModeInvalidTime, doorLock);
                 if (!res)
                 {
@@ -1410,7 +1388,7 @@
        }
        #endregion

        #region 开锁处理
        #region 开锁处理 
        /// <summary>
        /// 开锁处理
        /// </summary>

 ZigbeeApp/Shared/Phone/UserCenter/UserMain/UserMainForm.cs

@@ -59,8 +59,7 @@


            //body占完整个屏幕,除了底部菜单

            bodyFrameLayout.Y = 0;

            bodyFrameLayout.Height = ControlCommonResourse.TopMenuFrameHeight + ControlCommonResourse.TopFrameHeight

                + ControlCommonResourse.BodyFrameHeight - ControlCommonResourse.BottomFrameHeight;

            bodyFrameLayout.Height = this.Height;

            bodyFrameLayout.BackgroundColor = UserCenterColor.Current.BlackBackGround;



            //初始化中部控件


 ZigbeeApp/Shared/Phone/ZigBee/Device/CommonDevice.cs

old mode 100755
new mode 100644
@@ -182,6 +182,10 @@
            {
                return Newtonsoft.Json.JsonConvert.DeserializeObject<FreshAir>(strDeviceByte);
            }
            else if (strDeviceType == ZigBee.Device.DeviceType.PMSensor.ToString())
            {
                return Newtonsoft.Json.JsonConvert.DeserializeObject<PMSensor>(strDeviceByte);
            }
            return null;
        }

@@ -248,6 +252,11 @@
                    //新风 
                    IconPath = "Device/FreshAirEpoint.png";
                }
                else if (this.Type == DeviceType.FreshAir)
                {
                    //PM2.5空气质量传感器 
                    IconPath = "Device/FreshAirEpoint.png";
                }
                else if (this.Type == DeviceType.FreshAirHumiditySensor)
                {
                    //湿度传感器

 ZigbeeApp/Shared/Phone/ZigBee/Device/DeviceType.cs

old mode 100755
new mode 100644
@@ -94,6 +94,12 @@
        /// <para>定义对象：TemperatureSensor</para>

        /// </summary>
        TemperatureSensor = 770,
        /// <summary>

        /// <para>PM2.5传感器</para>

        /// <para>设备ID为777</para>

        /// <para>定义对象：PMSensor</para>

        /// </summary>
        PMSensor = 777,
    }



    /// <summary>


 ZigbeeApp/Shared/Phone/ZigBee/Device/DoorLock.cs

old mode 100644
new mode 100755

 ZigbeeApp/Shared/Phone/ZigBee/Device/FreshAir.cs

old mode 100644
new mode 100755

 ZigbeeApp/Shared/Phone/ZigBee/Device/PMSensor.cs

New file
@@ -0,0 +1,16 @@
using System;
using ZigBee.Device;

namespace ZigBee.Device
{
    public class PMSensor : CommonDevice
    {
        /// <summary>
        /// PM2.5传感器对象
        /// </summary>
        public PMSensor()
        {
            this.Type = DeviceType.PMSensor;
        }
    }
}

 ZigbeeApp/Shared/Phone/ZigBee/Device/Panel.cs

old mode 100644
new mode 100755

 ZigbeeApp/Shared/Phone/ZigBee/Device/ZbGateway.cs

old mode 100644
new mode 100755
@@ -101,7 +101,7 @@
            }
        }

        #region variable
        #region variable 
        /// <summary>
        /// 远程连接成功时的时间
        /// </summary>
@@ -2857,8 +2857,8 @@
        /// <summary>
        /// 远程MqttClient
        /// </summary>
        public static IMqttClient RemoteMqttClient = new MqttFactory().CreateMqttClient();
        static bool remoteIsConnected;
        public static IMqttClient RemoteMqttClient= new MqttFactory().CreateMqttClient();
        static bool remoteIsConnected; 
        private int IsLogin = 0;
        [Newtonsoft.Json.JsonIgnore]
        static Action actionTemp;
@@ -3051,8 +3051,8 @@
           .WithTcpServer(domain, int.Parse(port))

           .WithCredentials(connEmqUserName, connEmqPwd)

           .WithKeepAlivePeriod(TimeSpan.FromSeconds(20))

           .WithCleanSession()
           //.WithCommunicationTimeout(TimeSpan.FromSeconds(10))
           .WithCleanSession()

           //.WithCommunicationTimeout(TimeSpan.FromSeconds(10))

           .Build();

                                await DisConnectRemoteMqttClient("StartRemoteMqtt");

                                await RemoteMqttClient.ConnectAsync(options, CancellationToken.None);

@@ -3087,7 +3087,7 @@
                    localIsConnected = false;

                    DebugPrintLog($"Local主动断开_{s}");

                    //await localMqttClient.DisconnectAsync(new MQTTnet.Client.Disconnecting.MqttClientDisconnectOptions {  }, CancellationToken.None);

                    await localMqttClient.DisconnectAsync();
                    await localMqttClient.DisconnectAsync(); 
                }

            }
            catch (Exception ex)
@@ -3099,7 +3099,7 @@
        /// <summary>

        /// 断开远程Mqtt的链接

        /// </summary>
        public static async System.Threading.Tasks.Task DisConnectRemoteMqttClient(string s = "")

        public static async System.Threading.Tasks.Task DisConnectRemoteMqttClient(string s="")

        {

            try

            {

@@ -3218,7 +3218,7 @@
                        {

                            await localMqttClient.PublishAsync(new MqttApplicationMessage { Topic = topic, Payload = message, QualityOfServiceLevel = MQTTnet.Protocol.MqttQualityOfServiceLevel.ExactlyOnce, Retain = retain });

                        }

                        catch (Exception e)

                        catch(Exception e)

                        {
                            DebugPrintLog($"Local主动断开_{e.Message}");

                            await DisConnectLocalMqttClient(e.Message);
@@ -3424,7 +3424,7 @@
        /// <param name="topic">Topic.</param>
        /// <param name="message">Message.</param>
        /// <param name="e">E.</param>
        static void ReceiveMessage(string topic, string message, byte[] payload)
        static void ReceiveMessage(string topic, string message, byte []payload)
        {
            try
            {

 ZigbeeApp/Shared/R.cs

@@ -330,7 +330,7 @@
        /// </summary>
        public const int GetPanelProximityFail = 233;
        /// <summary>
        /// 按住面板模式
        /// 按住面板模式按键5秒，绿色指示灯闪烁{0}进入配网状态；闪烁停止{0}指示灯变白色表示配网成功
        /// </summary>
        public const int AddFreshAirPanelMsg = 235;
        /// <summary>
@@ -350,7 +350,7 @@
        /// </summary>
        public const int AddFreshAirModulPanelMsg = 239;
        /// <summary>
        /// 设置常开模式后，您的门锁将始终{0}处于打开状态，确认开启？
        /// 设置常开模式后，您的门锁将始终{0}处于打开状态，确认开启？ 
        /// </summary>
        public const int SetDoorLockNomallyOpen = 241;
        /// <summary>
@@ -566,6 +566,10 @@
        /// PM2.5感器 -> 长按图示按键5秒以上，信号图标{0}快闪， 进入配网状态。信号图标常亮则配网成功
        /// </summary>
        public const int AddSensorPMMsg = 313;
        /// <summary>
        /// 自动模式不支持操作
        /// </summary>
        public const int AutoModeForbiddenOperate = 314;

        public readonly static int cancel = 5097;
        public readonly static int confrim = 5098;
@@ -829,7 +833,7 @@
        public readonly static int daySone = 5386;
        public readonly static int numberSone = 5387;
        public readonly static int openAutomationSone = 5388;
        public readonly static int timeSetSone= 5389;
        public readonly static int timeSetSone = 5389;
        public readonly static int invalidSetting = 5390;
        public readonly static int hour = 5391;
        public readonly static int lockOpen = 5392;
@@ -1152,90 +1156,90 @@
        /// 功能设置
        /// </summary>
        public const int FunctionSetting = 11012;
        /// <summary>
        /// 信息编辑
        /// </summary>
        public const int EditInfo = 11013;
        /// <summary>
        /// 功能名称
        /// </summary>
        public const int FunctionName = 11014;
        /// <summary>
        /// 所属区域
        /// </summary>
        public const int BelongZone = 11015;
        /// <summary>
        /// 所属设备
        /// </summary>
        public const int BelongDevice = 11016;
        /// <summary>
        /// 未知
        /// </summary>
        public const int UNKnown = 11017;
        /// <summary>
        /// 分享
        /// </summary>
        public const int Share = 11018;
        /// <summary>
        /// 分享的
        /// </summary>
        public const int Shared = 11019;
        /// <summary>
        /// 选择图标
        /// </summary>
        public const int SelectIcon = 11020;
        /// <summary>
        /// 保存
        /// </summary>
        public const int Save = 11021;
        /// <summary>
        /// 提醒
        /// </summary>
        public const int TIP = 11022;
        /// <summary>
        /// 取消
        /// </summary>
        public const int Cancel = 11023;
        /// <summary>
        /// 没有场景 {\r\n} 请点击右上角添加
        /// </summary>
        public const int NoScene = 11024;
        /// <summary>
        /// 设置
        /// </summary>
        public const int Setting = 11025;
        /// <summary>
        /// 延时
        /// </summary>
        public const int Delay = 11026;
        /// <summary>
        /// 确定删除吗？
        /// </summary>
        public const int ConfirmDelete = 11027;
        /// <summary>
        /// 添加场景
        /// </summary>
        public const int AddScence = 11028;
        /// <summary>
        /// 场景名称
        /// </summary>
        public const int SceneName = 11029;
        /// <summary>
        /// 请输入场景名称
        /// </summary>
        public const int PleaseInputSceneName = 11030;
        /// <summary>
        /// 添加执行目标
        /// </summary>
        public const int AddScentTargetAction = 11031;
        /// <summary>
        /// 选择区域
        /// </summary>
        public const int SelectZone = 11032;
        /// <summary>
        /// 选择场景图片
        /// </summary>
        public const int SelectScenePic = 11033;
        /// <summary>
        /// 信息编辑
        /// </summary>
        public const int EditInfo = 11013;
        /// <summary>
        /// 功能名称
        /// </summary>
        public const int FunctionName = 11014;
        /// <summary>
        /// 所属区域
        /// </summary>
        public const int BelongZone = 11015;
        /// <summary>
        /// 所属设备
        /// </summary>
        public const int BelongDevice = 11016;
        /// <summary>
        /// 未知
        /// </summary>
        public const int UNKnown = 11017;
        /// <summary>
        /// 分享
        /// </summary>
        public const int Share = 11018;
        /// <summary>
        /// 分享的
        /// </summary>
        public const int Shared = 11019;
        /// <summary>
        /// 选择图标
        /// </summary>
        public const int SelectIcon = 11020;
        /// <summary>
        /// 保存
        /// </summary>
        public const int Save = 11021;
        /// <summary>
        /// 提醒
        /// </summary>
        public const int TIP = 11022;
        /// <summary>
        /// 取消
        /// </summary>
        public const int Cancel = 11023;
        /// <summary>
        /// 没有场景 {\r\n} 请点击右上角添加
        /// </summary>
        public const int NoScene = 11024;
        /// <summary>
        /// 设置
        /// </summary>
        public const int Setting = 11025;
        /// <summary>
        /// 延时
        /// </summary>
        public const int Delay = 11026;
        /// <summary>
        /// 确定删除吗？
        /// </summary>
        public const int ConfirmDelete = 11027;
        /// <summary>
        /// 添加场景
        /// </summary>
        public const int AddScence = 11028;
        /// <summary>
        /// 场景名称
        /// </summary>
        public const int SceneName = 11029;
        /// <summary>
        /// 请输入场景名称
        /// </summary>
        public const int PleaseInputSceneName = 11030;
        /// <summary>
        /// 添加执行目标
        /// </summary>
        public const int AddScentTargetAction = 11031;
        /// <summary>
        /// 选择区域
        /// </summary>
        public const int SelectZone = 11032;
        /// <summary>
        /// 选择场景图片
        /// </summary>
        public const int SelectScenePic = 11033;
        /// <summary>
        /// 确定要移除该功能？
        /// </summary>
@@ -5962,15 +5966,15 @@
        /// </summary>

        public const int uAddSensorTemperatureAndHumidityMsg = 21017;

        /// <summary>

        /// 方悦2按键轻触式面板 -> 按住面板左上角按键，所有按键指示灯{0}亮起，则配网成功

        /// 单开双控面板 -> 长按BUTTON1按键5秒，所有指示灯{0}变为绿色并闪烁，进入配网状态

        /// </summary>

        public const int uAddFangyueTwoButtonPanelMsg = 21018;

        /// <summary>

        /// 方悦4按键轻触式面板 -> 按住面板左上角按键，所有按键指示灯{0}亮起，则配网成功

        /// 双开四控面板 -> 长按BUTTON1按键5秒，所有指示灯{0}变为绿色并闪烁，进入配网状态

        /// </summary>

        public const int uAddFangyueFourButtonPanelMsg = 21019;

        /// <summary>

        /// 方悦8按键轻触式面板 -> 按住面板左上角按键，所有按键指示灯{0}亮起，则配网成功

        /// 四开八控面板-> 长按BUTTON1按键5秒，所有指示灯{0}变为绿色并闪烁，进入配网状态

        /// </summary>

        public const int uAddFangyueEightButtonPanelMsg = 21020;

        /// <summary>

@@ -5978,7 +5982,7 @@
        /// </summary>

        public const int uAddFangyueEnvironmentPanelMsg = 21021;

        /// <summary>

        /// 窗帘面板 -> 长按面板左上角按键，所有按键{0}指示灯亮起，则配网成功

        /// 窗帘面板 -> 长按面板左上角按键，所有按键{0}指示灯亮起，则配网成功 
        /// </summary>

        public const int uAddCurtaunPanelMsg = 21022;

        /// <summary>

@@ -6147,7 +6151,11 @@
        /// <summary>
        /// 镜像ID为1306的设备的默认名字：Zigbee吸顶燃气传感器
        /// </summary>
        public const int uDeviceModelId1306 = 30039;

        public const int uDeviceModelId1306 = 30039;
        /// <summary>
        /// 镜像ID为1307的设备的默认名字：PM2.5空气质量传感器
        /// </summary>
        public const int uDeviceModelId1307 = 30040;



        //★★★★下面这些是设备所属种类的翻译名字,从40000开始★★★★

        /// <summary>


 ZigbeeApp/Shared/Shared.projitems

@@ -209,6 +209,7 @@
    <Compile Include="$(MSBuildThisFileDirectory)Phone\UserCenter\Device\PirSensor\PirSensorWorkModeMenuForm.cs" />

    <Compile Include="$(MSBuildThisFileDirectory)Phone\UserCenter\DoorLock\AddUnLockMethod.cs" />

    <Compile Include="$(MSBuildThisFileDirectory)Phone\UserCenter\DoorLock\AddUnLockMethodTip.cs" />

    <Compile Include="$(MSBuildThisFileDirectory)Phone\UserCenter\DoorLock\DoorLockCommonInfo.cs" />

    <Compile Include="$(MSBuildThisFileDirectory)Phone\UserCenter\DoorLock\DoorLockCommonLayout.cs" />

    <Compile Include="$(MSBuildThisFileDirectory)Phone\UserCenter\DoorLock\DoorlockDialog.cs" />

    <Compile Include="$(MSBuildThisFileDirectory)Phone\UserCenter\DoorLock\EntryStatusPage.cs" />

@@ -220,6 +221,7 @@
    <Compile Include="$(MSBuildThisFileDirectory)Phone\UserCenter\DoorLock\TimeSettignPage.cs" />

    <Compile Include="$(MSBuildThisFileDirectory)Phone\UserCenter\DoorLock\UndistributeDoorlockUserPage.cs" />

    <Compile Include="$(MSBuildThisFileDirectory)Phone\UserCenter\DoorLock\UnLockMethod.cs" />

    <Compile Include="$(MSBuildThisFileDirectory)Phone\UserCenter\DoorLock\UserDoorLockPage.cs" />

    <Compile Include="$(MSBuildThisFileDirectory)Phone\UserCenter\DoorLock\UserManagement.cs" />

    <Compile Include="$(MSBuildThisFileDirectory)Phone\UserCenter\Gateway\Add\AddGatewayHelpForm.cs" />

    <Compile Include="$(MSBuildThisFileDirectory)Phone\UserCenter\Gateway\Add\WirelessApDirection1Form.cs" />

@@ -475,13 +477,7 @@
    <Compile Include="$(MSBuildThisFileDirectory)Phone\ZigBee\IO\LocalFileUtils.cs" />

    <Compile Include="$(MSBuildThisFileDirectory)Phone\UserCenter\CommonBase\Logic\HdlSafeguardLogic.cs" />

    <Compile Include="$(MSBuildThisFileDirectory)Phone\UserCenter\CommonBase\Logic\HdlAlarmsLogic.cs" />

    <Compile Include="$(MSBuildThisFileDirectory)Phone\UserCenter\Device\Panel\PanelFangyueFreshAirBackLightSettionForm.cs" />

    <Compile Include="$(MSBuildThisFileDirectory)Phone\UserCenter\DoorLock\UserDoorLockPage.cs" />

    <Compile Include="$(MSBuildThisFileDirectory)Phone\UserCenter\DoorLock\DoorLockCommonInfo.cs" />

    <Compile Include="$(MSBuildThisFileDirectory)Phone\UserCenter\DoorLock\ShowDoorLockMsgControl.cs" />

    <Compile Include="$(MSBuildThisFileDirectory)Phone\ZigBee\Device\DoorLock.cs" />

    <Compile Include="$(MSBuildThisFileDirectory)Phone\MainPage\Controls\DeviceCard\DeviceFreshAirCardControl.cs" />

    <Compile Include="$(MSBuildThisFileDirectory)Phone\UserCenter\Device\Direction\SensorPMTwoPointFiveForm.cs" />

    <Compile Include="$(MSBuildThisFileDirectory)Phone\ZigBee\Device\PMSensor.cs" />

  </ItemGroup>

  <ItemGroup>

    <Folder Include="$(MSBuildThisFileDirectory)Phone\CommonForm\" />

@@ -516,4 +512,4 @@
    <None Include="$(MSBuildThisFileDirectory)DLL\ZigBee.Droid.dll" />

    <None Include="$(MSBuildThisFileDirectory)DLL\ZigBee.Ios.xml" />

  </ItemGroup>

</Project>

</Project>