1 /*

     2 * Copyright (c) 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:

    15 * CWmWidgetData implementation.

    16 *

    17 */

    18 

    19 

    20 // INCLUDE FILES

    21 #include <fbs.h>

    22 #include <bautils.h>

    23 #include <s32file.h>

    24 #include <hscontentinfo.h>

    25 #include <widgetregistryclient.h> // widgetreqistry

    26 #include <eikenv.h>

    27 #include <avkon.mbg>

    28 #include <avkon.rsg>

    29 #include <AknsDrawUtils.h>

    30 #include <AknBitmapAnimation.h>

    31 #include <barsread.h>

    32 #include <widgetmanagerview.rsg>

    33 

    34 #include "wmwidgetdata.h"

    35 #include "wmwidgetdataobserver.h"

    36 #include "wmpersistentwidgetorder.h"

    37 #include "wmresourceloader.h"

    38 #include "wmcommon.h"

    39 #include "wmimageconverter.h"

    40 

    41 // ---------------------------------------------------------

    42 // CWmWidgetData::NewL

    43 // ---------------------------------------------------------

    44 //

    45 CWmWidgetData* CWmWidgetData::NewL(

    46         const TSize& aLogoSize,

    47         CWmResourceLoader& aWmResourceLoader,

    48         CHsContentInfo* aHsContentInfo,

    49         RWidgetRegistryClientSession* aRegistryClientSession )

    50     {

    51     CWmWidgetData* self = CWmWidgetData::NewLC( 

    52             aLogoSize, aWmResourceLoader,

    53             aHsContentInfo, aRegistryClientSession );

    54     CleanupStack::Pop(); // self;

    55     return self;

    56     }

    57 

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

    59 // CWmWidgetData::NewLC

    60 // ---------------------------------------------------------

    61 //

    62 CWmWidgetData* CWmWidgetData::NewLC(

    63         const TSize& aLogoSize,

    64         CWmResourceLoader& aWmResourceLoader,

    65         CHsContentInfo* aHsContentInfo,

    66         RWidgetRegistryClientSession* aRegistryClientSession )

    67     {

    68     CWmWidgetData* self = new ( ELeave ) CWmWidgetData( 

    69             aLogoSize, aWmResourceLoader );

    70     CleanupStack::PushL(self);

    71     self->ConstructL( aHsContentInfo, aRegistryClientSession );

    72     return self;

    73     }

    74 

    75 // ---------------------------------------------------------

    76 // CWmWidgetData::CWmWidgetData

    77 // ---------------------------------------------------------

    78 //

    79 CWmWidgetData::CWmWidgetData( const TSize& aLogoSize, 

    80         CWmResourceLoader& aWmResourceLoader )

    81     : iWmResourceLoader( aWmResourceLoader )

    82     {

    83     iLogoImage = NULL;    

    84     iLogoImageMask = NULL;

    85     iHsContentInfo = NULL;

    86     iWidgetType = CWmWidgetData::EUnknown;

    87     iWrtType = CWmWidgetData::EUnIdentified;

    88     iPublisherUid = KNullUid;

    89     iLogoSize = aLogoSize;

    90     iAnimationTimer = NULL;

    91     iAnimationIndex = 0;

    92     iAsyncUninstalling = EFalse;

    93     iMdcaPoint = NULL;

    94     }

    95 

    96 // ---------------------------------------------------------

    97 // CWmWidgetData::ConstructL

    98 // ---------------------------------------------------------

    99 //

   100 void CWmWidgetData::ConstructL(         

   101         CHsContentInfo* aHsContentInfo,

   102         RWidgetRegistryClientSession* aRegistryClientSession )

   103     {

   104     // start decoding the icon

   105 	iImageConverter = CWmImageConverter::NewL();

   106     iAnimationTimer = CPeriodic::NewL( CActive::EPriorityStandard );

   107 

   108     InitL( aHsContentInfo, aRegistryClientSession );

   109     

   110     // start logo handling

   111     HandleIconString( HsContentInfo().IconPath() );

   112     }

   113 

   114 // ---------------------------------------------------------

   115 // CWmWidgetData::InitL

   116 // ---------------------------------------------------------

   117 //

   118 void CWmWidgetData::InitL(

   119         CHsContentInfo* aHsContentInfo,

   120         RWidgetRegistryClientSession* aRegistryClientSession )

   121     {

   122     // analyse the widget type

   123     if ( aHsContentInfo->Type() == KContentTemplate )

   124         {

   125         iWidgetType = CWmWidgetData::ECps; // wrt widgets included in this gategory

   126         }

   127     else if ( aHsContentInfo->Type() == KContentWidget )

   128         {

   129         iWidgetType = CWmWidgetData::ENative;

   130         }

   131 

   132     // get publisher uid from widget registry

   133     FetchPublisherUidL( aHsContentInfo->PublisherId(), 

   134                         aRegistryClientSession );

   135     

   136     // create iMdcaPoint for listbox    

   137     _LIT( KFormatStr, "0\t%S");

   138     iMdcaPoint = HBufC::NewL( 

   139             aHsContentInfo->Name().Length() + KFormatStr().Length() );

   140     iMdcaPoint->Des().Format( KFormatStr(), &aHsContentInfo->Name() );

   141 

   142     // take ownership of the content info

   143     iHsContentInfo = aHsContentInfo;

   144     }

   145 

   146 // ---------------------------------------------------------

   147 // CWmWidgetData::~CWmWidgetData

   148 // ---------------------------------------------------------

   149 //

   150 CWmWidgetData::~CWmWidgetData()

   151     {

   152     SetObserver( NULL );

   153     DestroyAnimData();

   154     delete iAnimationTimer;

   155     delete iLogoImage;

   156     delete iLogoImageMask;

   157     delete iImageConverter;

   158     delete iHsContentInfo;

   159     delete iMdcaPoint;

   160     }

   161 

   162 // ---------------------------------------------------------

   163 // CWmWidgetData::SetObserver

   164 // ---------------------------------------------------------

   165 //

   166 void CWmWidgetData::SetObserver( MWmWidgetDataObserver* aObserver )

   167     {

   168     iObserver = aObserver;

   169     }

   170 

   171 // ---------------------------------------------------------

   172 // CWmWidgetData::SetObserver

   173 // ---------------------------------------------------------

   174 //

   175 void CWmWidgetData::SetPersistentWidgetOrder(

   176         const CWmPersistentWidgetOrder* aPersistentWidgetOrder )

   177     {

   178     iPersistentWidgetOrder = aPersistentWidgetOrder;

   179     }

   180 

   181 // ---------------------------------------------------------

   182 // CWmWidgetData::EqualsTo

   183 // ---------------------------------------------------------

   184 //

   185 TBool CWmWidgetData::EqualsTo( CHsContentInfo& aContentInfo )

   186     {

   187     return (

   188         HsContentInfo().Uid() == aContentInfo.Uid() &&

   189         HsContentInfo().PublisherId() == aContentInfo.PublisherId() );

   190     }

   191 

   192 // ---------------------------------------------------------

   193 // CWmWidgetData::CompareByName

   194 // ---------------------------------------------------------

   195 //

   196 TInt CWmWidgetData::CompareByName( 

   197         const CWmWidgetData& aDataOne, const CWmWidgetData& aDataTwo )

   198     {

   199     // negate the result for ascending alphabetical order

   200     TInt result = aDataOne.Name().CompareC( aDataTwo.Name() );

   201     return result;

   202     }

   203 

   204 // ---------------------------------------------------------

   205 // CWmWidgetData::CompareByPersistentWidgetOrder

   206 // ---------------------------------------------------------

   207 //

   208 TInt CWmWidgetData::CompareByPersistentWidgetOrder( 

   209         const CWmWidgetData& aDataOne, const CWmWidgetData& aDataTwo )

   210     {

   211     TInt result;

   212     const CWmPersistentWidgetOrder* order = aDataOne.iPersistentWidgetOrder;

   213     if ( order && !order->IsEmpty() )

   214         {

   215         result = order->IndexOf( aDataOne ) - order->IndexOf( aDataTwo );

   216         }

   217     else

   218         {

   219         // fallback: if persistent widget order is not available

   220         // or it is empty (this is the case on first start, or if the persistent

   221         // file is corrupted or deleted) -> order widgets by name.

   222         result = CompareByName( aDataOne, aDataTwo );

   223         }

   224     return result;

   225     }

   226 

   227 // ---------------------------------------------------------

   228 // CWmWidgetData::HandleIconString

   229 // ---------------------------------------------------------

   230 //

   231 void CWmWidgetData::HandleIconString( const TDesC& aIconStr )

   232     {

   233     HBufC* iconStr = NULL;

   234     if ( aIconStr.Length() == 0 && 

   235         iPublisherUid != KNullUid )

   236         {

   237         // workaround for wrt widgets icon

   238         _LIT( KUidTag, "uid(0x%x)" );

   239         const TInt KLength = 32;

   240         TBuf<KLength> uidBuf;

   241         uidBuf.Format( KUidTag, iPublisherUid.iUid );

   242         iconStr = uidBuf.Alloc();

   243         }

   244     else

   245         {

   246         iconStr = aIconStr.Alloc();

   247         }

   248     

   249     // nothing to do if no iconstr

   250     if ( !iconStr ){ return; }

   251 

   252     TSize size( iLogoSize );

   253     if ( iLogoImage ) { size = iLogoImage->SizeInPixels(); }

   254     if ( size != iLogoSize &&

   255         iLogoSize.iWidth > 0 && iLogoSize.iHeight > 0 )

   256         {

   257         size = iLogoSize;

   258         }

   259     

   260     iImageConverter->HandleIconString( 

   261             size, 

   262             *iconStr, 

   263             iLogoImage, 

   264             iLogoImageMask );

   265     

   266     delete iconStr;

   267     iconStr = NULL;

   268     

   269     FireDataChanged(); // draw default icon

   270     }

   271 

   272 // ---------------------------------------------------------

   273 // CWmWidgetData::FireDataChanged

   274 // ---------------------------------------------------------

   275 //

   276 void CWmWidgetData::FireDataChanged()

   277     {

   278     if ( iObserver )

   279         {

   280         iObserver->HandleWidgetDataChanged( this );

   281         }

   282     }

   283 

   284 // ----------------------------------------------------

   285 // CWmWidgetData::UidFromString

   286 // ----------------------------------------------------

   287 //

   288 TUid CWmWidgetData::UidFromString( const TDesC8& aUidString ) const

   289     {

   290     TUid uid( TUid::Null() );

   291     const TInt KHexPrefixLength = 2;

   292     if ( aUidString.Length() > KHexPrefixLength )

   293         {

   294         TUint id = 0;

   295         TLex8 lex( aUidString.Mid( KHexPrefixLength ) );

   296         if ( lex.Val( id, EHex ) == KErrNone )

   297             {

   298             uid.iUid = (TInt32)id;

   299             }

   300         }

   301     return uid;

   302     }

   303 

   304 // ----------------------------------------------------

   305 // CWmWidgetData::PublisherUid

   306 // ----------------------------------------------------

   307 //

   308 TUid CWmWidgetData::PublisherUid()

   309     {    

   310     return iPublisherUid;

   311     }

   312 

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

   314 // CWmWidgetData::FetchPublisherUidL

   315 // ----------------------------------------------------

   316 //

   317 void CWmWidgetData::FetchPublisherUidL( 

   318             const TDesC& aPublisherId,

   319             RWidgetRegistryClientSession* aRegistryClientSession )

   320     {

   321     if ( iPublisherUid == KNullUid && 

   322         aPublisherId != KNullDesC &&

   323         iWidgetType != CWmWidgetData::ENative &&

   324         aRegistryClientSession )

   325         {

   326         TInt widgetUid = aRegistryClientSession->GetWidgetUidL( aPublisherId );

   327         if ( widgetUid != 0 )

   328             {

   329             // WRT widget

   330             iPublisherUid = TUid::Uid( widgetUid );

   331             

   332             // wrt widget type  

   333             CWidgetPropertyValue* value( NULL );

   334             value = aRegistryClientSession->GetWidgetPropertyValueL( 

   335                     iPublisherUid, ENokiaWidget );

   336             if ( value && *value == 1 )

   337                 {

   338                 iWrtType = CWmWidgetData::EWgz;

   339                 }

   340             else if ( value && *value == 2 )

   341                 {

   342                 iWrtType = CWmWidgetData::EWgt;

   343                 }

   344             else

   345                 {

   346                 iWrtType = CWmWidgetData::EUnIdentified;

   347                 }

   348 

   349             delete value;

   350             value = NULL;

   351 

   352             }

   353         else

   354             {

   355             iPublisherUid = KNullUid;

   356             }

   357         }

   358     }

   359 

   360 // ---------------------------------------------------------

   361 // CWmWidgetData::Description

   362 // ---------------------------------------------------------

   363 //

   364 const TDesC& CWmWidgetData::Name() const

   365     {

   366     return ( iAsyncUninstalling ? 

   367         iWmResourceLoader.Uninstalling() :

   368         iHsContentInfo->Name() );

   369     }

   370 

   371 // ---------------------------------------------------------

   372 // CWmWidgetData::Description

   373 // ---------------------------------------------------------

   374 //

   375 const TDesC& CWmWidgetData::Description() const

   376     {

   377     if ( iHsContentInfo->Description().Length() <= 0 &&

   378         &iWmResourceLoader )

   379         {

   380         return ( ( iPublisherUid != KNullUid ) ? 

   381             iWmResourceLoader.WrtDescription() : 

   382             iWmResourceLoader.NoDescription() );

   383         }

   384     return iHsContentInfo->Description(); 

   385     }

   386 

   387 // ---------------------------------------------------------

   388 // CWmWidgetData::ReCreateLogo

   389 // ---------------------------------------------------------

   390 //

   391 void CWmWidgetData::UpdateLogo( const TSize& aSize, TBool aReCreateLogo )

   392     {        

   393     iLogoSize = aSize;

   394     if ( aReCreateLogo )

   395         {

   396         delete iLogoImage;

   397         iLogoImage = NULL;

   398         delete iLogoImageMask;

   399         iLogoImageMask = NULL;

   400         HandleIconString( HsContentInfo().IconPath() );

   401         }

   402     else

   403         {

   404         iImageConverter->UpdateImageSize(

   405                 iLogoSize,

   406                 HsContentInfo().IconPath(),

   407                 *iLogoImage,

   408                 *iLogoImageMask );

   409         }

   410     }

   411 

   412 // ---------------------------------------------------------

   413 // CWmWidgetData::ReplaceContentInfo

   414 // ---------------------------------------------------------

   415 //

   416 TBool CWmWidgetData::ReplaceContentInfo(

   417         CHsContentInfo* aHsContentInfo )

   418     {

   419     TBool sameAppearance = (

   420             iHsContentInfo->Name() == aHsContentInfo->Name() &&

   421             iHsContentInfo->Description() == aHsContentInfo->Description() &&

   422             iHsContentInfo->CanBeAdded() == aHsContentInfo->CanBeAdded() );

   423     TBool sameLogo = (

   424             iHsContentInfo->IconPath() == aHsContentInfo->IconPath() );

   425 

   426     // delete the old content info

   427     delete iHsContentInfo;

   428     iHsContentInfo = NULL;

   429     

   430     // re-init the object, take care about leave.

   431     TRAPD( err, InitL( aHsContentInfo, NULL ); );

   432     if ( KErrNone != err )

   433         {

   434         delete aHsContentInfo;

   435         aHsContentInfo = NULL;

   436         }

   437    

   438     if ( !sameAppearance )

   439         {

   440         // fire change event -> widget redrawn

   441         FireDataChanged();

   442         }

   443     

   444     if ( !sameLogo )

   445         {

   446         // re-convert image

   447         // change event will be fired later when bitmap is ready

   448         UpdateLogo( iLogoSize, ETrue );

   449         }

   450 

   451     return !( sameAppearance && sameLogo );

   452     }

   453 

   454 // ---------------------------------------------------------

   455 // CWmWidgetData::VisualizeUninstall

   456 // ---------------------------------------------------------

   457 //

   458 void CWmWidgetData::VisualizeUninstallL()

   459     {   

   460     DestroyAnimData();

   461     PrepairAnimL();

   462 

   463     iAsyncUninstalling = ETrue;

   464     iAnimationIndex = 0;

   465     const TInt tickInterval = 400000;

   466     iAnimationTimer->Start(

   467             tickInterval,tickInterval,TCallBack(AnimationTick, this));

   468     }

   469 

   470 // ---------------------------------------------------------

   471 // CWmWidgetData::PrepairAnimL

   472 // ---------------------------------------------------------

   473 //

   474 void CWmWidgetData::PrepairAnimL()

   475     {

   476     TInt resourceId = R_QGN_GRAF_WAIT_BAR_ANIM;

   477     CAknBitmapAnimation* aknAnimation = CAknBitmapAnimation::NewL();

   478     CleanupStack::PushL( aknAnimation );

   479     aknAnimation->SetScaleModeForAnimationFrames(EAspectRatioNotPreserved);

   480     TAknsItemID iid;

   481     iid.Set(EAknsMajorAvkon, resourceId );

   482     if ( !aknAnimation ->ConstructFromSkinL( iid ) )

   483         {

   484         TResourceReader readerForAnimation;

   485         CCoeEnv::Static()->CreateResourceReaderLC( readerForAnimation,resourceId );

   486         aknAnimation->ConstructFromResourceL( readerForAnimation );

   487         CleanupStack::PopAndDestroy();

   488         }

   489     TInt endFrame = aknAnimation ->BitmapAnimData()->FrameArray().Count()-1;

   490     for ( TInt i=0; i<=endFrame; i++ )

   491         {

   492         aknAnimation ->BitmapAnimData()->FrameArray().At(i)->SetBitmapsOwnedExternally( ETrue );

   493         CFbsBitmap* bitmap  = aknAnimation ->BitmapAnimData()->FrameArray().At(i)->Bitmap();

   494         CFbsBitmap* bitmapMask = aknAnimation ->BitmapAnimData()->FrameArray().At(i)->Mask();

   495         if ( bitmap && bitmapMask )

   496             {

   497             iUninstallAnimIcons.AppendL( bitmap );

   498             iUninstallAnimIcons.AppendL( bitmapMask );

   499             }

   500         }

   501     CleanupStack::PopAndDestroy( aknAnimation );

   502     }

   503 

   504 // ---------------------------------------------------------

   505 // CWmWidgetData::DestroyAnimData

   506 // ---------------------------------------------------------

   507 //

   508 void CWmWidgetData::DestroyAnimData()

   509     {

   510     if ( iAnimationTimer && iAnimationTimer->IsActive() )

   511         {

   512         iAnimationTimer->Cancel();

   513         }

   514         

   515     for( TInt i=0; i < iUninstallAnimIcons.Count(); i++ )

   516         {

   517         CFbsBitmap* bitmap = iUninstallAnimIcons[i];

   518         delete bitmap; bitmap = NULL;

   519         }

   520     iUninstallAnimIcons.Close();    

   521     }

   522 

   523 // ---------------------------------------------------------

   524 // CWmWidgetData::AnimationTick

   525 // ---------------------------------------------------------

   526 //

   527 TInt CWmWidgetData::AnimationTick( TAny* aPtr )

   528     {

   529     CWmWidgetData* self = static_cast< CWmWidgetData* >( aPtr );

   530     self->iAnimationIndex += 2;

   531     if ( self->iAnimationIndex >= self->iUninstallAnimIcons.Count() -1 )

   532         {

   533         self->iAnimationIndex = 0; // restart from beginging

   534         }

   535     self->FireDataChanged();

   536     return 1;

   537     }

   538 

   539 // ---------------------------------------------------------

   540 // CWmWidgetData::AnimationBitmap

   541 // ---------------------------------------------------------

   542 //

   543 const CFbsBitmap* CWmWidgetData::AnimationBitmap( const TSize& aSize )

   544     {

   545     CFbsBitmap* bitmap = NULL;

   546     if ( iUninstallAnimIcons.Count() )

   547         {

   548         TInt index = iAnimationIndex;

   549         if ( index >= iUninstallAnimIcons.Count() - 1 )

   550             {

   551             index = 0;

   552             }

   553         bitmap = iUninstallAnimIcons[index];

   554         if ( bitmap->SizeInPixels() != aSize )

   555             {

   556             AknIconUtils::SetSize( bitmap, aSize, 

   557                     EAspectRatioNotPreserved );

   558             }               

   559         }

   560     return bitmap;

   561     }

   562 

   563 // ---------------------------------------------------------

   564 // CWmWidgetData::AnimationMask

   565 // ---------------------------------------------------------

   566 //

   567 const CFbsBitmap* CWmWidgetData::AnimationMask( const TSize& aSize )

   568     {

   569     CFbsBitmap* mask = NULL;

   570     if ( iUninstallAnimIcons.Count() )

   571         {

   572         TInt index = iAnimationIndex+1;

   573         if ( index >= iUninstallAnimIcons.Count() )

   574             {

   575             index = 1;

   576             }

   577         mask = iUninstallAnimIcons[index];

   578         if ( mask && mask->SizeInPixels() != aSize )

   579             {

   580             AknIconUtils::SetSize( mask, aSize,

   581                     EAspectRatioNotPreserved );

   582             }

   583         }    

   584     return mask;

   585     }

   586 

   587 // ---------------------------------------------------------

   588 // CWmWidgetData::IsUninstalling

   589 // ---------------------------------------------------------

   590 //

   591 TBool CWmWidgetData::IsUninstalling()

   592     {

   593     return iAsyncUninstalling;

   594     }

   595 

   596 // ---------------------------------------------------------

   597 // CWmWidgetData::MdcaPoint

   598 // ---------------------------------------------------------

   599 //

   600 const TDesC& CWmWidgetData::MdcaPoint() const

   601     {

   602     if ( iMdcaPoint )

   603         return *iMdcaPoint;

   604     else

   605         return KNullDesC;

   606     }

   607 

   608 // ---------------------------------------------------------

   609 // CWmWidgetData::StopUninstallAnimation

   610 // ---------------------------------------------------------

   611 //

   612 void CWmWidgetData::StopUninstallAnimation()

   613     {

   614     iAsyncUninstalling = EFalse;

   615     DestroyAnimData();

   616     FireDataChanged(); //redraw

   617     }

   618 

   619 // End of file

   620