mmserv/tms/tmsimpl/src/tmsdtmfbodyimpl.cpp
changeset 20 b67dd1fc57c5
parent 14 80975da52420
child 33 5e8b14bae8c3
child 42 1fa3fb47b1e3
equal deleted inserted replaced
19:4a629bc82c5e 20:b67dd1fc57c5
    37     {
    37     {
    38     TRACE_PRN_FN_ENT;
    38     TRACE_PRN_FN_ENT;
    39     if (iProxy)
    39     if (iProxy)
    40         {
    40         {
    41         iProxy->Close();
    41         iProxy->Close();
    42         delete iProxy;
    42         }
    43         iProxy = NULL;
    43     delete iProxy;
    44         }
    44 
    45     if (iString)
    45     if (iString)
    46         {
    46         {
    47         g_string_free(iString, TRUE);
    47         g_string_free(iString, TRUE);
    48         }
    48         }
    49     iObserver = NULL;
    49     iObserver = NULL;
    75 
    75 
    76 gint TMSDTMFBodyImpl::PostConstruct()
    76 gint TMSDTMFBodyImpl::PostConstruct()
    77     {
    77     {
    78     gint ret(TMS_RESULT_SUCCESS);
    78     gint ret(TMS_RESULT_SUCCESS);
    79     iClientId = 1;
    79     iClientId = 1;
    80     iProxy = new TMSProxy;
    80     iProxy = new TMSProxy();
    81     if (!iProxy)
    81     if (!iProxy)
    82         {
    82         {
    83         ret = TMS_RESULT_INSUFFICIENT_MEMORY;
    83         ret = TMS_RESULT_INSUFFICIENT_MEMORY;
    84         }
    84         }
    85     RET_REASON_IF_ERR(ret);
    85     else
    86 
    86         {
    87     if (iProxy->Connect() != TMS_RESULT_SUCCESS)
    87         if (iProxy->Connect() != TMS_RESULT_SUCCESS)
    88         {
    88             {
    89         delete iProxy;
    89             delete iProxy;
    90         iProxy = NULL;
    90             iProxy = NULL;
    91         ret = TMS_RESULT_FATAL_ERROR;
    91             ret = TMS_RESULT_FATAL_ERROR;
       
    92             }
    92         }
    93         }
    93     RET_REASON_IF_ERR(ret);
    94     RET_REASON_IF_ERR(ret);
    94     return ret;
    95     return ret;
    95     }
    96     }
    96 
    97 
   139     }
   140     }
   140 
   141 
   141 gint TMSDTMFBodyImpl::Start()
   142 gint TMSDTMFBodyImpl::Start()
   142     {
   143     {
   143     gint ret(TMS_RESULT_SUCCESS);
   144     gint ret(TMS_RESULT_SUCCESS);
       
   145     if (iProxy && iString)
       
   146         {
       
   147         if (iString->len)
       
   148             {
       
   149             ret = iProxy->StartDTMF(iStreamType, iString);
       
   150             }
       
   151         else
       
   152             {
       
   153             ret = TMS_RESULT_INVALID_ARGUMENT;
       
   154             }
       
   155         }
       
   156     else
       
   157         {
       
   158         ret = TMS_RESULT_UNINITIALIZED_OBJECT;
       
   159         }
       
   160     return ret;
       
   161     }
       
   162 
       
   163 gint TMSDTMFBodyImpl::Stop()
       
   164     {
       
   165     gint ret(TMS_RESULT_SUCCESS);
   144     if (iProxy)
   166     if (iProxy)
   145         {
   167         {
       
   168         ret = iProxy->StopDTMF(iStreamType);
       
   169         }
       
   170     else
       
   171         {
       
   172         ret = TMS_RESULT_UNINITIALIZED_OBJECT;
       
   173         }
       
   174     return ret;
       
   175     }
       
   176 
       
   177 gint TMSDTMFBodyImpl::SetTone(GString* string)
       
   178     {
       
   179     __ASSERT_ALWAYS(string, PANIC(TMS_RESULT_NULL_ARGUMENT));
       
   180 
       
   181     gint ret(TMS_RESULT_SUCCESS);
       
   182 
       
   183     if (iString)
       
   184         {
   146         if (iString->len)
   185         if (iString->len)
   147             {
   186             {
   148             ret = iProxy->StartDTMF(iStreamType, iString);
   187             g_string_free(iString, TRUE);
   149             }
   188             }
   150         else
   189         }
   151             {
   190 
   152             ret = TMS_RESULT_INVALID_ARGUMENT;
   191     iString = g_string_new_len(string->str, string->len);
   153             }
   192     return ret;
       
   193     }
       
   194 
       
   195 gint TMSDTMFBodyImpl::ContinueDTMFStringSending(gboolean sending)
       
   196     {
       
   197     gint ret(TMS_RESULT_SUCCESS);
       
   198     if (iProxy)
       
   199         {
       
   200         ret = iProxy->ContinueDTMFStringSending(sending);
   154         }
   201         }
   155     else
   202     else
   156         {
   203         {
   157         ret = TMS_RESULT_DOES_NOT_EXIST;
   204         ret = TMS_RESULT_DOES_NOT_EXIST;
   158         }
   205         }
   159     return ret;
   206     return ret;
   160     }
   207     }
   161 
   208 
   162 gint TMSDTMFBodyImpl::Stop()
       
   163     {
       
   164     gint ret(TMS_RESULT_SUCCESS);
       
   165     if (iProxy)
       
   166         {
       
   167         ret = iProxy->StopDTMF(iStreamType);
       
   168         }
       
   169     else
       
   170         {
       
   171         ret = TMS_RESULT_DOES_NOT_EXIST;
       
   172         }
       
   173     return ret;
       
   174     }
       
   175 
       
   176 gint TMSDTMFBodyImpl::SetTone(GString* string)
       
   177     {
       
   178     gint ret(TMS_RESULT_SUCCESS);
       
   179 
       
   180     if (iString && iString->len)
       
   181         {
       
   182         g_string_free(iString, TRUE);
       
   183         }
       
   184 
       
   185     iString = g_string_new_len(string->str, string->len);
       
   186     return ret;
       
   187     }
       
   188 
       
   189 gint TMSDTMFBodyImpl::ContinueDTMFStringSending(gboolean aContinue)
       
   190     {
       
   191     gint ret(TMS_RESULT_SUCCESS);
       
   192     if (iProxy)
       
   193         {
       
   194         ret = iProxy->ContinueDTMFStringSending(aContinue);
       
   195         }
       
   196     else
       
   197         {
       
   198         ret = TMS_RESULT_DOES_NOT_EXIST;
       
   199         }
       
   200     return ret;
       
   201     }
       
   202 
       
   203 void TMSDTMFBodyImpl::SetParent(TMSDTMF*& parent)
   209 void TMSDTMFBodyImpl::SetParent(TMSDTMF*& parent)
   204     {
   210     {
   205     iParent = parent;
   211     iParent = parent;
   206     }
   212     }
   207 
   213