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

   1 /*
   2  * Copyright (c) 2021 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
  21 namespace Tizen.NUI
  22 {
  23     internal class WatchApplication : Application
  24     {
  25         internal WatchApplication(global::System.IntPtr cPtr, bool cMemoryOwn) : base(cPtr, cMemoryOwn)
  26         {
  27         }
  28
  29         internal static global::System.Runtime.InteropServices.HandleRef getCPtr(WatchApplication obj)
  30         {
  31             return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.SwigCPtr;
  32         }
  33
  34         protected override void ReleaseSwigCPtr(System.Runtime.InteropServices.HandleRef swigCPtr)
  35         {
  36             Interop.Watch.DeleteWatchApplication(swigCPtr);
  37         }
  38
  39         private void DisConnectFromSignals()
  40         {
  41             if (timeTickCallback != null)
  42             {
  43                 this.TimeTickSignal().Disconnect(timeTickCallback);
  44             }
  45             if (ambientTickCallback != null)
  46             {
  47                 this.AmbientTickSignal().Disconnect(ambientTickCallback);
  48             }
  49             if (ambientChangedCallback != null)
  50             {
  51                 this.AmbientChangedSignal().Disconnect(ambientChangedCallback);
  52             }
  53         }
  54
  55         public static WatchApplication NewWatchApplication()
  56         {
  57             WatchApplication ret = New();
  58             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
  59             // we've got an application now connect the signals
  60             instance = ret;
  61             return ret;
  62         }
  63
  64         public static WatchApplication NewWatchApplication(string[] args)
  65         {
  66             WatchApplication ret = New(args);
  67             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
  68             instance = ret;
  69             return ret;
  70         }
  71
  72         public static WatchApplication NewWatchApplication(string[] args, string stylesheet)
  73         {
  74             WatchApplication ret = New(args, stylesheet);
  75             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
  76             instance = ret;
  77             return ret;
  78         }
  79
  80         public new static WatchApplication New()
  81         {
  82             WatchApplication ret = new WatchApplication(Interop.Watch.WatchApplicationNew(), true);
  83             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
  84             return ret;
  85         }
  86
  87         public static WatchApplication New(string[] args)
  88         {
  89             int argc = args.Length;
  90             string argvStr = string.Join(" ", args);
  91
  92             WatchApplication ret = new WatchApplication(Interop.Watch.WatchApplicationNew(argc, argvStr), true);
  93             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
  94             return ret;
  95         }
  96
  97         public static WatchApplication New(string[] args, string stylesheet)
  98         {
  99             int argc = args.Length;
 100             string argvStr = string.Join(" ", args);
 101
 102             WatchApplication ret = new WatchApplication(Interop.Watch.WatchApplicationNew(argc, argvStr, stylesheet), true);
 103             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 104             return ret;
 105         }
 106
 107         internal WatchApplication(WatchApplication implementation) : this(Interop.Watch.NewWatchApplication(WatchApplication.getCPtr(implementation)), true)
 108         {
 109             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 110         }
 111
 112         /// <summary>
 113         /// Event arguments that passed via time tick event signal.
 114         /// </summary>
 115         public class TimeTickEventArgs : EventArgs
 116         {
 117             /// <summary>
 118             /// Application.
 119             /// </summary>
 120             public Application Application
 121             {
 122                 get;
 123                 set;
 124             }
 125
 126             /// <summary>
 127             /// WatchTime.
 128             /// </summary>
 129             public WatchTime WatchTime
 130             {
 131                 get;
 132                 set;
 133             }
 134         }
 135
 136         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 137         private delegate void TimeTickCallbackType(IntPtr application, IntPtr watchTime);
 138         private TimeTickCallbackType timeTickCallback;
 139         private DaliEventHandler<object, TimeTickEventArgs> timeTickEventHandler;
 140
 141         /// <summary>
 142         /// TimeTick event.
 143         /// </summary>
 144         public event DaliEventHandler<object, TimeTickEventArgs> TimeTick
 145         {
 146             add
 147             {
 148                 if (timeTickEventHandler == null)
 149                 {
 150                     timeTickCallback = new TimeTickCallbackType(OnTimeTick);
 151                     TimeTickSignal().Connect(timeTickCallback);
 152                 }
 153
 154                 timeTickEventHandler += value;
 155             }
 156
 157             remove
 158             {
 159                 timeTickEventHandler -= value;
 160
 161                 if (timeTickEventHandler == null && TimeTickSignal().Empty() == false)
 162                 {
 163                     TimeTickSignal().Disconnect(timeTickCallback);
 164                 }
 165             }
 166         }
 167
 168         private void OnTimeTick(IntPtr application, IntPtr watchTime)
 169         {
 170             TimeTickEventArgs e = new TimeTickEventArgs();
 171             e.Application = this;
 172             e.WatchTime = WatchTime.GetWatchTimeFromPtr(watchTime);
 173
 174             timeTickEventHandler?.Invoke(this, e);
 175         }
 176
 177         internal WatchTimeSignal TimeTickSignal()
 178         {
 179             WatchTimeSignal ret = new WatchTimeSignal(Interop.Watch.WatchApplicationTimeTickSignal(SwigCPtr), false);
 180             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 181             return ret;
 182         }
 183
 184         /// <summary>
 185         /// Event arguments that passed via ambient tick event signal.
 186         /// </summary>
 187         public class AmbientTickEventArgs : EventArgs
 188         {
 189             /// <summary>
 190             /// Application.
 191             /// </summary>
 192             public Application Application
 193             {
 194                 get;
 195                 set;
 196             }
 197
 198             /// <summary>
 199             /// WatchTime.
 200             /// </summary>
 201             public WatchTime WatchTime
 202             {
 203                 get;
 204                 set;
 205             }
 206         }
 207
 208         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 209         private delegate void AmbientTickCallbackType(IntPtr application, IntPtr watchTime);
 210         private AmbientTickCallbackType ambientTickCallback;
 211         private DaliEventHandler<object, AmbientTickEventArgs> ambientTickEventHandler;
 212
 213         /// <summary>
 214         /// AmbientTick event.
 215         /// </summary>
 216         public event DaliEventHandler<object, AmbientTickEventArgs> AmbientTick
 217         {
 218             add
 219             {
 220                 if (ambientTickEventHandler == null)
 221                 {
 222                     ambientTickCallback = new AmbientTickCallbackType(OnAmbientTick);
 223                     AmbientTickSignal().Connect(ambientTickCallback);
 224                 }
 225
 226                 ambientTickEventHandler += value;
 227             }
 228
 229             remove
 230             {
 231                 ambientTickEventHandler -= value;
 232
 233                 if (ambientTickEventHandler == null && AmbientTickSignal().Empty() == false)
 234                 {
 235                     AmbientTickSignal().Disconnect(ambientTickCallback);
 236                 }
 237             }
 238         }
 239
 240         private void OnAmbientTick(IntPtr application, IntPtr watchTime)
 241         {
 242             AmbientTickEventArgs e = new AmbientTickEventArgs();
 243
 244             e.Application = this;
 245             e.WatchTime = WatchTime.GetWatchTimeFromPtr(watchTime);
 246             ambientTickEventHandler?.Invoke(this, e);
 247         }
 248
 249         internal WatchTimeSignal AmbientTickSignal()
 250         {
 251             WatchTimeSignal ret = new WatchTimeSignal(Interop.Watch.WatchApplicationAmbientTickSignal(SwigCPtr), false);
 252             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 253             return ret;
 254         }
 255
 256         /// <summary>
 257         /// Event arguments that passed via ambient tick event signal.
 258         /// </summary>
 259         public class AmbientChangedEventArgs : EventArgs
 260         {
 261             /// <summary>
 262             /// Application.
 263             /// </summary>
 264             public Application Application
 265             {
 266                 get;
 267                 set;
 268             }
 269
 270             /// <summary>
 271             /// Changed.
 272             /// </summary>
 273             public bool Changed
 274             {
 275                 get;
 276                 set;
 277             }
 278         }
 279
 280         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 281         private delegate void AmbientChangedCallbackType(IntPtr application, bool changed);
 282         private AmbientChangedCallbackType ambientChangedCallback;
 283         private DaliEventHandler<object, AmbientChangedEventArgs> ambientChangedEventHandler;
 284
 285         /// <summary>
 286         /// AmbientChanged event.
 287         /// </summary>
 288         public event DaliEventHandler<object, AmbientChangedEventArgs> AmbientChanged
 289         {
 290             add
 291             {
 292                 if (ambientChangedEventHandler == null)
 293                 {
 294                     ambientChangedCallback = new AmbientChangedCallbackType(OnAmbientChanged);
 295                     AmbientChangedSignal().Connect(ambientChangedCallback);
 296                 }
 297
 298                 ambientChangedEventHandler += value;
 299             }
 300
 301             remove
 302             {
 303                 ambientChangedEventHandler -= value;
 304
 305                 if (ambientChangedEventHandler == null && AmbientChangedSignal().Empty() == false)
 306                 {
 307                     AmbientChangedSignal().Disconnect(ambientChangedCallback);
 308                 }
 309             }
 310         }
 311
 312         private void OnAmbientChanged(IntPtr application, bool changed)
 313         {
 314             AmbientChangedEventArgs e = new AmbientChangedEventArgs();
 315             e.Application = this;
 316             e.Changed = changed;
 317             ambientChangedEventHandler?.Invoke(this, e);
 318         }
 319
 320         internal WatchBoolSignal AmbientChangedSignal()
 321         {
 322             WatchBoolSignal ret = new WatchBoolSignal(Interop.Watch.WatchApplicationAmbientChangedSignal(SwigCPtr), false);
 323             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 324             return ret;
 325         }
 326     }
 327 }