src/display.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 <errno.h>
  20 #include <vconf.h>
  21 #include <libsyscommon/dbus-system.h>
  22
  23 #include "hal-display.h"
  24 #include "common.h"
  25
  26 #define METHOD_GET_DISPLAY_COUNT        "GetDisplayCount"
  27 #define METHOD_GET_MAX_BRIGHTNESS       "GetMaxBrightness"
  28 #define METHOD_GET_BRIGHTNESS           "GetBrightness"
  29 #define METHOD_SET_BRIGHTNESS           "SetBrightness"
  30 #define METHOD_CHANGE_STATE             "changestate"
  31 #define METHOD_CHANGE_STATE_BY_REASON   "ChangeStateByReason"
  32
  33 #define STR_LCD_OFF   "lcdoff"
  34 #define STR_LCD_DIM   "lcddim"
  35 #define STR_LCD_ON    "lcdon"
  36
  37 static int display_cnt = -1;
  38 struct display {
  39         int normal_max;
  40         int dim_max;
  41 } *display_arr;
  42
  43 static int alloc_display(void)
  44 {
  45         int i;
  46
  47         if (display_cnt < 0)
  48                 return -ENODEV;
  49
  50         display_arr = malloc(sizeof(struct display) * display_cnt);
  51         if (!display_arr)
  52                 return -ENOMEM;
  53
  54         for (i = 0; i < display_cnt; ++i) {
  55                 display_arr[i].normal_max = -1;
  56                 display_arr[i].dim_max = -1;
  57         }
  58
  59         return 0;
  60 }
  61
  62 int device_display_get_numbers(int *device_number)
  63 {
  64         int ret;
  65
  66         ret = is_display_supported();
  67         if (!ret)
  68                 return DEVICE_ERROR_NOT_SUPPORTED;
  69
  70         if (!device_number)
  71                 return DEVICE_ERROR_INVALID_PARAMETER;
  72
  73         /* if it is a first request */
  74         if (display_cnt < 0) {
  75                 ret = dbus_handle_method_sync_var(DEVICED_BUS_NAME,
  76                                 DEVICED_PATH_DISPLAY, DEVICED_INTERFACE_DISPLAY,
  77                                 METHOD_GET_DISPLAY_COUNT, NULL);
  78                 if (ret < 0)
  79                         return errno_to_device_error(ret); //LCOV_EXCL_LINE System Error
  80                 display_cnt = ret;
  81                 alloc_display();
  82         }
  83
  84         *device_number = display_cnt;
  85         _I("device_number : %d", *device_number);
  86         return DEVICE_ERROR_NONE;
  87 }
  88
  89 int device_display_get_max_brightness(int display_index, int *max_brightness)
  90 {
  91         int ret;
  92
  93         ret = is_display_supported();
  94         if (!ret)
  95                 return DEVICE_ERROR_NOT_SUPPORTED;
  96
  97         if (!max_brightness)
  98                 return DEVICE_ERROR_INVALID_PARAMETER;
  99
 100         if (display_cnt < 0) {
 101                 ret = device_display_get_numbers(&display_cnt);
 102                 if (ret != DEVICE_ERROR_NONE) //LCOV_EXCL_LINE System Error
 103                         return ret;
 104         }
 105
 106         if (display_index < 0 || display_index >= display_cnt)
 107                 return DEVICE_ERROR_INVALID_PARAMETER;
 108
 109         if (!display_arr && alloc_display() < 0)
 110                 return DEVICE_ERROR_OPERATION_FAILED;
 111
 112         if (display_arr[display_index].normal_max < 0) {
 113                 ret = dbus_handle_method_sync_var(DEVICED_BUS_NAME,
 114                                 DEVICED_PATH_DISPLAY, DEVICED_INTERFACE_DISPLAY,
 115                                 METHOD_GET_MAX_BRIGHTNESS, g_variant_new("(i)", (int)DISPLAY_STATE_NORMAL));
 116                 if (ret < 0)
 117                         return errno_to_device_error(ret); //LCOV_EXCL_LINE System Error
 118                 display_arr[display_index].normal_max = ret;
 119         }
 120
 121         *max_brightness = display_arr[display_index].normal_max;
 122         return DEVICE_ERROR_NONE;
 123 }
 124
 125 int device_display_get_brightness(int display_index, int *brightness)
 126 {
 127         int ret;
 128
 129         ret = is_display_supported();
 130         if (!ret)
 131                 return DEVICE_ERROR_NOT_SUPPORTED;
 132
 133         if (!brightness)
 134                 return DEVICE_ERROR_INVALID_PARAMETER;
 135
 136         if (display_cnt < 0) {
 137                 ret = device_display_get_numbers(&display_cnt);
 138                 if (ret != DEVICE_ERROR_NONE) //LCOV_EXCL_LINE System Error
 139                         return ret;
 140         }
 141
 142         if (display_index < 0 || display_index >= display_cnt)
 143                 return DEVICE_ERROR_INVALID_PARAMETER;
 144
 145         ret = dbus_handle_method_sync_var(DEVICED_BUS_NAME,
 146                         DEVICED_PATH_DISPLAY, DEVICED_INTERFACE_DISPLAY,
 147                         METHOD_GET_BRIGHTNESS, g_variant_new("(i)", (int)DISPLAY_STATE_NORMAL));
 148         if (ret < 0)
 149                 return errno_to_device_error(ret); //LCOV_EXCL_LINE System Error
 150
 151         *brightness = ret;
 152         return DEVICE_ERROR_NONE;
 153 }
 154
 155 int device_display_set_brightness(int display_index, int brightness)
 156 {
 157         int ret, max;
 158
 159         ret = is_display_supported();
 160         if (!ret)
 161                 return DEVICE_ERROR_NOT_SUPPORTED;
 162
 163         if (display_cnt < 0) {
 164                 ret = device_display_get_numbers(&display_cnt);
 165                 if (ret != DEVICE_ERROR_NONE) //LCOV_EXCL_LINE System Error
 166                         return ret;
 167         }
 168
 169         if (display_index < 0 || display_index >= display_cnt)
 170                 return DEVICE_ERROR_INVALID_PARAMETER;
 171
 172         if (display_arr[display_index].normal_max < 0)
 173                 device_display_get_max_brightness(display_index, &max);
 174
 175         if (brightness < 0 || brightness > display_arr[display_index].normal_max)
 176                 return DEVICE_ERROR_INVALID_PARAMETER;
 177
 178         ret = dbus_handle_method_sync_var(DEVICED_BUS_NAME,
 179                         DEVICED_PATH_DISPLAY, DEVICED_INTERFACE_DISPLAY,
 180                         METHOD_SET_BRIGHTNESS, g_variant_new("(ii)", (int)DISPLAY_STATE_NORMAL, brightness));
 181         if (ret < 0)
 182                 return errno_to_device_error(ret); //LCOV_EXCL_LINE System Error
 183
 184         return DEVICE_ERROR_NONE;
 185 }
 186
 187 int device_display_get_state(display_state_e *state)
 188 {
 189         int ret, val;
 190
 191         ret = is_display_supported();
 192         if (!ret)
 193                 return DEVICE_ERROR_NOT_SUPPORTED;
 194
 195         if (!state)
 196                 return DEVICE_ERROR_INVALID_PARAMETER;
 197
 198         ret = vconf_get_int(VCONFKEY_PM_STATE, &val);
 199         if (ret < 0)
 200                 return DEVICE_ERROR_OPERATION_FAILED;
 201
 202         if (val == VCONFKEY_PM_STATE_NORMAL)
 203                 *state = DISPLAY_STATE_NORMAL;
 204         else if (val == VCONFKEY_PM_STATE_LCDDIM)
 205                 *state = DISPLAY_STATE_SCREEN_DIM;
 206         else if (val == VCONFKEY_PM_STATE_LCDOFF || val == VCONFKEY_PM_STATE_SLEEP)
 207                 *state = DISPLAY_STATE_SCREEN_OFF;
 208         else
 209                 return DEVICE_ERROR_OPERATION_FAILED;
 210
 211         return DEVICE_ERROR_NONE;
 212 }
 213
 214 static char *get_state_str(display_state_e state)
 215 {
 216         switch (state) {
 217         case DISPLAY_STATE_NORMAL:
 218                 return STR_LCD_ON;
 219         case DISPLAY_STATE_SCREEN_DIM:
 220                 return STR_LCD_DIM;
 221         case DISPLAY_STATE_SCREEN_OFF:
 222                 return STR_LCD_OFF;
 223         default:
 224                 break;
 225         }
 226         return NULL;
 227 }
 228
 229 static void change_cb(GVariant *result, void *data, GError *err)
 230 {
 231         int ret;
 232
 233         if (!result) {
 234 //LCOV_EXCL_START System Error
 235                 _E("no message : %s", err->message);
 236                 return;
 237 //LCOV_EXCL_STOP
 238         }
 239
 240         g_variant_get(result, "(i)", &ret);
 241         _D("%s-%s : %d", DEVICED_INTERFACE_DISPLAY, METHOD_CHANGE_STATE, ret);
 242 }
 243
 244 int device_display_change_state(display_state_e state)
 245 {
 246         char *str;
 247         int ret;
 248         static int privilege = -1;
 249         static long num_calls = 0;
 250
 251         ret = is_display_state_supported();
 252         if (!ret)
 253                 return DEVICE_ERROR_NOT_SUPPORTED;
 254
 255         if (check_async_call_rate(&num_calls) < 0) {
 256 //LCOV_EXCL_START System Error
 257                 _E("Rejected by too frequent calls; %d (calls per sec.) limit is violated."
 258                                 , CHECK_RATE_THRESHOLD);
 259                 return DEVICE_ERROR_OPERATION_FAILED;
 260 //LCOV_EXCL_STOP
 261         }
 262
 263         if (state < DISPLAY_STATE_NORMAL || state > DISPLAY_STATE_SCREEN_OFF)
 264                 return DEVICE_ERROR_INVALID_PARAMETER;
 265
 266         if (privilege < 0) {
 267                 ret = dbus_handle_method_sync_var(DEVICED_BUS_NAME,
 268                                 DEVICED_PATH_DISPLAY, DEVICED_INTERFACE_DISPLAY,
 269                                 METHOD_CHANGE_STATE, g_variant_new("(s)", "privilege check"));
 270 //LCOV_EXCL_START System Error
 271                 if (ret < 0)
 272                         return errno_to_device_error(ret); //LCOV_EXCL_LINE System Error
 273 //LCOV_EXCL_STOP
 274                 else
 275                         privilege = 1;
 276         }
 277
 278         str = get_state_str(state);
 279         if (!str)
 280                 return DEVICE_ERROR_INVALID_PARAMETER;
 281
 282         ret = dbus_handle_method_async_with_reply_var(DEVICED_BUS_NAME,
 283                         DEVICED_PATH_DISPLAY, DEVICED_INTERFACE_DISPLAY,
 284                         METHOD_CHANGE_STATE, g_variant_new("(s)", str), change_cb, -1, NULL);
 285
 286         if (ret < 0)
 287                 ret = errno_to_device_error(ret); //LCOV_EXCL_LINE System Error
 288
 289         return ret;
 290 }
 291
 292 int device_display_get_max_brightness_state(int display_index, display_state_e state, int *brightness)
 293 {
 294         int ret;
 295
 296         ret = is_display_supported();
 297         if (!ret)
 298                 return DEVICE_ERROR_NOT_SUPPORTED;
 299
 300         if (!brightness)
 301                 return DEVICE_ERROR_INVALID_PARAMETER;
 302
 303         if (state > DISPLAY_STATE_SCREEN_DIM)
 304                 return DEVICE_ERROR_INVALID_PARAMETER;
 305
 306         if (display_cnt < 0) {
 307                 ret = device_display_get_numbers(&display_cnt);
 308                 if (ret != DEVICE_ERROR_NONE) //LCOV_EXCL_LINE System Error
 309                         return ret;
 310         }
 311
 312         if (display_index < 0 || display_index >= display_cnt)
 313                 return DEVICE_ERROR_INVALID_PARAMETER;
 314
 315         if (!display_arr && alloc_display() < 0)
 316                 return DEVICE_ERROR_OPERATION_FAILED;
 317
 318         ret = dbus_handle_method_sync_var(DEVICED_BUS_NAME,
 319                                 DEVICED_PATH_DISPLAY, DEVICED_INTERFACE_DISPLAY,
 320                                 METHOD_GET_MAX_BRIGHTNESS, g_variant_new("(i)", (int)state));
 321         if (ret < 0)
 322                 return errno_to_device_error(ret); //LCOV_EXCL_LINE System Error
 323
 324         if (state == DISPLAY_STATE_NORMAL) {
 325                 display_arr[display_index].normal_max = ret;
 326                 *brightness = display_arr[display_index].normal_max;
 327         } else {
 328                 display_arr[display_index].dim_max = ret;
 329                 *brightness = display_arr[display_index].dim_max;
 330         }
 331
 332         return DEVICE_ERROR_NONE;
 333 }
 334 //LCOV_EXCL_STOP
 335
 336 int device_display_get_brightness_state(int display_index, display_state_e state, int *brightness)
 337 {
 338         int ret;
 339
 340         ret = is_display_supported();
 341         if (!ret)
 342                 return DEVICE_ERROR_NOT_SUPPORTED;
 343
 344         if (!brightness)
 345                 return DEVICE_ERROR_INVALID_PARAMETER;
 346
 347         if (state > DISPLAY_STATE_SCREEN_DIM)
 348                 return DEVICE_ERROR_INVALID_PARAMETER;
 349
 350         if (display_cnt < 0) {
 351                 ret = device_display_get_numbers(&display_cnt);
 352                 if (ret != DEVICE_ERROR_NONE) //LCOV_EXCL_LINE System Error
 353                         return ret;
 354         }
 355
 356         if (display_index < 0 || display_index >= display_cnt)
 357                 return DEVICE_ERROR_INVALID_PARAMETER;
 358
 359         ret = dbus_handle_method_sync_var(DEVICED_BUS_NAME,
 360                         DEVICED_PATH_DISPLAY, DEVICED_INTERFACE_DISPLAY,
 361                         METHOD_GET_BRIGHTNESS, g_variant_new("(i)", (int)state));
 362         if (ret < 0)
 363                 return errno_to_device_error(ret); //LCOV_EXCL_LINE System Error
 364
 365         *brightness = ret;
 366
 367         return DEVICE_ERROR_NONE;
 368 }
 369
 370 int device_display_set_brightness_state(int display_index, display_state_e state, int brightness)
 371 {
 372         int ret, max;
 373
 374         ret = is_display_supported();
 375         if (!ret)
 376                 return DEVICE_ERROR_NOT_SUPPORTED;
 377
 378         if (display_cnt < 0) {
 379                 ret = device_display_get_numbers(&display_cnt);
 380                 if (ret != DEVICE_ERROR_NONE) //LCOV_EXCL_LINE System Error
 381                         return ret;
 382         }
 383
 384         if (state > DISPLAY_STATE_SCREEN_DIM)
 385                 return DEVICE_ERROR_INVALID_PARAMETER;
 386
 387         if (display_index < 0 || display_index >= display_cnt)
 388                 return DEVICE_ERROR_INVALID_PARAMETER;
 389
 390         switch (state) {
 391         case DISPLAY_STATE_NORMAL:
 392                 if (display_arr[display_index].normal_max < 0)
 393                         device_display_get_max_brightness_state(display_index, DISPLAY_STATE_NORMAL, &max);
 394                 if (brightness < 0 || brightness > display_arr[display_index].normal_max)
 395                         return DEVICE_ERROR_INVALID_PARAMETER;
 396                 break;
 397         case DISPLAY_STATE_SCREEN_DIM:
 398                 if (display_arr[display_index].dim_max < 0)
 399                         device_display_get_max_brightness_state(display_index, DISPLAY_STATE_SCREEN_DIM, &max);
 400                 if (brightness < 0 || brightness > display_arr[display_index].dim_max)
 401                         return DEVICE_ERROR_INVALID_PARAMETER;
 402                 break;
 403         default:
 404                 break;
 405         }
 406
 407         ret = dbus_handle_method_sync_var(DEVICED_BUS_NAME,
 408                         DEVICED_PATH_DISPLAY, DEVICED_INTERFACE_DISPLAY,
 409                         METHOD_SET_BRIGHTNESS, g_variant_new("(ii)", (int)state, brightness));
 410         if (ret < 0)
 411                 return errno_to_device_error(ret); //LCOV_EXCL_LINE System Error
 412
 413         return DEVICE_ERROR_NONE;
 414 }
 415
 416 int device_display_change_state_by_reason(display_state_e type, const char *reason, int timeout, dbus_pending_cb cb)
 417 {
 418         int ret;
 419
 420         ret = dbus_handle_method_async_with_reply_var(DEVICED_BUS_NAME,
 421                         DEVICED_PATH_DISPLAY, DEVICED_INTERFACE_DISPLAY,
 422                         METHOD_CHANGE_STATE_BY_REASON, g_variant_new("(isi)", (int)type, reason, timeout), cb, -1, NULL);
 423
 424         return errno_to_device_error(ret);
 425 }