1 /*

     2 * Copyright (c) 2006-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:  Engine class for Device Status Plug-in

    15 *

    16 */

    17 

    18 

    19 #include "aidevicestatuspluginengine.h"

    20 #include "aipublisherfactory.h"

    21 #include "aidevicestatuspublisher.h"

    22 

    23 CAiDeviceStatusPluginEngine::CAiDeviceStatusPluginEngine( 

    24                                             MAiContentObserver& aObserver, 

    25 											MAiPropertyExtension& aExtension,

    26                                             MAiPublishPrioritizer& aPrioritizer )

    27     : iContentObserver( &aObserver ), 

    28         iExtension( &aExtension ), 

    29         iPrioritizer( &aPrioritizer )

    30 	{	

    31 	}

    32 

    33 

    34 void CAiDeviceStatusPluginEngine::ConstructL()

    35     {

    36     // Instantiate all publishers via factory

    37     MAiDeviceStatusPublisher* publisher = AiPublisherFactory::CreateProfilePublisherL();

    38     CleanupStack::PushL( publisher );

    39     AddPublisherL( publisher );

    40     CleanupStack::Pop( publisher );

    41 

    42     publisher = AiPublisherFactory::CreateDatePublisherL();

    43     CleanupStack::PushL( publisher );

    44     AddPublisherL( publisher );

    45     CleanupStack::Pop( publisher );

    46 

    47     publisher = AiPublisherFactory::CreateSimRegPublisherL();

    48     CleanupStack::PushL( publisher );

    49     AddPublisherL( publisher );

    50     CleanupStack::Pop( publisher );

    51 

    52     publisher = AiPublisherFactory::CreateNWSPublisherL();

    53     CleanupStack::PushL( publisher );

    54     AddPublisherL( publisher );

    55     CleanupStack::Pop( publisher );

    56 

    57     publisher = AiPublisherFactory::CreateBTSAPPublisherL();

    58     CleanupStack::PushL( publisher );

    59     AddPublisherL( publisher );

    60     CleanupStack::Pop( publisher );

    61 

    62     publisher = AiPublisherFactory::CreateOperatorLogoPublisherL();

    63     CleanupStack::PushL( publisher );

    64     AddPublisherL( publisher );

    65     CleanupStack::Pop( publisher );

    66 

    67     publisher = AiPublisherFactory::CreateOperatorNamePublisherL();

    68     CleanupStack::PushL( publisher );

    69     AddPublisherL( publisher );

    70     CleanupStack::Pop( publisher );

    71 

    72     publisher = AiPublisherFactory::CreateMCNPublisherL();

    73     CleanupStack::PushL( publisher );

    74     AddPublisherL( publisher );

    75     CleanupStack::Pop( publisher );

    76 

    77     publisher = AiPublisherFactory::CreateCUGPublisherL();

    78     CleanupStack::PushL( publisher );

    79     AddPublisherL( publisher );

    80     CleanupStack::Pop( publisher );

    81 

    82     publisher = AiPublisherFactory::CreateVHZPublisherL();

    83     CleanupStack::PushL( publisher );

    84     AddPublisherL( publisher );

    85     CleanupStack::Pop( publisher );

    86     

    87     publisher = AiPublisherFactory::CreateCUGMCNPublisherL();

    88     CleanupStack::PushL( publisher );

    89     AddPublisherL( publisher );

    90     CleanupStack::Pop( publisher );

    91 

    92     // Subscribe all publishers once they are instantiated

    93     const TInt count = iPublishers.Count();

    94 

    95     for( TInt i( 0 ); i < count; i++ )

    96         {

    97         iPublishers[i]->Subscribe( *iContentObserver, 

    98                                     *iExtension, 

    99                                     *iPrioritizer, 

   100                                     *this );

   101         }    

   102     }

   103 

   104 

   105 CAiDeviceStatusPluginEngine* CAiDeviceStatusPluginEngine::NewL( 

   106                                             MAiContentObserver& aObserver, 

   107 											MAiPropertyExtension& aExtension,

   108                                             MAiPublishPrioritizer& aPrioritizer)

   109     {

   110     CAiDeviceStatusPluginEngine* self = 

   111     	new( ELeave ) CAiDeviceStatusPluginEngine( aObserver, 

   112 											        aExtension,

   113                                                     aPrioritizer);

   114     CleanupStack::PushL( self );

   115     self->ConstructL();

   116     CleanupStack::Pop( self );

   117     return self;

   118     }

   119 

   120 

   121 CAiDeviceStatusPluginEngine::~CAiDeviceStatusPluginEngine()

   122     {

   123     iPublishers.ResetAndDestroy();

   124     }

   125 

   126 

   127 void CAiDeviceStatusPluginEngine::AddPublisherL( MAiDeviceStatusPublisher* aPublisher )

   128     {

   129 	//Add publisher to list.

   130     if( aPublisher )

   131         {

   132         CleanupDeletePushL( aPublisher );

   133         User::LeaveIfError( iPublishers.Append( aPublisher ) );

   134         CleanupStack::Pop(aPublisher);//aPublisher

   135         }

   136     }

   137 

   138 

   139 void CAiDeviceStatusPluginEngine::ResumePublishersL()

   140 	{

   141     const TInt count = iPublishers.Count();

   142 

   143     for( TInt i( 0 ); i < count; i++ )

   144         {

   145         iPublishers[i]->ResumeL();

   146         }    

   147 	}

   148 

   149 

   150 void CAiDeviceStatusPluginEngine::RefreshPublishersL( TBool aClean )

   151 	{

   152 	iContentObserver->StartTransaction( KImplUidDevStaPlugin );

   153 

   154     const TInt count = iPublishers.Count();

   155 

   156     for( TInt i( 0 ); i < count; i++ )

   157         {

   158         iPublishers[i]->RefreshL( aClean );

   159         }    

   160         

   161 	iContentObserver->Commit( KImplUidDevStaPlugin );

   162 	}

   163 

   164 

   165 TBool CAiDeviceStatusPluginEngine::RefreshPublishersL( TInt aContentId, 

   166                                                         TBool aClean )

   167 	{

   168 	TBool success = EFalse;

   169 	

   170 	iContentObserver->StartTransaction( KImplUidDevStaPlugin );

   171 

   172     const TInt count = iPublishers.Count();

   173 

   174     for( TInt i( 0 ); i < count; i++ )

   175         {

   176         if( iPublishers[i]->RefreshL( aContentId, aClean ) )

   177             {

   178             success = ETrue;

   179             }

   180         }

   181 

   182     if ( success )

   183     	{

   184     	iContentObserver->Commit( KImplUidDevStaPlugin );

   185     	}

   186     else

   187         {

   188         iContentObserver->CancelTransaction( KImplUidDevStaPlugin );

   189         }

   190 

   191     return success;

   192 	}

   193 

   194 

   195 TBool CAiDeviceStatusPluginEngine::RefreshPriorizedPublishersL( TInt aContentId,

   196                                                                 TInt aPriority )

   197 	{

   198 	iContentObserver->StartTransaction( KImplUidDevStaPlugin );

   199 	TBool success = EFalse;

   200     const TInt count = iPublishers.Count();

   201 

   202     for( TInt i( 0 ); i < count; i++ )

   203         {

   204         if( iPublishers[i]->RefreshContentWithPriorityL( aContentId,

   205                                                             aPriority ) )

   206             {

   207             success = ETrue;

   208             break;

   209             }

   210         }

   211     if ( success )

   212         {

   213         iContentObserver->Commit( KImplUidDevStaPlugin );

   214         }

   215     else

   216         {

   217         iContentObserver->CancelTransaction( KImplUidDevStaPlugin );

   218         }

   219     return success;

   220 	}

   221