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
  19 #define LOG_TAG "TIZEN_SYSTEM_DEVICE"
  20
  21 #include <string.h>
  22 #include <stdio.h>
  23 #include <devman.h>
  24 #include <device.h>
  25 #include <errno.h>
  26 #include <dlog.h>
  27 #include <vconf.h>
  28
  29 #define _MSG_DEVICE_ERROR_INVALID_PARAMETER "Invalid parameter"
  30 #define _MSG_DEVICE_ERROR_OPERATION_FAILED "Operation failed"
  31
  32 #define RETURN_ERR_MSG(err_code, msg) \
  33     do { \
  34         LOGE("[%s] "_MSG_##err_code"(0x%08x) : %s", __FUNCTION__, err_code, msg); \
  35         return err_code; \
  36     }while(0)
  37
  38 #define RETURN_ERR(err_code) \
  39     do { \
  40         LOGE("[%s] "_MSG_##err_code"(0x%08x)", __FUNCTION__, err_code); \
  41         return err_code; \
  42     }while(0)
  43
  44 static int _display[] = {
  45     DEV_DISPLAY_0,
  46     DEV_DISPLAY_1,
  47 };
  48
  49 int device_get_display_numbers(int* device_number)
  50 {
  51     if(device_number == NULL)
  52         RETURN_ERR(DEVICE_ERROR_INVALID_PARAMETER);
  53
  54     *device_number = device_get_display_count();
  55     if(*device_number < 0)
  56         RETURN_ERR(DEVICE_ERROR_OPERATION_FAILED);
  57
  58     return DEVICE_ERROR_NONE;
  59 }
  60
  61 int device_battery_get_percent( int* percent )
  62 {
  63     if (percent == NULL) RETURN_ERR(DEVICE_ERROR_INVALID_PARAMETER);
  64
  65         int pct = device_get_battery_pct();
  66         if(pct < 0) {
  67         RETURN_ERR(DEVICE_ERROR_OPERATION_FAILED);
  68     }else{
  69                 *percent = pct;
  70     }
  71         return DEVICE_ERROR_NONE;
  72 }
  73
  74 int device_battery_is_full( bool* full )
  75 {
  76     if (full == NULL) RETURN_ERR(DEVICE_ERROR_INVALID_PARAMETER);
  77
  78     int f = device_get_battery_pct();
  79         if(f < 0) {
  80         RETURN_ERR(DEVICE_ERROR_OPERATION_FAILED);
  81     }
  82         else
  83                 *full = f == 100 ? true : false;
  84
  85         return DEVICE_ERROR_NONE;
  86 }
  87
  88 int device_get_brightness(int disp_idx, int* value)
  89 {
  90         int val, disp, max_id;
  91
  92     if(value == NULL) RETURN_ERR(DEVICE_ERROR_INVALID_PARAMETER);
  93
  94     if(device_get_display_numbers(&max_id) < 0)
  95         RETURN_ERR(DEVICE_ERROR_OPERATION_FAILED);
  96
  97     if(disp_idx < 0 || disp_idx >= max_id)
  98         RETURN_ERR(DEVICE_ERROR_INVALID_PARAMETER);
  99
 100     disp = _display[disp_idx];
 101
 102     if(value == NULL)
 103         RETURN_ERR(DEVICE_ERROR_INVALID_PARAMETER);
 104
 105         val = device_get_display_brt(disp);
 106
 107         if(val < 0) {
 108         RETURN_ERR(DEVICE_ERROR_OPERATION_FAILED);
 109     }
 110         else
 111                 *value = val;
 112
 113         return DEVICE_ERROR_NONE;
 114 }
 115
 116 int device_set_brightness(int disp_idx, int new_value)
 117 {
 118     int max_value, val;
 119         int disp, max_id;
 120
 121     if(device_get_display_numbers(&max_id) < 0)
 122         RETURN_ERR(DEVICE_ERROR_OPERATION_FAILED);
 123
 124     if(disp_idx < 0 || disp_idx >= max_id)
 125         RETURN_ERR(DEVICE_ERROR_INVALID_PARAMETER);
 126
 127     disp = _display[disp_idx];
 128
 129     if(new_value < 0)
 130         RETURN_ERR(DEVICE_ERROR_INVALID_PARAMETER);
 131
 132     device_get_max_brightness(disp, &max_value);
 133
 134     if(new_value > max_value)
 135         RETURN_ERR(DEVICE_ERROR_INVALID_PARAMETER);
 136
 137         val = device_set_display_brt(disp, new_value);
 138         if(val < 0) {
 139         RETURN_ERR(DEVICE_ERROR_OPERATION_FAILED);
 140     }
 141         return DEVICE_ERROR_NONE;
 142 }
 143
 144 int device_get_max_brightness(int disp_idx, int* max_value)
 145 {
 146         int val, disp, max_id;
 147
 148     if(device_get_display_numbers(&max_id) < 0)
 149         RETURN_ERR(DEVICE_ERROR_OPERATION_FAILED);
 150
 151     if(disp_idx < 0 || disp_idx >= max_id)
 152         RETURN_ERR(DEVICE_ERROR_INVALID_PARAMETER);
 153
 154     disp = _display[disp_idx];
 155
 156     if(max_value == NULL)
 157         RETURN_ERR(DEVICE_ERROR_INVALID_PARAMETER);
 158
 159         val = device_get_max_brt(disp);
 160
 161         if(val < 0) {
 162         RETURN_ERR(DEVICE_ERROR_OPERATION_FAILED);
 163     }
 164         else
 165                 *max_value = val;
 166
 167         return DEVICE_ERROR_NONE;
 168 }
 169
 170 int device_battery_is_charging(bool *charging)
 171 {
 172     // VCONFKEY_SYSMAN_BATTERY_CHARGE_NOW
 173     int value, err;
 174
 175     if(charging == NULL){
 176         RETURN_ERR(DEVICE_ERROR_INVALID_PARAMETER);
 177     }
 178
 179     err  = vconf_get_int(VCONFKEY_SYSMAN_BATTERY_CHARGE_NOW, &value);
 180
 181     if(err <0){
 182         RETURN_ERR(DEVICE_ERROR_OPERATION_FAILED);
 183     }
 184     if(value == 1){
 185         *charging = true;
 186     }else if(value == 0){
 187         *charging = false;
 188     }else{
 189         RETURN_ERR(DEVICE_ERROR_OPERATION_FAILED);
 190     }
 191     return DEVICE_ERROR_NONE;
 192 }
 193
 194 static device_battery_cb changed_callback = NULL;
 195 static void* changed_callback_user_data = NULL;
 196
 197 static void battery_changed_inside_cb(keynode_t* key, void* user_data)
 198 {
 199     char* keyname = vconf_keynode_get_name(key);
 200
 201     if(keyname != NULL && changed_callback != NULL && strcmp(keyname, VCONFKEY_SYSMAN_BATTERY_CAPACITY) == 0){
 202         int percent = 0;
 203         if(vconf_get_int(VCONFKEY_SYSMAN_BATTERY_CAPACITY, &percent) == 0){
 204             changed_callback(percent, changed_callback_user_data);
 205         }
 206     }
 207 }
 208
 209 int device_battery_set_cb(device_battery_cb callback, void* user_data)
 210 {
 211     // VCONFKEY_SYSMAN_BATTERY_CAPACITY
 212     int err;
 213     if(callback == NULL)
 214         RETURN_ERR(DEVICE_ERROR_INVALID_PARAMETER);
 215
 216     changed_callback = callback;
 217     changed_callback_user_data = user_data;
 218
 219     err = vconf_notify_key_changed(VCONFKEY_SYSMAN_BATTERY_CAPACITY, battery_changed_inside_cb, NULL);
 220     if(err < 0){
 221         RETURN_ERR(DEVICE_ERROR_INVALID_PARAMETER);
 222     }
 223
 224     return DEVICE_ERROR_NONE;
 225 }
 226 int device_battery_unset_cb(void)
 227 {
 228     int err = vconf_ignore_key_changed(VCONFKEY_SYSMAN_BATTERY_CAPACITY, battery_changed_inside_cb);
 229     if(err < 0){
 230         RETURN_ERR(DEVICE_ERROR_OPERATION_FAILED);
 231     }
 232     changed_callback = NULL;
 233     changed_callback_user_data = NULL;
 234
 235     return DEVICE_ERROR_NONE;
 236 }