added async version of vehicle.get

Change-Id: Ida4cef5c0e9229841d05db99928009b9864919fc

diff --git a/packaging/wrt-plugins-ivi.changes b/packaging/wrt-plugins-ivi.changes
index a46d0bd..71d15ee 100644 (file)
--- a/packaging/wrt-plugins-ivi.changes
+++ b/packaging/wrt-plugins-ivi.changes
@@ -1,3 +1,6 @@
+* Thu Jan 23 2013 <kevron.m.rees@intel.com>
+- Added vehicle.getAsync() method
+
 * Wed Dec 11 2013 <kevron.m.rees@intel.com>
 - Fixed crash when using locale
 

diff --git a/packaging/wrt-plugins-ivi.spec b/packaging/wrt-plugins-ivi.spec
index f8bbc98..628d017 100644 (file)
--- a/packaging/wrt-plugins-ivi.spec
+++ b/packaging/wrt-plugins-ivi.spec
@@ -1,6 +1,6 @@
 Name:       wrt-plugins-ivi
 Summary:    JavaScript plugins for WebRuntime for IVI
-Version:    0.12.1
+Version:    0.13.0
 Release:    1
 Group:      Development/Libraries
 License:    Apache-2.0

diff --git a/src/Vehicle/JSVehicle.cpp b/src/Vehicle/JSVehicle.cpp
index b135f8f..c50dd7c 100644 (file)
--- a/src/Vehicle/JSVehicle.cpp
+++ b/src/Vehicle/JSVehicle.cpp
@@ -44,6 +44,7 @@ JSClassDefinition JSVehicle::m_classInfo = {
 
 JSStaticFunction JSVehicle::m_function[] = {
        { "get", JSVehicle::get, kJSPropertyAttributeNone },
+       { "getAsync", JSVehicle::getAsync, kJSPropertyAttributeNone },
        { "subscribe", JSVehicle::subscribe, kJSPropertyAttributeNone },
        { "supported", JSVehicle::supported, kJSPropertyAttributeNone },
        { "set", JSVehicle::set, kJSPropertyAttributeNone },
@@ -183,6 +184,47 @@ JSValueRef JSVehicle::get(JSContextRef context,
        //return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Unknown Error");
 }
 
+JSValueRef JSVehicle::getAsync(JSContextRef context,
+               JSObjectRef object,
+               JSObjectRef thisObject,
+               size_t argumentCount,
+               const JSValueRef arguments[],
+               JSValueRef* exception)
+{
+       LoggerD("Entered async");
+       //Try {
+               VehiclePrivObject* privateObject = static_cast<VehiclePrivObject*>(JSObjectGetPrivate(thisObject));
+               if (NULL == privateObject)
+               {
+                       LoggerE("private object is null");
+                       return JSValueMakeUndefined(context);
+               }
+
+               LoggerD("Validating arguments: " << argumentCount);
+               
+               ArgumentValidator validator(context, argumentCount, arguments);
+               std::string property = validator.toString(0);
+
+               JSObjectRef cb = validator.toFunction(1,true);
+
+               JSObjectRef errorCb = validator.toFunction(2,true);
+
+               JSValueProtect(context, cb);
+               JSValueProtect(context, errorCb);
+
+               int zone = validator.toNumber(3, true);
+
+               LoggerD("property to get: " << property << " in zone " << zone);
+               
+               JSContextRef gContext = privateObject->getContext();
+
+               VehiclePtr vehicle(privateObject->getObject());
+
+               vehicle->get(property, cb, errorCb, gContext, zone );
+
+               return JSValueMakeUndefined(context);
+}
+
 JSValueRef JSVehicle::subscribe(JSContextRef context,
                                JSObjectRef object,
                                JSObjectRef thisObject,

diff --git a/src/Vehicle/JSVehicle.h b/src/Vehicle/JSVehicle.h
index 74cabd8..39326d9 100644 (file)
--- a/src/Vehicle/JSVehicle.h
+++ b/src/Vehicle/JSVehicle.h
@@ -45,6 +45,12 @@ private:
                                size_t argumentCount,
                                const JSValueRef arguments[],
                                JSValueRef* exception);
+       static JSValueRef getAsync(JSContextRef context,
+                               JSObjectRef object,
+                               JSObjectRef thisObject,
+                               size_t argumentCount,
+                               const JSValueRef arguments[],
+                               JSValueRef* exception);
        
        static JSValueRef subscribe(JSContextRef context,
                                JSObjectRef object,

diff --git a/src/Vehicle/Vehicle.cpp b/src/Vehicle/Vehicle.cpp
index 2ff6eec..8a8441e 100644 (file)
--- a/src/Vehicle/Vehicle.cpp
+++ b/src/Vehicle/Vehicle.cpp
@@ -31,11 +31,11 @@ public:
 
 GVariant* jsValueToGVariant(JSContextRef ctx, JSValueRef jsVal, std::string signature)
 {
-       LoggerD("Entered");
+       LoggerE("Entered");
 
        JSType type = JSValueGetType(ctx, jsVal);
 
-       LoggerD("JSType: " << type <<" signature: "<<signature);
+       LoggerE("JSType: " << type <<" signature: "<<signature);
 
        Converter converter(ctx);
 
@@ -121,7 +121,7 @@ static void signalCallback( GDBusConnection *connection,
                                                          GVariant *parameters,
                                                          gpointer user_data)
 {
-       LoggerD("Entered");
+       LoggerE("Entered");
 
        VehicleMaster* master = static_cast<VehicleMaster*>(user_data);
 
@@ -146,18 +146,18 @@ static void signalCallback( GDBusConnection *connection,
        char* key;
        GVariant *value;
 
-       LoggerD("argument type: " << g_variant_get_type_string(valueArray));
+       LoggerE("argument type: " << g_variant_get_type_string(valueArray));
        g_variant_iter_init(&iter,valueArray);
 
        ObjectZone object(master->objectPathToObjectNameMap[object_path]);
 
-       LoggerD("Object name is: "<<object.name);
-       LoggerD("Object zone is: "<<object.zone);
-       LoggerD("number of items in the array: " << g_variant_iter_n_children(&iter));
+       LoggerE("Object name is: "<<object.name);
+       LoggerE("Object zone is: "<<object.zone);
+       LoggerE("number of items in the array: " << g_variant_iter_n_children(&iter));
 
        while(g_variant_iter_next(&iter,"{sv}", &key, &value))
        {
-               LoggerD("setting key: "<<key);
+               LoggerE("setting key: "<<key);
 
                if(master->objectToPropertyValuesMap[object].find(key) == master->objectToPropertyValuesMap[object].end())
                {
@@ -179,7 +179,7 @@ static void signalCallback( GDBusConnection *connection,
 
 std::map<std::string, GVariant*> VehicleMaster::get(std::string property, int zone)
 {
-       LoggerD("Entered");
+       LoggerE("Entered");
        
        std::map<std::string, GVariant*> returnValue;
        
@@ -189,11 +189,11 @@ std::map<std::string, GVariant*> VehicleMaster::get(std::string property, int zo
 
        if(objPStr == "")
        {
-               LoggerD("could not find property " << property);
+               LoggerE("could not find property " << property);
                return returnValue;
        }
 
-       LoggerD("Getting properties interface");
+       LoggerE("Getting properties interface");
        
        GDBusProxy* propertiesProxy = g_dbus_proxy_new_for_bus_sync(G_BUS_TYPE_SYSTEM, G_DBUS_PROXY_FLAGS_NONE, NULL,
                                                                                                                                 "org.automotive.message.broker",
@@ -207,7 +207,7 @@ std::map<std::string, GVariant*> VehicleMaster::get(std::string property, int zo
 
        if(error)
        {
-               LoggerD("failed to call GetAll on interface " << interfaceName);
+               LoggerE("failed to call GetAll on interface " << interfaceName);
                g_object_unref(propertiesProxy);
                g_error_free(error);
                return returnValue;
@@ -228,10 +228,129 @@ std::map<std::string, GVariant*> VehicleMaster::get(std::string property, int zo
        return returnValue;
 }
 
+void VehicleMaster::get(std::string property, JSObjectRef successCallback, JSObjectRef errorCallback, JSContextRef context, int zone)
+{
+       LoggerE("Async Entered");
+               
+       GError* error = NULL;
+       
+       std::string objPStr = findProperty(property, zone);
+
+       if(objPStr == "")
+       {
+               LoggerE("could not find property " << property);
+               return;
+       }
+
+       LoggerE("Getting properties interface");
+       
+       GDBusProxy* propertiesProxy = g_dbus_proxy_new_for_bus_sync(G_BUS_TYPE_SYSTEM, G_DBUS_PROXY_FLAGS_NONE, NULL,
+                                                                                                                                "org.automotive.message.broker",
+                                                                                                                                objPStr.c_str(),
+                                                                                                                                "org.freedesktop.DBus.Properties",
+                                                                                                                                NULL,
+                                                                                                                                &error);
+
+       if(error)
+       {
+               LoggerE("failed to get properties proxy");
+               g_error_free(error);
+               return;
+       }
+
+       std::string interfaceName = "org.automotive." + property;
+
+       VehicleSubscribeCB * cbObj = new VehicleSubscribeCB;
+
+       cbObj->callback = successCallback;
+       cbObj->errorCallback = errorCallback;
+       cbObj->context = context;
+
+       g_dbus_proxy_call(propertiesProxy, "GetAll", g_variant_new("(s)", interfaceName.c_str()), G_DBUS_CALL_FLAGS_NONE, -1, NULL,[](GObject* source, GAsyncResult* res, gpointer user_data)
+       {
+               LoggerE("GetAll() method call completed");
+
+               GError * error= nullptr;
+       
+               GVariant* propertyMap = g_dbus_proxy_call_finish (G_DBUS_PROXY (source), res, &error);
+               
+               if(error)
+               {
+                       LoggerE("failed to call GetAll on interface.");
+                       g_error_free(error);
+                       return;
+               }
+
+               VehicleSubscribeCB * cbObj = static_cast<VehicleSubscribeCB*>(user_data);
+
+               if(!cbObj)
+               {
+                       return;
+               }
+
+               GVariantIter* iter;
+               char* key;
+               GVariant *value;
+               
+               std::map<std::string, GVariant*> returnValue;
+
+               g_variant_get(propertyMap,"(a{sv})",&iter);
+
+               while(g_variant_iter_next(iter,"{sv}", &key, &value))
+               {
+                       returnValue[key] = value;
+               }
+               
+               std::stringstream json;
+                               
+               json<<"{";
+
+               for(auto itr = returnValue.begin(); itr != returnValue.end(); itr++)
+               {
+                       if(json.str() != "{") json<<",";
+
+                       std::string key = (*itr).first;
+
+                       /// make key lowerCamelCase:
+                       std::transform(key.begin(), key.begin()+1, key.begin(), ::tolower);
+
+                       GVariant* var = (*itr).second;
+
+                       gsize size;
+
+                       LoggerE("get variant type: " << g_variant_get_type_string(var));
+                       json<<"\""<<key<<"\" : "<<json_gvariant_serialize_data(var,&size);
+
+                       g_variant_unref(var);
+
+               }
+
+               json << "}";
+
+               Converter converter(cbObj->context);
+               
+               LoggerE("get json: " << json.str().c_str());
+
+               JSStringRef jsonString = converter.toJSStringRef(json.str());
+
+               JSValueRef val =  JSValueMakeFromJSONString(cbObj->context, jsonString);
+
+               const JSValueRef arguments[1] = { val };
+
+               LoggerE("calling callback");
+               JSObjectCallAsFunction(cbObj->context, cbObj->callback, NULL, 1, arguments, NULL);
+               LoggerE("finished calling callback");
+
+               delete cbObj;
+
+       }, cbObj);
+
+}
+
 void VehicleMaster::subscribe(std::string objectName, JSObjectRef successCallback, JSContextRef context, int zone)
 {
-       LoggerD("Entered");
-       LoggerD("Subscribing to " << objectName << " in zone: " << zone);
+       LoggerE("Entered");
+       LoggerE("Subscribing to " << objectName << " in zone: " << zone);
 
        ObjectZone object(objectName,zone);
 
@@ -265,7 +384,7 @@ void VehicleMaster::subscribe(std::string objectName, JSObjectRef successCallbac
 
                if(error)
                {
-                       LoggerD("failed to call GetAll on interface " << interfaceName<< " "<<error->message);
+                       LoggerE("failed to call GetAll on interface " << interfaceName<< " "<<error->message);
                        ///TODO: call error callback
                        return;
                }
@@ -278,7 +397,7 @@ void VehicleMaster::subscribe(std::string objectName, JSObjectRef successCallbac
 
                while(g_variant_iter_next(iter,"{sv}", &key, &value))
                {
-                       LoggerD("Setting initial value for " << key);
+                       LoggerE("Setting initial value for " << key);
                        objectToPropertyValuesMap[object][key] = value;
                }
 
@@ -290,7 +409,7 @@ void VehicleMaster::subscribe(std::string objectName, JSObjectRef successCallbac
        }
 
        else {
-               LoggerD("Already subscribed to " << objectName);
+               LoggerE("Already subscribed to " << objectName);
        }
 
        VehicleSubscribeCB cb;
@@ -299,12 +418,12 @@ void VehicleMaster::subscribe(std::string objectName, JSObjectRef successCallbac
 
        objectToFunctionListMap[object].push_back(cb);
 
-       LoggerD("Successfully subscribed!");
+       LoggerE("Successfully subscribed!");
 }
 
 GDBusProxy* VehicleMaster::automotiveManager()
 {
-       LoggerD("Entered");
+       LoggerE("Entered");
 
        if(mAutomotiveManager) return mAutomotiveManager;
 
@@ -320,7 +439,7 @@ GDBusProxy* VehicleMaster::automotiveManager()
 
 std::string VehicleMaster::findProperty(std::string objectName, int zone)
 {
-       LoggerD("Entered");
+       LoggerE("Entered");
        GDBusProxy* managerProxy = automotiveManager();
 
        GError *error = nullptr;
@@ -329,24 +448,24 @@ std::string VehicleMaster::findProperty(std::string objectName, int zone)
 
        if(error)
        {
-               LoggerD("error calling FindObjectForZone "<< error->message);
-               LoggerD("Could not find object in zone "<< zone );
+               LoggerE("error calling FindObjectForZone "<< error->message);
+               LoggerE("Could not find object in zone "<< zone );
                g_error_free(error);
                return "";
        }
 
        if(!objectPath)
        {
-               LoggerD("Could not find object in zone "<< zone );
+               LoggerE("Could not find object in zone "<< zone );
                return "";
        }
 
-       LoggerD("returned object path: " << g_variant_get_type_string(objectPath));
+       LoggerE("returned object path: " << g_variant_get_type_string(objectPath));
 
        gchar * objP;
        g_variant_get(objectPath,"(o)", &objP);
 
-       LoggerD("FindObjectForZone() returned object path: " <<objP);
+       LoggerE("FindObjectForZone() returned object path: " <<objP);
 
        g_variant_unref(objectPath);
 
@@ -355,7 +474,7 @@ std::string VehicleMaster::findProperty(std::string objectName, int zone)
 
 void VehicleMaster::onSignalReceived(ObjectZone objectName, std::map<std::string, GVariant*> propertyMap)
 {
-       LoggerD("Entered");
+       LoggerE("Entered");
 
        std::string json = mapToJSon(propertyMap);
 
@@ -365,7 +484,7 @@ void VehicleMaster::onSignalReceived(ObjectZone objectName, std::map<std::string
 
        if(!cbs.size())
        {
-               LoggerD("No callbacks for this signal.  aborting");
+               LoggerE("No callbacks for this signal.  aborting");
                return;
        }
 
@@ -386,9 +505,9 @@ void VehicleMaster::onSignalReceived(ObjectZone objectName, std::map<std::string
        {
                VehicleSubscribeCB cb = *itr;
 
-               LoggerD("calling callback");
+               LoggerE("calling callback");
                JSObjectCallAsFunction(cb.context, cb.callback, NULL, 1, arguments, NULL);
-               LoggerD("finished calling callback");
+               LoggerE("finished calling callback");
        }
        }catch(...)
        {
@@ -398,7 +517,7 @@ void VehicleMaster::onSignalReceived(ObjectZone objectName, std::map<std::string
 
 GVariant* VehicleMaster::listObjects()
 {
-       LoggerD("Entered");
+       LoggerE("Entered");
 
        GDBusProxy* managerProxy = automotiveManager();
 
@@ -408,7 +527,7 @@ GVariant* VehicleMaster::listObjects()
 
        if(error)
        {
-               LoggerD("error calling list "<< error->message);
+               LoggerE("error calling list "<< error->message);
                g_error_free(error);
                
                if(supportedList)
@@ -422,13 +541,13 @@ GVariant* VehicleMaster::listObjects()
 
 VehicleMaster::ErrorType VehicleMaster::set(std::string objectName, std::map<std::string, JSValueRef> values, JSContextRef context, int zone)
 {
-       LoggerD("Entered");
+       LoggerE("Entered");
 
        std::string objectPath = findProperty(objectName, zone);
 
        if(objectPath == "")
        {
-               LoggerD("Object not found.  Check object Name and zone.");
+               LoggerE("Object not found.  Check object Name and zone.");
                return InvalidArguments;
        }
 
@@ -442,7 +561,7 @@ VehicleMaster::ErrorType VehicleMaster::set(std::string objectName, std::map<std
                                                                                                                         &error);
        std::string interfaceName = "org.automotive." + objectName;
 
-       LoggerD("Trace");
+       LoggerE("Trace");
 
        for(auto itr = values.begin(); itr != values.end(); itr++)
        {
@@ -450,7 +569,7 @@ VehicleMaster::ErrorType VehicleMaster::set(std::string objectName, std::map<std
                GError* err = nullptr;
                std::string property = (*itr).first;
 
-               LoggerD("trying to set property "<< property);
+               LoggerE("trying to set property "<< property);
                
                /// First, get the value so we know the signature:
                
@@ -458,7 +577,7 @@ VehicleMaster::ErrorType VehicleMaster::set(std::string objectName, std::map<std
 
                if(err || varValue == nullptr)
                {
-                       LoggerD("error getting initial property signature type.");
+                       LoggerE("error getting initial property signature type.");
 
                        g_error_free(err);
                        err = nullptr;
@@ -466,23 +585,23 @@ VehicleMaster::ErrorType VehicleMaster::set(std::string objectName, std::map<std
                        return Unknown;
                }
 
-               LoggerD("Trace");
+               LoggerE("Trace");
 
-               LoggerD("var value type: "<<g_variant_get_type_string(varValue));
+               LoggerE("var value type: "<<g_variant_get_type_string(varValue));
 
                GVariant* getValue;
                g_variant_get(varValue, "(v)", &getValue);
 
                if(!getValue)
                {
-                       LoggerD("Error getting variant value");
+                       LoggerE("Error getting variant value");
                        g_object_unref(propertiesProxy);
                        g_variant_unref(varValue);
                        return Unknown;
                }
 
                GVariant *value = jsValueToGVariant(context, (*itr).second, g_variant_get_type_string(getValue));
-               LoggerD("Trace");
+               LoggerE("Trace");
 
                if(!value)
                {
@@ -491,34 +610,34 @@ VehicleMaster::ErrorType VehicleMaster::set(std::string objectName, std::map<std
                        return Unknown;
                }
 
-               LoggerD("calling Set");
+               LoggerE("calling Set");
 
                g_dbus_proxy_call_sync(propertiesProxy, "Set", g_variant_new("(ssv)", interfaceName.c_str(), property.c_str(), value), G_DBUS_CALL_FLAGS_NONE, -1, NULL, &err);
 
-               LoggerD("set called");
+               LoggerE("set called");
 
                g_variant_unref(value);
                g_variant_unref(varValue);
                g_variant_unref(getValue);
 
-               LoggerD("cleaned up");
+               LoggerE("cleaned up");
 
                if(err)
                {
-                       LoggerD("error setting property:" << err->message);
+                       LoggerE("error setting property:" << err->message);
                        /// TODO: return proper ErrorType here: 
                        g_object_unref(propertiesProxy);
 
                        if(err->code == G_IO_ERROR_PERMISSION_DENIED || std::string(g_dbus_error_get_remote_error(err)) == "org.freedesktop.DBus.Error.AccessDenied")
                        {
-                               LoggerD("permission denied");
+                               LoggerE("permission denied");
                                return PermissionDenied;
                        }
 
                        return Unknown;
                }
 
-               LoggerD("set was probably successful");
+               LoggerE("set was probably successful");
        }
        g_object_unref(propertiesProxy);
 
@@ -527,7 +646,7 @@ VehicleMaster::ErrorType VehicleMaster::set(std::string objectName, std::map<std
 
 void VehicleMaster::getHistory(std::string objectName, int zone, double begin, double end, JSObjectRef successCallback, JSObjectRef errorCallback, JSContextRef context)
 {
-       LoggerD("Entered");
+       LoggerE("Entered");
 
        std::string objectPath = findProperty(objectName, zone);
 
@@ -544,7 +663,7 @@ void VehicleMaster::getHistory(std::string objectName, int zone, double begin, d
 
        auto cb = [](GObject* source, GAsyncResult *res, gpointer user_data)
        {
-               LoggerD("GetHistory DBus call completed");
+               LoggerE("GetHistory DBus call completed");
                
                GError *error = nullptr;
                GVariant *result;
@@ -559,28 +678,28 @@ void VehicleMaster::getHistory(std::string objectName, int zone, double begin, d
 
                if(error)
                {
-                       LoggerD("error getting history: "<<error->message);
-                       LoggerD("pre-error-callback");
+                       LoggerE("error getting history: "<<error->message);
+                       LoggerE("pre-error-callback");
                        const JSValueRef arguments[1] = { JSValueMakeNumber(histCb.context, 10) };
                        JSObjectCallAsFunction(histCb.context, histCb.errorCallback, NULL, 1, arguments, NULL);
-                       LoggerD("post error callback");
+                       LoggerE("post error callback");
                        return;
                }
 
-               LoggerD("TRACE");
+               LoggerE("TRACE");
                
                GVariantIter* iter;
                char* key;
                GVariant *value;
                double time;
 
-               LoggerD("variant sig type: "<<g_variant_get_type_string(result));
+               LoggerE("variant sig type: "<<g_variant_get_type_string(result));
 
                g_variant_get(result,"(a(svd))",&iter);
 
                gsize s = g_variant_iter_n_children(iter);
 
-               LoggerD("Results: "<<s);
+               LoggerE("Results: "<<s);
 
                std::list<std::string > superList;
                std::map<std::string, GVariant*> obj;
@@ -601,7 +720,7 @@ void VehicleMaster::getHistory(std::string objectName, int zone, double begin, d
 
                int i=0;
 
-               LoggerD("populating array");
+               LoggerE("populating array");
 
                for(auto itr = superList.begin(); itr != superList.end(); itr++)
                {
@@ -614,15 +733,15 @@ void VehicleMaster::getHistory(std::string objectName, int zone, double begin, d
                        JSStringRelease(jsonString);
                }
 
-               LoggerD("making array");
+               LoggerE("making array");
 
                JSObjectRef jsresult = JSObjectMakeArray(histCb.context, superList.size(), values, NULL);
 
                const JSValueRef arguments[1] = { jsresult };
 
-               LoggerD("calling callback");
+               LoggerE("calling callback");
                JSObjectCallAsFunction(histCb.context, histCb.callback, NULL, 1, arguments, NULL);
-               LoggerD("finished calling callback");
+               LoggerE("finished calling callback");
 
                JSValueUnprotect(histCb.context, histCb.callback);
                JSValueUnprotect(histCb.context, histCb.errorCallback);
@@ -647,7 +766,7 @@ void VehicleMaster::getHistory(std::string objectName, int zone, double begin, d
 
 GVariant* VehicleMaster::listZones(std::string objectName)
 {
-       LoggerD("Entered");
+       LoggerE("Entered");
 
        GDBusProxy* managerProxy = automotiveManager();
 
@@ -657,7 +776,7 @@ GVariant* VehicleMaster::listZones(std::string objectName)
 
        if(error)
        {
-               LoggerD("error calling listZones "<< error->message);
+               LoggerE("error calling listZones "<< error->message);
                g_error_free(error);
 
                if(supportedList)

diff --git a/src/Vehicle/Vehicle.h b/src/Vehicle/Vehicle.h
index e2698f6..669bfab 100644 (file)
--- a/src/Vehicle/Vehicle.h
+++ b/src/Vehicle/Vehicle.h
@@ -70,6 +70,8 @@ public:
        VehicleMaster();
 
        std::map<std::string, GVariant*> get(std::string property, int zone);
+       
+       void get(std::string property, JSObjectRef successCallback, JSObjectRef errorCb, JSContextRef context, int zone);
 
        void subscribe(std::string objectName, JSObjectRef successCallback, JSContextRef context, int zone);
 

diff --git a/src/Vehicle/Vehicle.idl b/src/Vehicle/Vehicle.idl
index 767e049..324b09a 100644 (file)
--- a/src/Vehicle/Vehicle.idl
+++ b/src/Vehicle/Vehicle.idl
@@ -78,6 +78,16 @@ interface Vehicle  {
         **/
        any get(DOMString objectType, optional short zone);
 
+
+        /**
+         *  \brief fetch the current value for 'objectType'
+         *  \param objectType is the requested property to be retrieved.
+         *  \param successCallback is called with the result of the call
+         *  \param errorCallback is called if there is an error
+         *  \param zone specify the zone in which this object type is in
+         **/
+        void getAsync(DOMString objectType, VehiclePropertyCallback successCallback, optional VehiclePropertyErrorCallback errorCb, optional short zone);
+
        /** \brief subscribe to the given property and get callbacks when it changes
         *  \param objectType property to set
         *  \param successCallback callback will be called when the "objectType" changes
@@ -880,3 +890,5 @@ interface DrivingMode : VehiclePropertyType {
        attribute unsigned short drivingMode;
 };
 
+
+