Functions listed by capability

Capability: AllFiles

CFileMan::Copy(const TDesC &,const TDesC &,TUint);{Dependent}

CFileMan::Copy(const TDesC &,const TDesC &,TUint,TRequestStatus &);{Dependent}

CFileMan::Move(const TDesC &,const TDesC &,TUint);{Dependent}

CFileMan::Move(const TDesC &,const TDesC &,TUint,TRequestStatus &);{Dependent}

MessageServer::CurrentDriveL(RFs &);{None}

MessageServer::DriveContainsStore(RFs &,TInt);{None}

RDir::Open(RFs &,const TDesC &,TUint);{}

RDir::Open(RFs &,const TDesC &,const TUidType &);{}

RFs::Att(const TDesC &,TUint &)const;{}

RFs::Modified(const TDesC &,TTime &)const;{}

RFs::NotifyChange(TNotifyType,TRequestStatus &);{}

RFs::NotifyChange(TNotifyType,TRequestStatus &,const TDesC &);{}

RFs::NotifyChangeCancel();{}

RFs::NotifyChangeCancel(TRequestStatus &);{}

Capability: CommDD

RBusDevComm::Open(TInt);{}

RBusDevCommDCE::Open(TInt);{}

RCommServ::CreateThreadInCommProc(const TDesC &,const TDesC &,TThreadFunction,TInt,TInt,TInt);{}

Capability: DiskAdmin

RFormat::Next(TInt &);{}

RFormat::Next(TPckgBuf< TInt > &,TRequestStatus &);{}

RFs::AddFileSystem(const TDesC &)const;{}

RFs::AddPlugin(const TDesC &)const;{}

RFs::CheckDisk(const TDesC &)const;{}

RFs::ClearPassword(TInt,const TMediaPassword &);{}

RFs::DismountFileSystem(const TDesC &,TInt)const;{}

RFs::DismountPlugin(const TDesC &)const;{}

RFs::DismountPlugin(const TDesC &,TInt)const;{}

RFs::DismountPlugin(const TDesC &,TInt,TInt)const;{}

RFs::ErasePassword(TInt);{}

RFs::FinaliseDrives();{}

RFs::LockDrive(TInt,const TMediaPassword &,const TMediaPassword &,TBool);{}

RFs::MountFileSystem(const TDesC &,TInt)const;{}

RFs::MountFileSystem(const TDesC &,TInt,TBool)const;{}

RFs::MountFileSystem(const TDesC &,const TDesC &,TInt);{}

RFs::MountFileSystem(const TDesC &,const TDesC &,TInt,TBool);{}

RFs::MountFileSystemAndScan(const TDesC &,TInt,TBool &)const;{}

RFs::MountPlugin(const TDesC &)const;{}

RFs::MountPlugin(const TDesC &,TInt)const;{}

RFs::MountPlugin(const TDesC &,TInt,TInt)const;{}

RFs::RemoveFileSystem(const TDesC &)const;{}

RFs::RemovePlugin(const TDesC &)const;{}

RFs::ScanDrive(const TDesC &)const;{}

RFs::SetDriveName(TInt,const TDesC &);{}

RFs::SetVolumeLabel(const TDesC &,TInt);{}

RFs::UnlockDrive(TInt,const TMediaPassword &,TBool);{}

RRawDisk::Open(RFs &,TInt);{}

RRawDisk::Read(TInt64,TDes8 &);{}

RRawDisk::Write(TInt64,TDesC8 &);{}

Capability: Drm

ContentAccess::CAgentContent::AgentSpecificCommand(TInt,const TDesC8 &,TDes8 &)=0;{}

ContentAccess::CAgentContent::AgentSpecificCommand(TInt,const TDesC8 &,TDes8 &,TRequestStatus &)=0;{}

ContentAccess::CAgentContent::CancelNotifyStatusChange(TRequestStatus &,const TDesC &)=0;{}

ContentAccess::CAgentContent::CancelRequestRights(TRequestStatus &,const TDesC &)=0;{}

ContentAccess::CAgentContent::CloseContainer()=0;{}

ContentAccess::CAgentContent::GetAttribute(TInt,TInt &,const TDesC &)=0;{}

ContentAccess::CAgentContent::GetAttributeSet(RAttributeSet &,const TDesC &)=0;{}

ContentAccess::CAgentContent::GetEmbeddedObjectsL(RStreamablePtrArray< CEmbeddedObject > &)=0;{}

ContentAccess::CAgentContent::GetEmbeddedObjectsL(RStreamablePtrArray< CEmbeddedObject > &,TEmbeddedType)=0;{}

ContentAccess::CAgentContent::GetStringAttribute(TInt,TDes &,const TDesC &)=0;{}

ContentAccess::CAgentContent::GetStringAttributeSet(RStringAttributeSet &,const TDesC &)=0;{}

ContentAccess::CAgentContent::NotifyStatusChange(TEventMask,TRequestStatus &,const TDesC &)=0;{}

ContentAccess::CAgentContent::OpenContainer(const TDesC &)=0;{}

ContentAccess::CAgentContent::Search(RStreamablePtrArray< CEmbeddedObject > &,const TDesC8 &,TBool)=0;{}

ContentAccess::CAgentContent::SetProperty(TAgentProperty,TInt)=0;{}

ContentAccess::CAgentData::DataSizeL(TInt &)=0;{}

ContentAccess::CAgentData::EvaluateIntent(TIntent)=0;{}

ContentAccess::CAgentData::ExecuteIntent(TIntent)=0;{}

ContentAccess::CAgentData::GetAttribute(TInt,TInt &)=0;{}

ContentAccess::CAgentData::GetStringAttribute(TInt,TDes &)=0;{}

ContentAccess::CAgentData::Read(TDes8 &)=0;{}

ContentAccess::CAgentData::Read(TDes8 &,TInt)=0;{}

ContentAccess::CAgentData::Read(TDes8 &,TInt,TRequestStatus &)=0;{}

ContentAccess::CAgentData::Read(TDes8 &,TRequestStatus &)=0;{}

ContentAccess::CAgentData::Seek(TSeek,TInt &)=0;{}

ContentAccess::CAgentData::SetProperty(TAgentProperty,TInt)=0;{}

ContentAccess::CAgentImportFile::GetImportStatus()const=0;{}

ContentAccess::CAgentImportFile::OutputFileL(TInt)=0;{}

ContentAccess::CAgentImportFile::WriteData(const TDesC8 &)=0;{}

ContentAccess::CAgentImportFile::WriteData(const TDesC8 &,TRequestStatus &)=0;{}

ContentAccess::CAgentImportFile::WriteDataComplete()=0;{}

ContentAccess::CAgentImportFile::WriteDataComplete(TRequestStatus &)=0;{}

ContentAccess::CAgentManager::AgentSpecificCommand(TInt,const TDesC8 &,TDes8 &)=0;{}

ContentAccess::CAgentManager::AgentSpecificCommand(TInt,const TDesC8 &,TDes8 &,TRequestStatus &)=0;{}

ContentAccess::CAgentManager::CancelNotifyStatusChange(const TDesC &,TRequestStatus &)=0;{}

ContentAccess::CAgentManager::CopyFile(const TDesC &,const TDesC &)=0;{}

ContentAccess::CAgentManager::DeleteFile(const TDesC &)=0;{}

ContentAccess::CAgentManager::GetDir(const TDesC &,TUint,TUint,CDir *&)const=0;{}

ContentAccess::CAgentManager::GetDir(const TDesC &,TUint,TUint,CDir *&,CDir *&)const=0;{}

ContentAccess::CAgentManager::GetDir(const TDesC &,const TUidType &,TUint,CDir *&)const=0;{}

ContentAccess::CAgentManager::MkDir(const TDesC &)=0;{}

ContentAccess::CAgentManager::MkDirAll(const TDesC &)=0;{}

ContentAccess::CAgentManager::NotifyStatusChange(const TDesC &,TEventMask,TRequestStatus &)=0;{}

ContentAccess::CAgentManager::RenameDir(const TDesC &,const TDesC &);{}

ContentAccess::CAgentManager::RenameFile(const TDesC &,const TDesC &)=0;{}

ContentAccess::CAgentManager::RmDir(const TDesC &)=0;{}

ContentAccess::CAgentManager::SetProperty(TAgentProperty,TInt)=0;{}

ContentAccess::CAgentRightsManager::DeleteAllRightsObjects(const TVirtualPathPtr &)=0;{}

ContentAccess::CAgentRightsManager::DeleteRightsObject(const CRightsInfo &)=0;{}

ContentAccess::CAgentRightsManager::GetRightsDataL(const CRightsInfo &)const=0;{}

ContentAccess::CAgentRightsManager::ListAllRightsL(RStreamablePtrArray< CRightsInfo > &)const=0;{}

ContentAccess::CAgentRightsManager::ListContentL(RStreamablePtrArray< CVirtualPath > &,CRightsInfo &)const=0;{}

ContentAccess::CAgentRightsManager::ListRightsL(RStreamablePtrArray< CRightsInfo > &,TVirtualPathPtr &)const=0;{}

ContentAccess::CAgentRightsManager::ListRightsL(RStreamablePtrArray< CRightsInfo > &,const TDesC &)const=0;{}

ContentAccess::CAgentRightsManager::SetProperty(TAgentProperty,TInt)=0;{}

ContentAccess::CContent::Agent()const;{}

ContentAccess::CContent::AgentSpecificCommand(TInt,const TDesC8 &,TDes8 &);{}

ContentAccess::CContent::AgentSpecificCommand(TInt,const TDesC8 &,TDes8 &,TRequestStatus &);{}

ContentAccess::CContent::CContent::OpenContentL(TIntent,TContentShareMode);{}

ContentAccess::CContent::CancelNotifyStatusChange(TRequestStatus &);{}

ContentAccess::CContent::CancelNotifyStatusChange(TRequestStatus &,const TDesC &);{}

ContentAccess::CContent::CancelRequestRights(TRequestStatus &);{}

ContentAccess::CContent::CancelRequestRights(TRequestStatus &,const TDesC &);{}

ContentAccess::CContent::CloseContainer();{}

ContentAccess::CContent::GetAttribute(TInt,TInt &)const;{}

ContentAccess::CContent::GetAttribute(TInt,TInt &,const TDesC &)const;{}

ContentAccess::CContent::GetAttributeSet(RAttributeSet &)const;{}

ContentAccess::CContent::GetAttributeSet(RAttributeSet &,const TDesC &)const;{}

ContentAccess::CContent::GetEmbeddedObjectsL(RStreamablePtrArray< CEmbeddedObject > &)const;{}

ContentAccess::CContent::GetEmbeddedObjectsL(RStreamablePtrArray< CEmbeddedObject > &,TEmbeddedType)const;{}

ContentAccess::CContent::GetStringAttribute(TInt,TDes &)const;{}

ContentAccess::CContent::GetStringAttribute(TInt,TDes &,const TDesC &)const;{}

ContentAccess::CContent::GetStringAttributeSet(RStringAttributeSet &)const;{}

ContentAccess::CContent::GetStringAttributeSet(RStringAttributeSet &,const TDesC &)const;{}

ContentAccess::CContent::NewAttributeL(TBool);{}

ContentAccess::CContent::NewAttributeL(TBool,TContentShareMode);{}

ContentAccess::CContent::NewL(RFile &);{}

ContentAccess::CContent::NewL(const TDesC &);{}

ContentAccess::CContent::NewL(const TDesC &,TContentShareMode);{}

ContentAccess::CContent::NewLC(RFile &);{}

ContentAccess::CContent::NewLC(const TDesC &);{}

ContentAccess::CContent::NewLC(const TDesC &,TContentShareMode);{}

ContentAccess::CContent::NotifyStatusChange(TEventMask,TRequestStatus &);{}

ContentAccess::CContent::NotifyStatusChange(TEventMask,TRequestStatus &,const TDesC &);{}

ContentAccess::CContent::OpenContainer(const TDesC &);{}

ContentAccess::CContent::OpenContentL(TIntent);{}

ContentAccess::CContent::OpenContentL(TIntent,const TDesC &);{}

ContentAccess::CContent::OpenContentLC(TIntent);{}

ContentAccess::CContent::OpenContentLC(TIntent,const TDesC &);{}

ContentAccess::CContent::Search(RStreamablePtrArray< CEmbeddedObject > &,const TDesC8 &,TBool);{}

ContentAccess::CContent::SetProperty(TAgentProperty,TInt);{}

ContentAccess::CData::DataSizeL(TInt &);{}

ContentAccess::CData::EvaluateIntent(TIntent);{}

ContentAccess::CData::ExecuteIntent(TIntent);{}

ContentAccess::CData::GetAttribute(TInt,TInt &)const;{}

ContentAccess::CData::GetAttributeSet(RAttributeSet &)const;{}

ContentAccess::CData::GetStringAttribute(TInt,TDes &)const;{}

ContentAccess::CData::GetStringAttributeSet(RStringAttributeSet &)const;{}

ContentAccess::CData::Read(TDes8 &)const;{}

ContentAccess::CData::Read(TDes8 &,TInt)const;{}

ContentAccess::CData::Read(TDes8 &,TInt,TRequestStatus &)const;{}

ContentAccess::CData::Read(TDes8 &,TRequestStatus &)const;{}

ContentAccess::CData::Seek(TSeek,TInt &)const;{}

ContentAccess::CData::SetProperty(TAgentProperty,TInt);{}

ContentAccess::CImportFile::GetImportStatus()const;{}

ContentAccess::CImportFile::OutputFileL(TInt)const;{}

ContentAccess::CImportFile::WriteData(const TDesC8 &);{}

ContentAccess::CImportFile::WriteData(const TDesC8 &,TRequestStatus &);{}

ContentAccess::CImportFile::WriteDataComplete();{}

ContentAccess::CImportFile::WriteDataComplete(TRequestStatus &);{}

ContentAccess::CManager::AgentSpecificCommand(TAgent &,TInt,const TDesC8 &,TDes8 &);{}

ContentAccess::CManager::AgentSpecificCommand(TAgent &,TInt,const TDesC8 &,TDes8 &,TRequestStatus &);{}

ContentAccess::CManager::CancelNotifyStatusChange(const TDesC &,TRequestStatus &);{}

ContentAccess::CManager::CopyFile(const TDesC &,const TDesC &)const;{}

ContentAccess::CManager::CreateRightsManagerL(TAgent &)const;{}

ContentAccess::CManager::DeleteFile(const TDesC &)const;{}

ContentAccess::CManager::DisplayManagementInfoL(TAgent &);{}

ContentAccess::CManager::GetDir(const TDesC &,TUint,TUint,CDir *&)const;{}

ContentAccess::CManager::GetDir(const TDesC &,TUint,TUint,CDir *&,CDir *&)const;{}

ContentAccess::CManager::GetDir(const TDesC &,const TUidType &,TUint,CDir *&)const;{}

ContentAccess::CManager::MkDir(const TDesC &)const;{}

ContentAccess::CManager::MkDirAll(const TDesC &)const;{}

ContentAccess::CManager::NotifyStatusChange(const TDesC &,TEventMask,TRequestStatus &);{}

ContentAccess::CManager::RenameFile(const TDesC &,const TDesC &)const;{}

ContentAccess::CManager::RmDir(const TDesC &)const;{}

ContentAccess::CManager::SetProperty(TAgentProperty,TInt);{}

ContentAccess::CRightsInfo::Description()const;{}

ContentAccess::CRightsInfo::RightsStatus()const;{}

ContentAccess::CRightsInfo::RightsType()const;{}

ContentAccess::CRightsInfo::UniqueId()const;{}

ContentAccess::CRightsManager::DeleteAllRightsObjects(const TVirtualPathPtr &);{}

ContentAccess::CRightsManager::DeleteRightsObject(const CRightsInfo &);{}

ContentAccess::CRightsManager::GetRightsDataL(const CRightsInfo &)const;{}

ContentAccess::CRightsManager::ListAllRightsL(RStreamablePtrArray< CRightsInfo > &)const;{}

ContentAccess::CRightsManager::ListContentL(RStreamablePtrArray< CVirtualPath > &,CRightsInfo &)const;{}

ContentAccess::CRightsManager::ListRightsL(RStreamablePtrArray< CRightsInfo > &,TVirtualPathPtr &)const;{}

ContentAccess::CRightsManager::ListRightsL(RStreamablePtrArray< CRightsInfo > &,const TDesC &)const;{}

ContentAccess::CRightsManager::SetProperty(TAgentProperty,TInt);{}

Capability: LocalServices

BAL::RBALClient::ConnectToHost();{NetworkServices}

BAL::RBALClient::DisconnectFromHostL();{NetworkServices}

BAL::RBALClient::SetConnectConfigurationL(const TBALConnectionConfig &);{NetworkServices}

BAL::RBALClient::StartListenerL();{NetworkServices}

BAL::RBALClient::StopListenerL();{NetworkServices}

CBluetoothSocket::NewL(MBluetoothSocketNotifier &,RSocketServ &,TUint,TUint);{}

CBluetoothSocket::NewL(MBluetoothSocketNotifier &,RSocketServ &,TUint,TUint,RConnection &);{}

CBluetoothSocket::NewL(MBluetoothSocketNotifier &,RSocketServ &,const TDesC &);{}

CBluetoothSocket::NewLC(MBluetoothSocketNotifier &,RSocketServ &,TUint,TUint);{}

CBluetoothSocket::NewLC(MBluetoothSocketNotifier &,RSocketServ &,TUint,TUint,RConnection &);{}

CBluetoothSocket::NewLC(MBluetoothSocketNotifier &,RSocketServ &,const TDesC &);{}

CBluetoothSynchronousLink::NewL(MBluetoothSynchronousLinkNotifier &,RSocketServ &);{}

CBluetoothSynchronousLink::NewLC(MBluetoothSynchronousLinkNotifier &,RSocketServ &);{}

CSdpAgent::AttributeRequestL(MSdpElementBuilder *,TSdpServRecordHandle,TSdpAttributeID);{}

CSdpAgent::AttributeRequestL(MSdpElementBuilder *,TSdpServRecordHandle,const CSdpAttrIdMatchList &);{}

CSdpAgent::AttributeRequestL(TSdpServRecordHandle,TSdpAttributeID);{}

CSdpAgent::AttributeRequestL(TSdpServRecordHandle,const CSdpAttrIdMatchList &);{}

CSdpAgent::Cancel();{}

CSdpAgent::NewL(MSdpAgentNotifier &,const TBTDevAddr &);{}

CSdpAgent::NewLC(MSdpAgentNotifier &,const TBTDevAddr &);{}

CSdpAgent::NextRecordRequestL();{}

CSdpAgent::SetAttributePredictorListL(const CSdpAttrIdMatchList &);{}

CSdpAgent::SetRecordFilterL(const CSdpSearchPattern &);{}

RBTLocalDevice::Modify(const TBTLocalDevice &);{WriteDeviceData}

RBTLocalDevice::Modify(const TBTLocalDevice &,TRequestStatus &);{WriteDeviceData}

RBTPhysicalLinkAdapter::Open(RSocketServ &,RSocket &);{}

RBTPhysicalLinkAdapter::Open(RSocketServ &,TBTDevAddr &);{}

RBTRegServ::Connect();{}

RBTRegistry::CreateView(const TBTRegistrySearch &,TRequestStatus &);{ReadDeviceData}

RBTRegistry::DeleteAllInView(TRequestStatus &);{WriteDeviceData}

RBTRegistry::GetDevice(TBTNamelessDevice &,TRequestStatus &);{ReadDeviceData}

RBTRegistry::ModifyBluetoothDeviceNameL(const TBTDevAddr &,const TDesC8 &,TRequestStatus &);{WriteDeviceData}

RBTRegistry::ModifyDevice(const TBTNamelessDevice &,TRequestStatus &);{WriteDeviceData}

RBTRegistry::ModifyFriendlyDeviceNameL(const TBTDevAddr &,const TDesC &,TRequestStatus &);{}

RBTRegistry::UnpairAllInView(TRequestStatus &);{WriteDeviceData}

RBTRegistry::UnpairDevice(const TBTDevAddr &,TRequestStatus &);{WriteDeviceData}

RHCIDirectAccess::Open(RSocketServ &);{}

RSdpDatabase::Close();{}

RSdpDatabase::CreateServiceRecordL(CSdpAttrValueDES &,TSdpServRecordHandle &);{}

RSdpDatabase::CreateServiceRecordL(const TUUID &,TSdpServRecordHandle &);{}

RSdpDatabase::DeleteAttributeL(TSdpServRecordHandle,TSdpAttributeID);{}

RSdpDatabase::DeleteRecordL(TSdpServRecordHandle);{}

RSdpDatabase::Open(RSdp &);{}

RSdpDatabase::RSdpDatabase();{}

RSdpDatabase::UpdateAttributeL(TSdpServRecordHandle,TSdpAttributeID,CSdpAttrValue &);{}

RSdpDatabase::UpdateAttributeL(TSdpServRecordHandle,TSdpAttributeID,TUint);{}

RSdpDatabase::UpdateAttributeL(TSdpServRecordHandle,TSdpAttributeID,const TDesC16 &);{}

RSdpDatabase::UpdateAttributeL(TSdpServRecordHandle,TSdpAttributeID,const TDesC8 &);{}

RSyncMLDataSyncJob::CreateL(RSyncMLSession &,TSmlProfileId);{NetworkServices}

RSyncMLDataSyncJob::CreateL(RSyncMLSession &,TSmlProfileId,TSmlSyncType);{NetworkServices}

RSyncMLDataSyncJob::CreateL(RSyncMLSession &,TSmlProfileId,TSmlSyncType,const RArray< TSmlTaskId > &);{NetworkServices}

RSyncMLDataSyncJob::CreateL(RSyncMLSession &,TSmlProfileId,const RArray< TSmlTaskId > &);{NetworkServices}

RSyncMLDevManJob::CreateL(RSyncMLSession &,TSmlProfileId);{NetworkServices}

RSyncMLDevManJob::CreateL(RSyncMLSession &,TSmlProfileId,TSmlConnectionId);{NetworkServices}

RSyncMLTransport::StartListeningL()const;{}

RSyncMLTransport::StopListeningL()const;{}

Capability: Location

CTelephony::GetCurrentNetworkInfo(TRequestStatus &,TDes8 &)const;{ReadDeviceData, ReadUserData}

RMobilePhone::GetCurrentNetwork(TRequestStatus &,TDes8 &,TMobilePhoneLocationAreaV1 &)const;{ReadDeviceData}

RMobilePhone::NotifyCurrentNetworkChange(TRequestStatus &,TDes8 &,TMobilePhoneLocationAreaV1 &)const;{ReadDeviceData}

Capability: MultimediaDD

CCamera::NewL(MCameraObserver2 &,TInt,TInt);{UserEnvironment}

CDevASR::SetPrioritySettings(const TMMFPrioritySettings &);{}

CMMFController::SetPrioritySettings(const TMMFPrioritySettings &)=0;{}

CMMFUrlSink::SetSinkPrioritySettings(const TMMFPrioritySettings &);{}

CMMFUrlSource::SetSourcePrioritySettings(const TMMFPrioritySettings &);{}

CMMTunerUtility::SetPriority(TTunerAccessPriority);{}

CMdaAudioConvertUtility::NewL(MMdaObjectStateChangeObserver &,CMdaServer *,TInt,TMdaPriorityPreference);{}

CMdaAudioInputStream::NewL(MMdaAudioInputStreamCallback &,TInt,TMdaPriorityPreference);{UserEnvironment}

CMdaAudioInputStream::SetPriority(TInt,TMdaPriorityPreference);{}

CMdaAudioOutputStream::NewL(MMdaAudioOutputStreamCallback &,TInt,TMdaPriorityPreference);{}

CMdaAudioOutputStream::SetPriority(TInt,TMdaPriorityPreference);{}

CMdaAudioPlayerUtility::NewDesPlayerL(const TDesC8 &,MMdaAudioPlayerCallback &,TInt,TMdaPriorityPreference,CMdaServer *);{}

CMdaAudioPlayerUtility::NewFilePlayerL(const TDesC &,MMdaAudioPlayerCallback &,TInt,TMdaPriorityPreference,CMdaServer *);{}

CMdaAudioPlayerUtility::NewL(MMdaAudioPlayerCallback &,TInt,TMdaPriorityPreference);{}

CMdaAudioPlayerUtility::SetPriority(TInt,TMdaPriorityPreference);{}

CMdaAudioRecorderUtility::NewL(MMdaObjectStateChangeObserver &,CMdaServer *,TInt,TMdaPriorityPreference);{}

CMdaAudioRecorderUtility::SetPriority(TInt,TMdaPriorityPreference);{}

CMdaAudioToneUtility::NewL(MMdaAudioToneObserver &,CMdaServer *,TInt,TMdaPriorityPreference);{}

CMdaAudioToneUtility::SetPriority(TInt,TMdaPriorityPreference);{}

CMidiClientUtility::NewL(MMidiClientUtilityObserver &,TInt,TMdaPriorityPreference);{}

CMidiClientUtility::SetPriorityL(TInt,TMdaPriorityPreference);{}

CMmfGlobalAudioEffect::SetByValuesL(const TDesC8 &);{}

CMmfGlobalAudioEffect::SetEnabledL(TBool);{}

CMmfGlobalAudioEffect::SetSettingsByDesL(const TDesC8 &);{}

CMmfGlobalAudioEffect::SetSettingsByUidL(TUid);{}

CSpeechRecognitionUtility::SetAudioPriority(TInt,TInt,TInt,TInt);{}

CVideoPlayerUtility::NewL(MVideoPlayerUtilityObserver &,TInt,TMdaPriorityPreference,RWsSession &,CWsScreenDevice &,RWindowBase &,const TRect &,const TRect &);{}

CVideoPlayerUtility::SetPriorityL(TInt,TMdaPriorityPreference);{}

CVideoRecorderUtility::NewL(MVideoRecorderUtilityObserver &,TInt,TMdaPriorityPreference);{}

CVideoRecorderUtility::SetPriorityL(TInt,TMdaPriorityPreference);{}

MDataSink::SetSinkPrioritySettings(const TMMFPrioritySettings &);{}

MDataSource::SetSourcePrioritySettings(const TMMFPrioritySettings &);{}

MMMTunerUtilityImpl::SetPriority(CMMTunerUtility::TTunerAccessPriority)=0;{}

MMmfGlobalAudioImpl::SetByValuesL(const TDesC8 &)=0;{}

MMmfGlobalAudioImpl::SetEnabledL(TBool)=0;{}

MMmfGlobalAudioImpl::SetSettingsByDesL(const TDesC8 &)=0;{}

MMmfGlobalAudioImpl::SetSettingsByUidL(TUid)=0;{}

RMMFController::Open(TUid,const TMMFPrioritySettings &);{}

RMMFController::Open(const CMMFControllerImplementationInformation &,const TMMFPrioritySettings &);{}

RMMFController::SetPrioritySettings(const TMMFPrioritySettings &)const;{}

RMdaDevSound::Open(TInt);{}

Capability: NetworkControl

CBluetoothPhysicalLinks::Broadcast(const TDesC8 &);{}

CBluetoothPhysicalLinks::Disconnect(const TBTDevAddr &);{}

CBluetoothPhysicalLinks::DisconnectAll();{}

CBluetoothPhysicalLinks::ReadRaw(TDes8 &);{}

RCall::AnswerIncomingCall()const;{NetworkServices}

RCall::AnswerIncomingCall(TRequestStatus &);{NetworkServices}

RCall::AnswerIncomingCall(TRequestStatus &,const TDesC8 &);{NetworkServices}

RCall::AnswerIncomingCall(const TDesC8 &)const;{NetworkServices}

RCall::AnswerIncomingCallCancel()const;{NetworkServices}

RCall::Dial(TRequestStatus &,const TDesC8 &,const TTelNumberC &);{NetworkServices}

RCall::Dial(TRequestStatus &,const TTelNumberC &);{NetworkServices}

RCall::Dial(const TDesC8 &,const TTelNumberC &)const;{NetworkServices}

RCall::Dial(const TTelNumberC &)const;{NetworkServices}

RCall::DialCancel()const;{NetworkServices}

RCall::LoanDataPort(TCommPort &)const;{NetworkServices}

RCall::LoanDataPort(TRequestStatus &,TCommPort &);{NetworkServices}

RCall::RecoverDataPort()const;{NetworkServices}

RCdmaMobilePhone::EndEmergencyMode(TRequestStatus &)const;{NetworkServices}

RCdmaMobilePhone::SetCallProcessingSuspendState(TRequestStatus &,TBool)const;{NetworkServices}

RConnection::Control(TUint,TUint,TDes8 &);{Dependent}

RConnection::Ioctl(TUint,TUint,TRequestStatus &,TDes8 *);{Dependent}

RFax::Open(RCall &);{}

RHostResolver::SetHostName(const TDesC &);{}

RMobileCall::DialEmergencyCall(TRequestStatus &,const TDesC &)const;{NetworkServices}

RMobileCall::DialNoFdnCheck(TRequestStatus &,const TDesC &)const;{NetworkServices}

RMobileCall::DialNoFdnCheck(TRequestStatus &,const TDesC8 &,const TDesC &)const;{NetworkServices}

RMobileCall::GetMobileDataCallRLPRange(TRequestStatus &,TInt,TDes8 &)const;{ReadDeviceData}

RMobilePhone::GetDefaultPrivacy(TMobilePhonePrivacy &)const;{ReadDeviceData}

RMobilePhone::InitialiseMM(TRequestStatus &,TDes8 &)const;{WriteDeviceData}

RMobilePhone::NotifyDefaultPrivacyChange(TRequestStatus &,TMobilePhonePrivacy &)const;{ReadDeviceData}

RMobilePhone::SendNetworkServiceRequestNoFdnCheck(TRequestStatus &,const TDesC &)const;{NetworkServices, WriteDeviceData}

RMobilePhone::SetDefaultPrivacy(TRequestStatus &,TMobilePhonePrivacy)const;{WriteDeviceData}

RMobilePhone::SetPersonalisationStatus(TRequestStatus &,const TMobilePhonePersonalisation,const TDes &)const;{WriteDeviceData}

RMobilePhone::SetSmartCardApplicationStatus(TRequestStatus &,const TAID &,TSmartCardApplicationAction)const;{WriteDeviceData}

RMobilePhone::UpdateScFile(TRequestStatus &,const TScFilePathWithAccessOffsets &,TDes8 &)const;{WriteDeviceData}

RMobileSmsMessaging::AckSmsStored(TRequestStatus &,const TDesC8 &,TBool)const;{NetworkServices}

RMobileSmsMessaging::NackSmsStored(TRequestStatus &,const TDesC8 &,TInt)const;{NetworkServices}

RMobileSmsMessaging::ResumeSmsReception(TRequestStatus &)const;{NetworkServices}

RMobileSmsMessaging::SendMessageNoFdnCheck(TRequestStatus &,const TDesC8 &,TDes8 &)const;{NetworkServices}

RMobileUssdMessaging::ReceiveMessage(TRequestStatus &,TDes8 &,TDes8 &)const;{ReadDeviceData}

RMobileUssdMessaging::SendMessage(TRequestStatus &,const TDesC8 &,const TDesC8 &)const;{NetworkServices, WriteDeviceData}

RMobileUssdMessaging::SendMessageNoFdnCheck(TRequestStatus &,const TDesC8 &,const TDesC8 &)const;{NetworkServices, WriteDeviceData}

RMobileUssdMessaging::SendRelease(TRequestStatus &,TDes8 &)const;{NetworkServices}

RPhone::Initialise();{}

RPhone::Initialise(TRequestStatus &);{}

RPhone::InitialiseCancel();{}

RQoSPolicy::RQoSPolicy();{}

RQoSPolicy::~RQoSPolicy();{}

RRootServ::Bind(TRequestStatus &,TRSBindingInfo &);{}

RRootServ::LoadCpm(TRequestStatus &,const TRSStartModuleParams &,const TDesC8 &);{}

RRootServ::SetMBufPoolSize(TUint);{}

RRootServ::Shutdown();{}

RRootServ::Unbind(TRequestStatus &,TRSUnBindingInfo &);{}

RRootServ::UnloadCpm(TRequestStatus &,const TCFModuleName &,TRSUnLoadType);{}

RSADB::FinalizeAndSend(TPfkeySendMsgBase &,TRequestStatus &);{}

RSADB::ReadRequest(TDes8 &,TRequestStatus &);{}

RSADB::SendRequest(const TDesC8 &,TRequestStatus &);{}

RSat::ClientSatProfileIndication(const TDesC8 &)const;{WriteDeviceData}

RSat::EventDownload(TRequestStatus &,TEventList,const TDesC8 &)const;{WriteDeviceData}

RSat::MenuSelection(TRequestStatus &,const TDesC8 &)const;{ReadDeviceData}

RSat::NotifyCallControlRequest(TRequestStatus &,TDes8 &)const;{ReadDeviceData}

RSat::NotifyCbDownload(TRequestStatus &,TDes8 &)const;{ReadUserData}

RSat::NotifyMoSmControlRequest(TRequestStatus &,TDes8 &)const;{ReadDeviceData}

RSat::NotifySmsPpDownload(TRequestStatus &,TDes8 &)const;{ReadUserData}

RSat::TerminalRsp(TRequestStatus &,TPCmd,const TDesC8 &)const;{}

RSat::UsatClientReadyIndication()const;{}

RServiceResolver::RegisterService(const TDesC &,const TUint &);{}

RServiceResolver::RegisterService(const TDesC &,const TUint &,TRequestStatus &);{}

RServiceResolver::RemoveService(const TDesC &,const TUint &);{}

RServiceResolver::RemoveService(const TDesC &,const TUint &,TRequestStatus &);{}

RSocketServ::InstallExtension(const TDesC &,const TDesC &);{}

RSocketServ::SetExclusiveMode(TRequestStatus &);{}

RSocketServ::StartProtocol(TUint,TUint,TUint,TRequestStatus &);{}

RSocketServ::StopProtocol(TUint,TUint,TUint,TRequestStatus &);{}

RTelServer::SetPriorityClient()const;{}

Capability: NetworkServices

BAL::RBALClient::ConnectToHost();{LocalServices}

BAL::RBALClient::DisconnectFromHostL();{LocalServices}

BAL::RBALClient::SetConnectConfigurationL(const TBALConnectionConfig &);{LocalServices}

BAL::RBALClient::StartListenerL();{LocalServices}

BAL::RBALClient::StopListenerL();{LocalServices}

CAsyncRetrievePhoneList::CancelReq(TInt,TInt);{ReadDeviceData}

CAsyncRetrieveVariableLengthBuffer::DoCancel();{ReadDeviceData}

CExtensionBase::CExtensionBase();{}

CExtensionBase::Copy(const CExtensionBase &)=0;{}

CExtensionBase::CreateL()=0;{}

CExtensionBase::Data()=0;{}

CExtensionBase::ParseMessage(const TDesC8 &)=0;{}

CExtensionBase::Type()const;{}

CExtensionBase::~CExtensionBase();{}

CFaxTransfer::Start(TRequestStatus &);{ReadUserData, WriteUserData}

CFaxTransfer::Stop();{ReadUserData, WriteUserData}

CRetrieveMobilePhoneCBList::Start(TRequestStatus &,RMobilePhone::TMobilePhoneCBCondition,RMobilePhone::TMobileInfoLocation);{ReadDeviceData}

CRetrieveMobilePhoneCFList::Start(TRequestStatus &,RMobilePhone::TMobilePhoneCFCondition,RMobilePhone::TMobileInfoLocation);{ReadDeviceData}

CRetrieveMobilePhoneCWList::Start(TRequestStatus &,RMobilePhone::TMobileInfoLocation);{ReadDeviceData}

CRetrieveMobilePhoneCcbsList::Start(TRequestStatus &);{ReadDeviceData}

CRetrieveMobilePhoneDetectedNetworks::Start(TRequestStatus &);{ReadDeviceData}

CRetrieveMobilePhoneDetectedNetworks::StartV2(TRequestStatus &);{ReadDeviceData}

CSblpPolicy::Copy(const CExtensionBase &);{}

CSblpPolicy::CreateL();{}

CSblpPolicy::Data();{}

CSblpPolicy::ParseMessage(const TDesC8 &);{}

CTelephony::AnswerIncomingCall(TRequestStatus &,TCallId &,const TPhoneLine)const;{}

CTelephony::DialNewCall(TRequestStatus &,TDes8 &,const TTelNumber &,TCallId &,const TPhoneLine)const;{}

CTelephony::GetCallBarringStatus(TRequestStatus &,const TCallBarringCondition,TDes8 &,const TServiceGroup)const;{ReadDeviceData}

CTelephony::GetCallForwardingStatus(TRequestStatus &,const TCallForwardingCondition,TDes8 &,const TServiceGroup)const;{ReadDeviceData}

CTelephony::GetCallWaitingStatus(TRequestStatus &,TDes8 &,const TServiceGroup)const;{ReadDeviceData}

CTelephony::Hangup(TRequestStatus &,const TCallId &)const;{}

CTelephony::Hold(TRequestStatus &,const TCallId &)const;{}

CTelephony::Resume(TRequestStatus &,const TCallId &)const;{}

CTelephony::SendDTMFTones(TRequestStatus &,const TDesC &)const;{}

CTelephony::Swap(TRequestStatus &,const TCallId &,const TCallId &)const;{}

MQoSObserver::Event(const CQoSEventBase &)=0;{}

RCall::AcquireOwnership(TRequestStatus &)const;{}

RCall::AcquireOwnershipCancel()const;{}

RCall::AdoptFaxSharedHeaderFile(const RFile &)const;{}

RCall::AnswerIncomingCall()const;{NetworkControl}

RCall::AnswerIncomingCall(TRequestStatus &);{NetworkControl}

RCall::AnswerIncomingCall(TRequestStatus &,const TDesC8 &);{NetworkControl}

RCall::AnswerIncomingCall(const TDesC8 &)const;{NetworkControl}

RCall::AnswerIncomingCallCancel()const;{NetworkControl}

RCall::Connect()const;{}

RCall::Connect(TRequestStatus &);{}

RCall::Connect(TRequestStatus &,const TDesC8 &);{}

RCall::Connect(const TDesC8 &)const;{}

RCall::ConnectCancel()const;{}

RCall::Dial(TRequestStatus &,const TDesC8 &,const TTelNumberC &);{NetworkControl}

RCall::Dial(TRequestStatus &,const TTelNumberC &);{NetworkControl}

RCall::Dial(const TDesC8 &,const TTelNumberC &)const;{NetworkControl}

RCall::Dial(const TTelNumberC &)const;{NetworkControl}

RCall::DialCancel()const;{NetworkControl}

RCall::HangUp()const;{}

RCall::HangUp(TRequestStatus &)const;{}

RCall::HangUpCancel()const;{}

RCall::LoanDataPort(TCommPort &)const;{NetworkControl}

RCall::LoanDataPort(TRequestStatus &,TCommPort &);{NetworkControl}

RCall::RecoverDataPort()const;{NetworkControl}

RCall::TransferOwnership()const;{}

RCdmaMobileCall::NotifyIncomingNetworkFlashWithInfo(TRequestStatus &,TDes8 &)const;{ReadUserData}

RCdmaMobileCall::ResumeConnect(TRequestStatus &,const TBool)const;{}

RCdmaMobileCall::SendNetworkFlashWithInfo(TRequestStatus &,const TDes8 &)const;{}

RCdmaMobilePhone::EndEmergencyMode(TRequestStatus &)const;{NetworkControl}

RCdmaMobilePhone::ProcessOtaRequest(TRequestStatus &,const TDesC8 &,TDes8 &)const;{ReadDeviceData, WriteDeviceData}

RCdmaMobilePhone::SetCallProcessingSuspendState(TRequestStatus &,TBool)const;{NetworkControl}

RCdmaMobilePhone::StartOta(TRequestStatus &,TOtaServiceType,const TDes8 &)const;{WriteDeviceData}

RCdmaMobilePhone::StopOta(TRequestStatus &,TOtaServiceType)const;{WriteDeviceData}

RFax::Read(TRequestStatus &,TDes8 &);{ReadUserData}

RFax::TerminateFaxSession()const;{}

RFax::Write(TRequestStatus &,const TDesC8 &);{WriteUserData}

RLine::NotifyIncomingCall(TRequestStatus &,TName &);{}

RLine::NotifyIncomingCallCancel()const;{}

RMobileCall::ActivateCCBS(TRequestStatus &,TInt &)const;{}

RMobileCall::ActivateUUS(TRequestStatus &,const TDesC8 &)const;{WriteDeviceData}

RMobileCall::AnswerIncomingCallISV(TRequestStatus &,const TDesC8 &);{}

RMobileCall::AnswerIncomingCallWithUUI(TRequestStatus &,const TDesC8 &,const TMobileCallUUI &)const;{WriteUserData}

RMobileCall::AnswerMultimediaCallAsVoice(TRequestStatus &,const TDesC8 &,TName &)const;{}

RMobileCall::Deflect(TRequestStatus &,TMobileCallDeflect,const RMobilePhone::TMobileAddress &)const;{}

RMobileCall::DialEmergencyCall(TRequestStatus &,const TDesC &)const;{NetworkControl}

RMobileCall::DialISV(TRequestStatus &,const TDesC8 &,const TTelNumberC &);{}

RMobileCall::DialNoFdnCheck(TRequestStatus &,const TDesC &)const;{NetworkControl}

RMobileCall::DialNoFdnCheck(TRequestStatus &,const TDesC8 &,const TDesC &)const;{NetworkControl}

RMobileCall::GoOneToOne(TRequestStatus &)const;{}

RMobileCall::HangupWithUUI(TRequestStatus &,const TMobileCallUUI &)const;{WriteUserData}

RMobileCall::Hold(TRequestStatus &)const;{}

RMobileCall::NotifyPrivacyConfirmation(TRequestStatus &,RMobilePhone::TMobilePhonePrivacy &)const;{}

RMobileCall::NotifyTrafficChannelConfirmation(TRequestStatus &,TMobileCallTch &)const;{}

RMobileCall::ReceiveUUI(TRequestStatus &,TMobileCallUUI &)const;{ReadUserData}

RMobileCall::RejectCCBS()const;{}

RMobileCall::Resume(TRequestStatus &)const;{}

RMobileCall::SendUUI(TRequestStatus &,TBool,const TMobileCallUUI &)const;{WriteUserData}

RMobileCall::SetDynamicHscsdParams(TRequestStatus &,TMobileCallAiur,TInt)const;{}

RMobileCall::SetPrivacy(RMobilePhone::TMobilePhonePrivacy)const;{}

RMobileCall::SetTrafficChannel(TMobileCallTch)const;{}

RMobileCall::Swap(TRequestStatus &)const;{}

RMobileCall::SwitchAlternatingCall(TRequestStatus &)const;{}

RMobileCall::Transfer(TRequestStatus &)const;{}

RMobileConferenceCall::AddCall(TRequestStatus &,const TName &)const;{}

RMobileConferenceCall::CreateConference(TRequestStatus &)const;{}

RMobileConferenceCall::HangUp(TRequestStatus &)const;{}

RMobileConferenceCall::Swap(TRequestStatus &)const;{}

RMobilePhone::AcceptCCBSRecall(TRequestStatus &,TInt,TName &)const;{}

RMobilePhone::ContinueDTMFStringSending(TBool)const;{}

RMobilePhone::DeactivateCCBS(TRequestStatus &,TInt)const;{WriteDeviceData}

RMobilePhone::NotifyStopInDTMFString(TRequestStatus &)const;{}

RMobilePhone::ReadDTMFTones(TRequestStatus &,TDes &)const;{}

RMobilePhone::RefuseCCBSRecall(TInt)const;{}

RMobilePhone::SelectNetwork(TRequestStatus &,TBool,const TMobilePhoneNetworkManualSelection &)const;{WriteDeviceData}

RMobilePhone::SendDTMFTones(TRequestStatus &,const TDesC &)const;{}

RMobilePhone::SendNetworkServiceRequest(TRequestStatus &,const TDesC &)const;{WriteDeviceData}

RMobilePhone::SendNetworkServiceRequestNoFdnCheck(TRequestStatus &,const TDesC &)const;{NetworkControl, WriteDeviceData}

RMobilePhone::SetCallBarringPassword(TRequestStatus &,const TMobilePhonePasswordChangeV1 &)const;{WriteDeviceData}

RMobilePhone::SetCallBarringStatus(TRequestStatus &,TMobilePhoneCBCondition,const TMobilePhoneCBChangeV1 &)const;{WriteDeviceData}

RMobilePhone::SetCallForwardingStatus(TRequestStatus &,TMobilePhoneCFCondition,const TMobilePhoneCFChangeV1 &)const;{WriteDeviceData}

RMobilePhone::SetCallWaitingStatus(TRequestStatus &,TMobileService,TMobilePhoneServiceAction)const;{WriteDeviceData}

RMobilePhone::SetSSPassword(TRequestStatus &,const TDesC8 &,const TInt)const;{WriteDeviceData}

RMobilePhone::SetUUSSetting(TRequestStatus &,TMobilePhoneUUSSetting)const;{WriteDeviceData}

RMobilePhone::StartDTMFTone(TChar)const;{}

RMobilePhone::StopDTMFTone()const;{}

RMobilePhone::TerminateAllCalls(TRequestStatus &)const;{}

RMobileSmsMessaging::AckSmsStored(TRequestStatus &,const TDesC8 &,TBool)const;{NetworkControl}

RMobileSmsMessaging::NackSmsStored(TRequestStatus &,const TDesC8 &,TInt)const;{NetworkControl}

RMobileSmsMessaging::ReceiveMessage(TRequestStatus &,TDes8 &,TDes8 &)const;{ReadUserData}

RMobileSmsMessaging::ResumeSmsReception(TRequestStatus &)const;{NetworkControl}

RMobileSmsMessaging::SendMessage(TRequestStatus &,const TDesC8 &,TDes8 &)const;{WriteUserData}

RMobileSmsMessaging::SendMessageNoFdnCheck(TRequestStatus &,const TDesC8 &,TDes8 &)const;{NetworkControl}

RMobileUssdMessaging::SendMessage(TRequestStatus &,const TDesC8 &,const TDesC8 &)const;{NetworkControl, WriteDeviceData}

RMobileUssdMessaging::SendMessageNoFdnCheck(TRequestStatus &,const TDesC8 &,const TDesC8 &)const;{NetworkControl, WriteDeviceData}

RMobileUssdMessaging::SendRelease(TRequestStatus &,TDes8 &)const;{NetworkControl}

RPacketContext::Activate(TRequestStatus &)const;{}

RPacketContext::AddMediaAuthorizationL(TRequestStatus &,CTFTMediaAuthorizationV3 &)const;{WriteDeviceData}

RPacketContext::AddPacketFilter(TRequestStatus &,const TDesC8 &)const;{WriteDeviceData}

RPacketContext::CreateNewTFT(TRequestStatus &,const TInt)const;{}

RPacketContext::Deactivate(TRequestStatus &)const;{}

RPacketContext::DeleteTFT(TRequestStatus &)const;{}

RPacketContext::GetPacketFilterInfo(TRequestStatus &,TInt,TDes8 &)const;{ReadDeviceData}

RPacketContext::InitialiseContext(TRequestStatus &,TDes8 &)const;{}

RPacketContext::LoanCommPort(TRequestStatus &,RCall::TCommPort &)const;{}

RPacketContext::ModifyActiveContext(TRequestStatus &)const;{}

RPacketContext::RecoverCommPort(TRequestStatus &)const;{}

RPacketContext::RemoveMediaAuthorization(TRequestStatus &,TAuthorizationToken &)const;{WriteDeviceData}

RPacketContext::RemovePacketFilter(TRequestStatus &,TInt)const;{WriteDeviceData}

RPacketQoS::SetProfileParameters(TRequestStatus &,TDes8 &)const;{WriteDeviceData}

RPacketService::Attach(TRequestStatus &)const;{}

RPacketService::DeactivateNIF(TRequestStatus &,const TDesC &)const;{}

RPacketService::Detach(TRequestStatus &)const;{}

RPacketService::RejectActivationRequest(TRequestStatus &)const;{}

RPacketService::SetMSClass(TRequestStatus &,TMSClass)const;{WriteDeviceData}

RPacketService::SetPreferredBearer(TRequestStatus &,TPreferredBearer)const;{WriteDeviceData}

RSat::SendMessageNoLogging(TRequestStatus &,const TDesC8 &,TUint16 &)const;{WriteDeviceData}

RSocket::Ioctl(TUint,TRequestStatus &,TDes8 *,TUint);{Dependent}

RSyncMLDataSyncJob::CreateL(RSyncMLSession &,TSmlProfileId);{LocalServices}

RSyncMLDataSyncJob::CreateL(RSyncMLSession &,TSmlProfileId,TSmlSyncType);{LocalServices}

RSyncMLDataSyncJob::CreateL(RSyncMLSession &,TSmlProfileId,TSmlSyncType,const RArray< TSmlTaskId > &);{LocalServices}

RSyncMLDataSyncJob::CreateL(RSyncMLSession &,TSmlProfileId,const RArray< TSmlTaskId > &);{LocalServices}

RSyncMLDevManJob::CreateL(RSyncMLSession &,TSmlProfileId);{LocalServices}

RSyncMLDevManJob::CreateL(RSyncMLSession &,TSmlProfileId,TSmlConnectionId);{LocalServices}

Capability: PowerMgmt

Power::CancelWakeupEventNotification();{}

Power::DisableWakeupEvents();{}

Power::EnableWakeupEvents(TPowerState);{}

Power::PowerDown();{}

Power::RequestWakeupEventNotification(TRequestStatus &);{}

RProcess::Kill(TInt);{}

RProcess::Panic(const TDesC &,TInt);{}

RProcess::Terminate(TInt);{}

RWsSession::RequestOffEvents(TBool,RWindowTreeNode *);{}

UserHal::SwitchOff();{}

Capability: ProtServ

CServer2::Start(const TDesC &);{}

CServer2::StartL(const TDesC &);{}

User::SetCritical(TCritical);{}

User::SetProcessCritical(TCritical);{}

Capability: ReadDeviceData

CAsyncRetrieveAuthorizationInfo::Start(TRequestStatus &);{}

CAsyncRetrievePhoneList::CancelReq(TInt,TInt);{NetworkServices}

CAsyncRetrieveVariableLengthBuffer::DoCancel();{NetworkServices}

CRetrieveMobilePhoneCBList::RetrieveListL();{}

CRetrieveMobilePhoneCBList::Start(TRequestStatus &,RMobilePhone::TMobilePhoneCBCondition,RMobilePhone::TMobileInfoLocation);{NetworkServices}

CRetrieveMobilePhoneCFList::Start(TRequestStatus &,RMobilePhone::TMobilePhoneCFCondition,RMobilePhone::TMobileInfoLocation);{NetworkServices}

CRetrieveMobilePhoneCWList::RetrieveListL();{}

CRetrieveMobilePhoneCWList::Start(TRequestStatus &,RMobilePhone::TMobileInfoLocation);{NetworkServices}

CRetrieveMobilePhoneCcbsList::RetrieveListL();{}

CRetrieveMobilePhoneCcbsList::Start(TRequestStatus &);{NetworkServices}

CRetrieveMobilePhoneDetectedNetworks::Start(TRequestStatus &);{NetworkServices}

CRetrieveMobilePhoneDetectedNetworks::StartV2(TRequestStatus &);{NetworkServices}

CRetrieveMobilePhoneNamList::RetrieveListL();{}

CRetrieveMobilePhoneNamList::RetrieveListV4L();{}

CRetrieveMobilePhoneNamList::Start(TRequestStatus &,TInt);{}

CRetrieveMobilePhoneNamList::StartV4(TRequestStatus &,TInt);{}

CRetrieveMobilePhonePreferredNetworks::Start(TRequestStatus &);{}

CRetrieveMobilePhoneSmspList::RetrieveListL();{}

CRetrieveMobilePhoneSmspList::Start(TRequestStatus &);{}

CSmsSimParamOperation::DoReadSimParamsL();{}

CSmsSimParamOperation::DoRunReadSimParamsL();{}

CSmsSimParamOperation::ReadSimParamsL(TUid,TMsvId,CMsvSession &,TRequestStatus &);{}

CSmsSimParamOperation::RestoreSimParamsL(CMsvStore &,CMobilePhoneSmspList &);{}

CSmsSimParamOperation::TransferCommandL(TInt);{WriteDeviceData}

CTelephony::GetCallBarringStatus(TRequestStatus &,const TCallBarringCondition,TDes8 &,const TServiceGroup)const;{NetworkServices}

CTelephony::GetCallForwardingStatus(TRequestStatus &,const TCallForwardingCondition,TDes8 &,const TServiceGroup)const;{NetworkServices}

CTelephony::GetCallWaitingStatus(TRequestStatus &,TDes8 &,const TServiceGroup)const;{NetworkServices}

CTelephony::GetCurrentNetworkInfo(TRequestStatus &,TDes8 &)const;{Location, ReadUserData}

CTelephony::GetLockInfo(TRequestStatus &,const TIccLock &,TDes8 &)const;{}

CTelephony::GetPhoneId(TRequestStatus &,TDes8 &)const;{}

CTelephony::GetSubscriberId(TRequestStatus &,TDes8 &)const;{}

RBTRegistry::CreateView(const TBTRegistrySearch &,TRequestStatus &);{LocalServices}

RBTRegistry::GetDevice(TBTNamelessDevice &,TRequestStatus &);{LocalServices}

RCdmaMobilePhone::ProcessOtaRequest(TRequestStatus &,const TDesC8 &,TDes8 &)const;{NetworkServices, WriteDeviceData}

RCdmaMobilePhone::ReadOtaStoreBlock(TRequestStatus &,TDes8 &,TDes8 &)const;{}

RMobileCall::GetMobileDataCallRLPRange(TRequestStatus &,TInt,TDes8 &)const;{NetworkControl}

RMobileConferenceCall::GetMobileCallInfo(TInt,TDes8 &)const;{}

RMobilePhone::EnumerateAPNEntries(TRequestStatus &,TUint32 &)const;{}

RMobilePhone::GetAPNname(TRequestStatus &,const TUint32,TDes8 &)const;{}

RMobilePhone::GetCurrentNetwork(TRequestStatus &,TDes8 &,TMobilePhoneLocationAreaV1 &)const;{Location}

RMobilePhone::GetCurrentNetworkName(TRequestStatus &,TDes8 &,TDes8 &)const;{}

RMobilePhone::GetDefaultPrivacy(TMobilePhonePrivacy &)const;{NetworkControl}

RMobilePhone::GetFeatureCode(TRequestStatus &,TDes &,TMobilePhoneNetworkService,TMobilePhoneServiceAction)const;{}

RMobilePhone::GetHomeNetwork(TRequestStatus &,TDes8 &)const;{}

RMobilePhone::GetIccIdentity(TRequestStatus &,TIccIdentity &)const;{}

RMobilePhone::GetIccMessageWaitingIndicators(TRequestStatus &,TDes8 &)const;{}

RMobilePhone::GetLockInfo(TRequestStatus &,TMobilePhoneLock,TDes8 &)const;{}

RMobilePhone::GetMmsConfig(TRequestStatus &,const TMmsConnParams,TDes8 &)const;{}

RMobilePhone::GetNITZInfo(TMobilePhoneNITZ &)const;{}

RMobilePhone::GetNetworkSelectionSetting(TDes8 &)const;{}

RMobilePhone::GetPersonalisationStatus(TRequestStatus &,TUint32 &)const;{}

RMobilePhone::GetPhoneId(TRequestStatus &,TMobilePhoneIdentityV1 &)const;{}

RMobilePhone::GetPhoneStoreInfo(TRequestStatus &,TDes8 &,const TDesC &)const;{}

RMobilePhone::GetPhoneStoreInfo(TRequestStatus &,TDes8 &,const TDesC &,const TDesC &)const;{}

RMobilePhone::GetScFileInfo(TRequestStatus &,const TScFilePath &,TDes8 &)const;{}

RMobilePhone::GetServiceProviderName(TRequestStatus &,TDes8 &)const;{}

RMobilePhone::GetSubscriberId(TRequestStatus &,TMobilePhoneSubscriberId &)const;{}

RMobilePhone::NotifyCurrentNetworkChange(TRequestStatus &,TDes8 &,TMobilePhoneLocationAreaV1 &)const;{Location}

RMobilePhone::NotifyDefaultPrivacyChange(TRequestStatus &,TMobilePhonePrivacy &)const;{NetworkControl}

RMobilePhone::NotifyIccMessageWaitingIndicatorsChange(TRequestStatus &,TDes8 &)const;{}

RMobilePhone::NotifyLockInfoChange(TRequestStatus &,TMobilePhoneLock &,TDes8 &)const;{}

RMobilePhone::NotifyMmsConfig(TRequestStatus &,const TMmsConnParams,TDes8 &)const;{}

RMobilePhone::NotifyMmsUpdate(TRequestStatus &,TDes8 &)const;{}

RMobilePhone::NotifyNITZInfoChange(TRequestStatus &,TMobilePhoneNITZ &)const;{}

RMobilePhone::NotifyNetworkSelectionSettingChange(TRequestStatus &,TDes8 &)const;{}

RMobilePhone::ReadScFile(TRequestStatus &,const TScFilePathWithAccessOffsets &,TDes8 &)const;{}

RMobileUssdMessaging::ReceiveMessage(TRequestStatus &,TDes8 &,TDes8 &)const;{NetworkControl}

RPacketContext::EnumeratePacketFilters(TRequestStatus &,TInt &)const;{}

RPacketContext::GetConfig(TRequestStatus &,TDes8 &)const;{}

RPacketContext::GetDnsInfo(TRequestStatus &,TDes8 &)const;{}

RPacketContext::GetPacketFilterInfo(TRequestStatus &,TInt,TDes8 &)const;{NetworkServices}

RPacketContext::NotifyConfigChanged(TRequestStatus &,TDes8 &)const;{}

RPacketQoS::GetProfileParameters(TRequestStatus &,TDes8 &)const;{}

RPacketQoS::NotifyProfileChanged(TRequestStatus &,TDes8 &)const;{}

RPacketService::EnumerateContextsInNif(TRequestStatus &,const TDesC &,TInt &)const;{}

RPacketService::GetContextNameInNif(TRequestStatus &,const TDesC &,TInt,TDes &)const;{}

RPacketService::GetDefaultContextParams(TDes8 &)const;{}

RPacketService::GetDefaultContextParams(TRequestStatus &,TDes8 &)const;{}

RPacketService::GetNifInfo(TRequestStatus &,TInt,TDes8 &)const;{}

RSat::GetProvisioningRefFile(TRequestStatus &,const TProvisioningFileRef &,TDes8 &)const;{}

RSat::MenuSelection(TRequestStatus &,const TDesC8 &)const;{NetworkControl}

RSat::NotifyCallControlRequest(TRequestStatus &,TDes8 &)const;{NetworkControl}

RSat::NotifyDeclareServicePCmd(TRequestStatus &,TDes8 &)const;{}

RSat::NotifyDisplayTextPCmd(TRequestStatus &,TDes8 &)const;{}

RSat::NotifyGetServiceInfoPCmd(TRequestStatus &,TDes8 &)const;{}

RSat::NotifyLaunchBrowserPCmd(TRequestStatus &,TDes8 &)const;{}

RSat::NotifyLocalInfoPCmd(TRequestStatus &,TDes8 &)const;{}

RSat::NotifyMoSmControlRequest(TRequestStatus &,TDes8 &)const;{NetworkControl}

RSat::NotifyOpenChannelPCmd(TRequestStatus &,TDes8 &)const;{}

RSat::NotifyPerformCardApduPCmd(TRequestStatus &,TDes8 &)const;{}

RSat::NotifyRunAtCommandPCmd(TRequestStatus &,TDes8 &)const;{}

RSat::NotifySendDataPCmd(TRequestStatus &,TDes8 &)const;{}

RSat::NotifySendDtmfPCmd(TRequestStatus &,TDes8 &)const;{}

RSat::NotifySendSmPCmd(TRequestStatus &,TDes8 &)const;{}

RSat::NotifySendSsPCmd(TRequestStatus &,TDes8 &)const;{}

RSat::NotifySendUssdPCmd(TRequestStatus &,TDes8 &)const;{}

RSat::NotifyServiceSearchPCmd(TRequestStatus &,TDes8 &)const;{}

RSat::NotifySetUpIdleModeTextPCmd(TRequestStatus &,TDes8 &)const;{}

RSyncMLDevManProfile::OpenL(RSyncMLSession &,TSmlProfileId);{}

User::MachineConfiguration(TDes8 &,TInt &);{}

Capability: ReadUserData

AgnEntryStorer::StoreEntryL(CStreamStore &,CAgnEntry *);{}

CAgnAnniv::CopyFromL(CAgnEntry *,const MPictureFactory *);{}

CAgnAppt::CopyFromL(CAgnEntry *,const MPictureFactory *);{}

CAgnAppt::CopyFromL(CAgnEntry *,const MPictureFactory *,TCopyHow);{}

CAgnEntry::CopyBasicDetailsFromL(CAgnEntry *,const MPictureFactory *,TCopyHow);{}

CAgnEntry::GetGsDataL();{}

CAgnEntry::LoadAllComponentsL(const MPictureFactory *);{}

CAgnEntry::NotesTextL()const;{}

CAgnEntry::OpenEmbeddedStoreL();{}

CAgnEntry::UpdateNotesTextL();{WriteUserData}

CAgnEntryManager::UpdateEntryL(CAgnEntry *,TStreamId &);{}

CAgnEntryModel::AddEntryL(CAgnEntry *,TAgnEntryId);{WriteUserData}

CAgnEntryModel::AddTodoListL(CAgnTodoList *,TInt);{WriteUserData}

CAgnEntryModel::BuildTodoListsL();{}

CAgnEntryModel::CategoryL(TInt)const;{}

CAgnEntryModel::ChangeTodoListOrderL(TInt,TInt);{WriteUserData}

CAgnEntryModel::ChangeTodoOrderL(CAgnTodoList *,TAgnEntryId,TAgnEntryId);{WriteUserData}

CAgnEntryModel::ChangeTodoOrderL(TAgnTodoListId,TAgnEntryId,TAgnEntryId);{WriteUserData}

CAgnEntryModel::CheckNotifier();{WriteUserData}

CAgnEntryModel::CutEntryL(CAgnEntry *);{WriteUserData}

CAgnEntryModel::CutEntryL(TAgnEntryId);{WriteUserData}

CAgnEntryModel::DeleteEntryL(CAgnEntry *);{WriteUserData}

CAgnEntryModel::DeleteEntryL(TAgnEntryId);{WriteUserData}

CAgnEntryModel::DeleteTodoListL(CAgnTodoList *);{WriteUserData}

CAgnEntryModel::DeleteTodoListL(TAgnTodoListId);{WriteUserData}

CAgnEntryModel::DoChangeTodoOrderL(CAgnTodoList *,TAgnEntryId,TAgnEntryId);{WriteUserData}

CAgnEntryModel::DoDeleteTodoListL(CAgnTodoList *);{}

CAgnEntryModel::DoSaveTodoListsL(CStreamStore &);{WriteUserData}

CAgnEntryModel::DoUpdateEntryL(CAgnEntry *,TAgnEntryId,TBool &,TCommit);{}

CAgnEntryModel::ExportVCalL(TInt,RWriteStream &,CArrayFixFlat< TAgnEntryId > *,const Versit::TVersitCharSet);{}

CAgnEntryModel::FetchAllRelatedGsEntrysL(const HBufC8 &)const;{}

CAgnEntryModel::FetchAllRelatedGsEntrysL(const HBufC8 &,TTime)const;{}

CAgnEntryModel::FetchEntryL(TAgnEntryId)const;{}

CAgnEntryModel::FetchEntryL(TAgnGlobalId)const;{}

CAgnEntryModel::FetchEntryL(TAgnUniqueId)const;{}

CAgnEntryModel::FetchGsEntryL(const HBufC8 &)const;{}

CAgnEntryModel::FetchGsEntryL(const HBufC8 &,TTime)const;{}

CAgnEntryModel::GetGuidL(const CAgnEntry &)const;{}

CAgnEntryModel::GetLiteEntryFromServerL(TAgnEntryId,CAgnSortEntryAllocator *)const;{}

CAgnEntryModel::GetRecurrenceIdL(const CAgnEntry &)const;{}

CAgnEntryModel::OpenL(const TDesC &,TTimeIntervalMinutes,TTimeIntervalMinutes,TTimeIntervalMinutes);{}

CAgnEntryModel::PasteEntryL(CAgnEntry *,TAgnEntryId);{WriteUserData}

CAgnEntryModel::PopulateTodoListNamesL(CAgnTodoListNames *)const;{}

CAgnEntryModel::SetReplicatedEntryAsDeleted(CAgnEntry *);{}

CAgnEntryModel::SetServer(RAgendaServ *);{}

CAgnEntryModel::UpdateEntryL(CAgnEntry *,TAgnEntryId);{WriteUserData}

CAgnEntryModel::UpdateTodoListL(CAgnTodoList *);{WriteUserData}

CAgnEntryStore::UpdateEntryL(const CAgnEntry *,TBool &);{}

CAgnEvent::CopyFromL(CAgnEntry *,const MPictureFactory *);{}

CAgnIndexedModel::BuildIndexL(MAgnProgressCallBack *,TBool,TOpenCallBackFrequency);{}

CAgnIndexedModel::DeleteTidiedEntriesL();{WriteUserData}

CAgnIndexedModel::DoTidyByDateStepL();{WriteUserData}

CAgnIndexedModel::DoTidyByTodoListStepL();{WriteUserData}

CAgnIndexedModel::OpenL(const TDesC &,TTimeIntervalMinutes,TTimeIntervalMinutes,TTimeIntervalMinutes);{}

CAgnIndexedModel::OpenL(const TDesC &,TTimeIntervalMinutes,TTimeIntervalMinutes,TTimeIntervalMinutes,MAgnProgressCallBack *,TBool,TOpenCallBackFrequency);{}

CAgnIndexedModel::SetUpTidyByDateL(const TAgnFilter &,const TTime &,CStreamStore *,TStreamId &,TTidyDirective);{WriteUserData}

CAgnIndexedModel::SetUpTidyByTodoListL(CStreamStore *,TStreamId &,TTidyDirective);{WriteUserData}

CAgnIndexedModel::TidyByDateL(const TAgnFilter &,const TTime &,const TTime &,const TTime &,MAgnProgressCallBack *,TTidyDirective);{WriteUserData}

CAgnIndexedModel::TidyByTodoListL(const CArrayFixFlat< TAgnTodoListId > *,MAgnProgressCallBack *,TTidyDirective,TTidyTodoListHow);{WriteUserData}

CAgnModel::AddTodoListL(CAgnTodoList *,TInt);{WriteUserData}

CAgnModel::CutInstanceL(CAgnEntry *,TAgnWhichInstances);{WriteUserData}

CAgnModel::CutInstanceL(const TAgnInstanceId &,TAgnWhichInstances);{WriteUserData}

CAgnModel::DeleteInstanceL(CAgnEntry *,TAgnWhichInstances);{WriteUserData}

CAgnModel::DeleteTodoListL(CAgnTodoList *);{WriteUserData}

CAgnModel::DeleteTodoListL(TAgnTodoListId);{WriteUserData}

CAgnModel::PopulateTodoInstanceListL(CAgnTodoInstanceList *,const TTime &)const;{}

CAgnModel::UpdateInstanceL(CAgnEntry *,TAgnWhichInstances,TAgnEntryId);{WriteUserData}

CAgnModel::UpdateTodoListL(CAgnTodoList *);{WriteUserData}

CAgnTodo::CopyFromL(CAgnEntry *,const MPictureFactory *);{}

CAgnTodo::SetDuration(TTimeIntervalDays);{}

CCalCategoryManager::FilterCategoryL(const CCalCategory &,RPointerArray< CCalEntry > &,MCalProgressCallBack &);{}

CCalDataExchange::ExportL(TUid,RWriteStream &,RPointerArray< CCalEntry > &);{}

CCalEntryView::FetchL(const TDesC8 &,RPointerArray< CCalEntry > &)const;{}

CCalInstanceView::FindInstanceL(RPointerArray< CCalInstance > &,CalCommon::TCalViewFilter,const CalCommon::TCalTimeRange &)const;{}

CCalInstanceView::FindInstanceL(RPointerArray< CCalInstance > &,CalCommon::TCalViewFilter,const CalCommon::TCalTimeRange &,const TCalSearchParams &)const;{}

CCalSession::OpenL(const TDesC &)const;{}

CContactConcatenatedView::CContactViewBase_Reserved_1(TFunction,TAny *);{}

CContactDatabase::CommitContactL(const CContactItem &);{WriteUserData}

CContactDatabase::ContactDatabaseExistsL(const TDesC &);{}

CContactDatabase::DatabaseDrive(TDriveUnit &);{}

CContactDatabase::DefaultContactDatabaseExistsL();{}

CContactDatabase::DeleteContactL(TContactItemId);{WriteUserData}

CContactDatabase::DeleteContactsL(const CContactIdArray &);{WriteUserData}

CContactDatabase::GetCurrentDatabase(TDes &)const;{}

CContactDatabase::GetCurrentItem()const;{}

CContactDatabase::GetDefaultNameL(TDes &);{}

CContactDatabase::GetSpeedDialFieldL(TInt,TDes &);{}

CContactDatabase::ListDatabasesL();{}

CContactDatabase::ListDatabasesL(TDriveUnit);{}

CContactDatabase::MatchPhoneNumberL(const TDesC &,TInt);{}

CContactDatabase::Open(TRequestStatus &,TThreadAccess);{}

CContactDatabase::Open(const TDesC &,TRequestStatus &,TThreadAccess);{}

CContactDatabase::OpenL(TThreadAccess);{}

CContactDatabase::OpenL(const TDesC &,TThreadAccess);{}

CContactDatabase::OpenTablesL();{}

CContactDatabase::RemoveSpeedDialAttribsFromContactL(TContactItemId,TInt);{WriteUserData}

CContactDatabase::RemoveSpeedDialFieldL(TContactItemId,TInt);{WriteUserData}

CContactDatabase::SetFieldAsSpeedDialL(CContactItem &,TInt,TInt);{WriteUserData}

CContactDatabase::UnfiledContactsL();{}

CContactDatabase::UpdateContactLC(TContactItemId,CContactItem *);{WriteUserData}

CContactDatabase::doCommitContactL(const CContactItem &,TBool,TBool);{WriteUserData}

CContactDatabase::doDeleteContactL(TContactItemId,TBool,TBool,TBool);{WriteUserData}

CContactDatabase::doDeleteContactsL(const CContactIdArray &,TBool &);{WriteUserData}

CContactFilteredView::CContactViewBase_Reserved_1(TFunction,TAny *);{}

CContactFindView::CContactViewBase_Reserved_1(TFunction,TAny *);{}

CContactGroupView::CContactViewBase_Reserved_1(TFunction,TAny *);{}

CContactLocalView::CContactViewBase_Reserved_1(TFunction,TAny *);{}

CContactNamedRemoteView::CContactViewBase_Reserved_1(TFunction,TAny *);{}

CContactNamedRemoteView::ChangeSortOrderL(const RContactViewSortOrder &);{}

CContactNamedRemoteView::ConstructL(MContactViewObserver &,const TDesC &,const RContactViewSortOrder &,TContactViewPreferences);{}

CContactNamedRemoteView::ConstructL(MContactViewObserver &,const TDesC &,const RContactViewSortOrder &,TContactViewPreferences,const TDesC8 &);{}

CContactNamedRemoteView::NewL(MContactViewObserver &,const TDesC &,const CContactDatabase &,const RContactViewSortOrder &,TContactViewPreferences);{}

CContactNamedRemoteView::NewL(MContactViewObserver &,const TDesC &,const CContactDatabase &,const RContactViewSortOrder &,TContactViewPreferences,const TDesC8 &);{}

CContactRemoteView::CContactViewBase_Reserved_1(TFunction,TAny *);{}

CContactRemoteView::ConstructL(MContactViewObserver &,const RContactViewSortOrder &,TContactViewPreferences);{}

CContactRemoteView::ConstructL(MContactViewObserver &,const RContactViewSortOrder &,TContactViewPreferences,const TDesC8 &);{}

CContactRemoteView::GetSortOrderL(RContactViewSortOrder &);{}

CContactRemoteView::NewL(MContactViewObserver &,const CContactDatabase &,const RContactViewSortOrder &,TContactViewPreferences);{}

CContactRemoteView::NewL(MContactViewObserver &,const CContactDatabase &,const RContactViewSortOrder &,TContactViewPreferences,const TDesC8 &);{}

CContactRemoteViewBase::AllFieldsLC(TInt,const TDesC &)const;{}

CContactRemoteViewBase::AtL(TInt)const;{}

CContactRemoteViewBase::CContactViewBase_Reserved_1(TFunction,TAny *);{}

CContactRemoteViewBase::ConstructL(MContactViewObserver &);{}

CContactRemoteViewBase::ContactAtL(TInt)const;{}

CContactRemoteViewBase::ContactViewPreferences();{}

CContactRemoteViewBase::ContactsMatchingCriteriaL(const MDesC16Array &,RPointerArray< CViewContact > &);{}

CContactRemoteViewBase::ContactsMatchingPrefixL(const MDesC16Array &,RPointerArray< CViewContact > &);{}

CContactRemoteViewBase::CountL()const;{}

CContactRemoteViewBase::FindL(TContactItemId)const;{}

CContactRemoteViewBase::GetContactIdsL(const CArrayFix< TInt > &,CContactIdArray &);{}

CContactRemoteViewBase::GetContactsMatchingFilterL(TInt,RArray< TContactIdWithMapping > &);{}

CContactRemoteViewBase::SortOrderL()const;{}

CContactSubView::CContactViewBase_Reserved_1(TFunction,TAny *);{}

CContactViewBase::AllFieldsLC(TInt,const TDesC &)const=0;{}

CContactViewBase::AtL(TInt)const=0;{}

CContactViewBase::CContactViewBase_Reserved_1(TFunction,TAny *);{}

CContactViewBase::ContactAtL(TInt)const=0;{}

CContactViewBase::ContactViewPreferences()=0;{}

CContactViewBase::ContactsMatchingCriteriaL(const MDesC16Array &,RPointerArray< CViewContact > &);{}

CContactViewBase::ContactsMatchingPrefixL(const MDesC16Array &,RPointerArray< CViewContact > &);{}

CContactViewBase::CountL()const=0;{}

CContactViewBase::FindL(TContactItemId)const=0;{}

CContactViewBase::GetContactIdsL(const CArrayFix< TInt > &,CContactIdArray &);{}

CContactViewBase::SortOrderL()const=0;{}

CFaxTransfer::Start(TRequestStatus &);{NetworkServices, WriteUserData}

CFaxTransfer::Stop();{NetworkServices, WriteUserData}

CRetrieveMobilePhoneBroadcastIdList::RetrieveListL();{}

CRetrieveMobilePhoneBroadcastIdList::Start(TRequestStatus &,RMobileBroadcastMessaging::TMobileBroadcastIdType);{}

CRetrieveMobilePhoneENList::RetrieveListL();{}

CRetrieveMobilePhoneENList::Start(TRequestStatus &);{}

CRetrieveMobilePhoneONList::RetrieveListL();{}

CRetrieveMobilePhoneONList::Start(TRequestStatus &);{}

CRetrieveMobilePhoneSmsList::RetrieveCdmaListL();{}

CRetrieveMobilePhoneSmsList::RetrieveGsmListL();{}

CRetrieveMobilePhoneSmsList::Start(TRequestStatus &);{}

CRetrieveMobilePhoneSmsList::StartBatch(TRequestStatus &,TInt,TInt);{}

CSWICertStore::Retrieve(const CCTCertInfo &,TDes8 &,TRequestStatus &);{}

CSmsEventLogger::GetEvent(TRequestStatus &,TLogId);{}

CSmsHeader::InternalizeL(RMsvReadStream &);{}

CSmsHeader::RestoreL(CMsvStore &);{}

CSmsHeader::RestoreL(CMsvStore &,CEditableText &);{}

CTelephony::GetCallInfo(TDes8 &,TDes8 &,TDes8 &)const;{}

CTelephony::GetCurrentNetworkInfo(TRequestStatus &,TDes8 &)const;{Location, ReadDeviceData}

CTelephony::GetCurrentNetworkName(TRequestStatus &,TDes8 &)const;{}

CTelephony::GetOperatorName(TRequestStatus &,TDes8 &)const;{}

CUnifiedCertStore::Retrieve(const CCTCertInfo &,CCertificate *&,TRequestStatus &);{}

CUnifiedCertStore::Retrieve(const CCTCertInfo &,TDes8 &,TRequestStatus &);{}

CUnifiedKeyStore::ExportEncryptedKey(TCTTokenObjectHandle,const CPBEncryptParms &,HBufC8 *&,TRequestStatus &);{}

CUnifiedKeyStore::ExportKey(TCTTokenObjectHandle,HBufC8 *&,TRequestStatus &);{}

CUnifiedKeyStore::GetKeyInfo(TCTTokenObjectHandle,CCTKeyInfo *&,TRequestStatus &);{}

CUnifiedKeyStore::List(RMPointerArray< CCTKeyInfo > &,const TCTKeyAttributeFilter &,TRequestStatus &);{}

CUnifiedKeyStore::Open(const TCTTokenObjectHandle &,MCTDH *&,TRequestStatus &);{}

CUnifiedKeyStore::Open(const TCTTokenObjectHandle &,MCTDecryptor *&,TRequestStatus &);{}

CUnifiedKeyStore::Open(const TCTTokenObjectHandle &,MDSASigner *&,TRequestStatus &);{}

CUnifiedKeyStore::Open(const TCTTokenObjectHandle &,MRSASigner *&,TRequestStatus &);{}

MCertStore::Retrieve(const CCTCertInfo &,TDes8 &,TRequestStatus &)=0;{}

MKeyStore::List(RMPointerArray< CCTKeyInfo > &,const TCTKeyAttributeFilter &,TRequestStatus &)=0;{}

RAgendaServ::AddEntryL(CAgnEntry *,TAgnEntryId,TInt,TBool);{WriteUserData}

RAgendaServ::CategoryL(TInt);{}

RAgendaServ::CreateTransmitBufferL(TInt)const;{}

RAgendaServ::DateIteratorCurrentElement(CAgnSortEntryAllocator *);{}

RAgendaServ::DeleteEntryL(CAgnEntry *);{WriteUserData}

RAgendaServ::FetchEntryL(TAgnEntryId,CParaFormatLayer *,CCharFormatLayer *)const;{}

RAgendaServ::FetchEntryL(TAgnGlobalId,CParaFormatLayer *,CCharFormatLayer *)const;{}

RAgendaServ::FetchEntryL(TAgnUniqueId,CParaFormatLayer *,CCharFormatLayer *)const;{}

RAgendaServ::GetEmbeddedReadStreamL(TStreamId);{}

RAgendaServ::GetLiteEntryL(TAgnEntryId,CAgnSortEntryAllocator *)const;{}

RAgendaServ::GetReadStreamL(TStreamId);{}

RAgendaServ::RefreshTodoListListL(CAgnTodoListList *,CAgnDeletedTodoListList *);{}

RAgendaServ::RestoreNotesTextL(TStreamId);{}

RAgendaServ::UpdateEntryL(CAgnEntry *,TAgnEntryId);{WriteUserData}

RCdmaMobileCall::NotifyIncomingNetworkFlashWithInfo(TRequestStatus &,TDes8 &)const;{NetworkServices}

RCdmaMobilePhone::NotifyIncomingInfoRecord(TRequestStatus &,TDes8 &)const;{}

RContactRemoteView::AllFieldsLC(TInt,const TDesC &)const;{}

RContactRemoteView::AtL(TInt)const;{}

RContactRemoteView::ChangeSortOrderL(const RContactViewSortOrder &);{}

RContactRemoteView::ContactAtL(TInt);{}

RContactRemoteView::ContactViewPreferencesL();{}

RContactRemoteView::ContactsMatchingCriteriaL(const MDesC16Array &,RPointerArray< CViewContact > &,TBool,TUid);{}

RContactRemoteView::CountL()const;{}

RContactRemoteView::FindL(TContactItemId)const;{}

RContactRemoteView::GetContactIdsL(const CArrayFix< TInt > &,CContactIdArray &);{}

RContactRemoteView::GetContactsMatchingFilterL(TInt,RArray< TContactIdWithMapping > &);{}

RContactRemoteView::GetSortOrderL(RContactViewSortOrder &);{}

RContactRemoteView::OpenL(const CContactDatabase &,const RContactViewSortOrder &,TContactViewPreferences,const TUid &,const TDesC8 &);{}

RContactRemoteView::OpenL(const CContactDatabase &,const TDesC &,const RContactViewSortOrder &,TContactViewPreferences,const TUid &,const TDesC8 &);{}

RContactRemoteView::RequestViewEvent(TPckgBuf< TContactViewEvent > &,TRequestStatus &);{}

RContactRemoteView::SortOrderL();{}

RFax::GetProgress(TProgress &);{}

RFax::Read(TRequestStatus &,TDes8 &);{NetworkServices}

RMobileBroadcastMessaging::GetFilterSetting(TMobilePhoneBroadcastFilter &)const;{}

RMobileBroadcastMessaging::GetLanguageFilter(TRequestStatus &,TDes16 &)const;{}

RMobileBroadcastMessaging::NotifyFilterSettingChange(TRequestStatus &,TMobilePhoneBroadcastFilter &)const;{}

RMobileBroadcastMessaging::NotifyLanguageFilterChange(TRequestStatus &,TDes16 &)const;{}

RMobileCall::GetMobileCallInfo(TDes8 &)const;{}

RMobileCall::NotifyRemotePartyInfoChange(TRequestStatus &,TDes8 &)const;{}

RMobileCall::ReceiveUUI(TRequestStatus &,TMobileCallUUI &)const;{NetworkServices}

RMobilePhone::GetAirTimeDuration(TTimeIntervalSeconds &)const;{}

RMobilePhone::GetCostInfo(TRequestStatus &,TDes8 &)const;{}

RMobilePhone::GetCurrentNetwork(TRequestStatus &,TDes8 &)const;{}

RMobilePhone::GetMailboxNumbers(TRequestStatus &,TDes8 &)const;{}

RMobilePhone::NotifyAirTimeDurationChange(TRequestStatus &,TTimeIntervalSeconds &)const;{}

RMobilePhone::NotifyCostInfoChange(TRequestStatus &,TDes8 &)const;{}

RMobilePhone::NotifyCurrentNetworkChange(TRequestStatus &,TDes8 &)const;{}

RMobilePhone::NotifyMailboxNumbersChange(TRequestStatus &,TDes8 &)const;{}

RMobilePhoneBookStore::Read(TRequestStatus &,TInt,TInt,TDes8 &)const;{}

RMobilePhoneStore::GetInfo(TRequestStatus &,TDes8 &)const;{}

RMobilePhoneStore::NotifyStoreEvent(TRequestStatus &,TUint32 &,TInt &)const;{}

RMobilePhoneStore::Read(TRequestStatus &,TDes8 &)const;{}

RMobileSmsMessaging::ReceiveMessage(TRequestStatus &,TDes8 &,TDes8 &)const;{NetworkServices}

RMsvServerSession::ChangeEntryL(const TMsvEntry &,TMsvOp,TSecureId);{None, WriteDeviceData, WriteUserData}

RMsvServerSession::ChangeEntryL(const TMsvEntry &,TMsvOp,TSecureId,TRequestStatus &);{None, WriteDeviceData, WriteUserData}

RMsvServerSession::CopyEntriesL(const CMsvEntrySelection &,TMsvId,TMsvOp);{None, WriteUserData}

RMsvServerSession::CopyEntriesL(const CMsvEntrySelection &,TMsvId,TMsvOp,TRequestStatus &);{None, WriteUserData}

RMsvServerSession::CreateAttachmentForWriteL(TMsvId,TDes &,RFile &);{None, WriteDeviceData, WriteUserData}

RMsvServerSession::CreateEntryL(const TMsvEntry &,TMsvOp,TSecureId);{None, WriteDeviceData, WriteUserData}

RMsvServerSession::CreateEntryL(const TMsvEntry &,TMsvOp,TSecureId,TRequestStatus &);{None, WriteDeviceData, WriteUserData}

RMsvServerSession::DecStoreReaderCount(TMsvId);{None}