src/Tizen.NUI/src/internal/WatchApplication.cs

   1 /*
   2  * Copyright (c) 2017 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.Runtime.InteropServices;
  20 namespace Tizen.NUI
  21 {
  22     internal class WatchApplication : Application
  23     {
  24         private global::System.Runtime.InteropServices.HandleRef swigCPtr;
  25
  26         internal WatchApplication(global::System.IntPtr cPtr, bool cMemoryOwn) : base(cPtr, cMemoryOwn)
  27         {
  28             swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
  29         }
  30
  31         internal static global::System.Runtime.InteropServices.HandleRef getCPtr(WatchApplication obj)
  32         {
  33             return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
  34         }
  35
  36         protected virtual void Dispose(DisposeTypes type)
  37         {
  38             if (disposed)
  39             {
  40                 return;
  41             }
  42
  43             if (type == DisposeTypes.Explicit)
  44             {
  45                 //Called by User
  46                 //Release your own managed resources here.
  47                 //You should release all of your own disposable objects here.
  48
  49             }
  50
  51             //Release your own unmanaged resources here.
  52             //You should not access any managed member here except static instance.
  53             //because the execution order of Finalizes is non-deterministic.
  54             DisConnectFromSignals();
  55
  56             if (swigCPtr.Handle != global::System.IntPtr.Zero)
  57             {
  58                 if (swigCMemOwn)
  59                 {
  60                     swigCMemOwn = false;
  61                     NDalicManualPINVOKE.delete_WatchApplication(swigCPtr);
  62                 }
  63                 swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
  64             }
  65
  66             base.Dispose(type);
  67         }
  68
  69         private void DisConnectFromSignals()
  70         {
  71             if (_timeTickCallback != null)
  72             {
  73                 this.TimeTickSignal().Disconnect(_timeTickCallback);
  74             }
  75             if (_ambientTickCallback != null)
  76             {
  77                 this.AmbientTickSignal().Disconnect(_ambientTickCallback);
  78             }
  79             if (_ambientChangedCallback != null)
  80             {
  81                 this.AmbientChangedSignal().Disconnect(_ambientChangedCallback);
  82             }
  83         }
  84
  85         public static WatchApplication Instance
  86         {
  87             get
  88             {
  89                 return _instance;
  90             }
  91         }
  92
  93         public static WatchApplication NewWatchApplication()
  94         {
  95             WatchApplication ret = New();
  96             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
  97             // we've got an application now connect the signals
  98             _instance = ret;
  99             return ret;
 100         }
 101
 102         public static WatchApplication NewWatchApplication(string[] args)
 103         {
 104             WatchApplication ret = New(args);
 105             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 106             _instance = ret;
 107             return ret;
 108         }
 109
 110         public static WatchApplication NewWatchApplication(string[] args, string stylesheet)
 111         {
 112             WatchApplication ret = New(args, stylesheet);
 113             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 114             _instance = ret;
 115             return ret;
 116         }
 117
 118         public new static WatchApplication New()
 119         {
 120             WatchApplication ret = new WatchApplication(NDalicManualPINVOKE.WatchApplication_New__SWIG_0(), true);
 121             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 122             return ret;
 123         }
 124
 125         public static WatchApplication New(string[] args)
 126         {
 127             int argc = args.Length;
 128             string argvStr = string.Join(" ", args);
 129
 130             WatchApplication ret = new WatchApplication(NDalicManualPINVOKE.WatchApplication_New__SWIG_1(argc, argvStr), true);
 131             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 132             return ret;
 133         }
 134
 135         public static WatchApplication New(string[] args, string stylesheet)
 136         {
 137             int argc = args.Length;
 138             string argvStr = string.Join(" ", args);
 139
 140             WatchApplication ret = new WatchApplication(NDalicManualPINVOKE.WatchApplication_New__SWIG_2(argc, argvStr, stylesheet), true);
 141             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 142             return ret;
 143         }
 144
 145         internal WatchApplication(WatchApplication implementation) : this(NDalicManualPINVOKE.new_WatchApplication__SWIG_1(WatchApplication.getCPtr(implementation)), true)
 146         {
 147             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 148         }
 149
 150         /// <summary>
 151         /// Event arguments that passed via time tick event signal.
 152         /// </summary>
 153         public class TimeTickEventArgs : EventArgs
 154         {
 155             /// <summary>
 156             /// Application.
 157             /// </summary>
 158             public Application Application
 159             {
 160                 get;
 161                 set;
 162             }
 163
 164             /// <summary>
 165             /// WatchTime.
 166             /// </summary>
 167             public WatchTime WatchTime
 168             {
 169                 get;
 170                 set;
 171             }
 172         }
 173
 174         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 175         private delegate void TimeTickCallbackType(IntPtr application, IntPtr watchTime);
 176         private TimeTickCallbackType _timeTickCallback;
 177         private DaliEventHandler<object,TimeTickEventArgs> _timeTickEventHandler;
 178
 179         /// <summary>
 180         /// TimeTick event.
 181         /// </summary>
 182         public event DaliEventHandler<object, TimeTickEventArgs> TimeTick
 183         {
 184             add
 185             {
 186                 if (_timeTickEventHandler == null)
 187                 {
 188                     _timeTickCallback = new TimeTickCallbackType( OnTimeTick);
 189                     TimeTickSignal().Connect(_timeTickCallback);
 190                 }
 191
 192                 _timeTickEventHandler += value;
 193             }
 194
 195             remove
 196             {
 197                 _timeTickEventHandler -= value;
 198
 199                 if (_timeTickEventHandler == null && TimeTickSignal().Empty() == false)
 200                 {
 201                    TimeTickSignal().Disconnect(_timeTickCallback);
 202                 }
 203             }
 204         }
 205
 206         private void OnTimeTick(IntPtr application, IntPtr watchTime)
 207         {
 208             TimeTickEventArgs e = new TimeTickEventArgs();
 209             if (application != null)
 210             {
 211                 e.Application = Application.GetApplicationFromPtr(application);
 212             }
 213             if(watchTime != null)
 214             {
 215                 e.WatchTime = WatchTime.GetWatchTimeFromPtr(watchTime);
 216             }
 217
 218             _timeTickEventHandler?.Invoke(this, e);
 219         }
 220
 221         internal WatchTimeSignal TimeTickSignal()
 222         {
 223             WatchTimeSignal ret = new WatchTimeSignal(NDalicManualPINVOKE.WatchApplication_TimeTickSignal(swigCPtr), false);
 224             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 225             return ret;
 226         }
 227
 228         /// <summary>
 229         /// Event arguments that passed via ambient tick event signal.
 230         /// </summary>
 231         public class AmbientTickEventArgs : EventArgs
 232         {
 233             /// <summary>
 234             /// Application.
 235             /// </summary>
 236             public Application Application
 237             {
 238                 get;
 239                 set;
 240             }
 241
 242             /// <summary>
 243             /// WatchTime.
 244             /// </summary>
 245             public WatchTime WatchTime
 246             {
 247                 get;
 248                 set;
 249             }
 250         }
 251
 252         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 253         private delegate void AmbientTickCallbackType(IntPtr application, IntPtr watchTime);
 254         private AmbientTickCallbackType _ambientTickCallback;
 255         private DaliEventHandler<object,AmbientTickEventArgs> _ambientTickEventHandler;
 256
 257         /// <summary>
 258         /// AmbientTick event.
 259         /// </summary>
 260         public event DaliEventHandler<object, AmbientTickEventArgs> AmbientTick
 261         {
 262             add
 263             {
 264                 if (_ambientTickEventHandler == null)
 265                 {
 266                     _ambientTickCallback = new AmbientTickCallbackType( OnAmbientTick);
 267                     AmbientTickSignal().Connect(_ambientTickCallback);
 268                 }
 269
 270                 _ambientTickEventHandler += value;
 271             }
 272
 273             remove
 274             {
 275                 _ambientTickEventHandler -= value;
 276
 277                 if (_ambientTickEventHandler == null && AmbientTickSignal().Empty() == false)
 278                 {
 279                    AmbientTickSignal().Disconnect(_ambientTickCallback);
 280                 }
 281             }
 282         }
 283
 284         private void OnAmbientTick(IntPtr application, IntPtr watchTime)
 285         {
 286             AmbientTickEventArgs e = new AmbientTickEventArgs();
 287             if (application != null)
 288             {
 289                 e.Application = Application.GetApplicationFromPtr(application);
 290             }
 291             if (watchTime != null)
 292             {
 293                 e.WatchTime = WatchTime.GetWatchTimeFromPtr(watchTime);
 294             }
 295
 296             _ambientTickEventHandler?.Invoke(this, e);
 297         }
 298
 299         internal WatchTimeSignal AmbientTickSignal()
 300         {
 301             WatchTimeSignal ret = new WatchTimeSignal(NDalicManualPINVOKE.WatchApplication_AmbientTickSignal(swigCPtr), false);
 302             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 303             return ret;
 304         }
 305
 306         /// <summary>
 307         /// Event arguments that passed via ambient tick event signal.
 308         /// </summary>
 309         public class AmbientChangedEventArgs : EventArgs
 310         {
 311             /// <summary>
 312             /// Application.
 313             /// </summary>
 314             public Application Application
 315             {
 316                 get;
 317                 set;
 318             }
 319
 320             /// <summary>
 321             /// Changed.
 322             /// </summary>
 323             public bool Changed
 324             {
 325                 get;
 326                 set;
 327             }
 328         }
 329
 330         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 331         private delegate void AmbientChangedCallbackType(IntPtr application, bool changed);
 332         private AmbientChangedCallbackType _ambientChangedCallback;
 333         private DaliEventHandler<object,AmbientChangedEventArgs> _ambientChangedEventHandler;
 334
 335         /// <summary>
 336         /// AmbientChanged event.
 337         /// </summary>
 338         public event DaliEventHandler<object, AmbientChangedEventArgs> AmbientChanged
 339         {
 340             add
 341             {
 342                 if (_ambientChangedEventHandler == null)
 343                 {
 344                     _ambientChangedCallback = new AmbientChangedCallbackType( OnAmbientChanged);
 345                     AmbientChangedSignal().Connect(_ambientChangedCallback);
 346                 }
 347
 348                 _ambientChangedEventHandler += value;
 349             }
 350
 351             remove
 352             {
 353                 _ambientChangedEventHandler -= value;
 354
 355                 if (_ambientChangedEventHandler == null && AmbientChangedSignal().Empty() == false)
 356                 {
 357                    AmbientChangedSignal().Disconnect(_ambientChangedCallback);
 358                 }
 359             }
 360         }
 361
 362         private void OnAmbientChanged(IntPtr application, bool changed)
 363         {
 364             AmbientChangedEventArgs e = new AmbientChangedEventArgs();
 365             if (application != null)
 366             {
 367                 e.Application = Application.GetApplicationFromPtr(application);
 368             }
 369             e.Changed = changed;
 370
 371             _ambientChangedEventHandler?.Invoke(this, e);
 372         }
 373
 374         internal WatchBoolSignal AmbientChangedSignal()
 375         {
 376             WatchBoolSignal ret = new WatchBoolSignal(NDalicManualPINVOKE.WatchApplication_AmbientChangedSignal(swigCPtr), false);
 377             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 378             return ret;
 379         }
 380
 381         private static WatchApplication _instance; //singleton
 382
 383     }
 384
 385 }