C++ CImplementationInformation类代码示例

// ---------------------------------------------------------------------------
// CLbtStratergyContainer::LoadStratergyL
// ---------------------------------------------------------------------------
//
void CLbtStratergyContainer::LoadStratergyL(MLbtTriggeringSupervisionObserver* aPtr)
	{
	FUNC_ENTER("CLbtStratergyContainer::LoadStratergyL");
	RImplInfoPtrArray implArray;
	REComSession::ListImplementationsL(KLocAcquisitionStrategyInterfaceUid, implArray);	
	if(implArray.Count() != 1)
		{
		implArray.ResetAndDestroy();
		// Leave if there are more than one or no 
		// implementation of stratergy
		User::Leave(KErrNotFound);
		}
	TCleanupItem arrayCleanup( RImpleInfoPtrArrayCleanup, &implArray );
	CleanupStack::PushL(arrayCleanup);
	CImplementationInformation* info = implArray[0];
	iStratergy = CLbtStrategyBase::NewL(aPtr);
	iVersion = info->Version();
	CleanupStack::PopAndDestroy(); // implArray
	
	iProperty.Set(KPSUidLbtStatusInformation, 
                  KLbtLocationTriggeringSupervisionStatus, 
                  ELbtLocationTriggeringSupervisionSuccessful);
                                     
  // request ecom framework for ecom change notification
	iEComSession->NotifyOnChange(iStatus);	
	SetActive();
	}

// ----------------------------------------------------------------------------
// CSIPClientResolver::AddClientDataL
// ----------------------------------------------------------------------------
//
void CSIPClientResolver::AddClientDataL( 
    RPointerArray< CSIPClientData >& aRegistry,
    CImplementationInformation& aInfo, 
    TBool aRomClient )
    {
	TLex8 lex( aInfo.DataType() );
    TUint32 uidValue( 0 );
    User::LeaveIfError( lex.Val( uidValue, EHex ) );
    TUid clientUid;
    clientUid.iUid = uidValue;     
    const TBool romBased = ( aRomClient && aInfo.RomBased() );
    TPtrC8 xml( aInfo.OpaqueData() );
    const TBool dynamicCaps = ( xml.Length() == 0 );
    
    CSIPClientData* clientData = 
        CSIPClientData::NewLC( aInfo.ImplementationUid(), clientUid,
                               romBased, dynamicCaps );    
    if ( !dynamicCaps )
        {
        // XML specified in resource-file.
        iClientDataParser->ParseL( clientData, xml );
        }
    aRegistry.AppendL( clientData );
    CleanupStack::Pop( clientData );
    }

void CRecordVideoFile::LoadCodecL()	
	{
	// Need new version of this to load from a PU based uid
	RImplInfoPtrArray array;
	REComSession::ListImplementationsL(TUid::Uid(KUidMdfProcessingUnit), array);
	TBool found = EFalse;
	CImplementationInformation* info = NULL;
	for (TInt i=0;i<array.Count() && !found;i++)
		{
		info = array[i];
		if (info->ImplementationUid() == TUid::Uid(KUidVideoTestEncoderPu))
			{
			found = ETrue;
			}
		}
	TInt err = KErrNotFound;
	if (found)
		{
		TRAP(err, iVideoHwDevice = CMMFVideoEncodeHwDevice::NewPuAdapterL(*info,*this));
		}
	else
		{
		err = KErrNotFound;
		}
	array.ResetAndDestroy();
	User::LeaveIfError(err);
	}

 TCFActionLoaderInfo( CImplementationInformation& aImplementationInfo,
     CCFActivatorEngineActionPluginManager& aManager ):
     iImplUid( aImplementationInfo.ImplementationUid() ),
     iImplVersion( aImplementationInfo.Version() ),
     iManager( aManager )
     {
     }

// --------------------------------------------------------------------------
// void CNSmlSOSHandler::ReadTasksFromDBL( RArray<TInt>& aArray )
// --------------------------------------------------------------------------
//
void CNSmlSOSHandler::ReadTasksFromDBL( RArray<TInt>& aArray )
    {
    // Get non-overrided data from settings.
    CNSmlDSSettings* settings = CNSmlDSSettings::NewLC();
    CNSmlDSProfile* prof = settings->ProfileL( iCurrentJob->ProfileId() );

    if ( prof )
        {        
        CleanupStack::PushL(prof);
        RImplInfoPtrArray implArray;
        CleanupStack::PushL(PtrArrCleanupItemRArr( CImplementationInformation, &implArray ) );    
        TUid ifUid = { KNSmlDSInterfaceUid };
        REComSession::ListImplementationsL( ifUid, implArray );

        for ( TInt i = 0 ; i < implArray.Count() ; i++ )
            {    
            CImplementationInformation* implInfo = implArray[i];
            CNSmlDSContentType* ctype = prof->ContentType( implInfo->ImplementationUid().iUid );
            if ( ctype )
                {            
                aArray.AppendL( ctype->IntValue( EDSAdapterTableId ) );
                }
            }        
        CleanupStack::PopAndDestroy(&implArray); 
        CleanupStack::PopAndDestroy(prof);
        REComSession::FinalClose();        
        }    
    CleanupStack::PopAndDestroy(settings);
    }

void GetResolvedDllInfo_OOMTestL()
	{
	TInt processHandlesS = 0;
	TInt threadHandlesS = 0;
	TInt processHandlesE = 0;
	TInt threadHandlesE = 0;
	RThread().HandleCount(processHandlesS, threadHandlesS);

	CEComServer* ecomServer = CEComServer::NewLC();
	TClientRequest clientReq;
	RArray<TUid> extendedInterfaces;
	CleanupClosePushL(extendedInterfaces);
	RImplInfoArray* implInfoArray = ecomServer->ListImplementationsL(KCExampleInterfaceUid,extendedInterfaces,clientReq);
	CleanupStack::PopAndDestroy(&extendedInterfaces);

	TEST(implInfoArray->Count() > 0);

	for(TInt count=1;;++count)
		{
		// Setting Heap failure for OOM test
		__UHEAP_SETFAIL(RHeap::EDeterministic, count);
		__UHEAP_MARK;

		TEntry dllInfo;
		TUid dtorIdKey;
		TClientRequest clntRq;
		CImplementationInformation* info = (*implInfoArray)[0];
		TRAPD(err, ecomServer->GetResolvedDllInfoL(info->ImplementationUid(),
												   dllInfo, dtorIdKey, clntRq));
		if(err == KErrNoMemory)
			{
			__UHEAP_MARKEND;
			}
		else if(err == KErrNone)
			{
			__UHEAP_MARKEND;
			RDebug::Print(_L("The test succeeded at heap failure rate=%d.\n"), count);
			break;
			}
		else
			{
			__UHEAP_MARKEND;
			TEST2(err, KErrNone);
			}
		__UHEAP_RESET;
		}
	__UHEAP_RESET;
	//implInfoArray should be deleted! The caller takes the ownership.
	if (implInfoArray!=NULL)
		{
		implInfoArray->Close();
		delete implInfoArray;
		}
	CleanupStack::PopAndDestroy(ecomServer);
	RThread().HandleCount(processHandlesE, threadHandlesE);
	TEST(processHandlesS == processHandlesE);
	TEST(threadHandlesS == threadHandlesE);
	}

TInt VersionLinearOrderFunction(const CImplementationInformation& pluginA, 
                                const CImplementationInformation& pluginB)
	{
	if (pluginA.Version() == pluginB.Version())
		{
		return 0;
		}

	return (pluginA.Version() < pluginB.Version())? 1: -1;	
	}

void CMMFControllerImplementationInformation::ConstructL(const CImplementationInformation& aImplInfo)
	{
	iUriSchemes = new(ELeave) CDesC8ArrayFlat(KDesCArrayGranularity);
	iUid = aImplInfo.ImplementationUid();
	iDisplayName = aImplInfo.DisplayName().AllocL();
	iVersion = aImplInfo.Version();

	// Parse the opaque data...
	TaggedDataParser::ParseTaggedDataL(aImplInfo.OpaqueData(), *this);
	}

//----------------------------------------------------------------------------
// CCFActionPlugInThread::CCFActionPlugInThread
//----------------------------------------------------------------------------
//
CCFActionPlugInThread::CCFActionPlugInThread(
	CCFActivatorEngineActionPluginManager& aActionPluginManager,
	CImplementationInformation& aImplInfo )
	: iPlugInUid( aImplInfo.ImplementationUid() ),
    iImplVersion( aImplInfo.Version() ),
	iActionPluginManager( &aActionPluginManager )
	{
    FUNC_LOG;

	}

// ----------------------------------------------------------------------------
// CSIPClientResolver::RemoveDuplicates
// ----------------------------------------------------------------------------
//
void CSIPClientResolver::RemoveDuplicates( 
    const RImplInfoPtrArray& aRomInfo,
    RImplInfoPtrArray& aAllInfo )
    {
    TInt romInfoCount = aRomInfo.Count();
    for( TInt i=0; i<romInfoCount; i++ )
        {
        for( TInt j=aAllInfo.Count()-1; j>=0; j-- )
            {
            CImplementationInformation* info = aAllInfo[j];
            if( info->ImplementationUid() == aRomInfo[i]->ImplementationUid() )
                {
                aAllInfo.Remove( j );
                delete info;
                }
            }
        }
    }

// -----------------------------------------------------------------------------
// Get array of know emergency plugins
// -----------------------------------------------------------------------------
//  
RArray<TUid>& CCCEPluginManager::AlternativeEmergencyPlugins()
    {
    CCELOGSTRING("CCCEPluginManager::AlternativeEmergencyPlugins ");
    RImplInfoPtrArray implementations;
    TRAP_IGNORE( CConvergedCallProvider::ListImplementationsL(implementations) );
    iAlternativeEmergencyPlugins.Reset();
        
    for( TInt i=0; i<implementations.Count(); i++ )
        {
        CImplementationInformation *info = implementations[i];
        CCELOGSTRING2("CCCEPluginManager::AlternativeEmergencyPlugins: Found %d ", info->ImplementationUid());
        AddToAlternativeEmergencyArray(info->ImplementationUid());
        }
         
    implementations.ResetAndDestroy();
    implementations.Close();  
 
    return iAlternativeEmergencyPlugins;
    }

// -----------------------------------------------------------------------------
// Load EBootstrapCallProvider marked or enabled plugins
// -----------------------------------------------------------------------------
//
void CCCEPluginManager::LoadBootPluginsL()
    {
    //List implementations
#ifdef _DEBUG
    RImplInfoPtrArray implementations;
    CConvergedCallProvider::ListImplementationsL(implementations);
    CCELOGSTRING2("CCCEPluginManager::GetPluginL: %d Implementation(s) found", 
        implementations.Count() );
        
    for( TInt i=0; i<implementations.Count(); i++ )
        {
        CImplementationInformation *info = implementations[i];
        
        CCELOGSTRING3("CCCEPluginManager::GetPluginL: Uid = %d, Name = %S", 
            info->ImplementationUid().iUid, &info->DisplayName() );
        CCELOGSTRING3("CCCEPluginManager::GetPluginL: ->RomBased = %d, RomOnly = %d", 
            info->RomBased(), info->RomOnly() );
        }
  
    implementations.ResetAndDestroy();
    implementations.Close();
#endif // _DEBUG
    
    RIdArray serviceIDArray;
    CleanupClosePushL( serviceIDArray );
    iSPSettings->GetServicesL( serviceIDArray );
    const TInt serviceCount = serviceIDArray.Count();
    iPrimaryEmergencyCallPlugin = NULL;
    TInt err = KErrNone;
    
    CCELOGSTRING2("CCCEPluginManager::LoadBootPluginsL: Service count: %d", serviceCount );
    for( TInt service = 0; service < serviceCount; service++ )
        {
        CCELOGSTRING2("CCCEPluginManager::LoadBootPluginsL: Processing service: %d", service );
        CCELOGSTRING2("CCCEPluginManager::LoadBootPluginsL: ServiceID: %d", serviceIDArray[service] );
        
        TRAP( err, LoadBootPluginL( serviceIDArray[service] ) )
        
        CCELOGSTRING2("CCCEPluginManager::LoadBootPluginsL: Result %i", err );
        }

    CleanupStack::PopAndDestroy();
    }

// ---------------------------------------------------------------------------
// Load ECom plug-ins
// ---------------------------------------------------------------------------
//
void CBTUIPluginMan::LoadPluginsL()
	{
	TRACE_FUNC_ENTRY
	
	REComSession::ListImplementationsL( KCBtuiPluginInterfaceUid, iPluginInfoArray );
	TInt count = iPluginInfoArray.Count();
	TRACE_INFO( ( _L( "[BTUI]\t CBTUIPluginMan::LoadSettingPluginL() PluginArray count=%d" ), count) )

    iPluginArray.Reset();
	for ( TUint ii = 0 ; ii < count; ++ii )
		{
		CImplementationInformation* impl = iPluginInfoArray[ii];
		//Only append the plugins which datatype() is for HID devices. 
	    if(impl->DataType().Length())
	    	{
	    	TLex8 lex( impl->DataType() );
	    	TUint major = 0, minor = 0;
	    	TInt err1 = lex.Val(major, EHex);
	    	lex.SkipSpace();
	    	TInt err2 = lex.Val(minor, EHex);
	    	if( !err1 && !err2)
	    	    {
	    	    TRACE_INFO( ( _L( "[BTUI]\t CBTUIPluginMan::LoadSettingPluginL() MajorCOD=%d MinorCOD=%d" ), major, minor) )
 	            TBTDeviceClass cod(0x00, major, minor);
	    	                
	    	    CBtuiPluginInterface* plugin = NULL;
	    	    TRAPD( ret, plugin = CBtuiPluginInterface::NewL( impl->ImplementationUid() ) );
	    	    if( !ret )
	    	        {
	    	        CleanupStack::PushL(plugin);
	    	        
	    	        // Transfer the ownership to AppUi
	    	        iAppUi->AddViewL( (CAknView*)plugin ); 
	    	        plugin->SetCOD(cod);
	    	        iPluginArray.AppendL(plugin);
	    	        CleanupStack::Pop(plugin);              
	    	        }	    	        
	    	    }
	        }
		}
	
	TRACE_FUNC_EXIT
	}

void CSenBaseIdentityManager::ReloadSenSecurityMechanismsL()
    {
    TLSLOG(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,(_L("Entering CSenXMLDAO::ReloadSenSecurityMechanismsL()..")));

    delete ipMechanicsNames;
    ipMechanicsNames = NULL;
    ipMechanicsNames = CBufFlat::NewL(KFLATBUF_SIZE);
    RBufWriteStream bufWs(*ipMechanicsNames);
    CleanupClosePushL(bufWs);

    iSechMechNames.ResetAndDestroy();
    iSechMechCues.ResetAndDestroy();

    REComSession::ListImplementationsL(KUidSechMech, iEcomInfoArray);


    TInt infoCount(iEcomInfoArray.Count());
    TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase  , KNormalLogLevel, _L8("%d Security Mechanism ECOM implementations found."),
                        infoCount));

    for (TInt i=0; i<infoCount; i++)
        {
        CImplementationInformation* pImplImfo = iEcomInfoArray[i];
        CSenSecurityMechanism* pSechMech =
            CSenSecurityMechanism::NewL(pImplImfo->DataType(),
                                        iManager);
        CleanupStack::PushL(pSechMech);
        iSechMechNames.Append(pSechMech->Name().AllocL());
        iSechMechCues.Append(pImplImfo->DataType().AllocL());
        bufWs.WriteL(pSechMech->Name());
        CleanupStack::PopAndDestroy(); // pSechMech
        if (i < (infoCount-1))
            {
            bufWs.WriteL(KSpace);
            }
        }
    iEcomInfoArray.ResetAndDestroy();
    CleanupStack::PopAndDestroy(1); // bufWs
    TLSLOG(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,(_L("Leaving CSenXMLDAO::ReloadSenSecurityMechanismsL().. ")));

    }

// ---------------------------------------------------------------------------
// Prepares filename from the displayname of the implementation.
// ---------------------------------------------------------------------------
//
void COMASuplPosTesterModuleCfg::PrepareFileName(TFileName& aOutputFileName, 
							const CImplementationInformation& aImplInfo)
	{
	TInt count = 0;
	TInt displayNameLength = aImplInfo.DisplayName().Length();

	for(count = 0; count < displayNameLength 
					&& count < KMaxFileName - 12; count++)
		{
		if(IsValidFileNameChar(aImplInfo.DisplayName().Ptr() + count))
			{
			aOutputFileName.Append(aImplInfo.DisplayName().Ptr() + count, 1);
			}
		}

	aOutputFileName.Append(_L("_"));
	aOutputFileName.Append(aImplInfo.ImplementationUid().Name().Ptr() + 1
					, aImplInfo.ImplementationUid().Name().Length() - 2);
	//Append file extension
	aOutputFileName.Append(_L(".txt"));
	}