pnpmobileservices/pnpms/PnP/PnpProvisioningAppSrc/PnpServiceActivation.cpp
changeset 2 a5fecba4b1e4
parent 0 3ce708148e4d
child 55 c4687ff85147
equal deleted inserted replaced
1:4490afcb47b1 2:a5fecba4b1e4
    25 #include <apgtask.h>
    25 #include <apgtask.h>
    26 #include <w32std.h>
    26 #include <w32std.h>
    27 #include <StringLoader.h>
    27 #include <StringLoader.h>
    28 #include <PnpProvisioning.rsg>
    28 #include <PnpProvisioning.rsg>
    29 #include <AknGlobalNote.h>
    29 #include <AknGlobalNote.h>
    30 
    30 #include <centralrepository.h>
    31 
    31 
    32 const TUint32 KEmailApplicationUID[] = {0x100058C5};
    32 #include <e32svr.h>
    33 
    33 #include <centralrepository.h>
       
    34 #include "PnpLogger.h"
       
    35 
       
    36 
       
    37 const TUid    KCRUidPnPProvisioning = {0x10204338};
    34 // Browser UID
    38 // Browser UID
    35 const TUid KWAPBrowserUID = { 0x10008d39 };
    39 const TUid KWAPBrowserUID = { 0x10008d39 };
    36 
    40 const TInt KMaxLength = 255;
    37 // POP3 and IMAP4 provisioning settings application ID
    41 // POP3 and IMAP4 provisioning settings application ID
    38 _LIT(KEmailProvAppPOP3ID, "110");
       
    39 _LIT(KEmailProvAppIMAP4ID, "143"); 
       
    40 
    42 
    41 // Literal constants
    43 // Literal constants
    42 _LIT( KMessagingAppName, "z:\\sys\\bin\\mce.exe" );
    44 
    43 _LIT( KEmptyDoc, "");
    45 const TUint32 KServiceAct1  = 0x00000100;
    44 	
       
    45 
    46 
    46 // INCLUDE FILES
    47 // INCLUDE FILES
    47 
    48 
    48 // -----------------------------------------------------------------------------
    49 // -----------------------------------------------------------------------------
    49 // CPnpServiceActivation::CPnpServiceActivation
    50 // CPnpServiceActivation::CPnpServiceActivation
   109     
   110     
   110     if(validApp) 
   111     if(validApp) 
   111     {
   112     {
   112     	
   113     	
   113     
   114     
   114      CApaCommandLine* cmd = CApaCommandLine::NewLC();
       
   115      
   115      
   116      cmd->SetExecutableNameL( KMessagingAppName );
       
   117      
   116      
   118      cmd->SetDocumentNameL( KEmptyDoc );
       
   119      cmd->SetCommandL( EApaCommandOpen ); 
       
   120      RApaLsSession appArcSession;
   117      RApaLsSession appArcSession;
   121 	
   118 	
   122      User::LeaveIfError( appArcSession.Connect() );
   119      User::LeaveIfError( appArcSession.Connect() );
   123      appArcSession.StartApp( *cmd ); 
   120        CleanupClosePushL( appArcSession );
   124      appArcSession.Close();
   121        TApaAppInfo appInfo; 
   125      CleanupStack::PopAndDestroy( cmd ); 
   122        User::LeaveIfError(appArcSession.GetAppInfo( appInfo, TUid::Uid( iLaunchUid) ) );        
       
   123        CApaCommandLine* cmdLine = CApaCommandLine::NewLC();
       
   124        cmdLine->SetCommandL( EApaCommandRun );
       
   125        cmdLine->SetExecutableNameL( appInfo.iFullName );
       
   126        User::LeaveIfError( appArcSession.StartApp( *cmdLine ) );
       
   127        CleanupStack::PopAndDestroy( 2 ); // cmdLine, appArcSession 
   126     }
   128     }
   127 
   129 
   128     }
   130     }
   129 
   131 
   130 
   132 
   135 TBool CPnpServiceActivation::ValidateAppUidWithProvappIDL()
   137 TBool CPnpServiceActivation::ValidateAppUidWithProvappIDL()
   136     {
   138     {
   137     
   139     
   138     // Get application ID and Provisioning settings application
   140     // Get application ID and Provisioning settings application
   139     // ID and validate the application launcher	
   141     // ID and validate the application launcher	
   140     TBool flag (EFalse);
   142    
   141     RPointerArray<HBufC> appID;
   143     RPointerArray<HBufC> appID;
       
   144     TBuf<16> pLaunchUid;
       
   145     TBool returnFlag (EFalse);
       
   146     TBool FoundUid(EFalse);
       
   147     TBool FoundAppid(EFalse);
   142 	
   148 	
   143     CPnpProvUtil *provutil = CPnpProvUtil::NewLC();
   149     CPnpProvUtil *provutil = CPnpProvUtil::NewLC();
   144     
   150     
   145     TUint32 val = provutil->GetApplicationUidL();
   151     iLaunchUid = provutil->GetApplicationUidL();
   146     if(val == KEmailApplicationUID[0])
   152  
   147     {
       
   148 	provutil->GetProvAdapterAppIdsL(appID);
   153 	provutil->GetProvAdapterAppIdsL(appID);
   149     
   154     pLaunchUid.Num(iLaunchUid);
       
   155     
       
   156     FoundUid = isPresent(pLaunchUid);
       
   157     TUint32 secondPosition = iPosition+200;
       
   158     if(FoundUid)
       
   159         {
   150     	for(TInt i=0; i<appID.Count(); i++)
   160     	for(TInt i=0; i<appID.Count(); i++)
   151     	{
   161     	{
   152 		TPtrC ptr(*appID[i]);
   162 		TPtrC ptr(*appID[i]);
   153 		if(ptr.Compare(KEmailProvAppPOP3ID) ==0||
   163     	    FoundAppid = isFound(ptr,secondPosition);
   154 		   ptr.Compare(KEmailProvAppIMAP4ID) ==0 )
   164             if(FoundAppid)
   155 		flag = ETrue;
   165                 {
   156 	
   166                 if(iPosition == KServiceAct1){
       
   167                 DisplayAppSpecNoteL();
       
   168                 }
       
   169                 returnFlag = ETrue;
       
   170                 }
   157     	}
   171     	}
   158      }
   172      }
   159     
   173     
   160     
   174     
   161     CleanupStack::PopAndDestroy();
   175     CleanupStack::PopAndDestroy();
   162      
   176      
   163     appID.ResetAndDestroy();
   177     appID.ResetAndDestroy();
   164     appID.Close();
   178     appID.Close();
   165     return flag; 
   179     return returnFlag; 
   166     }
   180     }
   167 
   181 
   168 
   182 
   169 // -----------------------------------------------------------------------------
   183 // -----------------------------------------------------------------------------
   170 // CPnpServiceActivation::KillBrowserL()
   184 // CPnpServiceActivation::KillBrowserL()
   203     CleanupStack::PushL( globalNote );
   217     CleanupStack::PushL( globalNote );
   204     globalNote->ShowNoteL( EAknGlobalInformationNote , *text );
   218     globalNote->ShowNoteL( EAknGlobalInformationNote , *text );
   205     CleanupStack::PopAndDestroy( 2 );
   219     CleanupStack::PopAndDestroy( 2 );
   206 }
   220 }
   207 
   221 
       
   222 TBool CPnpServiceActivation::isPresent(TDesC& p)
       
   223 {
       
   224    TBool flag(EFalse);
       
   225    TUint32 position = KServiceAct1;
       
   226    for(TInt i=0;i<=299;i++)
       
   227         {
       
   228         TBool val = isFound(p,position);
       
   229         if(val)
       
   230             {
       
   231             iPosition = position;
       
   232             flag = ETrue;
       
   233             break;
       
   234             }   
       
   235         position++;
       
   236         }
       
   237       return flag;
       
   238      }
       
   239 TBool CPnpServiceActivation::isFound(TDesC& p,TUint32 position)
       
   240 {
       
   241     TBool val(EFalse);     
       
   242     TBuf16<KMaxLength> keys;
       
   243     HBufC* heapBuf = HBufC::NewLC(20);
       
   244     TPtr ptr(heapBuf->Des());
       
   245     ptr = keys;
       
   246     RPointerArray<HBufC> array;    
       
   247     TRAPD( errVal,GetCenrepValueL(KCRUidPnPProvisioning,position,keys));
   208 //  End of File
   248 //  End of File
   209 
   249     if(errVal != KErrNone)
       
   250             {
       
   251             CleanupStack::PopAndDestroy();
       
   252             return val;
       
   253             }
       
   254     ParseValues(array, keys);
       
   255     val = Search(array,p);
       
   256     CleanupStack::PopAndDestroy(heapBuf);
       
   257     array.ResetAndDestroy();
       
   258     array.Close();
       
   259     return val;    
       
   260 }
       
   261 
       
   262 TBool CPnpServiceActivation::Search(RPointerArray<HBufC>& array,TDesC& p)
       
   263 {
       
   264     TBool flag(EFalse);
       
   265     for(TInt j=0; j<array.Count(); j++)
       
   266         {
       
   267         TPtrC ptr(*array[j]);
       
   268 	if(!ptr.Compare(p))
       
   269             {
       
   270             flag = ETrue;
       
   271             }
       
   272         }
       
   273     return flag;
       
   274 }
       
   275 void CPnpServiceActivation::ParseValues(RPointerArray<HBufC>& array, TDesC& aValue)
       
   276 {
       
   277      TLex aLex(aValue);
       
   278      while(aLex.Peek() != '\x00')
       
   279         {
       
   280         aLex.Mark();
       
   281         while(aLex.Peek()!=',' && aLex.Peek()!='\x00')
       
   282             aLex.Inc();
       
   283         TPtrC aPtr = aLex.MarkedToken(); 
       
   284         HBufC *buf18 = aPtr.AllocL();
       
   285         array.Append(buf18); 
       
   286         if(aLex.Peek()=='\x00') // end of string
       
   287             break; 
       
   288         aLex.Inc();
       
   289     }
       
   290 }
       
   291 void CPnpServiceActivation::GetCenrepValueL(const TUid aRepositoryUid,TUint32 aKey, TDes16& aValue)
       
   292     {
       
   293     CRepository * rep = NULL;
       
   294     TInt errorStatus = KErrNone;
       
   295     TRAPD( errVal, rep = CRepository::NewL(aRepositoryUid));
       
   296     if(errVal == KErrNone)
       
   297         {
       
   298         errorStatus =  rep->Get( aKey , aValue );
       
   299         }
       
   300         else
       
   301         {
       
   302         errorStatus =  errVal;
       
   303         }
       
   304     
       
   305     if(rep)     
       
   306         {
       
   307         delete rep;
       
   308         }
       
   309     if(errorStatus != KErrNone )
       
   310         {
       
   311         User::Leave(errorStatus);
       
   312         }
       
   313     }