include/gammu-call.h

   1 /**
   2  * \file gammu-call.h
   3  * \author Michal Čihař
   4  *
   5  * Call data and functions.
   6  */
   7 #ifndef __gammu_call_h
   8 #define __gammu_call_h
   9
  10 /**
  11  * \defgroup Call Call
  12  * Call entries manipulations.
  13  */
  14
  15 #include <gammu-types.h>
  16 #include <gammu-limits.h>
  17 #include <gammu-error.h>
  18 #include <gammu-statemachine.h>
  19
  20 /**
  21  * \defgroup Divert Divert
  22  * Diversion entries manipulations.
  23  */
  24
  25 /**
  26  * Enum with status of call.
  27  *
  28  * \ingroup Call
  29  */
  30 typedef enum {
  31         /**
  32          * Somebody calls to us
  33          */
  34         GSM_CALL_IncomingCall = 1,
  35         /**
  36          * We call somewhere
  37          */
  38         GSM_CALL_OutgoingCall,
  39         /**
  40          * Call started
  41          */
  42         GSM_CALL_CallStart,
  43         /**
  44          * End of call from unknown side
  45          */
  46         GSM_CALL_CallEnd,
  47         /**
  48          * End of call from remote side
  49          */
  50         GSM_CALL_CallRemoteEnd,
  51         /**
  52          * End of call from our side
  53          */
  54         GSM_CALL_CallLocalEnd,
  55         /**
  56          * Call established. Waiting for answer or dropping
  57          */
  58         GSM_CALL_CallEstablished,
  59         /**
  60          * Call held
  61          */
  62         GSM_CALL_CallHeld,
  63         /**
  64          * Call resumed
  65          */
  66         GSM_CALL_CallResumed,
  67         /**
  68          * We switch to call
  69          */
  70         GSM_CALL_CallSwitched
  71 } GSM_CallStatus;
  72
  73 /**
  74  * Call information.
  75  *
  76  * \ingroup Call
  77  */
  78 typedef struct {
  79         /**
  80          * Call status.
  81          */
  82         GSM_CallStatus Status;
  83         /**
  84          * Call ID
  85          */
  86         int CallID;
  87         /**
  88          * Whether Call ID is available.
  89          */
  90         gboolean CallIDAvailable;
  91         /**
  92          * Status code.
  93          */
  94         int StatusCode;
  95         /**
  96          * Remote phone number.
  97          */
  98         unsigned char PhoneNumber[(GSM_MAX_NUMBER_LENGTH + 1) * 2];
  99 } GSM_Call;
 100
 101 /**
 102  * Defines when diversion is active.
 103  *
 104  * \ingroup Divert
 105  */
 106 typedef enum {
 107         /**
 108          * Divert when busy.
 109          */
 110         GSM_DIVERT_Busy = 0x01,
 111         /**
 112          * Divert when not answered.
 113          */
 114         GSM_DIVERT_NoAnswer,
 115         /**
 116          * Divert when phone off or no coverage.
 117          */
 118         GSM_DIVERT_OutOfReach,
 119         /**
 120          * Divert all calls without ringing.
 121          */
 122         GSM_DIVERT_AllTypes
 123 } GSM_Divert_DivertTypes;
 124
 125 /**
 126  * Which type of calls should be diverted.
 127  *
 128  * \ingroup Divert
 129  */
 130 typedef enum {
 131         /**
 132          * Voice calls.
 133          */
 134         GSM_DIVERT_VoiceCalls = 0x01,
 135         /**
 136          * Fax calls.
 137          */
 138         GSM_DIVERT_FaxCalls,
 139         /**
 140          * Data calls.
 141          */
 142         GSM_DIVERT_DataCalls,
 143         /**
 144          * All calls.
 145          */
 146         GSM_DIVERT_AllCalls
 147 } GSM_Divert_CallTypes;
 148
 149 /**
 150  * Call diversion definition.
 151  *
 152  * \ingroup Divert
 153  */
 154 typedef struct {
 155         /**
 156          * When diversion is active.
 157          */
 158         GSM_Divert_DivertTypes DivertType;
 159         /**
 160          * Type of call to divert.
 161          */
 162         GSM_Divert_CallTypes CallType;
 163         /**
 164          * Timeout for diversion.
 165          */
 166         unsigned int Timeout;
 167         /**
 168          * Number where to divert.
 169          */
 170         char Number[(GSM_MAX_NUMBER_LENGTH + 1) * 2];
 171 } GSM_CallDivert;
 172
 173 /**
 174  * Multiple call diversions.
 175  *
 176  * \ingroup Divert
 177  */
 178 typedef struct {
 179         int EntriesNum;
 180         GSM_CallDivert Entries[GSM_MAX_CALL_DIVERTS];
 181 } GSM_MultiCallDivert;
 182
 183 /**
 184  * How to handle number when initiating voice call.
 185  *
 186  * \ingroup Call
 187  */
 188 typedef enum {
 189         /**
 190          * Show number.
 191          */
 192         GSM_CALL_ShowNumber = 1,
 193         /**
 194          * Hide number.
 195          */
 196         GSM_CALL_HideNumber,
 197         /**
 198          * Keep phone default settings.
 199          */
 200         GSM_CALL_DefaultNumberPresence
 201 } GSM_CallShowNumber;
 202
 203 /**
 204  * Dials number and starts voice call.
 205  *
 206  * \param s State machine pointer.
 207  * \param Number Number to dial.
 208  * \param ShowNumber Whether we want to display number on phone.
 209  *
 210  * \return Error code
 211  *
 212  * \ingroup Call
 213  */
 214 GSM_Error GSM_DialVoice(GSM_StateMachine * s, char *Number,
 215                         GSM_CallShowNumber ShowNumber);
 216 /**
 217  * Dials service number (usually for USSD).
 218  *
 219  * \param s State machine pointer.
 220  * \param Number Number to dial.
 221  *
 222  * \return Error code
 223  *
 224  * \ingroup Call
 225  */
 226 GSM_Error GSM_DialService(GSM_StateMachine * s, char *Number);
 227
 228 /**
 229  * Accept current incoming call.
 230  *
 231  * \param s State machine pointer.
 232  * \param ID ID of call.
 233  * \param all Whether to handle all call and not only the one specified
 234  * by ID.
 235  *
 236  * \return Error code
 237  *
 238  * \ingroup Call
 239  */
 240 GSM_Error GSM_AnswerCall(GSM_StateMachine * s, int ID, gboolean all);
 241
 242 /**
 243  * Deny current incoming call.
 244  *
 245  * \param s State machine pointer.
 246  * \param ID ID of call.
 247  * \param all Whether to handle all call and not only the one specified
 248  * by ID.
 249  *
 250  * \return Error code
 251  *
 252  * \ingroup Call
 253  */
 254 GSM_Error GSM_CancelCall(GSM_StateMachine * s, int ID, gboolean all);
 255
 256 /**
 257  * Holds call.
 258  *
 259  * \param s State machine pointer.
 260  * \param ID ID of call.
 261  *
 262  * \return Error code
 263  *
 264  * \ingroup Call
 265  */
 266 GSM_Error GSM_HoldCall(GSM_StateMachine * s, int ID);
 267
 268 /**
 269  * Unholds call.
 270  *
 271  * \param s State machine pointer.
 272  * \param ID ID of call.
 273  *
 274  * \return Error code
 275  *
 276  * \ingroup Call
 277  */
 278 GSM_Error GSM_UnholdCall(GSM_StateMachine * s, int ID);
 279
 280 /**
 281  * Initiates conference call.
 282  *
 283  * \param s State machine pointer.
 284  * \param ID ID of call.
 285  *
 286  * \return Error code
 287  *
 288  * \ingroup Call
 289  */
 290 GSM_Error GSM_ConferenceCall(GSM_StateMachine * s, int ID);
 291
 292 /**
 293  * Splits call.
 294  *
 295  * \param s State machine pointer.
 296  * \param ID ID of call.
 297  *
 298  * \return Error code
 299  *
 300  * \ingroup Call
 301  */
 302 GSM_Error GSM_SplitCall(GSM_StateMachine * s, int ID);
 303
 304 /**
 305  * Transfers call.
 306  *
 307  * \param s State machine pointer.
 308  * \param ID ID of call.
 309  * \param next Switches next call and ignores ID.
 310  *
 311  * \return Error code
 312  *
 313  * \ingroup Call
 314  */
 315 GSM_Error GSM_TransferCall(GSM_StateMachine * s, int ID, gboolean next);
 316
 317 /**
 318  * Switches call.
 319  *
 320  * \param s State machine pointer.
 321  * \param ID ID of call.
 322  * \param next Switches next call and ignores ID.
 323  *
 324  * \return Error code
 325  *
 326  * \ingroup Call
 327  */
 328 GSM_Error GSM_SwitchCall(GSM_StateMachine * s, int ID, gboolean next);
 329
 330 /**
 331  * Gets call diverts.
 332  *
 333  * \param s State machine pointer.
 334  * \param request Which diverts to get.
 335  * \param result Storage for diversions information.
 336  *
 337  * \return Error code
 338  *
 339  * \ingroup Divert
 340  */
 341 GSM_Error GSM_GetCallDivert(GSM_StateMachine *s, GSM_CallDivert *request, GSM_MultiCallDivert *result);
 342
 343 /**
 344  * Sets call diverts.
 345  *
 346  * \param s State machine pointer.
 347  * \param divert Diversions information to set.
 348  *
 349  * \return Error code
 350  *
 351  * \ingroup Divert
 352  */
 353 GSM_Error GSM_SetCallDivert(GSM_StateMachine * s, GSM_CallDivert * divert);
 354
 355 /**
 356  * Cancels all diverts.
 357  *
 358  * \param s State machine pointer.
 359  *
 360  * \return Error code
 361  *
 362  * \ingroup Divert
 363  */
 364 GSM_Error GSM_CancelAllDiverts(GSM_StateMachine * s);
 365
 366 /**
 367  * Activates/deactivates noticing about incoming calls.
 368  *
 369  * \param s State machine pointer.
 370  * \param enable Whether to enable notifications.
 371  *
 372  * \return Error code
 373  *
 374  * \ingroup Call
 375  */
 376 GSM_Error GSM_SetIncomingCall(GSM_StateMachine * s, gboolean enable);
 377
 378 /**
 379  * Sends DTMF (Dual Tone Multi Frequency) tone.
 380  *
 381  * \param s State machine pointer.
 382  * \param sequence Sequence to press.
 383  *
 384  * \return Error code
 385  *
 386  * \ingroup Call
 387  */
 388 GSM_Error GSM_SendDTMF(GSM_StateMachine * s, char *sequence);
 389
 390 #endif
 391
 392 /* Editor configuration
 393  * vim: noexpandtab sw=8 ts=8 sts=8 tw=72:
 394  */