Mercurial Mercurial > oss > FCL > sf > mw > mmappfw / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
qtms/src/qtmsfactoryimpl.cpp
changeset 32 edd273b3192a
parent 27 cbb1bfb7ebfb
child 40 4a1905d205a2
equal deleted inserted replaced
27:cbb1bfb7ebfb 32:edd273b3192a 
    55 using namespace QTMS;
 
    55 using namespace QTMS;
 
    56 using namespace TMS;
 
    56 using namespace TMS;
 
    57 
    57 
    58 QTMSFactoryImpl::QTMSFactoryImpl()
 
    58 QTMSFactoryImpl::QTMSFactoryImpl()
 
    59     {
 
    59     {
 
       
    60     TRACE_PRN_FN_ENT;
 
    60     TMSVer* ver = NULL;
 
    61     TMSVer* ver = NULL;
 
    61     TMSFactory::CreateFactory(iFactory, *ver);
 
    62     TMSFactory::CreateFactory(iFactory, *ver);
 
       
    63     TRACE_PRN_FN_EXT;
 
    62     }
 
    64     }
 
    63 
    65 
    64 QTMSFactoryImpl::~QTMSFactoryImpl()
 
    66 QTMSFactoryImpl::~QTMSFactoryImpl()
 
    65     {
 
    67     {
 
       
    68     TRACE_PRN_FN_ENT;
 
    66     delete iFactory;
 
    69     delete iFactory;
 
       
    70     TRACE_PRN_FN_EXT;
 
    67     }
 
    71     }
 
    68 
    72 
    69 gint QTMSFactoryImpl::CreateCall(QTMSCallType ctype, QTMSCall*& qtmscall,
 
    73 gint QTMSFactoryImpl::CreateCall(QTMSCallType ctype, QTMSCall*& qtmscall,
 
    70         guint /*ctxid*/)
 
    74         guint /*ctxid*/)
 
    71     {
 
    75     {
 
       
    76     TRACE_PRN_FN_ENT;
 
    72     gint ret(QTMS_RESULT_UNINITIALIZED_OBJECT);
 
    77     gint ret(QTMS_RESULT_UNINITIALIZED_OBJECT);
 
    73 
    78 
    74     TMSCall* tmscall(NULL);
 
    79     TMSCall* tmscall(NULL);
 
    75     if (iFactory)
 
    80     if (iFactory)
 
    76         {
 
    81         {
 
    79         if (ret == TMS_RESULT_SUCCESS)
 
    84         if (ret == TMS_RESULT_SUCCESS)
 
    80             {
 
    85             {
 
    81             ret = QTMSCallImpl::Create(qtmscall, tmscall);
 
    86             ret = QTMSCallImpl::Create(qtmscall, tmscall);
 
    82             }
 
    87             }
 
    83         }
 
    88         }
 
       
    89     TRACE_PRN_FN_EXT;
 
    84     return ret;
 
    90     return ret;
 
    85     }
 
    91     }
 
    86 
    92 
    87 gint QTMSFactoryImpl::DeleteCall(QTMSCall*& qtmscall)
 
    93 gint QTMSFactoryImpl::DeleteCall(QTMSCall*& qtmscall)
 
    88     {
 
    94     {
 
       
    95     TRACE_PRN_FN_ENT;
 
    89     gint ret(QTMS_RESULT_SUCCESS);
 
    96     gint ret(QTMS_RESULT_SUCCESS);
 
    90     delete qtmscall;
 
    97     delete qtmscall;
 
    91     qtmscall = NULL;
 
    98     qtmscall = NULL;
 
       
    99     TRACE_PRN_FN_EXT;
 
    92     return ret;
 
   100     return ret;
 
    93     }
 
   101     }
 
    94 
   102 
    95 gint QTMSFactoryImpl::IsCallTypeSupported(QTMSCallType ctype, gboolean& flag)
 
   103 gint QTMSFactoryImpl::IsCallTypeSupported(QTMSCallType ctype, gboolean& flag)
 
    96     {
 
   104     {
 
   111     }
 
   119     }
 
   112 
   120 
   113 gint QTMSFactoryImpl::GetSupportedFormats(const QTMSStreamType strmtype,
 
   121 gint QTMSFactoryImpl::GetSupportedFormats(const QTMSStreamType strmtype,
 
   114         FormatVector& fmtlist)
 
   122         FormatVector& fmtlist)
 
   115     {
 
   123     {
 
   116     gint ret(QTMS_RESULT_SUCCESS);
 
   124     TRACE_PRN_FN_ENT;
 
       
   125     gint ret(QTMS_RESULT_UNINITIALIZED_OBJECT);
 
   117     TMS::FormatVector tmsfmtlist;
 
   126     TMS::FormatVector tmsfmtlist;
 
   118     if(iFactory)
 
   127     if (iFactory)
 
   119         {
 
   128         {
 
   120         iFactory->GetSupportedFormats(strmtype,tmsfmtlist);
 
   129         ret = iFactory->GetSupportedFormats(strmtype,tmsfmtlist);
 
   121         }
 
   130         }
 
   122 
   131 
   123     std::vector<TMSFormat*>::iterator itCodecs = tmsfmtlist.begin();
 
   132     std::vector<TMSFormat*>::iterator itCodecs = tmsfmtlist.begin();
 
   124     TMSFormatType fmttype;
 
   133     TMSFormatType fmttype;
 
   125     for (; itCodecs < tmsfmtlist.end(); itCodecs++)
 
   134     for (; itCodecs < tmsfmtlist.end(); itCodecs++)
 
   145                 break;
 
   154                 break;
 
   146             default:
 
   155             default:
 
   147                 break;
 
   156                 break;
 
   148             }
 
   157             }
 
   149 
   158 
   150         if(qtmsfmt)
 
   159         if (qtmsfmt)
 
   151             {
 
   160             {
 
   152             fmtlist.push_back(qtmsfmt);
 
   161             fmtlist.push_back(qtmsfmt);
 
   153             }
 
   162             }
 
   154         }
 
   163         }
 
   155 
   164     TRACE_PRN_FN_EXT;
 
   156     return ret;
 
   165     return ret;
 
   157     }
 
   166     }
 
   158 
   167 
   159 gint QTMSFactoryImpl::CreateFormat(QTMSFormatType fmttype,
 
   168 gint QTMSFactoryImpl::CreateFormat(QTMSFormatType fmttype,
 
   160         QTMSFormat*& qtmsfmt)
 
   169         QTMSFormat*& qtmsfmt)
 
   161     {
 
   170     {
 
   162     gint ret(QTMS_RESULT_SUCCESS);
 
   171     TRACE_PRN_FN_ENT;
 
   163 
   172     gint ret(QTMS_RESULT_UNINITIALIZED_OBJECT);
 
   164     TMSFormat* tmsformat(NULL);
 
   173     TMSFormat* tmsformat(NULL);
 
   165 
   174 
   166     if (iFactory)
 
   175     if (iFactory)
 
   167         {
 
   176         {
 
   168         ret = iFactory->CreateFormat((TMSFormatType) fmttype, tmsformat);
 
   177         ret = iFactory->CreateFormat((TMSFormatType) fmttype, tmsformat);
 
   185                     break;
 
   194                     break;
 
   186                 case QTMS_FORMAT_ILBC:
 
   195                 case QTMS_FORMAT_ILBC:
 
   187                     ret = QTMSILBCFormatImpl::Create(qtmsfmt, tmsformat);
 
   196                     ret = QTMSILBCFormatImpl::Create(qtmsfmt, tmsformat);
 
   188                     break;
 
   197                     break;
 
   189                 default:
 
   198                 default:
 
       
   199                     ret = QTMS_RESULT_FORMAT_TYPE_NOT_SUPPORTED;
 
   190                     break;
 
   200                     break;
 
   191                 }
 
   201                 }
 
   192             }
 
   202             }
 
   193         }
 
   203         }
 
   194 
   204     TRACE_PRN_FN_EXT;
 
   195     return ret;
 
   205     return ret;
 
   196     }
 
   206     }
 
   197 
   207 
   198 gint QTMSFactoryImpl::DeleteFormat(QTMSFormat*& qtmsfmt)
 
   208 gint QTMSFactoryImpl::DeleteFormat(QTMSFormat*& qtmsfmt)
 
   199     {
 
   209     {
 
   200     gint ret(QTMS_RESULT_FORMAT_TYPE_NOT_SUPPORTED);
 
   210     TRACE_PRN_FN_ENT;
 
   201 
   211     __ASSERT_ALWAYS(qtmsfmt, PANIC(QTMS_RESULT_NULL_ARGUMENT));
 
       
   212 
       
   213     gint ret(QTMS_RESULT_SUCCESS);
 
   202     QTMSFormatType fmttype;
 
   214     QTMSFormatType fmttype;
 
   203     ret = qtmsfmt->GetType(fmttype);
 
   215     ret = qtmsfmt->GetType(fmttype);
 
   204     switch (fmttype)
 
   216     switch (fmttype)
 
   205         {
 
   217         {
 
   206         case QTMS_FORMAT_PCM:
 
   218         case QTMS_FORMAT_PCM:
 
   207             delete (static_cast<QTMSPCMFormatImpl*>(qtmsfmt));
 
   219             delete (static_cast<QTMSPCMFormatImpl*>(qtmsfmt));
 
   208             qtmsfmt = NULL;
 
   220             qtmsfmt = NULL;
 
   209             ret = QTMS_RESULT_SUCCESS;
 
       
   210             break;
 
   221             break;
 
   211         case QTMS_FORMAT_AMR:
 
   222         case QTMS_FORMAT_AMR:
 
   212             delete (static_cast<QTMSAMRFormatImpl*>(qtmsfmt));
 
   223             delete (static_cast<QTMSAMRFormatImpl*>(qtmsfmt));
 
   213             qtmsfmt = NULL;
 
   224             qtmsfmt = NULL;
 
   214             ret = QTMS_RESULT_SUCCESS;
 
       
   215             break;
 
   225             break;
 
   216         case QTMS_FORMAT_G711:
 
   226         case QTMS_FORMAT_G711:
 
   217             delete (static_cast<QTMSG711FormatImpl*>(qtmsfmt));
 
   227             delete (static_cast<QTMSG711FormatImpl*>(qtmsfmt));
 
   218             qtmsfmt = NULL;
 
   228             qtmsfmt = NULL;
 
   219             ret = QTMS_RESULT_SUCCESS;
 
       
   220             break;
 
   229             break;
 
   221         case QTMS_FORMAT_G729:
 
   230         case QTMS_FORMAT_G729:
 
   222             delete (static_cast<QTMSG729FormatImpl*>(qtmsfmt));
 
   231             delete (static_cast<QTMSG729FormatImpl*>(qtmsfmt));
 
   223             qtmsfmt = NULL;
 
   232             qtmsfmt = NULL;
 
   224             ret = QTMS_RESULT_SUCCESS;
 
       
   225             break;
 
   233             break;
 
   226         case QTMS_FORMAT_ILBC:
 
   234         case QTMS_FORMAT_ILBC:
 
   227             delete (static_cast<QTMSILBCFormatImpl*>(qtmsfmt));
 
   235             delete (static_cast<QTMSILBCFormatImpl*>(qtmsfmt));
 
   228             qtmsfmt = NULL;
 
   236             qtmsfmt = NULL;
 
   229             ret = QTMS_RESULT_SUCCESS;
 
       
   230             break;
 
   237             break;
 
   231         default:
 
   238         default:
 
   232             break;
 
   239             ret = QTMS_RESULT_FORMAT_TYPE_NOT_SUPPORTED;
 
   233         }
 
   240             break;
 
   234 
   241         }
 
       
   242     TRACE_PRN_FN_EXT;
 
   235     return ret;
 
   243     return ret;
 
   236     }
 
   244     }
 
   237 
   245 
   238 gint QTMSFactoryImpl::CreateEffect(QTMSEffectType tmseffecttype,
 
   246 gint QTMSFactoryImpl::CreateEffect(QTMSEffectType tmseffecttype,
 
   239         QTMSEffect*& qtmseffect)
 
   247         QTMSEffect*& qtmseffect)
 
   240     {
 
   248     {
 
   241     //gint ret(QTMS_RESULT_UNINITIALIZED_OBJECT);
 
   249     TRACE_PRN_FN_ENT;
 
   242     gint ret(TMS_RESULT_SUCCESS);
 
   250     gint ret(QTMS_RESULT_UNINITIALIZED_OBJECT);
 
   243     TMSEffect* tmseffect(NULL);
 
   251     TMSEffect* tmseffect(NULL);
 
       
   252 
   244     if (iFactory)
 
   253     if (iFactory)
 
   245         {
 
   254         {
 
   246         ret = iFactory->CreateEffect((TMSEffectType) tmseffecttype, tmseffect);
 
   255         ret = iFactory->CreateEffect((TMSEffectType) tmseffecttype, tmseffect);
 
   247 
   256 
   248         if (ret == TMS_RESULT_SUCCESS)
 
   257         if (ret == TMS_RESULT_SUCCESS)
 
   267                     ret = TMS_RESULT_EFFECT_TYPE_NOT_SUPPORTED;
 
   276                     ret = TMS_RESULT_EFFECT_TYPE_NOT_SUPPORTED;
 
   268                     break;
 
   277                     break;
 
   269                 }
 
   278                 }
 
   270             }
 
   279             }
 
   271         }
 
   280         }
 
   272 
   281     TRACE_PRN_FN_EXT;
 
   273     return ret;
 
   282     return ret;
 
   274     }
 
   283     }
 
   275 
   284 
   276 gint QTMSFactoryImpl::DeleteEffect(QTMSEffect*& qtmseffect)
 
   285 gint QTMSFactoryImpl::DeleteEffect(QTMSEffect*& qtmseffect)
 
   277     {
 
   286     {
 
       
   287     TRACE_PRN_FN_ENT;
 
   278     gint ret(QTMS_RESULT_SUCCESS);
 
   288     gint ret(QTMS_RESULT_SUCCESS);
 
   279 
   289 
   280     QTMSEffectType effecttype;
 
   290     QTMSEffectType effecttype;
 
   281     ret = qtmseffect->GetType(effecttype);
 
   291     ret = qtmseffect->GetType(effecttype);
 
   282     switch (effecttype)
 
   292     switch (effecttype)
 
   299             break;
 
   309             break;
 
   300         default:
 
   310         default:
 
   301             ret = QTMS_RESULT_EFFECT_TYPE_NOT_SUPPORTED;
 
   311             ret = QTMS_RESULT_EFFECT_TYPE_NOT_SUPPORTED;
 
   302             break;
 
   312             break;
 
   303         }
 
   313         }
 
   304 
   314     TRACE_PRN_FN_EXT;
 
   305     return ret;
 
   315     return ret;
 
   306     }
 
   316     }
 
   307 
   317 
   308 gint QTMSFactoryImpl::CreateBuffer(QTMSBufferType buffertype, guint size,
 
   318 gint QTMSFactoryImpl::CreateBuffer(QTMSBufferType buffertype, guint size,
 
   309         QTMSBuffer*& qtmsbuffer)
 
   319         QTMSBuffer*& qtmsbuffer)
 
   310     {
 
   320     {
 
   311     gint ret(TMS_RESULT_INSUFFICIENT_MEMORY);
 
   321     TRACE_PRN_FN_ENT;
 
   312     TRACE_PRN_FN_ENT;
 
   322     gint ret(QTMS_RESULT_UNINITIALIZED_OBJECT);
 
   313 
   323     TMSBuffer* tmsbuffer(NULL);
 
   314     switch (buffertype)
 
   324     if (iFactory)
 
   315         {
 
   325         {
 
   316         case QTMS_BUFFER_MEMORY:
 
   326         ret = iFactory->CreateBuffer(buffertype, size, tmsbuffer);
 
   317             ret = QTMSMemBuffer::Create(size, qtmsbuffer);
 
   327         if (ret == TMS_RESULT_SUCCESS)
 
   318             break;
 
   328             {
 
   319         default:
 
   329             switch (buffertype)
 
   320             ret = QTMS_RESULT_BUFFER_TYPE_NOT_SUPPORTED;
 
   330                 {
 
   321             break;
 
   331                 case QTMS_BUFFER_MEMORY:
 
       
   332                     ret = QTMSMemBuffer::Create(size, qtmsbuffer, tmsbuffer);
 
       
   333                     break;
 
       
   334                 default:
 
       
   335                     ret = QTMS_RESULT_BUFFER_TYPE_NOT_SUPPORTED;
 
       
   336                     break;
 
       
   337                 }
 
       
   338             }
 
   322         }
 
   339         }
 
   323 
   340 
   324     TRACE_PRN_FN_EXT;
 
   341     TRACE_PRN_FN_EXT;
 
   325     return ret;
 
   342     return ret;
 
   326     }
 
   343     }
 
   327 
   344 
   328 gint QTMSFactoryImpl::DeleteBuffer(QTMSBuffer*& qtmsbuffer)
 
   345 gint QTMSFactoryImpl::DeleteBuffer(QTMSBuffer*& qtmsbuffer)
 
   329     {
 
   346     {
 
       
   347     TRACE_PRN_FN_ENT;
 
       
   348     gint ret(QTMS_RESULT_SUCCESS);
 
   330     delete (static_cast<QTMSMemBuffer*> (qtmsbuffer));
 
   349     delete (static_cast<QTMSMemBuffer*> (qtmsbuffer));
 
   331     qtmsbuffer = NULL;
 
   350     qtmsbuffer = NULL;
 
   332     return QTMS_RESULT_SUCCESS;
 
   351     TRACE_PRN_FN_EXT;
 
       
   352     return ret;
 
   333     }
 
   353     }
 
   334 
   354 
   335 gint QTMSFactoryImpl::CreateSource(QTMSSourceType srctype,
 
   355 gint QTMSFactoryImpl::CreateSource(QTMSSourceType srctype,
 
   336         QTMSSource*& qtmssrc)
 
   356         QTMSSource*& qtmssrc)
 
   337     {
 
   357     {
 
   338     gint ret(QTMS_RESULT_SUCCESS);
 
   358     TRACE_PRN_FN_ENT;
 
       
   359     gint ret(QTMS_RESULT_UNINITIALIZED_OBJECT);
 
   339 
   360 
   340     TMS::TMSSource* tmssource(NULL);
 
   361     TMS::TMSSource* tmssource(NULL);
 
   341     if (iFactory)
 
   362     if (iFactory)
 
   342         {
 
   363         {
 
   343         ret = iFactory->CreateSource(srctype, tmssource);
 
   364         ret = iFactory->CreateSource(srctype, tmssource);
 
   354                     break;
 
   375                     break;
 
   355                 case QTMS_SOURCE_MIC:
 
   376                 case QTMS_SOURCE_MIC:
 
   356                     ret = QTMSMicSourceImpl::Create(qtmssrc, tmssource);
 
   377                     ret = QTMSMicSourceImpl::Create(qtmssrc, tmssource);
 
   357                     break;
 
   378                     break;
 
   358                 default:
 
   379                 default:
 
       
   380                     ret = TMS_RESULT_SOURCE_TYPE_NOT_SUPPORTED;
 
   359                     break;
 
   381                     break;
 
   360                 }
 
   382                 }
 
   361             }
 
   383             }
 
   362         }
 
   384         }
 
   363 
   385     TRACE_PRN_FN_EXT;
 
   364     return ret;
 
   386     return ret;
 
   365     }
 
   387     }
 
   366 
   388 
   367 gint QTMSFactoryImpl::DeleteSource(QTMSSource*& qtmssrc)
 
   389 gint QTMSFactoryImpl::DeleteSource(QTMSSource*& qtmssrc)
 
   368     {
 
   390     {
 
   369     gint ret(TMS_RESULT_INVALID_ARGUMENT);
 
   391     TRACE_PRN_FN_ENT;
 
   370 
   392     __ASSERT_ALWAYS(qtmssrc, PANIC(QTMS_RESULT_NULL_ARGUMENT));
 
       
   393 
       
   394     gint ret(QTMS_RESULT_SUCCESS);
 
   371     QTMSSourceType sourcetype;
 
   395     QTMSSourceType sourcetype;
 
   372     ret = qtmssrc->GetType(sourcetype);
 
   396     ret = qtmssrc->GetType(sourcetype);
 
   373     switch (sourcetype)
 
   397     switch (sourcetype)
 
   374         {
 
   398         {
 
   375         case QTMS_SOURCE_CLIENT:
 
   399         case QTMS_SOURCE_CLIENT:
 
   376             delete (static_cast<QTMSClientSourceImpl*>(qtmssrc));
 
   400             delete (static_cast<QTMSClientSourceImpl*>(qtmssrc));
 
   377             qtmssrc = NULL;
 
   401             qtmssrc = NULL;
 
   378             ret = QTMS_RESULT_SUCCESS;
 
       
   379             break;
 
   402             break;
 
   380         case QTMS_SOURCE_MODEM:
 
   403         case QTMS_SOURCE_MODEM:
 
   381             {
 
   404             {
 
   382             delete (static_cast<QTMSModemSourceImpl*>(qtmssrc));
 
   405             delete (static_cast<QTMSModemSourceImpl*>(qtmssrc));
 
   383             qtmssrc = NULL;
 
   406             qtmssrc = NULL;
 
   384             ret = TMS_RESULT_SUCCESS;
 
       
   385             }
 
   407             }
 
   386             break;
 
   408             break;
 
   387         case TMS_SOURCE_MIC:
 
   409         case TMS_SOURCE_MIC:
 
   388             {
 
   410             {
 
   389             delete (static_cast<QTMSMicSourceImpl*>(qtmssrc));
 
   411             delete (static_cast<QTMSMicSourceImpl*>(qtmssrc));
 
   390             qtmssrc = NULL;
 
   412             qtmssrc = NULL;
 
   391             ret = TMS_RESULT_SUCCESS;
 
       
   392             }
 
   413             }
 
   393             break;
 
   414             break;
 
   394         default:
 
   415         default:
 
   395             ret = TMS_RESULT_SOURCE_TYPE_NOT_SUPPORTED;
 
   416             ret = TMS_RESULT_SOURCE_TYPE_NOT_SUPPORTED;
 
   396             break;
 
   417             break;
 
   400     return ret;
 
   421     return ret;
 
   401     }
 
   422     }
 
   402 
   423 
   403 gint QTMSFactoryImpl::CreateSink(QTMSSinkType sinktype, QTMSSink*& qtmssink)
 
   424 gint QTMSFactoryImpl::CreateSink(QTMSSinkType sinktype, QTMSSink*& qtmssink)
 
   404     {
 
   425     {
 
   405     gint ret(QTMS_RESULT_SUCCESS);
 
   426     TRACE_PRN_FN_ENT;
 
       
   427     gint ret(QTMS_RESULT_UNINITIALIZED_OBJECT);
 
   406 
   428 
   407     TMS::TMSSink* tmssink(NULL);
 
   429     TMS::TMSSink* tmssink(NULL);
 
   408 
   430 
   409     if (iFactory)
 
   431     if (iFactory)
 
   410         {
 
   432         {
 
   422                     break;
 
   444                     break;
 
   423                 case QTMS_SINK_SPEAKER:
 
   445                 case QTMS_SINK_SPEAKER:
 
   424                     ret = QTMSSpeakerSinkImpl::Create(qtmssink, tmssink);
 
   446                     ret = QTMSSpeakerSinkImpl::Create(qtmssink, tmssink);
 
   425                     break;
 
   447                     break;
 
   426                 default:
 
   448                 default:
 
       
   449                     ret = TMS_RESULT_SINK_TYPE_NOT_SUPPORTED;
 
   427                     break;
 
   450                     break;
 
   428                 }
 
   451                 }
 
   429             }
 
   452             }
 
   430         }
 
   453         }
 
   431 
   454     TRACE_PRN_FN_EXT;
 
   432     return ret;
 
   455     return ret;
 
   433     }
 
   456     }
 
   434 
   457 
   435 gint QTMSFactoryImpl::DeleteSink(QTMSSink*& qtmssink)
 
   458 gint QTMSFactoryImpl::DeleteSink(QTMSSink*& qtmssink)
 
   436     {
 
   459     {
 
   437     gint ret(QTMS_RESULT_INVALID_ARGUMENT);
 
   460     TRACE_PRN_FN_ENT;
 
   438 
   461     __ASSERT_ALWAYS(qtmssink, PANIC(QTMS_RESULT_NULL_ARGUMENT));
 
       
   462 
       
   463     gint ret(QTMS_RESULT_SUCCESS);
 
   439     QTMSSinkType sinktype;
 
   464     QTMSSinkType sinktype;
 
   440     ret = qtmssink->GetType(sinktype);
 
   465     ret = qtmssink->GetType(sinktype);
 
   441     switch (sinktype)
 
   466     switch (sinktype)
 
   442         {
 
   467         {
 
   443         case QTMS_SINK_CLIENT:
 
   468         case QTMS_SINK_CLIENT:
 
   444             {
 
   469             {
 
   445             delete (static_cast<QTMSClientSinkImpl*>(qtmssink));
 
   470             delete (static_cast<QTMSClientSinkImpl*>(qtmssink));
 
   446             qtmssink = NULL;
 
   471             qtmssink = NULL;
 
   447             ret = QTMS_RESULT_SUCCESS;
 
       
   448             }
 
   472             }
 
   449             break;
 
   473             break;
 
   450         case QTMS_SINK_MODEM:
 
   474         case QTMS_SINK_MODEM:
 
   451             {
 
   475             {
 
   452             delete (static_cast<QTMSModemSinkImpl*>(qtmssink));
 
   476             delete (static_cast<QTMSModemSinkImpl*>(qtmssink));
 
   453             qtmssink = NULL;
 
   477             qtmssink = NULL;
 
   454             ret = QTMS_RESULT_SUCCESS;
 
       
   455             }
 
   478             }
 
   456             break;
 
   479             break;
 
   457         case QTMS_SINK_SPEAKER:
 
   480         case QTMS_SINK_SPEAKER:
 
   458             {
 
   481             {
 
   459             delete (static_cast<QTMSSpeakerSinkImpl*>(qtmssink));
 
   482             delete (static_cast<QTMSSpeakerSinkImpl*>(qtmssink));
 
   460             qtmssink = NULL;
 
   483             qtmssink = NULL;
 
   461             ret = QTMS_RESULT_SUCCESS;
 
       
   462             }
 
   484             }
 
   463             break;
 
   485             break;
 
   464         default:
 
   486         default:
 
   465             ret = QTMS_RESULT_SINK_TYPE_NOT_SUPPORTED;
 
   487             ret = QTMS_RESULT_SINK_TYPE_NOT_SUPPORTED;
 
   466             break;
 
   488             break;
 
   467         }
 
   489         }
 
   468 
   490     TRACE_PRN_FN_EXT;
 
   469     return ret;
 
   491     return ret;
 
   470     }
 
   492     }
 
   471 
   493 
   472 gint QTMSFactoryImpl::CreateGlobalRouting(QTMSGlobalRouting*& qrouting)
 
   494 gint QTMSFactoryImpl::CreateGlobalRouting(QTMSGlobalRouting*& qrouting)
 
   473     {
 
   495     {
 
   474     gint ret(QTMS_RESULT_SUCCESS);
 
   496     TRACE_PRN_FN_ENT;
 
       
   497     gint ret(QTMS_RESULT_UNINITIALIZED_OBJECT);
 
   475 
   498 
   476     TMS::TMSGlobalRouting* tmsrouting(NULL);
 
   499     TMS::TMSGlobalRouting* tmsrouting(NULL);
 
   477     if (iFactory)
 
   500     if (iFactory)
 
   478         {
 
   501         {
 
   479         ret = iFactory->CreateGlobalRouting(tmsrouting);
 
   502         ret = iFactory->CreateGlobalRouting(tmsrouting);
 
   481         if (ret == TMS_RESULT_SUCCESS)
 
   504         if (ret == TMS_RESULT_SUCCESS)
 
   482             {
 
   505             {
 
   483             ret = QTMSGlobalRoutingImpl::Create(qrouting, tmsrouting);
 
   506             ret = QTMSGlobalRoutingImpl::Create(qrouting, tmsrouting);
 
   484             }
 
   507             }
 
   485         }
 
   508         }
 
       
   509     TRACE_PRN_FN_EXT;
 
   486     return ret;
 
   510     return ret;
 
   487     }
 
   511     }
 
   488 
   512 
   489 gint QTMSFactoryImpl::DeleteGlobalRouting(QTMSGlobalRouting*& globalrouting)
 
   513 gint QTMSFactoryImpl::DeleteGlobalRouting(QTMSGlobalRouting*& globalrouting)
 
   490     {
 
   514     {
 
       
   515     TRACE_PRN_FN_ENT;
 
   491     gint ret(QTMS_RESULT_SUCCESS);
 
   516     gint ret(QTMS_RESULT_SUCCESS);
 
   492     delete (static_cast<QTMSGlobalRoutingImpl*>(globalrouting));
 
   517     delete (static_cast<QTMSGlobalRoutingImpl*>(globalrouting));
 
   493     globalrouting = NULL;
 
   518     globalrouting = NULL;
 
       
   519     TRACE_PRN_FN_EXT;
 
   494     return ret;
 
   520     return ret;
 
   495     }
 
   521     }
 
   496 
   522 
   497 gint QTMSFactoryImpl::CreateDTMF(QTMSStreamType streamtype, QTMSDTMF*& qdtmf)
 
   523 gint QTMSFactoryImpl::CreateDTMF(QTMSStreamType streamtype, QTMSDTMF*& qdtmf)
 
   498     {
 
   524     {
 
   499     gint ret(QTMS_RESULT_SUCCESS);
 
   525     TRACE_PRN_FN_ENT;
 
       
   526     gint ret(QTMS_RESULT_UNINITIALIZED_OBJECT);
 
   500 
   527 
   501     TMS::TMSDTMF* tmsdtmf = NULL;
 
   528     TMS::TMSDTMF* tmsdtmf = NULL;
 
   502 
   529 
   503     if (iFactory)
 
   530     if (iFactory)
 
   504         {
 
   531         {
 
   507         if (ret == TMS_RESULT_SUCCESS)
 
   534         if (ret == TMS_RESULT_SUCCESS)
 
   508             {
 
   535             {
 
   509             ret = QTMSDTMFImpl::Create(qdtmf, tmsdtmf);
 
   536             ret = QTMSDTMFImpl::Create(qdtmf, tmsdtmf);
 
   510             }
 
   537             }
 
   511         }
 
   538         }
 
       
   539     TRACE_PRN_FN_EXT;
 
   512     return ret;
 
   540     return ret;
 
   513     }
 
   541     }
 
   514 
   542 
   515 gint QTMSFactoryImpl::DeleteDTMF(QTMSDTMF*& dtmf)
 
   543 gint QTMSFactoryImpl::DeleteDTMF(QTMSDTMF*& dtmf)
 
   516     {
 
   544     {
 
       
   545     TRACE_PRN_FN_ENT;
 
   517     gint ret(QTMS_RESULT_SUCCESS);
 
   546     gint ret(QTMS_RESULT_SUCCESS);
 
   518     delete (static_cast<QTMSDTMFImpl*>(dtmf));
 
   547     delete (static_cast<QTMSDTMFImpl*>(dtmf));
 
   519     dtmf = NULL;
 
   548     dtmf = NULL;
 
       
   549     TRACE_PRN_FN_EXT;
 
   520     return ret;
 
   550     return ret;
 
   521     }
 
   551     }
 
   522 
   552 
   523 gint QTMSFactoryImpl::CreateRingTonePlayer(QTMSRingTone*& rt)
 
   553 gint QTMSFactoryImpl::CreateRingTonePlayer(QTMSRingTone*& rt)
 
   524     {
 
   554     {
 
   525     gint ret(QTMS_RESULT_SUCCESS);
 
   555     TRACE_PRN_FN_ENT;
 
       
   556     gint ret(QTMS_RESULT_UNINITIALIZED_OBJECT);
 
   526 
   557 
   527     TMS::TMSRingTone* tmsrt = NULL;
 
   558     TMS::TMSRingTone* tmsrt = NULL;
 
   528 
   559 
   529     if (iFactory)
 
   560     if (iFactory)
 
   530         {
 
   561         {
 
   533         if (ret == TMS_RESULT_SUCCESS)
 
   564         if (ret == TMS_RESULT_SUCCESS)
 
   534             {
 
   565             {
 
   535             ret = QTMSRingToneImpl::Create(rt, tmsrt);
 
   566             ret = QTMSRingToneImpl::Create(rt, tmsrt);
 
   536             }
 
   567             }
 
   537         }
 
   568         }
 
       
   569     TRACE_PRN_FN_EXT;
 
   538     return ret;
 
   570     return ret;
 
   539     }
 
   571     }
 
   540 
   572 
   541 gint QTMSFactoryImpl::DeleteRingTonePlayer(QTMSRingTone*& rt)
 
   573 gint QTMSFactoryImpl::DeleteRingTonePlayer(QTMSRingTone*& rt)
 
   542     {
 
   574     {
 
       
   575     TRACE_PRN_FN_ENT;
 
   543     gint ret(QTMS_RESULT_SUCCESS);
 
   576     gint ret(QTMS_RESULT_SUCCESS);
 
   544     delete (static_cast<QTMSRingToneImpl*>(rt));
 
   577     delete (static_cast<QTMSRingToneImpl*>(rt));
 
   545     rt = NULL;
 
   578     rt = NULL;
 
       
   579     TRACE_PRN_FN_EXT;
 
   546     return ret;
 
   580     return ret;
 
   547     }
 
   581     }
 
   548 
   582 
   549 gint QTMSFactoryImpl::CreateInbandTonePlayer(QTMSInbandTone*& qinbandtone)
 
   583 gint QTMSFactoryImpl::CreateInbandTonePlayer(QTMSInbandTone*& qinbandtone)
 
   550     {
 
   584     {
 
   551     gint ret(QTMS_RESULT_SUCCESS);
 
   585     TRACE_PRN_FN_ENT;
 
       
   586     gint ret(QTMS_RESULT_UNINITIALIZED_OBJECT);
 
   552 
   587 
   553     TMS::TMSInbandTone* tmsinband = NULL;
 
   588     TMS::TMSInbandTone* tmsinband = NULL;
 
   554     if (iFactory)
 
   589     if (iFactory)
 
   555         {
 
   590         {
 
   556         ret = iFactory->CreateInbandTonePlayer(tmsinband);
 
   591         ret = iFactory->CreateInbandTonePlayer(tmsinband);
 
   558         if (ret == TMS_RESULT_SUCCESS)
 
   593         if (ret == TMS_RESULT_SUCCESS)
 
   559             {
 
   594             {
 
   560             ret = QTMSInbandToneImpl::Create(qinbandtone, tmsinband);
 
   595             ret = QTMSInbandToneImpl::Create(qinbandtone, tmsinband);
 
   561             }
 
   596             }
 
   562         }
 
   597         }
 
       
   598     TRACE_PRN_FN_EXT;
 
   563     return ret;
 
   599     return ret;
 
   564     }
 
   600     }
 
   565 
   601 
   566 gint QTMSFactoryImpl::DeleteInbandTonePlayer(QTMSInbandTone*& inbandtone)
 
   602 gint QTMSFactoryImpl::DeleteInbandTonePlayer(QTMSInbandTone*& inbandtone)
 
   567     {
 
   603     {
 
       
   604     TRACE_PRN_FN_ENT;
 
   568     gint ret(QTMS_RESULT_SUCCESS);
 
   605     gint ret(QTMS_RESULT_SUCCESS);
 
   569     delete (static_cast<QTMSInbandToneImpl*>(inbandtone));
 
   606     delete (static_cast<QTMSInbandToneImpl*>(inbandtone));
 
   570     inbandtone = NULL;
 
   607     inbandtone = NULL;
 
       
   608     TRACE_PRN_FN_EXT;
 
   571     return ret;
 
   609     return ret;
 
   572     }
 
   610     }
 
   573 
   611 
   574 // End of file
 
   612 // End of file
FCL/sf/mw/mmappfw