1 /*

     2 * Copyright (c) 2005-2009 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:  CSConPCD implementation

    15 *

    16 */

    17 

    18 

    19 // INCLUDE FILES

    20 

    21 #include "sconpcd.h"

    22 #include "sconpcdconsts.h"

    23 #include "sconinstqueue.h"

    24 #include "sconbrqueue.h"

    25 #include "sconmetadata.h"

    26 #include "debug.h"

    27 

    28 // ============================= MEMBER FUNCTIONS ===============================

    29 

    30 

    31 // -----------------------------------------------------------------------------

    32 // CreateCSConPCDL()

    33 // Entry to CSConPCD

    34 // -----------------------------------------------------------------------------

    35 //

    36 EXPORT_C CSConPCD* CreateCSConPCDL()

    37     {

    38     TRACE_FUNC;

    39     return CSConPCD::NewL();

    40     }

    41     

    42 // -----------------------------------------------------------------------------

    43 // CSConPCD::NewL()

    44 // Two-phase constructor

    45 // -----------------------------------------------------------------------------

    46 //

    47 CSConPCD* CSConPCD::NewL()

    48     {

    49     TRACE_FUNC_ENTRY;

    50     CSConPCD* self = new (ELeave) CSConPCD();

    51     CleanupStack::PushL( self );

    52     self->ConstructL();

    53     CleanupStack::Pop( self );

    54     TRACE_FUNC_EXIT;

    55     return self;

    56     }

    57     

    58 // -----------------------------------------------------------------------------

    59 // CSConPCD::CSConPCD()

    60 // Constructor

    61 // -----------------------------------------------------------------------------

    62 //

    63 CSConPCD::CSConPCD() : iInstallerQueue( NULL ), iBackupRestoreQueue( NULL ), 

    64     iLatestReply(NULL), iTaskNumber( 0 ), iMaxObjectSize( 65536 ), 

    65     iLastOperation( ENoTask )

    66     {

    67     TRACE_FUNC;

    68     }

    69     

    70 // -----------------------------------------------------------------------------

    71 // CSConPCD::ConstructL()

    72 // Initializes member data

    73 // -----------------------------------------------------------------------------

    74 //

    75 void CSConPCD::ConstructL()

    76     {

    77     TRACE_FUNC_ENTRY;

    78     User::LeaveIfError( iFs.Connect() );

    79     iInstallerQueue = CSConInstallerQueue::NewL( iFs );

    80     iBackupRestoreQueue = CSConBackupRestoreQueue::NewL( iMaxObjectSize, iFs );

    81     iInstallerQueue->QueueAddress( iBackupRestoreQueue );

    82     iBackupRestoreQueue->QueueAddress( iInstallerQueue );

    83     

    84     if ( !CActiveScheduler::Current() )

    85         {

    86         CActiveScheduler* scheduler = new (ELeave) CActiveScheduler();

    87         CActiveScheduler::Install( scheduler );

    88         }

    89     CActiveScheduler::Add( iInstallerQueue );

    90     CActiveScheduler::Add( iBackupRestoreQueue );

    91     TRACE_FUNC_EXIT;

    92     }

    93     

    94 // -----------------------------------------------------------------------------

    95 // CSConPCD::~CSConPCD()

    96 // Destructor

    97 // -----------------------------------------------------------------------------

    98 //

    99 CSConPCD::~CSConPCD()

   100     {

   101     TRACE_FUNC_ENTRY;

   102     if ( iInstallerQueue )

   103         {

   104         iInstallerQueue->Cancel();

   105         delete iInstallerQueue;

   106         iInstallerQueue = NULL;

   107         }

   108         

   109     if ( iBackupRestoreQueue )

   110         {

   111         iBackupRestoreQueue->Cancel();

   112         delete iBackupRestoreQueue;

   113         iBackupRestoreQueue = NULL;

   114         }

   115     

   116     if ( iLatestReply )

   117         {

   118         delete iLatestReply;

   119         iLatestReply = NULL;

   120         }

   121     

   122     iFs.Close();

   123     TRACE_FUNC_EXIT;

   124     }

   125     

   126 // -----------------------------------------------------------------------------

   127 // CSConPCD::PutTaskL( CSConTask* aTask )

   128 // Receives a new task

   129 // -----------------------------------------------------------------------------

   130 //

   131 TInt CSConPCD::PutTaskL( CSConTask*& aTask )

   132     {

   133     TRACE_FUNC_ENTRY;

   134     TInt ret( KErrNone );

   135     TInt maxObjectSize( 0 );

   136     

   137     if ( iLastOperation == EPutTask )

   138         {

   139         LOGGER_WRITE( "CSConPCD::PutTaskL() : Two Puts in a row -> Reset()" );

   140         ResetPCD();

   141         }

   142     else

   143         {

   144         LOGGER_WRITE( "CSConPCD::PutTaskL() : Protocol procedure ok" );

   145         iLastOperation = EPutTask;

   146         }

   147     

   148     switch( aTask->GetServiceId() )

   149         {

   150         case ECancel :

   151             ret = CancelL( aTask->iCancelTaskId, aTask->iCancelTaskAll );

   152             delete aTask;

   153             break;

   154         case EGetDataOwnerStatus :

   155             ret = SupportedBRTaskL( aTask );

   156             break;

   157         case EGetDataSize :

   158             ret = SupportedBRTaskL( aTask );

   159             break;

   160         case EGetStatus :

   161             ret = GetStatusL( aTask->iGetStatusParams->iTaskId, 

   162             		aTask->iGetStatusParams->iAll );

   163             delete aTask;

   164             break;

   165         case EInstall :

   166             ret = SupportedInstTaskL( aTask );

   167             break;

   168         case EListDataOwners :

   169             ret = SupportedBRTaskL( aTask );

   170             break;

   171         case EListInstalledApps :

   172             ret = SupportedInstTaskL( aTask );

   173             break;

   174         case EListPublicFiles :

   175             ret = SupportedBRTaskL( aTask );          

   176             break;

   177         case ERequestData :

   178             ret = SupportedBRTaskL( aTask );

   179             break;

   180         case ESetBURMode :

   181             ret = SupportedBRTaskL( aTask );

   182             break;

   183         case ESetInstParams :

   184             ret = SupportedInstTaskL( aTask );

   185             break;

   186         case ESupplyData :

   187             ret = SupportedBRTaskL( aTask );

   188             break;

   189         case EUninstall :

   190             ret = SupportedInstTaskL( aTask );

   191             break;

   192         case EUpdateDeviceInfo :

   193             maxObjectSize = aTask->iDevInfoParams->iMaxObjectSize;

   194             ret = UpdateDeviceInfoL( maxObjectSize );

   195             iTaskNumber++;

   196             delete aTask;

   197             break;

   198         case EReboot :

   199             RebootTaskL( aTask );

   200             delete aTask;

   201             break;

   202         case EGetMetadata :

   203         	ret = KErrNone;

   204             GetMetadataTaskL( *aTask );

   205             delete aTask;

   206             break;

   207         default :

   208             break;

   209         }

   210     LOGGER_WRITE_1( "CSConPCD::PutTaskL() : returned %d", ret );

   211     return ret;

   212     }

   213 

   214 // -----------------------------------------------------------------------------

   215 // CSConPCD::GetReply()

   216 // Returns a reply to previous PutTaskL operation

   217 // -----------------------------------------------------------------------------

   218 //

   219 CSConStatusReply* CSConPCD::GetReply()

   220     {

   221     TRACE_FUNC_ENTRY;

   222     

   223     if ( iLastOperation == EGetReply )

   224         {

   225         LOGGER_WRITE( "CSConPCD::GetReply() : Two Gets in a row -> Reset()" );

   226         ResetPCD();

   227         }

   228     else

   229         {

   230         LOGGER_WRITE( "CSConPCD::GetReply() : Protocol procedure ok" );

   231         iLastOperation = EGetReply;

   232         }

   233     CSConStatusReply* reply = iLatestReply;

   234     iLatestReply = NULL;

   235     TRACE_FUNC_EXIT;

   236     return reply;

   237     }

   238 

   239 // -----------------------------------------------------------------------------

   240 // CSConPCD::ResetPCD()

   241 // Resets the module to the initial state

   242 // -----------------------------------------------------------------------------

   243 //

   244 void CSConPCD::ResetPCD()

   245     {

   246     TRACE_FUNC_ENTRY;

   247     if ( iInstallerQueue )

   248         {

   249         LOGGER_WRITE( "CSConPCD::ResetPCD() : Reseting installer queue" );

   250         iInstallerQueue->Reset();

   251         }

   252         

   253     if ( iBackupRestoreQueue )

   254         {

   255         LOGGER_WRITE( "CSConPCD::ResetPCD() : Reseting backup queue" );

   256         iBackupRestoreQueue->Reset();

   257         }

   258     

   259     TRACE_FUNC_EXIT;

   260     }

   261 

   262 // -----------------------------------------------------------------------------

   263 // CSConPCD::SupportedInstTaskL( CSConTask* aTask )

   264 // Fills a reply with predefined supported task -information

   265 // -----------------------------------------------------------------------------

   266 //  

   267 TInt CSConPCD::SupportedInstTaskL( CSConTask* aTask )

   268     {

   269     TRACE_FUNC_ENTRY;

   270     TInt ret( KErrNone );

   271     iTaskNumber++;

   272     ret = iInstallerQueue->AddNewTask( aTask, iTaskNumber );

   273     

   274     //Get status for this task

   275     TBool all( EFalse );

   276     CSConStatusReply* reply = new (ELeave) CSConStatusReply();

   277     CleanupStack::PushL( reply );

   278     iInstallerQueue->GetQueueStatusL( iTaskNumber, all, reply );

   279     CleanupStack::Pop( reply );

   280     

   281     StoreReply( reply );    

   282         

   283     LOGGER_WRITE_1( "CSConPCD::SupportedInstTaskL() : returned %d", ret );

   284     return ret;

   285     }

   286 

   287 // -----------------------------------------------------------------------------

   288 // CSConPCD::SupportedBRTask( CSConTask* aTask )

   289 // Fills a reply with predefined supported task -information

   290 // -----------------------------------------------------------------------------

   291 //

   292 TInt CSConPCD::SupportedBRTaskL( CSConTask* aTask )

   293     {

   294     TRACE_FUNC_ENTRY;

   295     TInt ret( KErrNone );

   296     

   297     TInt taskId;

   298     

   299     taskId = ++iTaskNumber;

   300         

   301     ret = iBackupRestoreQueue->AddNewTask( aTask, taskId );

   302     LOGGER_WRITE_1( "iBackupRestoreQueue->AddNewTask : ret %d", ret );

   303     //Get status for this task

   304     TBool all( EFalse );

   305     CSConStatusReply* reply = new (ELeave) CSConStatusReply();

   306     CleanupStack::PushL( reply );

   307     iBackupRestoreQueue->GetQueueStatusL( iTaskNumber, all, reply );

   308     CleanupStack::Pop( reply );

   309     

   310     StoreReply( reply );    

   311     

   312     TRACE_FUNC_EXIT;

   313     return ret;

   314     }

   315 

   316 

   317 // -----------------------------------------------------------------------------

   318 // CSConPCD::RebootTask( const CSConTask* aTask )

   319 // Fills a reply with predefined unsupported task -information

   320 // -----------------------------------------------------------------------------

   321 //  

   322 TInt CSConPCD::RebootTaskL( const CSConTask* aTask )

   323     {

   324     TRACE_FUNC_ENTRY;

   325     TInt ret( KErrNotSupported );

   326     iTaskNumber++;

   327     TSConMethodName method( aTask->GetServiceId() );

   328     CSConStatusReply* reply = new (ELeave) CSConStatusReply();

   329     CleanupStack::PushL( reply );

   330     CSConTaskReply* taskReply = new (ELeave) CSConTaskReply();

   331     CleanupStack::PushL( taskReply );

   332     

   333     TBool complete( ETrue );

   334     taskReply->InitializeL( method, KSConCodeNotSupported, complete );

   335     taskReply->iTaskId = iTaskNumber;

   336     

   337     reply->iNoTasks = EFalse;

   338     User::LeaveIfError( reply->iTasks.Append( taskReply ) );

   339     CleanupStack::Pop( taskReply );

   340     

   341     StoreReply( reply );

   342     CleanupStack::Pop( reply );

   343         

   344     LOGGER_WRITE_1( "CSConPCD::RebootTask() : returned %d", ret );

   345     return ret;

   346     }

   347 

   348 // -----------------------------------------------------------------------------

   349 // CSConPCD::GetMetadataTask( const CSConTask* aTask )

   350 // Fills a reply with predefined GetMetadata task -information

   351 // -----------------------------------------------------------------------------

   352 //

   353 void CSConPCD::GetMetadataTaskL( CSConTask& aTask )

   354     {

   355     TRACE_FUNC_ENTRY;

   356     

   357     aTask.iTaskId = ++iTaskNumber;

   358     

   359     //Set progress value "task accepted for execution"

   360     aTask.SetProgressValue( KSConCodeTaskCreated );

   361     aTask.SetCompleteValue( EFalse );

   362     

   363     SConMetadata::ProcessTask( aTask, iFs );

   364     

   365     //Get status for this task

   366  

   367     CSConStatusReply* reply = new (ELeave) CSConStatusReply();

   368     CleanupStack::PushL( reply );

   369     CSConTaskReply* taskReply = new (ELeave) CSConTaskReply();

   370     CleanupStack::PushL( taskReply );

   371     taskReply->InitializeL( aTask );

   372     User::LeaveIfError( reply->iTasks.Append( taskReply ) );

   373     CleanupStack::Pop( taskReply );

   374     

   375     if ( !aTask.GetComplete() )

   376         {

   377         // clean all unneccessary data from the reply packet

   378         taskReply->CleanTaskData();

   379         }

   380     

   381     

   382     StoreReply( reply );

   383     CleanupStack::Pop( reply ); 

   384  

   385     TRACE_FUNC_EXIT;

   386     }

   387 

   388 // -----------------------------------------------------------------------------

   389 // CSConPCD::GetStatus( TInt aTask, TBool aAll )

   390 // Collects a status of a specified task / all tasks

   391 // -----------------------------------------------------------------------------

   392 //

   393 TInt CSConPCD::GetStatusL( TInt aTask, TBool aAll )

   394     {

   395     TRACE_FUNC_ENTRY;

   396     TInt ret( KErrNone );

   397     

   398     // create mergeReply object. Store installer and br replys here.

   399     CSConStatusReply* mergeReply = new (ELeave) CSConStatusReply();

   400     CleanupStack::PushL( mergeReply );

   401             

   402     

   403     CSConStatusReply* brReply = new (ELeave) CSConStatusReply();

   404     CleanupStack::PushL( brReply );

   405     iBackupRestoreQueue->GetQueueStatusL( aTask, aAll, brReply );

   406     

   407     

   408     // Create installerReply and populate it

   409     CSConStatusReply* installerReply = new (ELeave) CSConStatusReply();

   410     CleanupStack::PushL( installerReply );

   411     iInstallerQueue->GetQueueStatusL( aTask, aAll, installerReply );

   412     

   413     if ( !installerReply->iNoTasks || !brReply->iNoTasks )

   414         {

   415         mergeReply->iNoTasks = EFalse;

   416         }

   417     else

   418         {

   419         mergeReply->iNoTasks = ETrue;

   420         }

   421         

   422     for ( TInt i = 0; i < installerReply->iTasks.Count(); i++ )

   423         {

   424         mergeReply->iTasks.Append( installerReply->iTasks[i]->CopyAndFreeL() );

   425         }

   426     

   427     // installer replys are copied to mergereply, delete installerReply

   428     CleanupStack::PopAndDestroy( installerReply );

   429     

   430     // do same for br reply

   431     for ( TInt j = 0; j < brReply->iTasks.Count(); j++ )

   432         {

   433         mergeReply->iTasks.Append( brReply->iTasks[j]->CopyAndFreeL() );

   434         }

   435     

   436     CleanupStack::PopAndDestroy( brReply );

   437     

   438     CleanupStack::Pop( mergeReply );

   439     // store reply

   440     StoreReply( mergeReply );

   441     

   442     LOGGER_WRITE_1( "CSConPCD::GetStatus() : returned %d", ret );

   443     return ret;

   444     }

   445         

   446 // -----------------------------------------------------------------------------

   447 // CSConPCD::Cancel( TInt aTask, TBool aAll )

   448 // Cancels a specified task / all tasks

   449 // -----------------------------------------------------------------------------

   450 //

   451 TInt CSConPCD::CancelL( TInt aTask, TBool aAll )

   452     {

   453     TRACE_FUNC_ENTRY;

   454     TInt ret( KErrNone );

   455     

   456     CSConStatusReply* reply = new (ELeave) CSConStatusReply();

   457     iInstallerQueue->CancelTask( aTask, aAll );

   458     iBackupRestoreQueue->CancelTask( aTask, aAll );

   459     

   460     reply->iNoTasks = ETrue;

   461     

   462     StoreReply( reply );

   463     

   464     LOGGER_WRITE_1( "CSConPCD::CancelL() : returned %d", ret );

   465     return ret;

   466     }

   467 

   468 // -----------------------------------------------------------------------------

   469 // CSConPCD::StoreReply( CSConStatusReply*& aReply )

   470 // Stores a reply

   471 // -----------------------------------------------------------------------------

   472 //

   473 void CSConPCD::StoreReply( CSConStatusReply*& aReply )  

   474     {

   475     TRACE_FUNC_ENTRY;

   476     if ( iLatestReply )

   477         {

   478         delete iLatestReply;

   479         iLatestReply = NULL;

   480         }

   481         

   482     iLatestReply = aReply;

   483     TRACE_FUNC_EXIT;

   484     }

   485 

   486 // -----------------------------------------------------------------------------

   487 // CSConPCD::UpdateDeviceInfo( TInt aMaxObjectSize )

   488 // Creates a reply for UpdateDeviceInfo task

   489 // -----------------------------------------------------------------------------

   490 //

   491 TInt CSConPCD::UpdateDeviceInfoL( TInt aMaxObjectSize )

   492     {

   493     TRACE_FUNC_ENTRY;

   494     TInt ret( KErrNone );

   495     TSConMethodName method( EUpdateDeviceInfo );

   496     

   497     CSConStatusReply* reply = new (ELeave) CSConStatusReply();

   498     CleanupStack::PushL( reply );

   499     CSConTaskReply* taskReply = new (ELeave) CSConTaskReply();

   500     CleanupStack::PushL( taskReply );

   501     

   502     

   503     TBool complete( ETrue );

   504     TInt progress( KSConCodeTaskCompleted );

   505     

   506     taskReply->InitializeL( method, progress, complete );

   507     taskReply->iTaskId = iTaskNumber;

   508         

   509     TInt arrayLength = sizeof KSupportedMethods / sizeof KSupportedMethods[0];

   510     

   511     for ( TInt i = 0; i < arrayLength; i++ )

   512         {

   513         switch( KSupportedMethods[i].method )

   514             {

   515             case EGetDataSize :

   516                 taskReply->iDevInfoParams->iGetSizeSupp = 

   517                 KSupportedMethods[i].support;

   518                 break;

   519             case EInstall :

   520                 taskReply->iDevInfoParams->iInstallSupp = 

   521                 KSupportedMethods[i].support;

   522                 break;

   523             case EListDataOwners :

   524                 taskReply->iDevInfoParams->iDataOwnersSupp = 

   525                 KSupportedMethods[i].support;

   526                 break;

   527             case EListInstalledApps :

   528                 taskReply->iDevInfoParams->iInstAppsSupp = 

   529                 KSupportedMethods[i].support;

   530                 break;

   531             case ERequestData :

   532                 taskReply->iDevInfoParams->iReqDataSupp = 

   533                 KSupportedMethods[i].support;

   534                 break;

   535             case ESetBURMode :

   536                 taskReply->iDevInfoParams->iSetBURModeSupp = 

   537                 KSupportedMethods[i].support;

   538                 break;

   539             case ESetInstParams :

   540                 taskReply->iDevInfoParams->iInstParamsSupp = 

   541                 KSupportedMethods[i].support;

   542                 break;

   543             case ESupplyData :

   544                 taskReply->iDevInfoParams->iSupplyDataSupp = 

   545                 KSupportedMethods[i].support;

   546                 break;

   547             case EUninstall :

   548                 taskReply->iDevInfoParams->iUninstallSupp = 

   549                 KSupportedMethods[i].support;

   550                 break;

   551             case EReboot :

   552                 taskReply->iDevInfoParams->iRebootSupp = 

   553                 KSupportedMethods[i].support;

   554                 break;

   555             default :

   556                 break;

   557             }

   558         }

   559     

   560     taskReply->iDevInfoParams->iVersion.Copy( KCONMLVERSION );

   561     taskReply->iDevInfoParams->iMaxObjectSize = 

   562         GetMaxObjectSize( aMaxObjectSize );

   563     

   564     reply->iNoTasks = EFalse;

   565 

   566     User::LeaveIfError( reply->iTasks.Append( taskReply ) );

   567     StoreReply( reply );

   568     

   569     CleanupStack::Pop( taskReply );

   570     CleanupStack::Pop( reply );

   571     LOGGER_WRITE_1( "CSConPCD::UpdateDeviceInfo() : returned %d", ret );

   572     return ret;

   573     }

   574     

   575 // -----------------------------------------------------------------------------

   576 // CSConPCD::GetMaxObjectSize( TInt /*aClientObjectSize*/ ) const

   577 // Gets the current max object size

   578 // -----------------------------------------------------------------------------

   579 //

   580 TInt CSConPCD::GetMaxObjectSize( TInt /*aClientObjectSize*/ ) const

   581     {

   582     LOGGER_WRITE_1( "CSConPCD::GetMaxObjectSize() : returned %d", iMaxObjectSize );

   583     return iMaxObjectSize;

   584     }

   585 

   586 // End of file