1 /*

     2 * Copyright (c) 2002-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:  Creator and user of ASY threads

    15 *

    16 */

    17 

    18 

    19 // INCLUDE FILES

    20 #include "ASYProxyMainService.h"

    21 #include "ASYProxyCommsService.h"

    22 #include "ASYProxyAsyHandler.h"

    23 #include "acc_debug.h"

    24 #include <e32svr.h>

    25 #include <e32std.h>

    26 

    27 // EXTERNAL DATA STRUCTURES

    28 

    29 // EXTERNAL FUNCTION PROTOTYPES

    30 

    31 // CONSTANTS

    32 

    33 // MACROS

    34 

    35 // LOCAL CONSTANTS AND MACROS

    36 

    37 // MODULE DATA STRUCTURES

    38 

    39 // LOCAL FUNCTION PROTOTYPES

    40 

    41 // FORWARD DECLARATIONS

    42 

    43 // ============================= LOCAL FUNCTIONS ===============================

    44 

    45 // ============================ MEMBER FUNCTIONS ===============================

    46 

    47 // -----------------------------------------------------------------------------

    48 // CASYProxyMainService::CASYProxyMainService

    49 // C++ default constructor can NOT contain any code, that

    50 // might leave.

    51 // -----------------------------------------------------------------------------

    52 //

    53 CASYProxyMainService::CASYProxyMainService( CASYProxyASYHandler* aAsyHandler ) :

    54                       CActive( CActive::EPriorityStandard ),

    55                       iAsyHandler( aAsyHandler )

    56     {

    57     COM_TRACE_1( "[AccFW:AsyProxy] CASYProxyMainService::CASYProxyMainService(aAsyHandler == 0x%x)", aAsyHandler );

    58 

    59     CActiveScheduler::Add(this);

    60 

    61     COM_TRACE_( "[AccFW:AsyProxy] CASYProxyMainService::CASYProxyMainService" );

    62     }

    63 

    64 // -----------------------------------------------------------------------------

    65 // CASYProxyMainService::ConstructL

    66 // Symbian 2nd phase constructor can leave.

    67 // -----------------------------------------------------------------------------

    68 //

    69 void CASYProxyMainService::ConstructL()

    70     {

    71     COM_TRACE_( "[AccFW:AsyProxy] CASYProxyMainService::ConstructL()" );

    72 

    73     iAsyHandler->UpdateASYStateL( EASYProxyASYInitial );

    74 

    75     COM_TRACE_( "[AccFW:AsyProxy] CASYProxyMainService::ConstructL - return void" );

    76     }

    77 

    78 // -----------------------------------------------------------------------------

    79 // CASYProxyMainService::NewL

    80 // Two-phased constructor.

    81 // -----------------------------------------------------------------------------

    82 //

    83 CASYProxyMainService* CASYProxyMainService::NewL( CASYProxyASYHandler* aAsyHandler )

    84     {

    85     COM_TRACE_1( "[AccFW:AsyProxy] CASYProxyMainService::NewL(0x%x)", aAsyHandler );

    86 

    87     CASYProxyMainService* self = new ( ELeave ) CASYProxyMainService( aAsyHandler );

    88     CleanupStack::PushL( self );

    89     self->ConstructL();

    90     CleanupStack::Pop( self );

    91 

    92     COM_TRACE_1( "[AccFW:AsyProxy] CASYProxyMainService::NewL - return 0x%x", self );

    93 

    94     return self;

    95     }

    96 

    97 // Destructor

    98 CASYProxyMainService::~CASYProxyMainService()

    99     {

   100     COM_TRACE_( "[AccFW:AsyProxy] CASYProxyMainService::~CASYProxyMainService()" );

   101     Cancel();

   102     iThread.Close ();

   103     COM_TRACE_( "[AccFW:AsyProxy] CASYProxyMainService::~CASYProxyMainService" );

   104     }

   105 

   106 // -----------------------------------------------------------------------------

   107 // CASYProxyMainService::RunL

   108 // Has three different cases:

   109 // - case for TASYThreadSyncLoadOkSignalNOk

   110 // - case for TASYThreadSyncLoadOkSignalOk

   111 // - case for TASYProxyASYStateThreadKills

   112 // (other items were commented in a header).

   113 // -----------------------------------------------------------------------------

   114 //

   115 void CASYProxyMainService::RunL()

   116     {

   117     COM_TRACE_( "[AccFW:AsyProxy] CASYProxyMainService::RunL()" );

   118 

   119 #ifdef _DEBUG

   120 /* coverity[var_compare_op] */ 

   121     if ( iAsyHandler )

   122         {

   123         COM_TRACE_1( "[AccFW:AsyProxy] CASYProxyMainService::RunL - iAsyIndex == %d", iAsyHandler->Index() );

   124         }

   125 

   126 #endif // _DEBUG

   127 

   128     COM_TRACE_1( "[AccFW:AsyProxy] CASYProxyMainService::RunL - iStatus == %d", iStatus.Int() );

   129 

   130     if ( iStatus.Int() == EASYThreadSyncLoadOkSignalNOk )

   131         {

   132         // Asynchronous ASY :

   133         // Synchronous load part is complete

   134         iAsyHandler->UpdateASYStateL( EASYProxyASYSynchronousLoadComplete );

   135 

   136         // ---------------------------------------------------------------------

   137         // Rendez vous for waiting...

   138         //

   139         // Case of Asynchronous ASY :

   140         // - Make this AO active waiting for Async complete after Sync complete

   141         // ---------------------------------------------------------------------

   142         //

   143         // ---------------------------------------------------------------------

   144         // Rendez vous

   145         // ---------------------------------------------------------------------

   146 

   147         iStatus = KRequestPending;

   148         SetActive();

   149         iThread.Rendezvous( iStatus );

   150 

   151         // ---------------------------------------------------------------------

   152         // End of Rendez vous for...

   153         // ---------------------------------------------------------------------

   154         }

   155 

   156     else if ( iStatus.Int() == EASYThreadSyncLoadOkSignalOk )

   157         {

   158         // Synchronous ASY :

   159         // Synchronous load part is now complete

   160         // Also ASY loading is totally complete

   161 

   162         // Asynchronous ASY :

   163         // Synchronous load part was earlier complete

   164         // Asynchronous load part is now complete

   165         // Also ASY loading is totally complete

   166         

   167         iAsyHandler->UpdateASYStateL( EASYProxyASYConnectionReady );

   168 

   169         // ---------------------------------------------------------------------

   170         // Rendez vous for waiting...

   171         //

   172         // Case of Synchronous ASY :

   173         // - Make this AO active waiting for ASY Panic

   174         //

   175         // Case of Asynchronous ASY :

   176         // - Make this AO active waiting for ASY Panic

   177         // ---------------------------------------------------------------------

   178         //

   179 

   180         // ---------------------------------------------------------------------

   181         // Logon

   182         // ---------------------------------------------------------------------

   183 

   184         iStatus = KRequestPending;

   185         SetActive();

   186         iThread.Logon( iStatus );

   187         

   188         // ---------------------------------------------------------------------

   189         // End of Logon...

   190         // ---------------------------------------------------------------------

   191         }

   192 

   193     else

   194         {

   195         iAsyHandler->UpdateASYStateL( EASYProxyASYThreadKills );

   196         }

   197 

   198     COM_TRACE_( "[AccFW:AsyProxy] CASYProxyMainService::RunL - return void" );

   199     }

   200     

   201 // -----------------------------------------------------------------------------

   202 // CASYProxyMainService::RunError

   203 // Returns KErrNone

   204 // (other items were commented in a header).

   205 // -----------------------------------------------------------------------------

   206 //

   207 TInt CASYProxyMainService::RunError( TInt aError )

   208     {

   209     COM_TRACE_1( "[AccFW:AsyProxy] CASYProxyMainService::RunError(%d)", aError );

   210 

   211      // Avoid Panic in CActiveScheduler

   212     aError = KErrNone;

   213 

   214     COM_TRACE_( "[AccFW:AsyProxy] CASYProxyMainService::RunError - return KErrNone" );

   215 

   216     return aError;

   217     }

   218 

   219 // -----------------------------------------------------------------------------

   220 // CASYProxyMainService::DoCancel

   221 // Kills the ASY thread

   222 // (other items were commented in a header).

   223 // -----------------------------------------------------------------------------

   224 //

   225 void CASYProxyMainService::DoCancel()

   226     {

   227     COM_TRACE_( "[AccFW:AsyProxy] CASYProxyMainService::DoCancel()" );

   228 

   229     iThread.RendezvousCancel( iStatus );

   230     TExitType threadExitType = iThread.ExitType();

   231     if ( EExitPending == threadExitType)

   232         {

   233         iThread.Kill( KErrCancel );

   234         iThread.Close();

   235         }

   236 

   237     COM_TRACE_( "[AccFW:AsyProxy] CASYProxyMainService::DoCancel - return void" );

   238     }

   239 

   240 // -----------------------------------------------------------------------------

   241 // CASYProxyMainService::StartThreadL

   242 // Creates a new thread

   243 // (other items were commented in a header).

   244 // -----------------------------------------------------------------------------

   245 //

   246 void CASYProxyMainService::StartThreadL(

   247                            const TUid aMainServiceUid,

   248                            const TUid aHandlerUid,

   249                            const TInt aHeapSize,

   250                            const TInt aStackSize )

   251     {

   252     COM_TRACE_1( "[AccFW:AsyProxy] CASYProxyMainService::StartThreadL(aMainServiceUid == 0x%x)", aMainServiceUid.iUid );

   253     COM_TRACE_1( "[AccFW:AsyProxy] CASYProxyMainService::StartThreadL(aHandlerUid == 0x%x)", aHandlerUid.iUid );

   254     COM_TRACE_1( "[AccFW:AsyProxy] CASYProxyMainService::StartThreadL(aHeapSize == 0x%x)", aHeapSize );

   255     COM_TRACE_1( "[AccFW:AsyProxy] CASYProxyMainService::StartThreadL(aStackSize == 0x%x)", aStackSize );

   256 

   257     iAsyHandler->UpdateASYStateL( EASYProxyASYThreadCreating );

   258 

   259     TASYProxyThreadParam param;

   260     RSemaphore semaphore;

   261     User::LeaveIfError( semaphore.CreateLocal( 0 ) );

   262     CleanupClosePushL( semaphore );

   263     param.iSemaphore = &semaphore;

   264     param.iThreadMainServiceUid = aMainServiceUid;

   265     param.iThreadHandlerUid     = aHandlerUid;

   266 

   267     // Generate unique thread name

   268     HBufC* bufThreadName = HBufC::NewL( KASYThreadName().Length() + KMaxUidName );

   269 

   270     CleanupStack::PushL( bufThreadName );

   271     TPtr ptrThreadName = bufThreadName->Des();

   272     ptrThreadName = KASYThreadName;

   273     ptrThreadName.Append( aMainServiceUid.Name() );

   274 

   275     COM_TRACE_1( "[AccFW:AsyProxy] CASYProxyMainService::StartThreadL(%S)", &ptrThreadName );

   276  

   277     User::LeaveIfError( iThread.Create(

   278                         ptrThreadName,

   279                         ThreadEntryPoint,

   280                         aStackSize,

   281                         KMinHeapSize,

   282                         aHeapSize,

   283                         &param ) );

   284 

   285     CleanupStack::Pop ( bufThreadName );

   286 

   287     delete bufThreadName;

   288 

   289     if ( aHandlerUid.iUid != ZEROHANDLERUID )

   290         {

   291         iThread.SetPriority( EPriorityMore );

   292         }

   293 

   294     // ---------------------------------------------------------------------

   295     // Rendez vous

   296     // ---------------------------------------------------------------------

   297 

   298     iStatus = KRequestPending;

   299     iThread.Rendezvous( iStatus );

   300 

   301     // ---------------------------------------------------------------------

   302     // End of Rendez vous

   303     // ---------------------------------------------------------------------

   304 

   305     SetActive();

   306     iThread.Resume();

   307     semaphore.Wait();

   308     CleanupStack::PopAndDestroy( &semaphore );

   309 

   310     COM_TRACE_( "[AccFW:AsyProxy] CASYProxyMainService::StartThreadL - return void" );

   311     }

   312 

   313 // -----------------------------------------------------------------------------

   314 // CASYProxyMainService::ThreadEntryPoint

   315 // Entry point of new thread

   316 // (other items were commented in a header).

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

   318 //

   319 TInt CASYProxyMainService::ThreadEntryPoint( TAny* aParameter )

   320     {

   321     COM_TRACE_1( "[AccFW:AsyProxy] CASYProxyMainService::ThreadEntryPoint(0x%x)", &aParameter );

   322 

   323     TInt err = KErrNone;

   324 

   325     //create cleanupstack

   326     CTrapCleanup* cleanup = CTrapCleanup::New(); // get clean-up stack

   327     if ( !cleanup )

   328         err = KErrNoMemory;

   329 

   330     if ( !err )

   331         {

   332         TASYProxyThreadParam* Param = ( TASYProxyThreadParam* ) aParameter;

   333 

   334         TUid MainServiceUid = Param->iThreadMainServiceUid;

   335         TUid HandlerUid     = Param->iThreadHandlerUid;

   336 

   337         Param->iSemaphore->Signal();

   338 

   339         TRAP( err, DoStartThreadL( MainServiceUid, HandlerUid ) );

   340         }

   341     delete cleanup;

   342 

   343     COM_TRACE_1( "[AccFW:AsyProxy] CASYProxyMainService::ThreadEntryPoint - return %d", err );

   344 

   345     return err;

   346     }

   347 

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

   349 // CASYProxyMainService::DoStartThreadL

   350 // Starts new thread by creating and starting active scheduler

   351 // (other items were commented in a header).

   352 // -----------------------------------------------------------------------------

   353 //

   354 TInt CASYProxyMainService::DoStartThreadL(

   355                            const TUid aMainServiceUid,

   356                            const TUid aHandlerUid )

   357     {

   358     COM_TRACE_1( "[AccFW:AsyProxy] CASYProxyMainService::DoStartThreadL(aMainServiceUid == 0x%x)", aMainServiceUid.iUid );

   359     COM_TRACE_1( "[AccFW:AsyProxy] CASYProxyMainService::DoStartThreadL(aHandlerUid == 0x%x)", aHandlerUid.iUid );

   360 

   361     CActiveScheduler* actSched = new ( ELeave ) CActiveScheduler;

   362     CleanupStack::PushL( actSched );

   363     CActiveScheduler::Install( actSched );

   364 

   365     TInt res = CreateAsyServicesLC( aMainServiceUid, aHandlerUid );

   366 

   367     CActiveScheduler::Start();

   368 

   369     CleanupStack::PopAndDestroy( 2, actSched ); // asyMainService, actSched

   370 

   371     COM_TRACE_1( "[AccFW:AsyProxy] CASYProxyMainService::DoStartThreadL - return %d", res );

   372 

   373     return ( res );

   374     }

   375 

   376 // -----------------------------------------------------------------------------

   377 // CASYProxyMainService::CreateAsyServicesLC

   378 // Creates a new ASYProxyCommsService and CASYMainServiceBase -instances

   379 // Starts the instance of CASYMainServiceBase

   380 // (other items were commented in a header).

   381 // -----------------------------------------------------------------------------

   382 //

   383 TInt CASYProxyMainService::CreateAsyServicesLC(

   384                            const TUid aMainServiceUid,

   385                            const TUid aHandlerUid )

   386     {

   387     COM_TRACE_1( "[AccFW:AsyProxy] CASYProxyMainService::CreateAsyServicesLC(aMainServiceUid == 0x%x)", aMainServiceUid.iUid );

   388     COM_TRACE_1( "[AccFW:AsyProxy] CASYProxyMainService::CreateAsyServicesLC(aHandlerUid == 0x%x)", aHandlerUid.iUid );

   389     

   390     CASYProxyCommsService* asyProxyCommsService = NULL;

   391 

   392     asyProxyCommsService = CASYProxyCommsService::NewL( aHandlerUid, aMainServiceUid );

   393     CleanupStack::PushL( asyProxyCommsService );

   394 

   395     // asyProxyCommsService will be deleted in CASYMainServiceBase's destructor

   396     CASYMainServiceBase* asyMainService = CASYMainServiceBase::NewL(

   397                                                asyProxyCommsService,

   398                                                aMainServiceUid );

   399 

   400     asyProxyCommsService->iAsyMainServiceBase = asyMainService; 

   401     CleanupStack::Pop( asyProxyCommsService );

   402 

   403     CleanupStack::PushL( asyMainService );

   404 

   405     COM_TRACE_( "[AccFW:AsyProxy] CASYProxyMainService::CreateAsyServicesLC - next call StartL" );

   406     TInt res = asyMainService->StartL();

   407 

   408     asyMainService->iGlobalParams.iStartlFlag = ETrue;

   409 

   410     if ( asyMainService->iGlobalParams.iSignalFlag != EFalse ) // Synchronous ASY

   411     // --------------------------------------------------------------------------

   412         {

   413         asyMainService->iGlobalParams.iThreadStatus = EASYThreadSyncLoadOkSignalOk;

   414         RThread::Rendezvous( asyMainService->iGlobalParams.iThreadStatus );

   415         }

   416     else // Asynchronous ASY

   417     // --------------------------------------------------------------------------

   418         {

   419         asyMainService->iGlobalParams.iThreadStatus = EASYThreadSyncLoadOkSignalNOk;

   420         RThread::Rendezvous( asyMainService->iGlobalParams.iThreadStatus );

   421         }

   422 

   423     COM_TRACE_1( "[AccFW:AsyProxy] CASYProxyMainService::CreateAsyServicesLC - return %d", res );

   424 

   425     return res;

   426     }

   427 

   428 // ========================== OTHER EXPORTED FUNCTIONS =========================

   429 

   430 // End of File