question

38512626 avatar image
0 Votes"
38512626 asked JarvanZhang-MSFT edited

skiasharp xamarin.form memory release

I'm using skiasharp to display multiple images, but the app crashes over time.

I think it's a memory usage issue.

Is there a problem with the code below?

 public async void Pic()
 {
    
     try
     {
    
         int nY;
         int nX;
    
         MAX = 0;
         BX = 0;
         EX = 0;
         BY = 0;
         EY = 0;
         offX = 0;
         offY = 0;
         nX = 0;
         nY = 0;
         zoomOver = 0;
    
         int ZoomSub = Zoom;
    
         MAX = (int)Math.Pow(2, ZoomSub) - 1;
         BX = Math.Max(0, (CX - W / 2) / 256);
         EX = Math.Min(MAX, (CX + W / 2 + 255) / 256);
         BY = Math.Max(0, (CY - H / 2) / 256);
         EY = Math.Min(MAX, (CY + H / 2 + 255) / 256);
         offX = (CX - W / 2) % 256;
         offY = (CY - H / 2) % 256;
            
         bitmaps.Clear();
    
         Assembly assembly = GetType().GetTypeInfo().Assembly;
    
         string spath = "";
    
         HttpClient httpClient = new HttpClient();
    
         for (nY = BY; nY <= EY; nY++)
         {
             for (nX = BX; nX <= EX; nX++)
             {
                 string url = "";
                 string imgpath = "";
                    
                 SKBitmap img = SKBitmap.Decode("App.pic.noimage.png");
    
                 //img = SKBitmap.Decode("App.pic.noimage.png");
    
                 if ((System.IO.File.Exists(imgpath) == false) || (SKBitmap.Decode(imgpath) == null))
                 {
    
                     try
                     {
    
                         if (zoomOver > 0)
                         {
                             //spath = fileDL(url, MapPath + (Zoom - zoomOver) + "/" + (nX / (zoomOver * 2)) + "/");
    
                             switch (omapmode)
                             {
                                 case 1:
                                     spath = fileDL(url, MapPath + "std/" + (Zoom - zoomOver) + "/" + nX + "/");
                                     break;
                                 case 2:
                                     spath = fileDL(url, MapPath + "seamlessphoto/" + (Zoom - zoomOver) + "/" + nX + "/");
                                     break;
                                 case 3:
                                     spath = fileDL(url, MapPath + "pale/" + (Zoom - zoomOver) + "/" + nX + "/");
                                     break;
                                 default:
                                     spath = fileDL(url, MapPath + "openstreetmap/" + (Zoom - zoomOver) + "/" + nX + "/");
                                     break;
                             }
    
                         }
                         else
                         {
                             //spath = fileDL(url, MapPath + Zoom + "/" + nX + "/");
    
                             switch (omapmode)
                             {
                                 case 1:
                                     spath = fileDL(url, MapPath + "std/" + Zoom + "/" + nX + "/");
                                     break;
                                 case 2:
                                     spath = fileDL(url, MapPath + "seamlessphoto/" + Zoom + "/" + nX + "/");
                                     break;
                                 case 3:
                                     spath = fileDL(url, MapPath + "pale/" + Zoom + "/" + nX + "/");
                                     break;
                                 default:
                                     spath = fileDL(url, MapPath + "openstreetmap/" + Zoom + "/" + nX + "/");
                                     break;
                             }
                         }
    
                         using (Stream stream = await httpClient.GetStreamAsync(url))
                         using (MemoryStream memStream = new MemoryStream())
                         {
    
                             if (dictTiles.Contains(imgpath))
                             {
                                 img = (SKBitmap)dictTiles[imgpath];
                             }
                             else
                             {
                                 await stream.CopyToAsync(memStream);
                                 memStream.Seek(0, SeekOrigin.Begin);
    
                                 if (dictTiles.Count > DictSize)
                                 {
                                     dictTiles.RemoveAt(0);
                                 }
    
                                 dictTiles[imgpath] = SKBitmap.Decode(memStream);
                                 img = (SKBitmap)dictTiles[imgpath];
                             }
    
    
                         }
    
                     }
                     catch (Exception)
                     {
                     }
    
                 }
    
                 int iX = (nX) % tilecnt;
                 int iY = (nY) % tilecnt;
                 SKBitmap imgset = new SKBitmap(img.Width, img.Height);
                 SKRect dest = new SKRect(0, 0, img.Width, img.Height);
                 float x0 = iX * (img.Width / tilecnt);
                 float y0 = iY * (img.Height / tilecnt);
                 float x1 = x0 + (img.Width / tilecnt);
                 float y1 = y0 + (img.Height / tilecnt);
                 SKRect src = new SKRect(x0, y0, x1, y1);
    
                 using (SKCanvas canvas = new SKCanvas(imgset))
                 {
                     canvas.DrawBitmap(img, src, dest);
                     bitmaps.Add(imgset);
    
                 }
                    
             }
    
         }
    
    
         yy = Math.Abs(EY - BY);
         xx = Math.Abs(EX - BX);
    
         httpClient.Dispose();
     }
     catch (Exception)
     {
     }
    
 }
    
 private void OnCanvasViewPaintSurface(object sender, SKPaintSurfaceEventArgs args)
 {
     try
     {
         SKImageInfo info = args.Info;
         SKSurface surface = args.Surface;
         SKCanvas canvas = surface.Canvas;
    
         canvas.Clear();
    
         int imgsize = 256;
         int i = 0;
         for (int y = 0; y <= yy; y++)
         {
             for (int x = 0; x <= xx; x++)
             {
                 canvas.DrawBitmap(bitmaps[i], imgsize * x - offX, imgsize * y - offY, null);
    
                 i++;
             }
         }
    
         canvas.DrawCircle(x0, y0, swidth, paint);
    
         canvas.Dispose();
     }
     catch
     {
    
     }
 }
dotnet-xamarin
· 3
5 |1600 characters needed characters left characters exceeded

Up to 10 attachments (including images) can be used with a maximum of 3.0 MiB each and 30.0 MiB total.

For the problem of using skiasharp, please report the issue to the github repo: https://github.com/mono/SkiaSharp

0 Votes 0 ·

i'm really very sorry

0 Votes 0 ·

That's all right.

0 Votes 0 ·

0 Answers