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 #include <libsyscommon/dbus-system.h>
  23
  24 #include "led.h"
  25 #include "led-internal.h"
  26 #include "common.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_handle_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_handle_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_handle_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_handle_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
 139         return DEVICE_ERROR_NONE;
 140 }
 141
 142 int device_led_stop_custom(void)
 143 {
 144         int ret;
 145
 146         if (!support_front_led)
 147                 return DEVICE_ERROR_NOT_SUPPORTED;
 148
 149         ret = dbus_handle_method_sync_var(DEVICED_BUS_NAME,
 150                         DEVICED_PATH_LED, DEVICED_INTERFACE_LED,
 151                         METHOD_STOP_CUSTOM, NULL);
 152 //LCOV_EXCL_START System Error
 153         if (ret < 0)
 154                 return errno_to_device_error(ret);
 155 //LCOV_EXCL_STOP
 156
 157         return DEVICE_ERROR_NONE;
 158 }
 159
 160 //LCOV_EXCL_START Not tested API
 161 int device_multi_led_get_number(int *num_of_leds)
 162 {
 163         int ret;
 164
 165         if (!support_front_led)
 166                 return DEVICE_ERROR_NOT_SUPPORTED;
 167
 168         if (!num_of_leds)
 169                 return DEVICE_ERROR_INVALID_PARAMETER;
 170
 171         if (number_of_devices < 0) {
 172                 ret = dbus_handle_method_sync_var(DEVICED_BUS_NAME,
 173                                 DEVICED_PATH_LED, DEVICED_INTERFACE_LED,
 174                                 METHOD_GET_LED_NUMBER, NULL);
 175                 if (ret < 0)
 176                         return errno_to_device_error(ret); //LCOV_EXCL_LINE System Error
 177                 number_of_devices = ret;
 178         }
 179
 180         *num_of_leds = number_of_devices;
 181
 182         return DEVICE_ERROR_NONE;
 183 }
 184 //LCOV_EXCL_STOP
 185
 186 //LCOV_EXCL_START Not tested API
 187 int device_multi_led_control(unsigned int color[])
 188 {
 189         GVariantBuilder *builder = NULL;
 190         GVariant *var = NULL;
 191         int i, ret;
 192
 193         if (!support_front_led)
 194                 return DEVICE_ERROR_NOT_SUPPORTED;
 195
 196         if (color == NULL)
 197                 return DEVICE_ERROR_INVALID_PARAMETER;
 198
 199         if (number_of_devices < 0) {
 200                 ret = device_multi_led_get_number(&number_of_devices);
 201                 if (ret != DEVICE_ERROR_NONE) //LCOV_EXCL_LINE System Error
 202                         return ret;
 203         }
 204
 205         builder = g_variant_builder_new(G_VARIANT_TYPE("au"));
 206         for (i = 0; i < number_of_devices; i++)
 207                 g_variant_builder_add(builder, "u", color[i]);
 208
 209         var = g_variant_new("(au)", builder);
 210         g_variant_builder_unref(builder);
 211
 212         ret = dbus_handle_method_sync_var(DEVICED_BUS_NAME, DEVICED_PATH_LED,
 213                                 DEVICED_INTERFACE_LED, METHOD_MULTI_LED_CONTROL, var);
 214         if (ret < 0)
 215                 return errno_to_device_error(ret); //LCOV_EXCL_LINE System Error
 216
 217         return DEVICE_ERROR_NONE;
 218 }
 219 //LCOV_EXCL_STOP