src/co_phonebook.c

   1 /*
   2  * libtcore
   3  *
   4  * Copyright (c) 2012 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: Ja-young Gu <jygu@samsung.com>
   7  *
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  * http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  */
  20
  21 #include <stdio.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24
  25 #include <glib.h>
  26
  27 #include "tcore.h"
  28 #include "plugin.h"
  29 #include "queue.h"
  30 #include "user_request.h"
  31 #include "core_object.h"
  32 #include "co_phonebook.h"
  33
  34 struct private_object_data {
  35         struct tcore_phonebook_operations *ops;
  36         gboolean b_init;
  37         struct tel_phonebook_support_list support_list;
  38         struct tel_phonebook_field_support_list field_support_list;
  39         enum tel_phonebook_type selected;
  40 };
  41
  42 static TReturn _dispatcher(CoreObject *o, UserRequest *ur)
  43 {
  44         enum tcore_request_command command;
  45         struct private_object_data *po = NULL;
  46
  47         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PHONEBOOK, TCORE_RETURN_EINVAL);
  48
  49         po = tcore_object_ref_object(o);
  50         if (!po || !po->ops)
  51                 return TCORE_RETURN_ENOSYS;
  52
  53         command = tcore_user_request_get_command(ur);
  54         switch (command) {
  55                 case TREQ_PHONEBOOK_GETCOUNT:
  56                         if (!po->ops->get_count)
  57                                 return TCORE_RETURN_ENOSYS;
  58
  59                         return po->ops->get_count(o, ur);
  60                         break;
  61
  62                 case TREQ_PHONEBOOK_GETMETAINFO:
  63                         if (!po->ops->get_info)
  64                                 return TCORE_RETURN_ENOSYS;
  65
  66                         return po->ops->get_info(o, ur);
  67                         break;
  68
  69                 case TREQ_PHONEBOOK_GETUSIMINFO:
  70                         if (!po->ops->get_usim_info)
  71                                 return TCORE_RETURN_ENOSYS;
  72
  73                         return po->ops->get_usim_info(o, ur);
  74                         break;
  75
  76                 case TREQ_PHONEBOOK_READRECORD:
  77                         if (!po->ops->read_record)
  78                                 return TCORE_RETURN_ENOSYS;
  79
  80                         return po->ops->read_record(o, ur);
  81                         break;
  82
  83                 case TREQ_PHONEBOOK_UPDATERECORD:
  84                         if (!po->ops->update_record)
  85                                 return TCORE_RETURN_ENOSYS;
  86
  87                         return po->ops->update_record(o, ur);
  88                         break;
  89
  90                 case TREQ_PHONEBOOK_DELETERECORD:
  91                         if (!po->ops->delete_record)
  92                                 return TCORE_RETURN_ENOSYS;
  93
  94                         return po->ops->delete_record(o, ur);
  95                         break;
  96
  97                 default:
  98                         break;
  99         }
 100
 101         return TCORE_RETURN_SUCCESS;
 102 }
 103
 104 static void _clone_hook(CoreObject *src, CoreObject *dest)
 105 {
 106         struct private_object_data *src_po = NULL;
 107         struct private_object_data *dest_po = NULL;
 108
 109         if (!src || !dest)
 110                 return;
 111
 112         dest_po = calloc(1, sizeof(struct private_object_data));
 113         if (!dest_po) {
 114                 tcore_object_link_object(dest, NULL);
 115                 return;
 116         }
 117
 118         src_po = tcore_object_ref_object(src);
 119         dest_po->ops = src_po->ops;
 120
 121         tcore_object_link_object(dest, dest_po);
 122 }
 123
 124 static void _free_hook(CoreObject *o)
 125 {
 126         struct private_object_data *po = NULL;
 127
 128         CORE_OBJECT_CHECK(o, CORE_OBJECT_TYPE_PHONEBOOK);
 129
 130         po = tcore_object_ref_object(o);
 131         if (po) {
 132                 free(po);
 133                 tcore_object_link_object(o, NULL);
 134         }
 135 }
 136
 137 gboolean tcore_phonebook_get_status(CoreObject *o)
 138 {
 139         struct private_object_data *po = NULL;
 140         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PHONEBOOK, FALSE);
 141         po = tcore_object_ref_object(o);
 142         return po->b_init;
 143 }
 144
 145 gboolean tcore_phonebook_set_status(CoreObject *o, gboolean b_init)
 146 {
 147         struct private_object_data *po = NULL;
 148         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PHONEBOOK, FALSE);
 149         po = tcore_object_ref_object(o);
 150         po->b_init = b_init;
 151         return TRUE;
 152 }
 153
 154 struct tel_phonebook_support_list* tcore_phonebook_get_support_list(CoreObject *o)
 155 {
 156         struct tel_phonebook_support_list *tmp;
 157         struct private_object_data *po = NULL;
 158         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PHONEBOOK, NULL);
 159         po = tcore_object_ref_object(o);
 160         tmp = calloc(1, sizeof(struct tel_phonebook_support_list));
 161         if (!tmp)
 162                 return NULL;
 163         memcpy(tmp, &po->support_list, sizeof(struct tel_phonebook_support_list));
 164         return tmp;
 165 }
 166
 167 gboolean tcore_phonebook_set_support_list(CoreObject *o, struct tel_phonebook_support_list *list)
 168 {
 169         struct private_object_data *po = NULL;
 170         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PHONEBOOK, FALSE);
 171         po = tcore_object_ref_object(o);
 172         memcpy(&po->support_list, list, sizeof(struct tel_phonebook_support_list));
 173         return TRUE;
 174 }
 175
 176 struct tel_phonebook_field_support_list* tcore_phonebook_get_field_support_list(CoreObject *o)
 177 {
 178         struct tel_phonebook_field_support_list *tmp;
 179         struct private_object_data *po = NULL;
 180         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PHONEBOOK, NULL);
 181         po = tcore_object_ref_object(o);
 182         tmp = calloc(1, sizeof(struct tel_phonebook_field_support_list));
 183         if (!tmp)
 184                 return NULL;
 185         memcpy(tmp, &po->field_support_list, sizeof(struct tel_phonebook_field_support_list));
 186         return tmp;
 187 }
 188
 189 gboolean tcore_phonebook_set_field_support_list(CoreObject *o, struct tel_phonebook_field_support_list *list)
 190 {
 191         struct private_object_data *po = NULL;
 192         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PHONEBOOK, FALSE);
 193         po = tcore_object_ref_object(o);
 194         memcpy(&po->field_support_list, list, sizeof(struct tel_phonebook_field_support_list));
 195         return TRUE;
 196 }
 197
 198 enum tel_phonebook_type tcore_phonebook_get_selected_type(CoreObject *o)
 199 {
 200         struct private_object_data *po = NULL;
 201         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PHONEBOOK, PB_TYPE_UNKNOWNN);
 202         po = tcore_object_ref_object(o);
 203         return po->selected;
 204 }
 205
 206 gboolean tcore_phonebook_set_selected_type(CoreObject *o, enum tel_phonebook_type t)
 207 {
 208         struct private_object_data *po = NULL;
 209         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PHONEBOOK, FALSE);
 210         po = tcore_object_ref_object(o);
 211         po->selected = t;
 212         return TRUE;
 213 }
 214
 215 CoreObject *tcore_phonebook_new(TcorePlugin *p, const char *name,
 216                 struct tcore_phonebook_operations *ops, TcoreHal *hal)
 217 {
 218         CoreObject *o = NULL;
 219         struct private_object_data *po = NULL;
 220
 221         if (!p)
 222                 return NULL;
 223
 224         o = tcore_object_new(p, name, hal);
 225         if (!o)
 226                 return NULL;
 227
 228         po = calloc(1, sizeof(struct private_object_data));
 229         if (!po) {
 230                 tcore_object_free(o);
 231                 return NULL;
 232         }
 233
 234         po->ops = ops;
 235         po->selected = PB_TYPE_UNKNOWNN;
 236
 237         tcore_object_set_type(o, CORE_OBJECT_TYPE_PHONEBOOK);
 238         tcore_object_link_object(o, po);
 239         tcore_object_set_free_hook(o, _free_hook);
 240         tcore_object_set_clone_hook(o, _clone_hook);
 241         tcore_object_set_dispatcher(o, _dispatcher);
 242
 243         return o;
 244 }
 245
 246 void tcore_phonebook_free(CoreObject *o)
 247 {
 248         CORE_OBJECT_CHECK(o, CORE_OBJECT_TYPE_PHONEBOOK);
 249         tcore_object_free(o);
 250 }
 251
 252 void tcore_phonebook_set_ops(CoreObject *o, struct tcore_phonebook_operations *ops)
 253 {
 254         struct private_object_data *po = NULL;
 255
 256         CORE_OBJECT_CHECK(o, CORE_OBJECT_TYPE_PHONEBOOK);
 257
 258         po = (struct private_object_data *)tcore_object_ref_object(o);
 259         if (!po) {
 260                 return;
 261         }
 262
 263         po->ops = ops;
 264 }