1 /*

     2 * Copyright (c) 2002-2007 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:  Model class for Psln application.

    15 *

    16 */

    17 

    18 

    19 // Psln specific.

    20 #include "PslnModel.h"

    21 #include "PslnDiskUtil.h"

    22 #include "PslnFeatures.h"

    23 #include "PslnSkinEntry.h"

    24 #include "PslnSkinStore.h"

    25 #include "PslnEcomListener.h"

    26 #include "PslnDebug.h"

    27 #include "PslnConst.h"

    28 

    29 // Wrapper for wallpaper utils.

    30 #include "pslnwallpaperutilsloader.h"

    31 #include "pslnbrowserlaunchloader.h"

    32 

    33 // Resources

    34 #include <psln.rsg>

    35 #include <pslnskinnames.rsg>

    36 

    37 // Generic

    38 #include <StringLoader.h>

    39 #include <data_caging_path_literals.hrh>

    40 #include <f32file.h>

    41 #include <hal.h>

    42 

    43 // UI libraries

    44 #include <AknsSkinUID.h>

    45 #include <AknsConstants.h>

    46 #include <eikenv.h>

    47 #include <AknQueryDialog.h>

    48 

    49 // Misc

    50 #include <bautils.h>

    51 #include <mmf/common/mmfcontrollerpluginresolver.h> // For CleanupResetAndDestroyPushL

    52 

    53 // Central Repository and Publish&Subscribe keys.

    54 #include <centralrepository.h>

    55 #include <e32property.h>

    56 #include "pslninternalcrkeys.h"

    57 #include <AknSkinsInternalCRKeys.h>             // wallpaper, screen saver

    58 #include <cenrepnotifyhandler.h>

    59 

    60 // For enabling first component transition effect

    61 #include <gfxtranseffect/gfxtranseffect.h>

    62 #include <akntranseffect.h>

    63 #ifdef RD_MULTIPLE_DRIVE

    64 #include <driveinfo.h>

    65 #endif //RD_MULTIPLE_DRIVE

    66 

    67 

    68 // CONSTANTS

    69 // Path of skin files.

    70 _LIT( KPslnSkinNamesFile,"z:PslnSkinNames.rsc" );

    71 

    72 // Default item index.

    73 const TInt KPslnDefaultItemIndex = 0;

    74 

    75 // Screen saver type: user defined text

    76 const TInt KPslnSsText = 0;

    77 // Screen saver type: date & time

    78 const TInt KPslnSsDate = 1;

    79 // Screen saver type: object

    80 const TInt KPslnSsObject = 3;

    81 // Screen saver type: none

    82 const TInt KPslnSsNone = 4;

    83 

    84 // Granularity of screen saver array.

    85 const TInt KPslnSsArrayGranularity = 5;

    86 // Length of drive number descriptor.

    87 const TInt KPslnDriveNumberLength = 2;

    88 // Free RAM required when activating transition effects.

    89 const TInt KPslnTransitionEffectRAMThreshold = 2000000;

    90 // Maximum of text length in text screensaver for APAC.

    91 // For western variant, value is taken directly from resources.

    92 const TInt KPslnSsTextDialogAPACMaxLength = 7;

    93 // Path to wallpaper utils.

    94 _LIT( KPslnWallpaperUtilsLoaderName, 

    95      "\\system\\libs\\PslnWallpaperUtilsLoader.dll");

    96 _LIT( KPslnBrowserLaunchLoaderName, 

    97      "\\system\\libs\\PslnBrowserLaunchLoader.dll");

    98 // Screen saver UID is stored like [ss_uid]. This is the end mark.

    99 _LIT( KPslnScreenSaverUidEndMark, "]" );

   100 

   101 // CLASS DECLARATIONS

   102 

   103 class CPslnActivationGuard : public CBase

   104     {

   105     public:

   106         virtual ~CPslnActivationGuard()

   107             {

   108             PSLN_TRACE_DEBUG("CPslnActivationGuard::destructor");

   109             iModel->SkinSrvSession().EnableSkinChangeNotify();

   110             }

   111 

   112         static CPslnActivationGuard* NewL( CPslnModel* aModel )

   113             {

   114             PSLN_TRACE_DEBUG("CPslnActivationGuard::NewL");

   115             CPslnActivationGuard* self = new (ELeave) CPslnActivationGuard();

   116             self->iModel = aModel;

   117             PSLN_TRACE_DEBUG("CPslnActivationGuard DisableSkinChangeNotify");

   118             aModel->SkinSrvSession().DisableSkinChangeNotify();

   119             return self;

   120             }

   121 

   122     private:

   123         CPslnModel* iModel;

   124     };

   125 

   126 // TYPE DEFINITIONS

   127 // Wallpaper Utils entry.

   128 typedef TAny* (*NewWallpaperUtilsL)();

   129 

   130 // Browser Launcher entry.

   131 typedef TAny* (*NewBrowserLauncherL)();

   132 

   133 

   134 // ============================ MEMBER FUNCTIONS ===============================

   135 // -----------------------------------------------------------------------------

   136 // Two-phased constructor.

   137 // -----------------------------------------------------------------------------

   138 //

   139 EXPORT_C CPslnModel* CPslnModel::NewL( MAknsSkinChangeObserver* aObserver )

   140     {

   141     PSLN_TRACE_DEBUG("CPslnModel::NewL");

   142     CPslnModel* self = new(ELeave) CPslnModel;

   143 

   144     CleanupStack::PushL( self );

   145     self->ConstructL( aObserver );

   146     CleanupStack::Pop( self );

   147 

   148     PSLN_TRACE_DEBUG("CPslnModel::NewL OK");

   149     return self;

   150     }

   151 

   152 // -----------------------------------------------------------------------------

   153 // Two-phased constructor. Simpler version for PslnFramework use.

   154 // Deprecated.

   155 // -----------------------------------------------------------------------------

   156 //

   157 EXPORT_C CPslnModel* CPslnModel::NewL()

   158     {

   159     CPslnModel* self = new(ELeave) CPslnModel;

   160     return self;

   161     }

   162 

   163 // -----------------------------------------------------------------------------

   164 // Destructor

   165 // -----------------------------------------------------------------------------

   166 //

   167 EXPORT_C CPslnModel::~CPslnModel()

   168     {

   169     PSLN_TRACE_DEBUG("CPslnModel::destructor");

   170 

   171     delete iSkinsRepository;

   172     delete iScreenSaverRepository;

   173     iSkinSrvSession.Close();

   174 

   175     while( iSkinNames.Count() )

   176         {

   177         delete iSkinNames[0].iListName;

   178         delete iSkinNames[0].iTitleName;

   179         iSkinNames.Remove(0);

   180         }

   181     iSkinNames.Close();

   182 

   183     delete iScreensaverFilenameArr;

   184     delete iScreensaverNameArr;

   185     iScreensaverCapsArr.Reset();

   186 

   187     delete iSkinStore;

   188     if( iVisibleSkinArr )

   189         {

   190         iVisibleSkinArr->ResetAndDestroy();

   191         delete iVisibleSkinArr;

   192         }

   193     delete iScreenSaverInfo;

   194 

   195     delete iWallpaperSetter;

   196     if( iInternalState.IsSet( EPslnModelStateWallpaperDllLoaded  ) )

   197         {

   198         iWallpaperDll.Close();

   199         }

   200 

   201     delete iBrowserLauncher;

   202     if( iInternalState.IsSet( EPslnModelStateBrowserLaunchDllLoaded ) )

   203         {

   204         iBrowserLaunchDll.Close();

   205         }

   206 

   207     // If client is bad-behaving and has not cancelled listening, 

   208     // cancel itself.

   209     if ( iScreenSaverListener )

   210         {

   211         if ( iScreenSaverListener->IsActive() )

   212             {

   213             iScreenSaverListener->Cancel();

   214             }

   215         delete iScreenSaverListener;

   216         // NUllified here, just in case if client later decides to try and

   217         // destroy this.

   218         iScreenSaverListener = NULL;

   219         }

   220         

   221     if(iThemesAppCenRepNotifyHandler)

   222         {

   223         iThemesAppCenRepNotifyHandler->StopListening();

   224         delete iThemesAppCenRepNotifyHandler;

   225         }

   226     delete iThemesAppRepository;

   227     }

   228 

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

   230 // Activate a Skin.

   231 // -----------------------------------------------------------------------------

   232 //

   233 EXPORT_C TBool CPslnModel::ActivateSkinL(

   234     const TDesC8& /*aPreviewType*/,

   235     const TInt /*aActiveSkinIndex*/ )

   236     {

   237     PSLN_TRACE_DEBUG("CPslnModel::ActivateSkinL -- depricated!!");

   238     User::Leave( KErrNotSupported );

   239     return EFalse;

   240     }

   241 

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

   243 // Activate a screen saver.

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

   245 //

   246 EXPORT_C TInt CPslnModel::ActivateScreenSaver( const TInt aItemIndex, 

   247     TPslnScreenSaverActivation aActivationType )

   248     {

   249     PSLN_TRACE_DEBUG("CPslnModel::ActivateScreenSaver");

   250     TRAPD( err, ActivateScreenSaverL( aItemIndex, aActivationType ) );

   251     PSLN_TRACE_DEBUG1("CPslnModel::ActivateScreenSaver %d", err );

   252     return err;

   253     }

   254 

   255 // -----------------------------------------------------------------------------

   256 // CPslnModel::GuardActivationLC

   257 // -----------------------------------------------------------------------------

   258 //

   259 EXPORT_C void  CPslnModel::GuardActivationLC()

   260     {

   261     PSLN_TRACE_DEBUG("CPslnModel::GuardActivationLC");

   262     CleanupStack::PushL( CPslnActivationGuard::NewL( this ) );

   263     }

   264 

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

   266 // Download a skin.

   267 // -----------------------------------------------------------------------------

   268 //

   269 EXPORT_C void CPslnModel::DownloadSkinL()

   270     {

   271     PSLN_TRACE_DEBUG("CPslnModel::DownloadSkinL BEGIN");

   272     PSLN_TRACE_DEBUG("CPslnModel::DownloadSkinL Load DLL");

   273     LoadBrowserLaunchL();

   274     if ( iBrowserLauncher )

   275         {

   276         PSLN_TRACE_DEBUG("CPslnModel::DownloadSkinL Launch embedded browser");

   277         TRAPD( error, 

   278                iBrowserLauncher->LaunchBrowserStandaloneL( ) );

   279         if ( error != KErrNone )

   280             {

   281             PSLN_TRACE_DEBUG1("CPslnModel::DownloadSkinL Handle exit: %d", error );

   282             }

   283         if ( error == KErrNoMemory )

   284             {

   285             PSLN_TRACE_DEBUG("CPslnModel::DownloadSkinL OOM");

   286             User::Leave( error );

   287             }

   288         }

   289     PSLN_TRACE_DEBUG("CPslnModel::DownloadSkinL END");

   290     }

   291 

   292 // -----------------------------------------------------------------------------

   293 // Set Background image path name.

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

   295 //

   296 EXPORT_C TInt CPslnModel::SetBackgroundImagePath( const TDesC& aImagePath )

   297     {

   298     PSLN_TRACE_DEBUG("CPslnModel::SetBackgroundImagePath");

   299 

   300     TRAP_IGNORE( LoadWallpaperUtilsL() );

   301     TInt retVal = KErrNone;

   302     if ( iWallpaperSetter )

   303         {

   304         if( aImagePath.Length() > 0 )

   305             {

   306             retVal = iWallpaperSetter->SetIdleWallpaper(

   307                 aImagePath, 

   308                 CCoeEnv::Static(),

   309                 R_PSLN_SKINS_LOADING_IMAGE,

   310                 R_PSLN_GENERAL_WAIT_NOTE );

   311             }

   312         else

   313             {

   314             retVal = iWallpaperSetter->SetIdleWallpaper( KNullDesC, NULL );

   315             }

   316         }

   317     else

   318         {

   319         retVal = KErrNoMemory;

   320         }

   321     return retVal;

   322     }

   323 

   324 // ---------------------------------------------------------------------------

   325 // CPslnModel::InvokeSSPluginFunctionL

   326 // ---------------------------------------------------------------------------

   327 //

   328 EXPORT_C void CPslnModel::InvokeSSPluginFunctionL(

   329     TInt aIndex,

   330     TScPluginCaps aFunction )

   331     {

   332     PSLN_TRACE_DEBUG("CPslnModel::InvokeSSPluginFunctionL");

   333     if ( !iScreensaverFilenameArr || iScreensaverFilenameArr->Count() == 0 )

   334         {

   335         User::Leave( KErrNotFound );

   336         }

   337 

   338     if( aIndex >= iScreensaverFilenameArr->MdcaCount() )

   339         {

   340         User::Leave( KErrArgument );

   341         }

   342         

   343     if(aFunction == EScpCapsConfigure &&

   344        aIndex == GetScreenSaverIndexByFileName(KPslnScreenSaverTypeText))

   345         {

   346         TBool ret = QueryAndSetScreensaverTextL();

   347         if ( !ret )

   348             {

   349             User::Leave( KErrCancel );

   350             }

   351         return;

   352         }

   353 

   354     // Convert the UID of the given screensaver plugin from text to integer

   355     // The string format of the UID: [12345678]

   356     // The number inside the brackets in hexadecimal format

   357     TLex lex( iScreensaverFilenameArr->MdcaPoint( aIndex ) );

   358     // Skip the first character: '['

   359     lex.Get();

   360     TUint screenSaverPluginImpUid;

   361     // Get the UID

   362     TInt err = lex.Val( screenSaverPluginImpUid, EHex );

   363     PSLN_TRACE_DEBUG1("CPslnModel::InvokeSSPluginFunctionL lexed: %d", err );

   364     User::LeaveIfError( err );

   365 

   366     if( err == KErrCancel && aIndex == CurrentPropertyIndexL( KPslnScreenSettingId ) )

   367         {

   368         SetScreenSaverToDefault();

   369         }

   370     

   371     User::LeaveIfError( err );

   372     }

   373 

   374 // ---------------------------------------------------------------------------

   375 // CPslnModel::PerformCompleteUpdateL

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

   377 //

   378 EXPORT_C void CPslnModel::PerformCompleteUpdateL()

   379     {

   380     PSLN_TRACE_DEBUG("CPslnModel::PerformCompleteUpdateL");

   381 

   382     if ( iInternalState.IsClear( EPslnModelStateSkinNamesLoaded ) )

   383         {

   384         LoadSkinNamesResourceL();

   385         }

   386     UpdateFromServerL();

   387     SetActiveSkinL();

   388 

   389     PSLN_TRACE_DEBUG("CPslnModel::PerformCompleteUpdateL COMPLETED");

   390     }

   391 

   392 // ---------------------------------------------------------------------------

   393 // CPslnModel::LoadScreensaverArrayL

   394 // ---------------------------------------------------------------------------

   395 //

   396 EXPORT_C void CPslnModel::LoadScreensaverArrayL()

   397     {

   398     PSLN_TRACE_DEBUG("CPslnModel::LoadScreensaverArrayL");

   399 

   400     // Destroy old arrays, if any

   401     delete iScreensaverNameArr;

   402     iScreensaverNameArr = NULL;

   403     delete iScreensaverFilenameArr;

   404     iScreensaverFilenameArr = NULL;

   405     iScreensaverCapsArr.Reset();

   406 

   407     // Load default items

   408     iScreensaverNameArr = iEikEnv->ReadDesC16ArrayResourceL(

   409         R_SCREEN_SAVER_SETTING_PAGE_LBX );

   410 

   411     // Add descriptors for system screensavers

   412     iScreensaverFilenameArr =

   413         new (ELeave) CDesC16ArrayFlat( KPslnSsArrayGranularity );

   414     iScreensaverFilenameArr->AppendL( KPslnScreenSaverTypeDateTime );

   415     iScreensaverFilenameArr->AppendL( KPslnScreenSaverTypeText );

   416 

   417     // System screensavers have no capabilities

   418     User::LeaveIfError( iScreensaverCapsArr.Append( EFalse ) );

   419 

   420     if ( IsSupportScreenSaverNoneOption() )

   421         {

   422         iScreensaverFilenameArr->InsertL(0, KPslnScreenSaverTypeNone ); 

   423         User::LeaveIfError( iScreensaverCapsArr.Insert( 0, EFalse ) );

   424         }

   425     else

   426         {

   427         iScreensaverNameArr->Delete(0);

   428         }

   429 

   430     FindAndAppendScreensaversL();

   431     }

   432 

   433 // ---------------------------------------------------------------------------

   434 // CPslnModel::VisibleSkin

   435 // ---------------------------------------------------------------------------

   436 //

   437 EXPORT_C CPslnSkinEntry* CPslnModel::VisibleSkin( const TInt aIndex )

   438     {

   439     PSLN_TRACE_DEBUG("CPslnModel::VisibleSkin");

   440     if ( !iSkinStore )

   441         {

   442         TRAPD( err, iSkinStore = CPslnSkinStore::NewL( this ) );

   443         if ( err != KErrNone )

   444             {

   445             return NULL;

   446             }

   447         }

   448     CPslnSkinEntry* visibleSkin = NULL;

   449     if ( iVisibleSkinArr )

   450         {

   451         if( ( aIndex >= 0 ) && ( aIndex < iVisibleSkinArr->Count() ) )

   452             {

   453             CPslnSkinNameEntry* nameEntry = (*iVisibleSkinArr)[aIndex];

   454             visibleSkin = iSkinStore->Find(

   455                 nameEntry->PkgID(), nameEntry->Location() );

   456             }

   457         }

   458     return visibleSkin;

   459     }

   460 

   461 // -----------------------------------------------------------------------------

   462 // Get a skin's name by index.

   463 // -----------------------------------------------------------------------------

   464 //

   465 EXPORT_C void CPslnModel::GetSkinNameByIndex( const TInt aIndex, TDes& aSkinName,

   466     const TPslnSkinNameType aType ) const

   467     {

   468     PSLN_TRACE_DEBUG("CPslnModel::GetSkinNameByIndex");

   469 

   470     TAknsPkgID pid = KAknsNullPkgID;

   471     if ( iVisibleSkinArr )

   472         {

   473         if( ( aIndex >= 0 ) && ( aIndex < iVisibleSkinArr->Count() ) )

   474             {

   475             pid = (*iVisibleSkinArr)[aIndex]->PkgID();

   476             }

   477         }

   478 

   479     GetSkinNameByPID( pid, aSkinName, aType );

   480     }

   481 

   482 // -----------------------------------------------------------------------------

   483 // Return if the selected skin is activated.

   484 // -----------------------------------------------------------------------------

   485 //

   486 EXPORT_C TBool CPslnModel::IsActiveSkinSelected( TInt aSkinIndex ) const

   487     {

   488     PSLN_TRACE_DEBUG("CPslnModel::IsActiveOfSkinSelected");

   489 

   490     TInt skinIndex = iCurrentSkinIndex;

   491     if ( aSkinIndex >= 0 )

   492         {

   493         skinIndex = aSkinIndex;

   494         }

   495     return ( iActiveSkinIndex == skinIndex );

   496     }

   497 

   498 // -----------------------------------------------------------------------------

   499 // CPslnModel::LocationOfSkin

   500 // Deprecated.

   501 // -----------------------------------------------------------------------------

   502 //

   503 EXPORT_C TAknSkinSrvSkinPackageLocation CPslnModel::LocationOfSkin(

   504     const TInt aIndex )

   505     {

   506     PSLN_TRACE_DEBUG("CPslnModel::LocationOfSkin");

   507     TAknSkinSrvSkinPackageLocation skinLocation = EAknsSrvPhone;

   508     CPslnSkinEntry* entry = VisibleSkin( aIndex );

   509     if( entry )

   510         {

   511         skinLocation = entry->Location();

   512         }

   513     return skinLocation;

   514     }

   515 

   516 // -----------------------------------------------------------------------------

   517 // Return the active skin index.

   518 // -----------------------------------------------------------------------------

   519 //

   520 EXPORT_C TInt CPslnModel::ActiveSkinIndex () const

   521     {

   522     PSLN_TRACE_DEBUG("CPslnModel::ActiveSkinIndex");

   523     return iActiveSkinIndex;

   524     }

   525 

   526 // -----------------------------------------------------------------------------

   527 // Return the skin index of the selection currently active.

   528 // -----------------------------------------------------------------------------

   529 //

   530 EXPORT_C TInt CPslnModel::CurrentSelectedSkinIndex () const

   531     {

   532     PSLN_TRACE_DEBUG("CPslnModel::CurrentSelectedSkinIndex");

   533     return iCurrentSkinIndex;

   534     }

   535 

   536 // -----------------------------------------------------------------------------

   537 // Get number of skins.

   538 // -----------------------------------------------------------------------------

   539 //

   540 EXPORT_C TInt CPslnModel::NumberOfSkins() const

   541     {

   542     PSLN_TRACE_DEBUG("CPslnModel::NumberOfSkins");

   543     TInt numberOfSkins = 0;

   544     if ( iVisibleSkinArr )

   545         {

   546         numberOfSkins = iVisibleSkinArr->Count();

   547         }

   548     return numberOfSkins;

   549     }

   550 

   551 // ---------------------------------------------------------------------------

   552 // CPslnModel::ScreensaverNames

   553 // ---------------------------------------------------------------------------

   554 //

   555 EXPORT_C const MDesC16Array& CPslnModel::ScreensaverNames() const

   556     {

   557     PSLN_TRACE_DEBUG("CPslnModel::ScreensaverNames");

   558     return *iScreensaverNameArr;

   559     }

   560 

   561 // ---------------------------------------------------------------------------

   562 // CPslnModel::ScreensaverHasCapability

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

   564 //

   565 EXPORT_C TBool CPslnModel::ScreensaverHasCapability(

   566     const TInt aIndex,

   567     const TScPluginCaps aCapability ) const

   568     {

   569     PSLN_TRACE_DEBUG("CPslnModel::ScreensaverHasCapability");

   570     if( ( aIndex < 0 ) || ( aIndex >= iScreensaverCapsArr.Count() ) )

   571         {

   572         return EFalse;

   573         }

   574 

   575     return ( iScreensaverCapsArr[ aIndex ] & aCapability );

   576     }

   577 

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

   579 // CPslnModel::ProtectionOfSkin

   580 // -----------------------------------------------------------------------------

   581 //

   582 EXPORT_C TAknsSkinSrvSkinProtectionType CPslnModel::ProtectionOfSkin(

   583     const TInt aIndex )

   584     {

   585     PSLN_TRACE_DEBUG("CPslnModel::ProtectionOfSkin");

   586     TAknsSkinSrvSkinProtectionType skinProtectionType = EAknsSrvNoProtection;

   587     CPslnSkinEntry* entry = VisibleSkin( aIndex );

   588     if( entry )

   589         {

   590         skinProtectionType = entry->Protection();

   591         }

   592     return skinProtectionType;

   593     }

   594 

   595 // -----------------------------------------------------------------------------

   596 // CPslnModel::IsValidForActivation

   597 // -----------------------------------------------------------------------------

   598 //

   599 EXPORT_C TBool CPslnModel::IsValidForActivation( const TInt aItemIndex )

   600     {

   601     PSLN_TRACE_DEBUG("CPslnModel::IsValidForActivation");

   602     CPslnSkinEntry* skinEntry = VisibleSkin( aItemIndex );

   603     return ( skinEntry && !skinEntry->IsCorrupted() );

   604     }

   605 

   606 // -----------------------------------------------------------------------------

   607 // CPslnModel::IsValidForPreview

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

   609 //

   610 EXPORT_C TBool CPslnModel::IsValidForPreview( const TInt aItemIndex )

   611     {

   612     PSLN_TRACE_DEBUG("CPslnModel::IsValidForPreview");

   613     CPslnSkinEntry* skinEntry = VisibleSkin( aItemIndex );

   614     if( !skinEntry )

   615         {

   616         return EFalse;

   617         }

   618         

   619     if( skinEntry->IsCorrupted() )

   620         {

   621         return EFalse;

   622         }

   623     TInt type = skinEntry->Protection();

   624     if( type != EAknsSrvNoProtection && type != EAknsSrvProtected )

   625         {

   626         return EFalse;

   627         }

   628         

   629     TBool skinFileExist = SkinFileExist( aItemIndex );

   630     if( !skinFileExist )

   631         {

   632         return EFalse;

   633         }

   634 

   635     return ETrue;

   636     }

   637 

   638 // -----------------------------------------------------------------------------

   639 // Checks if the skin support animated background.

   640 // -----------------------------------------------------------------------------

   641 //

   642 EXPORT_C TBool CPslnModel::IsSupportAnimBg( TInt aItemIndex )

   643     {

   644     CPslnSkinEntry* skinEntry = VisibleSkin( aItemIndex );

   645     return skinEntry && skinEntry->IsSupportAnimBg();

   646     }

   647 	

   648 // -----------------------------------------------------------------------------

   649 // Set current selected skin index.

   650 // -----------------------------------------------------------------------------

   651 //

   652 EXPORT_C void CPslnModel::SetCurrentSelectedSkinIndex(

   653     const TInt aCurrentSkinIndex )

   654     {

   655     PSLN_TRACE_DEBUG1("CPslnModel::SetCurrentSelectedSkinIndex:%d", aCurrentSkinIndex );

   656     if ( aCurrentSkinIndex >= 0 )

   657         {

   658         iCurrentSkinIndex = aCurrentSkinIndex;

   659         }

   660     // If given index is negative, assume that first skin is selected.

   661     else

   662         {

   663         iCurrentSkinIndex = 0;

   664         }

   665     }

   666 

   667 // -----------------------------------------------------------------------------

   668 // CPslnModel::SetCurrentPropertyType

   669 // -----------------------------------------------------------------------------

   670 //

   671 EXPORT_C TInt CPslnModel::SetCurrentPropertyType(

   672     const TInt /*aProperty*/, const TInt /*aCurItemIndex*/ )

   673     {

   674     // deprecated.

   675     return KErrNotSupported;

   676     }

   677 

   678 // -----------------------------------------------------------------------------

   679 // Get a Skin's Properties Type index.

   680 // -----------------------------------------------------------------------------

   681 //

   682 EXPORT_C TInt CPslnModel::CurrentPropertyIndex( const TInt aProperty )

   683     {

   684     PSLN_TRACE_DEBUG1("CPslnModel::CurrentPropertyIndex:%d", aProperty );

   685     TInt currentIndex = KErrNotFound;

   686     TRAP_IGNORE( currentIndex = CurrentPropertyIndexL( aProperty ) );

   687     PSLN_TRACE_DEBUG1("CPslnModel::CurrentPropertyIndex return:%d", currentIndex );

   688     return currentIndex;

   689     }

   690 

   691 // -----------------------------------------------------------------------------

   692 // Starts to listen for ECOM screensaver changes.

   693 // -----------------------------------------------------------------------------

   694 //

   695 EXPORT_C void CPslnModel::EnableScreenSaverNotifications(

   696     const TBool& aActive, MPslnScreenSaverECOMObserver& aObserver )

   697     {

   698     PSLN_TRACE_DEBUG("CPslnModel::EnableScreenSaverNotifications" );

   699     if ( aActive )

   700         {

   701         // Create listening class (active object)

   702         TRAP_IGNORE(

   703             iScreenSaverListener = CPslnEcomListener::NewL( *this, aObserver ) );

   704         }

   705     else

   706         {

   707         // Check if model has already destroyed this.

   708         if ( iScreenSaverListener )

   709             {

   710             if ( iScreenSaverListener->IsActive() )

   711                 {

   712                 iScreenSaverListener->Cancel();

   713                 }

   714             delete iScreenSaverListener;

   715             iScreenSaverListener = NULL;

   716             }

   717         }

   718     }

   719 

   720 // -----------------------------------------------------------------------------

   721 // Activates skin. This overloaded version knows in which state the activation 

   722 // is requested.

   723 // -----------------------------------------------------------------------------

   724 //

   725 EXPORT_C TBool CPslnModel::ActivateSkinL(

   726     const TDesC8& /*aPreviewType*/,

   727     const TInt /*aActiveSkinIndex*/,

   728     const TBool& /*aActivateFromPreview*/ )

   729     {

   730     PSLN_TRACE_DEBUG("CPslnModel::ActivateSkinL -- depricated!!");

   731     User::Leave( KErrNotSupported );

   732     return EFalse;

   733     }

   734 

   735 // -----------------------------------------------------------------------------

   736 // Activates skin. 

   737 // -----------------------------------------------------------------------------

   738 //

   739 EXPORT_C TBool CPslnModel::ActivateSkinL(

   740     const TInt aActiveSkinIndex )

   741     {

   742     PSLN_TRACE_DEBUG("CPslnModel::ActivateSkinL");

   743 

   744     TInt indexToActivate = aActiveSkinIndex;

   745     if( aActiveSkinIndex == KErrNotFound )

   746         {

   747         indexToActivate = iActiveSkinIndex;

   748         }

   749     PSLN_TRACE_DEBUG1("CPslnModel::ActivateSkinL activate skin index=%d", indexToActivate );

   750     // Get skin's full name.

   751     HBufC* fullName = HBufC::NewLC( KMaxFileName );

   752     TPtr fullNamePtr = fullName->Des();

   753     fullNamePtr = GetSkinFullName( indexToActivate );

   754 

   755     if ( !PslnDiskUtil::QueryAndSetAutomatedL( iSkinSrvSession, fullNamePtr ) )

   756         {

   757         CleanupStack::PopAndDestroy( fullName );

   758         PSLN_TRACE_DEBUG("CPslnModel::ActivateSkinL set autom. not ok");

   759         return EFalse;

   760         }

   761     CleanupStack::PopAndDestroy( fullName );

   762 

   763     // Find out the skin package ID

   764     CPslnSkinEntry* activeEntry = VisibleSkin( indexToActivate );

   765     if ( !activeEntry )

   766         {

   767         PSLN_TRACE_DEBUG("CPslnModel::ActivateSkinL NULL entry");

   768         User::Leave( KErrGeneral );

   769         }

   770 

   771     if ( !activeEntry->IsSupportAnimBg() )

   772         {

   773         //Stop animated background

   774         SetAnimBackground( EPslnDisableAllEffects );

   775         }

   776     TAknsPkgID activeSkinPid = activeEntry->PkgID();

   777     // Activate whole skin

   778     PSLN_TRACE_DEBUG("CPslnModel::ActivateSkinL set all definition sets");

   779     TInt error = iSkinSrvSession.SetAllDefinitionSets( activeSkinPid );

   780     

   781     // For enabling first component transition effect

   782     GfxTransEffect::Enable();

   783     

   784     if ( error != KErrNone )

   785         {

   786         PSLN_TRACE_DEBUG1("CPslnModel::ActivateSkinL error when setting definition sets: %d", error );

   787         User::LeaveIfError( error );

   788         }

   789         

   790     // Otherwise, save to shareddata

   791     TAknsPkgIDBuf pidBuf;

   792     activeSkinPid.CopyToDes( pidBuf );

   793 

   794     iSkinsRepository->Set(

   795         KPslnActiveSkinUid,

   796         pidBuf );

   797     iSkinsRepository->Set(

   798         KPslnActiveSkinLocation,

   799         activeEntry->Location() );

   800         

   801     iActiveSkinIndex = indexToActivate;

   802     return ETrue;

   803     }

   804 

   805 // -----------------------------------------------------------------------------

   806 // Leaving version of CurrentPropertyIndex.

   807 // -----------------------------------------------------------------------------

   808 //

   809 EXPORT_C TInt CPslnModel::CurrentPropertyIndexL( const TInt aProperty )

   810     {

   811     PSLN_TRACE_DEBUG1("CPslnModel::CurrentPropertyIndex prop=%d", aProperty );

   812 

   813     TInt itemIndex = KErrNotFound;

   814 

   815     switch( aProperty )

   816         {

   817         case KPslnBgIdleSettingId:

   818             {

   819             itemIndex = GetWallPaperItemIndex();

   820             break;

   821             }

   822         case KPslnScreenSettingId:

   823             {

   824             itemIndex = GetScreenSaverItemIndexL();

   825             break;

   826             }

   827         default:

   828             break;

   829         }

   830     return itemIndex;

   831     }

   832 

   833 // -----------------------------------------------------------------------------

   834 // Sets transition effects.

   835 // -----------------------------------------------------------------------------

   836 //

   837 EXPORT_C TInt CPslnModel::SetTransitionEffectsL( const TInt aEffectValue )

   838     {

   839     PSLN_TRACE_DEBUG("CPslnModel::SetTransitionEffectsL");

   840     TInt retVal = KErrNone;

   841 

   842     // For the first time only, read default enable mask.

   843     if ( iInternalState.IsClear( EPslnModelStateTransitionEnableCRKeyRead ) )

   844         {

   845         // Initialize to enable all.

   846         iEffectsDefaultEnableMask = EPslnEnableAllEffects;

   847 

   848         retVal = iThemesAppRepository->Get( 

   849             KThemesDefaultTransitionEffects, 

   850             iEffectsDefaultEnableMask );

   851         if ( retVal == KErrNone )

   852             {            

   853             iInternalState.Set( EPslnModelStateTransitionEnableCRKeyRead );

   854             }

   855         }

   856 

   857     // Only accept default mask, zero or max value.

   858     if ( aEffectValue != iEffectsDefaultEnableMask && 

   859          aEffectValue != EPslnEnableAllEffects &&

   860          aEffectValue != EPslnDisableAllEffects )

   861         {

   862         retVal = KErrArgument;

   863         }

   864     else

   865         {

   866         if ( aEffectValue == EPslnEnableAllEffects ||

   867              aEffectValue == iEffectsDefaultEnableMask )

   868             {

   869             TInt freeRAM = 0;

   870             HAL::Get( HALData::EMemoryRAMFree, freeRAM );

   871             if ( freeRAM < KPslnTransitionEffectRAMThreshold )

   872                 {

   873                 return KErrNoMemory;

   874                 }

   875             }

   876 

   877         // Use mask, if activating effects.

   878         TInt effectValue = aEffectValue;

   879         if ( aEffectValue != EPslnDisableAllEffects )

   880             {

   881             effectValue = iEffectsDefaultEnableMask;

   882             }

   883 

   884         iThemesAppRepository->Set( 

   885             KThemesTransitionEffects, 

   886             effectValue );

   887         }

   888         

   889     // Need to have TFXSrv running before calling enable

   890     const TInt KWaitForTFXServerStart( 100000 );

   891     User::After( KWaitForTFXServerStart );

   892     // For enabling first component transition effect

   893     GfxTransEffect::Enable();

   894     

   895     PSLN_TRACE_DEBUG1("CPslnModel::SetTransitionEffectsL %d", retVal );

   896     return retVal;

   897     }

   898 

   899 // -----------------------------------------------------------------------------

   900 // Gets current value of transition effects.

   901 // -----------------------------------------------------------------------------

   902 //

   903 EXPORT_C TInt CPslnModel::GetTransitionEffectStateL()

   904     {

   905     if( PslnFeatures::IsSupported( KPslnSupportFastPreviewTheme ) )

   906         {

   907         return iTransitionEffectValue;

   908         }

   909     

   910 

   911     PSLN_TRACE_DEBUG("CPslnModel::GetTransitionEffectStateL");

   912     TInt effectsValue = KErrNone;

   913 

   914     TInt error = iThemesAppRepository->Get( KThemesTransitionEffects, effectsValue );

   915     if ( error != KErrNone || effectsValue < 0 )

   916         {

   917         PSLN_TRACE_DEBUG2("CPslnModel::GetTransitionEffectStateL Error: %d %d", error, effectsValue );

   918         effectsValue = KErrNotFound;

   919         }

   920 

   921     PSLN_TRACE_DEBUG1("CPslnModel::GetTransitionEffectStateL return %d", effectsValue );

   922     return effectsValue;

   923     }

   924 

   925 // -----------------------------------------------------------------------------

   926 // Get Animated Background state

   927 // -----------------------------------------------------------------------------

   928 //

   929 EXPORT_C TInt CPslnModel::AnimBackgroundState() const

   930     {   

   931     TInt value = KErrNone;

   932     TInt error = iThemesAppRepository->Get( KThemesAnimBackgroundSupport, value );

   933     if ( error != KErrNone || value < 0 )

   934         {

   935         value = KMaxTInt;

   936         }

   937 

   938     return value;

   939     }

   940 

   941 // -----------------------------------------------------------------------------

   942 // Set Animated Background state

   943 // -----------------------------------------------------------------------------

   944 //

   945 EXPORT_C TInt CPslnModel::SetAnimBackground( TInt aValue )

   946     {

   947     ASSERT( aValue == EPslnEnableAllEffects ||

   948             aValue == EPslnDisableAllEffects );

   949     

   950     TInt retVal = KErrNone;

   951     if ( aValue == EPslnEnableAllEffects )

   952         {

   953         TInt freeRAM = 0;

   954         HAL::Get( HALData::EMemoryRAMFree, freeRAM );

   955         if ( freeRAM < KPslnTransitionEffectRAMThreshold )

   956             {

   957             return KErrNoMemory;

   958             }

   959         }

   960     iThemesAppRepository->Set( KThemesAnimBackgroundSupport, aValue );

   961         

   962     return retVal;

   963     }

   964 	

   965 // -----------------------------------------------------------------------------

   966 // Checks if screensaver is on memory card.

   967 // -----------------------------------------------------------------------------

   968 //

   969 EXPORT_C TBool CPslnModel::IsScreenSaverOnMemoryCard( const TInt aIndex ) const

   970     {

   971     if ( !iScreensaverFilenameArr || iScreensaverFilenameArr->Count() == 0 )

   972         {

   973         return EFalse;

   974         }

   975 

   976     TLex lex( iScreensaverFilenameArr->MdcaPoint( aIndex ) );

   977     // Skip the first character: '['

   978     lex.Get();

   979     TUint screenSaverPluginImpUid;

   980     TInt currentDrive = EDriveC;

   981     // Get the UID

   982     lex.Val( screenSaverPluginImpUid, EHex );

   983     // Skip character: ']'

   984     lex.Get();

   985     // Get the drive

   986     if ( !lex.Eos() )

   987         {

   988         // Find out which drive the plugin is on

   989         if ( lex.Val( currentDrive ) != KErrNone )

   990             {

   991             return EFalse;

   992             }

   993         }

   994 #ifndef RD_MULTIPLE_DRIVE

   995     if ( currentDrive == EDriveE )

   996         {

   997         return ETrue;

   998         }

   999     return EFalse;

  1000 #else

  1001     RFs& fs = iEikEnv->FsSession();

  1002 

  1003     TUint driveStatus = 0;

  1004     TBool retVal = EFalse;

  1005     TInt err = DriveInfo::GetDriveStatus( fs, currentDrive, driveStatus );

  1006     if ( driveStatus & DriveInfo::EDriveExternallyMountable &&

  1007          driveStatus & DriveInfo::EDriveRemovable )

  1008         {

  1009         retVal = ETrue;

  1010         }

  1011     return retVal;

  1012 #endif // RD_MULTIPLE_DRIVE

  1013     }

  1014 

  1015 // -----------------------------------------------------------------------------

  1016 // Sets currently active content (screensaver/wallpaper) index.

  1017 // -----------------------------------------------------------------------------

  1018 //

  1019 EXPORT_C void CPslnModel::SetCurrentPropertyTypeL(

  1020     const TInt aProperty, const TInt aCurItemIndex )

  1021     {

  1022     PSLN_TRACE_DEBUG2("CPslnModel::SetCurrentPropertyTypeL prop=%d index=%d", 

  1023         aProperty, aCurItemIndex );

  1024 

  1025     if( aCurItemIndex < KPslnDefaultItemIndex )

  1026         {

  1027         User::Leave( KErrArgument );

  1028         }

  1029 

  1030     TInt retVal = KErrNone;

  1031     switch( aProperty )

  1032         {

  1033         case KPslnBgIdleSettingId:

  1034             retVal = iSkinsRepository->Set( KPslnWallpaperType, aCurItemIndex );

  1035             break;

  1036         case KPslnScreenSettingId:

  1037             {

  1038             TInt screensaverType = GetScreensaverTypeByIndex(aCurItemIndex);

  1039             if ( screensaverType == KPslnSsText )

  1040                 {

  1041                 // Query text if necessary

  1042                 TBool ret = QueryAndSetScreensaverTextL();

  1043                 if ( !ret )

  1044                     {

  1045                     User::Leave( KErrCancel );

  1046                     }

  1047                 }

  1048             

  1049             break;

  1050             }

  1051         default:

  1052             break;

  1053         }

  1054     User::LeaveIfError( retVal );

  1055     }

  1056 

  1057 // -----------------------------------------------------------------------------

  1058 // Checks if the theme is on memory card.

  1059 // -----------------------------------------------------------------------------

  1060 //

  1061 EXPORT_C TBool CPslnModel::IsThemeOnMemoryCard( const TInt& aIndex )

  1062     {

  1063 #ifndef RD_MULTIPLE_DRIVE

  1064     return EFalse;

  1065 #else

  1066     PSLN_TRACE_DEBUG("CPslnModel::IsThemeOnMemoryCard");

  1067     TBool isThemeOnMemoryCard = EFalse;

  1068     CPslnSkinEntry* entry = VisibleSkin( aIndex );

  1069     if( entry )

  1070         {

  1071         isThemeOnMemoryCard = entry->IsOnMemoryCard();

  1072         }

  1073     return isThemeOnMemoryCard;

  1074 #endif //RD_MULTIPLE_DRIVE

  1075     }

  1076 

  1077 // -----------------------------------------------------------------------------

  1078 // Checks if the theme is on mass memory.

  1079 // -----------------------------------------------------------------------------

  1080 //

  1081 EXPORT_C TBool CPslnModel::IsThemeOnMassDrive( const TInt& aIndex  )

  1082     {

  1083 #ifndef RD_MULTIPLE_DRIVE

  1084     return EFalse;

  1085 #else

  1086     PSLN_TRACE_DEBUG("CPslnModel::IsThemeOnMassDrive");

  1087     TBool isThemeOnMemoryCard = EFalse;

  1088     CPslnSkinEntry* entry = VisibleSkin( aIndex );

  1089     if( entry )

  1090         {

  1091         isThemeOnMemoryCard = entry->IsOnMassDrive();

  1092         }

  1093     return isThemeOnMemoryCard;

  1094 #endif //RD_MULTIPLE_DRIVE

  1095     }

  1096 

  1097 // -----------------------------------------------------------------------------

  1098 // Checks if the screensaver is on mass memory.

  1099 // -----------------------------------------------------------------------------

  1100 //

  1101 EXPORT_C TBool CPslnModel::IsScreenSaverOnMassDrive( const TInt& aIndex ) const

  1102     {

  1103 #ifndef RD_MULTIPLE_DRIVE

  1104     return EFalse;

  1105 #else

  1106 

  1107     if ( !iScreensaverFilenameArr || iScreensaverFilenameArr->Count() == 0 )

  1108         {

  1109         return EFalse;

  1110         }

  1111 

  1112     TLex lex( iScreensaverFilenameArr->MdcaPoint( aIndex ) );

  1113     // Skip the first character: '['

  1114     lex.Get();

  1115     TUint screenSaverPluginImpUid;

  1116     TInt currentDrive = EDriveC;

  1117     // Get the UID

  1118     lex.Val( screenSaverPluginImpUid, EHex );

  1119     // Skip character: ']'

  1120     lex.Get();

  1121     // Get the drive

  1122     if ( !lex.Eos() )

  1123         {

  1124         // Find out which drive the plugin is on

  1125         if ( lex.Val( currentDrive ) != KErrNone )

  1126             {

  1127             return EFalse;

  1128             }

  1129         }

  1130 

  1131     RFs& fs = iEikEnv->FsSession();

  1132 

  1133     TUint driveStatus = 0;

  1134     TBool retVal = EFalse;