1 /*

     2 * Copyright (c) 2008 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 #include "wsovitokencreationresponse.h"

    26 #include "wsovicons.h"

    27 #include "sendebug.h"

    28 #include "senlogger.h"

    29 

    30 using namespace WSOviResponse;

    31 CWSOviTokenCreationResponse* CWSOviTokenCreationResponse::NewL()

    32     {

    33     CWSOviTokenCreationResponse* self = NewLC();

    34     CleanupStack::Pop(self);

    35     return self;

    36     }

    37 

    38 CWSOviTokenCreationResponse* CWSOviTokenCreationResponse::NewLC()

    39     {

    40     CWSOviTokenCreationResponse* self = new (ELeave) CWSOviTokenCreationResponse();

    41     CleanupStack::PushL (self);

    42     self->ConstructL();

    43     return self;

    44     }

    45 // Second phase construction.

    46 void CWSOviTokenCreationResponse::ConstructL()

    47     {

    48         CSenBaseFragment::BaseConstructL(TPtrC8(NULL,0),

    49         		KTokenCreationResponseLocalName);

    50     }

    51 

    52 void CWSOviTokenCreationResponse::StartElementL(const TDesC8& /*aNsUri*/,

    53                                const TDesC8& aLocalName,

    54                                const TDesC8& /*aQName*/,

    55                                const RAttributeArray& /*aAttributes*/)

    56     {

    57     switch (iState)

    58         {

    59         case KStateIgnore:

    60             {

    61             if (aLocalName == KTokenInfoLocalName)

    62             	{

    63             	iState = KStateParsingTokenInfo;

    64             	}

    65             else if (aLocalName == KTokenCreationResponseLocalName)

    66                 {

    67                 iIsTokenUpdate = EFalse;

    68                 }

    69             else if (aLocalName == KUserInfoLocalName)

    70                 {

    71                 iState = KStateParsingUserInfo;

    72                 }

    73                 break;

    74             }

    75         case KStateParsingTokenInfo:

    76         	{

    77         	if (aLocalName == KTokenSecretLocalName)

    78         		{

    79         		iState = KStateSave;

    80         		}

    81             else if (aLocalName == KTokenLocalName)

    82                 {

    83                 iState = KStateSave;

    84                 }

    85         	else if (aLocalName == KTTLLocalName)

    86         		{

    87         		iState = KStateSave;

    88         		}

    89         	break;

    90         	}

    91         case KStateParsingUserInfo:

    92             {

    93             if (aLocalName == KUserNameLocalName)

    94                 {

    95                 iState = KStateSave;

    96                 }

    97             break;

    98             }

    99         default:

   100             break;

   101         }

   102     }                       

   103     

   104 void CWSOviTokenCreationResponse::EndElementL(const TDesC8& /*aNsUri*/,

   105                              const TDesC8& aLocalName,

   106                              const TDesC8& /*aQName*/)

   107     {

   108     TPtrC8 content = Content();

   109     switch (iState)

   110         {

   111         case KStateSave:

   112             {

   113         	if (aLocalName == KTokenLocalName)

   114                 {

   115                 if (iToken)

   116                 	{

   117                 	delete iToken;

   118                 	iToken = NULL;

   119                 	}

   120                 TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,"WSOviTokenCreationResponse::token parsing");

   121                 TLSLOG_ALL(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel, content);

   122                 	

   123                 iToken = HBufC8::NewL(content.Length()+KTokenTag().Length()+KTokenTagEnd().Length());

   124                 iToken->Des().Append(KTokenTag);

   125                 iToken->Des().Append(content);

   126                 iToken->Des().Append(KTokenTagEnd);

   127                 ResetContentL();

   128                 iState = KStateParsingTokenInfo;

   129                 }

   130             if (aLocalName == KTokenSecretLocalName)

   131                 {

   132                 if (iTokenSecret)

   133                     {

   134                     delete iTokenSecret;

   135                     iTokenSecret = NULL;

   136                     }

   137                 TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,"WSOviTokenCreationResponse::tokenSecret parsing");

   138                 TLSLOG_ALL(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel, content);

   139                     

   140                 iTokenSecret = content.AllocL();

   141                 ResetContentL();

   142                 iState = KStateParsingTokenInfo;

   143                 }

   144             else if (aLocalName == KTTLLocalName)

   145                 {

   146                 if (iTTL)

   147                 	{

   148                 	delete iTTL;

   149                 	iTTL = NULL;

   150                 	}

   151                 TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,"WSOviTokenCreationResponse::ttl parsing");

   152                 TLSLOG(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel, content);

   153                 iTTL = content.AllocL();

   154                 ResetContentL();

   155                 iState = KStateParsingTokenInfo;

   156                 }

   157             else if ( aLocalName == KUserNameLocalName)

   158                 {

   159                 if (iUsername)

   160                     {

   161                     delete iUsername;

   162                     iUsername = NULL;

   163                     }

   164                 TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,"WSOviTokenCreationResponse::username parsing");

   165                 TLSLOG(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel, content);

   166                 iUsername = content.AllocL();

   167                 ResetContentL();

   168                 iState = KStateParsingUserInfo;

   169                 }

   170             break;

   171             }

   172         case KStateParsingTokenInfo:

   173         	{

   174         	if (aLocalName == KTokenInfoLocalName)

   175         		{

   176             	iState = KStateIgnore;

   177         		}

   178         	break;

   179         	}

   180         case KStateParsingUserInfo:

   181             {

   182             if (aLocalName == KUserInfoLocalName)

   183                 {

   184                 iState = KStateIgnore;

   185                 }

   186             break;

   187             }

   188         default:

   189             break;

   190         }

   191     }

   192 

   193 

   194 CWSOviTokenCreationResponse::CWSOviTokenCreationResponse():

   195 iIsTokenUpdate(ETrue)

   196 	{

   197 	}

   198 

   199 CWSOviTokenCreationResponse::~CWSOviTokenCreationResponse()

   200 	{

   201 	delete iToken;

   202 	delete iTokenSecret;

   203 	delete iTTL;

   204 	delete iUsername;

   205 	}

   206 

   207 TPtrC8 CWSOviTokenCreationResponse::Token()

   208     {

   209     if (iToken)

   210         {

   211         return *iToken;    

   212         }

   213     else 

   214         {

   215         return KNullDesC8();

   216         }

   217     }

   218 

   219 TPtrC8 CWSOviTokenCreationResponse::TokenSecret()

   220     {

   221     if (iTokenSecret)

   222         {

   223         return *iTokenSecret;    

   224         }

   225     else 

   226         {

   227         return KNullDesC8();

   228         }

   229     }

   230 

   231 TPtrC8 CWSOviTokenCreationResponse::TTL()

   232     {

   233     if (iTTL)

   234         {

   235         return *iTTL;    

   236         }

   237     else 

   238         {

   239         return KNullDesC8();

   240         }

   241     }

   242 

   243 TPtrC8 CWSOviTokenCreationResponse::Username()

   244     {

   245     if (iUsername)

   246         {

   247         return *iUsername;    

   248         }

   249     else 

   250         {

   251         return KNullDesC8();

   252         }

   253     }

   254 

   255 TBool CWSOviTokenCreationResponse::IsTokenUpdate()

   256     {

   257     return iIsTokenUpdate;

   258     }