src/Tizen.NUI/src/internal/NUICoreBackend.cs

   1 /*
   2  * Copyright (c) 2018 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
  18 using System;
  19 using System.Collections.Generic;
  20
  21 using Tizen.Applications.CoreBackend;
  22 using Tizen.Applications;
  23
  24 namespace Tizen.NUI
  25 {
  26     class NUICoreBackend : ICoreBackend
  27     {
  28         /// <summary>
  29         /// The Application instance to connect event.
  30         /// </summary>
  31         protected Application _application;
  32         private string _stylesheet = "";
  33         private NUIApplication.WindowMode _windowMode = NUIApplication.WindowMode.Opaque;
  34
  35         /// <summary>
  36         /// The Dictionary to contain each type of event callback.
  37         /// </summary>
  38         protected IDictionary<EventType, object> Handlers = new Dictionary<EventType, object>();
  39
  40         /// <summary>
  41         /// The default Constructor.
  42         /// </summary>
  43         public NUICoreBackend()
  44         {
  45         }
  46
  47         /// <summary>
  48         /// The constructor with stylesheet.
  49         /// </summary>
  50         public NUICoreBackend(string stylesheet)
  51         {
  52             _stylesheet = stylesheet;
  53         }
  54
  55         /// <summary>
  56         /// The constructor with stylesheet and window mode.
  57         /// </summary>
  58         public NUICoreBackend(string stylesheet, NUIApplication.WindowMode windowMode)
  59         {
  60             _stylesheet = stylesheet;
  61             _windowMode = windowMode;
  62         }
  63
  64         /// <summary>
  65         /// Adds NUIApplication event to Application.
  66         /// Puts each type of event callback in Dictionary.
  67         /// </summary>
  68         /// <param name="evType">The type of event.</param>
  69         /// <param name="handler">The event callback.</param>
  70         public void AddEventHandler(EventType evType, Action handler)
  71         {
  72             Handlers.Add(evType, handler);
  73         }
  74
  75         /// <summary>
  76         /// Adds NUIApplication event to Application.
  77         /// Puts each type of event callback in Dictionary.
  78         /// </summary>
  79         /// <typeparam name="TEventArgs">The argument type for the event.</typeparam>
  80         /// <param name="evType">The type of event.</param>
  81         /// <param name="handler">The event callback.</param>
  82         public void AddEventHandler<TEventArgs>(EventType evType, Action<TEventArgs> handler) where TEventArgs : EventArgs
  83         {
  84             Handlers.Add(evType, handler);
  85         }
  86
  87
  88         /// <summary>
  89         /// The Dispose function.
  90         /// </summary>
  91         public void Dispose()
  92         {
  93             if(_application != null)
  94             {
  95                 _application.Dispose();
  96             }
  97         }
  98
  99         /// <summary>
 100         /// The Exit application.
 101         /// </summary>
 102         public void Exit()
 103         {
 104             if(_application != null)
 105             {
 106                 _application.Quit();
 107             }
 108         }
 109
 110         /// <summary>
 111         /// Ensures that the function passed in is called from the main loop when it is idle.
 112         /// </summary>
 113         /// <param name="func">The function to call</param>
 114         /// <returns>true if added successfully, false otherwise</returns>
 115         public bool AddIdle(System.Delegate func)
 116         {
 117             return _application.AddIdle(func);
 118         }
 119
 120         /// <summary>
 121         /// The Run application.
 122         /// </summary>
 123         /// <param name="args">The arguments from commandline.</param>
 124         public void Run(string[] args)
 125         {
 126             TizenSynchronizationContext.Initialize();
 127
 128             args[0] = Tizen.Applications.Application.Current.ApplicationInfo.ExecutablePath;
 129             if (args.Length == 1)
 130             {
 131                 _application = Application.NewApplication();
 132             }
 133             else if (args.Length > 1)
 134             {
 135                 _application = Application.NewApplication(args, _stylesheet, (Application.WindowMode)_windowMode);
 136             }
 137
 138             _application.BatteryLow += OnBatteryLow;
 139             _application.LanguageChanged += OnLanguageChanged;
 140             _application.MemoryLow += OnMemoryLow;
 141             _application.RegionChanged += OnRegionChanged;
 142
 143             _application.Initialized += OnInitialized;
 144             _application.Resumed += OnResumed;
 145             _application.Terminating += OnTerminated;
 146             _application.Paused += OnPaused;
 147             _application.AppControl += OnAppControl;
 148
 149             _application.MainLoop();
 150
 151             _application.Dispose();
 152
 153         }
 154
 155         /// <summary>
 156         /// The Region changed event callback function.
 157         /// </summary>
 158         /// <param name="source">The application instance.</param>
 159         /// <param name="e">The event argument for RegionChanged.</param>
 160         private void OnRegionChanged(object source, NUIApplicationRegionChangedEventArgs e)
 161         {
 162             Log.Info("NUI", "NUICorebackend OnRegionChanged Called");
 163             var handler = Handlers[EventType.RegionFormatChanged] as Action<RegionFormatChangedEventArgs>;
 164             handler?.Invoke( new RegionFormatChangedEventArgs((source as Application)?.GetRegion()));
 165         }
 166
 167         /// <summary>
 168         /// The Memory Low event callback function.
 169         /// </summary>
 170         /// <param name="source">The application instance.</param>
 171         /// <param name="e">The event argument for MemoryLow.</param>
 172         private void OnMemoryLow(object source, NUIApplicationMemoryLowEventArgs e)
 173         {
 174             Log.Info("NUI", "NUICorebackend OnMemoryLow Called");
 175             var handler = Handlers[EventType.LowMemory] as Action<LowMemoryEventArgs>;
 176
 177             switch ( e.MemoryStatus )
 178             {
 179                 case Application.MemoryStatus.Normal:
 180                 {
 181                     handler?.Invoke( new LowMemoryEventArgs(LowMemoryStatus.None));
 182                     break;
 183                 }
 184                 case Application.MemoryStatus.Low:
 185                 {
 186                     handler?.Invoke(new LowMemoryEventArgs(LowMemoryStatus.SoftWarning));
 187                     break;
 188                 }
 189                 case Application.MemoryStatus.CriticallyLow:
 190                 {
 191                     handler?.Invoke(new LowMemoryEventArgs(LowMemoryStatus.HardWarning));
 192                     break;
 193                 }
 194             }
 195         }
 196
 197         /// <summary>
 198         /// The Language changed event callback function.
 199         /// </summary>
 200         /// <param name="source">The application instance.</param>
 201         /// <param name="e">The event argument for LanguageChanged.</param>
 202         private void OnLanguageChanged(object source, NUIApplicationLanguageChangedEventArgs e)
 203         {
 204             Log.Info("NUI", "NUICorebackend OnLanguageChanged Called");
 205             var handler = Handlers[EventType.LocaleChanged] as Action<LocaleChangedEventArgs>;
 206             handler?.Invoke( new LocaleChangedEventArgs((source as Application)?.GetLanguage()));
 207         }
 208
 209         /// <summary>
 210         /// The Battery Low event callback function.
 211         /// </summary>
 212         /// <param name="source">The application instance.</param>
 213         /// <param name="e">The event argument for BatteryLow.</param>
 214         private void OnBatteryLow(object source, NUIApplicationBatteryLowEventArgs e)
 215         {
 216             Log.Info("NUI", "NUICorebackend OnBatteryLow Called");
 217             var handler = Handlers[EventType.LowBattery] as Action<LowBatteryEventArgs>;
 218             switch( e.BatteryStatus )
 219             {
 220                 case Application.BatteryStatus.Normal:
 221                 {
 222                     handler?.Invoke(new LowBatteryEventArgs(LowBatteryStatus.None));
 223                     break;
 224                 }
 225                 case Application.BatteryStatus.CriticallyLow:
 226                 {
 227                     handler?.Invoke(new LowBatteryEventArgs(LowBatteryStatus.CriticalLow));
 228                     break;
 229                 }
 230                 case Application.BatteryStatus.PowerOff:
 231                 {
 232                     handler?.Invoke(new LowBatteryEventArgs(LowBatteryStatus.PowerOff));
 233                     break;
 234                 }
 235             }
 236         }
 237
 238         /// <summary>
 239         /// The Initialized event callback function.
 240         /// </summary>
 241         /// <param name="source">The application instance.</param>
 242         /// <param name="e">The event argument for Initialized.</param>
 243         private void OnInitialized(object source, NUIApplicationInitEventArgs e)
 244         {
 245             Log.Info("NUI", "NUICorebackend OnPreCreated Called");
 246             var preCreateHandler = Handlers[EventType.PreCreated] as Action;
 247             preCreateHandler?.Invoke();
 248
 249             Log.Info("NUI", "NUICorebackend OnCreate Called");
 250             var createHandler = Handlers[EventType.Created] as Action;
 251             createHandler?.Invoke();
 252         }
 253
 254         /// <summary>
 255         /// The Terminated event callback function.
 256         /// </summary>
 257         /// <param name="source">The application instance.</param>
 258         /// <param name="e">The event argument for Terminated.</param>
 259         private void OnTerminated(object source, NUIApplicationTerminatingEventArgs e)
 260         {
 261             Log.Info("NUI", "NUICorebackend OnTerminated Called");
 262             var handler = Handlers[EventType.Terminated] as Action;
 263             handler?.Invoke();
 264         }
 265
 266         /// <summary>
 267         /// The Resumed event callback function.
 268         /// </summary>
 269         /// <param name="source">The application instance.</param>
 270         /// <param name="e">The event argument for Resumed.</param>
 271         private void OnResumed(object source, NUIApplicationResumedEventArgs e)
 272         {
 273             Log.Info("NUI", "NUICorebackend OnResumed Called");
 274             var handler = Handlers[EventType.Resumed] as Action;
 275             handler?.Invoke();
 276         }
 277
 278         /// <summary>
 279         /// The App control event callback function.
 280         /// </summary>
 281         /// <param name="source">The application instance.</param>
 282         /// <param name="e">The event argument for AppControl.</param>
 283         private void OnAppControl(object source, NUIApplicationAppControlEventArgs e)
 284         {
 285             Log.Info("NUI", "NUICorebackend OnAppControl Called");
 286             var handler = Handlers[EventType.AppControlReceived] as Action<AppControlReceivedEventArgs>;
 287             SafeAppControlHandle handle = new SafeAppControlHandle(e.VoidP,false);
 288             handler?.Invoke( new AppControlReceivedEventArgs(new ReceivedAppControl(handle)) );
 289         }
 290
 291         /// <summary>
 292         /// The Paused event callback function.
 293         /// </summary>
 294         /// <param name="source">The application instance.</param>
 295         /// <param name="e">The event argument for Paused.</param>
 296         private void OnPaused(object source, NUIApplicationPausedEventArgs e)
 297         {
 298             Log.Info("NUI", "NUICorebackend OnPaused Called");
 299             var handler = Handlers[EventType.Paused] as Action;
 300             handler?.Invoke();
 301         }
 302
 303
 304         internal Application ApplicationHandle
 305         {
 306                 get
 307                 {
 308                         return _application;
 309                 }
 310         }
 311
 312     }
 313 }