DEV_IDX_1,
};
-static int _LEVEL[] =
-{
- HAPTIC_FEEDBACK_LEVEL_AUTO,
- VIBE_SILENCE,
- HAPTIC_FEEDBACK_LEVEL_1,
- HAPTIC_FEEDBACK_LEVEL_2,
- HAPTIC_FEEDBACK_LEVEL_3,
- HAPTIC_FEEDBACK_LEVEL_4,
- HAPTIC_FEEDBACK_LEVEL_5,
-};
-
struct _vibe_pattern {
haptic_vibration_iter_s *iters;
int current;
int size;
- int level_change;
+ int level;
int iter_count;
- int stop;
int pattern_index;
int error;
};
+static const int UNDEFINED = 0;
+static const int START = 1;
+
GArray *pattern_table = NULL;
static int initialize = 0;
static int* haptic_ids = NULL;
-static void _free_pattern_from_table(int index);
-
-static bool invalid_ivt(const char* file_name)
-{
- if( 0 != access(file_name, R_OK) )
- {
- return false;
- }
-
- char* ext = strrchr(file_name, '.');
- if (ext == NULL || 0 != strcasecmp(ext, ".ivt")){
- return false;
- }
-
- return true;
-}
-
int haptic_get_count(int* vibrator_number)
{
int count;
int i, j;
int id;
+ if(initialize)
+ return HAPTIC_ERROR_NONE;
+
+
if( haptic_get_count(&max_device) < 0)
RETURN_ERR(HAPTIC_ERROR_OPERATION_FAILED);
initialize = 1;
- pattern_table = g_array_new(FALSE, TRUE, sizeof(struct _vibe_pattern*));
+ pattern_table = g_array_new(FALSE, TRUE, sizeof(int));
_haptic_init();
err = device_haptic_close(haptic_ids[i]);
}
initialize = 0;
-
if(haptic_ids != NULL)
free(haptic_ids);
- for(i=0; i< pattern_table->len; i++){
- _free_pattern_from_table(i);
- }
g_array_free(pattern_table, TRUE);
+ pattern_table = NULL;
_haptic_deinit();
}
-int haptic_get_file_duration(int device_index, const char *file_name , int* duration)
+int haptic_vibrate_monotone(int device_index, int duration_ms, int level)
{
int ret;
- if(!initialize)
- RETURN_ERR(HAPTIC_ERROR_NOT_INITIALIZED);
-
- if(device_index < 0 || device_index > max_device)
- RETURN_ERR(HAPTIC_ERROR_INVALID_PARAMETER);
-
- device_index = ((device_index < 3) ? device_index : 0); // xxx
-
- if(!invalid_ivt(file_name))
- RETURN_ERR(HAPTIC_ERROR_NOT_SUPPORTED_FORMAT);
-
- ret = device_haptic_get_file_duration(haptic_ids[device_index], file_name, duration);
-
- if(ret < 0){
- if(ret == -2)
- RETURN_ERR(HAPTIC_ERROR_OPERATION_FAILED);
- else
- RETURN_ERR(HAPTIC_ERROR_INVALID_PARAMETER);
- }
-
- return HAPTIC_ERROR_NONE;
-}
-
-int haptic_vibrate_file(int device_index, const char *file_name , int count , haptic_level_e level)
-{
- int ret;
-
- if(device_index < 0 || device_index > max_device)
- RETURN_ERR(HAPTIC_ERROR_INVALID_PARAMETER);
-
- device_index = ((device_index < 3) ? device_index : 0); // xxx
-
- if(!initialize)
- RETURN_ERR(HAPTIC_ERROR_NOT_INITIALIZED);
-
- if(level == VIBE_SILENCE)
- return HAPTIC_ERROR_NONE;
-
- if(level > HAPTIC_LEVEL_5 || level < 0)
+ if(device_index < 0 || device_index > max_device)
RETURN_ERR(HAPTIC_ERROR_INVALID_PARAMETER);
- if(count < 0 || count >= HAPTIC_INFINITE_ITERATION)
- RETURN_ERR(HAPTIC_ERROR_INVALID_PARAMETER);
-
- if(count == 0)
- count = HAPTIC_INFINITE_ITERATION;
-
- if(!invalid_ivt(file_name))
- RETURN_ERR(HAPTIC_ERROR_NOT_SUPPORTED_FORMAT);
-
- ret = device_haptic_play_file(haptic_ids[device_index], file_name, count, _LEVEL[level]);
-
- if(ret < 0){
- if(ret == -2)
- RETURN_ERR(HAPTIC_ERROR_OPERATION_FAILED);
- else
- RETURN_ERR(HAPTIC_ERROR_INVALID_PARAMETER);
- }
-
- return HAPTIC_ERROR_NONE;
-}
-
-int haptic_vibrate_monotone(int device_index , int duration)
-{
- int ret;
+ if(level < HAPTIC_LEVEL_AUTO || level > HAPTIC_LEVEL_5)
+ RETURN_ERR(HAPTIC_ERROR_INVALID_PARAMETER);
- if(device_index < 0 || device_index > max_device)
- RETURN_ERR(HAPTIC_ERROR_INVALID_PARAMETER);
+ device_index = ((device_index < 3) ? device_index : 0); // xxx
- device_index = ((device_index < 3) ? device_index : 0); // xxx
+ if(!initialize)
+ RETURN_ERR(HAPTIC_ERROR_NOT_INITIALIZED);
- if(!initialize)
- RETURN_ERR(HAPTIC_ERROR_NOT_INITIALIZED);
+ if(level == HAPTIC_LEVEL_0)
+ return HAPTIC_ERROR_NONE;
- ret = device_haptic_play_monotone(haptic_ids[device_index], duration);
+ level = (level == HAPTIC_LEVEL_AUTO) ? 0 : level;
+ ret = device_haptic_play_monotone_with_detail_feedback_level(haptic_ids[device_index], duration_ms, level);
if(ret < 0){
- if(ret == -2)
- RETURN_ERR(HAPTIC_ERROR_OPERATION_FAILED);
- else
- RETURN_ERR(HAPTIC_ERROR_INVALID_PARAMETER);
- }
+ if(ret == -2)
+ RETURN_ERR(HAPTIC_ERROR_OPERATION_FAILED);
+ else
+ RETURN_ERR(HAPTIC_ERROR_INVALID_PARAMETER);
+ }
return HAPTIC_ERROR_NONE;
}
return HAPTIC_ERROR_NONE;
}
-static void _free_pattern_from_table(int index)
-{
- struct _vibe_pattern* p = g_array_index(pattern_table, struct _vibe_pattern *, index);
- if(p == NULL)
- return;
- free(p->iters);
- free(p);
- g_array_index(pattern_table, struct _vibe_pattern *, index) = NULL;
-}
-
-static int _haptic_play_monotone(int device_index, long duration, haptic_level_e level)
+static int _haptic_play_monotone(int device_index, long duration, int level)
{
int ret;
if(!initialize)
RETURN_ERR(HAPTIC_ERROR_NOT_INITIALIZED);
+ if(level == HAPTIC_LEVEL_AUTO) {
+ level = HAPTIC_FEEDBACK_LEVEL_AUTO;
+ }else {
+ level = level > 100 ? 100 : (level < 0 ? 0 : level);
+ }
- ret = device_haptic_play_monotone_with_feedback_level(haptic_ids[device_index], duration, _LEVEL[level]);
+ ret = device_haptic_play_monotone_with_detail_feedback_level(haptic_ids[device_index], duration, level);
if(ret < 0){
if(ret == -2)
static gboolean _haptic_play_iter(gpointer data)
{
int err;
- struct _vibe_pattern* pattern = (struct _vibe_pattern*)data;
+ struct _vibe_pattern* pattern = NULL;
+
+ pattern = (struct _vibe_pattern*)data;
+
+ if(pattern == NULL)
+ return false;
- if(pattern->stop){
- _free_pattern_from_table(pattern->pattern_index);
+ if(pattern_table == NULL || g_array_index(pattern_table, int, pattern->pattern_index) != START) {
+ free(pattern->iters);
+ free(pattern);
return false;
}
+ if(pattern->iters == NULL)
+ return false;
int current = pattern->current;
int device = pattern->iters[current].vibrator_index;
- int level = pattern->iters[current].level;
long time = pattern->iters[current].time;
- int level_change = pattern->level_change;
- int iter_count = pattern->iter_count;
+ int level = pattern->level;
// set default device, if can't find given device.
if(device >= max_device || device < 0)
device = 0;
- if(level + level_change < HAPTIC_LEVEL_0)
- level = HAPTIC_LEVEL_0;
- if(level + level_change > HAPTIC_LEVEL_5)
- level = HAPTIC_LEVEL_5;
-
- if(level != HAPTIC_LEVEL_0 || time != 0){
+ if(level != 0 || time != 0){
err = _haptic_play_monotone(device, time, level);
if(err<0){
pattern->error = err;
return false;
}
}
-
- pattern->current++;
-
// pattern play finish
- if(pattern->current >= pattern->size){
- if(iter_count <= 0){
- _free_pattern_from_table(pattern->pattern_index);
+ if(++pattern->current >= pattern->size){
+ if(pattern->iter_count <= 0){
+ free(pattern->iters);
+ free(pattern);
return false;
}else{
pattern->current = 0;
pattern->iter_count--;
}
}
-
-
g_timeout_add(time, _haptic_play_iter, data);
return false;
}
-int haptic_play_pattern(haptic_vibration_iter_s* pattern, int pattern_size, int count, int level_change, int* id)
+int haptic_play_pattern(haptic_vibration_iter_s* pattern, int pattern_size, int count, int level, int* id)
{
int i, key = -1;
}
vibe_p->iters = tmp_ptn;
vibe_p->size = pattern_size;
- vibe_p->level_change = level_change;
+ vibe_p->level = level;
vibe_p->iter_count = count;
vibe_p->current = 0;
- vibe_p->stop = 0;
vibe_p->error= 0;
for(i=0; i< pattern_table->len; i++){
- if(g_array_index(pattern_table, struct _vibe_pattern *, i) == NULL){
+ if(g_array_index(pattern_table, int, i) == UNDEFINED){
key = i;
break;
}
}
if(key == -1){
- g_array_append_val(pattern_table, vibe_p);
+ g_array_append_val(pattern_table, START);
key = pattern_table->len -1;
}else{
- g_array_index(pattern_table, struct _vibe_pattern *, key) = vibe_p;
+ g_array_index(pattern_table, int, key) = START;
}
vibe_p->pattern_index = key;
_haptic_play_iter((gpointer)vibe_p);
- if(vibe_p->error < 0){
- _free_pattern_from_table(key);
- if(vibe_p->error == -2)
+ int error = vibe_p->error;
+ if(error < 0){
+ free(vibe_p->iters);
+ free(vibe_p);
+
+ if(error == -2)
RETURN_ERR(HAPTIC_ERROR_OPERATION_FAILED);
else
RETURN_ERR(HAPTIC_ERROR_NOT_INITIALIZED);
if(id >= pattern_table->len)
RETURN_ERR(HAPTIC_ERROR_INVALID_PARAMETER);
- struct _vibe_pattern* pattern = g_array_index(pattern_table, struct _vibe_pattern *, id);
- if(pattern != NULL)
- pattern->stop = 1;
- else
- RETURN_ERR(HAPTIC_ERROR_INVALID_PARAMETER);
+ g_array_index(pattern_table, int, id) = UNDEFINED;
return HAPTIC_ERROR_NONE;
}
projects / framework / api / haptic.git / blobdiff