src/Tizen.NUI/src/internal/Application/Application.cs

   1 /*
   2  * Copyright(c) 2022 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17 using System;
  18 using System.Collections.Generic;
  19 using System.Collections.ObjectModel;
  20 using System.ComponentModel;
  21 using System.Diagnostics;
  22 using System.Runtime.InteropServices;
  23 using Tizen.NUI.Binding;
  24
  25 namespace Tizen.NUI
  26 {
  27     // Event arguments that passed via NUIApplicationInit signal
  28     internal class NUIApplicationInitEventArgs : EventArgs
  29     {
  30         private Application application;
  31
  32         // Application - is the application that is being initialized
  33         public Application Application
  34         {
  35             get
  36             {
  37                 return application;
  38             }
  39             set
  40             {
  41                 application = value;
  42             }
  43         }
  44     }
  45
  46     // Event arguments that passed via NUIApplicationTerminate signal
  47     internal class NUIApplicationTerminatingEventArgs : EventArgs
  48     {
  49         private Application application;
  50
  51         // Application - is the application that is being Terminated
  52         public Application Application
  53         {
  54             get
  55             {
  56                 return application;
  57             }
  58             set
  59             {
  60                 application = value;
  61             }
  62         }
  63     }
  64
  65     // Event arguments that passed via NUIApplicationPause signal
  66     internal class NUIApplicationPausedEventArgs : EventArgs
  67     {
  68         private Application application;
  69
  70         // Application - is the application that is being Paused
  71         public Application Application
  72         {
  73             get
  74             {
  75                 return application;
  76             }
  77             set
  78             {
  79                 application = value;
  80             }
  81         }
  82     }
  83
  84     // Event arguments that passed via NUIApplicationResume signal
  85     internal class NUIApplicationResumedEventArgs : EventArgs
  86     {
  87         private Application application;
  88         // Application - is the application that is being Resumed
  89         public Application Application
  90         {
  91             get
  92             {
  93                 return application;
  94             }
  95             set
  96             {
  97                 application = value;
  98             }
  99         }
 100     }
 101
 102     // Event arguments that passed via NUIApplicationReset signal
 103     internal class NUIApplicationResetEventArgs : EventArgs
 104     {
 105         private Application application;
 106
 107         // Application - is the application that is being Reset
 108         public Application Application
 109         {
 110             get
 111             {
 112                 return application;
 113             }
 114             set
 115             {
 116                 application = value;
 117             }
 118         }
 119     }
 120
 121     // Event arguments that passed via NUIApplicationLanguageChanged signal
 122     internal class NUIApplicationLanguageChangedEventArgs : EventArgs
 123     {
 124         private Application application;
 125
 126         // Application - is the application that is being affected with Device's language change
 127         public Application Application
 128         {
 129             get
 130             {
 131                 return application;
 132             }
 133             set
 134             {
 135                 application = value;
 136             }
 137         }
 138     }
 139
 140     // Event arguments that passed via NUIApplicationRegionChanged signal
 141     internal class NUIApplicationRegionChangedEventArgs : EventArgs
 142     {
 143         private Application application;
 144
 145         // Application - is the application that is being affected with Device's region change
 146         public Application Application
 147         {
 148             get
 149             {
 150                 return application;
 151             }
 152             set
 153             {
 154                 application = value;
 155             }
 156         }
 157     }
 158
 159     // Event arguments that passed via NUIApplicationBatteryLow signal
 160     internal class NUIApplicationBatteryLowEventArgs : EventArgs
 161     {
 162         private Application.BatteryStatus status;
 163
 164         // Application - is the application that is being affected when the battery level of the device is low
 165         public Application.BatteryStatus BatteryStatus
 166         {
 167             get
 168             {
 169                 return status;
 170             }
 171             set
 172             {
 173                 status = value;
 174             }
 175         }
 176     }
 177
 178     // Event arguments that passed via NUIApplicationMemoryLow signal
 179     internal class NUIApplicationMemoryLowEventArgs : EventArgs
 180     {
 181         private Application.MemoryStatus status;
 182
 183         // Application - is the application that is being affected when the memory level of the device is low
 184         public Application.MemoryStatus MemoryStatus
 185         {
 186             get
 187             {
 188                 return status;
 189             }
 190             set
 191             {
 192                 status = value;
 193             }
 194         }
 195     }
 196
 197     // Event arguments that passed via NUIApplicationDeviceOrientationChanged signal
 198     internal class NUIApplicationDeviceOrientationChangedEventArgs : EventArgs
 199     {
 200         private Application.DeviceOrientationStatus status;
 201
 202         // Application - is the application that is being affected when the device orientation is changed.
 203         public Application.DeviceOrientationStatus DeviceOrientationStatus
 204         {
 205             get
 206             {
 207                 return status;
 208             }
 209             set
 210             {
 211                 status = value;
 212             }
 213         }
 214     }
 215
 216     // Event arguments that passed via NUIApplicationAppControl  signal
 217     internal class NUIApplicationAppControlEventArgs : EventArgs
 218     {
 219         private Application application;
 220         private IntPtr voidp;
 221
 222         // Application - is the application that is receiving the launch request from another application
 223         public Application Application
 224         {
 225             get
 226             {
 227                 return application;
 228             }
 229             set
 230             {
 231                 application = value;
 232             }
 233         }
 234
 235         // VoidP - contains the information about why the application is launched
 236         public IntPtr VoidP
 237         {
 238             get
 239             {
 240                 return voidp;
 241             }
 242             set
 243             {
 244                 voidp = value;
 245             }
 246         }
 247     }
 248
 249     /// <summary>
 250     /// A class to get resources in current application.
 251     /// </summary>
 252     public sealed class GetResourcesProvider
 253     {
 254         /// <summary>
 255         /// Get resources in current application.
 256         /// </summary>
 257         static public IResourcesProvider Get()
 258         {
 259             return Tizen.NUI.Application.Current;
 260         }
 261     }
 262
 263     internal class Application : BaseHandle, IResourcesProvider, IElementConfiguration<Application>
 264     {
 265         static Application s_current;
 266
 267         ReadOnlyCollection<Element> logicalChildren;
 268
 269         [EditorBrowsable(EditorBrowsableState.Never)]
 270         public static void SetCurrentApplication(Application value) => Current = value;
 271
 272         public static Application Current
 273         {
 274             get { return s_current; }
 275             set
 276             {
 277                 if (s_current == value)
 278                     return;
 279                 s_current = value;
 280             }
 281         }
 282
 283         internal override ReadOnlyCollection<Element> LogicalChildrenInternal
 284         {
 285             get { return logicalChildren ?? (logicalChildren = new ReadOnlyCollection<Element>(InternalChildren)); }
 286         }
 287
 288         internal IResourceDictionary SystemResources { get; }
 289
 290         ObservableCollection<Element> InternalChildren { get; } = new ObservableCollection<Element>();
 291
 292         ResourceDictionary resources;
 293         public bool IsResourcesCreated => resources != null;
 294
 295         public delegate void resChangeCb(object sender, ResourcesChangedEventArgs e);
 296
 297         internal override void OnResourcesChanged(object sender, ResourcesChangedEventArgs e)
 298         {
 299             base.OnResourcesChanged(sender, e);
 300         }
 301
 302         public ResourceDictionary XamlResources
 303         {
 304             get
 305             {
 306                 if (resources == null)
 307                 {
 308                     resources = new ResourceDictionary();
 309                     int hashCode = resources.GetHashCode();
 310                     ((IResourceDictionary)resources).ValuesChanged += OnResourcesChanged;
 311                 }
 312                 return resources;
 313             }
 314             set
 315             {
 316                 if (resources == value)
 317                     return;
 318                 OnPropertyChanging();
 319
 320                 if (resources != null)
 321                     ((IResourceDictionary)resources).ValuesChanged -= OnResourcesChanged;
 322                 resources = value;
 323                 OnResourcesChanged(value);
 324                 if (resources != null)
 325                     ((IResourceDictionary)resources).ValuesChanged += OnResourcesChanged;
 326
 327                 OnPropertyChanged();
 328             }
 329         }
 330
 331         protected override void OnParentSet()
 332         {
 333             throw new InvalidOperationException("Setting a Parent on Application is invalid.");
 334         }
 335
 336         [EditorBrowsable(EditorBrowsableState.Never)]
 337         public static bool IsApplicationOrNull(Element element)
 338         {
 339             return element == null || element is Application;
 340         }
 341
 342         internal override void OnParentResourcesChanged(IEnumerable<KeyValuePair<string, object>> values)
 343         {
 344             if (values == null)
 345                 return;
 346
 347             if (!((IResourcesProvider)this).IsResourcesCreated || XamlResources.Count == 0)
 348             {
 349                 base.OnParentResourcesChanged(values);
 350                 return;
 351             }
 352
 353             var innerKeys = new HashSet<string>();
 354             var changedResources = new List<KeyValuePair<string, object>>();
 355             foreach (KeyValuePair<string, object> c in XamlResources)
 356                 innerKeys.Add(c.Key);
 357             foreach (KeyValuePair<string, object> value in values)
 358             {
 359                 if (innerKeys.Add(value.Key))
 360                     changedResources.Add(value);
 361             }
 362             if (changedResources.Count != 0)
 363                 OnResourcesChanged(changedResources);
 364         }
 365
 366         internal Application(global::System.IntPtr cPtr, bool cMemoryOwn) : base(cPtr, cMemoryOwn)
 367         {
 368             SetCurrentApplication(this);
 369             s_current = this;
 370         }
 371
 372         protected override void Dispose(DisposeTypes type)
 373         {
 374             if (disposed)
 375             {
 376                 return;
 377             }
 378
 379             //Release your own unmanaged resources here.
 380             //You should not access any managed member here except static instance.
 381             //because the execution order of Finalizes is non-deterministic.
 382             if (applicationInitEventCallbackDelegate != null)
 383             {
 384                 initSignal?.Disconnect(applicationInitEventCallbackDelegate);
 385                 initSignal?.Dispose();
 386                 initSignal = null;
 387             }
 388
 389             if (applicationTerminateEventCallbackDelegate != null)
 390             {
 391                 terminateSignal?.Disconnect(applicationTerminateEventCallbackDelegate);
 392                 terminateSignal?.Dispose();
 393                 terminateSignal = null;
 394             }
 395
 396             if (applicationPauseEventCallbackDelegate != null)
 397             {
 398                 pauseSignal?.Disconnect(applicationPauseEventCallbackDelegate);
 399                 pauseSignal?.Dispose();
 400                 pauseSignal = null;
 401             }
 402
 403             if (applicationResumeEventCallbackDelegate != null)
 404             {
 405                 resumeSignal?.Disconnect(applicationResumeEventCallbackDelegate);
 406                 resumeSignal?.Dispose();
 407                 resumeSignal = null;
 408             }
 409
 410             if (applicationResetEventCallbackDelegate != null)
 411             {
 412                 resetSignal?.Disconnect(applicationResetEventCallbackDelegate);
 413                 resetSignal?.Dispose();
 414                 resetSignal = null;
 415             }
 416
 417             if (applicationLanguageChangedEventCallbackDelegate != null)
 418             {
 419                 languageChangedSignal?.Disconnect(applicationLanguageChangedEventCallbackDelegate);
 420                 languageChangedSignal?.Dispose();
 421                 languageChangedSignal = null;
 422             }
 423
 424             if (applicationRegionChangedEventCallbackDelegate != null)
 425             {
 426                 regionChangedSignal?.Disconnect(applicationRegionChangedEventCallbackDelegate);
 427                 regionChangedSignal?.Dispose();
 428                 regionChangedSignal = null;
 429             }
 430
 431             if (applicationBatteryLowEventCallbackDelegate != null)
 432             {
 433                 batteryLowSignal?.Disconnect(applicationBatteryLowEventCallbackDelegate);
 434                 batteryLowSignal?.Dispose();
 435                 batteryLowSignal = null;
 436             }
 437
 438             if (applicationMemoryLowEventCallbackDelegate != null)
 439             {
 440                 memoryLowSignal?.Disconnect(applicationMemoryLowEventCallbackDelegate);
 441                 memoryLowSignal?.Dispose();
 442                 memoryLowSignal = null;
 443             }
 444
 445             if (applicationDeviceOrientationChangedEventCallback != null)
 446             {
 447                 deviceOrientationChangedSignal?.Disconnect(applicationDeviceOrientationChangedEventCallback);
 448                 deviceOrientationChangedSignal?.Dispose();
 449                 deviceOrientationChangedSignal = null;
 450             }
 451
 452             if (applicationAppControlEventCallbackDelegate != null)
 453             {
 454                 appControlSignal?.Disconnect(applicationAppControlEventCallbackDelegate);
 455                 appControlSignal?.Dispose();
 456                 appControlSignal = null;
 457             }
 458
 459             //Task
 460             if (applicationTaskInitEventCallbackDelegate != null)
 461             {
 462                 taskInitSignal?.Disconnect(applicationTaskInitEventCallbackDelegate);
 463                 taskInitSignal?.Dispose();
 464                 taskInitSignal = null;
 465             }
 466
 467             if (applicationTaskTerminateEventCallbackDelegate != null)
 468             {
 469                 taskTerminateSignal?.Disconnect(applicationTaskTerminateEventCallbackDelegate);
 470                 taskTerminateSignal?.Dispose();
 471                 taskTerminateSignal = null;
 472             }
 473
 474             if (applicationTaskLanguageChangedEventCallbackDelegate != null)
 475             {
 476                 taskLanguageChangedSignal?.Disconnect(applicationTaskLanguageChangedEventCallbackDelegate);
 477                 taskLanguageChangedSignal?.Dispose();
 478                 taskLanguageChangedSignal = null;
 479             }
 480
 481             if (applicationTaskRegionChangedEventCallbackDelegate != null)
 482             {
 483                 taskRegionChangedSignal?.Disconnect(applicationTaskRegionChangedEventCallbackDelegate);
 484                 taskRegionChangedSignal?.Dispose();
 485                 taskRegionChangedSignal = null;
 486             }
 487
 488             if (applicationTaskBatteryLowEventCallbackDelegate != null)
 489             {
 490                 taskBatteryLowSignal?.Disconnect(applicationTaskBatteryLowEventCallbackDelegate);
 491                 taskBatteryLowSignal?.Dispose();
 492                 taskBatteryLowSignal = null;
 493             }
 494
 495             if (applicationTaskMemoryLowEventCallbackDelegate != null)
 496             {
 497                 taskMemoryLowSignal?.Disconnect(applicationTaskMemoryLowEventCallbackDelegate);
 498                 taskMemoryLowSignal?.Dispose();
 499                 taskMemoryLowSignal = null;
 500             }
 501
 502             if (applicationTaskDeviceOrientationChangedEventCallback != null)
 503             {
 504                 taskDeviceOrientationChangedSignal?.Disconnect(applicationTaskDeviceOrientationChangedEventCallback);
 505                 taskDeviceOrientationChangedSignal?.Dispose();
 506                 taskDeviceOrientationChangedSignal = null;
 507             }
 508
 509             if (applicationTaskAppControlEventCallbackDelegate != null)
 510             {
 511                 taskAppControlSignal?.Disconnect(applicationTaskAppControlEventCallbackDelegate);
 512                 taskAppControlSignal?.Dispose();
 513                 taskAppControlSignal = null;
 514             }
 515
 516             window?.Dispose();
 517             window = null;
 518
 519             base.Dispose(type);
 520         }
 521         protected override void ReleaseSwigCPtr(System.Runtime.InteropServices.HandleRef swigCPtr)
 522         {
 523             Interop.Application.DeleteApplication(swigCPtr);
 524         }
 525
 526         public enum BatteryStatus
 527         {
 528             Normal,
 529             CriticallyLow,
 530             PowerOff
 531         };
 532
 533         public enum MemoryStatus
 534         {
 535             Normal,
 536             Low,
 537             CriticallyLow
 538         };
 539
 540         public enum DeviceOrientationStatus
 541         {
 542             Orientation_0 = 0,
 543             Orientation_90 = 90,
 544             Orientation_180 = 180,
 545             Orientation_270 = 270
 546         };
 547
 548         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 549         private delegate void NUIApplicationInitEventCallbackDelegate(IntPtr application);
 550         private DaliEventHandler<object, NUIApplicationInitEventArgs> applicationInitEventHandler;
 551         private NUIApplicationInitEventCallbackDelegate applicationInitEventCallbackDelegate;
 552         private ApplicationSignal initSignal;
 553
 554         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 555         private delegate void NUIApplicationTerminateEventCallbackDelegate(IntPtr application);
 556         private DaliEventHandler<object, NUIApplicationTerminatingEventArgs> applicationTerminateEventHandler;
 557         private NUIApplicationTerminateEventCallbackDelegate applicationTerminateEventCallbackDelegate;
 558         private ApplicationSignal terminateSignal;
 559
 560         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 561         private delegate void NUIApplicationPauseEventCallbackDelegate(IntPtr application);
 562         private DaliEventHandler<object, NUIApplicationPausedEventArgs> applicationPauseEventHandler;
 563         private NUIApplicationPauseEventCallbackDelegate applicationPauseEventCallbackDelegate;
 564         private ApplicationSignal pauseSignal;
 565
 566         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 567         private delegate void NUIApplicationResumeEventCallbackDelegate(IntPtr application);
 568         private DaliEventHandler<object, NUIApplicationResumedEventArgs> applicationResumeEventHandler;
 569         private NUIApplicationResumeEventCallbackDelegate applicationResumeEventCallbackDelegate;
 570         private ApplicationSignal resumeSignal;
 571
 572         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 573         private delegate void NUIApplicationResetEventCallbackDelegate(IntPtr application);
 574         private DaliEventHandler<object, NUIApplicationResetEventArgs> applicationResetEventHandler;
 575         private NUIApplicationResetEventCallbackDelegate applicationResetEventCallbackDelegate;
 576         private ApplicationSignal resetSignal;
 577
 578         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 579         private delegate void NUIApplicationLanguageChangedEventCallbackDelegate(IntPtr application);
 580         private DaliEventHandler<object, NUIApplicationLanguageChangedEventArgs> applicationLanguageChangedEventHandler;
 581         private NUIApplicationLanguageChangedEventCallbackDelegate applicationLanguageChangedEventCallbackDelegate;
 582         private ApplicationSignal languageChangedSignal;
 583
 584
 585         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 586         private delegate void NUIApplicationRegionChangedEventCallbackDelegate(IntPtr application);
 587         private DaliEventHandler<object, NUIApplicationRegionChangedEventArgs> applicationRegionChangedEventHandler;
 588         private NUIApplicationRegionChangedEventCallbackDelegate applicationRegionChangedEventCallbackDelegate;
 589         private ApplicationSignal regionChangedSignal;
 590
 591         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 592         private delegate void NUIApplicationBatteryLowEventCallbackDelegate(BatteryStatus status);
 593         private DaliEventHandler<object, NUIApplicationBatteryLowEventArgs> applicationBatteryLowEventHandler;
 594         private NUIApplicationBatteryLowEventCallbackDelegate applicationBatteryLowEventCallbackDelegate;
 595         private LowBatterySignalType batteryLowSignal;
 596
 597         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 598         private delegate void NUIApplicationMemoryLowEventCallbackDelegate(MemoryStatus status);
 599         private DaliEventHandler<object, NUIApplicationMemoryLowEventArgs> applicationMemoryLowEventHandler;
 600         private NUIApplicationMemoryLowEventCallbackDelegate applicationMemoryLowEventCallbackDelegate;
 601         private LowMemorySignalType memoryLowSignal;
 602
 603         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 604         private delegate void NUIApplicationDeviceOrientationChangedEventCallback(DeviceOrientationStatus status);
 605         private DaliEventHandler<object, NUIApplicationDeviceOrientationChangedEventArgs> applicationDeviceOrientationChangedEventHandler;
 606         private NUIApplicationDeviceOrientationChangedEventCallback applicationDeviceOrientationChangedEventCallback;
 607         private DeviceOrientationChangedSignalType deviceOrientationChangedSignal;
 608
 609         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 610         private delegate void NUIApplicationAppControlEventCallbackDelegate(IntPtr application, IntPtr voidp);
 611         private DaliEventHandler<object, NUIApplicationAppControlEventArgs> applicationAppControlEventHandler;
 612         private NUIApplicationAppControlEventCallbackDelegate applicationAppControlEventCallbackDelegate;
 613         private ApplicationControlSignal appControlSignal;
 614
 615         private DaliEventHandler<object, NUIApplicationInitEventArgs> applicationTaskInitEventHandler;
 616         private NUIApplicationInitEventCallbackDelegate applicationTaskInitEventCallbackDelegate;
 617         private ApplicationSignal taskInitSignal;
 618
 619         private DaliEventHandler<object, NUIApplicationTerminatingEventArgs> applicationTaskTerminateEventHandler;
 620         private NUIApplicationTerminateEventCallbackDelegate applicationTaskTerminateEventCallbackDelegate;
 621         private ApplicationSignal taskTerminateSignal;
 622
 623         private DaliEventHandler<object, NUIApplicationLanguageChangedEventArgs> applicationTaskLanguageChangedEventHandler;
 624         private NUIApplicationLanguageChangedEventCallbackDelegate applicationTaskLanguageChangedEventCallbackDelegate;
 625         private ApplicationSignal taskLanguageChangedSignal;
 626
 627         private DaliEventHandler<object, NUIApplicationRegionChangedEventArgs> applicationTaskRegionChangedEventHandler;
 628         private NUIApplicationRegionChangedEventCallbackDelegate applicationTaskRegionChangedEventCallbackDelegate;
 629         private ApplicationSignal taskRegionChangedSignal;
 630
 631         private DaliEventHandler<object, NUIApplicationBatteryLowEventArgs> applicationTaskBatteryLowEventHandler;
 632         private NUIApplicationBatteryLowEventCallbackDelegate applicationTaskBatteryLowEventCallbackDelegate;
 633         private LowBatterySignalType taskBatteryLowSignal;
 634
 635         private DaliEventHandler<object, NUIApplicationMemoryLowEventArgs> applicationTaskMemoryLowEventHandler;
 636         private NUIApplicationMemoryLowEventCallbackDelegate applicationTaskMemoryLowEventCallbackDelegate;
 637         private LowMemorySignalType taskMemoryLowSignal;
 638
 639         private DaliEventHandler<object, NUIApplicationDeviceOrientationChangedEventArgs> applicationTaskDeviceOrientationChangedEventHandler;
 640         private NUIApplicationDeviceOrientationChangedEventCallback applicationTaskDeviceOrientationChangedEventCallback;
 641         private DeviceOrientationChangedSignalType taskDeviceOrientationChangedSignal;
 642
 643         private DaliEventHandler<object, NUIApplicationAppControlEventArgs> applicationTaskAppControlEventHandler;
 644         private NUIApplicationAppControlEventCallbackDelegate applicationTaskAppControlEventCallbackDelegate;
 645         private ApplicationControlSignal taskAppControlSignal;
 646
 647         private Window window;
 648
 649         // Event for Initialized signal which can be used to subscribe/unsubscribe the event handler
 650         // provided by the user. Initialized signal is emitted when application is initialized
 651         public event DaliEventHandler<object, NUIApplicationInitEventArgs> Initialized
 652         {
 653             add
 654             {
 655                 // Restricted to only one listener
 656                 if (applicationInitEventHandler == null)
 657                 {
 658                     applicationInitEventHandler += value;
 659                     applicationInitEventCallbackDelegate = new NUIApplicationInitEventCallbackDelegate(OnApplicationInit);
 660                     initSignal = this.InitSignal();
 661                     initSignal?.Connect(applicationInitEventCallbackDelegate);
 662                 }
 663             }
 664
 665             remove
 666             {
 667                 if (applicationInitEventHandler != null)
 668                 {
 669                     initSignal?.Disconnect(applicationInitEventCallbackDelegate);
 670                     initSignal?.Dispose();
 671                     initSignal = null;
 672                 }
 673
 674                 applicationInitEventHandler -= value;
 675             }
 676         }
 677
 678         // Callback for Application InitSignal
 679         private void OnApplicationInit(IntPtr data)
 680         {
 681             Log.Info("NUI", "[NUI] OnApplicationInit: DisposeQueue Initialize");
 682             Tizen.Tracer.Begin("[NUI] OnApplicationInit: DisposeQueue Initialize");
 683             // Initialize DisposeQueue Singleton class. This is also required to create DisposeQueue on main thread.
 684             DisposeQueue.Instance.Initialize();
 685             Tizen.Tracer.End();
 686
 687             Log.Info("NUI", "[NUI] OnApplicationInit: ProcessorController Initialize");
 688             Tizen.Tracer.Begin("[NUI] OnApplicationInit: ProcessorController Initialize");
 689             // Initialize ProcessorController Singleton class. This is also required to create ProcessorController on main thread.
 690             ProcessorController.Instance.Initialize();
 691             Tizen.Tracer.End();
 692
 693             Log.Info("NUI", "[NUI] OnApplicationInit: GetWindow");
 694             Tizen.Tracer.Begin("[NUI] OnApplicationInit: GetWindow");
 695             Window.Instance = GetWindow();
 696 #if !PROFILE_TV
 697             //tv profile never use default focus indicator, so this is not needed!
 698             _ = FocusManager.Instance;
 699 #endif
 700             Tizen.Tracer.End();
 701
 702             Log.Info("NUI", "[NUI] OnApplicationInit: Window Show");
 703             Tizen.Tracer.Begin("[NUI] OnApplicationInit: Window Show");
 704             // Notify that the window is displayed to the app core.
 705             if (NUIApplication.IsPreload)
 706             {
 707                 Window.Instance.Show();
 708             }
 709             Tizen.Tracer.End();
 710
 711             Log.Info("NUI", "[NUI] OnApplicationInit: applicationInitEventHandler Invoke");
 712             Tizen.Tracer.Begin("[NUI] OnApplicationInit: applicationInitEventHandler Invoke");
 713             if (applicationInitEventHandler != null)
 714             {
 715                 NUIApplicationInitEventArgs e = new NUIApplicationInitEventArgs();
 716                 e.Application = this;
 717                 applicationInitEventHandler.Invoke(this, e);
 718             }
 719             Tizen.Tracer.End();
 720         }
 721
 722         // Event for Terminated signal which can be used to subscribe/unsubscribe the event handler
 723         //  provided by the user. Terminated signal is emitted when application is terminating
 724         public event DaliEventHandler<object, NUIApplicationTerminatingEventArgs> Terminating
 725         {
 726             add
 727             {
 728                 // Restricted to only one listener
 729                 if (applicationTerminateEventHandler == null)
 730                 {
 731                     applicationTerminateEventHandler += value;
 732
 733                     applicationTerminateEventCallbackDelegate = new NUIApplicationTerminateEventCallbackDelegate(OnNUIApplicationTerminate);
 734                     terminateSignal = this.TerminateSignal();
 735                     terminateSignal?.Connect(applicationTerminateEventCallbackDelegate);
 736                 }
 737             }
 738
 739             remove
 740             {
 741                 if (applicationTerminateEventHandler != null)
 742                 {
 743                     terminateSignal?.Disconnect(applicationTerminateEventCallbackDelegate);
 744                     terminateSignal?.Dispose();
 745                     terminateSignal = null;
 746                 }
 747
 748                 applicationTerminateEventHandler -= value;
 749             }
 750         }
 751
 752         // Callback for Application TerminateSignal
 753         private void OnNUIApplicationTerminate(IntPtr data)
 754         {
 755             if (applicationTerminateEventHandler != null)
 756             {
 757                 NUIApplicationTerminatingEventArgs e = new NUIApplicationTerminatingEventArgs();
 758                 e.Application = this;
 759                 applicationTerminateEventHandler.Invoke(this, e);
 760             }
 761
 762             List<Window> windows = GetWindowList();
 763             if (windows != null)
 764             {
 765                 foreach (Window window in windows)
 766                 {
 767                     window?.DisconnectNativeSignals();
 768                 }
 769             }
 770         }
 771
 772         // Event for Paused signal which can be used to subscribe/unsubscribe the event handler
 773         // provided by the user. Paused signal is emitted when application is paused
 774         public event DaliEventHandler<object, NUIApplicationPausedEventArgs> Paused
 775         {
 776             add
 777             {
 778                 // Restricted to only one listener
 779                 if (applicationPauseEventHandler == null)
 780                 {
 781                     applicationPauseEventHandler += value;
 782
 783                     applicationPauseEventCallbackDelegate = new NUIApplicationPauseEventCallbackDelegate(OnNUIApplicationPause);
 784                     pauseSignal = this.PauseSignal();
 785                     pauseSignal?.Connect(applicationPauseEventCallbackDelegate);
 786                 }
 787             }
 788
 789             remove
 790             {
 791                 if (applicationPauseEventHandler != null)
 792                 {
 793                     pauseSignal?.Disconnect(applicationPauseEventCallbackDelegate);
 794                     pauseSignal?.Dispose();
 795                     pauseSignal = null;
 796                 }
 797
 798                 applicationPauseEventHandler -= value;
 799             }
 800         }
 801
 802         // Callback for Application PauseSignal
 803         private void OnNUIApplicationPause(IntPtr data)
 804         {
 805             if (applicationPauseEventHandler != null)
 806             {
 807                 NUIApplicationPausedEventArgs e = new NUIApplicationPausedEventArgs();
 808                 e.Application = this;
 809                 applicationPauseEventHandler.Invoke(this, e);
 810             }
 811         }
 812
 813         // Event for Resumed signal which can be used to subscribe/unsubscribe the event handler
 814         //  provided by the user. Resumed signal is emitted when application is resumed
 815         public event DaliEventHandler<object, NUIApplicationResumedEventArgs> Resumed
 816         {
 817             add
 818             {
 819                 // Restricted to only one listener
 820                 if (applicationResumeEventHandler == null)
 821                 {
 822                     applicationResumeEventHandler += value;
 823
 824                     applicationResumeEventCallbackDelegate = new NUIApplicationResumeEventCallbackDelegate(OnNUIApplicationResume);
 825                     resumeSignal = this.ResumeSignal();
 826                     resumeSignal?.Connect(applicationResumeEventCallbackDelegate);
 827                 }
 828             }
 829
 830             remove
 831             {
 832                 if (applicationResumeEventHandler != null)
 833                 {
 834                     resumeSignal?.Disconnect(applicationResumeEventCallbackDelegate);
 835                     resumeSignal?.Dispose();
 836                     resumeSignal = null;
 837                 }
 838
 839                 applicationResumeEventHandler -= value;
 840             }
 841         }
 842
 843         // Callback for Application ResumeSignal
 844         private void OnNUIApplicationResume(IntPtr data)
 845         {
 846             if (applicationResumeEventHandler != null)
 847             {
 848                 NUIApplicationResumedEventArgs e = new NUIApplicationResumedEventArgs();
 849                 e.Application = this;
 850                 applicationResumeEventHandler.Invoke(this, e);
 851             }
 852         }
 853
 854         // Event for Reset signal which can be used to subscribe/unsubscribe the event handler
 855         //  provided by the user. Reset signal is emitted when application is reset
 856         public new event DaliEventHandler<object, NUIApplicationResetEventArgs> Reset
 857         {
 858             add
 859             {
 860                 // Restricted to only one listener
 861                 if (applicationResetEventHandler == null)
 862                 {
 863                     applicationResetEventHandler += value;
 864
 865                     applicationResetEventCallbackDelegate = new NUIApplicationResetEventCallbackDelegate(OnNUIApplicationReset);
 866                     resetSignal = this.ResetSignal();
 867                     resetSignal?.Connect(applicationResetEventCallbackDelegate);
 868                 }
 869             }
 870
 871             remove
 872             {
 873                 if (applicationResetEventHandler != null)
 874                 {
 875                     resetSignal?.Disconnect(applicationResetEventCallbackDelegate);
 876                     resetSignal?.Dispose();
 877                     resetSignal = null;
 878                 }
 879
 880                 applicationResetEventHandler -= value;
 881             }
 882         }
 883
 884         // Callback for Application ResetSignal
 885         private void OnNUIApplicationReset(IntPtr data)
 886         {
 887             if (applicationResetEventHandler != null)
 888             {
 889                 NUIApplicationResetEventArgs e = new NUIApplicationResetEventArgs();
 890                 e.Application = this;
 891                 applicationResetEventHandler.Invoke(this, e);
 892             }
 893         }
 894
 895         // Event for LanguageChanged signal which can be used to subscribe/unsubscribe the event handler
 896         //  provided by the user. LanguageChanged signal is emitted when the region of the device is changed.
 897         public event DaliEventHandler<object, NUIApplicationLanguageChangedEventArgs> LanguageChanged
 898         {
 899             add
 900             {
 901                 // Restricted to only one listener
 902                 if (applicationLanguageChangedEventHandler == null)
 903                 {
 904                     applicationLanguageChangedEventHandler += value;
 905
 906                     applicationLanguageChangedEventCallbackDelegate = new NUIApplicationLanguageChangedEventCallbackDelegate(OnNUIApplicationLanguageChanged);
 907                     languageChangedSignal = this.LanguageChangedSignal();
 908                     languageChangedSignal?.Connect(applicationLanguageChangedEventCallbackDelegate);
 909                 }
 910             }
 911
 912             remove
 913             {
 914                 if (applicationLanguageChangedEventHandler != null)
 915                 {
 916                     languageChangedSignal?.Disconnect(applicationLanguageChangedEventCallbackDelegate);
 917                     languageChangedSignal?.Dispose();
 918                     languageChangedSignal = null;
 919                 }
 920
 921                 applicationLanguageChangedEventHandler -= value;
 922             }
 923         }
 924
 925         // Callback for Application LanguageChangedSignal
 926         private void OnNUIApplicationLanguageChanged(IntPtr data)
 927         {
 928             if (applicationLanguageChangedEventHandler != null)
 929             {
 930                 NUIApplicationLanguageChangedEventArgs e = new NUIApplicationLanguageChangedEventArgs();
 931                 e.Application = this;
 932                 applicationLanguageChangedEventHandler.Invoke(this, e);
 933             }
 934         }
 935
 936         // Event for RegionChanged signal which can be used to subscribe/unsubscribe the event handler
 937         //  provided by the user. RegionChanged signal is emitted when the region of the device is changed.
 938         public event DaliEventHandler<object, NUIApplicationRegionChangedEventArgs> RegionChanged
 939         {
 940             add
 941             {
 942                 // Restricted to only one listener
 943                 if (applicationRegionChangedEventHandler == null)
 944                 {
 945                     applicationRegionChangedEventHandler += value;
 946
 947                     applicationRegionChangedEventCallbackDelegate = new NUIApplicationRegionChangedEventCallbackDelegate(OnNUIApplicationRegionChanged);
 948                     regionChangedSignal = this.RegionChangedSignal();
 949                     regionChangedSignal?.Connect(applicationRegionChangedEventCallbackDelegate);
 950                 }
 951             }
 952
 953             remove
 954             {
 955                 if (applicationRegionChangedEventHandler != null)
 956                 {
 957                     regionChangedSignal?.Disconnect(applicationRegionChangedEventCallbackDelegate);
 958                     regionChangedSignal?.Dispose();
 959                     regionChangedSignal = null;
 960                 }
 961
 962                 applicationRegionChangedEventHandler -= value;
 963             }
 964         }
 965
 966         // Callback for Application RegionChangedSignal
 967         private void OnNUIApplicationRegionChanged(IntPtr data)
 968         {
 969             if (applicationRegionChangedEventHandler != null)
 970             {
 971                 NUIApplicationRegionChangedEventArgs e = new NUIApplicationRegionChangedEventArgs();
 972                 e.Application = this;
 973                 applicationRegionChangedEventHandler.Invoke(this, e);
 974             }
 975         }
 976
 977         // Event for BatteryLow signal which can be used to subscribe/unsubscribe the event handler
 978         // provided by the user. BatteryLow signal is emitted when the battery level of the device is low.
 979         public event DaliEventHandler<object, NUIApplicationBatteryLowEventArgs> BatteryLow
 980         {
 981             add
 982             {
 983                 // Restricted to only one listener
 984                 if (applicationBatteryLowEventHandler == null)
 985                 {
 986                     applicationBatteryLowEventHandler += value;
 987
 988                     applicationBatteryLowEventCallbackDelegate = new NUIApplicationBatteryLowEventCallbackDelegate(OnNUIApplicationBatteryLow);
 989                     batteryLowSignal = this.BatteryLowSignal();
 990                     batteryLowSignal?.Connect(applicationBatteryLowEventCallbackDelegate);
 991                 }
 992             }
 993
 994             remove
 995             {
 996                 if (applicationBatteryLowEventHandler != null)
 997                 {
 998                     batteryLowSignal?.Disconnect(applicationBatteryLowEventCallbackDelegate);
 999                     batteryLowSignal?.Dispose();
1000                     batteryLowSignal = null;
1001                 }
1002
1003                 applicationBatteryLowEventHandler -= value;
1004             }
1005         }
1006
1007         // Callback for Application BatteryLowSignal
1008         private void OnNUIApplicationBatteryLow(BatteryStatus status)
1009         {
1010             NUIApplicationBatteryLowEventArgs e = new NUIApplicationBatteryLowEventArgs();
1011
1012             // Populate all members of "e" (NUIApplicationBatteryLowEventArgs) with real data
1013             e.BatteryStatus = status;
1014             applicationBatteryLowEventHandler?.Invoke(this, e);
1015         }
1016
1017         // Event for MemoryLow signal which can be used to subscribe/unsubscribe the event handler
1018         //  provided by the user. MemoryLow signal is emitted when the memory level of the device is low.
1019         public event DaliEventHandler<object, NUIApplicationMemoryLowEventArgs> MemoryLow
1020         {
1021             add
1022             {
1023                 // Restricted to only one listener
1024                 if (applicationMemoryLowEventHandler == null)
1025                 {
1026                     applicationMemoryLowEventHandler += value;
1027
1028                     applicationMemoryLowEventCallbackDelegate = new NUIApplicationMemoryLowEventCallbackDelegate(OnNUIApplicationMemoryLow);
1029                     memoryLowSignal = this.MemoryLowSignal();
1030                     memoryLowSignal?.Connect(applicationMemoryLowEventCallbackDelegate);
1031                 }
1032             }
1033
1034             remove
1035             {
1036                 if (applicationMemoryLowEventHandler != null)
1037                 {
1038                     memoryLowSignal?.Disconnect(applicationMemoryLowEventCallbackDelegate);
1039                     memoryLowSignal?.Dispose();
1040                     memoryLowSignal = null;
1041                 }
1042
1043                 applicationMemoryLowEventHandler -= value;
1044             }
1045         }
1046
1047         // Callback for Application MemoryLowSignal
1048         private void OnNUIApplicationMemoryLow(MemoryStatus status)
1049         {
1050             NUIApplicationMemoryLowEventArgs e = new NUIApplicationMemoryLowEventArgs();
1051
1052             // Populate all members of "e" (NUIApplicationMemoryLowEventArgs) with real data
1053             e.MemoryStatus = status;
1054             applicationMemoryLowEventHandler?.Invoke(this, e);
1055         }
1056
1057         // Event for changing Device orientation signal which can be used to subscribe/unsubscribe the event handler
1058         //  provided by the user. DeviceOrientationChanged signal is emitted when the device orientation is changed.
1059         public event DaliEventHandler<object, NUIApplicationDeviceOrientationChangedEventArgs> DeviceOrientationChanged
1060         {
1061             add
1062             {
1063                 // Restricted to only one listener
1064                 if (applicationDeviceOrientationChangedEventHandler == null)
1065                 {
1066                     applicationDeviceOrientationChangedEventHandler += value;
1067
1068                     applicationDeviceOrientationChangedEventCallback = new NUIApplicationDeviceOrientationChangedEventCallback(OnNUIApplicationDeviceOrientationChanged);
1069                     deviceOrientationChangedSignal = this.DeviceOrientationChangedSignal();
1070                     deviceOrientationChangedSignal?.Connect(applicationDeviceOrientationChangedEventCallback);
1071                 }
1072             }
1073
1074             remove
1075             {
1076                 if (applicationDeviceOrientationChangedEventHandler != null)
1077                 {
1078                     deviceOrientationChangedSignal?.Disconnect(applicationDeviceOrientationChangedEventCallback);
1079                     deviceOrientationChangedSignal?.Dispose();
1080                     deviceOrientationChangedSignal = null;
1081                 }
1082
1083                 applicationDeviceOrientationChangedEventHandler -= value;
1084             }
1085         }
1086
1087         // Callback for Application DeviceOrientationChangedSignal
1088         private void OnNUIApplicationDeviceOrientationChanged(DeviceOrientationStatus status)
1089         {
1090             NUIApplicationDeviceOrientationChangedEventArgs e = new NUIApplicationDeviceOrientationChangedEventArgs();
1091
1092             e.DeviceOrientationStatus = status;
1093             applicationDeviceOrientationChangedEventHandler?.Invoke(this, e);
1094         }
1095
1096         // Event for AppControl signal which can be used to subscribe/unsubscribe the event handler
1097         //  provided by the user. AppControl signal is emitted when another application sends a launch request to the application.
1098         public event DaliEventHandler<object, NUIApplicationAppControlEventArgs> AppControl
1099         {
1100             add
1101             {
1102                 // Restricted to only one listener
1103                 if (applicationAppControlEventHandler == null)
1104                 {
1105                     applicationAppControlEventHandler += value;
1106
1107                     applicationAppControlEventCallbackDelegate = new NUIApplicationAppControlEventCallbackDelegate(OnNUIApplicationAppControl);
1108                     appControlSignal = this.AppControlSignal();
1109                     appControlSignal?.Connect(applicationAppControlEventCallbackDelegate);
1110                 }
1111             }
1112
1113             remove
1114             {
1115                 if (applicationAppControlEventHandler != null)
1116                 {
1117                     appControlSignal?.Disconnect(applicationAppControlEventCallbackDelegate);
1118                     appControlSignal?.Dispose();
1119                     appControlSignal = null;
1120                 }
1121
1122                 applicationAppControlEventHandler -= value;
1123             }
1124         }
1125
1126         // Callback for Application AppControlSignal
1127         private void OnNUIApplicationAppControl(IntPtr application, IntPtr voidp)
1128         {
1129             if (applicationAppControlEventHandler != null)
1130             {
1131                 NUIApplicationAppControlEventArgs e = new NUIApplicationAppControlEventArgs();
1132                 e.VoidP = voidp;
1133                 e.Application = this;
1134                 applicationAppControlEventHandler.Invoke(this, e);
1135             }
1136         }
1137
1138         /// <summary>
1139         /// Event for Initialized signal which can be used to subscribe/unsubscribe the event handler
1140         ///  provided by the user. Initialized signal is emitted when application is initialized
1141         /// </summary>
1142         public event DaliEventHandler<object, NUIApplicationInitEventArgs> TaskInitialized
1143         {
1144             add
1145             {
1146                 // Restricted to only one listener
1147                 if (applicationTaskInitEventHandler == null)
1148                 {
1149                     Tizen.Log.Fatal("NUI", "TaskInitialized Property adding");
1150                     applicationTaskInitEventHandler += value;
1151                     applicationTaskInitEventCallbackDelegate = new NUIApplicationInitEventCallbackDelegate(OnApplicationTaskInit);
1152                     taskInitSignal = this.TaskInitSignal();
1153                     taskInitSignal?.Connect(applicationTaskInitEventCallbackDelegate);
1154                 }
1155             }
1156
1157             remove
1158             {
1159                 if (applicationTaskInitEventHandler != null)
1160                 {
1161                     taskInitSignal?.Disconnect(applicationTaskInitEventCallbackDelegate);
1162                     taskInitSignal?.Dispose();
1163                     taskInitSignal = null;
1164                 }
1165
1166                 applicationTaskInitEventHandler -= value;
1167             }
1168         }
1169
1170         private void OnApplicationTaskInit(IntPtr data)
1171         {
1172             if (applicationTaskInitEventHandler != null)
1173             {
1174                 NUIApplicationInitEventArgs e = new NUIApplicationInitEventArgs();
1175                 e.Application = this;
1176                 applicationTaskInitEventHandler.Invoke(this, e);
1177             }
1178
1179         }
1180
1181         /// <summary>
1182         /// Event for Terminated signal which can be used to subscribe/unsubscribe the event handler
1183         ///  provided by the user. Terminated signal is emitted when application is terminating
1184         /// </summary>
1185         public event DaliEventHandler<object, NUIApplicationTerminatingEventArgs> TaskTerminating
1186         {
1187             add
1188             {
1189                 // Restricted to only one listener
1190                 if (applicationTaskTerminateEventHandler == null)
1191                 {
1192                     applicationTaskTerminateEventHandler += value;
1193
1194                     applicationTaskTerminateEventCallbackDelegate = new NUIApplicationTerminateEventCallbackDelegate(OnNUIApplicationTaskTerminate);
1195                     taskTerminateSignal = this.TaskTerminateSignal();
1196                     taskTerminateSignal?.Connect(applicationTaskTerminateEventCallbackDelegate);
1197                 }
1198             }
1199
1200             remove
1201             {
1202                 if (applicationTaskTerminateEventHandler != null)
1203                 {
1204                     taskTerminateSignal?.Disconnect(applicationTaskTerminateEventCallbackDelegate);
1205                     taskTerminateSignal?.Dispose();
1206                     taskTerminateSignal = null;
1207                 }
1208
1209                 applicationTaskTerminateEventHandler -= value;
1210             }
1211         }
1212
1213         private void OnNUIApplicationTaskTerminate(IntPtr data)
1214         {
1215             if (applicationTaskTerminateEventHandler != null)
1216             {
1217                 NUIApplicationTerminatingEventArgs e = new NUIApplicationTerminatingEventArgs();
1218                 e.Application = this;
1219                 applicationTaskTerminateEventHandler.Invoke(this, e);
1220             }
1221         }
1222
1223         /// <summary>
1224         /// Event for TaskLanguageChanged signal which can be used to subscribe/unsubscribe the event handler
1225         ///  provided by the user. TaskLanguageChanged signal is emitted when the region of the device is changed.
1226         /// </summary>
1227         public event DaliEventHandler<object, NUIApplicationLanguageChangedEventArgs> TaskLanguageChanged
1228         {
1229             add
1230             {
1231                 // Restricted to only one listener
1232                 if (applicationTaskLanguageChangedEventHandler == null)
1233                 {
1234                     applicationTaskLanguageChangedEventHandler += value;
1235
1236                     applicationTaskLanguageChangedEventCallbackDelegate = new NUIApplicationLanguageChangedEventCallbackDelegate(OnNUIApplicationTaskLanguageChanged);
1237                     taskLanguageChangedSignal = this.TaskLanguageChangedSignal();
1238                     taskLanguageChangedSignal?.Connect(applicationTaskLanguageChangedEventCallbackDelegate);
1239                 }
1240             }
1241
1242             remove
1243             {
1244                 if (applicationTaskLanguageChangedEventHandler != null)
1245                 {
1246                     taskLanguageChangedSignal?.Disconnect(applicationTaskLanguageChangedEventCallbackDelegate);
1247                     taskLanguageChangedSignal?.Dispose();
1248                     taskLanguageChangedSignal = null;
1249                 }
1250
1251                 applicationTaskLanguageChangedEventHandler -= value;
1252             }
1253         }
1254
1255         private void OnNUIApplicationTaskLanguageChanged(IntPtr data)
1256         {
1257             if (applicationTaskLanguageChangedEventHandler != null)
1258             {
1259                 NUIApplicationLanguageChangedEventArgs e = new NUIApplicationLanguageChangedEventArgs();
1260                 e.Application = this;
1261                 applicationTaskLanguageChangedEventHandler.Invoke(this, e);
1262             }
1263         }
1264
1265         /// <summary>
1266         /// Event for TaskRegionChanged signal which can be used to subscribe/unsubscribe the event handler
1267         ///  provided by the user. TaskRegionChanged signal is emitted when the region of the device is changed.
1268         /// </summary>
1269         public event DaliEventHandler<object, NUIApplicationRegionChangedEventArgs> TaskRegionChanged
1270         {
1271             add
1272             {
1273                 // Restricted to only one listener
1274                 if (applicationTaskRegionChangedEventHandler == null)
1275                 {
1276                     applicationTaskRegionChangedEventHandler += value;
1277
1278                     applicationTaskRegionChangedEventCallbackDelegate = new NUIApplicationRegionChangedEventCallbackDelegate(OnNUIApplicationTaskRegionChanged);
1279                     taskRegionChangedSignal = this.TaskRegionChangedSignal();
1280                     taskRegionChangedSignal?.Connect(applicationTaskRegionChangedEventCallbackDelegate);
1281                 }
1282             }
1283
1284             remove
1285             {
1286                 if (applicationTaskRegionChangedEventHandler != null)
1287                 {
1288                     taskRegionChangedSignal?.Disconnect(applicationTaskRegionChangedEventCallbackDelegate);
1289                     taskRegionChangedSignal?.Dispose();
1290                     taskRegionChangedSignal = null;
1291                 }
1292
1293                 applicationTaskRegionChangedEventHandler -= value;
1294             }
1295         }
1296
1297         private void OnNUIApplicationTaskRegionChanged(IntPtr data)
1298         {
1299             if (applicationTaskRegionChangedEventHandler != null)
1300             {
1301                 NUIApplicationRegionChangedEventArgs e = new NUIApplicationRegionChangedEventArgs();
1302                 e.Application = this;
1303                 applicationTaskRegionChangedEventHandler.Invoke(this, e);
1304             }
1305         }
1306
1307         /// <summary>
1308         /// Event for TaskBatteryLow signal which can be used to subscribe/unsubscribe the event handler
1309         /// provided by the user. TaskBatteryLow signal is emitted when the battery level of the device is low.
1310         /// </summary>
1311         public event DaliEventHandler<object, NUIApplicationBatteryLowEventArgs> TaskBatteryLow
1312         {
1313             add
1314             {
1315                 // Restricted to only one listener
1316                 if (applicationTaskBatteryLowEventHandler == null)
1317                 {
1318                     applicationTaskBatteryLowEventHandler += value;
1319
1320                     applicationTaskBatteryLowEventCallbackDelegate = new NUIApplicationBatteryLowEventCallbackDelegate(OnNUIApplicationTaskBatteryLow);
1321                     taskBatteryLowSignal = this.TaskBatteryLowSignal();
1322                     taskBatteryLowSignal?.Connect(applicationTaskBatteryLowEventCallbackDelegate);
1323                 }
1324             }
1325
1326             remove
1327             {
1328                 if (applicationTaskBatteryLowEventHandler != null)
1329                 {
1330                     taskBatteryLowSignal?.Disconnect(applicationTaskBatteryLowEventCallbackDelegate);
1331                     taskBatteryLowSignal?.Dispose();
1332                     taskBatteryLowSignal = null;
1333                 }
1334
1335                 applicationTaskBatteryLowEventHandler -= value;
1336             }
1337         }
1338
1339         private void OnNUIApplicationTaskBatteryLow(BatteryStatus status)
1340         {
1341             NUIApplicationBatteryLowEventArgs e = new NUIApplicationBatteryLowEventArgs();
1342
1343             // Populate all members of "e" (NUIApplicationBatteryLowEventArgs) with real data
1344             e.BatteryStatus = status;
1345             applicationTaskBatteryLowEventHandler?.Invoke(this, e);
1346         }
1347
1348         /// <summary>
1349         /// Event for TaskMemoryLow signal which can be used to subscribe/unsubscribe the event handler
1350         /// provided by the user. TaskMemoryLow signal is emitted when the memory level of the device is low.
1351         /// </summary>
1352         public event DaliEventHandler<object, NUIApplicationMemoryLowEventArgs> TaskMemoryLow
1353         {
1354             add
1355             {
1356                 // Restricted to only one listener
1357                 if (applicationTaskMemoryLowEventHandler == null)
1358                 {
1359                     applicationTaskMemoryLowEventHandler += value;
1360
1361                     applicationTaskMemoryLowEventCallbackDelegate = new NUIApplicationMemoryLowEventCallbackDelegate(OnNUIApplicationTaskMemoryLow);
1362                     taskMemoryLowSignal = this.TaskMemoryLowSignal();
1363                     taskMemoryLowSignal?.Connect(applicationTaskMemoryLowEventCallbackDelegate);
1364                 }
1365             }
1366
1367             remove
1368             {
1369                 if (applicationTaskMemoryLowEventHandler != null)
1370                 {
1371                     taskMemoryLowSignal?.Disconnect(applicationTaskMemoryLowEventCallbackDelegate);
1372                     taskMemoryLowSignal?.Dispose();
1373                     taskMemoryLowSignal = null;
1374                 }
1375
1376                 applicationTaskMemoryLowEventHandler -= value;
1377             }
1378         }
1379
1380         private void OnNUIApplicationTaskMemoryLow(MemoryStatus status)
1381         {
1382             NUIApplicationMemoryLowEventArgs e = new NUIApplicationMemoryLowEventArgs();
1383
1384             // Populate all members of "e" (NUIApplicationMemoryLowEventArgs) with real data
1385             e.MemoryStatus = status;
1386             applicationTaskMemoryLowEventHandler?.Invoke(this, e);
1387         }
1388
1389         /// <summary>
1390         /// Event for TaskDeviceOrientationChanged signal which can be used to subscribe/unsubscribe the event handler
1391         /// provided by the user. TaskDeviceOrientationChanged signal is emitted when the device orientation is changed.
1392         /// </summary>
1393         public event DaliEventHandler<object, NUIApplicationDeviceOrientationChangedEventArgs> TaskDeviceOrientationChanged
1394         {
1395             add
1396             {
1397                 if (applicationTaskDeviceOrientationChangedEventHandler == null)
1398                 {
1399                     applicationTaskDeviceOrientationChangedEventHandler += value;
1400
1401                     applicationTaskDeviceOrientationChangedEventCallback = new NUIApplicationDeviceOrientationChangedEventCallback(OnNUIApplicationTaskDeviceOrientationChanged);
1402                     taskDeviceOrientationChangedSignal = this.TaskDeviceOrientationChangedSignal();
1403                     taskDeviceOrientationChangedSignal?.Connect(applicationTaskDeviceOrientationChangedEventCallback);
1404                 }
1405             }
1406
1407             remove
1408             {
1409                 if (applicationTaskDeviceOrientationChangedEventHandler != null)
1410                 {
1411                     taskDeviceOrientationChangedSignal?.Disconnect(applicationTaskDeviceOrientationChangedEventCallback);
1412                     taskDeviceOrientationChangedSignal?.Dispose();
1413                     taskDeviceOrientationChangedSignal = null;
1414                 }
1415
1416                 applicationTaskDeviceOrientationChangedEventHandler -= value;
1417             }
1418         }
1419
1420         private void OnNUIApplicationTaskDeviceOrientationChanged(DeviceOrientationStatus status)
1421         {
1422             NUIApplicationDeviceOrientationChangedEventArgs e = new NUIApplicationDeviceOrientationChangedEventArgs();
1423
1424             e.DeviceOrientationStatus = status;
1425             applicationTaskDeviceOrientationChangedEventHandler?.Invoke(this, e);
1426         }
1427
1428         /// <summary>
1429         /// Event for TaskAppControl signal which can be used to subscribe/unsubscribe the event handler
1430         /// provided by the user. TaskAppControl signal is emitted when another application sends a launch request to the application.
1431         /// </summary>
1432         public event DaliEventHandler<object, NUIApplicationAppControlEventArgs> TaskAppControl
1433         {
1434             add
1435             {
1436                 // Restricted to only one listener
1437                 if (applicationTaskAppControlEventHandler == null)
1438                 {
1439                     applicationTaskAppControlEventHandler += value;
1440
1441                     applicationTaskAppControlEventCallbackDelegate = new NUIApplicationAppControlEventCallbackDelegate(OnNUIApplicationTaskAppControl);
1442                     taskAppControlSignal = this.TaskAppControlSignal();
1443                     taskAppControlSignal?.Connect(applicationTaskAppControlEventCallbackDelegate);
1444                 }
1445             }
1446
1447             remove
1448             {
1449                 if (applicationTaskAppControlEventHandler != null)
1450                 {
1451                     taskAppControlSignal?.Disconnect(applicationTaskAppControlEventCallbackDelegate);
1452                     taskAppControlSignal?.Dispose();
1453                     taskAppControlSignal = null;
1454                 }
1455
1456                 applicationTaskAppControlEventHandler -= value;
1457             }
1458         }
1459
1460         private void OnNUIApplicationTaskAppControl(IntPtr application, IntPtr voidp)
1461         {
1462             if (applicationTaskAppControlEventHandler != null)
1463             {
1464                 NUIApplicationAppControlEventArgs e = new NUIApplicationAppControlEventArgs();
1465                 e.VoidP = voidp;
1466                 e.Application = this;
1467                 applicationTaskAppControlEventHandler.Invoke(this, e);
1468             }
1469         }
1470
1471         protected static Application instance; // singleton
1472
1473         public static Application Instance
1474         {
1475             get
1476             {
1477                 return instance;
1478             }
1479         }
1480
1481         public static Application GetApplicationFromPtr(global::System.IntPtr cPtr)
1482         {
1483             if (cPtr == global::System.IntPtr.Zero)
1484             {
1485                 return null;
1486             }
1487
1488             Application ret = Registry.GetManagedBaseHandleFromNativePtr(cPtr) as Application;
1489             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1490             return ret;
1491         }
1492
1493         public static Application NewApplication()
1494         {
1495             return NewApplication("", NUIApplication.WindowMode.Opaque);
1496         }
1497
1498         public static Application NewApplication(string stylesheet)
1499         {
1500             return NewApplication(stylesheet, NUIApplication.WindowMode.Opaque);
1501         }
1502
1503         public static Application NewApplication(string stylesheet, NUIApplication.WindowMode windowMode)
1504         {
1505             // register all Views with the type registry, so that can be created / styled via JSON
1506             //ViewRegistryHelper.Initialize(); //moved to Application side.
1507             if (instance != null)
1508             {
1509                 return instance;
1510             }
1511
1512             Application ret = New(1, stylesheet, windowMode);
1513             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1514
1515             // set the singleton
1516             instance = ret;
1517             return ret;
1518         }
1519
1520         public static Application NewApplication(string stylesheet, NUIApplication.WindowMode windowMode, Rectangle positionSize)
1521         {
1522             if (instance != null)
1523             {
1524                 return instance;
1525             }
1526             Application ret = New(1, stylesheet, windowMode, positionSize);
1527             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1528
1529             // set the singleton
1530             instance = ret;
1531             return ret;
1532         }
1533
1534         public static Application NewApplication(string[] args, string stylesheet, NUIApplication.WindowMode windowMode)
1535         {
1536             if (instance != null)
1537             {
1538                 return instance;
1539             }
1540             Application ret = New(args, stylesheet, windowMode);
1541             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1542
1543             // set the singleton
1544             instance = ret;
1545             return instance;
1546         }
1547
1548         public static Application NewApplication(string[] args, string stylesheet, NUIApplication.WindowMode windowMode, Rectangle positionSize)
1549         {
1550             if (instance != null)
1551             {
1552                 return instance;
1553             }
1554             Application ret = New(args, stylesheet, windowMode, positionSize);
1555             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1556
1557             // set the singleton
1558             instance = ret;
1559             return instance;
1560         }
1561
1562         public static Application NewApplication(string[] args, string stylesheet, NUIApplication.WindowMode windowMode, WindowType type)
1563         {
1564             if (instance != null)
1565             {
1566                 return instance;
1567             }
1568             Application ret = New(args, stylesheet, windowMode, type);
1569             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1570
1571             instance = ret;
1572             return instance;
1573         }
1574
1575         public static Application NewApplication(string[] args, string stylesheet, NUIApplication.WindowMode windowMode, Rectangle positionSize, bool useUIThread)
1576         {
1577             if (instance != null)
1578             {
1579                 return instance;
1580             }
1581             Application ret = New(args, stylesheet, windowMode, positionSize, useUIThread);
1582             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1583
1584             instance = ret;
1585             return instance;
1586         }
1587
1588         public static Application NewApplication(string[] args, string stylesheet, bool useUIThread, WindowData windowData)
1589         {
1590             if (instance != null)
1591             {
1592                 return instance;
1593             }
1594             Application ret = New(args, stylesheet, useUIThread, windowData);
1595             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1596
1597             instance = ret;
1598             return instance;
1599         }
1600
1601         /// <summary>
1602         /// Ensures that the function passed in is called from the main loop when it is idle.
1603         /// </summary>
1604         /// <param name="func">The function to call</param>
1605         /// <returns>true if added successfully, false otherwise</returns>
1606         /// <remarks>
1607         /// It will return false when one of the following conditions is met.
1608         /// 1) the <see cref="Window"/> is hidden.
1609         /// 2) the <see cref="Window"/> is iconified.
1610         /// </remarks>
1611         public bool AddIdle(System.Delegate func)
1612         {
1613             System.IntPtr ip = System.Runtime.InteropServices.Marshal.GetFunctionPointerForDelegate<System.Delegate>(func);
1614             System.IntPtr ip2 = Interop.Application.MakeCallback(new System.Runtime.InteropServices.HandleRef(this, ip));
1615
1616             bool ret = Interop.Application.AddIdle(SwigCPtr, new System.Runtime.InteropServices.HandleRef(this, ip2));
1617
1618             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1619             return ret;
1620         }
1621
1622         /**
1623         * Outer::outer_method(int)
1624         */
1625         public static Application New()
1626         {
1627             Application ret = new Application(Interop.Application.New(), true);
1628             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1629             return ret;
1630         }
1631
1632         public static Application New(int argc)
1633         {
1634             Application ret = new Application(Interop.Application.New(argc), true);
1635             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1636             return ret;
1637         }
1638
1639         public static Application New(int argc, string stylesheet)
1640         {
1641             Application ret = new Application(Interop.Application.New(argc, stylesheet), true);
1642             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1643             return ret;
1644         }
1645
1646         public static Application New(int argc, string stylesheet, NUIApplication.WindowMode windowMode)
1647         {
1648             Application ret = new Application(Interop.Application.New(argc, stylesheet, (int)windowMode), true);
1649             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1650             s_current = ret;
1651             return ret;
1652         }
1653
1654         public static Application New(string[] args, string stylesheet, NUIApplication.WindowMode windowMode)
1655         {
1656             Application ret = null;
1657             int argc = 0;
1658             string argvStr = "";
1659             try
1660             {
1661                 argc = args.Length;
1662                 argvStr = string.Join(" ", args);
1663             }
1664             catch (Exception exception)
1665             {
1666                 Tizen.Log.Fatal("NUI", "[Error] got exception during Application New(), this should not occur, message : " + exception.Message);
1667                 Tizen.Log.Fatal("NUI", "[Error] error line number : " + new StackTrace(exception, true).GetFrame(0).GetFileLineNumber());
1668                 Tizen.Log.Fatal("NUI", "[Error] Stack Trace : " + exception.StackTrace);
1669                 throw;
1670             }
1671
1672             ret = new Application(NDalicPINVOKE.ApplicationNewManual4(argc, argvStr, stylesheet, (int)windowMode), true);
1673             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1674
1675             return ret;
1676         }
1677
1678         public static Application New(int argc, string stylesheet, NUIApplication.WindowMode windowMode, Rectangle positionSize)
1679         {
1680             Application ret = new Application(Interop.Application.New(argc, stylesheet, (int)windowMode, Rectangle.getCPtr(positionSize)), true);
1681             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1682             return ret;
1683         }
1684
1685         public static Application New(string[] args, string stylesheet, NUIApplication.WindowMode windowMode, Rectangle positionSize)
1686         {
1687             Application ret = null;
1688             int argc = 0;
1689             string argvStr = "";
1690             try
1691             {
1692                 argc = args.Length;
1693                 argvStr = string.Join(" ", args);
1694             }
1695             catch (Exception exception)
1696             {
1697                 Tizen.Log.Fatal("NUI", "[Error] got exception during Application New(), this should not occur, message : " + exception.Message);
1698                 Tizen.Log.Fatal("NUI", "[Error] error line number : " + new StackTrace(exception, true).GetFrame(0).GetFileLineNumber());
1699                 Tizen.Log.Fatal("NUI", "[Error] Stack Trace : " + exception.StackTrace);
1700                 throw;
1701             }
1702
1703             ret = new Application(NDalicPINVOKE.ApplicationNewWithWindowSizePosition(argc, argvStr, stylesheet, (int)windowMode, Rectangle.getCPtr(positionSize)), true);
1704             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1705
1706             return ret;
1707         }
1708
1709         public static Application New(string[] args, string stylesheet, NUIApplication.WindowMode windowMode, WindowType type)
1710         {
1711             int argc = 0;
1712             string argvStr = "";
1713             try
1714             {
1715                 argc = args.Length;
1716                 argvStr = string.Join(" ", args);
1717             }
1718             catch (Exception exception)
1719             {
1720                 Tizen.Log.Fatal("NUI", "[Error] got exception during Application New(), this should not occur, message : " + exception.Message);
1721                 Tizen.Log.Fatal("NUI", "[Error] error line number : " + new StackTrace(exception, true).GetFrame(0).GetFileLineNumber());
1722                 Tizen.Log.Fatal("NUI", "[Error] Stack Trace : " + exception.StackTrace);
1723                 throw;
1724             }
1725
1726             // It will be removed until dali APIs are prepared.
1727             Rectangle initRectangle = new Rectangle(0, 0, 0, 0);
1728
1729             Application ret = new Application(Interop.Application.New(argc, argvStr, stylesheet, (int)windowMode, Rectangle.getCPtr(initRectangle), (int)type), true);
1730             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1731             return ret;
1732         }
1733
1734         public static Application New(string[] args, string stylesheet, NUIApplication.WindowMode windowMode, Rectangle positionSize, bool useUIThread)
1735         {
1736             Application ret = null;
1737             int argc = 0;
1738             string argvStr = "";
1739             try
1740             {
1741                 argc = args.Length;
1742                 argvStr = string.Join(" ", args);
1743
1744                 ret = new Application(Interop.Application.New(argc, argvStr, stylesheet, (int)windowMode, Rectangle.getCPtr(positionSize), useUIThread), true);
1745                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1746             }
1747             catch (Exception exception)
1748             {
1749                 Tizen.Log.Fatal("NUI", "[Error] got exception during Application New(), this should not occur, message : " + exception.Message);
1750                 Tizen.Log.Fatal("NUI", "[Error] error line number : " + new StackTrace(exception, true).GetFrame(0).GetFileLineNumber());
1751                 Tizen.Log.Fatal("NUI", "[Error] Stack Trace : " + exception.StackTrace);
1752                 throw;
1753             }
1754
1755             return ret;
1756         }
1757
1758         public static Application New(string[] args, string stylesheet, bool useUIThread, WindowData windowData)
1759         {
1760             Application ret = null;
1761             int argc = 0;
1762             string argvStr = "";
1763             try
1764             {
1765                 argc = args.Length;
1766                 argvStr = string.Join(" ", args);
1767
1768                 ret = new Application(Interop.Application.New(argc, argvStr, stylesheet, useUIThread, WindowData.getCPtr(windowData)), true);
1769                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1770             }
1771             catch (Exception exception)
1772             {
1773                 Tizen.Log.Fatal("NUI", "[Error] got exception during Application New(), this should not occur, message : " + exception.Message);
1774                 Tizen.Log.Fatal("NUI", "[Error] error line number : " + new StackTrace(exception, true).GetFrame(0).GetFileLineNumber());
1775                 Tizen.Log.Fatal("NUI", "[Error] Stack Trace : " + exception.StackTrace);
1776                 throw;
1777             }
1778
1779             return ret;
1780         }
1781
1782         public Application() : this(Interop.Application.NewApplication(), true)
1783         {
1784             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1785         }
1786
1787         public Application(Application application) : this(Interop.Application.NewApplication(Application.getCPtr(application)), true)
1788         {
1789             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1790         }
1791
1792         public Application Assign(Application application)
1793         {
1794             Application ret = new Application(Interop.Application.Assign(SwigCPtr, Application.getCPtr(application)), false);
1795             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1796             return ret;
1797         }
1798
1799         public void MainLoop()
1800         {
1801             NDalicPINVOKE.ApplicationMainLoop(SwigCPtr);
1802             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1803         }
1804
1805         public void Lower()
1806         {
1807             Interop.Application.Lower(SwigCPtr);
1808             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1809         }
1810
1811         public void Quit()
1812         {
1813             Interop.Application.Quit(SwigCPtr);
1814             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1815         }
1816
1817         internal bool AddIdle(SWIGTYPE_p_Dali__CallbackBase callback)
1818         {
1819             bool ret = Interop.Application.AddIdle(SwigCPtr, SWIGTYPE_p_Dali__CallbackBase.getCPtr(callback));
1820             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1821             return ret;
1822         }
1823
1824         public Window GetWindow()
1825         {
1826             if (window != null)
1827             {
1828                 return window;
1829             }
1830
1831             var nativeWindow = Interop.Application.GetWindow(SwigCPtr);
1832             window = Registry.GetManagedBaseHandleFromNativePtr(nativeWindow) as Window;
1833             if (window != null)
1834             {
1835                 HandleRef CPtr = new HandleRef(this, nativeWindow);
1836                 Interop.BaseHandle.DeleteBaseHandle(CPtr);
1837                 CPtr = new HandleRef(null, IntPtr.Zero);
1838             }
1839             else
1840             {
1841                 window = new Window(nativeWindow, true);
1842             }
1843
1844             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1845             return window;
1846         }
1847
1848         public static string GetResourcePath()
1849         {
1850             string ret = Interop.Application.GetResourcePath();
1851             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1852             return ret;
1853         }
1854
1855         public string GetLanguage()
1856         {
1857             string ret = Interop.Application.GetLanguage(SwigCPtr);
1858             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1859             return ret;
1860         }
1861
1862         public string GetRegion()
1863         {
1864             string ret = Interop.Application.GetRegion(SwigCPtr);
1865             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1866             return ret;
1867         }
1868
1869         public void FlushUpdateMessages()
1870         {
1871             Interop.Application.FlushUpdateMessages(SwigCPtr);
1872             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1873         }
1874
1875         [EditorBrowsable(EditorBrowsableState.Never)]
1876         public static List<Window> GetWindowList()
1877         {
1878             if (Interop.Stage.IsInstalled() == false)
1879             {
1880                 NUILog.ErrorBacktrace($"[ERROR] dali adaptor and dali window is not ready. just return NULL here");
1881                 return null;
1882             }
1883
1884             uint ListSize = Interop.Application.GetWindowsListSize();
1885             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1886
1887             List<Window> WindowList = new List<Window>();
1888             for (uint i = 0; i < ListSize; ++i)
1889             {
1890                 Window currWin = WindowList.GetInstanceSafely<Window>(Interop.Application.GetWindowsFromList(i));
1891                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1892                 if (currWin != null)
1893                 {
1894                     WindowList.Add(currWin);
1895                 }
1896             }
1897             return WindowList;
1898         }
1899
1900         internal ApplicationSignal InitSignal()
1901         {
1902             ApplicationSignal ret = new ApplicationSignal(NDalicPINVOKE.ApplicationInitSignal(SwigCPtr), false);
1903             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1904             return ret;
1905         }
1906
1907         internal ApplicationSignal TerminateSignal()
1908         {
1909             ApplicationSignal ret = new ApplicationSignal(NDalicPINVOKE.ApplicationTerminateSignal(SwigCPtr), false);
1910             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1911             return ret;
1912         }
1913
1914         internal ApplicationSignal PauseSignal()
1915         {
1916             ApplicationSignal ret = new ApplicationSignal(NDalicPINVOKE.ApplicationPauseSignal(SwigCPtr), false);
1917             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1918             return ret;
1919         }
1920
1921         internal ApplicationSignal ResumeSignal()
1922         {
1923             ApplicationSignal ret = new ApplicationSignal(NDalicPINVOKE.ApplicationResumeSignal(SwigCPtr), false);
1924             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1925             return ret;
1926         }
1927
1928         internal ApplicationSignal ResetSignal()
1929         {
1930             ApplicationSignal ret = new ApplicationSignal(NDalicPINVOKE.ApplicationResetSignal(SwigCPtr), false);
1931             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1932             return ret;
1933         }
1934
1935         internal ApplicationControlSignal AppControlSignal()
1936         {
1937             ApplicationControlSignal ret = new ApplicationControlSignal(NDalicPINVOKE.ApplicationAppControlSignal(SwigCPtr), false);
1938             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1939             return ret;
1940         }
1941
1942         internal ApplicationSignal LanguageChangedSignal()
1943         {
1944             ApplicationSignal ret = new ApplicationSignal(NDalicPINVOKE.ApplicationLanguageChangedSignal(SwigCPtr), false);
1945             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1946             return ret;
1947         }
1948
1949         internal ApplicationSignal RegionChangedSignal()
1950         {
1951             ApplicationSignal ret = new ApplicationSignal(NDalicPINVOKE.ApplicationRegionChangedSignal(SwigCPtr), false);
1952             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1953             return ret;
1954         }
1955
1956         internal LowBatterySignalType BatteryLowSignal()
1957         {
1958             LowBatterySignalType ret = new LowBatterySignalType(NDalicPINVOKE.ApplicationLowBatterySignal(SwigCPtr), false);
1959             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1960             return ret;
1961         }
1962
1963         internal LowMemorySignalType MemoryLowSignal()
1964         {
1965             LowMemorySignalType ret = new LowMemorySignalType(NDalicPINVOKE.ApplicationLowMemorySignal(SwigCPtr), false);
1966             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1967             return ret;
1968         }
1969
1970         internal DeviceOrientationChangedSignalType DeviceOrientationChangedSignal()
1971         {
1972             DeviceOrientationChangedSignalType ret = new DeviceOrientationChangedSignalType(NDalicPINVOKE.ApplicationDeviceOrientationChangedSignal(SwigCPtr), false);
1973             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1974             return ret;
1975         }
1976
1977         //Task
1978         internal ApplicationSignal TaskInitSignal()
1979         {
1980             ApplicationSignal ret = new ApplicationSignal(NDalicPINVOKE.ApplicationTaskInitSignal(SwigCPtr), false);
1981             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1982             return ret;
1983         }
1984
1985         internal ApplicationSignal TaskTerminateSignal()
1986         {
1987             ApplicationSignal ret = new ApplicationSignal(NDalicPINVOKE.ApplicationTaskTerminateSignal(SwigCPtr), false);
1988             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1989             return ret;
1990         }
1991
1992         internal ApplicationControlSignal TaskAppControlSignal()
1993         {
1994             ApplicationControlSignal ret = new ApplicationControlSignal(NDalicPINVOKE.ApplicationTaskAppControlSignal(SwigCPtr), false);
1995             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1996             return ret;
1997         }
1998
1999         internal ApplicationSignal TaskLanguageChangedSignal()
2000         {
2001             ApplicationSignal ret = new ApplicationSignal(NDalicPINVOKE.ApplicationTaskLanguageChangedSignal(SwigCPtr), false);
2002             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2003             return ret;
2004         }
2005
2006         internal ApplicationSignal TaskRegionChangedSignal()
2007         {
2008             ApplicationSignal ret = new ApplicationSignal(NDalicPINVOKE.ApplicationTaskRegionChangedSignal(SwigCPtr), false);
2009             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2010             return ret;
2011         }
2012
2013         internal LowBatterySignalType TaskBatteryLowSignal()
2014         {
2015             LowBatterySignalType ret = new LowBatterySignalType(NDalicPINVOKE.ApplicationTaskLowBatterySignal(SwigCPtr), false);
2016             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2017             return ret;
2018         }
2019
2020         internal LowMemorySignalType TaskMemoryLowSignal()
2021         {
2022             LowMemorySignalType ret = new LowMemorySignalType(NDalicPINVOKE.ApplicationTaskLowMemorySignal(SwigCPtr), false);
2023             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2024             return ret;
2025         }
2026
2027         internal DeviceOrientationChangedSignalType TaskDeviceOrientationChangedSignal()
2028         {
2029             DeviceOrientationChangedSignalType ret = new DeviceOrientationChangedSignalType(NDalicPINVOKE.ApplicationTaskDeviceOrientationChangedSignal(SwigCPtr), false);
2030             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2031             return ret;
2032         }
2033     }
2034 }