src/haptic.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 #include <stdio.h>
  20 #include <stdlib.h>
  21 #include <unistd.h>
  22 #include <string.h>
  23 #include <stdbool.h>
  24 #include <haptic.h>
  25 #include <devman_haptic.h>
  26 #include <glib.h>
  27 #include <dlog.h>
  28
  29 #include "haptic_private.h"
  30
  31 #undef LOG_TAG
  32 #define LOG_TAG "TIZEN_SYSTEM_HAPTIC"
  33
  34 #define NOT_ASSIGNED -1
  35 #define VIBE_SILENCE -128
  36
  37 #define _MSG_HAPTIC_ERROR_INVALID_PARAMETER "Invalid parameter"
  38 #define _MSG_HAPTIC_ERROR_NO_SUCH_FILE "No such file"
  39 #define _MSG_HAPTIC_ERROR_NOT_SUPPORTED_FORMAT "Not supported format"
  40 #define _MSG_HAPTIC_ERROR_NOT_INITIALIZED "Not initialize"
  41 #define _MSG_HAPTIC_ERROR_OPERATION_FAILED "Operation failed"
  42
  43 #define RETURN_ERR_MSG(err_code, msg) \
  44     do { \
  45         LOGE("[%s] "_MSG_##err_code"(0x%08x) : %s", __FUNCTION__, err_code, msg); \
  46         return err_code; \
  47     }while(0)
  48
  49 #define RETURN_ERR(err_code) \
  50     do { \
  51         LOGE("[%s] "_MSG_##err_code"(0x%08x)", __FUNCTION__, err_code); \
  52         return err_code; \
  53     }while(0)
  54
  55 static int _DEV[] = {
  56     DEV_IDX_ALL,
  57     DEV_IDX_0,
  58     DEV_IDX_1,
  59 };
  60
  61 struct _vibe_pattern {
  62     haptic_vibration_iter_s *iters;
  63     int current;
  64     int size;
  65     int level;
  66     int iter_count;
  67     int pattern_index;
  68     int error;
  69 };
  70
  71 static const int UNDEFINED = 0;
  72 static const int START = 1;
  73
  74 GArray *pattern_table = NULL;
  75
  76 static int initialize = 0;
  77 static int max_device = 0;
  78
  79 static int* haptic_ids = NULL;
  80
  81 int haptic_get_count(int* vibrator_number)
  82 {
  83     int count;
  84     if(vibrator_number == NULL)
  85         RETURN_ERR(HAPTIC_ERROR_INVALID_PARAMETER);
  86
  87     count = device_haptic_get_device_count();
  88     if(count < 0)
  89         RETURN_ERR(HAPTIC_ERROR_OPERATION_FAILED);
  90
  91     *vibrator_number = count;
  92
  93     return HAPTIC_ERROR_NONE;
  94 }
  95
  96 int haptic_initialize()
  97 {
  98     int i, j;
  99     int id;
 100
 101     if(initialize)
 102         return HAPTIC_ERROR_NONE;
 103
 104
 105     if( haptic_get_count(&max_device) < 0)
 106         RETURN_ERR(HAPTIC_ERROR_OPERATION_FAILED);
 107
 108     haptic_ids = (int*)malloc(sizeof(int)*max_device+1); // max + zero
 109
 110     if(haptic_ids == NULL){
 111         RETURN_ERR(HAPTIC_ERROR_OPERATION_FAILED);
 112     }
 113
 114     for(i=0; i<=max_device; i++){
 115         id = device_haptic_open(_DEV[i], 0);
 116         if(id < 0) {
 117             for (j=i; j>=0; j--){
 118                 device_haptic_close(haptic_ids[j]);
 119             }
 120             RETURN_ERR(HAPTIC_ERROR_OPERATION_FAILED);
 121         }
 122
 123         haptic_ids[i] = id;
 124     }
 125
 126     initialize = 1;
 127
 128     pattern_table = g_array_new(FALSE, TRUE, sizeof(int));
 129
 130     _haptic_init();
 131
 132     return HAPTIC_ERROR_NONE;
 133 }
 134
 135 int haptic_deinitialize()
 136 {
 137 //    int err, i;
 138     int i;
 139
 140     if(!initialize)
 141         RETURN_ERR(HAPTIC_ERROR_NOT_INITIALIZED);
 142
 143     for(i=0; i<=max_device; i++){
 144 //        err = device_haptic_close(haptic_ids[i]);
 145         device_haptic_close(haptic_ids[i]);
 146     }
 147     initialize = 0;
 148     if(haptic_ids != NULL)
 149         free(haptic_ids);
 150
 151     g_array_free(pattern_table, TRUE);
 152     pattern_table = NULL;
 153
 154     _haptic_deinit();
 155
 156     return HAPTIC_ERROR_NONE;
 157 }
 158
 159
 160 int haptic_vibrate_monotone(int device_index, int duration_ms, int level)
 161 {
 162         int ret;
 163
 164         if(device_index < 0 || device_index > max_device)
 165                 RETURN_ERR(HAPTIC_ERROR_INVALID_PARAMETER);
 166
 167         if(level < HAPTIC_LEVEL_AUTO || level > HAPTIC_LEVEL_5)
 168                 RETURN_ERR(HAPTIC_ERROR_INVALID_PARAMETER);
 169
 170         device_index = ((device_index < 3) ? device_index : 0); // xxx
 171
 172         if(!initialize)
 173                 RETURN_ERR(HAPTIC_ERROR_NOT_INITIALIZED);
 174
 175         if(level == HAPTIC_LEVEL_0)
 176                 return HAPTIC_ERROR_NONE;
 177
 178         ret = device_haptic_play_monotone_with_detail_feedback_level(haptic_ids[device_index], duration_ms, level);
 179
 180         if(ret < 0){
 181                 if(ret == -2)
 182                         RETURN_ERR(HAPTIC_ERROR_OPERATION_FAILED);
 183                 else
 184                         RETURN_ERR(HAPTIC_ERROR_INVALID_PARAMETER);
 185         }
 186
 187         return HAPTIC_ERROR_NONE;
 188 }
 189
 190 int haptic_stop_device(int device_index)
 191 {
 192         int ret;
 193
 194     if(device_index < 0 || device_index > max_device)
 195         RETURN_ERR(HAPTIC_ERROR_INVALID_PARAMETER);
 196
 197     device_index = ((device_index < 3) ? device_index : 0); // xxx
 198
 199     if(!initialize)
 200         RETURN_ERR(HAPTIC_ERROR_NOT_INITIALIZED);
 201
 202         ret = device_haptic_stop_play(haptic_ids[device_index]);
 203
 204         if(ret < 0){
 205         if(ret == -2)
 206             RETURN_ERR(HAPTIC_ERROR_OPERATION_FAILED);
 207         else
 208             RETURN_ERR(HAPTIC_ERROR_INVALID_PARAMETER);
 209     }
 210
 211         return HAPTIC_ERROR_NONE;
 212 }
 213
 214 static int _haptic_play_monotone(int device_index, long duration, int level)
 215 {
 216         int ret;
 217
 218     if(device_index < 0 || device_index > max_device)
 219         RETURN_ERR(HAPTIC_ERROR_INVALID_PARAMETER);
 220
 221     device_index = ((device_index < 3) ? device_index : 0); // xxx
 222
 223     if(!initialize)
 224         RETURN_ERR(HAPTIC_ERROR_NOT_INITIALIZED);
 225
 226     if(level == HAPTIC_LEVEL_AUTO) {
 227         level = HAPTIC_FEEDBACK_LEVEL_AUTO;
 228     }else {
 229         level = level > 100 ? 100 : (level < 0 ? 0 : level);
 230     }
 231
 232         ret = device_haptic_play_monotone_with_detail_feedback_level(haptic_ids[device_index], duration, level);
 233
 234         if(ret < 0){
 235         if(ret == -2)
 236             RETURN_ERR(HAPTIC_ERROR_OPERATION_FAILED);
 237         else
 238             RETURN_ERR(HAPTIC_ERROR_INVALID_PARAMETER);
 239     }
 240
 241         return HAPTIC_ERROR_NONE;
 242 }
 243
 244 static gboolean _haptic_play_iter(gpointer data)
 245 {
 246     int err;
 247     struct _vibe_pattern* pattern = NULL;
 248
 249     pattern = (struct _vibe_pattern*)data;
 250
 251     if(pattern == NULL)
 252         return false;
 253
 254     if(pattern_table == NULL || g_array_index(pattern_table, int, pattern->pattern_index) != START) {
 255         free(pattern->iters);
 256         free(pattern);
 257         return false;
 258     }
 259     if(pattern->iters == NULL)
 260         return false;
 261     int current = pattern->current;
 262
 263     int device = pattern->iters[current].vibrator_index;
 264     long time = pattern->iters[current].time;
 265     int level = pattern->level;
 266
 267     // set default device, if can't find given device.
 268     if(device >= max_device || device < 0)
 269         device = 0;
 270
 271     if(level != 0 || time != 0){
 272         err = _haptic_play_monotone(device, time, level);
 273         if(err<0){
 274             pattern->error = err;
 275             return false;
 276         }
 277     }
 278     // pattern play finish
 279     if(++pattern->current >= pattern->size){
 280         if(pattern->iter_count <= 0){
 281             free(pattern->iters);
 282             free(pattern);
 283             return false;
 284         }else{
 285             pattern->current = 0;
 286             pattern->iter_count--;
 287         }
 288     }
 289     g_timeout_add(time, _haptic_play_iter, data);
 290
 291     return false;
 292 }
 293
 294 int haptic_play_pattern(haptic_vibration_iter_s* pattern, int pattern_size, int count, int level, int* id)
 295 {
 296     int i, key = -1;
 297
 298     if(id == NULL)
 299         RETURN_ERR(HAPTIC_ERROR_INVALID_PARAMETER);
 300
 301     if(pattern == NULL)
 302         RETURN_ERR(HAPTIC_ERROR_INVALID_PARAMETER);
 303
 304     if(!initialize)
 305         RETURN_ERR(HAPTIC_ERROR_NOT_INITIALIZED);
 306
 307     haptic_vibration_iter_s* tmp_ptn = (haptic_vibration_iter_s*)
 308         malloc(sizeof(haptic_vibration_iter_s) * pattern_size);
 309     if(tmp_ptn == NULL){
 310         RETURN_ERR(HAPTIC_ERROR_OPERATION_FAILED);
 311     }
 312     memcpy(tmp_ptn, pattern, sizeof(haptic_vibration_iter_s) * pattern_size);
 313
 314     struct _vibe_pattern* vibe_p = (struct _vibe_pattern*)malloc(sizeof(struct _vibe_pattern));
 315     if(vibe_p == NULL){
 316         free(tmp_ptn);
 317         RETURN_ERR(HAPTIC_ERROR_OPERATION_FAILED);
 318     }
 319     vibe_p->iters = tmp_ptn;
 320     vibe_p->size = pattern_size;
 321     vibe_p->level = level;
 322     vibe_p->iter_count = count;
 323     vibe_p->current = 0;
 324     vibe_p->error= 0;
 325
 326     for(i=0; i< pattern_table->len; i++){
 327         if(g_array_index(pattern_table, int, i) == UNDEFINED){
 328             key = i;
 329             break;
 330         }
 331     }
 332     if(key == -1){
 333         g_array_append_val(pattern_table, START);
 334         key = pattern_table->len -1;
 335     }else{
 336         g_array_index(pattern_table, int, key) = START;
 337     }
 338
 339     vibe_p->pattern_index = key;
 340
 341     _haptic_play_iter((gpointer)vibe_p);
 342
 343     int error = vibe_p->error;
 344     if(error < 0){
 345         free(vibe_p->iters);
 346         free(vibe_p);
 347
 348                 if(error == -2)
 349             RETURN_ERR(HAPTIC_ERROR_OPERATION_FAILED);
 350         else
 351             RETURN_ERR(HAPTIC_ERROR_NOT_INITIALIZED);
 352     }
 353
 354     *id = key;
 355
 356     return HAPTIC_ERROR_NONE;
 357 }
 358
 359 int haptic_stop_pattern(int id)
 360 {
 361     if(id < 0)
 362         RETURN_ERR(HAPTIC_ERROR_INVALID_PARAMETER);
 363
 364     if(!initialize || pattern_table == NULL)
 365         RETURN_ERR(HAPTIC_ERROR_NOT_INITIALIZED);
 366
 367     if(id >= pattern_table->len)
 368         RETURN_ERR(HAPTIC_ERROR_INVALID_PARAMETER);
 369
 370    g_array_index(pattern_table, int, id) = UNDEFINED;
 371
 372     return HAPTIC_ERROR_NONE;
 373 }