diff -r e5618cc85d74 -r 6c158198356e javamanager/javabackup/midp2backup_usif/src.s60/javascrbackuputil.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/javamanager/javabackup/midp2backup_usif/src.s60/javascrbackuputil.cpp	Thu Aug 19 09:48:13 2010 +0300
@@ -0,0 +1,1014 @@
+/*
+* 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
+                              }       
+                    }
+
+                
+                   iPresentUids.Compress();  // need to see if this works
+                   presentComponentsIds.Compress();// contains the uids that has to be deleted
+                   //Updated the count
+                   presentComponentsCount = iPresentUids.Count();
+                   for(j = 0 ; j <= presentComponentsCount ; j++ )
+                       {       
+                           TRAPD(err ,iScr->DeleteApplicationEntriesL(presentComponentsIds.operator [](j)));
+                           if (KErrNone == err)
+                               {
+                                   iScr->DeleteComponentL(presentComponentsIds.operator [](j));
+                               }
+                            
+                       }
+                   
+                   
+            }
+        RDesReadStream readStream;
+        readStream.Open(iPtrToWriteBuffer);
+        for( i ; i < iComponentIds.Count() ;)
+            {
+                if(iState == EIsFetchCompleteInfo)
+                    {   
+                        TUid uid ;
+                        uid.iUid = iUids.operator [](i);
+                        SetDataInScrL(uid,readStream);
+                        i++;
+                    }
+                if(iState == EIsWriteCompleteInfo)
+                    {                           
+                        RDesReadStream readStream;
+                        readStream.Open(iPtrToWriteBuffer);
+                        iLengthOfString = aStream.ReadInt32L();
+                        
+                         
+                        //Reading the remaining information into the new buffer
+                        if(iBufferToWriteNextTime)
+                            {
+                            //appened it in the remaing
+                             HBufC* remainingBuff = HBufC::NewL(iRemainingBuffer);
+                             TPtr ptr(remainingBuff->Des());            
+                             aStream.ReadL(ptr,iRemainingBuffer);
+                             iPtrToWriteBuffer.Append(ptr);
+                             iState = EIsFetchCompleteInfo;                     
+                             iLengthOfString = 0; // to maintain the loop
+                             iWriteToStream = EFalse;
+                                                       
+                            
+                            }
+                        if (iLengthOfString > iBufferSpaceLeft && !iBufferToWriteNextTime)
+                        {  
+                        iRemainingBuffer = iLengthOfString - iBufferSpaceLeft;
+                        aStream.ReadL(iPtrToWriteBuffer,iBufferSpaceLeft);
+                        iBufferToWriteNextTime = ETrue;
+                        break ;
+                        }
+                        // Read the complete string
+                        else if(iWriteToStream)
+                        {       
+                            aStream.ReadL(iPtrToWriteBuffer,iLengthOfString);
+                            iBufferSpaceLeft = iBufferSpaceLeft - iLengthOfString;
+                            iState = EIsFetchCompleteInfo;
+                            iLengthOfString = 0; // to maintain the loop 
+                            
+                        }
+                                                
+                    }
+            }
+        //take care of restorestate
+        // SCR restore is over; Set state to EAppArc
+        if(i >= iComponentIds.Count())
+            {
+                aRestoreState = EAppArc;
+                aBufferSpaceLeft = iBufferSpaceLeft;// need to to this coz of last iteration
+            }
+              
+        LOG(EBackup,EInfo," <--- RestoreScrDataL() ");
+    }
+void CScrBackupUtil::SetDataInScrL(TUid aUid , RDesReadStream& aStream)
+    {
+		LOG(EBackup,EInfo," ---> SetDataInScrL() ");
+        TInt tempSize = NULL;
+        TInt j = 0;
+        tempSize = aStream.ReadInt32L();
+        CComponentEntry* entries;
+        entries = CComponentEntry::NewL();
+        CleanupStack::PushL( entries);
+        entries->InternalizeL(aStream);
+        
+        
+        TBool isComponentPresent = aStream.ReadInt8L();
+        
+        // Localizable Component info 
+        RPointerArray<CLocalizableComponentInfo> localizableComponentInfoArray; // Not owned by me nee to delete in last 
+        TInt temp = aStream.ReadInt32L();
+        for(j ; j <= temp; j++)
+            {
+                CLocalizableComponentInfo* componentinfo = CLocalizableComponentInfo::NewL(aStream);
+                localizableComponentInfoArray.Append(componentinfo);
+            }
+ 
+        // now need to set all the properties
+        // extracted the UID
+        CIntPropertyEntry* property;
+        property = (CIntPropertyEntry*)CPropertyEntry::NewL(aStream);
+        TInt64 id = property->Int64Value();
+        delete property;
+        
+        //extracted midlet Domain-Catogary
+        CLocalizablePropertyEntry* propertyString;
+        propertyString =(CLocalizablePropertyEntry*) CPropertyEntry::NewL(aStream);
+        HBufC* domainCategory  = (propertyString->StrValue()).Alloc();
+        delete propertyString;
+        
+        // Exctracted Media ID
+        property = (CIntPropertyEntry*)CPropertyEntry::NewL(aStream);
+        TInt64 mediaID = property->Int64Value();
+        delete property;
+        
+        //extracted midlet SettingsValue
+        propertyString =(CLocalizablePropertyEntry*) CPropertyEntry::NewL(aStream);
+        HBufC* SettingsValue  = (propertyString->StrValue()).Alloc();
+        delete propertyString;
+        
+        // Optional Properties
+        // extracted info URL
+        propertyString = propertyString = (CLocalizablePropertyEntry*)CPropertyEntry::NewL(aStream);  
+        HBufC* url = (propertyString->StrValue()).Alloc();
+        delete propertyString;
+                    
+               
+        // extracted midlet description
+        propertyString = (CLocalizablePropertyEntry*)CPropertyEntry::NewL(aStream);
+        HBufC* midletDescription  = (propertyString->StrValue()).Alloc();
+        delete propertyString;
+        
+        // midlet deletion conformation has to be here
+        CBinaryPropertyEntry* propertyBinary = (CBinaryPropertyEntry*)CPropertyEntry::NewL(aStream);
+        HBufC8* midletDeletionConformation  = (propertyBinary->BinaryValue()).Alloc();
+        delete propertyBinary;
+        
+        //extracted midlet DN URL
+        propertyString =(CLocalizablePropertyEntry*) CPropertyEntry::NewL(aStream);
+        HBufC* dnUrl  = (propertyString->StrValue()).Alloc();
+        delete propertyString;
+        
+        //Extracting no. of files registered with a component
+        //1st the no. of files
+        RPointerArray<HBufC> componentFilesArray;
+        
+        TInt fileCount = aStream.ReadInt32L();
+       //now the files 
+        for(TInt k = 0 ; k < fileCount ; k++)
+            {   
+                TInt size = aStream.ReadInt32L();
+                HBufC* componentFile = HBufC::NewL(aStream,size);
+                CleanupStack::PushL( componentFile);
+                componentFilesArray.AppendL(componentFile);
+                CleanupStack::Pop( componentFile);
+            }
+        
+        //Extracting no. of apps with a component
+        TInt noOfApps = aStream.ReadInt32L();
+        RPointerArray<CAppInfo> appinfoArray;
+        for(j = 0 ; j < noOfApps ; j++ )
+            {
+                   CAppInfo* appinfo = CAppInfo::NewL();
+                   CleanupStack::PushL( appinfo);// i will not own it after using has to be destroyed  
+                   TLanguage language;
+                   language = (TLanguage)(aStream.ReadInt32L());
+                   TUid uid;
+                   uid.Uid(aStream.ReadInt32L());
+                   
+                   TAppCaption caption ;
+                   aStream.ReadL(caption);
+                   HBufC* appIcon ;
+                   TPtr temp(appIcon->Des());
+                   aStream.ReadL(temp);
+                   TInt noOfIcons = aStream.ReadInt32L();
+                   
+                   appinfo->Set(language,uid,caption,temp,noOfIcons);// TODO: check if it works
+                   appinfoArray.Append(appinfo);
+                   
+                   
+                   
+            }
+        
+         
+        TInt index =  iPresentUids.Find(aUid.iUid);
+        if(index != NULL)
+            {           CComponentEntry* entry = CComponentEntry::NewLC();
+                        TUid uid ;
+                        uid.Uid(iPresentUids.operator [](index));
+                        TComponentId componentId = iScr->GetComponentIdForAppL(uid);
+                        iScr->GetComponentL(componentId,*entry);
+                        HBufC* versionPresent = entry->Version().AllocLC();
+                        CleanupStack::PopAndDestroy(entry);
+                        HBufC* versionBackUpComponent = entries->Version().AllocLC();
+                       if((versionPresent->CompareC(versionBackUpComponent->Des())))//check version
+                           {
+                                   //ignore  Write a log statement as the midlet is same no need to do any thing :)
+                           }    
+                       else 
+                           {
+                             //  delete it and thn register it 
+                             TRAPD(err ,iScr->DeleteApplicationEntriesL(componentId));
+                             if (KErrNone == err)
+                                  {
+                                      iScr->DeleteComponentL(componentId);
+                                  }
+                            // call register
+                            TComponentId newComponentId = RegisterComponentL(*entries,uid,url->Des(),midletDescription->Des(),midletDeletionConformation->Des(),dnUrl->Des(),mediaID,domainCategory->Des(),SettingsValue->Des(),componentFilesArray,isComponentPresent,localizableComponentInfoArray);
+                             for(j=0; j < appinfoArray.Count() ; j++)
+                                 {
+                                     CAppInfo* appInfo = appinfoArray.operator [](j);
+                                     
+                                     RegisterApplicationL(newComponentId,appInfo->GetAppUid(),appInfo->GetCaption(),appInfo->GetAppIcon()->Des(),appInfo->NoOfIcons(),appInfo->GetLanguage());
+                                     CleanupStack::PopAndDestroy(appInfo);
+                                 }
+                           }
+                       CleanupStack::PopAndDestroy(versionPresent);
+                       CleanupStack::PopAndDestroy(versionBackUpComponent);
+            }
+        else
+            {
+                //just go register it as its not there in the phone 
+                TComponentId newComponentId = RegisterComponentL(*entries,aUid,url->Des(),midletDescription->Des(),midletDeletionConformation->Des(),dnUrl->Des(),mediaID,domainCategory->Des(),SettingsValue->Des(),componentFilesArray,isComponentPresent,localizableComponentInfoArray);
+                 for(j=0; j < appinfoArray.Count() ; j++)
+                     {
+                         CAppInfo* appInfo = appinfoArray.operator [](j);
+                         
+                         RegisterApplicationL(newComponentId,appInfo->GetAppUid(),appInfo->GetCaption(),appInfo->GetAppIcon()->Des(),appInfo->NoOfIcons(),appInfo->GetLanguage());
+                         CleanupStack::PopAndDestroy(appInfo);
+                     }
+            }
+        
+        //CleanupStack::Pop();//componentFilesArray
+        CleanupStack::PopAndDestroy( entries);
+        
+        LOG(EBackup,EInfo," <--- SetDataInScrL() ");
+    }
+
+
+TComponentId CScrBackupUtil::RegisterComponentL(CComponentEntry& aEntry ,TUid aUid,TPtr aMidletInfoUrl,
+        TPtr aMidletDescription,TPtr8 aMidletDeletionConformation, TPtr aDownloadUrl,TInt64 aMediaId,TPtr aDomainCatogary , TPtr aSettingValue,
+        RPointerArray<HBufC>& aComponentFilesArray, TBool aIsComponentPresent,RPointerArray<CLocalizableComponentInfo>& aLocalizableComponentInfoArray)
+{
+	LOG(EBackup,EInfo," ---> RegisterComponentL() ");
+    HBufC* globalId =( aEntry.GlobalId()).AllocLC();
+   
+    TComponentId componentId = iScr->AddComponentL(aLocalizableComponentInfoArray,Usif::KSoftwareTypeJava,globalId);
+   
+    
+    
+    iScr->SetComponentVersionL(componentId, aEntry.Version());
+    //LOG1(EJavaInstaller, EInfo, "RegisterComponentL: version set %s",*version);
+    
+    iScr->SetIsComponentRemovableL(componentId, aEntry.IsRemovable());
+    
+    
+    iScr->SetIsComponentDrmProtectedL(componentId, aEntry.IsDrmProtected());
+    
+    
+    iScr->SetIsComponentKnownRevokedL(componentId,aEntry.IsKnownRevoked());
+    
+    
+    iScr->SetIsComponentOriginVerifiedL(componentId, aEntry.IsOriginVerified());
+    
+    
+    iScr->SetComponentSizeL(componentId, aEntry.ComponentSize());
+    
+    
+    iScr->SetScomoStateL(componentId,aEntry.ScomoState());
+    
+    
+    iScr->SetIsComponentPresentL(componentId,aIsComponentPresent);
+    
+    
+    
+    iScr->SetComponentPropertyL(componentId,KUid(), aUid.iUid);
+    
+    
+    iScr->SetComponentPropertyL(componentId,KMIDletInfoURL(),aMidletInfoUrl);
+    
+    iScr->SetComponentPropertyL(componentId, KMIDletDescription(), aMidletDescription);
+    
+    iScr->SetComponentPropertyL(componentId,KMIDletDeletionConformation(),aMidletDeletionConformation);
+        
+    iScr->SetComponentPropertyL(componentId, KDownloadURL(), aDownloadUrl);
+    
+    iScr->SetComponentPropertyL(componentId,KDomainCategory(),aDomainCatogary);
+    
+    iScr->SetComponentPropertyL(componentId, KMediaId(), aMediaId);
+    
+    
+    iScr->SetComponentPropertyL(componentId, KSettingsPlugin(), aSettingValue);
+    
+
+    CleanupStack::PopAndDestroy(globalId);
+  
+    TInt fileCount = aComponentFilesArray.Count();
+    for (TInt i = 0; i < fileCount; i++)
+    {
+        HBufC *componentFile = aComponentFilesArray.operator [](i);
+        iScr->RegisterComponentFileL(componentId, *componentFile);
+        CleanupStack::PopAndDestroy(componentFile);
+    }
+    LOG(EBackup,EInfo," <--- RegisterComponentL() ");
+    return componentId;
+}
+
+void CScrBackupUtil::RegisterApplicationL(TInt aComponentId, TUid aAppUid,
+        TAppCaption aAppName, TDesC aIconFilename, TInt aNumberOfIcons,
+        TLanguage aLanguages)
+    {
+		LOG(EBackup,EInfo," ---> RegisterApplicationL() ");
+        TFileName appName;
+        RPointerArray<HBufC> ownedFileArray; // codescanner::resourcenotoncleanupstack
+        RPointerArray<Usif::CServiceInfo> serviceArray; // codescanner::resourcenotoncleanupstack
+        RPointerArray<Usif::CPropertyEntry> appPropertiesArray; // codescanner::resourcenotoncleanupstack
+        RPointerArray<Usif::CAppViewData> viewDataList; // codescanner::resourcenotoncleanupstack
+
+        RPointerArray<Usif::COpaqueData> opaqueDataArray;
+        CleanupResetAndDestroyPushL(opaqueDataArray);
+        // Write application Uid to opaque data (needed by MIDlet launcher).
+        TBuf8<4> opaqueDataBuf; // Opaque data will contain one signed 32-bit int.
+        RDesWriteStream writeStream(opaqueDataBuf);
+        writeStream.WriteInt32L(aAppUid.iUid);
+        writeStream.CommitL();
+        
+       
+        
+        COpaqueData *opaqueData = COpaqueData::NewLC(opaqueDataBuf, KUnspecifiedLocale);
+        opaqueDataArray.AppendL(opaqueData);
+        CleanupStack::Pop(opaqueData);
+
+        RPointerArray<Usif::CLocalizableAppInfo> localizableAppInfoList;
+        CleanupResetAndDestroyPushL(localizableAppInfoList);
+        // Add non-localized application name (caption) and icon.
+
+        CCaptionAndIconInfo *captionAndIconInfo = CCaptionAndIconInfo::NewLC(aAppName,aIconFilename,aNumberOfIcons);
+        
+        CLocalizableAppInfo *locAppInfo = CLocalizableAppInfo::NewLC(/*aShortCaption=*/ KNullDesC,KNonLocalized,
+            /*aGroupName=*/ KNullDesC,captionAndIconInfo,viewDataList);
+        localizableAppInfoList.AppendL(locAppInfo);
+        
+        CleanupStack::Pop(locAppInfo);
+        CleanupStack::Pop(captionAndIconInfo);
+               
+    CCaptionAndIconInfo *tmpCaptionAndIconInfo =CCaptionAndIconInfo::NewLC(aAppName,/*aIconFileName=*/ KNullDesC,/*aNumOfAppIcons=*/ 0);
+    CLocalizableAppInfo *tmpLocAppInfo = CLocalizableAppInfo::NewLC(/*aShortCaption=*/ KNullDesC,aLanguages,/*aGroupName=*/ KNullDesC,
+                                                                        tmpCaptionAndIconInfo,/*aViewDataList=*/ viewDataList);
+                localizableAppInfoList.AppendL(tmpLocAppInfo);
+               
+                CleanupStack::Pop(tmpLocAppInfo);
+                CleanupStack::Pop(tmpCaptionAndIconInfo);
+            
+            
+        
+        // Create application registration data objects.
+        TApplicationCharacteristics appCharacteristics;
+        appCharacteristics.iAttributes = TApaAppCapability::ENonNative;
+        appCharacteristics.iEmbeddability = TApplicationCharacteristics::ENotEmbeddable;
+        appCharacteristics.iSupportsNewFile = EFalse;
+        appCharacteristics.iAppIsHidden = EFalse;
+        appCharacteristics.iLaunchInBackground = EFalse;
+        
+        CApplicationRegistrationData *appRegData =
+        CApplicationRegistrationData::NewLC(ownedFileArray, serviceArray,localizableAppInfoList,appPropertiesArray,opaqueDataArray,
+                /*aAppUid=*/ aAppUid, /*aAppFile=*/ appName,/*aCharacteristics=*/ appCharacteristics,/*aDefaultScreenNumber=*/ 0);
+        
+        LOG(EJavaInstaller, EInfo,"RegisterApplicationL : Called AddApplicationEntryL  >>>>>>>>>>>> ");
+        iScr->AddApplicationEntryL(aComponentId, *appRegData);
+        CleanupStack::PopAndDestroy(appRegData);
+
+      
+        CleanupStack::Pop(&localizableAppInfoList); // deleted in appRegData destructor
+        CleanupStack::Pop(&opaqueDataArray); // deleted in appRegData destructor
+
+        LOG(EBackup,EInfo," <--- RegisterApplicationL() ");
+    }
+
+CScrBackupUtil::~CScrBackupUtil()
+    {
+    LOG(EBackup,EInfo," ---> ~CScrBackupUtil() ");
+    
+    if(iScr)
+        {
+            iScr->Close();
+            delete iScr;
+            iScr = NULL;
+        }
+    if(iRemainingInfo)
+        {
+            delete iRemainingInfo;
+            iRemainingInfo = NULL;
+        }
+            
+    LOG(EBackup,EInfo," <--- ~CScrBackupUtil() ");
+    }
+
+CAppInfo* CAppInfo::NewL()
+    {
+    LOG(EBackup,EInfo," ---> CAppInfo:NewL()");
+    CAppInfo *self = CAppInfo::NewLC();
+    CleanupStack::Pop(self);
+    LOG(EBackup,EInfo," <--- CAppInfo:NewL()");
+    return self;
+    }
+
+
+CAppInfo* CAppInfo::NewLC()
+    {
+    LOG(EBackup,EInfo," ---> CAppInfo:NewLC");
+    CAppInfo *self = new(ELeave) CAppInfo();
+    CleanupStack::PushL(self); 
+    self->ConstructL();
+    LOG(EBackup,EInfo," <---CAppInfo:NewLC");
+    return self;
+    }
+CAppInfo::CAppInfo()
+    {
+
+    }
+void CAppInfo::ConstructL()
+    {
+        LOG(EBackup,EInfo," ---> CAppInfo:ConstructL ");
+        
+        
+        
+        LOG(EBackup,EInfo," <--- CAppInfo:ConstructL()");
+    }
+CAppInfo::~CAppInfo()
+    {
+    LOG(EBackup,EInfo," ---> CAppInfo:~CAppInfo() ");
+    if(iAppIcon)
+        {
+            delete iAppIcon;
+        }
+    LOG(EBackup,EInfo," <--- CAppInfo:~CAppInfo() ");
+    }
+    
+void CAppInfo::Set(TLanguage language,TUid appUid,Usif::TAppCaption caption,TDesC& appIcon,TInt aNoOfIcons)
+    {
+        LOG(EBackup,EInfo," ---> CAppInfo:Set() ");
+        iLanguage = language;
+        iAppUid = appUid;
+        iCaption = caption;
+        iAppIcon->Des().Copy(appIcon);
+        iNoOfIcons = aNoOfIcons;
+        LOG(EBackup,EInfo," <--- CAppInfo:Set() ");
+        
+    }
+TLanguage CAppInfo::GetLanguage()
+    {
+    LOG(EBackup,EInfo," ---> CAppInfo:GetLanguage() ");
+    LOG(EBackup,EInfo," <--- CAppInfo:GetLanguage() ");
+    return iLanguage;
+    }
+TUid CAppInfo::GetAppUid()
+    {
+    LOG(EBackup,EInfo," ---> CAppInfo:GetAppUid() ");
+    LOG(EBackup,EInfo," <--- CAppInfo:GetAppUid() ");
+    return iAppUid;
+    }
+Usif::TAppCaption CAppInfo::GetCaption()
+    {
+    LOG(EBackup,EInfo," ---> CAppInfo:GetCaption() ");
+    LOG(EBackup,EInfo," <--- CAppInfo:GetCaption() ");
+    return iCaption;
+   
+    }
+HBufC* CAppInfo::GetAppIcon()
+    {
+    LOG(EBackup,EInfo," ---> CAppInfo:GetAppIcon() ");
+    LOG(EBackup,EInfo," <--- CAppInfo:GetAppIcon() ");
+    return iAppIcon;
+    
+    }
+
+TInt CAppInfo::NoOfIcons()
+    {
+    LOG(EBackup,EInfo," ---> CAppInfo:NoOfIcons() ");
+    LOG(EBackup,EInfo," <--- CAppInfo:NoOfIcons() ");
+    return iNoOfIcons;
+    }