src/led.c

   1 /*
   2  * Copyright (c) 2011 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
  18 #include <stdio.h>
  19 #include <stdbool.h>
  20 #include <errno.h>
  21 #include <system_info.h>
  22
  23 #include "led.h"
  24 #include "led-internal.h"
  25 #include "common.h"
  26 #include "dbus.h"
  27
  28 #define METHOD_GET_MAX_BRIGHTNESS       "GetMaxBrightness"
  29 #define METHOD_GET_BRIGHTNESS           "GetBrightness"
  30 #define METHOD_SET_BRIGHTNESS           "SetBrightness"
  31 #define METHOD_PLAY_CUSTOM              "playcustom"
  32 #define METHOD_GET_LED_NUMBER           "GetNumOfLeds"
  33 #define METHOD_MULTI_LED_CONTROL        "multi_led_control"
  34 #define METHOD_STOP_CUSTOM              "stopcustom"
  35
  36 #define FRONT_LED_FEATURE               "tizen.org/feature/led"
  37 #define CAMERA_LED_FEATURE              "tizen.org/feature/camera.back.flash"
  38
  39 static bool support_front_led;
  40 static bool support_camera_led;
  41 static int number_of_devices = -1;
  42
  43 static void __CONSTRUCTOR__ init(void)
  44 {
  45         int ret;
  46         bool val;
  47
  48         ret = system_info_get_platform_bool(FRONT_LED_FEATURE, &val);
  49         if (ret == SYSTEM_INFO_ERROR_NONE && val)
  50                 support_front_led = true;
  51
  52         ret = system_info_get_platform_bool(CAMERA_LED_FEATURE, &val);
  53         if (ret == SYSTEM_INFO_ERROR_NONE && val)
  54                 support_camera_led = true;
  55 }
  56
  57 int device_flash_get_max_brightness(int *max_brightness)
  58 {
  59         int ret;
  60
  61         if (!support_camera_led)
  62                 return DEVICE_ERROR_NOT_SUPPORTED;
  63
  64         if (!max_brightness)
  65                 return DEVICE_ERROR_INVALID_PARAMETER;
  66
  67         ret = dbus_method_sync_var(DEVICED_BUS_NAME,
  68                         DEVICED_PATH_LED, DEVICED_INTERFACE_LED,
  69                         METHOD_GET_MAX_BRIGHTNESS, NULL);
  70         if (ret < 0)
  71                 return errno_to_device_error(ret); //LCOV_EXCL_LINE System Error
  72
  73         *max_brightness = ret;
  74         return DEVICE_ERROR_NONE;
  75 }
  76
  77 int device_flash_get_brightness(int *brightness)
  78 {
  79         int ret;
  80
  81         if (!support_camera_led)
  82                 return DEVICE_ERROR_NOT_SUPPORTED;
  83
  84         if (!brightness)
  85                 return DEVICE_ERROR_INVALID_PARAMETER;
  86
  87         ret = dbus_method_sync_var(DEVICED_BUS_NAME,
  88                         DEVICED_PATH_LED, DEVICED_INTERFACE_LED,
  89                         METHOD_GET_BRIGHTNESS, NULL);
  90         if (ret < 0)
  91                 return errno_to_device_error(ret); //LCOV_EXCL_LINE System Error
  92
  93         *brightness = ret;
  94         return DEVICE_ERROR_NONE;
  95 }
  96
  97 int device_flash_set_brightness(int brightness)
  98 {
  99         int max, ret;
 100
 101         if (!support_camera_led)
 102                 return DEVICE_ERROR_NOT_SUPPORTED;
 103
 104         ret = device_flash_get_max_brightness(&max);
 105         if (ret < 0)
 106                 return ret;
 107
 108         if (brightness < 0 || brightness > max)
 109                 return DEVICE_ERROR_INVALID_PARAMETER;
 110
 111         /* if camera API preempt a flash device, it will return -EBUSY error. */
 112         ret = dbus_method_sync_var(DEVICED_BUS_NAME,
 113                         DEVICED_PATH_LED, DEVICED_INTERFACE_LED,
 114                         METHOD_SET_BRIGHTNESS, g_variant_new("(ii)", brightness, 0));
 115         if (ret < 0)
 116                 return errno_to_device_error(ret); //LCOV_EXCL_LINE System Error
 117
 118         return DEVICE_ERROR_NONE;
 119 }
 120
 121 int device_led_play_custom(int on, int off, unsigned int color, unsigned int flags)
 122 {
 123         int ret;
 124
 125         if (!support_front_led)
 126                 return DEVICE_ERROR_NOT_SUPPORTED;
 127
 128         if (on < 0 || off < 0)
 129                 return DEVICE_ERROR_INVALID_PARAMETER;
 130
 131         ret = dbus_method_sync_var(DEVICED_BUS_NAME,
 132                         DEVICED_PATH_LED, DEVICED_INTERFACE_LED,
 133                         METHOD_PLAY_CUSTOM, g_variant_new("(iiuu)", on, off, (unsigned int)color, (unsigned int)flags));
 134 //LCOV_EXCL_START System Error
 135         if (ret < 0)
 136                 return errno_to_device_error(ret);
 137 //LCOV_EXCL_STOP
 138         return DEVICE_ERROR_NONE;
 139 }
 140
 141 int device_led_stop_custom(void)
 142 {
 143         int ret;
 144
 145         if (!support_front_led)
 146                 return DEVICE_ERROR_NOT_SUPPORTED;
 147
 148         ret = dbus_method_sync_var(DEVICED_BUS_NAME,
 149                         DEVICED_PATH_LED, DEVICED_INTERFACE_LED,
 150                         METHOD_STOP_CUSTOM, NULL);
 151 //LCOV_EXCL_START System Error
 152         if (ret < 0)
 153                 return errno_to_device_error(ret);
 154 //LCOV_EXCL_STOP
 155
 156         return DEVICE_ERROR_NONE;
 157 }
 158
 159 //LCOV_EXCL_START Not used function
 160 int device_multi_led_get_number(int *num_of_leds)
 161 {
 162         int ret;
 163
 164         if (!support_front_led)
 165                 return DEVICE_ERROR_NOT_SUPPORTED;
 166
 167         if (!num_of_leds)
 168                 return DEVICE_ERROR_INVALID_PARAMETER;
 169
 170         if (number_of_devices < 0) {
 171                 ret = dbus_method_sync_var(DEVICED_BUS_NAME,
 172                                 DEVICED_PATH_LED, DEVICED_INTERFACE_LED,
 173                                 METHOD_GET_LED_NUMBER, NULL);
 174                 if (ret < 0)
 175                         return errno_to_device_error(ret); //LCOV_EXCL_LINE System Error
 176                 number_of_devices = ret;
 177         }
 178
 179         *num_of_leds = number_of_devices;
 180
 181         return DEVICE_ERROR_NONE;
 182 }
 183
 184 int device_multi_led_control(unsigned int color[])
 185 {
 186         GVariantBuilder *builder = NULL;
 187         GVariant *var = NULL;
 188         int i, ret;
 189
 190         if (!support_front_led)
 191                 return DEVICE_ERROR_NOT_SUPPORTED;
 192
 193         if (color == NULL)
 194                 return DEVICE_ERROR_INVALID_PARAMETER;
 195
 196         if (number_of_devices < 0) {
 197                 ret = device_multi_led_get_number(&number_of_devices);
 198                 if (ret != DEVICE_ERROR_NONE) //LCOV_EXCL_LINE System Error
 199                         return ret;
 200         }
 201
 202         builder = g_variant_builder_new(G_VARIANT_TYPE("au"));
 203         for (i = 0; i < number_of_devices; i++)
 204                 g_variant_builder_add(builder, "u", color[i]);
 205
 206         var = g_variant_new("(au)", builder);
 207         g_variant_builder_unref(builder);
 208
 209         return dbus_method_sync_var(DEVICED_BUS_NAME, DEVICED_PATH_LED,
 210                                 DEVICED_INTERFACE_LED, METHOD_MULTI_LED_CONTROL, var);
 211 }
 212 //LCOV_EXCL_STOP