src/device.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 <string.h>
  20 #include <errno.h>
  21 #include <dd-display.h>
  22 #include <dd-battery.h>
  23 #include <vconf.h>
  24
  25 #include "device.h"
  26 #include "common.h"
  27
  28 #define CHECK_ERR(val)  \
  29         do {    \
  30                 if (val < 0) {          \
  31                         if (errno == ENODEV)    \
  32                                 return DEVICE_ERROR_NOT_SUPPORTED;      \
  33                         return DEVICE_ERROR_OPERATION_FAILED;   \
  34                 }       \
  35         } while(0)
  36
  37 int device_get_display_numbers(int* device_number)
  38 {
  39         if(device_number == NULL)
  40                 return DEVICE_ERROR_INVALID_PARAMETER;
  41
  42         *device_number = display_get_count();
  43         CHECK_ERR(*device_number);
  44
  45         return DEVICE_ERROR_NONE;
  46 }
  47
  48 int device_get_brightness(int disp_idx, int* value)
  49 {
  50         int val, max_id, ret;
  51
  52         if(value == NULL)
  53                 return DEVICE_ERROR_INVALID_PARAMETER;
  54
  55         ret = device_get_display_numbers(&max_id);
  56         if (ret != DEVICE_ERROR_NONE)
  57                 return ret;
  58
  59         if(disp_idx < 0 || disp_idx >= max_id)
  60                 return DEVICE_ERROR_INVALID_PARAMETER;
  61
  62         val = display_get_brightness();
  63         CHECK_ERR(val);
  64
  65         *value = val;
  66         return DEVICE_ERROR_NONE;
  67 }
  68
  69 int device_set_brightness(int disp_idx, int new_value)
  70 {
  71         int max_value, val, max_id, ret;
  72
  73         if(new_value < 0)
  74                 return DEVICE_ERROR_INVALID_PARAMETER;
  75
  76         ret = device_get_display_numbers(&max_id);
  77         if (ret != DEVICE_ERROR_NONE)
  78                 return ret;
  79
  80         if(disp_idx < 0 || disp_idx >= max_id)
  81                 return DEVICE_ERROR_INVALID_PARAMETER;
  82
  83         ret = device_get_max_brightness(disp_idx, &max_value);
  84         if (ret != DEVICE_ERROR_NONE)
  85                 return ret;
  86
  87         if(new_value > max_value)
  88                 return DEVICE_ERROR_INVALID_PARAMETER;
  89
  90         val = display_set_brightness(new_value);
  91         CHECK_ERR(val);
  92
  93         return DEVICE_ERROR_NONE;
  94 }
  95
  96 int device_get_max_brightness(int disp_idx, int* max_value)
  97 {
  98         int val, max_id, ret;
  99
 100         if(max_value == NULL)
 101                 return DEVICE_ERROR_INVALID_PARAMETER;
 102
 103         ret = device_get_display_numbers(&max_id);
 104         _E("max id : %d", max_id);
 105         if (ret != DEVICE_ERROR_NONE)
 106                 return ret;
 107
 108         if(disp_idx < 0 || disp_idx >= max_id)
 109                 return DEVICE_ERROR_INVALID_PARAMETER;
 110
 111         val = display_get_max_brightness();
 112         CHECK_ERR(val);
 113
 114         *max_value = val;
 115         return DEVICE_ERROR_NONE;
 116 }
 117
 118 int device_set_brightness_from_settings(int disp_idx)
 119 {
 120         int max_id, val, ret;
 121
 122         ret = device_get_display_numbers(&max_id);
 123         if (ret != DEVICE_ERROR_NONE)
 124                 return ret;
 125
 126         if(disp_idx < 0 || disp_idx >= max_id)
 127                 return DEVICE_ERROR_INVALID_PARAMETER;
 128
 129         val = display_release_brightness();
 130         CHECK_ERR(val);
 131
 132         return DEVICE_ERROR_NONE;
 133 }
 134
 135 int device_set_brightness_to_settings(int disp_idx, int new_value)
 136 {
 137         int max_value, val, max_id, ret;
 138
 139         if(new_value < 0)
 140                 return DEVICE_ERROR_INVALID_PARAMETER;
 141
 142         ret = device_get_display_numbers(&max_id);
 143         if (ret != DEVICE_ERROR_NONE)
 144                 return ret;
 145
 146         if(disp_idx < 0 || disp_idx >= max_id)
 147                 return DEVICE_ERROR_INVALID_PARAMETER;
 148
 149         ret = device_get_max_brightness(disp_idx, &max_value);
 150         if (ret != DEVICE_ERROR_NONE)
 151                 return ret;
 152
 153         if(new_value > max_value)
 154                 return DEVICE_ERROR_INVALID_PARAMETER;
 155
 156         val = display_set_brightness_with_setting(new_value);
 157         CHECK_ERR(val);
 158
 159         return DEVICE_ERROR_NONE;
 160 }
 161
 162 int device_battery_get_detail(int *percent)
 163 {
 164         _E("Deprecated api. Use device_battery_get_percent()");
 165         return DEVICE_ERROR_NOT_SUPPORTED;
 166 }
 167
 168 int device_battery_is_full(bool* full)
 169 {
 170         if (full == NULL)
 171                 return DEVICE_ERROR_INVALID_PARAMETER;
 172
 173         int f = battery_is_full();
 174         CHECK_ERR(f);
 175
 176         *full = (f == 1) ? true : false;
 177         return DEVICE_ERROR_NONE;
 178 }
 179
 180 int device_battery_get_remaining_time(device_battery_remaining_time_type_e type, int *time)
 181 {
 182         _E("Deprecated api.");
 183         return DEVICE_ERROR_NOT_SUPPORTED;
 184 }
 185
 186 int device_battery_set_remaining_time_changed_cb(device_battery_remaining_time_type_e type,
 187                 device_battery_remaining_time_changed_cb callback, void* user_data)
 188 {
 189         _E("Deprecated api.");
 190         return DEVICE_ERROR_NOT_SUPPORTED;
 191 }
 192
 193 int device_battery_unset_remaining_time_changed_cb(device_battery_remaining_time_type_e type)
 194 {
 195         _E("Deprecated api.");
 196         return DEVICE_ERROR_NOT_SUPPORTED;
 197 }
 198
 199 static device_battery_cb changed_callback = NULL;
 200 static void* changed_callback_user_data = NULL;
 201
 202 static void battery_changed_inside_cb(keynode_t* key, void* user_data)
 203 {
 204         const char* keyname = vconf_keynode_get_name(key);
 205
 206         if (keyname != NULL && changed_callback != NULL && strcmp(keyname, VCONFKEY_SYSMAN_BATTERY_CAPACITY) == 0) {
 207                 int percent = 0;
 208                 if (vconf_get_int(VCONFKEY_SYSMAN_BATTERY_CAPACITY, &percent) == 0) {
 209                         changed_callback(percent, changed_callback_user_data);
 210                 }
 211         }
 212 }
 213
 214 int device_battery_set_cb(device_battery_cb callback, void* user_data)
 215 {
 216         // VCONFKEY_SYSMAN_BATTERY_CAPACITY
 217         int err;
 218         if (callback == NULL)
 219                 return DEVICE_ERROR_INVALID_PARAMETER;
 220
 221         changed_callback = callback;
 222         changed_callback_user_data = user_data;
 223
 224         err = vconf_notify_key_changed(VCONFKEY_SYSMAN_BATTERY_CAPACITY, battery_changed_inside_cb, NULL);
 225         if (err < 0)
 226                 return DEVICE_ERROR_INVALID_PARAMETER;
 227
 228         return DEVICE_ERROR_NONE;
 229 }
 230
 231 int device_battery_unset_cb(void)
 232 {
 233         int err = vconf_ignore_key_changed(VCONFKEY_SYSMAN_BATTERY_CAPACITY, battery_changed_inside_cb);
 234         if (err < 0)
 235                 return DEVICE_ERROR_OPERATION_FAILED;
 236
 237         changed_callback = NULL;
 238         changed_callback_user_data = NULL;
 239
 240         return DEVICE_ERROR_NONE;
 241 }
 242
 243 int device_battery_get_warning_status(device_battery_warn_e *status)
 244 {
 245         if (status == NULL)
 246                 return DEVICE_ERROR_INVALID_PARAMETER;
 247
 248         int value, err;
 249
 250         err = vconf_get_int(VCONFKEY_SYSMAN_BATTERY_STATUS_LOW, &value);
 251         if (err < 0)
 252                 return DEVICE_ERROR_OPERATION_FAILED;
 253
 254         if (value == VCONFKEY_SYSMAN_BAT_POWER_OFF) {
 255                 *status = DEVICE_BATTERY_WARN_EMPTY;
 256         } else if (value == VCONFKEY_SYSMAN_BAT_CRITICAL_LOW) {
 257                 *status = DEVICE_BATTERY_WARN_CRITICAL;
 258         } else if (value == VCONFKEY_SYSMAN_BAT_WARNING_LOW) {
 259                 *status = DEVICE_BATTERY_WARN_LOW;
 260         } else if (value == VCONFKEY_SYSMAN_BAT_NORMAL) {
 261                 *status = DEVICE_BATTERY_WARN_NORMAL;
 262         } else if (value == VCONFKEY_SYSMAN_BAT_FULL) {
 263                 *status = DEVICE_BATTERY_WARN_FULL;
 264         } else {
 265                 return DEVICE_ERROR_OPERATION_FAILED;
 266         }
 267
 268         return DEVICE_ERROR_NONE;
 269 }
 270
 271 static device_battery_warn_cb warn_changed_callback = NULL;
 272 static void* warn_changed_callback_user_data = NULL;
 273
 274 static void battery_warn_changed_inside_cb(keynode_t* key, void* user_data)
 275 {
 276         const char* keyname = vconf_keynode_get_name(key);
 277
 278         if (keyname != NULL && warn_changed_callback != NULL && strcmp(keyname, VCONFKEY_SYSMAN_BATTERY_STATUS_LOW) == 0) {
 279                 int bat_state = 0;
 280                 if (vconf_get_int(VCONFKEY_SYSMAN_BATTERY_STATUS_LOW, &bat_state) == 0) {
 281                         warn_changed_callback(bat_state-1, warn_changed_callback_user_data);
 282                 }
 283         }
 284 }
 285
 286 int device_battery_warning_set_cb(device_battery_warn_cb callback, void* user_data)
 287 {
 288         // VCONFKEY_SYSMAN_BATTERY_STATUS_LOW
 289         int err;
 290
 291         if (callback == NULL)
 292                 return DEVICE_ERROR_INVALID_PARAMETER;
 293
 294         warn_changed_callback = callback;
 295         warn_changed_callback_user_data = user_data;
 296
 297         err = vconf_notify_key_changed(VCONFKEY_SYSMAN_BATTERY_STATUS_LOW, battery_warn_changed_inside_cb, NULL);
 298         if (err < 0)
 299                 return DEVICE_ERROR_INVALID_PARAMETER;
 300
 301         return DEVICE_ERROR_NONE;
 302 }
 303
 304 int device_battery_warning_unset_cb(void)
 305 {
 306         int err = vconf_ignore_key_changed(VCONFKEY_SYSMAN_BATTERY_STATUS_LOW, battery_warn_changed_inside_cb);
 307         if (err < 0)
 308                 return DEVICE_ERROR_OPERATION_FAILED;
 309
 310         warn_changed_callback = NULL;
 311         warn_changed_callback_user_data = NULL;
 312
 313         return DEVICE_ERROR_NONE;
 314 }