backend/dummy/src/backend_dummy.c

   1
   2 #define IRRECO_DEBUG_PREFIX "DUMMY"
   3 #include <glib.h>
   4 #include <glib/gprintf.h>
   5 #include <gtk/gtk.h>
   6 #include <irreco_backend_api.h>
   7
   8 /*
   9  * Arbitary values for testing pointer travelsal.
  10  */
  11 #define TEST_INSTANCE_CONTEX    ((void *) 12345)
  12 #define TEST_DEVICE_CONTEX2     ((void *) 12346)
  13 #define TEST_DEVICE_CONTEX3     ((void *) 12347)
  14 #define TEST_DEVICE_CONTEX      ((void *) 54321)
  15 #define TEST_COMMAND_CONTEX     ((void *) 54345)
  16
  17 const char *dummy_backend_get_error_msg(void * instance_context,
  18                                        IrrecoBackendStatus code)
  19 {
  20         switch (code) {
  21                 case 1: return "Mad user error";
  22                 default: return "Unknown error";
  23         }
  24 }
  25
  26 void *dummy_backend_create()
  27 {
  28         g_printf("DUMMY: %s\n", __func__);
  29         return TEST_INSTANCE_CONTEX;
  30 }
  31
  32 void dummy_backend_destroy(void * instance_context, gboolean permanently)
  33 {
  34         g_printf("DUMMY: %s\n", __func__);
  35         g_assert(instance_context == TEST_INSTANCE_CONTEX);
  36 }
  37
  38 IrrecoBackendStatus dummy_backend_read_from_conf(void * instance_context,
  39                                                  const char * config_file)
  40 {
  41         g_printf("DUMMY: %s\n", __func__);
  42         g_assert(instance_context == TEST_INSTANCE_CONTEX);
  43         return IRRECO_BACKEND_OK;
  44 }
  45
  46 IrrecoBackendStatus dummy_backend_save_to_conf(void * instance_context,
  47                                                const char * config_file)
  48 {
  49         g_printf("DUMMY: %s\n", __func__);
  50         g_assert(instance_context == TEST_INSTANCE_CONTEX);
  51         return IRRECO_BACKEND_OK;
  52 }
  53
  54 gint i = 0;
  55 IrrecoBackendStatus dummy_backend_get_devices(void * instance_context,
  56                                               IrrecoGetDeviceCallback callback)
  57 {
  58         g_printf("DUMMY: %s\n", __func__);
  59         g_assert(instance_context == TEST_INSTANCE_CONTEX);
  60         callback("Device 1", TEST_DEVICE_CONTEX);
  61         callback("Device 2", TEST_DEVICE_CONTEX2);
  62         callback("Device 3", TEST_DEVICE_CONTEX3);
  63         callback("Device 4", TEST_DEVICE_CONTEX);
  64         i = 0;
  65         return IRRECO_BACKEND_OK;
  66 }
  67
  68 IrrecoBackendStatus dummy_backend_get_commands(void * instance_context,
  69                                                const char * device_name,
  70                                                void * device_contex,
  71                                               IrrecoGetCommandCallback callback)
  72 {
  73         i++;
  74         g_printf("DUMMY: %s\n", __func__);
  75         g_assert(instance_context == TEST_INSTANCE_CONTEX);
  76         g_assert(device_name != NULL);
  77         g_assert(device_contex == TEST_DEVICE_CONTEX
  78                  || device_contex == TEST_DEVICE_CONTEX2
  79                  || device_contex == TEST_DEVICE_CONTEX3);
  80
  81         if (i == 1) {
  82                 callback("00", TEST_COMMAND_CONTEX);
  83                 callback("01", TEST_COMMAND_CONTEX);
  84                 callback("02", TEST_COMMAND_CONTEX);
  85                 callback("03", TEST_COMMAND_CONTEX);
  86                 callback("04", TEST_COMMAND_CONTEX);
  87                 callback("05", TEST_COMMAND_CONTEX);
  88                 callback("06", TEST_COMMAND_CONTEX);
  89                 callback("07", TEST_COMMAND_CONTEX);
  90                 callback("08", TEST_COMMAND_CONTEX);
  91                 callback("09", TEST_COMMAND_CONTEX);
  92                 callback("10", TEST_COMMAND_CONTEX);
  93                 callback("12", TEST_COMMAND_CONTEX);
  94                 callback("13", TEST_COMMAND_CONTEX);
  95                 callback("14", TEST_COMMAND_CONTEX);
  96                 callback("15", TEST_COMMAND_CONTEX);
  97                 callback("16", TEST_COMMAND_CONTEX);
  98                 callback("17", TEST_COMMAND_CONTEX);
  99                 callback("18", TEST_COMMAND_CONTEX);
 100                 callback("19", TEST_COMMAND_CONTEX);
 101                 callback("20", TEST_COMMAND_CONTEX);
 102         } else if (i == 2) {
 103                 /* None. */
 104         } else {
 105                 callback("Command 1", TEST_COMMAND_CONTEX);
 106                 callback("Command 2", TEST_COMMAND_CONTEX);
 107                 callback("Command 3", TEST_COMMAND_CONTEX);
 108                 callback("Command 4", TEST_COMMAND_CONTEX);
 109         }
 110         return IRRECO_BACKEND_OK;
 111 }
 112
 113 IrrecoBackendStatus dummy_backend_send_command(void * instance_context,
 114                                                const char * device_name,
 115                                                void * device_contex,
 116                                                const char * command_name,
 117                                                void * command_contex)
 118 {
 119         g_printf("DUMMY: %s\n", __func__);
 120         g_assert(instance_context == TEST_INSTANCE_CONTEX);
 121         g_assert(device_name != NULL);
 122         g_assert(device_contex == TEST_DEVICE_CONTEX
 123                  || device_contex == TEST_DEVICE_CONTEX2
 124                  || device_contex == TEST_DEVICE_CONTEX3);
 125         g_assert(command_name != NULL);
 126         g_assert(command_contex == TEST_COMMAND_CONTEX);
 127         g_printf("Send: %s, %s\n", device_name, command_name);
 128         return -1;
 129 }
 130
 131
 132
 133 IrrecoBackendStatus dummy_backend_configure(void * instance_context,
 134                                             GtkWindow * parent)
 135 {
 136         GtkWidget* dialog;
 137         g_printf("DUMMY: %s\n", __func__);
 138         g_assert(instance_context == TEST_INSTANCE_CONTEX);
 139
 140         dialog = gtk_message_dialog_new(parent,
 141                 GTK_DIALOG_DESTROY_WITH_PARENT,
 142                 GTK_MESSAGE_INFO, GTK_BUTTONS_OK, "dummy_backend_configure()");
 143         gtk_dialog_run(GTK_DIALOG(dialog));
 144         gtk_widget_destroy(dialog);
 145
 146         return IRRECO_BACKEND_OK;
 147 }
 148
 149 gchar *dummy_backend_get_description(gpointer instance_context)
 150 {
 151         return g_strdup("Dummy description");
 152 }
 153
 154 IrrecoBackendStatus dummy_backend_create_device(gpointer instance_context,
 155                                                 GtkWindow * parent)
 156 {
 157         GtkWidget* dialog;
 158         g_printf("DUMMY: %s\n", __func__);
 159         g_assert(instance_context == TEST_INSTANCE_CONTEX);
 160
 161         dialog = gtk_message_dialog_new(parent,
 162                 GTK_DIALOG_DESTROY_WITH_PARENT,
 163                 GTK_MESSAGE_INFO, GTK_BUTTONS_OK,
 164                 "dummy_backend_create_device()");
 165         gtk_dialog_run(GTK_DIALOG(dialog));
 166         gtk_widget_destroy(dialog);
 167
 168         return IRRECO_BACKEND_OK;
 169 }
 170
 171 gboolean dummy_backend_is_device_editable(gpointer instance_context,
 172                                           const gchar * device_name,
 173                                           gpointer device_contex)
 174 {
 175         g_printf("DUMMY: %s\n", __func__);
 176         g_assert(device_contex == TEST_DEVICE_CONTEX
 177                  || device_contex == TEST_DEVICE_CONTEX2
 178                  || device_contex == TEST_DEVICE_CONTEX3);
 179
 180         if (device_contex == TEST_DEVICE_CONTEX2
 181             || device_contex == TEST_DEVICE_CONTEX3) {
 182                 return FALSE;
 183         }
 184         return TRUE;
 185 }
 186
 187 IrrecoBackendStatus dummy_backend_edit_device(gpointer instance_context,
 188                                               const gchar * device_name,
 189                                               gpointer device_contex,
 190                                               GtkWindow * parent)
 191 {
 192         GtkWidget* dialog;
 193         g_printf("DUMMY: %s\n", __func__);
 194         g_assert(instance_context == TEST_INSTANCE_CONTEX);
 195
 196         dialog = gtk_message_dialog_new(parent,
 197                 GTK_DIALOG_DESTROY_WITH_PARENT,
 198                 GTK_MESSAGE_INFO, GTK_BUTTONS_OK,
 199                 "dummy_backend_edit_device()");
 200         gtk_dialog_run(GTK_DIALOG(dialog));
 201         gtk_widget_destroy(dialog);
 202
 203         return IRRECO_BACKEND_OK;
 204 }
 205
 206 IrrecoBackendStatus dummy_backend_delete_device(gpointer instance_context,
 207                                                 const gchar * device_name,
 208                                                 gpointer device_contex,
 209                                                 GtkWindow * parent)
 210 {
 211         GtkWidget* dialog;
 212         g_printf("DUMMY: %s\n", __func__);
 213         g_assert(instance_context == TEST_INSTANCE_CONTEX);
 214
 215         dialog = gtk_message_dialog_new(parent,
 216                 GTK_DIALOG_DESTROY_WITH_PARENT,
 217                 GTK_MESSAGE_INFO, GTK_BUTTONS_OK,
 218                 "dummy_backend_delete_device()");
 219         gtk_dialog_run(GTK_DIALOG(dialog));
 220         gtk_widget_destroy(dialog);
 221
 222         return IRRECO_BACKEND_OK;
 223 }
 224
 225 IrrecoBackendStatus dummy_backend_export_conf(gpointer instance_context,
 226                                 const char * device_name,
 227                                 IrrecoBackendFileContainer **file_container)
 228 {
 229         g_printf("DUMMY: %s\n", __func__);
 230
 231         *file_container = irreco_backend_file_container_new();
 232
 233         irreco_backend_file_container_set(*file_container,
 234                                           "Dummy backend",
 235                                           "category",
 236                                           "manufacturer",
 237                                           "model",
 238                                           "file_name",
 239                                           "file_data");
 240
 241         return IRRECO_BACKEND_OK;
 242 }
 243
 244 IrrecoBackendStatus dummy_backend_import_conf(gpointer instance_context,
 245                                 IrrecoBackendFileContainer *file_container)
 246 {
 247         g_printf("DUMMY: %s\n", __func__);
 248
 249         g_printf("\nCategory: %s\n",file_container->category->str);
 250         g_printf("Manufacturer: %s\n",file_container->manufacturer->str);
 251         g_printf("Model: %s\n",file_container->model->str);
 252         g_printf("Hash: %s\n",file_container->hash->str);
 253         g_printf("Name: %s\n",file_container->name->str);
 254         g_printf("Data: %s\n",file_container->data->str);
 255
 256         return IRRECO_BACKEND_OK;
 257 }
 258
 259  IrrecoBackendStatus dummy_backend_check_conf(
 260                                 gpointer instance_context,
 261                                 IrrecoBackendFileContainer *file_container,
 262                                 gboolean *configuration)
 263 {
 264         *configuration = TRUE;
 265         return IRRECO_BACKEND_OK;
 266 }
 267
 268 IrrecoBackendFunctionTable dummy_backend_function_table = {
 269         IRRECO_BACKEND_API_VERSION,     /* backend_api_version          */
 270         IRRECO_BACKEND_EDITABLE_DEVICES |
 271         IRRECO_BACKEND_CONFIGURATION_EXPORT |
 272         IRRECO_BACKEND_MULTI_DEVICE_SUPPORT/* |
 273         IRRECO_BACKEND_NEW_INST_ON_CONF_IMPORT*/,/* flags               */
 274         NULL,                           /* name                         */
 275
 276         dummy_backend_get_error_msg,    /* get_error_msg                */
 277         dummy_backend_create,           /* create                       */
 278         dummy_backend_destroy,          /* destroy                      */
 279         dummy_backend_read_from_conf,   /* from_conf                    */
 280         dummy_backend_save_to_conf,     /* to_conf                      */
 281         dummy_backend_get_devices,      /* get_devices                  */
 282         dummy_backend_get_commands,     /* get_commands                 */
 283         dummy_backend_send_command,     /* send_command                 */
 284         dummy_backend_configure,        /* configure                    */
 285
 286         dummy_backend_get_description,  /* get_description,    optional */
 287         dummy_backend_create_device,    /* create_device,      optional */
 288         dummy_backend_is_device_editable,/*is_device_editable, optional */
 289         dummy_backend_edit_device,      /* edit_device,        optional */
 290         dummy_backend_delete_device,    /* delete_device,      optional */
 291
 292         dummy_backend_export_conf,      /*export_conf,         optional */
 293         dummy_backend_import_conf,      /*import_conf,         optional */
 294         dummy_backend_check_conf,       /*check_conf,          optional */
 295         NULL                            /* reserved */
 296 };
 297 IrrecoBackendFunctionTable *get_irreco_backend_function_table()
 298 {
 299         g_printf("DUMMY: %s\n", __func__);
 300         dummy_backend_function_table.name = "Dummy backend";
 301         return &dummy_backend_function_table;
 302 }
 303