1 /*

     2  * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

     3  * All rights reserved.

     4  * This component and the accompanying materials are made available

     5  * under the terms of "Eclipse Public License v1.0"

     6  * which accompanies this distribution, and is available

     7  * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8  *

     9  * Initial Contributors:

    10  * Nokia Corporation - initial contribution.

    11  *

    12  * Contributors:

    13  *

    14  * Description: Telephony Multimedia Service

    15  *

    16  */

    17 

    18 #include <tms.h>

    19 #include <tmsdtmfobsrvr.h>

    20 #include "tmsutility.h"

    21 #include "tmsproxy.h"

    22 #include "tmsdtmfbodyimpl.h"

    23 

    24 using namespace TMS;

    25 

    26 TMSDTMFBodyImpl::TMSDTMFBodyImpl() :

    27     iObserver(NULL),

    28     iProxy(NULL),

    29     iParent(NULL),

    30     iString(NULL)

    31     {

    32     TRACE_PRN_FN_ENT;

    33     TRACE_PRN_FN_EXT;

    34     }

    35 

    36 TMSDTMFBodyImpl::~TMSDTMFBodyImpl()

    37     {

    38     TRACE_PRN_FN_ENT;

    39     if (iProxy)

    40         {

    41         iProxy->Close();

    42         delete iProxy;

    43         iProxy = NULL;

    44         }

    45     if (iString)

    46         {

    47         g_string_free(iString, TRUE);

    48         }

    49     iObserver = NULL;

    50     iParent = NULL;

    51     iUserData = NULL;

    52     TRACE_PRN_FN_EXT;

    53     }

    54 

    55 gint TMSDTMFBodyImpl::Create(TMSStreamType streamtype, TMSDTMFBody*& bodyimpl)

    56     {

    57     gint ret(TMS_RESULT_INSUFFICIENT_MEMORY);

    58     TMSDTMFBodyImpl* self = new TMSDTMFBodyImpl();

    59     if (self)

    60         {

    61         ret = self->PostConstruct();

    62         if (ret != TMS_RESULT_SUCCESS)

    63             {

    64             delete self;

    65             self = NULL;

    66             }

    67         self->iStreamType = streamtype;

    68         }

    69     bodyimpl = self;

    70     return ret;

    71     }

    72 

    73 gint TMSDTMFBodyImpl::PostConstruct()

    74     {

    75     gint ret(TMS_RESULT_SUCCESS);

    76     iClientId = 1;

    77     iProxy = new TMSProxy;

    78     if (!iProxy)

    79         {

    80         ret = TMS_RESULT_INSUFFICIENT_MEMORY;

    81         }

    82     RET_REASON_IF_ERR(ret);

    83 

    84     if (iProxy->Connect() != TMS_RESULT_SUCCESS)

    85         {

    86         delete iProxy;

    87         iProxy = NULL;

    88         ret = TMS_RESULT_FATAL_ERROR;

    89         }

    90     RET_REASON_IF_ERR(ret);

    91     return ret;

    92     }

    93 

    94 gint TMSDTMFBodyImpl::AddObserver(TMSDTMFObserver& obsrvr,

    95         gpointer user_data)

    96     {

    97     gint ret(TMS_RESULT_SUCCESS);

    98     if (!iObserver)

    99         {

   100         iObserver = &obsrvr;

   101         iUserData = user_data;

   102         if (iProxy)

   103             {

   104             ret = iProxy->SetMsgQueueNotifier(EMsgQueueDTMFType, iObserver,

   105                     iParent, iClientId);

   106             if (ret == TMS_RESULT_SUCCESS)

   107                 {

   108                 ret = iProxy->StartDTMFNotifier();

   109                 }

   110             }

   111         else

   112             {

   113             ret = TMS_RESULT_DOES_NOT_EXIST;

   114             }

   115         }

   116     else

   117         {

   118         ret = TMS_RESULT_ALREADY_EXIST;

   119         }

   120     return ret;

   121     }

   122 

   123 gint TMSDTMFBodyImpl::RemoveObserver(TMSDTMFObserver& obsrvr)

   124     {

   125     gint ret(TMS_RESULT_SUCCESS);

   126     if (iProxy && (&obsrvr == iObserver))

   127         {

   128         ret = iProxy->RemoveMsgQueueNotifier(EMsgQueueDTMFType, iObserver);

   129         iObserver = NULL;

   130         iProxy->CancelDTMFNotifier();

   131         }

   132     else

   133         {

   134         ret = TMS_RESULT_DOES_NOT_EXIST;

   135         }

   136     return ret;

   137     }

   138 

   139 gint TMSDTMFBodyImpl::Start()

   140     {

   141     gint ret(TMS_RESULT_SUCCESS);

   142     if (iProxy)

   143         {

   144         if (iString->len)

   145             {

   146             ret = iProxy->StartDTMF(iStreamType, iString);

   147             }

   148         else

   149             {

   150             ret = TMS_RESULT_INVALID_ARGUMENT;

   151             }

   152         }

   153     else

   154         {

   155         ret = TMS_RESULT_DOES_NOT_EXIST;

   156         }

   157     return ret;

   158     }

   159 

   160 gint TMSDTMFBodyImpl::Stop()

   161     {

   162     gint ret(TMS_RESULT_SUCCESS);

   163     if (iProxy)

   164         {

   165         ret = iProxy->StopDTMF(iStreamType);

   166         }

   167     else

   168         {

   169         ret = TMS_RESULT_DOES_NOT_EXIST;

   170         }

   171     return ret;

   172     }

   173 

   174 gint TMSDTMFBodyImpl::SetTone(GString* string)

   175     {

   176     gint ret(TMS_RESULT_SUCCESS);

   177 

   178     if (iString && iString->len)

   179         {

   180         g_string_free(iString, TRUE);

   181         }

   182 

   183     iString = g_string_new_len(string->str, string->len);

   184     return ret;

   185     }

   186 

   187 gint TMSDTMFBodyImpl::ContinueDTMFStringSending(gboolean aContinue)

   188     {

   189     gint ret(TMS_RESULT_SUCCESS);

   190     if (iProxy)

   191         {

   192         ret = iProxy->ContinueDTMFStringSending(aContinue);

   193         }

   194     else

   195         {

   196         ret = TMS_RESULT_DOES_NOT_EXIST;

   197         }

   198     return ret;

   199     }

   200 

   201 void TMSDTMFBodyImpl::SetParent(TMSDTMF*& parent)

   202     {

   203     iParent = parent;

   204     }

   205