1 /*

     2 * Copyright (c) 2006 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:          

    15 *

    16 */

    17 

    18 

    19 

    20 

    21 

    22 

    23 

    24 

    25 

    26 

    27 

    28 // INCLUDE FILES

    29 #include <s32strm.h>

    30 #include "senmessagebase.h"

    31 #include <MSenProperties.h>

    32 #include <SenHttpTransportProperties.h>

    33 #include "senvtcptransportproperties.h"

    34 //#include "SenLayeredHttpTransportProperties.h"

    35 //#include "SenLayeredVtcpTransportProperties.h"

    36 

    37 #include "senchunk.h"

    38 

    39 #include "sendebug.h"

    40 #include "senlogger.h"

    41 //#include <SenXmlReader.h>

    42 

    43 #include "msenmessagecontext.h"

    44 #include "senmessagecontext.h"

    45 #include "senlayeredtransportproperties.h" // private

    46 

    47 #include <SenServiceConnection.h>

    48 

    49 EXPORT_C CSenMessageBase* CSenMessageBase::NewL(CSenChunk& aChunk)

    50     {

    51     CSenMessageBase* pNew = CSenMessageBase::NewLC(aChunk);

    52     CleanupStack::Pop(pNew);

    53     return pNew;

    54     }

    55 

    56 EXPORT_C CSenMessageBase* CSenMessageBase::NewLC(CSenChunk& aChunk)

    57     {

    58     CSenMessageBase* pNew = new (ELeave) CSenMessageBase(aChunk);

    59     CleanupStack::PushL(pNew);

    60     pNew->BaseConstructL();

    61     return pNew;

    62     }

    63 

    64 

    65 EXPORT_C void CSenMessageBase::BaseConstructL()

    66     {

    67     TLSLOG_L( KSenMessagesLogChannel, KMinLogLevel, "CSenMessageBase::BaseConstructL" );

    68     MSenProperties::TSenPropertiesClassType type = iChunk.ChunkHeader().PropertiesType();

    69     TLSLOG_FORMAT(( KSenMessagesLogChannel, KNormalLogLevel, 

    70                     _L("- Message type: (%d)"), type ));

    71     

    72     TInt error = iChunk.DescFromChunk( iSerializedMessage, 0 );

    73 #ifdef _SENDEBUG

    74     if( error )

    75         {

    76         TLSLOG_FORMAT(( KSenMessagesLogChannel, KMinLogLevel, 

    77                         _L("- Fatal(!): cannot find message (descriptor) from chunk, error: (%d)"), error ));

    78         }

    79 #endif // _SENDEBUG        

    80     User::LeaveIfError ( error );

    81     

    82     if( type != MSenProperties::ENotInUse )

    83         {

    84         //User::LeaveIfError( iChunk.DescsFromChunk(iSerializedMessage, iSerializedProperties) );

    85         error = iChunk.DescFromChunk( iSerializedProperties, 1 );

    86 #ifdef _SENDEBUG        

    87         if ( error )

    88             {

    89             TLSLOG_FORMAT(( KSenMessagesLogChannel, KMinLogLevel, 

    90                 _L("CSenMessageBase::BaseConstructL, MAJOR: properties type != MSenProperties::ENotInUse, but desc not in chunk, error: (%d)"), error ));

    91             }

    92 #endif // _SENDEBUG

    93         }

    94     

    95     switch( type )

    96         {

    97         case MSenProperties::ENotInUse:

    98             {

    99             

   100             break;

   101             }

   102         case MSenProperties::ESenXmlProperties:

   103         case MSenProperties::ESenLayeredXmlProperties: // flatten the props

   104             {

   105             ipProperties = CSenXmlProperties::NewL(); // iSerializedMessage, *pReader);

   106             break;

   107             }

   108         case MSenProperties::ESenTransportProperties:

   109         case MSenProperties::ESenLayeredTransportProperties: // flatten the props

   110             {

   111             ipProperties = CSenTransportProperties::NewL();

   112             break;

   113             }

   114         case MSenProperties::ESenHttpTransportProperties:

   115         case MSenProperties::ESenLayeredHttpTransportProperties: // flatten the props

   116             {

   117             ipProperties = CSenHttpTransportProperties::NewL();

   118             break;

   119             }

   120         case MSenProperties::ESenVtcpTransportProperties:

   121         case MSenProperties::ESenLayeredVtcpTransportProperties: // flatten the props

   122             {

   123             ipProperties = CSenVtcpTransportProperties::NewL();

   124             break;

   125             }

   126             /*

   127         case MSenProperties::ESenLayeredXmlProperties:

   128             {

   129             ipProperties = CSenLayeredXmlProperties::NewL(iSerializedMessage, *pReader);

   130             break;

   131             }

   132         case MSenProperties::ESenLayeredTransportProperties:

   133             {

   134             ipProperties = CSenLayeredTransportProperties::NewL(iSerializedMessage, *pReader);

   135             break;

   136             }

   137         case MSenProperties::ESenLayeredHttpTransportProperties:

   138             {

   139             ipProperties = CSenLayeredHttpTransportProperties::NewL(iSerializedMessage, *pReader);

   140             break;

   141             }

   142         case MSenProperties::ESenLayeredVtcpTransportProperties:

   143             {

   144             ipProperties = CSenLayeredVtcpTransportProperties::NewL(iSerializedMessage, *pReader);

   145             break;

   146             }

   147             */

   148         default: 

   149             {

   150             break;

   151             }

   152         }

   153         

   154     if ( ipProperties && iSerializedProperties.Length() > 0 )

   155         {

   156         ipProperties->ReadFromL( iSerializedProperties );

   157         }

   158     }

   159 

   160 EXPORT_C CSenMessageBase::CSenMessageBase(CSenChunk& aChunk)

   161 :   iChunk( aChunk ),

   162     ipProperties( NULL ),

   163     iTxnId( KErrNotFound ),

   164     iSerializedMessage( KNullDesC8 ),

   165     iSerializedProperties( KNullDesC8 )

   166     {

   167     }

   168 

   169 EXPORT_C CSenMessageBase::~CSenMessageBase()

   170     {

   171     if( ipProperties )

   172         {

   173         if( ipProperties->IsSafeToCast( MSenProperties::ESenXmlProperties) )

   174             {

   175             CSenXmlProperties* pFlatProps = (CSenXmlProperties*)ipProperties;

   176             delete pFlatProps;

   177             }

   178         else if( ipProperties->IsSafeToCast( MSenProperties::ESenLayeredXmlProperties) )

   179             {

   180             CSenLayeredXmlProperties* pLayeredProps = (CSenLayeredXmlProperties*)ipProperties;

   181             delete pLayeredProps;

   182             }

   183 #ifdef _SENDEBUG            

   184         else 

   185             { 

   186             // TLS log as fatal(!) 

   187             TLSLOG_L( KSenMessagesLogChannel, KMinLogLevel, 

   188                 "CSenMessageBase::~CSenMessageBase():" );            

   189             TLSLOG_L( KSenMessagesLogChannel, KMinLogLevel, 

   190                 "- Fatal(!): ipProperties != NULL, but cannot be cast to XML properties(!)" );            

   191             }

   192 #endif // _SENDEBUG            

   193         }

   194     }

   195 

   196 

   197 MSenMessage::TClass CSenMessageBase::Type()

   198     {

   199     return iChunk.ChunkHeader().MessageType();

   200     }

   201     

   202 MSenMessage::TDirection CSenMessageBase::Direction()

   203     {

   204     return iChunk.ChunkHeader().MessageDirection();

   205     }

   206 

   207 MSenMessageContext* CSenMessageBase::Context() 

   208     {

   209     return ipContext; 

   210     }

   211 

   212 MSenProperties* CSenMessageBase::Properties()

   213     {

   214     return ipProperties;    

   215     }

   216     

   217 TInt CSenMessageBase::SetContext(MSenMessageContext* apNotOwnedContext)

   218     {

   219     if( !apNotOwnedContext )

   220         {

   221         return KErrArgument;

   222         }

   223     // ipContext is NOT owned(!)

   224     delete ipProperties;

   225     ipProperties = NULL;

   226     ipContext = apNotOwnedContext;

   227     return KErrNone;

   228     }

   229     

   230 TInt CSenMessageBase::SetProperties(MSenProperties* apOwnedProperties)

   231     {

   232     if( !apOwnedProperties )

   233         {

   234         return KErrArgument;

   235         }

   236     delete ipProperties;

   237     ipProperties = apOwnedProperties;

   238     return KErrNone;

   239     }

   240     

   241     

   242 TBool CSenMessageBase::IsSafeToCast(TClass aType)

   243     {

   244     if ( aType == MSenMessage::EMessageBase )

   245         {

   246         return ETrue;

   247         }

   248     else

   249         {

   250         return EFalse;

   251         }        

   252     }

   253     

   254 TInt CSenMessageBase::TxnId()

   255     {

   256     return iChunk.ChunkHeader().TransactionId();

   257     }

   258 

   259 MSenMessage* CSenMessageBase::CloneL()

   260     {

   261     return NULL;

   262     }

   263 

   264 // End of File