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 override 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 new 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         /// <since_tizen> 4 </since_tizen>
 154         public class TimeTickEventArgs : EventArgs
 155         {
 156             /// <summary>
 157             /// Application.
 158             /// </summary>
 159             /// <since_tizen> 4 </since_tizen>
 160             public Application Application
 161             {
 162                 get;
 163                 set;
 164             }
 165
 166             /// <summary>
 167             /// WatchTime.
 168             /// </summary>
 169             /// <since_tizen> 4 </since_tizen>
 170             public WatchTime WatchTime
 171             {
 172                 get;
 173                 set;
 174             }
 175         }
 176
 177         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 178         private delegate void TimeTickCallbackType(IntPtr application, IntPtr watchTime);
 179         private TimeTickCallbackType _timeTickCallback;
 180         private DaliEventHandler<object,TimeTickEventArgs> _timeTickEventHandler;
 181
 182         /// <summary>
 183         /// TimeTick event.
 184         /// </summary>
 185         public event DaliEventHandler<object, TimeTickEventArgs> TimeTick
 186         {
 187             add
 188             {
 189                 if (_timeTickEventHandler == null)
 190                 {
 191                     _timeTickCallback = new TimeTickCallbackType( OnTimeTick);
 192                     TimeTickSignal().Connect(_timeTickCallback);
 193                 }
 194
 195                 _timeTickEventHandler += value;
 196             }
 197
 198             remove
 199             {
 200                 _timeTickEventHandler -= value;
 201
 202                 if (_timeTickEventHandler == null && TimeTickSignal().Empty() == false)
 203                 {
 204                    TimeTickSignal().Disconnect(_timeTickCallback);
 205                 }
 206             }
 207         }
 208
 209         private void OnTimeTick(IntPtr application, IntPtr watchTime)
 210         {
 211             TimeTickEventArgs e = new TimeTickEventArgs();
 212             if (application != null)
 213             {
 214                 e.Application = Application.GetApplicationFromPtr(application);
 215             }
 216             if(watchTime != null)
 217             {
 218                 e.WatchTime = WatchTime.GetWatchTimeFromPtr(watchTime);
 219             }
 220
 221             _timeTickEventHandler?.Invoke(this, e);
 222         }
 223
 224         internal WatchTimeSignal TimeTickSignal()
 225         {
 226             WatchTimeSignal ret = new WatchTimeSignal(NDalicManualPINVOKE.WatchApplication_TimeTickSignal(swigCPtr), false);
 227             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 228             return ret;
 229         }
 230
 231         /// <summary>
 232         /// Event arguments that passed via ambient tick event signal.
 233         /// </summary>
 234         /// <since_tizen> 4 </since_tizen>
 235         public class AmbientTickEventArgs : EventArgs
 236         {
 237             /// <summary>
 238             /// Application.
 239             /// </summary>
 240             /// <since_tizen> 4 </since_tizen>
 241             public Application Application
 242             {
 243                 get;
 244                 set;
 245             }
 246
 247             /// <summary>
 248             /// WatchTime.
 249             /// </summary>
 250             /// <since_tizen> 4 </since_tizen>
 251             public WatchTime WatchTime
 252             {
 253                 get;
 254                 set;
 255             }
 256         }
 257
 258         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 259         private delegate void AmbientTickCallbackType(IntPtr application, IntPtr watchTime);
 260         private AmbientTickCallbackType _ambientTickCallback;
 261         private DaliEventHandler<object,AmbientTickEventArgs> _ambientTickEventHandler;
 262
 263         /// <summary>
 264         /// AmbientTick event.
 265         /// </summary>
 266         public event DaliEventHandler<object, AmbientTickEventArgs> AmbientTick
 267         {
 268             add
 269             {
 270                 if (_ambientTickEventHandler == null)
 271                 {
 272                     _ambientTickCallback = new AmbientTickCallbackType( OnAmbientTick);
 273                     AmbientTickSignal().Connect(_ambientTickCallback);
 274                 }
 275
 276                 _ambientTickEventHandler += value;
 277             }
 278
 279             remove
 280             {
 281                 _ambientTickEventHandler -= value;
 282
 283                 if (_ambientTickEventHandler == null && AmbientTickSignal().Empty() == false)
 284                 {
 285                    AmbientTickSignal().Disconnect(_ambientTickCallback);
 286                 }
 287             }
 288         }
 289
 290         private void OnAmbientTick(IntPtr application, IntPtr watchTime)
 291         {
 292             AmbientTickEventArgs e = new AmbientTickEventArgs();
 293             if (application != null)
 294             {
 295                 e.Application = Application.GetApplicationFromPtr(application);
 296             }
 297             if (watchTime != null)
 298             {
 299                 e.WatchTime = WatchTime.GetWatchTimeFromPtr(watchTime);
 300             }
 301
 302             _ambientTickEventHandler?.Invoke(this, e);
 303         }
 304
 305         internal WatchTimeSignal AmbientTickSignal()
 306         {
 307             WatchTimeSignal ret = new WatchTimeSignal(NDalicManualPINVOKE.WatchApplication_AmbientTickSignal(swigCPtr), false);
 308             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 309             return ret;
 310         }
 311
 312         /// <summary>
 313         /// Event arguments that passed via ambient tick event signal.
 314         /// </summary>
 315         /// <since_tizen> 4 </since_tizen>
 316         public class AmbientChangedEventArgs : EventArgs
 317         {
 318             /// <summary>
 319             /// Application.
 320             /// </summary>
 321             /// <since_tizen> 4 </since_tizen>
 322             public Application Application
 323             {
 324                 get;
 325                 set;
 326             }
 327
 328             /// <summary>
 329             /// Changed.
 330             /// </summary>
 331             /// <since_tizen> 4 </since_tizen>
 332             public bool Changed
 333             {
 334                 get;
 335                 set;
 336             }
 337         }
 338
 339         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 340         private delegate void AmbientChangedCallbackType(IntPtr application, bool changed);
 341         private AmbientChangedCallbackType _ambientChangedCallback;
 342         private DaliEventHandler<object,AmbientChangedEventArgs> _ambientChangedEventHandler;
 343
 344         /// <summary>
 345         /// AmbientChanged event.
 346         /// </summary>
 347         public event DaliEventHandler<object, AmbientChangedEventArgs> AmbientChanged
 348         {
 349             add
 350             {
 351                 if (_ambientChangedEventHandler == null)
 352                 {
 353                     _ambientChangedCallback = new AmbientChangedCallbackType( OnAmbientChanged);
 354                     AmbientChangedSignal().Connect(_ambientChangedCallback);
 355                 }
 356
 357                 _ambientChangedEventHandler += value;
 358             }
 359
 360             remove
 361             {
 362                 _ambientChangedEventHandler -= value;
 363
 364                 if (_ambientChangedEventHandler == null && AmbientChangedSignal().Empty() == false)
 365                 {
 366                    AmbientChangedSignal().Disconnect(_ambientChangedCallback);
 367                 }
 368             }
 369         }
 370
 371         private void OnAmbientChanged(IntPtr application, bool changed)
 372         {
 373             AmbientChangedEventArgs e = new AmbientChangedEventArgs();
 374             if (application != null)
 375             {
 376                 e.Application = Application.GetApplicationFromPtr(application);
 377             }
 378             e.Changed = changed;
 379
 380             _ambientChangedEventHandler?.Invoke(this, e);
 381         }
 382
 383         internal WatchBoolSignal AmbientChangedSignal()
 384         {
 385             WatchBoolSignal ret = new WatchBoolSignal(NDalicManualPINVOKE.WatchApplication_AmbientChangedSignal(swigCPtr), false);
 386             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 387             return ret;
 388         }
 389
 390         private static WatchApplication _instance; //singleton
 391
 392     }
 393
 394 }