/*

* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:  Implementation of CScrBackupUtil

*

*/

#include "javascrbackuputil.h"

#include "midp2backupdataids.h"

#include "logger.h"

#include "javasymbianoslayer.h" // for CleanupResetAndDestroyPushL

#include <scs/nullstream.h>

#include <e32cmn.h> 

#include <apaid.h> //for TApaAppCapability::ENonNative

#include <e32def.h>

using namespace java::backup;

using namespace Usif;

// Properties registered to SCR.

_LIT(KMIDletName, "MIDlet-Name");

_LIT(KUid, "Uid");

_LIT(KMediaId, "Media-Id");

_LIT(KMIDletInfoURL, "MIDlet-Info-URL");

_LIT(KMIDletDescription, "MIDlet-Description");

_LIT(KDownloadURL, "Download-URL");

_LIT(KSettingsPlugin, "SettingsName");

_LIT(KMIDletDeletionConformation, "MIDlet-Delete-Confirm");

_LIT(KDomainCategory,"Domain-Category");

CScrBackupUtil* CScrBackupUtil::NewL()

    {

    LOG(EBackup,EInfo," --->  CScrBackupUtil:  NewL()");

    CScrBackupUtil *self = CScrBackupUtil::NewLC();

    CleanupStack::Pop(self);

    LOG(EBackup,EInfo," <--- CScrBackupUtil: NewL()");

    return self;

    }

CScrBackupUtil* CScrBackupUtil::NewLC()

    {

    LOG(EBackup,EInfo," --->  CScrBackupUtil: NewLC");

    CScrBackupUtil *self = new(ELeave) CScrBackupUtil();

    CleanupStack::PushL(self); 

    self->ConstructL();

    LOG(EBackup,EInfo," <--- CScrBackupUtil: NewLC");

    return self;

    }

CScrBackupUtil::CScrBackupUtil():iPtrToWriteBuffer(NULL,0)

    {

    LOG(EBackup,EInfo," --->  CScrBackupUtil: CScrBackupUtil");

    LOG(EBackup,EInfo," <---  CScrBackupUtil: CScrBackupUtil");

    }

void CScrBackupUtil::ConstructL()

    {

        LOG(EBackup,EInfo," ---> CScrBackupUtil: ConstructL ");

        //will be incremented as and when needed

        iRemainingInfo = HBufC8::NewL(4096);//TODO :need to change it to the total size of the the attribute

        //iPtrToWriteBuffer = ((const_cast<TUint8*>(iRemainingInfo->Ptr())));// need to do this coz when fun end and goes to fetch next 4096 bytes i lose it

        iPtrToWriteBuffer.Set(iRemainingInfo->Des());

        iIsFristCall = ETrue;

        iState = EIsFetchCompleteInfo;

        iIsToWriteInStream = ETrue;

        LOG(EBackup,EInfo," <--- CScrBackupUtil: ConstructL()");

    }

void CScrBackupUtil::ConnectScrL()

    {

            LOG(EBackup,EInfo," ---> CScrBackupUtil: ConnectScrL()");

            iScr = new RSoftwareComponentRegistry();

            if (NULL == iScr)

            {

                ELOG(EBackup,"Creating RSoftwareComponentRegistry failed");

                User::Leave(KErrGeneral);

            }

            TInt err = iScr->Connect();

            if (KErrNone != err)

            {

                ELOG1(EBackup,"Connecting to RSoftwareComponentRegistry failed, error %d",err);

                //TODO need to see can we afford leaving here ;)

                User::Leave(err);

            }

            LOG(EBackup,EInfo," <--- CScrBackupUtil: ConnectScrL()");

    }

void CScrBackupUtil::ExtractUidAndComponentIdL(RArray<Usif::TComponentId>& componentIds,RArray<TInt>& uids,TInt& ComponentsCount)

    {

        LOG(EBackup,EInfo," ---> CScrBackupUtil: ExtractUidAndComponentId()");

        CComponentFilter* filter;

        CPropertyEntry* property;

        filter = CComponentFilter::NewLC();

        //Set the filter for software type Usif::KSoftwareTypeJava and ftech the Ids

        filter->SetSoftwareTypeL(Usif::KSoftwareTypeJava);

        TRAPD(error,iScr->GetComponentIdsL(componentIds,filter));

        if(error)

            {

            ELOG(EBackup,"Failed to get the components ID");

            }

        CleanupStack::PopAndDestroy(filter);

        // fetch the no. of component from the given RArray

        ComponentsCount = componentIds.Count();

        // No use of Component Ids as such as they are used by SCR internally 

        //so exctracted the UID of of each component

        for(TInt i = 0 ;i < ComponentsCount ; i++)

            {

                property = iScr->GetComponentPropertyL(componentIds.operator [](i),KUid());

                if (property->PropertyType() == CPropertyEntry::EIntProperty)

                        {

                           TInt uid = ((CIntPropertyEntry*)property)->IntValue();

                           uids.AppendL(uid);

                        }

                        else

                        {

                                 //Error

                        }  

                        delete property;

                        property = NULL;

            }

        LOG(EBackup,EInfo," <--- CScrBackupUtil: ExtractUidAndComponentId()");

    }

void CScrBackupUtil::BackupScrDataL(RDesWriteStream& aStream, TBool& aBackupNotFinished, TInt& aBufferSpaceLeft)

    {

        LOG(EBackup,EInfo," ---> CScrBackupUtil: BackupScrDataL()");

        iBufferSpaceLeft = aBufferSpaceLeft ;

        if(iIsFristCall)

            {

                // to get no. of components need to keep a flag that its called only once

                ConnectScrL();

                ExtractUidAndComponentIdL(iComponentIds,iUids,iNumberOfComponents);

                //write the no. of components so that it will help us in restoration time

                aStream.WriteInt32L(iNumberOfComponents);

                iBufferSpaceLeft -= sizeof(TInt32);

                //all the ids of the midlets that are to be backedup and the size of the rarray with holds the Ids 

                TPckgBuf<RArray<TInt> > ids(iUids);

                TInt size = ComputeSizeL(ids);

                aStream.WriteInt32L(size);

                iBufferSpaceLeft -= sizeof(TInt32);

                aStream.WriteL(ids);

                iBufferSpaceLeft = iBufferSpaceLeft - size;

                iIsFristCall = EFalse;

            }    

            for( i ; i < iComponentIds.Count() ;)

                {

                    if(iState == EIsFetchCompleteInfo)

                        {

                            TInt at = iComponentIds.operator[](i);

                            //Temp stream in which all attributes are backed up 

                            RDesWriteStream writeStream;

                            writeStream.Open(iPtrToWriteBuffer);

                            GetComponentInfoL(at,writeStream);

                            writeStream.CommitL();

                            iLengthOfString = iPtrToWriteBuffer.Length();

                            iWriteToStream = ETrue;

                            // write the size, Used while restoring

                            aStream.WriteInt32L(iLengthOfString);

                            iBufferSpaceLeft = iBufferSpaceLeft - sizeof(TInt);

                        }

                    if(iState == EIsWriteCompleteInfo)

                        {                           

                            //writing the remaining information into the new buffer

                            if(iBufferToWriteNextTime)

                            {

                                aStream.WriteL(iPtrToWriteBuffer,iRemainingBuffer);

                                aStream.CommitL();

                                LOG(EBackup, EInfo, "attributes written fully in the stream fetching for next component");

                                iBufferSpaceLeft = iBufferSpaceLeft - iRemainingBuffer;

                                iBufferToWriteNextTime = EFalse;

                                iState = EIsFetchCompleteInfo;

                                iLengthOfString = 0; // to maintain the loop

                                iWriteToStream = EFalse;

                                i++;

                            }

                            // if the whole string cannot be writen, write part of it

                            if (iLengthOfString > iBufferSpaceLeft && !iBufferToWriteNextTime)

                            {

                                iRemainingBuffer = iLengthOfString - iBufferSpaceLeft;

                                aStream.WriteL(iPtrToWriteBuffer,iBufferSpaceLeft);

                                aStream.CommitL();

                                iBufferToWriteNextTime = ETrue;

                                break;

                            }

                            // else write the complete string

                            else if(iWriteToStream)

                            {       aStream.WriteL(iPtrToWriteBuffer,iLengthOfString);

                                    aStream.CommitL();

                                    iBufferSpaceLeft = iBufferSpaceLeft - iLengthOfString;

                                    iState = EIsFetchCompleteInfo;

                                    iLengthOfString = 0; // to maintain the loop 

                                    i++;

                            }

                        }

                }

            // making it false to backup next component next time

            if(i >= iComponentIds.Count())

                aBackupNotFinished = EFalse; 

    }

template <typename T>

TInt CScrBackupUtil::ComputeSizeL(const T &aObject)

    {

        LOG(EBackup,EInfo," ---> computeSize() ");

        TInt size(0);

        RNullWriteStream nullstream;

        CleanupClosePushL(nullstream);

        nullstream << aObject;

        nullstream.CommitL();

        size = nullstream.BytesWritten();

        CleanupStack::PopAndDestroy(&nullstream);

        LOG(EBackup,EInfo," <--- computeSize() ");

        return size;

    }

void CScrBackupUtil::GetComponentInfoL(TComponentId aComponentId ,RDesWriteStream& aStream )

    {

        LOG(EBackup,EInfo," ---> GetComponentInfo() ");

        TInt j = 0 ;

        CPropertyEntry* property;

        CComponentEntry* entries = CComponentEntry::NewL();

        CleanupStack::PushL(entries);

        TLanguage language =KNonLocalized;

        TBool result = iScr->GetComponentL(aComponentId,*entries,language);

        entries->ExternalizeL(aStream);

        CleanupStack::PopAndDestroy(entries);

        TBool isComponentPresent = iScr->IsComponentPresentL(aComponentId);

        aStream.WriteInt8L(isComponentPresent);

        // Localizable Component info 

        RPointerArray<CLocalizableComponentInfo> localizableComponentInfo;

        iScr->GetComponentLocalizedInfoL(aComponentId,localizableComponentInfo);

        aStream.WriteInt32L(localizableComponentInfo.Count());

        for(j ; j < localizableComponentInfo.Count(); j++)

            {

                    (localizableComponentInfo.operator [](j))->ExternalizeL(aStream);

            }

        // Properties

        // extracted the UID

        property = iScr->GetComponentPropertyL(aComponentId,KUid());

        if (NULL != property)

            {  

                 property->ExternalizeL(aStream);

                delete property;

                property = NULL;

            }

        else 

            {

                // need to return or have to proceed

            }

        // Exctracted Domain - Category

        property = iScr->GetComponentPropertyL(aComponentId,KDomainCategory());

        if (NULL != property)

            {

                property->ExternalizeL(aStream);

                delete property;

                property = NULL;

            }

        // Exctracted Media ID

        property = iScr->GetComponentPropertyL(aComponentId,KMediaId());

        if (NULL != property)

            {

                property->ExternalizeL(aStream);

                delete property;

                property = NULL;

            }

        // Exctracted Setings plugin name

        property = iScr->GetComponentPropertyL(aComponentId,KSettingsPlugin());

        if (NULL != property)

            {

                property->ExternalizeL(aStream);

                delete property;

                property = NULL;

            }

        // Optional Properties

        // extracted info URL

        property = iScr->GetComponentPropertyL(aComponentId,KMIDletInfoURL());

        if (NULL != property)

            {

                property->ExternalizeL(aStream);

                delete property;

                property = NULL;

            }

        else // as its optional property so could be NULL 

            {

                aStream.WriteInt8L(NULL);

            }

        // extracted midlet description

        property = iScr->GetComponentPropertyL(aComponentId,KMIDletDescription());

        if (NULL != property)

            {

                property->ExternalizeL(aStream);

                delete property;

                property = NULL;

            }

        else // as its optional property so could be NULL 

           {

               aStream.WriteInt8L(NULL);

           }

        // extracted midlet DeletionConformation

        property = iScr->GetComponentPropertyL(aComponentId,KMIDletDeletionConformation());

        if (NULL != property)

            {

                property->ExternalizeL(aStream);

                delete property;

                property = NULL;

            }

        else // as its optional property so could be NULL 

           {

               aStream.WriteInt8L(NULL);

           }

        //extracted midlet DN URL

        property = iScr->GetComponentPropertyL(aComponentId,KDownloadURL());

        if (NULL != property)

            {  

              property->ExternalizeL(aStream);

              delete property;

              property = NULL;

            }

        else // as its optional property so could be NULL 

           {

               aStream.WriteInt8L(NULL);

           }

        // backing up files corresponds to component

        RSoftwareComponentRegistryFilesList fileList;

        CleanupClosePushL(fileList);

        TInt count = iScr->GetComponentFilesCountL(aComponentId); 

        TInt k = 0;

        RPointerArray<HBufC> files;

        fileList.OpenListL(*iScr,aComponentId);

        fileList.NextFileSetL(count,files);        

        aStream.WriteInt32L(files.Count());

        CleanupStack::PopAndDestroy(&fileList);//filelist

        for( k ; k < files.Count(); k++)

            {

               HBufC* temp =  files.operator [](k);

               aStream.WriteInt32L(temp->Length());

               aStream.WriteL(temp->Des());                                    

            }

        RArray<TUid> noOfApps; 

        HBufC* appIcon;

        TAppRegInfo appInfo;

        iScr->GetAppUidsForComponentL(aComponentId,noOfApps); 

        RRegistrationInfoForApplication regInfoIcon;

        CleanupClosePushL(regInfoIcon);

        RApplicationRegistrationInfo regInfoCaption;

        CleanupClosePushL(regInfoCaption);

       //backing up the no. of apps

       aStream.WriteInt32L(noOfApps.Count()); 

        for(j = 0 ; j < noOfApps.Count(); j++ )

            {

                regInfoIcon.OpenL(*iScr,noOfApps.operator [](j));

                regInfoCaption.OpenL(*iScr);

               //check if language is imp to give as an argument\

               // Language extracted

               TLanguage language = regInfoIcon.ApplicationLanguageL();

               // Language backed up

               aStream.WriteInt32L(language);

               // AppUID extracted

               TUid appUid = noOfApps[j];               

               // AppUID backed up

               aStream.WriteInt32L(appUid.iUid);

               //App caption extracted 

               regInfoCaption.GetAppInfoL(appUid,appInfo,language);

               TAppCaption caption = appInfo.Caption();

               caption.Trim();// would give the acctual size of content

               //App caption backed up

               aStream.WriteL(caption);

               //AppIcon path extracted

               regInfoIcon.GetAppIconL(appIcon);

               //AppIcon path backed up

               aStream.WriteL(appIcon->Des());

               //need to backup no. of icons to needed for registrating application

               TInt noOfIcons = regInfoIcon.NumberOfOwnDefinedIconsL();

               aStream.WriteInt32L(noOfIcons);

            }

               CleanupStack::PopAndDestroy();//regInfoIcon

               CleanupStack::PopAndDestroy();//regInfoCaption

               //regInfoIcon.Close();

               //regInfoCaption.Close();

        iState = EIsWriteCompleteInfo;

        LOG(EBackup,EInfo," <--- GetComponentInfo() ");

    }

void CScrBackupUtil::RestoreScrDataL(RDesReadStream& aStream, TInt& aRestoreState, TInt& aBufferSpaceLeft)

    {

		LOG(EBackup,EInfo," ---> RestoreScrDataL() ");

        if(iIsFristCall)

            {

                ConnectScrL();

                TInt j = 0;

                TInt presentComponentsCount;

                RArray<Usif::TComponentId> presentComponentsIds;

                iBufferSpaceLeft = aBufferSpaceLeft;

                //aStream.r

                //reading components count

                iNumberOfComponents = aStream.ReadInt32L();

                iBufferSpaceLeft = iBufferSpaceLeft - sizeof(TInt32);

                //reading the size of the TPckgBuf<RArray<TComponentId>>

                TInt size = aStream.ReadInt32L();

                iBufferSpaceLeft = iBufferSpaceLeft - sizeof(TInt32);

                //reading TPckgBuf<RArray<TComponentId>> 

                HBufC* temp = HBufC::NewLC(aStream , size);

                TPckgBuf<RArray<TInt> > ids;

                //extracting RArray from TPckgBuf<RArray<TUids>>

                ids.Append(temp->Des());

                CleanupStack::PopAndDestroy(temp);

                iUids = ids.operator ()();// populated iUids

                iBufferSpaceLeft = iBufferSpaceLeft - size;

                iNumberOfComponents = iUids.Count();

                ExtractUidAndComponentIdL(presentComponentsIds,iPresentUids,presentComponentsCount);

                // calculating the midlets to be deleted from SCR

                for(j ; j <= iNumberOfComponents ; j++ )

                    {

                          TInt id = NULL;

                          TInt index = 0;

                          id = iUids.operator [](j);

                          index = iPresentUids.Find(iUids.operator [](j));

                          if(index != NULL)

                              {

                                  presentComponentsIds.Remove(index);// removeing the app that is present in SCr and backed up too

                                  iPresentUids.Remove(index);// TODO : check if right component Id is removed

                              }       

                    }