Implement IR apis.

- device_ir_is_available : Check whether ir is available
- device_ir_transmit : Send IR command

Change-Id: Ib96cc19675d6d1b5cb7fc2c0a635ef5ed99bc83d
Signed-off-by: pr.jung <pr.jung@samsung.com>

diff --git a/include/ir.h b/include/ir.h
index 1c8bea0..ad4fbd4 100755 (executable)
--- a/include/ir.h
+++ b/include/ir.h
@@ -18,6 +18,7 @@
 #ifndef __TIZEN_SYSTEM_IR_H__
 #define __TIZEN_SYSTEM_IR_H__
 
+#include <stdbool.h>
 #include "device-error.h"
 
 #ifdef __cplusplus

diff --git a/src/dbus.c b/src/dbus.c
index 497096f..a9528e2 100644 (file)
--- a/src/dbus.c
+++ b/src/dbus.c
@@ -50,12 +50,20 @@ static int g_dbus_error_to_errno(int code)
 static GVariant *append_g_variant(const char *sig, char *param[])
 {
        GVariantBuilder builder;
+       GVariantBuilder *sub_builder;
+       GVariant *var;
+       struct dbus_int *array_int;
        char *ch;
-       int i;
+       int i, j;
 
        if (!sig || !param)
                return NULL;
 
+       if (!g_variant_type_string_is_valid(sig)) {
+               _D("type string is invalid");
+               return NULL;
+       }
+
        g_variant_builder_init(&builder, G_VARIANT_TYPE_TUPLE);
 
        for (ch = (char*)sig, i = 0; *ch != '\0'; ++i, ++ch) {
@@ -72,6 +80,22 @@ static GVariant *append_g_variant(const char *sig, char *param[])
                case 's':
                        g_variant_builder_add(&builder, "s", param[i]);
                        break;
+               case 'a':
+                       ++ch;
+                       switch (*ch) {
+                       case 'i':
+                               sub_builder = g_variant_builder_new(G_VARIANT_TYPE("ai"));
+                               array_int = (struct dbus_int *)param[i];
+                               for (j = 0; j < array_int->size; j++)
+                                       g_variant_builder_add(sub_builder, "i", array_int->list[j]);
+                               var = g_variant_new("ai", sub_builder);
+                               g_variant_builder_unref(sub_builder);
+                               g_variant_builder_add_value(&builder, var);
+                               break;
+                       default:
+                               break;
+                       }
+                       break;
                default:
                        return NULL;
                }
@@ -127,6 +151,12 @@ int dbus_method_sync(const char *dest, const char *path,
                        NULL,                         /* GCancellable */
                        &err);
        if (!output) {
+               if (!err) {
+                       _E("g_dbus_proxy_call_sync error : %s-%s",
+                                       interface, method);
+                       g_object_unref(proxy);
+                       return result;
+               }
                _E("g_dbus_proxy_call_sync error : %s-%s (%d-%s)",
                                interface, method, err->code, err->message);
                result = g_dbus_error_to_errno(err->code);

diff --git a/src/dbus.h b/src/dbus.h
index eb4da1f..0f32297 100644 (file)
--- a/src/dbus.h
+++ b/src/dbus.h
@@ -46,6 +46,15 @@
 #define DEVICED_PATH_POWER                  DEVICED_OBJECT_PATH"/Power"
 #define DEVICED_INTERFACE_POWER             DEVICED_INTERFACE_NAME".power"
 
+/* IR service: transmit IR commands */
+#define DEVICED_PATH_IR                  DEVICED_OBJECT_PATH"/Ir"
+#define DEVICED_INTERFACE_IR             DEVICED_INTERFACE_NAME".ir"
+
+struct dbus_int {
+       int *list;
+       int size;
+};
+
 int dbus_method_sync(const char *dest, const char *path,
                const char *interface, const char *method,
                const char *sig, char *param[]);

diff --git a/src/ir.c b/src/ir.c
index faf7dc1..35f7bb1 100644 (file)
--- a/src/ir.c
+++ b/src/ir.c
@@ -15,17 +15,59 @@
  */
 
 #include <stdio.h>
-#include <stdbool.h>
 
 #include "ir.h"
+#include "common.h"
+#include "dbus.h"
+
+#define METHOD_IS_AVAILABLE            "IRIsAvailable"
+#define METHOD_TRANSMIT                        "TransmitIR"
 
 int device_ir_is_available(bool *available)
 {
-       *available = false;
+       int ret;
+
+       if (!available)
+               return DEVICE_ERROR_INVALID_PARAMETER;
+
+       ret = dbus_method_sync(DEVICED_BUS_NAME, DEVICED_PATH_IR,
+                       DEVICED_INTERFACE_IR, METHOD_IS_AVAILABLE,
+                       NULL, NULL);
+
+       if (ret < 0)
+               return DEVICE_ERROR_OPERATION_FAILED;
+
+       *available = ret;
        return DEVICE_ERROR_NONE;
 }
 
 int device_ir_transmit(int carrier_frequency, int *pattern, int size)
 {
+       char *arr[1];
+       struct dbus_int pattern_list;
+       int freq_pattern[size + 1];
+       int ret;
+       int i;
+
+       if (size <= 0) {
+               _D("IR pattern size is invalid");
+               return DEVICE_ERROR_INVALID_PARAMETER;
+       }
+
+       freq_pattern[0] = carrier_frequency;
+       for (i = 1; i <= size; i++)
+               freq_pattern[i] = pattern[i-1];
+
+       pattern_list.list = freq_pattern;
+       pattern_list.size = size + 1;
+       arr[0] = (char *)&pattern_list;
+
+       ret = dbus_method_sync(DEVICED_BUS_NAME, DEVICED_PATH_IR,
+                       DEVICED_INTERFACE_IR, METHOD_TRANSMIT,
+                       "ai", arr);
+
+       if (ret < 0)
+               return DEVICE_ERROR_OPERATION_FAILED;
+
        return DEVICE_ERROR_NONE;
-}
\ No newline at end of file
+}