internals/src/EflSharp/EflSharp/efl/eldbus_proxy.cs

   1 #pragma warning disable 1591
   2
   3 using System;
   4 using System.Runtime.InteropServices;
   5
   6 using static eldbus.EldbusProxyNativeFunctions;
   7
   8 namespace eldbus
   9 {
  10
  11 public static class EldbusProxyNativeFunctions
  12 {
  13     [DllImport(efl.Libs.Eldbus)] public static extern IntPtr
  14         eldbus_proxy_get(IntPtr obj, string _interface);
  15
  16     [DllImport(efl.Libs.Eldbus)] public static extern IntPtr
  17         eldbus_proxy_ref(IntPtr proxy);
  18
  19     [DllImport(efl.Libs.Eldbus)] public static extern void
  20         eldbus_proxy_unref(IntPtr proxy);
  21
  22     [DllImport(efl.Libs.Eldbus)] public static extern IntPtr
  23         eldbus_proxy_object_get(IntPtr proxy);
  24
  25     [DllImport(efl.Libs.Eldbus)] public static extern IntPtr
  26         eldbus_proxy_interface_get(IntPtr proxy);
  27
  28     [DllImport(efl.Libs.Eldbus)] public static extern void
  29         eldbus_proxy_data_set(IntPtr proxy, string key, IntPtr data);
  30
  31     [DllImport(efl.Libs.Eldbus)] public static extern IntPtr
  32         eldbus_proxy_data_get(IntPtr proxy, string key);
  33
  34     [DllImport(efl.Libs.Eldbus)] public static extern IntPtr
  35         eldbus_proxy_data_del(IntPtr proxy, string key);
  36
  37     [DllImport(efl.Libs.Eldbus)] public static extern void
  38         eldbus_proxy_free_cb_add(IntPtr proxy, IntPtr cb, IntPtr data);
  39
  40     [DllImport(efl.Libs.Eldbus)] public static extern void
  41         eldbus_proxy_free_cb_del(IntPtr proxy, IntPtr cb, IntPtr data);
  42
  43     [DllImport(efl.Libs.Eldbus)] public static extern IntPtr
  44         eldbus_proxy_method_call_new(IntPtr proxy, string member);
  45
  46     [DllImport(efl.Libs.Eldbus)] public static extern IntPtr
  47         eldbus_proxy_send(IntPtr proxy, IntPtr msg, IntPtr cb, IntPtr cb_data, double timeout);
  48
  49     [DllImport(efl.Libs.Eldbus)] public static extern IntPtr
  50         eldbus_proxy_send_and_block(IntPtr proxy, IntPtr msg, double timeout);
  51
  52 //     [DllImport(efl.Libs.Eldbus)] public static extern IntPtr
  53 //         eldbus_proxy_call(IntPtr proxy, string member, IntPtr cb, IntPtr cb_data, double timeout, string signature, ...);
  54 //
  55 //     [DllImport(efl.Libs.Eldbus)] public static extern IntPtr
  56 //         eldbus_proxy_vcall(IntPtr proxy, string member, IntPtr cb, IntPtr cb_data, double timeout, string signature, va_list ap);
  57
  58     [DllImport(efl.Libs.Eldbus)] public static extern IntPtr
  59         eldbus_proxy_signal_handler_add(IntPtr proxy, string member, IntPtr cb, IntPtr cb_data);
  60
  61     [DllImport(efl.Libs.Eldbus)] public static extern void
  62         eldbus_proxy_event_callback_add(IntPtr proxy, int type, IntPtr cb, IntPtr cb_data);
  63
  64     [DllImport(efl.Libs.Eldbus)] public static extern void
  65         eldbus_proxy_event_callback_del(IntPtr proxy, int type, IntPtr cb, IntPtr cb_data);
  66 }
  67
  68 public class Proxy : IDisposable
  69 {
  70     public IntPtr Handle {get;set;} = IntPtr.Zero;
  71     public bool Own {get;set;} = true;
  72
  73     private void InitNew(IntPtr handle, bool own)
  74     {
  75         Handle = handle;
  76         Own = own;
  77         CheckHandle();
  78     }
  79
  80     private void CheckHandle()
  81     {
  82         if (Handle == IntPtr.Zero)
  83         {
  84             eldbus.Common.RaiseNullHandle();
  85         }
  86     }
  87
  88     public Proxy(IntPtr handle, bool own)
  89     {
  90         InitNew(handle, own);
  91     }
  92
  93     public Proxy(eldbus.Object obj, string _interface)
  94     {
  95         InitNew(eldbus_proxy_get(obj.Handle, _interface), true);
  96     }
  97
  98     ~Proxy()
  99     {
 100         Dispose(false);
 101     }
 102
 103     protected virtual void Dispose(bool disposing)
 104     {
 105         IntPtr h = Handle;
 106         Handle = IntPtr.Zero;
 107         if (h == IntPtr.Zero)
 108         {
 109             return;
 110         }
 111
 112         if (Own)
 113         {
 114             if (disposing)
 115             {
 116                 eldbus_proxy_unref(h);
 117             }
 118             else
 119             {
 120                 Efl.Eo.Globals.ThreadSafeFreeCbExec(eldbus_proxy_unref, h);
 121             }
 122         }
 123     }
 124
 125     public void Dispose()
 126     {
 127         Dispose(true);
 128         GC.SuppressFinalize(this);
 129     }
 130
 131     public void Free()
 132     {
 133         Dispose();
 134     }
 135
 136     public IntPtr Release()
 137     {
 138         IntPtr h = Handle;
 139         Handle = IntPtr.Zero;
 140         return h;
 141     }
 142
 143     eldbus.Object GetObject()
 144     {
 145         CheckHandle();
 146         var ptr = eldbus_proxy_object_get(Handle);
 147         if (ptr == IntPtr.Zero)
 148         {
 149             throw new SEHException("Eldbus: could not get `Object' object from eldbus_proxy_object_get");
 150         }
 151
 152         return new eldbus.Object(ptr, false);
 153     }
 154
 155     string GetInterface()
 156     {
 157         CheckHandle();
 158         var ptr = eldbus_proxy_interface_get(Handle);
 159         return Eina.StringConversion.NativeUtf8ToManagedString(ptr);
 160     }
 161
 162     eldbus.Message NewMethodCall(string member)
 163     {
 164         CheckHandle();
 165
 166         if (member == null)
 167         {
 168             throw new ArgumentNullException("member");
 169         }
 170
 171         var ptr = eldbus_proxy_method_call_new(Handle, member);
 172         if (ptr == IntPtr.Zero)
 173         {
 174             throw new SEHException("Eldbus: could not get `Message' object from eldbus_proxy_method_call_new");
 175         }
 176
 177         return new eldbus.Message(ptr, false);
 178     }
 179
 180     eldbus.Pending Send(eldbus.Message msg, eldbus.MessageDelegate dlgt = null, double timeout = -1)
 181     {
 182         CheckHandle();
 183
 184         if (msg == null)
 185         {
 186             throw new ArgumentNullException("msg");
 187         }
 188
 189         IntPtr cb_wrapper = dlgt == null ? IntPtr.Zero : eldbus.Common.GetMessageCbWrapperPtr();
 190         IntPtr cb_data = dlgt == null ? IntPtr.Zero : Marshal.GetFunctionPointerForDelegate(dlgt);
 191
 192         var pending_hdl = eldbus_proxy_send(Handle, msg.Handle, cb_wrapper, cb_data, timeout);
 193
 194         if (pending_hdl == IntPtr.Zero)
 195         {
 196             throw new SEHException("Eldbus: could not get `Pending' object from eldbus_proxy_send");
 197         }
 198
 199         return new eldbus.Pending(pending_hdl, false);
 200     }
 201
 202     eldbus.Message SendAndBlock(eldbus.Message msg, double timeout = -1)
 203     {
 204         CheckHandle();
 205         var ptr = eldbus_proxy_send_and_block(Handle, msg.Handle, timeout);
 206         if (ptr == IntPtr.Zero)
 207         {
 208             throw new SEHException("Eldbus: could not get `Message' object from eldbus_proxy_send_and_block");
 209         }
 210
 211         return new eldbus.Message(ptr, true);
 212     }
 213
 214     eldbus.Pending Call(string member, eldbus.MessageDelegate dlgt, double timeout, params BasicMessageArgument[] args)
 215     {
 216         CheckHandle();
 217
 218         var msg = NewMethodCall(member);
 219
 220         foreach (BasicMessageArgument arg in args)
 221         {
 222             arg.AppendTo(msg);
 223         }
 224
 225         return Send(msg, dlgt, timeout);
 226     }
 227
 228     eldbus.Pending Call(string member, params BasicMessageArgument[] args)
 229     {
 230         return Call(member, null, -1.0, args);
 231     }
 232 }
 233
 234 }