1 /*

     2  * Copyright (c) 2010 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: QT Bindings for TMS

    15  *

    16  */

    17 

    18 #include <tms.h>

    19 #include <QObject>

    20 #include <qtmsfactory.h>

    21 #include "qtmswrapperexport.h"

    22 #include "qtmsfactoryimpl.h"

    23 

    24 using namespace QTMS;

    25 

    26 QTMSFactory::QTMSFactory()

    27     {

    28     impl = new QTMSFactoryImpl();

    29     }

    30 

    31 QTMSFactory::~QTMSFactory()

    32     {

    33     delete impl;

    34     }

    35 

    36 gint QTMSFactory::CreateFactory(QTMSFactory*& tmsfactory, QTMSVer& /*ver*/)

    37     {

    38     QTMSFactory* self = new QTMSFactory();

    39     tmsfactory = self;

    40     return QTMS_RESULT_SUCCESS;

    41     }

    42 

    43 gint QTMSFactory::CreateCall(QTMSCallType ctype, QTMSCall*& tmscall,

    44         guint ctxid)

    45     {

    46     gint status(TMS_RESULT_UNINITIALIZED_OBJECT);

    47     if (impl)

    48         {

    49         status = impl->CreateCall(ctype, tmscall, ctxid);

    50         }

    51     return status;

    52     }

    53 

    54 gint QTMSFactory::DeleteCall(QTMSCall*& tmscall)

    55     {

    56     gint status(TMS_RESULT_UNINITIALIZED_OBJECT);

    57     if (impl)

    58         {

    59         status = impl->DeleteCall(tmscall);

    60         }

    61     return status;

    62     }

    63 

    64 gint QTMSFactory::IsCallTypeSupported(QTMSCallType ctype, gboolean& flag)

    65     {

    66     gint status(TMS_RESULT_UNINITIALIZED_OBJECT);

    67     if (impl)

    68         {

    69         status = impl->IsCallTypeSupported(ctype, flag);

    70         }

    71     return status;

    72     }

    73 

    74 gint QTMSFactory::GetSupportedFormats(const QTMSStreamType strmtype,

    75         FormatVector& fmtlist)

    76     {

    77     gint status(TMS_RESULT_UNINITIALIZED_OBJECT);

    78     if (impl)

    79         {

    80         status = impl->GetSupportedFormats(strmtype, fmtlist);

    81         }

    82     return status;

    83     }

    84 

    85 gint QTMSFactory::CreateFormat(QTMSFormatType qfmttype, QTMSFormat*& qfmt)

    86     {

    87     gint status(TMS_RESULT_UNINITIALIZED_OBJECT);

    88     if (impl)

    89         {

    90         status = impl->CreateFormat(qfmttype, qfmt);

    91         }

    92     return status;

    93 

    94     }

    95 

    96 gint QTMSFactory::DeleteFormat(QTMSFormat*& qfmt)

    97     {

    98     gint status(TMS_RESULT_UNINITIALIZED_OBJECT);

    99     if (impl)

   100         {

   101         status = impl->DeleteFormat(qfmt);

   102         }

   103     return status;

   104     }

   105 

   106 gint QTMSFactory::CreateEffect(QTMSEffectType tmseffecttype,

   107         QTMSEffect*& tmseffect)

   108     {

   109     gint status(TMS_RESULT_UNINITIALIZED_OBJECT);

   110     if (impl)

   111         {

   112         status = impl->CreateEffect(tmseffecttype, tmseffect);

   113         }

   114     return status;

   115     }

   116 

   117 gint QTMSFactory::DeleteEffect(QTMSEffect*& qtmseffect)

   118     {

   119     gint status(TMS_RESULT_UNINITIALIZED_OBJECT);

   120     if (impl)

   121         {

   122         impl->DeleteEffect(qtmseffect);

   123         }

   124     return status;

   125     }

   126 

   127 gint QTMSFactory::CreateBuffer(QTMSBufferType buffertype, guint size,

   128         QTMSBuffer*& qbuffer)

   129     {

   130     gint status(TMS_RESULT_UNINITIALIZED_OBJECT);

   131     if (impl)

   132         {

   133         status = impl->CreateBuffer(buffertype, size, qbuffer);

   134         }

   135     return status;

   136     }

   137 

   138 gint QTMSFactory::DeleteBuffer(QTMSBuffer*& qbuffer)

   139     {

   140     gint status(TMS_RESULT_UNINITIALIZED_OBJECT);

   141     if (impl)

   142         {

   143         status = impl->DeleteBuffer(qbuffer);

   144         }

   145     return status;

   146     }

   147 

   148 gint QTMSFactory::CreateSource(QTMSSourceType srctype, QTMSSource*& qtmssrc)

   149     {

   150     gint status(TMS_RESULT_UNINITIALIZED_OBJECT);

   151     if (impl)

   152         {

   153         status = impl->CreateSource(srctype, qtmssrc);

   154         }

   155     return status;

   156     }

   157 

   158 gint QTMSFactory::DeleteSource(QTMSSource*& qtmssrc)

   159     {

   160     gint status(TMS_RESULT_UNINITIALIZED_OBJECT);

   161     if (impl)

   162         {

   163         status = impl->DeleteSource(qtmssrc);

   164         }

   165     return status;

   166     }

   167 

   168 gint QTMSFactory::CreateSink(QTMSSinkType sinktype, QTMSSink*& qtmssink)

   169     {

   170     gint status(TMS_RESULT_UNINITIALIZED_OBJECT);

   171     if (impl)

   172         {

   173         status = impl->CreateSink(sinktype, qtmssink);

   174         }

   175     return status;

   176     }

   177 

   178 gint QTMSFactory::DeleteSink(QTMSSink*& qtmssink)

   179     {

   180     gint status(TMS_RESULT_UNINITIALIZED_OBJECT);

   181     if (impl)

   182         {

   183         status = impl->DeleteSink(qtmssink);

   184         }

   185     return status;

   186     }

   187 

   188 gint QTMSFactory::CreateGlobalRouting(QTMSGlobalRouting*& globalrouting)

   189     {

   190     gint status(TMS_RESULT_UNINITIALIZED_OBJECT);

   191     if (impl)

   192         {

   193         status = impl->CreateGlobalRouting(globalrouting);

   194         }

   195     return status;

   196     }

   197 

   198 gint QTMSFactory::DeleteGlobalRouting(QTMSGlobalRouting*& globrouting)

   199     {

   200     gint status(TMS_RESULT_UNINITIALIZED_OBJECT);

   201     if (impl)

   202         {

   203         status = impl->DeleteGlobalRouting(globrouting);

   204         }

   205     return status;

   206     }

   207 

   208 gint QTMSFactory::CreateDTMF(QTMSStreamType streamtype, QTMSDTMF*& dtmf)

   209     {

   210     gint status(TMS_RESULT_UNINITIALIZED_OBJECT);

   211     if (impl)

   212         {

   213         status = impl->CreateDTMF(streamtype, dtmf);

   214         }

   215     return status;

   216     }

   217 

   218 gint QTMSFactory::DeleteDTMF(QTMSDTMF*& dtmf)

   219     {

   220     gint status(TMS_RESULT_UNINITIALIZED_OBJECT);

   221     if (impl)

   222         {

   223         status = impl->DeleteDTMF(dtmf);

   224         }

   225     return status;

   226     }

   227 

   228 gint QTMSFactory::CreateRingTonePlayer(QTMSRingTone*& rt)

   229     {

   230     gint status(TMS_RESULT_UNINITIALIZED_OBJECT);

   231     if (impl)

   232         {

   233         status = impl->CreateRingTonePlayer(rt);

   234         }

   235     return status;

   236     }

   237 

   238 gint QTMSFactory::DeleteRingTonePlayer(QTMSRingTone*& rt)

   239     {

   240     gint status(TMS_RESULT_UNINITIALIZED_OBJECT);

   241     if (impl)

   242         {

   243         status = impl->DeleteRingTonePlayer(rt);

   244         }

   245     return status;

   246     }

   247 

   248 gint QTMSFactory::CreateInbandTonePlayer(QTMSInbandTone*& inbandtone)

   249     {

   250     gint status(TMS_RESULT_UNINITIALIZED_OBJECT);

   251     if (impl)

   252         {

   253         status = impl->CreateInbandTonePlayer(inbandtone);

   254         }

   255     return status;

   256     }

   257 

   258 gint QTMSFactory::DeleteInbandTonePlayer(QTMSInbandTone*& inbandtone)

   259     {

   260     gint status(TMS_RESULT_UNINITIALIZED_OBJECT);

   261     if (impl)

   262         {

   263         status = impl->DeleteInbandTonePlayer(inbandtone);

   264         }

   265     return status;

   266     }