2021-11-30 1.修复乐橙Android，没调用拒接接口问题。

JLChen

2021-11-30 efad979b6fae76fb37a4de7e94e6bac0a85cb72c

 HDL_ON/Common/ImageUtlis.cs

@@ -1,11 +1,8 @@
using System;
using Shared;
using HDL_ON;
using HDL_ON.UI.CSS;
using HDL_ON.DAL.Server;
using HDL_ON.UI;
using System.Threading;
using HDL_ON.Entity;
using System.IO;
using HDL_ON.Common;

namespace HDL_ON
{
@@ -41,6 +38,107 @@
        }
        #endregion


        #region 文件读写
        /// <summary>
        /// 根目录
        /// </summary>
        string RootPath = Environment.GetFolderPath(System.Environment.SpecialFolder.Personal) + "/";
        /// <summary>
        /// 文件是否存在
        /// </summary>
        /// <param name="filePath">File path.</param>
        public bool Exists(string filePath)
        {
            return File.Exists(Path.Combine(RootPath, filePath));
        }

        /// <summary>
        /// Writes the file by bytes.
        /// </summary>
        /// <returns><c>true</c>, if file by bytes was writed, <c>false</c> otherwise.</returns>
        /// <param name="fileName">File name.</param>
        /// <param name="bytes">Bytes.</param>
        public bool WriteFileByBytes(string fileName, byte[] bytes)
        {
            if (fileName == null || (fileName = fileName.Trim()) == (""))
            {
                return false;
            }

            FileStream fs = null;

            try
            {
                fs = new FileStream(Path.Combine(RootPath, fileName), FileMode.Create, FileAccess.Write);
                fs.Write(bytes, 0, bytes.Length);
                fs.Flush();
                MainPage.Log("SaveFile:" + fileName);
                return true;
            }
            catch (Exception ex)
            {
                MainPage.Log("FileUtiles Code 113:" + ex.ToString());
                return false;
            }
            finally
            {
                try
                {
                    if (fs != null)
                    {
                        fs.Close();
                    }
                }
                catch (Exception ex)
                {
                    MainPage.Log("FileUtils Code 121 :" + ex.ToString());
                }
            }
        }
        public byte[] ReadFile(string fileName)
        {
            FileStream fs = null;
            try
            {
                if (File.Exists(Path.Combine(RootPath, fileName)))
                {
                    fs = new FileStream(Path.Combine(RootPath, fileName), FileMode.Open, FileAccess.Read);
                }
                else if (File.Exists(fileName))
                {
                    fs = new FileStream(fileName, FileMode.Open, FileAccess.Read);
                }
                else
                {
                    return new byte[0];
                }
                byte[] bytes = new byte[fs.Length];
                fs.Read(bytes, 0, bytes.Length);
                return bytes;
            }
            catch
            {
                return new byte[0];
            }
            finally
            {
                try
                {
                    if (fs != null)
                    {
                        fs.Close();
                    }
                }
                catch
                {

                }
            }
        }

        #endregion

        #region 房间、场景 图片上传和下载
        /// <summary>
        /// 上传图片
@@ -65,6 +163,7 @@

        /// <summary>
        /// 通过图片路径下载图片
        /// 针对住宅，使用住宅域名服务器
        /// </summary>
        public byte[] GetImageDownloadUrl(string imageKey)
        {
@@ -73,6 +172,31 @@
                imageKey = imageKey,
            });
            var revertObj = HttpUtil.RequestHttpsPostFroHome(NewAPI.API_POST_GetImageUrl, requestJson);
            if (revertObj.Code == StateCode.SUCCESS)
            {
                if (revertObj.Data != null)
                {
                    if (!string.IsNullOrEmpty(revertObj.Data.ToString()))
                    {
                        var url = revertObj.Data.ToString();
                        return HttpUtil.HttpsDownload(url);
                    }
                }
            }
            return null;
        }

        /// <summary>
        /// 通过图片路径下载图片
        /// 针对用户头像指定用户路径等
        /// </summary>
        public byte[] GetImageDownloadUrlWithRegionUrl(string imageKey, string regionUrl)
        {
            var requestJson = HttpUtil.GetSignRequestJson(new GetImageUrlObj()
            {
                imageKey = imageKey,
            });
            var revertObj = HttpUtil.RequestHttpsPost(NewAPI.API_POST_GetImageUrl, requestJson, regionUrl);
            if (revertObj.Code == StateCode.SUCCESS)
            {
                if (revertObj.Data != null)
@@ -106,19 +230,19 @@
                    {
                        imageView.ImageBytes = null;
                        imageView.ImagePath = imageKey;
                        Utlis.WriteLine("imageKey 加载本地图片成功");
                        //Utlis.WriteLine("imageKey 加载本地图片成功");
                    }
                }
                else
                {
                    //2.自定义图片，检测是否本地缓存过，没有则云端下载然后缓存
                    if (!ignoreCache && FileUtils.Exists(imageKey))
                    if (!ignoreCache && Exists(imageKey))
                    {
                        //2.1 本地有缓存并且不忽略缓存，直接本地读取
                        if (imageView != null)
                        {
                            imageView.ImageBytes = FileUtils.ReadFile(imageKey);
                            Utlis.WriteLine("imageKey 加载自定义缓存图片成功");
                            imageView.ImageBytes = ReadFile(imageKey);
                            //Utlis.WriteLine("imageKey 加载自定义缓存图片成功");
                        }
                    }
                    else
@@ -129,21 +253,21 @@
                            byte[] imageBytes = GetImageDownloadUrl(imageKey);
                            if (imageBytes != null)
                            {
                                FileUtils.WriteFileByBytes(imageKey, imageBytes);
                                WriteFileByBytes(imageKey, imageBytes);
                                //2.3 下载成功，显示并缓存本地
                                Application.RunOnMainThread(() =>
                                {
                                    if (imageView != null)
                                    {
                                        imageView.ImageBytes = imageBytes;
                                        Utlis.WriteLine("imageKey 加载云端下载图片成功");
                                        //Utlis.WriteLine("imageKey 加载云端下载图片成功");
                                    }
                                });
                            }
                            else
                            {
                                //2.4 下载是否，是否使用默认图片
                                Utlis.WriteLine("imageKey 加载云端图片失败");
                                //Utlis.WriteLine("imageKey 加载云端图片失败");
                            }
                        });
                    }
@@ -177,19 +301,19 @@
                    {
                        //imageView.ImageBytes = null;
                        frameLayout.BackgroundImagePath = imageKey;
                        Utlis.WriteLine("imageKey 加载本地图片成功");
                        //Utlis.WriteLine("imageKey 加载本地图片成功");
                    }
                }
                else
                {
                    //2.自定义图片，检测是否本地缓存过，没有则云端下载然后缓存
                    if (!ignoreCache && FileUtils.Exists(imageKey))
                    if (!ignoreCache && Exists(imageKey))
                    {
                        //2.1 本地有缓存并且不忽略缓存，直接本地读取
                        if (frameLayout != null)
                        {
                            frameLayout.BackgroundImagePath = imageKey;
                            Utlis.WriteLine("imageKey 加载自定义缓存图片成功");
                            //Utlis.WriteLine("imageKey 加载自定义缓存图片成功");
                        }
                    }
                    else
@@ -200,21 +324,21 @@
                            byte[] imageBytes = GetImageDownloadUrl(imageKey);
                            if (imageBytes != null)
                            {
                                FileUtils.WriteFileByBytes(imageKey, imageBytes);
                                WriteFileByBytes(imageKey, imageBytes);
                                //2.3 下载成功，显示并缓存本地
                                Application.RunOnMainThread(() =>
                                {
                                    if (frameLayout != null)
                                    {
                                        frameLayout.BackgroundImagePath = imageKey;
                                        Utlis.WriteLine("imageKey 加载云端下载图片成功");
                                        //Utlis.WriteLine("imageKey 加载云端下载图片成功");
                                    }
                                });
                            }
                            else
                            {
                                //2.4 下载是否，是否使用默认图片
                                Utlis.WriteLine("imageKey 加载云端图片失败");
                                //Utlis.WriteLine("imageKey 加载云端图片失败");
                            }
                        });
                    }
@@ -229,54 +353,108 @@
            }
        }

        /// <summary>
      /// 获取拼接用户头像的ImageKey规则
      /// </summary>
      /// <returns></returns>
      public string GetHeadImageKey(string userId)
        {
            return "ON" + "_" + userId + "_" + HEADIMAGE;
        }


        /// <summary>
        /// 生成头像上传规则参数
        /// 2021-01-28
        /// 加载第三方品牌icon
        /// </summary>
        /// <returns></returns>
        public UploadImageObj GetHeadImageUploadKeyObj(string userId)
        /// <param name="imageKey">图片路径、云端下载图片的标识key</param>
        /// <param name="imageView">需要显示图片的ImageView</param>
        /// <param name="ignoreCache">是否需要忽略缓存</param>
        public void Load3tyBrandIconImages(string brandName, string imageKey, ImageView imageView)
        {
            return new UploadImageObj()
            try
            {
                prefix = "ON",
                uid = userId,
                fileName = HEADIMAGE,
            };
                System.Threading.Tasks.Task.Run(() =>
                {
                    //byte[] imageBytes = GetImageDownloadUrl(imageKey);
                    //if (imageBytes != null)
                    //{
                    //    WriteFileByBytes(imageKey, imageBytes);
                    //    //2.3 下载成功，显示并缓存本地
                    //    Application.RunOnMainThread(() => {
                    //        if (imageView != null)
                    //        {
                    //            imageView.ImageBytes = imageBytes;
                    //            //Utlis.WriteLine("imageKey 加载云端下载图片成功");
                    //        }
                    //    });
                    //}

                    //var ddd = new Common.DownLoadImageAsync(imageKey,"1","1");
                    //ddd.StartDownloadImageAsync();

                    Action action = () => {
                        Application.RunOnMainThread(() =>
                        {
                            imageView.ImagePath = $"{brandName}.png";
                        });
                    };
                    FileUtlis.Files.DownLoadImage($"{brandName}.png", imageKey, action);

                });
            }
            catch (Exception ex)
            {
                Utlis.WriteLine("imageKey 加载图片异常 catch");
            }
            finally
            {
            }
        }


        //      /// <summary>
        ///// 获取拼接用户头像的ImageKey规则
        ///// </summary>
        ///// <returns></returns>
        //public string GetHeadImageKey(string userId)
        //      {
        //          return "ON" + "_" + userId + "_" + HEADIMAGE;
        //      }

        ///// <summary>
        ///// 生成头像上传规则参数
        ///// </summary>
        ///// <returns></returns>
        //public UploadImageObj GetHeadImageUploadKeyObj(string userId)
        //{
        //    return new UploadImageObj()
        //    {
        //        prefix = "Icon" + Utlis.GetTimestamp(),
        //        uid = userId,
        //        fileName = HEADIMAGE,
        //    };
        //}

        /// <summary>
        /// 下载用户头像
        /// </summary>
        /// <param name="userId"></param>
        /// <param name="ignoreCache">是否忽略缓存</param>
        /// <param name="imageKey"></param>
        /// <param name="ignoreCache">忽略缓存</param>
        /// <param name="regionUrl">指定服务器域名,传空为使用当前用户地址</param>
        /// <returns></returns>
        public byte[] DownHeadImage(string userId, bool ignoreCache = false)
        public byte[] DownHeadImageByImageKey(string imageKey, bool ignoreCache = false, string regionUrl = "")
        {
            try
            {
                var imageKey = GetHeadImageKey(userId);
                if (string.IsNullOrEmpty(imageKey)) return null;
                
                byte[] imageBytes;
                if (!ignoreCache && FileUtils.Exists(imageKey))
                if (!ignoreCache && Exists(imageKey))
                {
                    //本地有缓存
                    imageBytes = FileUtils.ReadFile(imageKey);
                    imageBytes = ReadFile(imageKey);
                }
                else
                {
                    //云端下载
                    imageBytes = GetImageDownloadUrl(imageKey);
                    imageBytes = GetImageDownloadUrlWithRegionUrl(imageKey, regionUrl);
                    if(imageBytes != null)
                    {
                        //保存到本地
                        FileUtils.WriteFileByBytes(imageKey, imageBytes);
                        WriteFileByBytes(imageKey, imageBytes);
                    }
                   
                }