1 // Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

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

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    15 

    16 /**

    17  @file

    18  @internalComponent

    19 */

    20 

    21 #include "cmtpplaybackparam.h"

    22 #include "mtpplaybackcontrolpanic.h"

    23 

    24 

    25 /*********************************************

    26     class TMTPPbDataSuid

    27 **********************************************/

    28 TMTPPbCategory TMTPPbDataSuid::Category() const

    29     {

    30     return iPlayCategory;

    31     }

    32 

    33 const TDesC& TMTPPbDataSuid::Suid() const

    34     {

    35     return iSuid;

    36     }

    37 

    38 TMTPPbDataSuid::TMTPPbDataSuid(TMTPPbCategory aCategory, const TDesC& aSuid):

    39     iPlayCategory(aCategory),

    40     iSuid(aSuid)

    41     {

    42     

    43     }

    44 

    45 /*********************************************

    46     class CMTPPbParamBase

    47 **********************************************/

    48 

    49 CMTPPbParamBase::~CMTPPbParamBase()

    50     {

    51     delete iData;

    52     }

    53 

    54 CMTPPbParamBase::CMTPPbParamBase():

    55     iParamType(EMTPPbTypeNone)

    56     {

    57 

    58     }

    59 

    60 CMTPPbParamBase::CMTPPbParamBase(TMTPPbCategory /*aCategory*/, const TDesC& /*aSuid*/):

    61     iParamType(EMTPPbSuidSet)

    62     {

    63 

    64     }

    65 

    66 CMTPPbParamBase::CMTPPbParamBase(TInt32 /*aValue*/):

    67     iParamType(EMTPPbInt32)

    68     {

    69     

    70     }

    71 

    72 CMTPPbParamBase::CMTPPbParamBase(TUint32 /*aValue*/):

    73     iParamType(EMTPPbUint32)

    74     {

    75     

    76     }

    77 

    78 void CMTPPbParamBase::ConstructL(TMTPPbCategory aCategory, const TDesC& aSuid)

    79     {

    80     TMTPPbDataSuid* val = new (ELeave) TMTPPbDataSuid(aCategory, aSuid);

    81     iData = static_cast<TAny*>(val);

    82     }

    83 

    84 void CMTPPbParamBase::ConstructL(TInt32 aValue)

    85     {

    86     TInt32* val = new (ELeave) TInt32();

    87     *val = aValue;

    88     iData = static_cast<TAny*>(val);

    89     }

    90 

    91 void CMTPPbParamBase::ConstructL(TUint32 aValue)

    92     {

    93     TUint32* val = new (ELeave) TUint32();

    94     *val = aValue;

    95     iData = static_cast<TAny*>(val);

    96     }

    97 

    98 void CMTPPbParamBase::ConstructL(const CMTPPbParamBase& aParam)

    99     {

   100     TMTPPbDataType type(aParam.Type());

   101     __ASSERT_DEBUG((type > EMTPPbTypeNone && type < EMTPPbTypeEnd), Panic(EMTPPBArgumentErr));

   102     __ASSERT_ALWAYS((type > EMTPPbTypeNone && type < EMTPPbTypeEnd), User::Leave(KErrArgument));

   103     

   104     switch(type)

   105         {

   106         case EMTPPbSuidSet:

   107             {

   108             ConstructL(aParam.SuidSetL().Category(), aParam.SuidSetL().Suid());

   109             }

   110             break;

   111         case EMTPPbInt32:

   112             {

   113             ConstructL(aParam.Int32L());

   114             }

   115             break;

   116         case EMTPPbUint32:

   117             {

   118             ConstructL(aParam.Uint32L());

   119             }

   120             break;

   121         default:

   122             User::Leave(KErrArgument);

   123             break;

   124         }

   125 

   126     iParamType = type;

   127     }

   128 

   129 TMTPPbDataType CMTPPbParamBase::Type() const

   130     {

   131     __ASSERT_DEBUG((iParamType > EMTPPbTypeNone && iParamType < EMTPPbTypeEnd), 

   132                     Panic(EMTPPBDataTypeErr));

   133     return iParamType;

   134     }

   135 

   136 void CMTPPbParamBase::SetType(TMTPPbDataType aType)

   137     {

   138     __ASSERT_DEBUG((iParamType == EMTPPbTypeNone), Panic(EMTPPBDataTypeErr));

   139     __ASSERT_DEBUG((aType > EMTPPbTypeNone && aType < EMTPPbTypeEnd), Panic(EMTPPBDataTypeErr));

   140     iParamType = aType;

   141     }

   142 

   143 TAny* CMTPPbParamBase::GetData() const

   144     {

   145     __ASSERT_DEBUG((iData != NULL), Panic(EMTPPBDataNullErr));

   146     return iData;

   147     }

   148 

   149 void CMTPPbParamBase::SetData(TAny* aData)

   150     {

   151     __ASSERT_DEBUG((aData != NULL), Panic(EMTPPBDataNullErr));

   152     iData = aData;

   153     }

   154 

   155 const TMTPPbDataSuid& CMTPPbParamBase::SuidSetL() const

   156     {

   157     __ASSERT_DEBUG((iParamType == EMTPPbSuidSet), Panic(EMTPPBDataTypeErr));

   158     __ASSERT_ALWAYS((iParamType == EMTPPbSuidSet), User::Leave(KErrArgument));

   159 

   160     return *static_cast<TMTPPbDataSuid*>(iData);

   161     }

   162 

   163 TInt32 CMTPPbParamBase::Int32L() const

   164     {

   165     __ASSERT_DEBUG((iParamType == EMTPPbInt32), Panic(EMTPPBDataTypeErr));

   166     __ASSERT_ALWAYS((iParamType == EMTPPbInt32), User::Leave(KErrArgument));

   167 

   168     return *static_cast<TInt32*>(iData);

   169     }

   170 

   171 TUint32 CMTPPbParamBase::Uint32L() const

   172     {

   173     __ASSERT_DEBUG((iParamType == EMTPPbUint32), Panic(EMTPPBDataTypeErr));

   174     __ASSERT_ALWAYS((iParamType == EMTPPbUint32), User::Leave(KErrArgument));

   175 

   176     return *static_cast<TUint32*>(iData);

   177     }