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