tizen/SIMULATOR/src/haptic_module_internal.c

   1 /*
   2  * haptic-module-tizen
   3  * Copyright (c) 2012 Samsung Electronics Co., Ltd.
   4  *
   5  * Licensed under the Apache License, Version 2.0 (the License);
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *     http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  */
  17
  18
  19 #include <stdio.h>
  20 #include <stdlib.h>
  21 #include <unistd.h>
  22 #include <string.h>
  23 #include <sys/types.h>
  24 #include <sys/stat.h>
  25 #include <fcntl.h>
  26
  27 #include <haptic_plugin_intf.h>
  28 #include "haptic_module_log.h"
  29
  30 #ifndef EXTAPI
  31 #define EXTAPI __attribute__ ((visibility("default")))
  32 #endif
  33
  34 #define DEFAULT_MOTOR_COUNT                     1
  35 #define DEFAULT_DEVICE_HANDLE           0x01
  36 #define DEFAULT_EFFECT_HANDLE           0x02
  37
  38 int haptic_internal_get_device_count(int *count)
  39 {
  40         if (count == NULL)
  41                 return HAPTIC_MODULE_INVALID_ARGUMENT;
  42
  43         *count = DEFAULT_MOTOR_COUNT;
  44         return HAPTIC_MODULE_ERROR_NONE;
  45 }
  46
  47 int haptic_internal_open_device(int device_index, int *device_handle)
  48 {
  49         if (device_index < HAPTIC_MODULE_DEVICE_0 || device_index > HAPTIC_MODULE_DEVICE_ALL)
  50                 return HAPTIC_MODULE_INVALID_ARGUMENT;
  51
  52         if (device_handle == NULL)
  53                 return HAPTIC_MODULE_INVALID_ARGUMENT;
  54
  55         *device_handle = DEFAULT_DEVICE_HANDLE;
  56         return HAPTIC_MODULE_ERROR_NONE;
  57 }
  58
  59 int haptic_internal_close_device(int device_handle)
  60 {
  61         if (device_handle < 0)
  62                 return HAPTIC_MODULE_INVALID_ARGUMENT;
  63
  64         return HAPTIC_MODULE_ERROR_NONE;
  65 }
  66
  67 int haptic_internal_vibrate_monotone(int device_handle, int duration, int feedback, int priority, int *effect_handle)
  68 {
  69         if (device_handle < 0)
  70                 return HAPTIC_MODULE_INVALID_ARGUMENT;
  71
  72         if (duration < 0)
  73                 return HAPTIC_MODULE_INVALID_ARGUMENT;
  74
  75         if (feedback < HAPTIC_MODULE_FEEDBACK_MIN || feedback > HAPTIC_MODULE_FEEDBACK_MAX)
  76                 return HAPTIC_MODULE_INVALID_ARGUMENT;
  77
  78         if (priority < HAPTIC_MODULE_PRIORITY_MIN || priority > HAPTIC_MODULE_PRIORITY_HIGH)
  79                 return HAPTIC_MODULE_INVALID_ARGUMENT;
  80
  81         if (effect_handle == NULL)
  82                 return HAPTIC_MODULE_INVALID_ARGUMENT;
  83
  84         if (feedback == HAPTIC_MODULE_FEEDBACK_MIN)
  85                 return HAPTIC_MODULE_ERROR_NONE;
  86
  87         MODULE_LOG("call %s function", __func__);
  88
  89         *effect_handle = DEFAULT_EFFECT_HANDLE;
  90         return HAPTIC_MODULE_ERROR_NONE;
  91 }
  92
  93 int haptic_internal_vibrate_file(int device_handle, const char *file_path, int iteration, int feedback, int priority, int  *effect_handle)
  94 {
  95     if (device_handle < 0)
  96         return HAPTIC_MODULE_INVALID_ARGUMENT;
  97
  98     if (file_path == NULL)
  99         return HAPTIC_MODULE_INVALID_ARGUMENT;
 100
 101     if (iteration < HAPTIC_MODULE_ITERATION_ONCE || iteration > HAPTIC_MODULE_ITERATION_INFINITE)
 102         return HAPTIC_MODULE_INVALID_ARGUMENT;
 103
 104     if (feedback < HAPTIC_MODULE_FEEDBACK_MIN || feedback > HAPTIC_MODULE_FEEDBACK_MAX)
 105         return HAPTIC_MODULE_INVALID_ARGUMENT;
 106
 107     if (priority < HAPTIC_MODULE_PRIORITY_MIN || priority > HAPTIC_MODULE_PRIORITY_HIGH)
 108         return HAPTIC_MODULE_INVALID_ARGUMENT;
 109
 110     if (effect_handle == NULL)
 111         return HAPTIC_MODULE_INVALID_ARGUMENT;
 112
 113     if (feedback == HAPTIC_MODULE_FEEDBACK_MIN)
 114         return HAPTIC_MODULE_ERROR_NONE;
 115
 116         MODULE_LOG("call %s function", __func__);
 117
 118         *effect_handle = DEFAULT_EFFECT_HANDLE;
 119         return HAPTIC_MODULE_ERROR_NONE;
 120 }
 121
 122 int haptic_internal_vibrate_buffer(int device_handle, const unsigned char *vibe_buffer, int iteration, int feedback, int priority, int *effect_handle)
 123 {
 124     if (device_handle < 0)
 125         return HAPTIC_MODULE_INVALID_ARGUMENT;
 126
 127     if (vibe_buffer == NULL)
 128         return HAPTIC_MODULE_INVALID_ARGUMENT;
 129
 130     if (iteration < HAPTIC_MODULE_ITERATION_ONCE || iteration > HAPTIC_MODULE_ITERATION_INFINITE)
 131         return HAPTIC_MODULE_INVALID_ARGUMENT;
 132
 133     if (feedback < HAPTIC_MODULE_FEEDBACK_MIN || feedback > HAPTIC_MODULE_FEEDBACK_MAX)
 134         return HAPTIC_MODULE_INVALID_ARGUMENT;
 135
 136     if (priority < HAPTIC_MODULE_PRIORITY_MIN || priority > HAPTIC_MODULE_PRIORITY_HIGH)
 137         return HAPTIC_MODULE_INVALID_ARGUMENT;
 138
 139     if (effect_handle == NULL)
 140         return HAPTIC_MODULE_INVALID_ARGUMENT;
 141
 142     if (feedback == HAPTIC_MODULE_FEEDBACK_MIN)
 143         return HAPTIC_MODULE_ERROR_NONE;
 144
 145         MODULE_LOG("call %s function", __func__);
 146
 147         *effect_handle = DEFAULT_EFFECT_HANDLE;
 148         return HAPTIC_MODULE_ERROR_NONE;
 149 }
 150
 151 int haptic_internal_stop_effect(int device_handle, int effect_handle)
 152 {
 153     if (device_handle < 0)
 154         return HAPTIC_MODULE_INVALID_ARGUMENT;
 155
 156     if (effect_handle < 0)
 157         return HAPTIC_MODULE_INVALID_ARGUMENT;
 158
 159         MODULE_LOG("call %s function", __func__);
 160
 161         return HAPTIC_MODULE_ERROR_NONE;
 162 }
 163
 164 int haptic_internal_stop_all_effects(int device_handle)
 165 {
 166         if (device_handle < 0)
 167                 return HAPTIC_MODULE_INVALID_ARGUMENT;
 168
 169         MODULE_LOG("call %s function", __func__);
 170
 171         return HAPTIC_MODULE_ERROR_NONE;
 172 }
 173
 174 int haptic_internal_pause_effect(int device_handle, int effect_handle)
 175 {
 176     if (device_handle < 0)
 177         return HAPTIC_MODULE_INVALID_ARGUMENT;
 178
 179     if (effect_handle < 0)
 180         return HAPTIC_MODULE_INVALID_ARGUMENT;
 181
 182         MODULE_LOG("call %s function", __func__);
 183
 184         return HAPTIC_MODULE_ERROR_NONE;
 185 }
 186
 187 int haptic_internal_resume_effect(int device_handle, int effect_handle)
 188 {
 189     if (device_handle < 0)
 190         return HAPTIC_MODULE_INVALID_ARGUMENT;
 191
 192     if (effect_handle < 0)
 193         return HAPTIC_MODULE_INVALID_ARGUMENT;
 194
 195         MODULE_LOG("call %s function", __func__);
 196
 197         return HAPTIC_MODULE_ERROR_NONE;
 198 }
 199
 200 int haptic_internal_get_effect_state(int device_handle, int effect_handle, int *effect_state)
 201 {
 202     if (device_handle < 0)
 203         return HAPTIC_MODULE_INVALID_ARGUMENT;
 204
 205     if (effect_handle < 0)
 206         return HAPTIC_MODULE_INVALID_ARGUMENT;
 207
 208     if (effect_state == NULL)
 209         return HAPTIC_MODULE_INVALID_ARGUMENT;
 210
 211         MODULE_LOG("call %s function", __func__);
 212
 213         return HAPTIC_MODULE_ERROR_NONE;
 214 }
 215
 216 int haptic_internal_create_effect(const unsigned char *vibe_buffer, int max_bufsize, haptic_module_effect_element *elem_arr, int max_elemcnt)
 217 {
 218     if (vibe_buffer == NULL)
 219         return HAPTIC_MODULE_INVALID_ARGUMENT;
 220
 221     if (max_bufsize < 0)
 222         return HAPTIC_MODULE_INVALID_ARGUMENT;
 223
 224     if (elem_arr == NULL)
 225         return HAPTIC_MODULE_INVALID_ARGUMENT;
 226
 227     if (max_elemcnt < 0)
 228         return HAPTIC_MODULE_INVALID_ARGUMENT;
 229
 230         MODULE_LOG("call %s function", __func__);
 231
 232         return HAPTIC_MODULE_ERROR_NONE;
 233 }
 234
 235 int haptic_internal_save_effect(const unsigned char *vibe_buffer, int max_bufsize, const char *file_path)
 236 {
 237     if (vibe_buffer == NULL)
 238         return HAPTIC_MODULE_INVALID_ARGUMENT;
 239
 240     if (max_bufsize < 0)
 241         return HAPTIC_MODULE_INVALID_ARGUMENT;
 242
 243     if (file_path == NULL)
 244         return HAPTIC_MODULE_INVALID_ARGUMENT;
 245
 246         MODULE_LOG("call %s function", __func__);
 247
 248         return HAPTIC_MODULE_ERROR_NONE;
 249 }
 250
 251 int haptic_internal_get_file_duration(int device_handle, const char *file_path, int *file_duration)
 252 {
 253     if (device_handle < 0)
 254         return HAPTIC_MODULE_INVALID_ARGUMENT;
 255
 256     if (file_path == NULL)
 257         return HAPTIC_MODULE_INVALID_ARGUMENT;
 258
 259     if (file_duration == NULL)
 260         return HAPTIC_MODULE_INVALID_ARGUMENT;
 261
 262         MODULE_LOG("call %s function", __func__);
 263
 264         return HAPTIC_MODULE_ERROR_NONE;
 265 }
 266
 267 int haptic_internal_get_buffer_duration(int device_handle, const unsigned char *vibe_buffer, int *buffer_duration)
 268 {
 269     if (device_handle < 0)
 270         return HAPTIC_MODULE_INVALID_ARGUMENT;
 271
 272     if (vibe_buffer == NULL)
 273         return HAPTIC_MODULE_INVALID_ARGUMENT;
 274
 275     if (buffer_duration == NULL)
 276         return HAPTIC_MODULE_INVALID_ARGUMENT;
 277
 278         MODULE_LOG("call %s function", __func__);
 279
 280         return HAPTIC_MODULE_ERROR_NONE;
 281 }
 282
 283 int haptic_internal_convert_binary (void)
 284 {
 285         MODULE_ERROR("This device is not supported this function(%s)", __func__);
 286         return HAPTIC_MODULE_NOT_SUPPORTED;
 287 }
 288
 289 static haptic_plugin_interface haptic_plugin_emul;
 290
 291 EXTAPI
 292 const haptic_plugin_interface *get_haptic_plugin_interface()
 293 {
 294         haptic_plugin_emul.haptic_internal_get_device_count    = &haptic_internal_get_device_count;
 295         haptic_plugin_emul.haptic_internal_open_device         = &haptic_internal_open_device;
 296         haptic_plugin_emul.haptic_internal_close_device        = &haptic_internal_close_device;
 297         haptic_plugin_emul.haptic_internal_vibrate_monotone    = &haptic_internal_vibrate_monotone;
 298         haptic_plugin_emul.haptic_internal_vibrate_file        = &haptic_internal_vibrate_file;
 299         haptic_plugin_emul.haptic_internal_vibrate_buffer      = &haptic_internal_vibrate_buffer;
 300         haptic_plugin_emul.haptic_internal_stop_effect         = &haptic_internal_stop_effect;
 301         haptic_plugin_emul.haptic_internal_stop_all_effects    = &haptic_internal_stop_all_effects;
 302         haptic_plugin_emul.haptic_internal_pause_effect        = &haptic_internal_pause_effect;
 303         haptic_plugin_emul.haptic_internal_resume_effect       = &haptic_internal_resume_effect;
 304         haptic_plugin_emul.haptic_internal_get_effect_state    = &haptic_internal_get_effect_state;
 305         haptic_plugin_emul.haptic_internal_create_effect       = &haptic_internal_create_effect;
 306         haptic_plugin_emul.haptic_internal_save_effect         = &haptic_internal_save_effect;
 307         haptic_plugin_emul.haptic_internal_get_file_duration   = &haptic_internal_get_file_duration;
 308         haptic_plugin_emul.haptic_internal_get_buffer_duration = &haptic_internal_get_buffer_duration;
 309         haptic_plugin_emul.haptic_internal_convert_binary      = &haptic_internal_convert_binary;
 310
 311         return &haptic_plugin_emul;
 312 }