1 /*

     2 * Copyright (c) 2005-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:  Mini web browser for downloading settings files

    15 *

    16 */

    17 

    18 

    19 // INCLUDE FILES

    20 #include <in_sock.h>

    21 #include <uri8.h>

    22 #include <http.h>

    23 #include <CWPEngine.h>

    24 #include <commdbconnpref.h>

    25 #include <etelmm.h>

    26 #include <basched.h>            // For KLeaveExit

    27 #include <AknGlobalNote.h> 

    28 #include <avkon.rsg>            // For R_AVKON_SOFTKEYS_CLOSE

    29 

    30 #include "MiniBrowser.h"

    31 #include "OnlineSupportLogger.h"

    32 #include "NHeadWrapperParser.h"

    33 #include "SupportedContentTypes.h"

    34 #include "VersionStrings.h"

    35 

    36 // 50 secs time-out

    37 const TInt KTimeOut( 50000000 );

    38 const TInt KInitialDataBufferSize( 2048 );

    39 const TInt KInitialReportUrlBufferSize( 512 );

    40 // maximum length of the info message (currently not supported)

    41 //const TInt KMaxMessageLength(256);

    42 //_LIT( KMiniBrowserPanic, "CMiniBrowser" );

    43 _LIT8( KHttpProtString, "HTTP/TCP" );

    44 _LIT8( KNokiaHeadWrapper, "application/vnd.nokia.headwrapper" );

    45 

    46 _LIT( KAmpersand, "&" );

    47 _LIT( KQuestionMark, "?" );

    48 _LIT( KStatus, "Status=" );

    49 

    50 CMiniBrowser* CMiniBrowser::NewLC(

    51     MMiniBrowserObserver& aObserver,

    52     RSocketServ& aSockerServ,

    53     RConnection& aConnection )

    54     {

    55     CMiniBrowser* self = new (ELeave) CMiniBrowser( aObserver );

    56     CleanupStack::PushL( self );

    57     self->ConstructL( aSockerServ, aConnection );

    58     return self;

    59     }

    60 

    61 CMiniBrowser* CMiniBrowser::NewL(

    62     MMiniBrowserObserver& aObserver,

    63     RSocketServ& aSockerServ,

    64     RConnection& aConnection )

    65     {

    66     CMiniBrowser* self = NewLC( aObserver, aSockerServ, aConnection );

    67     CleanupStack::Pop( self );

    68     return self;

    69     }

    70 

    71 CMiniBrowser::~CMiniBrowser()

    72     {

    73     LOGSTRING( "CMiniBrowser::~CMiniBrowser" );

    74     if( iPeriodic->IsActive() )

    75         {

    76         iPeriodic->Cancel();

    77         }

    78 

    79     delete iUri;

    80     delete iPeriodic;

    81     delete iResponseData;

    82     delete iReportUrl;

    83     iTransaction.Close();

    84     iSession.Close();

    85 

    86     LOGSTRING( "CMiniBrowser::~CMiniBrowser - done" );

    87     }

    88 

    89 CMiniBrowser::CMiniBrowser( MMiniBrowserObserver& aObserver ) :

    90     iObserver( aObserver ),

    91     iContentType( EContentTypeUnknown ),

    92     iProvisioningStatus( THttpProvStates::EStatusUnknown )

    93     {

    94     }

    95 

    96 void CMiniBrowser::ConstructL( RSocketServ& aSockerServ, RConnection& aConnection )

    97     {

    98     LOGSTRING( "CMiniBrowser::ConstructL" );

    99 

   100     iUri = HBufC8::NewL(1);

   101     iPeriodic = CPeriodic::NewL( CActive::EPriorityStandard );

   102     iResponseData = HBufC8::NewL( KInitialDataBufferSize );

   103     iReportUrl = HBufC8::NewL( KInitialReportUrlBufferSize );

   104 

   105     // Opens session using protocol HTTP/TCP

   106     LOGSTRING( "CMiniBrowser: iSession.OpenL" );

   107     iSession.OpenL( KHttpProtString );

   108     LOGSTRING( "CMiniBrowser: iSession.OpenL - done" );

   109     iSessionStringPool = iSession.StringPool();

   110 

   111     RHTTPConnectionInfo connectionInfo = iSession.ConnectionInfo();

   112 

   113     // Set SocketServ and Connection explicitly as we do not want to show

   114     // the AP selection list to the user when making submit for the request

   115     connectionInfo.SetPropertyL(

   116         iSessionStringPool.StringF( HTTP::EHttpSocketServ,

   117         RHTTPSession::GetTable() ),

   118         aSockerServ.Handle() );

   119     connectionInfo.SetPropertyL(

   120         iSessionStringPool.StringF( HTTP::EHttpSocketConnection,

   121         RHTTPSession::GetTable() ),

   122         reinterpret_cast< TInt > ( &aConnection ) );

   123     LOGSTRING( "CMiniBrowser::ConstructL - done" );

   124     }

   125 

   126 void CMiniBrowser::HttpGetL( const TDesC& aUri )

   127     {

   128     DoHttpGetL( aUri, EFalse, KNullDesC, 0 );

   129     }

   130 

   131 void CMiniBrowser::HttpGetL( const TDesC& aUri, const TDesC& aProxyAddress,

   132     const TUint aProxyPort )

   133     {

   134     DoHttpGetL( aUri, ETrue, aProxyAddress, aProxyPort );

   135     }

   136 

   137 void CMiniBrowser::DoHttpGetL(

   138     const TDesC& aUri,

   139     const TBool aUseProxy,

   140     const TDesC& aProxyAddress,

   141     const TUint aProxyPort )

   142     {

   143     LOGSTRING( "CMiniBrowser::DoHttpGetL" );

   144 

   145     ResetResponseDataL();

   146 

   147     delete iUri;

   148     iUri = 0;

   149     iUri = HBufC8::NewL( aUri.Length() );

   150     iUri->Des().Copy( aUri );

   151 

   152     TUriParser8 uriParser;

   153 

   154     // In case URL is not valid the transaction will fail with code KErrHttpInvalidUri

   155     // uriParser does not leave in all invalid uri cases

   156 #ifdef _DEBUG

   157     LOGSTRING( "CMiniBrowser::HttpGetL uri:" );

   158     //LOGTEXT( aUri );

   159     for( TInt i(0); i < aUri.Length(); i += 128 )

   160         {

   161         LOGTEXT( aUri.Right( aUri.Length() - i ) );

   162         }

   163 #endif

   164     User::LeaveIfError( uriParser.Parse( *iUri ) );

   165 

   166     RHTTPConnectionInfo connectionInfo = iSession.ConnectionInfo();

   167 

   168     // The default value is HTTP::EDoNotUseProxy

   169     if( aUseProxy )

   170         {

   171         LOGSTRING("CMiniBrowser: using proxy");

   172         connectionInfo.SetPropertyL(

   173             iSessionStringPool.StringF( HTTP::EProxyUsage, RHTTPSession::GetTable() ),

   174             iSessionStringPool.StringF( HTTP::EUseProxy, RHTTPSession::GetTable() ) );

   175 

   176         LOGSTRING("Set Proxy address")

   177         HBufC8* proxy = HBufC8::NewLC( aProxyAddress.Length() + 1 + 16 );

   178         TPtr8 proxyPtr = proxy->Des();

   179         proxyPtr.Copy( aProxyAddress );

   180         proxyPtr.Append( _L8( ":" ) );

   181         proxyPtr.AppendNum( aProxyPort );

   182         LOGTEXT( proxyPtr );

   183 

   184         RStringF proxyF = iSessionStringPool.OpenFStringL( *proxy );

   185         CleanupClosePushL( proxyF );

   186 

   187         connectionInfo.SetPropertyL(

   188             iSessionStringPool.StringF( HTTP::EProxyAddress, RHTTPSession::GetTable() ),

   189             proxyF );

   190 

   191         CleanupStack::PopAndDestroy(1); // proxyF.Close()

   192         CleanupStack::PopAndDestroy( proxy );

   193         }

   194     else

   195         {

   196         LOGSTRING("CMiniBrowser: NOT using proxy");

   197         connectionInfo.SetPropertyL(

   198             iSessionStringPool.StringF( HTTP::EProxyUsage, RHTTPSession::GetTable() ),

   199             iSessionStringPool.StringF( HTTP::EDoNotUseProxy, RHTTPSession::GetTable() ) );

   200         }

   201 

   202     LOGSTRING( "CMiniBrowser: iSession.OpenTransactionL" );

   203     iTransaction = iSession.OpenTransactionL( uriParser, *this,

   204         iSessionStringPool.StringF( HTTP::EGET, RHTTPSession::GetTable() ) );

   205     LOGSTRING( "CMiniBrowser: iSession.OpenTransactionL - done" );

   206 

   207 

   208     // Set user agent string (we have our own user agent string definition,

   209     // not Mozilla compatible)

   210     HBufC8* userAgent = NULL;

   211     TRAPD( err, userAgent = GetUserAgentStringL() );

   212     if( err != KErrNone )

   213         {

   214         LOGSTRING2( "Error in GetUserAgentStringL: %i", err );

   215         }

   216     else

   217         {

   218         CleanupStack::PushL( userAgent );

   219         LOGTEXT( *userAgent );

   220         RHTTPHeaders headers = iTransaction.Request().GetHeaderCollection();

   221         RStringF str = iSessionStringPool.OpenFStringL( *userAgent );

   222         CleanupClosePushL( str );

   223         headers.SetFieldL(

   224             iSessionStringPool.StringF( HTTP::EUserAgent, RHTTPSession::GetTable() ),

   225             str );

   226         CleanupStack::PopAndDestroy(); // str.Close()

   227         CleanupStack::PopAndDestroy( userAgent );

   228         }

   229 

   230 

   231     TCallBack callBack( TimeOutCallBack, this );

   232     if( iPeriodic->IsActive() )

   233         {

   234         iPeriodic->Cancel();

   235         }

   236     iPeriodic->Start( KTimeOut, KTimeOut, callBack );

   237 

   238     iTransaction.SubmitL();

   239     LOGSTRING( "CMiniBrowser::HttpGetL - done" );

   240     }

   241 

   242 HBufC8* CMiniBrowser::GetUserAgentStringL()

   243     {

   244     LOGSTRING("CMiniBrowser::GetUserAgentStringL");

   245 

   246     _LIT8( KUserAgentName, "OnlineSupport");

   247     _LIT8( KSlash, "/");

   248     _LIT8( KSpace, " ");

   249     _LIT8( KSymbianOS, "SymbianOS");

   250     _LIT8( KS60, "Series60");

   251     _LIT8( KQuestionMark, "?" );

   252     _LIT( KPhoneModuleName, "Phonetsy.tsy");

   253     _LIT( KPhoneName, "DefaultPhone");

   254     const TChar lineFeedChar( 0xA );

   255 

   256     RTelServer telServer;

   257     User::LeaveIfError( telServer.Connect() );

   258     CleanupClosePushL( telServer );

   259     User::LeaveIfError( telServer.LoadPhoneModule( KPhoneModuleName ) );

   260     RMobilePhone phone;

   261     User::LeaveIfError( phone.Open( telServer, KPhoneName ) );

   262     CleanupClosePushL( phone );

   263     LOGSTRING("CMiniBrowser::GetUserAgentStringL 2");

   264 

   265     RMobilePhone::TMobilePhoneIdentityV1 phoneIdentity;

   266     TRequestStatus status( KRequestPending );

   267     phone.GetPhoneId( status, phoneIdentity );

   268     User::WaitForRequest( status );

   269 

   270 

   271     // parse sw version from the string

   272     // sw version is assumed to be string between first "V" and "\n"

   273     LOGSTRING("Reading sw version info");

   274     TBuf<KSysUtilVersionTextLength> versions;

   275     User::LeaveIfError( SysUtil::GetSWVersion( versions ) );

   276     LOGTEXT( versions );

   277 

   278     // SW version

   279     LOGSTRING("Locating sw version from the string");

   280     TInt begin(0);

   281     TInt len(0);

   282     // Assume sw version is in the first row (use line feed as a token separator)

   283     TBuf8<KSysUtilVersionTextLength> sw;

   284     TVersionStrings::TokenLocationL( versions, lineFeedChar, 0, sw.MaxLength(), begin, len );

   285     if( len <= 2 )

   286         {

   287         User::Leave( KErrNotFound );

   288         }

   289 

   290     _LIT(KVerStrStart,"V ");

   291     TInt pos1 = versions.Find(KVerStrStart);

   292     if (pos1 != KErrNotFound)

   293         {

   294         sw.Copy( versions.Mid( begin + 2, len - 2 ) ); // remove "V "

   295         }

   296     else

   297         {

   298         // SW version does not always start with "V "

   299         sw.Copy( versions.Mid( begin, len ) );

   300         }

   301     

   302     LOGTEXT( sw );

   303 

   304 

   305     // Series 60 and Symbian OS versions

   306     LOGSTRING("Reading OS versions");

   307     TVersionBuf s60Version;

   308     s60Version.Copy( KQuestionMark );

   309     TVersionBuf symbianVersion;

   310     symbianVersion.Copy( KQuestionMark );

   311     TRAPD( err, TVersionStrings::GetUserAgentVersionsL( s60Version, symbianVersion ) );

   312     if( err != KErrNone )

   313         {

   314         LOGSTRING2( "Error: %i", err );

   315         }

   316 

   317     LOGSTRING("Series60 version");

   318     LOGTEXT( s60Version );

   319     LOGSTRING("SymbianOS version");

   320     LOGTEXT( symbianVersion );

   321 

   322 

   323     LOGSTRING("CMiniBrowser::GetUserAgentStringL 3");

   324     // The string is of format:

   325     // OnlineSupport <manufacturer><model>/<sw> SymbianOS/<symbian_os_version> S60/<S60_version>

   326     HBufC8* agent = HBufC8::NewLC(

   327         KUserAgentName().Length() +

   328         phoneIdentity.iManufacturer.Length() +

   329         phoneIdentity.iModel.Length() +

   330         sw.Length() +

   331         KSymbianOS().Length() +

   332         symbianVersion.Length() +

   333         KS60().Length() +

   334         s60Version.Length() +

   335         3 * KSlash().Length() +      /* three slasles in the string */

   336         3 * KSpace().Length()        /* three spaces in the string */

   337         );

   338     LOGSTRING("CMiniBrowser::GetUserAgentStringL 3.5");

   339     TPtr8 agentPtr = agent->Des();

   340     agentPtr.Append( KUserAgentName );

   341     agentPtr.Append( KSpace);

   342     agentPtr.Append( phoneIdentity.iManufacturer );

   343     agentPtr.Append( phoneIdentity.iModel );

   344     agentPtr.Append( KSlash );

   345     agentPtr.Append( sw );

   346     agentPtr.Append( KSpace);

   347     agentPtr.Append( KSymbianOS );

   348     agentPtr.Append( KSlash);

   349     agentPtr.Append( symbianVersion );

   350     agentPtr.Append( KSpace);

   351     agentPtr.Append( KS60 );

   352     agentPtr.Append( KSlash);

   353     agentPtr.Append( s60Version );

   354 

   355     LOGSTRING("CMiniBrowser::GetUserAgentStringL 4");

   356     CleanupStack::Pop( agent );

   357     CleanupStack::PopAndDestroy(); // phone.Close()

   358     CleanupStack::PopAndDestroy(); // telServer.Close()

   359     LOGSTRING("CMiniBrowser::GetUserAgentStringL - done");

   360     return agent;

   361     }

   362 

   363 

   364 TInt CMiniBrowser::TimeOutCallBack( TAny* aMiniBrowser)

   365     {

   366     TRAPD( err, ( ( CMiniBrowser* ) aMiniBrowser )->DoTimeOutCallBackL() );

   367     if( err == KLeaveExit )

   368         {

   369         User::Leave( KLeaveExit );

   370         }

   371     return err;

   372     }

   373 

   374 void CMiniBrowser::DoTimeOutCallBackL()

   375     {

   376     LOGSTRING( "CMiniBrowser::DoTimeOutCallBackL" );

   377     if( iPeriodic->IsActive() )

   378         {

   379         iPeriodic->Cancel();

   380         }

   381 

   382     TRAPD( err, iObserver.MiniBrowserErrorL( KErrTimedOut ) );

   383     if( err != KErrNone )

   384         {

   385         iObserver.MiniBrowserUnhandledLeave( err );

   386         }

   387     if( err == KLeaveExit )

   388         {

   389         User::Leave( err ); 

   390         }

   391 

   392     LOGSTRING( "CMiniBrowser::DoTimeOut - done" );

   393     }

   394 

   395 void CMiniBrowser::MHFRunL( RHTTPTransaction aTransaction, const THTTPEvent &aEvent )

   396     {

   397     LOGSTRING( "CMiniBrowser::MHFRunL" );

   398     if( iPeriodic->IsActive() )

   399         {

   400         iPeriodic->Cancel();

   401         }

   402 

   403     switch( aEvent.iStatus )

   404         {

   405         case THTTPEvent::ESubmit:

   406             {

   407             LOGSTRING( "CMiniBrowser::MHFRunL:ESubmit" );

   408             LOGTEXT( aTransaction.Request().URI().UriDes() );

   409 

   410             LOGSTRING( "CMiniBrowser: reset ResponseData" );

   411             ResetResponseDataL();

   412             break;

   413             }

   414         case THTTPEvent::EGotResponseHeaders:

   415             {

   416             LOGSTRING( "CMiniBrowser::MHFRunL:EGotResponseHeaders" );

   417             THTTPHdrVal value;

   418             TInt err = aTransaction.Response().GetHeaderCollection().GetField(

   419                 iSessionStringPool.StringF( HTTP::EContentType, RHTTPSession::GetTable() ), 0, value );

   420 

   421             if( err == KErrNone )

   422             {

   423                 LOGSTRING("Content type:");

   424                 const TDesC8& contentType = value.StrF().DesC();

   425                 LOGTEXT( contentType );

   426                 if( contentType.Compare( KNokiaHeadWrapper ) == 0 )

   427                     {

   428                     iContentType = EContentTypeNokiaHeadWrapper;

   429                     }

   430                 else

   431                     {

   432                     iContentType = EContentTypeUnknown;

   433                     }

   434             }

   435 

   436             TCallBack callBack( TimeOutCallBack, this );

   437             if( iPeriodic->IsActive() )

   438                 {

   439                 iPeriodic->Cancel();

   440                 }

   441             iPeriodic->Start( KTimeOut, KTimeOut, callBack );

   442             break;

   443             }

   444         case THTTPEvent::EGotResponseBodyData:

   445             {

   446             LOGSTRING( "CMiniBrowser::MHFRunL:EGotResponseBodyData" );

   447             MHTTPDataSupplier* pBody = aTransaction.Response().Body();

   448             if( pBody )

   449                 {

   450                 TPtrC8 dataChunk;

   451                 pBody->GetNextDataPart( dataChunk );

   452                 // Log

   453                 LOGSTRING( "CMiniBrowser: MHTTPDataSupplier:" );

   454 #ifdef _DEBUG

   455                 for( TInt i(0); i < dataChunk.Length(); i += 128 )

   456                     {

   457                     LOGTEXT( dataChunk.Right( dataChunk.Length() - i ) );

   458                     }

   459 #endif

   460                 AppendResponseDataL( dataChunk );

   461                 pBody->ReleaseData();

   462                 }

   463             LOGSTRING( "CMiniBrowser::MHFRunL:EGotResponseBodyData - 2" );

   464 

   465             TCallBack callBack( TimeOutCallBack, this );

   466             if( iPeriodic->IsActive() )

   467                 {

   468                 iPeriodic->Cancel();

   469                 }

   470             iPeriodic->Start( KTimeOut, KTimeOut, callBack );

   471             break;

   472             }

   473         case THTTPEvent::EResponseComplete:

   474             {

   475             LOGSTRING( "CMiniBrowser::MHFRunL:EResponseComplete" );

   476             break;

   477             }

   478         case THTTPEvent::ESucceeded:

   479             {

   480             LOGSTRING( "CMiniBrowser::MHFRunL:ESucceeded" );

   481 

   482             if( iContentType == EContentTypeNokiaHeadWrapper )

   483                 {

   484                 TRAPD( err, ParseAndSaveProvisionedSettingsL() );

   485                 if( err != THttpProvStates::EStatusOk )

   486                     {

   487                     User::Leave( err );

   488                     }

   489                 }

   490             else if( iContentType == EContentTypeUnknown )

   491                 {

   492                 TRAPD( err, ParseAndSaveProvisionedSettingsL() );

   493                 if( err != THttpProvStates::EStatusOk )

   494                     {

   495                     User::Leave( err );

   496                     }

   497                 }

   498             iObserver.MiniBrowserRequestDoneL();

   499             }

   500             break;

   501         case THTTPEvent::EFailed:

   502             LOGSTRING( "CMiniBrowser::MHFRunL:EFailed" );

   503             ResetResponseDataL();

   504             User::Leave( KErrGeneral );

   505             break;

   506         default:

   507             {

   508             LOGSTRING2( "CMiniBrowser::MHFRunL:event: %i", aEvent.iStatus );

   509             break;

   510             }

   511         }

   512 

   513     LOGSTRING( "CMiniBrowser::MHFRunL - done" );

   514     }

   515 

   516 // currently not supported

   517 //void CMiniBrowser::ShowMessageDialogL( const TDesC8& aMessage )

   518 //    {

   519 //    LOGSTRING( "ShowMessageDialogL" );

   520 //    LOGTEXT( aMessage );

   521 //    TInt length = aMessage.Length();

   522 //    if( length > KMaxMessageLength )

   523 //        {

   524 //        length = KMaxMessageLength;

   525 //        }

   526 //    HBufC* message = HBufC::NewLC( length );

   527 //    message->Des().Copy( aMessage.Left( length ) );

   528 //

   529 //    CAknGlobalNote* globalNote = CAknGlobalNote::NewL();

   530 //    CleanupStack::PushL( globalNote );

   531 //    globalNote->SetSoftkeys( R_AVKON_SOFTKEYS_CLOSE );

   532 //    globalNote->ShowNoteL( EAknGlobalInformationNote , *message );

   533 //

   534 //    LOGSTRING( "deleting globalNote" );

   535 //    CleanupStack::PopAndDestroy( globalNote );

   536 //    CleanupStack::PopAndDestroy( message );

   537 //    LOGSTRING( "ShowMessageDialogL - done" );

   538 //    }

   539 

   540 

   541 void CMiniBrowser::ParseAndSaveProvisionedSettingsL()

   542     {

   543     LOGSTRING( "CMiniBrowser::ParseAndSaveProvisionedSettingsL - begin" );

   544     if( !iResponseData )

   545         {

   546         User::Leave( THttpProvStates::EStatusWrapperParsingFailed );

   547         }

   548     LOGSTRING( "CMiniBrowser::SaveProvisionedSettingsL - 2" );

   549     CNHeadWrapperParser* NHwrParser = CNHeadWrapperParser::NewL( *iResponseData );

   550     CleanupStack::PushL( NHwrParser );

   551     LOGSTRING( "CMiniBrowser::SaveProvisionedSettingsL - 3" );

   552     iProvisioningStatus = NHwrParser->Parse();

   553     LOGSTRING( "CMiniBrowser::SaveProvisionedSettingsL - 4" );

   554     if( iProvisioningStatus != THttpProvStates::EStatusOk )

   555         {

   556         LOGSTRING2( "status from parse:%i", iProvisioningStatus ); 

   557         // Try to get report url anyways, this should succeed at leat in case

   558         // Nokia HeadWrapper authentication failed while parsing an otherwise valid

   559         // HeadWrapper document

   560         GetReportUrlL( *NHwrParser );

   561         User::Leave( iProvisioningStatus );

   562         }

   563     LOGSTRING( "CMiniBrowser::SaveProvisionedSettingsL - 5" );

   564     GetReportUrlL( *NHwrParser );

   565     LOGSTRING( "CMiniBrowser::SaveProvisionedSettingsL - 6" );

   566     // Get provisioned data

   567     TPtrC8 content;

   568     TRAPD( err, content.Set( NHwrParser->GetContentL() ) );

   569     if( err != KErrNone )

   570         {

   571         LOGSTRING2( "err from GetContentL:%i", err );

   572         iProvisioningStatus = THttpProvStates::EStatusDocumentParsingFailed;

   573         User::Leave( err );

   574         }

   575 

   576     LOGSTRING( "Response parsed" ); 

   577 

   578     TPtrC8 contentType;

   579     TRAP( err, contentType.Set( NHwrParser->GetContentTypeL() ) );

   580     if( err != KErrNone )

   581         {

   582         LOGSTRING2( "err from GetContentTypeL:%i", err );

   583         iProvisioningStatus = THttpProvStates::EStatusDocumentParsingFailed;

   584         User::Leave( err );

   585         }

   586 

   587     if( contentType.Compare( KContentTypeApplicationWapConnectivityWbxml ) == 0 )

   588         {

   589         LOGSTRING( "CMiniBrowser: content type application/vnd.wap.connectivity-wbxml" );

   590         TRAP( err, SaveProvisionedSettingsL( content ) );

   591         iProvisioningStatus = (THttpProvStates::TProvisioningStatus) err;

   592         if( iProvisioningStatus != THttpProvStates::EStatusOk )

   593             {

   594             LOGSTRING2( "ProvisioningStatus from SaveProvisionedSettingsL:%i", iProvisioningStatus ); 

   595             User::Leave( iProvisioningStatus );

   596             }

   597         }

   598 // currently not supported

   599 //    else if( contentType.Compare( KContentTypeTextPlain ) == 0 )

   600 //        {

   601 //        LOGSTRING( "CMiniBrowser: content type text/plain" );

   602 //        ShowMessageDialogL( content );

   603 //        }

   604     else

   605         {

   606         LOGSTRING( "CMiniBrowser: Unknown content type" );

   607         User::Leave( THttpProvStates::EStatusWrapperParsingFailed );

   608         }

   609 

   610     CleanupStack::PopAndDestroy( NHwrParser );

   611     LOGSTRING( "CMiniBrowser::SaveProvisionedSettingsL - done" );

   612     }

   613 

   614 void CMiniBrowser::GetReportUrlL( const CNHeadWrapperParser& aNHwrParser )

   615     {

   616     LOGSTRING( "CMiniBrowser::GetReportUrlL - begin" );

   617     // Store report URL for later reference

   618     const TDesC8& reportUrl = aNHwrParser.GetReportUrlL();

   619     if( iReportUrl->Des().MaxLength() < reportUrl.Length() )

   620         {

   621         delete iReportUrl;

   622         iReportUrl = 0;

   623         iReportUrl = HBufC8::NewL( reportUrl.Length() );

   624         }

   625     TPtr8 reportUrlPtr = iReportUrl->Des();

   626     reportUrlPtr.Copy( reportUrl );

   627     LOGTEXT( *iReportUrl );

   628     LOGSTRING( "CMiniBrowser::GetReportUrlL - end" );

   629     }

   630 

   631 HBufC* CMiniBrowser::GetReportUrlLC()

   632     {

   633     LOGSTRING( "CMiniBrowser::GetReportUrlLC - begin" );

   634     if( iReportUrl && iReportUrl->Length() )

   635         {

   636         HBufC* url = HBufC::NewLC(

   637             iReportUrl->Length() +

   638             KAmpersand().Length() +

   639             KQuestionMark().Length() +

   640             KStatus().Length() );

   641 

   642         TPtr urlPtr = url->Des();

   643         urlPtr.Copy( *iReportUrl );

   644 

   645         // Add provisioning status to the url if known

   646         if( iProvisioningStatus != THttpProvStates::EStatusUnknown )

   647             {

   648             // Assume there might already be parameters in the URL given

   649             if( urlPtr.Find( KQuestionMark ) != KErrNotFound )

   650                 {

   651                 urlPtr.Append( KAmpersand );

   652                 }

   653             else

   654                 {

   655                 urlPtr.Append( KQuestionMark );

   656                 }

   657             urlPtr.Append( KStatus );

   658             urlPtr.AppendNum( (TInt) iProvisioningStatus );

   659             }

   660         LOGSTRING( "CMiniBrowser::GetReportUrlLC - end" );

   661         return url;

   662         }

   663     else

   664         {

   665         LOGSTRING( "CMiniBrowser::GetReportUrlLC Leave KErrNotFound" );

   666         User::Leave( KErrNotFound );

   667         }

   668     return NULL; // Not possible to end up here

   669     }

   670 

   671 void CMiniBrowser::SaveProvisionedSettingsL( const TDesC8& aContent )

   672     {

   673     LOGSTRING( "CMiniBrowser::SaveProvisionedSettingsL" );

   674     TInt status = THttpProvStates::EStatusOk;

   675     // Create WPEngine

   676     CWPEngine* wpengine = CWPEngine::NewL();

   677     CleanupStack::PushL( wpengine );

   678 

   679     LOGSTRING( "wpengine->ImportDocumentL" );   

   680     TRAPD( err, wpengine->ImportDocumentL( aContent ) );

   681     User::LeaveIfError( err );

   682 

   683     LOGSTRING( "wpengine->PopulateL" );

   684     TRAP( err, wpengine->PopulateL() );

   685     if( err != KErrNone )

   686         {

   687         LOGSTRING2( "PopulateL err: %i", err );

   688         User::Leave( err );

   689         }

   690     LOGSTRING( "wpengine->PopulateL success" );

   691 

   692     TInt itemCount = wpengine->ItemCount();

   693     // Empty messages are not supported

   694     if( itemCount == 0 )

   695         {

   696         LOGSTRING("No items in provisioning message!");

   697         User::Leave( THttpProvStates::EStatusWrapperParsingFailed );

   698         }

   699 

   700     for( TInt i(0); i < itemCount; i++ )

   701         {

   702         LOGSTRING( "Saving" );

   703         TRAP( err, wpengine->SaveL( i ) );

   704         if( wpengine->CanSetAsDefault( i ) )

   705             {

   706             LOGSTRING( "Setting as default" );

   707             TRAP( err, wpengine->SetAsDefaultL( i ) );

   708             }

   709         else

   710             {

   711             LOGSTRING( "Cannot set as default" );

   712             }

   713         if( err != KErrNone )

   714             {

   715             LOGSTRING2( "Error while saving: %i", err );

   716             status = THttpProvStates::EStatusStorageFailed;

   717             }

   718         }

   719 

   720     if( status != THttpProvStates::EStatusOk )

   721         {

   722         User::Leave( status );

   723         }

   724     }

   725 

   726 TInt CMiniBrowser::MHFRunError( TInt aError, RHTTPTransaction /*aTransaction*/, const THTTPEvent& /*aEvent*/ )

   727     {

   728     LOGSTRING2( "CMiniBrowser::MHFRunError %i", aError );

   729     iTransaction.Close();

   730     TRAPD( err, iObserver.MiniBrowserErrorL( aError ) );

   731     if( err != KErrNone )

   732         {

   733         iObserver.MiniBrowserUnhandledLeave( err );

   734         }

   735     LOGSTRING( "CMiniBrowser::MHFRunError - done" );

   736     if( err == KLeaveExit )

   737         {

   738         return err;

   739         }

   740     return KErrNone;

   741     }

   742 

   743 

   744 void CMiniBrowser::AppendResponseDataL( const TDesC8& aData )

   745     {

   746     LOGSTRING( "CMiniBrowser::AppendResponseDataL()" );

   747     if( ( iResponseData->Des().MaxLength() - iResponseData->Length() ) < aData.Length() )

   748         {

   749         // ReAlloc

   750         HBufC8* tempBuf = HBufC8::NewL( iResponseData->Length() + aData.Length() );

   751         TPtr8 tempBufPtr = tempBuf->Des();

   752         tempBufPtr.Append( *iResponseData );

   753         delete iResponseData;

   754         iResponseData = tempBuf; 

   755         }

   756 

   757     TPtr8 ptr = iResponseData->Des();

   758     ptr.Append( aData );

   759     LOGSTRING( "CMiniBrowser::AppendResponseDataL() - done" );

   760     }

   761 

   762 void CMiniBrowser::ResetResponseDataL()

   763     {

   764     LOGSTRING( "CMiniBrowser::ResetResponseDataL()" );

   765     if( iResponseData && iResponseData->Length() )

   766         {

   767         delete iResponseData;

   768         iResponseData = 0;

   769         iResponseData = HBufC8::NewL( KInitialDataBufferSize );

   770         }

   771     if( iReportUrl && iReportUrl->Length() )

   772         {

   773         delete iReportUrl;

   774         iReportUrl = 0;

   775         iReportUrl = HBufC8::NewL( KInitialReportUrlBufferSize );

   776         }

   777     iContentType = EContentTypeUnknown;

   778     iProvisioningStatus = THttpProvStates::EStatusUnknown;

   779     LOGSTRING( "CMiniBrowser::ResetResponseDataL() - done" );

   780     }

   781 

   782 TBool CMiniBrowser::GetNextDataPart( TPtrC8 &aDataPart )

   783     {

   784     _LIT8( KEmpty, "");

   785     aDataPart.Set( KEmpty() );

   786     return ETrue;

   787     }

   788 

   789 void CMiniBrowser::ReleaseData()

   790     {

   791     }

   792 

   793 TInt CMiniBrowser::OverallDataSize()

   794     {

   795     return KErrNotFound;

   796     }

   797 

   798 TInt CMiniBrowser::Reset()

   799     {

   800     return KErrNone;

   801     }