namespace Swi

    // -----------------------------------------------------------------------

    // Two-phased constructor

    // -----------------------------------------------------------------------

    //    

    CVersionRevisor* CVersionRevisor::NewL( CProgramStatus& aMainStatus )

        {

        CVersionRevisor* self = NewLC( aMainStatus );

        CleanupStack::Pop( self );

        return self;

        }

    // ------------------------------------------------------------------------

    // Two-phased constructor

    // ------------------------------------------------------------------------

    //    

    CVersionRevisor* CVersionRevisor::NewLC( CProgramStatus& aMainStatus )

        {

        CVersionRevisor* self = new (ELeave) CVersionRevisor;

        CleanupStack::PushL( self );

        self->ConstructL( aMainStatus );

        return self;    

        }

    // -----------------------------------------------------------------------

    // 2nd constructor

    // -----------------------------------------------------------------------

    //    

    void CVersionRevisor::ConstructL( CProgramStatus& aMainStatus )

        {

        FLOG( _L("[VersionRev] ConstructL start") );

        iSisUninstaller = NULL;

        iStartupReason = KErrNone; 

        // Note revisor do not own this instance.

        iProgramStatus = &aMainStatus;         

        User::LeaveIfError( iFs.Connect() );

        // Get system startup reason.

        TRAP_IGNORE( StartUpReasonL() );         

        FLOG( _L("[VersionRev] ConstructL end") );

        }

    // -----------------------------------------------------------------------

    // c++ destructor

    // -----------------------------------------------------------------------

    //    

    CVersionRevisor::~CVersionRevisor()

        {

        FLOG( _L("[VersionRev] ~CVersionRevisor start") );         

        delete iSisUninstaller;

        iSisUninstaller = NULL;         

        iStubDataArray.ResetAndDestroy();               

        iFs.Close(); 

        FLOG( _L("[VersionRev] ~CVersionRevisor end") ); 

        }

    // -----------------------------------------------------------------------

    // Starts uninstall process.

    // -----------------------------------------------------------------------

    //    

    TInt CVersionRevisor::StartProcessL()

        {  

        FLOG( _L("[VersionRev] StartProcessL start") );        

        TInt err = KErrNone;

//#ifdef _DEBUG        

//FLOG( _L("[VersionRev] FOR TESTING: STARTUP REASON = Firmwareupdate ! ! !") );          

//iStartupReason = EFirmwareUpdate;

//#endif

        // If firmware update is done, start scan process.

         if( iStartupReason == EFirmwareUpdate )

              {                             

              iSisUninstaller = 

                  CSisPkgUninstaller::NewL( *iProgramStatus, *this );  

              TRAP( err, ProcessStubFilesL() );

              FLOG_1( _L("[VersionRev] Process stub TRAP error = %d"), err );

              TRAP( err, ProcessSisRegistryL() ); 

              FLOG_1( _L("[VersionRev] Process sis TRAP error = %d"), err );

              iSisUninstaller->StartUninstallL();                           

              }        

         else

             {

             FLOG( _L("[VersionRev] StartProcessL: No firmware update") );

             // Ok, no need to start process. Leave so main will call delete. 

             User::Leave( KErrAbort );

             }

        FLOG( _L("[VersionRev] StartProcessL end") );

        return KErrNone;

        }

    // -----------------------------------------------------------------------

    // Reads stub sis files.

    // -----------------------------------------------------------------------

    //    

    TInt CVersionRevisor::ProcessStubFilesL()

        {  

        FLOG( _L("[VersionRev] ProcessStubFilesL start") );

        CDir* dir;

        TInt err = iFs.GetDir( 

                KVerRevStubSISDir, 

                KEntryAttNormal, 

                ESortNone, 

                dir );

        if ( err == KErrNone )

            CleanupStack::PushL( dir );

            TInt count = dir->Count();

            FLOG_1( _L("[VersionRev] Stub count = %d"), count );

            for ( TInt index = 0; index < count; index++ )

                {

                FLOG_1( _L("[VersionRev] Stub index = %d"), index );                                               

                TFileName stubName;                 

                stubName.Append( KVerRevStubSISDir );

                stubName.Append( (*dir)[index].iName );                

                FLOG_1( _L("[VersionRev] Stub name: %S\n "), 

                        &(*dir)[index].iName );                

                // Function needs to be trapped because SisController leavs 

                // if some corrupted file is in dir etc.

                TRAP( err, AppendStubInfoL( stubName ) );                            

                }                       

            CleanupStack::PopAndDestroy( dir ); 

            }

        FLOG( _L("[VersionRev] ProcessStubFilesL end") );         

        return err;

    // -----------------------------------------------------------------------

    // Checks rom updates from sis registry and adds pkg UID to array for

    // uninstaller process.

    //

    // Pre contitons for uninstall is: 

    // 1. sis version is older or same as rom STUB version.

    // 2. sis has files only in C drvie.

    // 3. if sis version is same as stub version, all binary files must be

    // present in rom (z:\sys\bin).

    // Rom STUB <- SA       = uninstalled

    // Rom STUB <- SP       = no uninstall, returned drive is Z   (0x04)

    // Rom STUB <- PU       = no uninstall, returned drive is Z+C (0x2000004)

    // Rom STUB <- SA <- SP = SA is uninstalled, SP is not (n-gage) 

    // Rom STUB <- SA <- PU = uninstalled

    // Rom STUB <- SA + emped. sis = SA is uninstalled, empedded pkg is not.

    // -----------------------------------------------------------------------

    //    

    TInt CVersionRevisor::ProcessSisRegistryL()

        FLOG( _L("[VersionRev] ProcessSisRegistryL start") );        

        TInt stubArrayCount = iStubDataArray.Count();

        FLOG_1( _L("[VersionRev] Stub array count = %d"), stubArrayCount );

        if ( stubArrayCount )

            {

            Swi::RSisRegistrySession sisRegSession;                                        

            User::LeaveIfError( sisRegSession.Connect() );                

            CleanupClosePushL( sisRegSession );

            Swi::RSisRegistryEntry entry;                                    

            TInt err = KErrNone;

            // Search correct sis pagace and open entry to it.

            for ( TInt stubIndex = 0; stubIndex < stubArrayCount; stubIndex++ )

                {                  

                TUid stubUID = iStubDataArray[stubIndex]->pkgUID;                 

                FLOG_1( _L("[VersionRev] Stub UID: 0x%x \n "), stubUID.iUid );                                                  

                TBool isInstalled = sisRegSession.IsInstalledL( stubUID );

                if ( isInstalled )

                    {                                

                    err = entry.Open( sisRegSession, stubUID );                     

                    if ( !err )

                        {

                        CleanupClosePushL( entry );                                                                                                                                                                                                                                                                                      

                        TUint drives = entry.InstalledDrivesL();

                        FLOG_1( _L("[VersionRev] Installe drive: 0x%x \n "), 

                                drives );                                                                                               

                        if ( drives == KVerRevDriveC )

                            { 

                            FLOG( _L("[VersionRev] SIS is installed to C:") );                                                        

                            FLOG( _L("[VersionRev] Check SIS version") );

                            TVersion stubVersion(

                                    iStubDataArray[stubIndex]->major,

                                    iStubDataArray[stubIndex]->minor,

                                    iStubDataArray[stubIndex]->build );

                            // Check sis and stub version.              

                            TInt ver = CompareVersions( 

                                   entry.VersionL(), 

                                   stubVersion ); 

                            FLOG_1( _L("[VersionRev] CompareVer.= %d "), ver );                                                                                           

                            TBool removePkg = EFalse;

                            if ( ver == KVerRevSisVersionSame )

                                {

                                // If version is same check that all binary 

                                // files in rom is found. If files are missing

                                // do not remove sis pkg.

                                FLOG( _L("[VersionRev] Sis version same"));

                                removePkg = AllRomBinariesFoundL( entry );

                                }

                            if ( ver == KVerRevSisVersionOlder )

                                {

                                FLOG( _L("[VersionRev] Sis version older"));

                                removePkg = ETrue;

                                } 

                            // Add uid to uninstall array if removePkg is true.

                            if ( removePkg )

                                {                                                                   

                                iSisUninstaller->AddUidToListL( stubUID );

                                FLOG_1( _L("[VersionRev] Uninst. UID:0x%x"), 

                                          stubUID.iUid );                                  

                                } 

                            }//if

                        CleanupStack::PopAndDestroy(); //entry                         

                        }//if                                                                   

                    } //if                                                                          

                } //for  

            CleanupStack::PopAndDestroy(); //sisRegSession

            } //if

        return KErrNone;

        }

    // -----------------------------------------------------------------------

    // This function reads firmware string and checks if firmware update has

    // been done. This function does create file to private directory and

    // saves current firmware version string to it.

    // -----------------------------------------------------------------------

    //    

    void CVersionRevisor::StartUpReasonL()

        {          

        FLOG( _L("[VersionRev] StartUpReasonL") );                           

        iStartupReason = KErrNotFound;                               

        HBufC* currentVersionString = HBufC::NewLC( KVerRevStrLength*2 );

        TPtr currentStringPtr = currentVersionString->Des();

        // Get current firmware string from sysutil. 

        // Firmware string is saved to Z:\\resource\\versions\\sw.txt

        SysUtil::GetSWVersion( currentStringPtr );

        FLOG_1( _L("[VersionRev] Firmware version = %S "), 

                &currentStringPtr );                 

        TUint result;

        // If private directory is not found create it. 

        TInt err = iFs.Att( KVerRevPrivatePath, result );

        if ( ! err == KErrNone && result & KEntryAttDir )

            {                 

            iFs.CreatePrivatePath( EDriveC ); 

            FLOG( _L("[VersionRev] StartUpReasonL: Create private folder") );

            }

        RFile file; 

        TFindFile find( iFs );                      

        // Check if version file is found in Daemon private director.

        err = find.FindByPath( KVerRevVersionFile(), &KVerRevPrivatePath() );

        FLOG_1( _L("[VersionRev] StartUpReasonL: Find file = %d"), err );  

        if ( err )

            {

            // If file is not found this is first boot or user memory (C:) has 

            // been formatted. No need to start version checking but let's save

            // the current firmware version to Daemon private folder.

            err = file.Create( 

                    iFs, 

                    KVerRevVersionFile, 

                    EFileWrite|EFileRead|EFileStreamText );

            FLOG_1( _L("[VersionRev] file create err = %d"), err ); 

            User::LeaveIfError( err );

            // Write current firmware version strign to file. 

            WriteFileText( file, currentStringPtr );

            file.Flush();

            file.Close();                        

            }

        else

            {

            HBufC* previousVersionString = HBufC::NewLC( KVerRevStrLength*2 );

            TPtr previousStringPtr = previousVersionString->Des();            

            // Open firmware version file from private directory.

            err = file.Open( 

                    EFileWrite|EFileRead|EFileStreamText );

            FLOG_1( _L("[VersionRev] file open err = %d"), err ); 

            User::LeaveIfError( err );            

            // Read previous firmware string from the file. 

            ReadFileText( file, previousStringPtr );

            FLOG_1( _L("[VersionRev] Previous sw version: %S"), 

                    &previousStringPtr ); 

            file.Close();

            if ( previousStringPtr.Length() != 0 )

                {                                                                             

                // Compare firmware strings.

                err = previousVersionString->Compare( currentStringPtr );

                FLOG_1( _L("[VersionRev] String compare = %d"), err ); 

                if ( err == KErrNone )

                    {  

                    // Strings are identical, no firmware update.

                    iStartupReason = KErrNone;

                    FLOG( _L("[VersionRev] iStartupReason = KErrNone") );                 

                    }

                else

                    {

                    iStartupReason = EFirmwareUpdate;

                    FLOG( _L("[VersionRev] iStartupReason = EFirmwareUpdate") );                     

                    file.Replace(                    

                        iFs, 

                        KVerRevVersionFile, 

                        EFileWrite|EFileStreamText );                                        

                    // Ok we have firmware update. Let's write new firmware 

                    // string to file and start version checking.

                    WriteFileText( file, currentStringPtr );                                                                                 

                    file.Flush();

                    file.Close();  

                    }

                }            

            CleanupStack::PopAndDestroy(); //previousVersionString  

            }                                                                   

        CleanupStack::PopAndDestroy( ); //currentVersionString                  

        }

    // -----------------------------------------------------------------------

    // Help function to read firmware version string from file.

    // -----------------------------------------------------------------------

    //  

    void CVersionRevisor::ReadFileText( RFile& aFile, TDes& aText )

        {                        

        TFileText fileText;

        fileText.Set( aFile );

        fileText.Read( aText );

         // Replace new-line patterns with real ones.

         TInt position = aText.Find( KVerRevNewLinePattern );

         while ( position != KErrNotFound )

             {

             // err is a position

             aText.Replace( 

                     position, 

                     KVerRevNewLinePattern().Length(), 

                     KVerRevNewLine );

             position = aText.Find( KVerRevNewLinePattern );

             }                        

        }

    // -----------------------------------------------------------------------

    // Help function to write firmware version string from file.

    // -----------------------------------------------------------------------

    //  

    void CVersionRevisor::WriteFileText( RFile& aFile, TDes& aText )

        { 

        // Replace real new-line marker with pattern. This makes 

        // reading operation easy.

        TInt position = aText.Find( KVerRevNewLine );                

        while ( position != KErrNotFound )

            {                

            aText.Replace( 

                    position, 

                    KVerRevNewLine().Length(), 

                    KVerRevNewLinePattern );

             position = aText.Find( KVerRevNewLine );

             }

        TFileText fileText;

        fileText.Set( aFile );

        fileText.Write( aText );                       

        }

    // -----------------------------------------------------------------------

    // This function reads stub sis files version and uid and adds the info

    // in array.

    // -----------------------------------------------------------------------

    //  

    void CVersionRevisor::AppendStubInfoL( TDesC& aStubName )

        {                                             

        CFileSisDataProvider* provider = 

            CFileSisDataProvider::NewLC( iFs, aStubName );

        Sis::CController* stubData = Sis::CController::NewLC( *provider );

        const Sis::CVersion& version = stubData->Info().Version();

        TVersionRevStubData* stubPkg = new( ELeave ) TVersionRevStubData();

        CleanupStack::PushL( stubPkg );        

        stubPkg->pkgUID = stubData->Info().Uid().Uid();

        stubPkg->major = version.Major();

        stubPkg->minor = version.Minor();

        stubPkg->build = version.Build();

        iStubDataArray.AppendL( stubPkg );

        CleanupStack::Pop( stubPkg );

 #ifdef _DEBUG  

        RDebug::Print( _L("[VersionRev] Add Stub UID: 0x%x Ver: %d.%d.%d\n "),                  

                  stubData->Info().Uid().Uid(),

                  version.Major(),

                  version.Minor(),

                  version.Build() );        

 #endif

        CleanupStack::PopAndDestroy( 2, provider );

        provider = NULL;

        stubData = NULL;

        stubPkg = NULL;        

        }

    // -----------------------------------------------------------------------    

    // This function compares sis and stub versions. 

    // -----------------------------------------------------------------------

    //   

    TInt CVersionRevisor::CompareVersions( 

        TVersion aSisVer, 

        TVersion aStubVer )

        { 

        FLOG( _L("[VersionRev] CompareVersions()") );

        // Compare major version

        if ( aSisVer.iMajor > aStubVer.iMajor  )

            FLOG( _L("[VersionRev] STUB major version older ") );