How to setup the UrhoSharp engine to render on a live wallpaper on Xamarin Android platform ?

[zielony71]

Hello,

I have been strunggling for several days to setup the UrhoSharp engine as a renderer for live wallpaper in Xamarin on Android platform, but without success. Can anybody show me how to do this ? Below there is my code. But really this is only an outline of the code, probably not compileable, but mayby somebody could see what I do wrong. Thank you in advance.

`namespace Demo.Droid
 {
     [Service(Label = "@string/app_name", Permission = "android.permission.BIND_WALLPAPER")]
     [IntentFilter(new string[] { "android.service.wallpaper.WallpaperService" })]
     [MetaData("android.service.wallpaper", Resource = "@xml/cube1")]
     public class MyWallpaper : WallpaperService
     {
         public override WallpaperService.Engine OnCreateEngine()
         {
             return new MyEngine(this);
         }
    
         public class MyEngine : WallpaperService.Engine
         {
             private Handler mHandler = new Handler();
    
             MySdlSurface mSDLSurface;
    
             public WallpaperService mWallService;
             public ISurfaceHolder mMySurfaceHolder;
    
             MyGame mUrhoApp;
             public MyEngine(MetalStreamWallpaper wall) : base(wall)
             {
                 mWallService = wall;
                 // Set up the paint to draw the lines for our cube
             }
    
             public override void OnCreate(ISurfaceHolder surfaceHolder)
             {
                 base.OnCreate(surfaceHolder);
                 mMySurfaceHolder = surfaceHolder;
    
                 var appOpt = new Urho.ApplicationOptions("");
                 appOpt.LimitFps = true;
                 appOpt.ResourcePackagesPaths = new string[] { "Data.pkg" };
    
                 mSDLSurface = new MySdlSurface(mWallService.ApplicationContext, this); //   );
    
                 mSDLSurface.SurfaceCreated(surfaceHolder);
                 this.OnSurfaceCreated(surfaceHolder);
    
                 var currentSurface = typeof(Urho.Application).GetProperty(nameof(Urho.Application.CurrentSurface), BindingFlags.Public | BindingFlags.Static | BindingFlags.GetProperty);
                 currentSurface.SetValue(default, new WeakReference(mSDLSurface));
    
                 var tcs = new TaskCompletionSource<Urho.Application>();
                 void startedHandler()
                 {
                     Urho.Application.Started -= startedHandler;
                     tcs.TrySetResult(Urho.Application.Current);
                 }
    
                 Urho.Application.Started += startedHandler;
                 // UrhoSurface.SetSdlMain(() => Urho.Application.CreateInstance(appType, options), finishActivityOnExit, SDLSurface);
                 var setSdlMain = typeof(UrhoSurface).GetMethod("SetSdlMain", BindingFlags.NonPublic | BindingFlags.Static);
                 setSdlMain.Invoke(default, 
                     new object[] { new Func<Urho.Application>(() => Urho.Application.CreateInstance(typeof(MyGame), appOpt)), 
                         false /* finishActivityOnExit */,
                         mSDLSurface
                     });
    
                 tcs.Task.Wait();
                 mUrhoApp = (MyGame )tcs.Task.Result;
                 // launching = false;
    
                 Urho.Application.UnhandledException += (s1, e1) => {
                     Console.WriteLine(e1.Exception.ToString());
                     e1.Handled = true;
                 };
             }
    
             public override void OnDestroy()
             {
                 base.OnDestroy();
             }
    
             public override void OnVisibilityChanged(bool visible)
             {
                    
             }
    
             public override void OnSurfaceChanged(ISurfaceHolder holder, Format format, int width, int height)
             {
                 base.OnSurfaceChanged(holder, format, width, height);
                 mMySurfaceHolder = holder;
                 holder.SetType(SurfaceType.Gpu);
                 mSDLSurface.SurfaceChanged(holder, format, width, height);
    
             }
    
             public override void OnSurfaceDestroyed(ISurfaceHolder holder)
             {
                 base.OnSurfaceDestroyed(holder);
    
                 // mSDLSurface.SurfaceDestroyed(holder);
             }
    
             public override void OnOffsetsChanged(float xOffset, float yOffset, float xOffsetStep, float yOffsetStep, int xPixelOffset, int yPixelOffset)
             {
             }
    
             // Store the position of the touch event so we can use it for drawing later
             public override void OnTouchEvent(MotionEvent e)
             {
             }
    
         }
    
     }
     public class MySdlSurface : global::Org.Libsdl.App.SDLSurface
     {
         MyWallpaper.MyEngine mEngine;
    
         public MySdlSurface(Android.Content.Context p0, MyWallpaper.MyEngine engine) : base(p0)
         {
             mEngine = engine;
             Holder.AddCallback(this);
         }
    
         // public void setSurfHolder(ISurfaceHolder mySurfHolder) { mMySurfHolder = mySurfHolder; }
         public override ISurfaceHolder Holder
         {
             get
             {
                 if (mEngine != null && mEngine.mMySurfaceHolder != null)
                 {
                     return mEngine.mMySurfaceHolder;
                 }
                 else
                 {
                     return base.Holder;
                 }
             }
         }
    
         public override Surface NativeSurface
         {
             get
             {
                 return mEngine.mMySurfaceHolder.Surface;
             }
         }
    
    
         public override void SurfaceChanged(ISurfaceHolder holder, Format format, int width, int height)
         {
             Holder.AddCallback(this);
             SDLActivity.MIsSurfaceReady = true;
    
         }
    
     }
 }    

`