html/dbus.js

   1 /*
   2  * DBus.js, a JS wrapper for the Browser D-Bus Bridge
   3  * Copyright (c) 2008-2009  Movial Creative Technologies Inc
   4  *
   5  * Contact: Movial Creative Technologies Inc, <info@movial.com>
   6  * Authors: Lauri Mylläri, <lauri.myllari@movial.fi>
   7  *          Kalle Vahlman, <kalle.vahlman@movial.com>
   8  *          Ehsun Amanolahi, <ehsun.amanolahi@movial.com>
   9  *
  10  * Permission is hereby granted, free of charge, to any person
  11  * obtaining a copy of this software and associated documentation
  12  * files (the "Software"), to deal in the Software without
  13  * restriction, including without limitation the rights to use,
  14  * copy, modify, merge, publish, distribute, sublicense, and/or sell
  15  * copies of the Software, and to permit persons to whom the
  16  * Software is furnished to do so, subject to the following
  17  * conditions:
  18  *
  19  * The above copyright notice and this permission notice shall be
  20  * included in all copies or substantial portions of the Software.
  21  *
  22  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  23  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
  24  * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  25  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
  26  * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
  27  * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  28  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  29  * OTHER DEALINGS IN THE SOFTWARE.
  30  */
  31
  32 if (!window.DBus)
  33 {
  34     /* This is the Gecko wrapping for the Browser D-Bus Bridge API
  35      * You can use the XPCOM API directly, but the Bridge API
  36      *  - is easier to use
  37      *  - has few utility features over the "raw" API (like introspection)
  38      *  - generally feels a bit more JavaScriptish (hopefully)
  39      */
  40
  41     /* For readability */
  42     var ep = netscape.security.PrivilegeManager.enablePrivilege;
  43     ep("UniversalXPConnect");
  44     var cc = Components.classes;
  45     var ci = Components.interfaces;
  46
  47     /* Utility function that creates a wrapper function which handles signature
  48      * conversion from wrapper(argarray) to method(arg1, ..., argN) and sets
  49      * 'this' to point to the user-specified object. This is mainly used to
  50      * convert the variant arrays from the XPCOM service to callback arguments.
  51      */
  52     var unWrap = function(method, user_data) {
  53         return function() {
  54             if (method){
  55                 method.apply(user_data, arguments[0]);
  56             }
  57         };
  58     };
  59
  60     var makeVariantMaker = function(variant_type) {
  61         return function(val) {
  62             ep("UniversalXPConnect");
  63             var variant = cc["@mozilla.org/variant;1"].createInstance(ci.nsIWritableVariant);
  64             variant['setAs' + variant_type](val);
  65             return variant;
  66         };
  67         return ret;
  68     };
  69
  70     // Bridge API: The DBus singleton class
  71     window.DBus = function() {
  72
  73         ep("UniversalXPConnect");
  74         this.dbus = cc["@movial.fi/dbus/service;1"].getService();
  75         this.dbus = this.dbus.QueryInterface(Components.interfaces.IDBusService);
  76
  77         // Mirror static properties
  78         this.SYSTEM = this.dbus.SYSTEM;
  79         this.SESSION = this.dbus.SESSION;
  80
  81         // Bridge API: DBus.[some type]()
  82         // These are types we can wrap to variants directly for the
  83         // DBus.Int32() etc conversion methods
  84         var types = {
  85             Int32:  "Int32",
  86             UInt32: "Uint32",
  87             Int16:  "Int16",
  88             UInt16: "Uint16",
  89             Int64:  "Int64",
  90             UInt64: "Uint64",
  91             Double: "Double",
  92             Byte:   "Int8"
  93         };
  94
  95         for (var type in types) {
  96             if(type !== null ){
  97                 this[type] = makeVariantMaker(types[type]);
  98             }
  99         }
 100
 101     };
 102
 103     // Methods for non-variant and non-automatic type conversions
 104     window.DBus.prototype.Signature = function(val) {
 105       ep("UniversalXPConnect");
 106       var carrier = cc["@movial.fi/dbus/datacarrier;1"].createInstance(ci.IDBusDataCarrier);
 107       carrier.type = "g";
 108       carrier.value = val;
 109       return carrier;
 110     };
 111
 112     window.DBus.prototype.ObjectPath = function(val) {
 113       ep("UniversalXPConnect");
 114       var carrier = cc["@movial.fi/dbus/datacarrier;1"].createInstance(ci.IDBusDataCarrier);
 115       carrier.type = "o";
 116       carrier.value = val;
 117       return carrier;
 118     };
 119
 120     window.DBus.prototype.Variant = function(sig, val) {
 121       ep("UniversalXPConnect");
 122       var carrier = cc["@movial.fi/dbus/datacarrier;1"].createInstance(ci.IDBusDataCarrier);
 123       carrier.type = "v";
 124       carrier.signature = sig;
 125       carrier.value = val;
 126       return carrier;
 127     };
 128
 129     window.DBus.prototype.Struct = function(val) {
 130       ep("UniversalXPConnect");
 131       var carrier = cc["@movial.fi/dbus/datacarrier;1"].createInstance(ci.IDBusDataCarrier);
 132       carrier.type = "r";
 133       carrier.value = val;
 134       return carrier;
 135     };
 136
 137     // Bridge API: dbus.getMethod()
 138     window.DBus.prototype.getMethod = function(bustype,
 139                                                destination,
 140                                                object_path,
 141                                                method_name,
 142                                                inter,
 143                                                signature,
 144                                                user_data) {
 145
 146         /* A wrapper function for method calls
 147          * Executes the actual call through the XPCOM interface
 148          */
 149         var method = function() {
 150             ep("UniversalXPConnect");
 151             // FIXME: Is the copy really necessary? Why?
 152             method.dbusmethod.doCall(Array.prototype.slice.call(arguments),
 153                                      arguments.length);
 154         };
 155
 156         // Store the user specified "this" object
 157         method.user_data = user_data;
 158
 159         // Create the XPCOM method object
 160         ep("UniversalXPConnect");
 161         method.dbusmethod = this.dbus.getMethod(bustype,
 162                                                 destination,
 163                                                 object_path,
 164                                                 method_name,
 165                                                 inter,
 166                                                 signature);
 167
 168         /* XXX: Hmm? onreply and onerror are undefined here, no? */
 169         method.dbusmethod.onReply = unWrap(method.onreply, method.user_data);
 170         method.dbusmethod.onError = unWrap(method.onerror, method.user_data);
 171
 172         // Watch the onreply property and assign the callback through our
 173         // wrapper
 174         method.watch("onreply", function(id, oldval, newval) {
 175             ep("UniversalXPConnect");
 176             method.dbusmethod.onReply = unWrap(newval, method.user_data);
 177         });
 178
 179         // Ditto for onerror
 180         method.watch("onerror", function(id, oldval, newval) {
 181             ep("UniversalXPConnect");
 182             method.dbusmethod.onError = unWrap(newval, method.user_data);
 183         });
 184
 185         // Mirror the async property
 186         method.async = true;
 187         method.watch("async", function(id, oldval, newval) {
 188             ep("UniversalXPConnect");
 189             method.dbusmethod.async = newval;
 190         });
 191
 192         return method;
 193     };
 194
 195     // Bridge API: dbus.getSignal()
 196     window.DBus.prototype.getSignal = function(bustype,
 197                                                inter,
 198                                                signal_name,
 199                                                sender,
 200                                                object_path,
 201                                                user_data) {
 202         var signal = {};
 203
 204         // Create the XPCOM signal object
 205         ep("UniversalXPConnect");
 206         signal.dbussignal = this.dbus.getSignal(bustype,
 207                                                 inter,
 208                                                 signal_name,
 209                                                 sender,
 210                                                 object_path);
 211
 212         // Store user-specified "this" for callbacks
 213         signal.user_data = user_data;
 214
 215         // XXX: ummm.... onemit == undefined?
 216         signal.dbussignal.onEmit = unWrap(signal.onemit, signal.user_data);
 217
 218         // Watch the onemit property for wrapping
 219         signal.watch("onemit", function(id, oldval, newval) {
 220             ep("UniversalXPConnect");
 221             signal.dbussignal.onEmit = unWrap(newval, signal.user_data);
 222         });
 223
 224         // Watch the enabled property for wrapping
 225         signal.enabled = false;
 226         signal.watch("enabled", function(id, oldval, newval) {
 227             ep("UniversalXPConnect");
 228             signal.dbussignal.enabled = newval;
 229         });
 230
 231         return signal;
 232     };
 233
 234     // Bridge API: dbus.emitSignal()
 235     window.DBus.prototype.emitSignal = function() {
 236         var args = arguments.splice(5);
 237         ep("UniversalXPConnect");
 238         this.dbus.emitSignal(arguments[0], arguments[1],
 239                              arguments[2], arguments[3],
 240                              arguments[4], args, args.length);
 241     };
 242
 243 }
 244
 245 // Instantiate the Bridge API singleton
 246 try {
 247   window.dbus = new window.DBus();
 248 } catch (e) {
 249   window.dbus = null;
 250 }
 251
 252 /**
 253  *  @private
 254  */
 255
 256 DBus.prototype.parseInterface = function(doc, dest, path, inter){
 257     var ret = {};
 258     var temp = doc.getElementsByTagName("interface");
 259     //interesting interface is last
 260     for( var i = temp.length - 1; i >=0; i--){
 261         if( temp[i].getAttribute("name") != inter ) { continue; }
 262         //method name
 263         var methods = temp[i].getElementsByTagName("method");
 264         for ( var j = 0, jl = methods.length; j < jl; j ++){
 265             var name = methods[j].getAttribute("name");
 266             //params
 267             var args = methods[j].getElementsByTagName("arg");
 268             var type = [];
 269
 270             for( var z = 0, zl = args.length; z < zl; z ++){
 271
 272                 if(  args[z].getAttribute("direction") == "in"){
 273                     type.push(args[z].getAttribute("type") );
 274                 }
 275
 276             }
 277             ret[name] = dbus.getMethod(window.DBus.SESSION, dest, path,
 278                                        name, inter, type.join(""), ret );
 279         }
 280
 281         //signals
 282         var signals = temp[i].getElementsByTagName("signal");
 283         for ( var j = 0, jl = signals.length; j < jl; j ++){
 284             name = signals[j].getAttribute("name");
 285             ret[name] = dbus.getSignal(window.DBus.SESSION,
 286                                        inter, name, null,
 287                                        this.object_path, ret);
 288             ret[name].enabled = false;
 289             ret[name].onemit = null;
 290         }
 291         ret.xml = (new XMLSerializer()).serializeToString(doc);
 292         return ret;
 293         // break; //interface found
 294     }
 295     return null;
 296 };
 297
 298 /**
 299     *  @constructor
 300     *  @class This method uses the <code>Introspect</code> method on the standard
 301     *  <code>org.freedesktop.DBus.Introspectable</code> interface to map a given
 302     *  D-Bus interface to a JavaScript object. The produced object works as
 303     *  <code>this</code> in all its methods.<br/> Note that introspecting is
 304     *  not done asynchronously so the function call will block until the service
 305     *  responds.
 306     *  <br/>
 307     *  for example:<br/>
 308     *  <code>
 309     *  var myinterface = DBus.getInterface( mydest, mypath, myinterface);<br/>
 310     *  var myname = "";<br/>
 311     *  myinterface.getName.onreply = function(name){<br/>
 312     *  &nbsp;&nbsp;myname = name;<br/>
 313     *  };<br/>
 314     *  myinterface.getName.onerror = function(message){<br/>
 315     *  &nbsp;&nbsp;alert('name getting failed:'+message );<br/>
 316     *  };<br/>
 317     *  myinterface.getName( me );<br/>
 318     *  </code>
 319     *  @param dest {String} destination
 320     *  @param path {String} object path
 321     *  @param inter {String} interface
 322     */
 323 DBus.prototype.getInterface = function(dest, path, inter){
 324     var doc = null;
 325     var introspect = dbus.getMethod(dbus.SESSION, dest, path,
 326                                     "Introspect",
 327                                     "org.freedesktop.DBus.Introspectable" );
 328     introspect.onreply = function(s){
 329         doc = s.replace(/^\s*|\s*$/g,"");
 330     };
 331     introspect.onerror = function(s){
 332         doc = null;
 333     };
 334     introspect.async = false;
 335     introspect();
 336
 337     if (doc === null) {
 338         return null;
 339     }
 340
 341     doc = (new DOMParser()).parseFromString(doc, "text/xml");
 342
 343     return this.parseInterface(doc, dest, path, inter);
 344 };
 345
 346 /* Conversion functions for default conversion types
 347  * These are offered mainly just for completeness, there is usually no point in
 348  * actually using them...
 349  */
 350 DBus.prototype.Boolean = function (val) { return val; };
 351 DBus.prototype.Double = function (val) { return val; };
 352 DBus.prototype.String = function (val) { return val; };
 353 DBus.prototype.Array = function (val) { return val; };
 354 DBus.prototype.Dict = function (val) { return val; };