sample/phone/telephony-binding/gdbus/ofono_voicecallmanager.c

   1 /*
   2  * Copyright (C) 2017 Konsulko Group
   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 #define _GNU_SOURCE
  18
  19 #include <string.h>
  20
  21 #include <afb/afb-binding.h>
  22
  23 #include "ofono_voicecallmanager_interface.h"
  24
  25 static const struct afb_binding_interface *interface;
  26
  27 static void call_added(OrgOfonoVoiceCallManager *manager,
  28                        gchar *op,
  29                        GVariant *properties)
  30 {
  31         GVariantIter *iter;
  32         gchar *key;
  33         GVariant *value;
  34         const gchar *state, *cl = NULL;
  35
  36         g_variant_get(properties, "a{sv}", &iter);
  37         while (g_variant_iter_loop(iter, "{sv}", &key, &value)) {
  38                 if (!strcmp(key, "State")) {
  39                         state = g_variant_get_string(value, NULL);
  40                 } else if (!strcmp(key, "LineIdentification")) {
  41                         cl = g_variant_get_string(value, NULL);
  42                 }
  43         }
  44
  45         if (!strcmp(state, "incoming")) {
  46                 g_signal_emit_by_name(manager, "incoming-call", op, cl ? cl : "");
  47         } else if (!strcmp(state, "dialing")) {
  48                 g_signal_emit_by_name(manager, "dialing-call", op, cl ? cl : "");
  49         }
  50 }
  51
  52 static void call_removed(OrgOfonoVoiceCallManager *manager,
  53                          gchar *op,
  54                          GVariant *properties)
  55 {
  56         g_signal_emit_by_name(manager, "terminated-call", op);
  57 }
  58
  59
  60 const OrgOfonoVoiceCallManager
  61 *ofono_voicecallmanager_init(const struct afb_binding_interface *iface,
  62                              const gchar *op,
  63                              void (*incoming_call)(OrgOfonoVoiceCallManager *manager,gchar *,gchar *),
  64                              void (*dialing_call)(OrgOfonoVoiceCallManager *manager,gchar *,gchar *),
  65                              void (*terminated_call)(OrgOfonoVoiceCallManager *manager,gchar *))
  66 {
  67         interface = iface;
  68
  69         OrgOfonoVoiceCallManager *manager = org_ofono_voice_call_manager_proxy_new_for_bus_sync(
  70                         G_BUS_TYPE_SYSTEM, G_DBUS_PROXY_FLAGS_NONE,
  71                         "org.ofono", op, NULL, NULL);
  72
  73         g_signal_new("incoming-call",
  74                      G_TYPE_OBJECT,
  75                      G_SIGNAL_RUN_LAST,
  76                      0,
  77                      NULL,
  78                      NULL,
  79                      g_cclosure_marshal_generic,
  80                      G_TYPE_NONE,
  81                      2,
  82                      G_TYPE_STRING,
  83                      G_TYPE_STRING);
  84
  85         g_signal_new("dialing-call",
  86                      G_TYPE_OBJECT,
  87                      G_SIGNAL_RUN_LAST,
  88                      0,
  89                      NULL,
  90                      NULL,
  91                      g_cclosure_marshal_generic,
  92                      G_TYPE_NONE,
  93                      2,
  94                      G_TYPE_STRING,
  95                      G_TYPE_STRING);
  96
  97         g_signal_new("terminated-call",
  98                      G_TYPE_OBJECT,
  99                      G_SIGNAL_RUN_LAST,
 100                      0,
 101                      NULL,
 102                      NULL,
 103                      g_cclosure_marshal_generic,
 104                      G_TYPE_NONE,
 105                      1,
 106                      G_TYPE_STRING);
 107
 108         if (g_signal_connect(G_OBJECT(manager), "incoming-call", G_CALLBACK(incoming_call), NULL) <= 0) {
 109                 ERROR(interface, "Failed to connect to signal incoming-call\n");
 110         }
 111
 112         if (g_signal_connect(G_OBJECT(manager), "dialing-call", G_CALLBACK(dialing_call), NULL) <= 0) {
 113                 ERROR(interface, "Failed to connect to signal dialing-call\n");
 114         }
 115
 116         if (g_signal_connect(G_OBJECT(manager), "terminated-call", G_CALLBACK(terminated_call), NULL) <= 0) {
 117                 ERROR(interface, "Failed to connect to signal terminated-call\n");
 118         }
 119
 120         if (g_signal_connect(manager, "call-added", G_CALLBACK(call_added), NULL) <= 0) {
 121                 ERROR(interface, "Failed to connect to signal call-added\n");
 122         }
 123
 124         if (g_signal_connect(manager, "call-removed", G_CALLBACK(call_removed), NULL) <= 0) {
 125                 ERROR(interface, "Failed to connect to signal call-removed\n");
 126         }
 127
 128         return manager;
 129 }
 130
 131 gchar *ofono_voicecallmanager_dial(OrgOfonoVoiceCallManager *manager,
 132                                    const gchar *number,
 133                                    const gchar *cid)
 134 {
 135         gchar *out = NULL;
 136         GError *error = NULL;
 137
 138         if (!manager) {
 139                 ERROR(interface, "Ofono VoiceCallmanager uninitialized\n");
 140                 return NULL;
 141         }
 142
 143         org_ofono_voice_call_manager_call_dial_sync(manager, number, cid, &out, NULL, &error);
 144         if (error != NULL)
 145                 out = NULL;
 146
 147         return out;
 148 }
 149
 150 void ofono_voicecallmanager_hangup_all(OrgOfonoVoiceCallManager *manager)
 151 {
 152         GError *error = NULL;
 153
 154         if (!manager) {
 155                 ERROR(interface, "Ofono VoiceCallmanager uninitialized\n");
 156                 return;
 157         }
 158
 159         org_ofono_voice_call_manager_call_hangup_all_sync(manager, NULL, &error);
 160 }