1 /*

     2 * Copyright (c) 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:  Network identity related prioritizer.

    15 *

    16 */

    17 

    18 

    19 #include "aipublishprioritizer.h"

    20 #include "ainwidpriorities.h"

    21 #include "aidevicestatuscontentmodel.h"

    22 #include <aicontentrequest.h>

    23 #include "aipropertyextension.h"

    24 #include "aipublisherbroadcaster.h"

    25 #include "debug.h"

    26 

    27 

    28 CAiPublishPrioritizer::CAiPublishPrioritizer( 

    29                                         MAiContentObserver& aContentObserver,

    30                                         MAiPropertyExtension& aPropertyExtension )

    31     : iContentObserver( aContentObserver ),

    32         iPropertyExtension( aPropertyExtension ),

    33         iPriority( EAiInvalidPriority )

    34     {

    35     }

    36 

    37 

    38 CAiPublishPrioritizer* CAiPublishPrioritizer::NewL( 

    39                                         MAiContentObserver& aContentObserver,

    40                                         MAiPropertyExtension& aPropertyExtension )

    41     {

    42     return new( ELeave ) CAiPublishPrioritizer( aContentObserver, 

    43                                                 aPropertyExtension );

    44     }

    45 

    46 

    47 CAiPublishPrioritizer::~CAiPublishPrioritizer()

    48     {

    49     }

    50 

    51 

    52 void CAiPublishPrioritizer::TryToPublishL( MAiPublisherBroadcaster& /*aBroadcaster*/, 

    53                                             TInt aContent, 

    54                                             TInt aResource, 

    55                                             TInt aPriority )

    56     {

    57     if( aPriority >= iPriority )

    58         {

    59         iPriority = aPriority;

    60         (void)iContentObserver.Publish( iPropertyExtension, 

    61                                             aContent, 

    62                                             aResource, 

    63                                             0 );

    64         }

    65     }

    66 

    67 

    68 void CAiPublishPrioritizer::TryToPublishL( MAiPublisherBroadcaster& /*aBroadcaster*/, 

    69                                             TInt aContent, 

    70                                             const TDesC16& aText, 

    71                                             TInt aPriority )

    72     {

    73     __PRINT(__DBG_FORMAT("XAI: prio publish - content %d, priority %d, text %S"), aContent, aPriority, &aText );

    74     

    75     if( aPriority >= iPriority )

    76         {

    77         __PRINTS("XAI: prio publish - priority check ok");

    78         iPriority = aPriority;

    79         (void)iContentObserver.Publish( iPropertyExtension, 

    80                                             aContent, 

    81                                             aText, 

    82                                             0 );

    83         }

    84         

    85     __PRINTS("XAI: prio publish - done");

    86     }

    87 

    88 

    89 void CAiPublishPrioritizer::TryToPublishL( MAiPublisherBroadcaster& /*aBroadcaster*/, 

    90                                             TInt aContent, 

    91                                             const TDesC8& aBuf, 

    92                                             TInt aPriority )

    93     {

    94     if( aPriority >= iPriority )

    95         {

    96         iPriority = aPriority;

    97         (void)iContentObserver.Publish( iPropertyExtension, 

    98                                             aContent, 

    99                                             aBuf, 

   100                                             0 );

   101         }

   102     }

   103                             

   104 

   105 void CAiPublishPrioritizer::TryToCleanL( MAiPublisherBroadcaster& aBroadcaster, 

   106                                         TInt aContent, 

   107                                         TInt aPriority )

   108     {

   109     __PRINT(__DBG_FORMAT("XAI: prio clean - content %d, priority %d"), aContent, aPriority );

   110     if( aPriority == EAiInvalidPriority )

   111         {

   112         // do nothing

   113         return;

   114         }

   115         

   116     else if( aPriority == iPriority )

   117         {

   118         __PRINTS("XAI: prio clean - priority matched");

   119         // Clean the current content...

   120         (void)iContentObserver.Clean( iPropertyExtension, aContent, 0 );

   121 

   122         TInt currentPriority = iPriority;

   123         iPriority = EAiInvalidPriority;

   124 

   125         TBool refreshed = EFalse;

   126         while( --currentPriority != EAiInvalidPriority && !refreshed )

   127         	{

   128         	__PRINT(__DBG_FORMAT("XAI: prio clean - refreshing %d"), currentPriority );

   129         	refreshed = aBroadcaster.RefreshPriorizedPublishersL( aContent, 

   130         	                                                currentPriority );

   131         	if( refreshed )

   132         	    {

   133                 __PRINTS("XAI: prio clean - refresh success");        	    

   134         	    }

   135         	else

   136         	    {

   137                 __PRINTS("XAI: prio clean - refresh failed");        	    

   138         	    }

   139         	}

   140         }

   141     }