src/ElmSharp/ElmSharp/EcoreMainloop.cs

   1 /*
   2  * Copyright (c) 2016 Samsung Electronics Co., Ltd All Rights Reserved
   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 using System;
  18 using System.Collections.Concurrent;
  19
  20 namespace ElmSharp
  21 {
  22     /// <summary>
  23     /// EcoreMainloop is a helper class, it provide functions relative Ecore's main loop.
  24     /// </summary>
  25     /// <since_tizen> preview </since_tizen>
  26     public static class EcoreMainloop
  27     {
  28
  29         static readonly ConcurrentDictionary<int, Func<bool>> _taskMap = new ConcurrentDictionary<int, Func<bool>>();
  30         static readonly Object _taskLock = new Object();
  31         static int _newTaskId = 0;
  32
  33         static Interop.Ecore.EcoreTaskCallback _nativeHandler;
  34
  35         static EcoreMainloop()
  36         {
  37             Interop.Ecore.ecore_init();
  38             Interop.Ecore.ecore_main_loop_glib_integrate();
  39             _nativeHandler = NativeHandler;
  40         }
  41
  42         /// <summary>
  43         /// Checks if you are calling this function from the main thread.
  44         /// </summary>
  45         /// <remarks>True is the calling function is the same thread, false otherwise.</remarks>
  46         /// <since_tizen> preview </since_tizen>
  47         public static bool IsMainThread => Interop.Eina.eina_main_loop_is();
  48
  49         /// <summary>
  50         /// Runs the application main loop.
  51         /// </summary>
  52         /// <since_tizen> preview </since_tizen>
  53         public static void Begin()
  54         {
  55             Interop.Ecore.ecore_main_loop_begin();
  56         }
  57
  58         /// <summary>
  59         /// Quits the main loop once all the events currently on the queue have been processed.
  60         /// </summary>
  61         /// <since_tizen> preview </since_tizen>
  62         public static void Quit()
  63         {
  64             Interop.Ecore.ecore_main_loop_quit();
  65         }
  66
  67         /// <summary>
  68         /// Adds an idler handler.
  69         /// </summary>
  70         /// <param name="task">The action to call when idling</param>
  71         /// <since_tizen> preview </since_tizen>
  72         public static void Post(Action task)
  73         {
  74             int id = RegistHandler(() => { task(); return false; });
  75             Interop.Ecore.ecore_idler_add(_nativeHandler, (IntPtr)id);
  76         }
  77
  78         /// <summary>
  79         /// Calls callback asynchronously in the main loop.
  80         /// </summary>
  81         /// <param name="task">The action wanted to be called</param>
  82         /// <since_tizen> preview </since_tizen>
  83         public static void PostAndWakeUp(Action task)
  84         {
  85             int id = RegistHandler(() => { task(); return false; });
  86             Interop.Ecore.ecore_main_loop_thread_safe_call_async(_nativeHandler, (IntPtr)id);
  87         }
  88
  89         /// <summary>
  90         /// Calls callback synchronously in the main loop.
  91         /// </summary>
  92         /// <param name="task">The action wanted to be called</param>
  93         /// <since_tizen> preview </since_tizen>
  94         public static void Send(Action task)
  95         {
  96             int id = RegistHandler(() => { task(); return false; });
  97             Interop.Ecore.ecore_main_loop_thread_safe_call_sync(_nativeHandler, (IntPtr)id);
  98         }
  99
 100         /// <summary>
 101         /// Creates a timer to call the given function in the given period of time.
 102         /// </summary>
 103         /// <param name="interval">The interval in seconds.</param>
 104         /// <param name="handler">The given function.</param>
 105         /// <returns>A timer object handler on success, NULL on failure.</returns>
 106         /// <since_tizen> preview </since_tizen>
 107         public static IntPtr AddTimer(double interval, Func<bool> handler)
 108         {
 109             int id = RegistHandler(handler);
 110             return Interop.Ecore.ecore_timer_add(interval, _nativeHandler, (IntPtr)id);
 111         }
 112
 113         /// <summary>
 114         /// Removes the specified timer from the timer list.
 115         /// </summary>
 116         /// <param name="id">The specified timer handler</param>
 117         /// <since_tizen> preview </since_tizen>
 118         public static void RemoveTimer(IntPtr id)
 119         {
 120             int taskId = (int)Interop.Ecore.ecore_timer_del(id);
 121             Func<bool> unused;
 122             _taskMap.TryRemove(taskId, out unused);
 123         }
 124
 125         static int RegistHandler(Func<bool> task)
 126         {
 127             int taskId;
 128             lock (_taskLock)
 129             {
 130                 taskId = _newTaskId++;
 131             }
 132             _taskMap[taskId] = task;
 133             return taskId;
 134         }
 135
 136         static bool NativeHandler(IntPtr user_data)
 137         {
 138             int task_id = (int)user_data;
 139             Func<bool> userAction = null;
 140             if (_taskMap.TryGetValue(task_id, out userAction))
 141             {
 142                 bool result = false;
 143
 144                 if (userAction != null)
 145                 {
 146                     result = userAction();
 147                 }
 148
 149                 if (!result)
 150                 {
 151                     _taskMap.TryRemove(task_id, out userAction);
 152                 }
 153                 return result;
 154             }
 155             return false;
 156         }
 157     }
 158 }