如何查找symbian CAPABILITY 对应的系统api

来源:互联网 发布:淘宝删除代发货的 编辑:程序博客网 时间:2024/05/15 02:18

在S60_MR_Doc帮助文档(CHM)中搜索doxygen
然后打开搜索结果的最后一项,你期待的东东就出现咯

 

附结果:

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}

RMsvServerSession::DeleteAttachment(TMsvId,const TDesC &);{None, WriteDeviceData, WriteUserData}

RMsvServerSession::DeleteEntriesL(const CMsvEntrySelection &,TMsvOp);{None, WriteDeviceData, WriteUserData}

RMsvServerSession::DeleteEntriesL(const CMsvEntrySelection &,TMsvOp,TRequestStatus &);{None, WriteDeviceData, WriteUserData}

RMsvServerSession::DeleteFileStoreL(TMsvId);{None, WriteDeviceData, WriteUserData}

RMsvServerSession::GetChildIdsL(TMsvId,const CMsvEntryFilter &,CMsvEntrySelection &);{None}

RMsvServerSession::GetChildren(TMsvId,CArrayPtrFlat< CMsvClientEntry > &,const TMsvSelectionOrdering &);{None}

RMsvServerSession::GetEntry(TMsvId,TMsvId &,TMsvEntry &);{None}

RMsvServerSession::LockStore(TMsvId);{None, WriteDeviceData, WriteUserData}

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

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

RMsvServerSession::OpenAttachmentForWriteL(TMsvId,const TDesC &,RFile &);{None, WriteUserData}

RMsvServerSession::OpenAttachmentL(TMsvId,const TDesC &,RFile &);{None}

RMsvServerSession::OpenFileStoreForRead(TMsvId,RFile &);{None}

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

RMsvServerSession::ReadStore(TMsvId);{None}

RMsvServerSession::ReleaseStore(TMsvId);{None, WriteDeviceData, WriteUserData}

RMsvServerSession::RemoveEntry(TMsvId);{None, WriteDeviceData, WriteUserData}

RMsvServerSession::ReplaceFileStoreL(TMsvId);{None, WriteDeviceData, WriteUserData}

RMsvServerSession::TransferCommandL(const CMsvEntrySelection &,TInt,const TDesC8 &,TMsvOp);{WriteUserData}

RMsvServerSession::TransferCommandL(const CMsvEntrySelection &,TInt,const TDesC8 &,TMsvOp,TRequestStatus &);{WriteUserData}

RPacketContext::GetDataVolumeTransferred(TDataVolume &)const;{}

RPacketContext::GetDataVolumeTransferred(TRequestStatus &,TDataVolume &)const;{}

RPacketContext::NotifyDataTransferred(TRequestStatus &,TDataVolume &,TUint,TUint)const;{}

RPhoneBookSession::CancelRequest(TPhonebookSyncRequestCancel,TUid);{WriteUserData}

RPhoneBookSession::DoSynchronisation(TRequestStatus &);{WriteUserData}

RPhoneBookSession::DoSynchronisation(TRequestStatus &,TUid);{WriteUserData}

RPhoneBookSession::ShutdownServer(TBool);{WriteUserData}

RPhoneBookSession::ValidateContact(MContactSynchroniser::TValidateOperation,TContactItemId);{}

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

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

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

RWorldServer::Home(TWorldId &)const;{}

TAgnInstanceEditor::CreateAndStoreExceptionL(CAgnEntry *&,CAgnEntry *,TAgnEntryId);{WriteUserData}

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

TAgnInstanceEditor::DoUpdateInstanceL(CAgnEntry *,TAgnWhichInstances,TAgnEntryId);{WriteUserData}

TAgnInstanceEditor::SplitRepeatL(CAgnEntry *&,TAgnWhichInstances,CAgnEntry *,TAgnEntryId);{WriteUserData}

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

Capability: SurroundingsDD

Capability: SwEvent

RWindowGroup::CaptureKey(TUint,TUint,TUint);{}

RWindowGroup::CaptureKey(TUint,TUint,TUint,TInt);{}

RWindowGroup::CaptureKeyUpAndDowns(TUint,TUint,TUint);{}

RWindowGroup::CaptureKeyUpAndDowns(TUint,TUint,TUint,TInt);{}

RWindowGroup::CaptureLongKey(TTimeIntervalMicroSeconds32,TUint,TUint,TUint,TUint,TInt,TUint);{}

RWindowGroup::CaptureLongKey(TUint,TUint,TUint,TUint,TInt,TUint);{}

RWsSession::SendEventToAllWindowGroups(TInt,const TWsEvent &);{}

RWsSession::SendEventToAllWindowGroups(const TWsEvent &);{}

RWsSession::SendEventToOneWindowGroupsPerClient(const TWsEvent &);{}

RWsSession::SendEventToWindowGroup(TInt,const TWsEvent &);{}

RWsSession::SimulateKeyEvent(TKeyEvent);{}

RWsSession::SimulateRawEvent(TRawEvent);{}

UserSvr::AddEvent(const TRawEvent &);{}

Capability: Tcb

RLocalDrive::Connect(TInt,TBool &);{}

TBusLocalDrive::Connect(TInt,TBool &);{}

Capability: TrustedUI

Capability: UserEnvironment

CCamera::NewDuplicateL(MCameraObserver &,TInt);{}

CCamera::NewDuplicateL(MCameraObserver2 &,TInt);{}

CCamera::NewL(MCameraObserver &,TInt);{}

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

CMMFDevSound::RecordData();{}

CMMFDevSound::RecordInitL();{}

CMdaAudioInputStream::NewL(MMdaAudioInputStreamCallback &);{}

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

CMdaAudioRecorderUtility::RecordL();{}

Capability: WriteDeviceData

CCertificateAppInfoManager::AddL(const TCertificateAppInfo &);{}

CCertificateAppInfoManager::RemoveL(const TUid &);{}

CCoeEnv::InstallFepL(TUid);{}

CCoeEnv::InstallFepL(TUid,const TBool);{}

CCoeFep::IsTurnedOffByL(const TKeyEvent &)const;{}

CCoeFep::IsTurnedOnByL(const TKeyEvent &)const;{}

CCoeFep::WriteAttributeDataAndBroadcastL(TUid);{}

CCoeFep::WriteAttributeDataAndBroadcastL(const TArray< TUid > &);{}

CEikonEnv::UpdateSystemColorListL(const CColorList &);{}

CFepGenericGlobalSettings::StoreChangesAndBroadcastL();{}

CLogClient::AddEventType(const CLogEventType &,TRequestStatus &);{}

CLogClient::ChangeConfig(const TLogConfig &,TRequestStatus &);{}

CLogClient::ChangeEventType(const CLogEventType &,TRequestStatus &);{}

CLogClient::ClearLog(TInt,TRequestStatus &);{}

CLogClient::ClearLog(const TTime &,TRequestStatus &);{}

CLogClient::DeleteEventType(TUid,TRequestStatus &);{}

CLogViewDuplicate::RemoveL(TLogId);{}

CLogViewDuplicate::RemoveL(TRequestStatus &);{}

CLogViewRecent::ClearDuplicatesL();{}

CLogViewRecent::RemoveL(TLogId);{}

CLogViewRecent::RemoveL(TRequestStatus &);{}

CMobilePhoneStoredNetworkList::ChangeEntryL(TInt,const RMobilePhone::TMobilePreferredNetworkEntryV3 &);{}

CMobilePhoneStoredNetworkList::DeleteEntryL(TInt);{}

CMobilePhoneStoredNetworkList::InsertEntryL(TInt,const RMobilePhone::TMobilePreferredNetworkEntryV3 &);{}

CServiceRegistry::RemoveEntry(TUid,const TDataType &);{}

CServiceRegistry::SetDefault(TUid,const TDataType &,TUid);{}

CSmsMessageSettings::ExternalizeL(RWriteStream &)const;{}

CSmsSimParamOperation::DoWriteSimParamsL(const CMobilePhoneSmspList &);{}

CSmsSimParamOperation::StoreSimParamsL(CMsvStore &,const CMobilePhoneSmspList &);{}

CSmsSimParamOperation::TransferCommandL(TInt);{ReadDeviceData}

CSmsSimParamOperation::WriteSimParamsL(const CMobilePhoneSmspList &,TUid,TMsvId,CMsvSession &,TRequestStatus &);{}

CUnifiedCertStore::Remove(const CCTCertInfo &,TRequestStatus &);{WriteUserData}

CUnifiedCertStore::SetApplicability(const CCTCertInfo &,const RArray< TUid > &,TRequestStatus &);{}

CUnifiedCertStore::SetTrust(const CCTCertInfo &,TBool,TRequestStatus &);{}

CWsScreenDevice::SetCurrentRotations(TInt,CFbsBitGc::TGraphicsOrientation)const;{}

CWsScreenDevice::SetCustomPalette(const CPalette *);{}

CWsScreenDevice::SetScreenMode(TInt);{}

CWsScreenDevice::SetScreenModeEnforcement(TScreenModeEnforcement)const;{}

MCTWritableCertStore::Add(const TDesC &,TCertificateFormat,TCertificateOwnerType,const TKeyIdentifier *,const TKeyIdentifier *,const TDesC8 &,TRequestStatus &)=0;{WriteUserData}

MCTWritableCertStore::Add(const TDesC &,TCertificateFormat,TCertificateOwnerType,const TKeyIdentifier *,const TKeyIdentifier *,const TDesC8 &,const TBool,TRequestStatus &);{WriteUserData}

MCTWritableCertStore::Remove(const CCTCertInfo &,TRequestStatus &)=0;{WriteUserData}

MCTWritableCertStore::SetApplicability(const CCTCertInfo &,const RArray< TUid > &,TRequestStatus &)=0;{}

MCTWritableCertStore::SetTrust(const CCTCertInfo &,TBool,TRequestStatus &)=0;{}

MFepAttributeStorer::WriteAttributeDataAndBroadcastL(CCoeEnv &,TUid);{}

MFepAttributeStorer::WriteAttributeDataAndBroadcastL(CCoeEnv &,const TArray< TUid > &);{}

RApaLsSession::DeleteDataMapping(const TDataType &);{}

RApaLsSession::InsertDataMapping(const TDataType &,TDataTypePriority,TUid);{}

RApaLsSession::InsertDataMappingIfHigher(const TDataType &,TDataTypePriority,TUid,TBool &);{}

RApaLsSession::SetAcceptedConfidence(TInt);{}

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

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

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

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

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

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

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

RCall::SetFaxSettings(const TFaxSessionSettings &)const;{}

RCdmaMobilePhone::LockNam(TRequestStatus &,TMobilePhoneNamCommitStatus)const;{}

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

RCdmaMobilePhone::SetDTMFBurstDuration(TRequestStatus &,TMobilePhoneDtmfOnDuration,TMobilePhoneDtmfOffDuration)const;{}

RCdmaMobilePhone::SetDTMFMode(TRequestStatus &,TMobilePhoneDtmfMode)const;{}

RCdmaMobilePhone::SetLocationPrivacy(TRequestStatus &,TMobilePhoneLocationPrivacy)const;{}

RCdmaMobilePhone::SetOtaSettings(TRequestStatus &,TUint)const;{}

RCdmaMobilePhone::SetTtyMode(TRequestStatus &,TMobilePhoneTtyMode)const;{}

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

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

RCdmaMobilePhone::StorePreferredLanguagesListL(TRequestStatus &,CMobilePhonePreferredLanguagesList *)const;{}

RCdmaMobilePhone::UnlockNam(TRequestStatus &,const RMobilePhone::TMobilePassword &)const;{}

RCdmaMobilePhone::WriteOtaStoreBlock(TRequestStatus &,const TDesC8 &,const TDesC8 &)const;{}

RDmDomain::Connect(TDmDomainId);{}

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

RMobileNamStore::SetActiveNam(TRequestStatus &,TInt)const;{}

RMobileNamStore::StoreAllL(TRequestStatus &,TInt,CMobilePhoneNamList *)const;{}

RMobileNamStore::StoreAllL(TRequestStatus &,TInt,CMobilePhoneNamListV4 *)const;{}

RMobilePhone::AbortSecurityCode(TMobilePhoneSecurityCode)const;{}

RMobilePhone::ChangeSecurityCode(TRequestStatus &,TMobilePhoneSecurityCode,const TMobilePhonePasswordChangeV1 &)const;{}

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

RMobilePhone::ClearCostMeter(TRequestStatus &,TMobilePhoneCostMeters)const;{}

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

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

RMobilePhone::ProgramFeatureCode(TRequestStatus &,const TDesC &,TMobilePhoneNetworkService,TMobilePhoneServiceAction)const;{}

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

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

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

RMobilePhone::SetALSLine(TRequestStatus &,TMobilePhoneALSLine)const;{}

RMobilePhone::SetAlternatingCallMode(TRequestStatus &,TMobilePhoneAlternatingCallMode,TMobileService)const;{}

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

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

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

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

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

RMobilePhone::SetFdnSetting(TRequestStatus &,TMobilePhoneFdnSetting)const;{}

RMobilePhone::SetIccMessageWaitingIndicators(TRequestStatus &,const TDesC8 &)const;{}

RMobilePhone::SetIdentityServiceStatus(TRequestStatus &,const TMobilePhoneIdService,const TMobilePhoneIdServiceSetting)const;{}

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

RMobilePhone::SetLockSetting(TRequestStatus &,TMobilePhoneLock,TMobilePhoneLockSetting)const;{}

RMobilePhone::SetMaxCostMeter(TRequestStatus &,TUint)const;{}

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

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

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

RMobilePhone::SetMultimediaCallPreference(TRequestStatus &,TMobilePhoneMultimediaSettings)const;{}

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

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

RMobilePhone::SetPuct(TRequestStatus &,const TDesC8 &)const;{}

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

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

RMobilePhone::SetUSimApplicationStatus(TRequestStatus &,const TAID,TUSimAppAction)const;{}

RMobilePhone::SetUSimAppsSelectionMode(TUSimSelectionMode)const;{}

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

RMobilePhone::StorePreferredNetworksListL(TRequestStatus &,CMobilePhoneStoredNetworkList *)const;{}

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

RMobilePhone::VerifySecurityCode(TRequestStatus &,TMobilePhoneSecurityCode,const TMobilePassword &,const TMobilePassword &)const;{}

RMobileSmsMessaging::SetMoSmsBearer(TRequestStatus &,TMobileSmsBearer)const;{}

RMobileSmsMessaging::SetReceiveMode(TRequestStatus &,TMobileSmsReceiveMode)const;{}

RMobileSmsMessaging::StoreSmspListL(TRequestStatus &,CMobilePhoneSmspList *)const;{}

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

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

RMsvServerSession::ChangeDriveL(TInt,TMsvOp,TRequestStatus &);{}

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

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

RMsvServerSession::CloseMessageServer();{}

RMsvServerSession::CopyStoreL(const TDriveUnit &,TMsvOp,TRequestStatus &);{}

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

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

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

RMsvServerSession::DeInstallMtmGroup(const TDesC &);{}

RMsvServerSession::DeleteAttachment(TMsvId,const TDesC &);{None, ReadUserData, WriteUserData}

RMsvServerSession::DeleteEntriesL(const CMsvEntrySelection &,TMsvOp);{None, ReadUserData, WriteUserData}

RMsvServerSession::DeleteEntriesL(const CMsvEntrySelection &,TMsvOp,TRequestStatus &);{None, ReadUserData, WriteUserData}

RMsvServerSession::DeleteFileStoreL(TMsvId);{None, ReadUserData, WriteUserData}

RMsvServerSession::DeleteStoreL(const TDriveUnit &,TMsvOp,TRequestStatus &);{}

RMsvServerSession::InstallMtmGroup(const TDesC &);{}

RMsvServerSession::LockStore(TMsvId);{None, ReadUserData, WriteUserData}

RMsvServerSession::OpenTempStoreFileL(TMsvId,RFile &);{None, ReadUserData, WriteUserData}

RMsvServerSession::ReleaseStore(TMsvId);{None, ReadUserData, WriteUserData}

RMsvServerSession::RemoveEntry(TMsvId);{None, ReadUserData, WriteUserData}

RMsvServerSession::ReplaceFileStoreL(TMsvId);{None, ReadUserData, WriteUserData}

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

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

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

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

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

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

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

RPacketService::SetAttachMode(TAttachMode)const;{}

RPacketService::SetAttachMode(TRequestStatus &,TAttachMode)const;{}

RPacketService::SetDefaultContextParams(TRequestStatus &,const TDesC8 &)const;{}

RPacketService::SetDefaultContextParams(const TDesC8 &)const;{}

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

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

RProperty::Define(TUid,TUint,TInt,const TSecurityPolicy &,const TSecurityPolicy &,TInt);{}

RProperty::Define(TUint,TInt,const TSecurityPolicy &,const TSecurityPolicy &,TInt);{}

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

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

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

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

RSoundPlugIn::Load(const TDesC &);{}

RSoundPlugIn::SetKeyClick(TBool);{}

RSoundPlugIn::SetPenClick(TBool);{}

RSoundPlugIn::Unload();{}

RSyncMLDataSyncProfile::CreateL(RSyncMLSession &);{}

RSyncMLDevMan::ClearRootAclL();{}

RSyncMLDevManProfile::CreateL(RSyncMLSession &);{}

RSyncMLHistoryLog::DeleteAllEntriesL();{}

RSyncMLSession::DeleteProfileL(TSmlProfileId);{}

RSyncMLSettings::SetValueL(TSmlGlobalSetting,TInt);{}

RTz::SetTimeZoneL(CTzId &)const;{}

RWindowGroup::DefaultOwningWindow();{}

RWorldServer::DataFileRevertToSaved();{WriteUserData}

RWorldServer::DataFileSave();{WriteUserData}

RWorldServer::ResetAllData();{WriteUserData}

RWorldServer::SetHome(const TWorldId &);{WriteUserData}

RWorldServer::UpdateCity(TWorldId &,const TCityData &);{WriteUserData}

RWorldServer::UpdateCountry(TWorldId &,const TCountryData &);{WriteUserData}

RWsSession::ClaimSystemPointerCursorList();{}

RWsSession::SetClientCursorMode(TPointerCursorMode);{}

RWsSession::SetDefaultFadingParameters(TUint8,TUint8);{}

RWsSession::SetDoubleClick(const TTimeIntervalMicroSeconds32 &,TInt);{}

RWsSession::SetKeyboardRepeatRate(const TTimeIntervalMicroSeconds32 &,const TTimeIntervalMicroSeconds32 &);{}

RWsSession::SetModifierState(TEventModifier,TModifierState);{}

RWsSession::SetPointerCursorArea(TInt,const TRect &);{}

RWsSession::SetPointerCursorPosition(const TPoint &);{}

RWsSession::SetSystemFaded(TBool);{}

RWsSession::SetSystemFaded(TBool,TUint8,TUint8);{}

TExtendedLocale::SaveSystemSettings();{}

TExtendedLocale::SetCurrencySymbol(const TDesC &);{}

TLocale::Set()const;{}

User::SetCurrencySymbol(const TDesC &);{}

User::SetHomeTime(const TTime &);{}

User::SetMachineConfiguration(const TDesC8 &);{}

User::SetUTCOffset(TTimeIntervalSeconds);{}

User::SetUTCTime(const TTime &);{}

User::SetUTCTimeAndOffset(const TTime &,TTimeIntervalSeconds);{}

UserHal::RestoreXYInputCalibration(TDigitizerCalibrationType);{}

UserHal::SetXYInputCalibration(const TDigitizerCalibration &);{}

UserSvr::SetMemoryThresholds(TInt,TInt);{}

Capability: WriteUserData

CAgnAlarm::FindAndQueueNextAlarmL();{}

CAgnAlarm::RestartL();{}

CAgnAlarmActive::FindAndQueueNextAlarmL();{}

CAgnEntry::StoreNotesTextL();{}

CAgnEntry::UpdateNotesTextL();{ReadUserData}

CAgnEntryModel::AddCategoryToListL(const TDesC &);{}

CAgnEntryModel::AddEntryForServerL(CAgnEntry *,TAgnEntryId,TCommit,TUseExistingUniqueId);{}

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

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

CAgnEntryModel::AddGsChildExceptionEntryL(CAgnEntry *,TAgnUniqueId,TGsBasicData,TTime);{}

CAgnEntryModel::AddGsChildRuleEntryL(CAgnEntry *,TAgnUniqueId,TGsBasicData,TTime);{}

CAgnEntryModel::AddGsEntryL(CAgnEntry *,HBufC8 *,TGsBasicData);{}

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

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

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

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

CAgnEntryModel::CheckNotifier();{ReadUserData}

CAgnEntryModel::CreateL(RFs &,TFileName,const TDesC &,const CParaFormatLayer *,const CCharFormatLayer *);{}

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

CAgnEntryModel::CutEntryL(TAgnEntryId);{ReadUserData}

CAgnEntryModel::DeleteAgendaFileL(const TDesC &)const;{}

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

CAgnEntryModel::DeleteEntryL(TAgnEntryId);{ReadUserData}

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

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

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

CAgnEntryModel::DeleteTodoListL(TAgnTodoListId);{ReadUserData}

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

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

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

CAgnEntryModel::QueueNextAlarmL(const TTime &,CArrayFixFlat< TAgnSortInstance > *);{}

CAgnEntryModel::RegisterObserverL(TUid,const TDesC8 &);{}

CAgnEntryModel::SecureSaveTodoListsL(const TDesC &)const;{}

CAgnEntryModel::SetParaAndCharFormatLayersL(const CParaFormatLayer *,const CCharFormatLayer *);{}

CAgnEntryModel::UnregisterObserverL(TUid);{}

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

CAgnEntryModel::UpdateObserverControllerL();{}

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

CAgnIndexedModel::DeleteTidiedEntriesL();{ReadUserData}

CAgnIndexedModel::DoTidyByDateStepL();{ReadUserData}

CAgnIndexedModel::DoTidyByTodoListStepL();{ReadUserData}

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

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

CAgnIndexedModel::TidyByDateCompleted(TInt);{}

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

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

CAgnModel::AddEntryL(CAgnEntry *,TAgnEntryId);{}

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

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

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

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

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

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

CAgnModel::DeleteTodoListL(TAgnTodoListId);{ReadUserData}

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

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

CCalCategoryManager::AddCategoryL(const CCalCategory &);{}

CCalDataExchange::ImportL(TUid,RReadStream &,RPointerArray< CCalEntry > &);{}

CCalDataExchange::ImportL(TUid,RReadStream &,RPointerArray< CCalEntry > &,TInt);{}

CCalEntryView::DeleteL(const CCalEntry &);{}

CCalEntryView::DeleteL(const CDesC8Array &);{}

CCalEntryView::StoreL(const RPointerArray< CCalEntry > &,TInt &);{}

CCalEntryView::UpdateL(const RPointerArray< CCalEntry > &,TInt &);{}

CCalInstanceView::DeleteL(CCalInstance *,CalCommon::TRecurrenceRange);{}

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

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

CContactDatabase::CheckAndUpdatePhoneTableL();{}

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

CContactDatabase::CreateL(TThreadAccess);{}

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

CContactDatabase::DatabaseBeginL(TBool);{}

CContactDatabase::DatabaseCommitL(TBool);{}

CContactDatabase::DatabaseRollback();{}

CContactDatabase::DeleteContactL(TContactItemId);{ReadUserData}

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

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

CContactDatabase::DeleteDefaultFileL();{}

CContactDatabase::LockRecordLC(TContactItemId);{}

CContactDatabase::OpenContactL(TContactItemId);{}

CContactDatabase::OpenContactL(TContactItemId,const CContactItemViewDef &);{}

CContactDatabase::OpenContactLX(TContactItemId);{}

CContactDatabase::OpenContactLX(TContactItemId,const CContactItemViewDef &);{}

CContactDatabase::RecoverL();{}

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

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

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

CContactDatabase::ReplaceL(TThreadAccess);{}

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

CContactDatabase::ResetServerSpeedDialsL();{}

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

CContactDatabase::SetCurrentItem(const TContactItemId);{}

CContactDatabase::SetDatabaseDriveL(TDriveUnit,TBool);{}

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

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

CContactDatabase::UpdateExistingContactL(CContactItem &);{}

CContactDatabase::doAddNewContactL(CContactItem &,TBool,TBool);{}

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

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

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

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

CFaxTransfer::AddSourceL(const TFileName &,TFaxPreferredCompression);{}

CFaxTransfer::AddSourceL(const TFileName &,TInt,TFaxPreferredCompression);{}

CFaxTransfer::AddSourceL(const TFileName &,TInt,TInt,TFaxPreferredCompression);{}

CFaxTransfer::RemoveAllSources();{}

CFaxTransfer::SetPhoneNumberL(TDesC8 &);{}

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

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

CFaxTransferSource::AddSourceL(const TFileName &,TFaxPreferredCompression);{}

CFaxTransferSource::AddSourceL(const TFileName &,TInt,TFaxPreferredCompression);{}

CFaxTransferSource::AddSourceL(const TFileName &,TInt,TInt,TFaxPreferredCompression);{}

CFaxTransferSource::RemoveAllSources();{}

CSmsEventLogger::AddEvent(TRequestStatus &,const CSmsMessage &,const TLogSmsPduData &,TInt *);{}

CSmsEventLogger::ChangeEvent(TRequestStatus &,const CSmsMessage &,const TLogSmsPduData &,TInt *);{}

CSmsEventLogger::DeleteEvent(TRequestStatus &);{}

CSmsHeader::ExternalizeL(RMsvWriteStream &)const;{}

CSmsHeader::StoreL(CMsvStore &)const;{}

CUnifiedCertStore::Remove(const CCTCertInfo &,TRequestStatus &);{WriteDeviceData}

CUnifiedKeyStore::CreateKey(TInt,TKeyUsagePKCS15,TUint,const TDesC &,CCTKeyInfo::EKeyAlgorithm,TInt,TTime,TTime,CCTKeyInfo *&,TRequestStatus &);{}

CUnifiedKeyStore::DeleteKey(TCTTokenObjectHandle,TRequestStatus &);{}

CUnifiedKeyStore::ImportKey(TInt,const TDesC8 &,TKeyUsagePKCS15,const TDesC &,TInt,TTime,TTime,CCTKeyInfo *&,TRequestStatus &);{}

CUnifiedKeyStore::SetManagementPolicy(TCTTokenObjectHandle,const TSecurityPolicy &,TRequestStatus &);{}

CUnifiedKeyStore::SetPassphraseTimeout(TInt,TRequestStatus &);{}

CUnifiedKeyStore::SetUsePolicy(TCTTokenObjectHandle,const TSecurityPolicy &,TRequestStatus &);{}

MCTKeyStoreManager::CreateKey(CCTKeyInfo *&,TRequestStatus &)=0;{}

MCTKeyStoreManager::ImportEncryptedKey(const TDesC8 &,CCTKeyInfo *&,TRequestStatus &)=0;{}

MCTKeyStoreManager::ImportKey(const TDesC8 &,CCTKeyInfo *&,TRequestStatus &)=0;{}

MCTWritableCertStore::Add(const TDesC &,TCertificateFormat,TCertificateOwnerType,const TKeyIdentifier *,const TKeyIdentifier *,const TDesC8 &,TRequestStatus &)=0;{WriteDeviceData}

MCTWritableCertStore::Add(const TDesC &,TCertificateFormat,TCertificateOwnerType,const TKeyIdentifier *,const TKeyIdentifier *,const TDesC8 &,const TBool,TRequestStatus &);{WriteDeviceData}

MCTWritableCertStore::Remove(const CCTCertInfo &,TRequestStatus &)=0;{WriteDeviceData}

RAgendaServ::AddCategoryToListL(const TDesC &);{}

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

RAgendaServ::AddTodoListL(CAgnTodoList *,TInt);{}

RAgendaServ::ChangeTodoListOrderL(TInt,TInt);{}

RAgendaServ::CloseWriteStreamL();{}

RAgendaServ::CreateNewStreamL(TUid);{}

RAgendaServ::DecEntryRefCountL(const TAgnUniqueId);{}

RAgendaServ::DecEntryRefCountsL(const CArrayFix< TAgnUniqueId > &);{}

RAgendaServ::DeleteEntry(TAgnUniqueId);{}

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

RAgendaServ::DeleteNotesTextL(TStreamId);{}

RAgendaServ::DeleteTodoList(TAgnUniqueId);{}

RAgendaServ::DeleteTodoListL(CAgnTodoList *);{}

RAgendaServ::IncEntryRefCountL(const TAgnUniqueId);{}

RAgendaServ::IncEntryRefCountsL(const CArrayFix< TAgnUniqueId > &);{}

RAgendaServ::QueueNextAlarmL(const TTime &,CArrayFixFlat< TAgnSortInstance > *,CAgnSortEntryAllocator *);{}

RAgendaServ::SaveTodoListsL(TFileName);{}

RAgendaServ::SetDefaultDisplayTimes(TTimeIntervalMinutes,TTimeIntervalMinutes,TTimeIntervalMinutes);{}

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

RAgendaServ::StoreNotesTextL(const TDesC &);{}

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

RAgendaServ::UpdateNotesTextL(const TDesC &,TStreamId);{}

RAgendaServ::UpdateTodoListL(CAgnTodoList *);{}

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

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

RMobileBroadcastMessaging::SetLanguageFilter(TRequestStatus &,const TDesC16 &)const;{}

RMobileBroadcastMessaging::StoreBroadcastIdListL(TRequestStatus &,CMobilePhoneBroadcastIdList *,TMobileBroadcastIdType);{}

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

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

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

RMobileONStore::StoreAllL(TRequestStatus &,CMobilePhoneONList *)const;{}

RMobilePhoneBookStore::Write(TRequestStatus &,const TDesC8 &,TInt &)const;{}

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

RMobilePhoneStore::DeleteAll(TRequestStatus &)const;{}

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

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

RMsvServerSession::ChangeAttributesL(const CMsvEntrySelection &,TUint,TUint);{}

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

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

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

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

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

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

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

RMsvServerSession::DeleteAttachment(TMsvId,const TDesC &);{None, ReadUserData, WriteDeviceData}

RMsvServerSession::DeleteEntriesL(const CMsvEntrySelection &,TMsvOp);{None, ReadUserData, WriteDeviceData}

RMsvServerSession::DeleteEntriesL(const CMsvEntrySelection &,TMsvOp,TRequestStatus &);{None, ReadUserData, WriteDeviceData}

RMsvServerSession::DeleteFileStoreL(TMsvId);{None, ReadUserData, WriteDeviceData}

RMsvServerSession::LockStore(TMsvId);{None, ReadUserData, WriteDeviceData}

RMsvServerSession::MoveEntriesL(const CMsvEntrySelection &,TMsvId,TMsvOp);{None, ReadUserData}

RMsvServerSession::MoveEntriesL(const CMsvEntrySelection &,TMsvId,TMsvOp,TRequestStatus &);{None, ReadUserData}

RMsvServerSession::OpenAttachmentForWriteL(TMsvId,const TDesC &,RFile &);{None, ReadUserData}

RMsvServerSession::OpenTempStoreFileL(TMsvId,RFile &);{None, ReadUserData, WriteDeviceData}

RMsvServerSession::ReleaseStore(TMsvId);{None, ReadUserData, WriteDeviceData}

RMsvServerSession::RemoveEntry(TMsvId);{None, ReadUserData, WriteDeviceData}

RMsvServerSession::ReplaceFileStoreL(TMsvId);{None, ReadUserData, WriteDeviceData}

RMsvServerSession::TransferCommandL(const CMsvEntrySelection &,TInt,const TDesC8 &,TMsvOp);{ReadUserData}

RMsvServerSession::TransferCommandL(const CMsvEntrySelection &,TInt,const TDesC8 &,TMsvOp,TRequestStatus &);{ReadUserData}

RPhoneBookSession::CancelRequest(TPhonebookSyncRequestCancel,TUid);{ReadUserData}

RPhoneBookSession::DeleteContact(TRequestStatus &,TContactItemId);{}

RPhoneBookSession::DoSynchronisation(TRequestStatus &);{ReadUserData}

RPhoneBookSession::DoSynchronisation(TRequestStatus &,TUid);{ReadUserData}

RPhoneBookSession::ShutdownServer(TBool);{ReadUserData}

RPhoneBookSession::WriteContact(TRequestStatus &,CContactICCEntry &,TInt &);{}

RPhoneBookSession::WriteContact(TRequestStatus &,CContactICCEntry &,TInt &,TUid &);{}

RWorldServer::DataFileRevertToSaved();{WriteDeviceData}

RWorldServer::DataFileSave();{WriteDeviceData}

RWorldServer::ResetAllData();{WriteDeviceData}

RWorldServer::SetHome(const TWorldId &);{WriteDeviceData}

RWorldServer::SetRomDatabaseToUse(const TDesC &);{}

RWorldServer::UpdateCity(TWorldId &,const TCityData &);{WriteDeviceData}

RWorldServer::UpdateCountry(TWorldId &,const TCountryData &);{WriteDeviceData}

TAgnInstanceEditor::CreateAndStoreExceptionL(CAgnEntry *&,CAgnEntry *,TAgnEntryId);{ReadUserData}

TAgnInstanceEditor::DeleteInstanceL(CAgnEntry *,TAgnWhichInstances);{ReadUserData}

TAgnInstanceEditor::DoUpdateInstanceL(CAgnEntry *,TAgnWhichInstances,TAgnEntryId);{ReadUserData}

TAgnInstanceEditor::SplitRepeatL(CAgnEntry *&,TAgnWhichInstances,CAgnEntry *,TAgnEntryId);{ReadUserData}

TAgnInstanceEditor::UpdateInstanceL(CAgnEntry *,TAgnWhichInstances,TAgnEntryId);{ReadUserData}

Capability: Dependent

MCTDH::Agree(const CDHPublicKey &,HBufC8 *&,TRequestStatus &)=0;{} - Requires the caller to have any capabilities specified in the key use security policy.

MCTDH::PublicKey(const TInteger &,const TInteger &,CDHPublicKey *&,TRequestStatus &)=0;{} - Requires the caller to have any capabilities specified in the key use security policy.

MCTDecryptor::Decrypt(const TDesC8 &,TDes8 &,TRequestStatus &)=0;{} - Requires the caller to have any capabilities specified in the key use security policy.

MCTKeyStoreManager::DeleteKey(TCTTokenObjectHandle,TRequestStatus &)=0;{} - Requires the caller to have any capabilities specified in the key use security policy.

MCTKeyStoreManager::ExportEncryptedKey(TCTTokenObjectHandle,const CPBEncryptParms &,HBufC8 *&,TRequestStatus &)=0;{} - Requires the caller to have any capabilities specified in the key use security policy.

MCTKeyStoreManager::ExportKey(TCTTokenObjectHandle,HBufC8 *&,TRequestStatus &)=0;{} - Requires the caller to have any capabilities specified in the key use security policy.

MCTKeyStoreManager::SetManagementPolicy(TCTTokenObjectHandle,const TSecurityPolicy &,TRequestStatus &)=0;{} - Requires the caller to have any capabilities specified in the key use security policy.

MCTKeyStoreManager::SetPassphraseTimeout(TInt,TRequestStatus &)=0;{}

MCTKeyStoreManager::SetUsePolicy(TCTTokenObjectHandle,const TSecurityPolicy &,TRequestStatus &)=0;{} - Requires the caller to have any capabilities specified in the key use security policy.

MCTSigner::Sign(const TDesC8 &,Signature &,TRequestStatus &)=0;{} - Requires the caller to have any capabilities specified in the key use security policy.

MCTSigner::SignMessage(const TDesC8 &,Signature &,TRequestStatus &)=0;{} - Requires the caller to have any capabilities specified in the key use security policy.

MKeyStore::ExportPublic(const TCTTokenObjectHandle &,HBufC8 *&,TRequestStatus &)=0;{} - Requires the caller to have any capabilities specified in the key use security policy.

MKeyStore::GetKeyInfo(TCTTokenObjectHandle,CCTKeyInfo *&,TRequestStatus &)=0;{} - Requires the caller to have any capabilities specified in the key use security policy.

MKeyStore::Open(const TCTTokenObjectHandle &,MCTDH *&,TRequestStatus &)=0;{} - Requires the caller to have any capabilities specified in the key use security policy.

MKeyStore::Open(const TCTTokenObjectHandle &,MCTDecryptor *&,TRequestStatus &)=0;{} - Requires the caller to have any capabilities specified in the key use security policy.

MKeyStore::Open(const TCTTokenObjectHandle &,MDSASigner *&,TRequestStatus &)=0;{} - Requires the caller to have any capabilities specified in the key use security policy.

MKeyStore::Open(const TCTTokenObjectHandle &,MRSASigner *&,TRequestStatus &)=0;{} - Requires the caller to have any capabilities specified in the key use security policy.

RAvctp::Open(MAvctpEventNotify &,SymbianAvctp::TPid);{} - None. The SID of the process holding the RAvctp is checked if it is allowed to access aPid.

RComm::Open(RCommServ &,const TDesC &,TCommAccess);{} - Capabilities required depend on the port type specified. Bluetooth and Infrared ports: LocalServices, RS232 serial port: None .

RComm::Open(RCommServ &,const TDesC &,TCommAccess,TCommRole);{} - Capabilities required depend on the port type specified.

RComm::OpenWhenAvailable(TRequestStatus &,RCommServ &,const TDesC &);{} - Capabilities required depend on the port type specified.

RComm::OpenWhenAvailable(TRequestStatus &,RCommServ &,const TDesC &,TCommRole);{} - Capabilities required depend on the port type specified.

RFs::Entry(const TDesC &,TEntry &)const;{} - Dependent: If aName contains /sys/ then AllFiles capability is required. If aName contains /Private/ and does not match this process' SID, then AllFiles capability is required.

RSocket::Open(RSocketServ &,TUint,TUint,TUint);{} - Dependent: Capabilities required depend on the type of socket specified. TCP and UDP sockets: NetworkServices, IMCP and IP sockets: NetworkControl.

RSocket::SetOpt(TUint,TUint,const TDesC8 &);{Dependent} - Dependent: Capabilities required depend on the option specified. For options KSoInetConfigInterface, KSoInetDeleteInterface, KSoInetChangeInterface,KSoInetResetInterface, KSoInetStartInterface, KSoIpv4LinkLocal, KSoInetAddRoute, KSoInetDeleteRoute, and KSoInetChangeRoute: NetworkControl. For options KSoInetEnumRoutes, and KSoInetNextRoute: NetworkServices.

原创粉丝点击