using namespace Swi;

//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;

    // 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( 

                iFs, 

                KVerRevVersionFile, 

                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(                    

                    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 ") );

        return KVerRevSisVersionNewer;

    // If same major version, check minor version.

    else if ( aSisVer.iMajor == aStubVer.iMajor )

        {