Ejemplo n.º 1
0
        static void ProxyStop(IntPtr h)
        {
            isExiting = true;
            if (CancelActiveActionsOnStop)
            {
                Current.ActionManager.CancelActiveActions();
            }
            LogSharp.Debug("ProxyStop");
            UrhoPlatformInitializer.Initialized = false;
            var context = Current.Context;
            var app     = GetApp(h);

            app.IsClosed = true;
            app.Stop();
            LogSharp.Debug("ProxyStop: Runtime.Cleanup");
            Runtime.Cleanup();
            LogSharp.Debug("ProxyStop: Disposing context");
            context.Dispose();
            Current = null;
            Stopped?.Invoke();
            LogSharp.Debug("ProxyStop: end");
            exitTask?.TrySetResult(true);
        }
Ejemplo n.º 2
0
        public void Clean(bool disposeContext = true)
        {
            IntPtr[] handles;

            lock (knownObjects)
                handles = knownObjects.OrderBy(t => GetDisposePriority(t.Value)).Select(t => t.Key).ToArray();

            foreach (var handle in handles)
            {
                ReferenceHolder <RefCounted> refHolder;
                lock (knownObjects)
                    knownObjects.TryGetValue(handle, out refHolder);
                var reference = refHolder?.Reference;
                if (!disposeContext && reference is Context)
                {
                    continue;
                }
                reference?.Dispose();
            }
            LogSharp.Warn($"RefCountedCache objects alive: {knownObjects.Count}");

            //knownObjects.Clear();
        }
Ejemplo n.º 3
0
 /// <summary>
 /// Called by RefCounted::~RefCounted - we don't need to check Refs here - just mark it as deleted and remove from cache
 /// </summary>
 internal void HandleNativeDelete()
 {
     LogSharp.Trace($"{GetType().Name}: HandleNativeDelete");
     Dispose(true);
     GC.SuppressFinalize(this);
 }
Ejemplo n.º 4
0
        internal static async Task StopCurrent()
        {
            if (current == null && !current.IsActive)
            {
                return;
            }

            //Current.Engine.PauseMinimized = true;
            Current.Input.Enabled = false;

            isExiting = true;
#if IOS
            iOS.UrhoSurface.StopRendering(current);
#endif

#if WINDOWS_UWP && !UWP_HOLO
            UWP.UrhoSurface.StopRendering().Wait();
#endif
#if ANDROID
            if (Current.UrhoSurface?.IsAlive == false)
            {
                Current.Engine.Exit();
            }
            else if (System.Threading.Thread.CurrentThread.ManagedThreadId != renderThreadId)
            {
                exitTask = new TaskCompletionSource <bool>();
                InvokeOnMainAsync(() => Current.Engine.Exit()).Wait();
                Current.UrhoSurface?.Remove();
                Current.UrhoSurface = null;
                await exitTask.Task;                //.Wait();
            }
            else
            {
                Current.Engine.Exit();
                new Android.OS.Handler(Android.OS.Looper.MainLooper).PostAtFrontOfQueue(() => {
                    Current.UrhoSurface?.Remove();
                    Current.UrhoSurface = null;
                });
            }
#else
            LogSharp.Debug($"StopCurrent: Current.IsFrameRendering={Current.IsFrameRendering}");
            if (Current.IsFrameRendering)            // && !Current.Engine.PauseMinimized)
            {
                waitFrameEndTaskSource = new TaskCompletionSource <bool>();
                await waitFrameEndTaskSource.Task;
                LogSharp.Debug($"StopCurrent: waitFrameEndTaskSource awaited");
                waitFrameEndTaskSource = null;
            }
            LogSharp.Debug($"StopCurrent: Engine.Exit");
            Current.Engine.Exit();
#endif
#if IOS || WINDOWS_UWP
#if DESKTOP
            if (Current.Options.DelayedStart)
#endif
            ProxyStop(Current.Handle);
#endif
            GC.Collect();
            GC.WaitForPendingFinalizers();
            GC.Collect();
        }