RApaLsSession Class Reference

class RApaLsSession : public RSessionBase

A session with the application architecture server.

The server provides access to a cached list of the applications on the device.

To use this class, clients first need to connect to the server.

Then, one of GetAllApps(), GetEmbeddableApps() or GetFilteredApps() needs to be called. These functions do some initialisation of server data in preparation for returning the application list (which is owned by the server).

Then, GetNextApp() is called in a loop. The first time around, it populates the session's application list and retrieves the first application in the list. Further calls to GetNextApp() retrieve the remaining applications in the list, until RApaLsSession::ENoMoreAppsInList is returned.

The session should be closed when it is no longer needed, before it goes out of scope.

Various functions in RApaLsSession need to access the application list, and may return RApaLsSession::EAppListInvalid to indicate that the function was called before the initial population of the list is complete. If this occurs, you could try again after a short delay.

This class provides many other functions, for instance launching applications, querying application-specific information, recognising data.

Inherits from

Public Member Functions
RApaLsSession()
IMPORT_C TIntAppCount(TInt &)
IMPORT_C TIntAppForDataType(const TDataType &, TUid &)
IMPORT_C TIntAppForDocument(const TDesC &, TUid &, TDataType &)
IMPORT_C TIntAppForDocument(const RFile &, TUid &, TDataType &)
IMPORT_C TIntAppForDocumentAndService(const TDesC &, TUid, TUid &, TDataType &)
IMPORT_C TIntAppForDocumentAndService(const RFile &, TUid, TUid &, TDataType &)
IMPORT_C TIntCancelListPopulationCompleteObserver()
IMPORT_C voidCancelNotify()
IMPORT_C voidCancelRecognizeFiles()
IMPORT_C TIntConnect()
IMPORT_C TIntCreateDocument(const TDesC &, TUid, TThreadId &, TLaunchType)
IMPORT_C TIntDeleteDataMapping(const TDataType &)
IMPORT_C voidDeregisterNonNativeApplicationL(TUid)
IMPORT_C TIntEmbeddableAppCount(TInt &)
IMPORT_C voidForceCommitNonNativeApplicationsUpdatesL()
IMPORT_C TIntForceRegistration(const RPointerArray< TDesC > &)
IMPORT_C RFs *FsSession()
IMPORT_C TIntGetAcceptedConfidence(TInt &)
IMPORT_C TIntGetAllApps()
IMPORT_C TIntGetAppByDataType(const TDataType &, TUid, TUid &)
IMPORT_C TIntGetAppCapability(TDes8 &, TUid)
IMPORT_C TIntGetAppIcon(TUid, TInt, CApaMaskedBitmap &)
IMPORT_C TIntGetAppIcon(TUid, TSize, CApaMaskedBitmap &)
IMPORT_C TIntGetAppIcon(TUid, HBufC *&)
IMPORT_C TIntGetAppIconSizes(TUid, CArrayFixFlat< TSize > &)
IMPORT_C TIntGetAppInfo(TApaAppInfo &, TUid)
IMPORT_C TIntGetAppOwnedFiles(CDesCArray &, TUid)
IMPORT_C CApaAppServiceInfoArray *GetAppServiceOpaqueDataLC(TUid, TUid)
IMPORT_C voidGetAppServicesL(TUid, CArrayFixFlat< TUid > &)
IMPORT_C CApaAppServiceInfoArray *GetAppServicesLC(TUid)
IMPORT_C TIntGetAppType(TUid &, TUid)
IMPORT_C TIntGetAppViewIcon(TUid, TUid, const TSize &, CApaMaskedBitmap &)
IMPORT_C TIntGetAppViewIcon(TUid, TUid, HBufC *&)
IMPORT_C TIntGetAppViews(CApaAppViewArray &, TUid)
IMPORT_C TIntGetDefaultScreenNumber(TInt &, TUid)
IMPORT_C TIntGetEmbeddableApps()
IMPORT_C TIntGetEmbeddableApps(TInt)
IMPORT_C TIntGetFilteredApps(const TApaEmbeddabilityFilter &)
IMPORT_C TIntGetFilteredApps(const TApaEmbeddabilityFilter &, TInt)
IMPORT_C TIntGetFilteredApps(TUint, TUint)
IMPORT_C TIntGetFilteredApps(TUint, TUint, TInt)
IMPORT_C TIntGetNextApp(TApaAppInfo &)
IMPORT_C TIntGetNextApp(TApaAppInfo &, TInt)
IMPORT_C TIntGetPreferredBufSize(TInt &)
IMPORT_C TIntGetServerApps(TUid)
IMPORT_C TIntGetServerApps(TUid, TInt)
IMPORT_C CApaAppServiceInfoArray *GetServiceImplementationsLC(TUid)
IMPORT_C CApaAppServiceInfoArray *GetServiceImplementationsLC(TUid, const TDataType &)
IMPORT_C TIntGetSupportedDataTypesL(CDataTypeArray &)
IMPORT_C TIntInsertDataMapping(const TDataType &, TDataTypePriority, TUid)
IMPORT_C TIntInsertDataMapping(const TDataType &, TDataTypePriority, TUid, TUid)
IMPORT_C TIntInsertDataMappingIfHigher(const TDataType &, TDataTypePriority, TUid, TBool &)
IMPORT_C TIntIsProgram(const TDesC &, TBool &)
IMPORT_C TIntMatchesSecurityPolicy(TBool &, TUid, const TSecurityPolicy &)
IMPORT_C voidNotifyOnDataMappingChange(TRequestStatus &)
IMPORT_C TIntNumberOfOwnDefinedIcons(TUid, TInt &)
IMPORT_C voidPrepareNonNativeApplicationsUpdatesL()
IMPORT_C TIntRecognizeData(const TDesC8 &, TDataRecognitionResult &)
IMPORT_C TIntRecognizeData(const TDesC &, const TDesC8 &, TDataRecognitionResult &)
IMPORT_C TIntRecognizeFilesL(const TDesC &, CDataRecognitionResultArray &)
IMPORT_C voidRecognizeFilesL(const TDesC &, CDataRecognitionResultArray &, TRequestStatus &)
IMPORT_C TIntRecognizeFilesL(const TDesC &, const TDesC8 &, CDataRecognitionResultArray &)
IMPORT_C voidRecognizeFilesL(const TDesC &, const TDesC8 &, CDataRecognitionResultArray &, TRequestStatus &)
IMPORT_C TIntRecognizeSpecificData(const TDesC &, const TDesC8 &, const TDataType &, TBool &)
IMPORT_C TIntRecognizeSpecificData(const RFile &, const TDataType &, TBool &)
IMPORT_C voidRegisterListPopulationCompleteObserver(TRequestStatus &)
IMPORT_C voidRegisterNonNativeApplicationL(TUid, const TDriveUnit &, CApaRegistrationResourceFileWriter &, CApaLocalisableResourceFileWriter *, const RFile *)
IMPORT_C voidRegisterNonNativeApplicationTypeL(TUid, const TDesC &)
IMPORT_C TIntRollbackNonNativeApplicationsUpdates()
IMPORT_C TIntSetAcceptedConfidence(TInt)
IMPORT_C TIntSetAppShortCaption(const TDesC &, TLanguage, TUid)
IMPORT_C voidSetFsSessionL(RFs &)
IMPORT_C TIntSetMaxDataBufSize(TInt)
IMPORT_C voidSetNotify(TBool, TRequestStatus &)
IMPORT_C TIntStartApp(const CApaCommandLine &)
IMPORT_C TIntStartApp(const CApaCommandLine &, TThreadId &)
IMPORT_C TIntStartApp(const CApaCommandLine &, TThreadId &, TRequestStatus *)
IMPORT_C TIntStartDocument(const TDesC &, TThreadId &, TLaunchType)
IMPORT_C TIntStartDocument(const TDesC &, const TDataType &, TThreadId &, TLaunchType)
IMPORT_C TIntStartDocument(const TDesC &, TUid, TThreadId &, TLaunchType)
IMPORT_C TIntStartDocument(RFile &, TThreadId &, TRequestStatus *)
IMPORT_C TIntStartDocument(RFile &, const TDataType &, TThreadId &, TRequestStatus *)
IMPORT_C TIntStartDocument(RFile &, TUid, TThreadId &, TRequestStatus *)
IMPORT_C TVersionVersion()
Private Member Functions
voidCleanupOperation(TAny *)
CBufFlat *CreateRegFilesBufferL(const RPointerArray< TDesC > &)
voidDeletePointerToPointerToTAny(TAny *)
TInt DoAppForDocumentOptionallySpecifyingService(const TDesC &, TUid, TUid &, TDataType &, TInt)
voidDoGetAppIconSizesL(TUid, CArrayFixFlat< TSize > &)
voidDoGetAppOwnedFilesL(CDesCArray &, TUid)
voidDoGetAppViewsL(CApaAppViewArray &, TUid)
voidDoStartAppL(const CApaCommandLine &, TThreadId *, TRequestStatus *)
voidDoStartApplicationL(const TDesC &, const CApaCommandLine &, TThreadId &, TRequestStatus *)
voidFetchArrayL(MArrayFiller &, TUid, TInt, TInt)
voidGetMainThreadIdL(TThreadId &, const RProcess &)
TInt GetNewBufferFromFile(HBufC8 *&, const TDesC &)
TInt GetNewOpaqueData(HBufC8 *&, TInt)
CBufBase *GetServiceBufferLC(TInt, TUid, TUid)
IMPORT_C voidRApaLsSession_Reserved1()
IMPORT_C voidRApaLsSession_Reserved2()
TInt SendReceiveWithReconnect(TInt, const TIpcArgs &)
TInt StartApplicationPassingDocumentName(const TDesC &, const TDesC &, const TDesC8 *, const TDesC &, TThreadId &, TApaCommand, TRequestStatus *)
TInt StartApplicationPassingFileHandle(const TDesC &, const TDesC &, const TDesC8 *, const RFile &, TThreadId &, TRequestStatus *)
TInt TransferAndInternalizeDataL(const TDesC &, const TInt, CDataRecognitionResultArray &)
Inherited Functions
RHandleBase::Attributes()const
RHandleBase::BTraceId()const
RHandleBase::DoExtendedClose()
RHandleBase::Duplicate(const RThread &,TOwnerType)
RHandleBase::FullName()const
RHandleBase::FullName(TDes &)const
RHandleBase::Handle()const
RHandleBase::HandleInfo(THandleInfo *)
RHandleBase::Name()const
RHandleBase::NotifyDestruction(TRequestStatus &)
RHandleBase::Open(const TFindHandleBase &,TOwnerType)
RHandleBase::OpenByName(const TDesC &,TOwnerType,TInt)
RHandleBase::RHandleBase()
RHandleBase::RHandleBase(TInt)
RHandleBase::SetHandle(TInt)
RHandleBase::SetHandleNC(TInt)
RSessionBase::CreateSession(RServer2,const TVersion &)
RSessionBase::CreateSession(RServer2,const TVersion &,TInt)
RSessionBase::CreateSession(RServer2,const TVersion &,TInt,TIpcSessionType,const TSecurityPolicy *,TRequestStatus *)
RSessionBase::CreateSession(const TDesC &,const TVersion &)
RSessionBase::CreateSession(const TDesC &,const TVersion &,TInt)
RSessionBase::CreateSession(const TDesC &,const TVersion &,TInt,TIpcSessionType,const TSecurityPolicy *,TRequestStatus *)
RSessionBase::CreateSession(const TDesC &,const TVersion &,TInt,TRequestStatus *)
RSessionBase::Open(RMessagePtr2,TInt,TOwnerType)
RSessionBase::Open(RMessagePtr2,TInt,const TSecurityPolicy &,TOwnerType)
RSessionBase::Open(TInt,TOwnerType)
RSessionBase::Open(TInt,const TSecurityPolicy &,TOwnerType)
RSessionBase::Send(TInt)const
RSessionBase::Send(TInt,const TIpcArgs &)const
RSessionBase::SendReceive(TInt)const
RSessionBase::SendReceive(TInt,TRequestStatus &)const
RSessionBase::SendReceive(TInt,const TIpcArgs &)const
RSessionBase::SendReceive(TInt,const TIpcArgs &,TRequestStatus &)const
RSessionBase::SetReturnedHandle(TInt)
RSessionBase::SetReturnedHandle(TInt,RHandleBase &)
RSessionBase::SetReturnedHandle(TInt,const TSecurityPolicy &)
RSessionBase::ShareAuto()
RSessionBase::ShareProtected()
Public Member Enumerations
enumTApaLsErrorCode { ENoMoreAppsInList = 1, EAppListInvalid }
enumTLaunchType { ELaunchNewApp = 1, ESwitchFiles }
Inherited Enumerations
RHandleBase:TAttributes
RSessionBase:TAttachMode
Private Attributes
CApaLsSessionExtension *iExtension
Inherited Attributes
RHandleBase::iHandle

Constructor & Destructor Documentation

RApaLsSession()

IMPORT_CRApaLsSession()

Member Functions Documentation

AppCount(TInt &)

IMPORT_C TIntAppCount(TInt &aCount)const

Gets the total number of applications.

Control panel applications are excluded.

Parameters

TInt & aCountOn return, the total number of applications.

AppForDataType(const TDataType &, TUid &)

IMPORT_C TIntAppForDataType(const TDataType &aDataType,
TUid &aAppUid
)const

Gets the UID of an application that can handle the specified data (MIME) type.

If no application can be found, the function returns the UID of the preferred default handler. If none of the default handlers can handle the data type, then a NULL UID is returned.

Parameters

const TDataType & aDataTypeThe data (MIME) type.
TUid & aAppUidOn return, the UID of the application that can handle the data (MIME) type; this may be NULL.

AppForDocument(const TDesC &, TUid &, TDataType &)

IMPORT_C TIntAppForDocument(const TDesC &aFileName,
TUid &aAppUid,
TDataType &aDataType
)const

Gets the data (MIME) type of the data in the specified file and gets the UID of an application that can handle this type.

Parameters

const TDesC & aFileNameThe name of the file containing the data.
TUid & aAppUidOn return, the UID of the application that can handle the data (MIME) type; this may be NULL.
TDataType & aDataTypeOn return, the data (MIME) type.

AppForDocument(const RFile &, TUid &, TDataType &)

IMPORT_C TIntAppForDocument(const RFile &aFile,
TUid &aAppUid,
TDataType &aDataType
)const

Parameters

const RFile & aFile
TUid & aAppUid
TDataType & aDataType

AppForDocumentAndService(const TDesC &, TUid, TUid &, TDataType &)

IMPORT_C TIntAppForDocumentAndService(const TDesC &aFileName,
TUidaServiceUid,
TUid &aAppUid,
TDataType &aDataType
)const

Gets the data (MIME) type of the data in the specified file and gets the UID of an application that can handle this type and service.

Parameters

const TDesC & aFileNameThe name of the file containing the data.
TUid aServiceUidThe service UID
TUid & aAppUid
TDataType & aDataTypeOn return, the data (MIME) type.

AppForDocumentAndService(const RFile &, TUid, TUid &, TDataType &)

IMPORT_C TIntAppForDocumentAndService(const RFile &aFile,
TUidaServiceUid,
TUid &aAppUid,
TDataType &aDataType
)const

Parameters

const RFile & aFile
TUid aServiceUid
TUid & aAppUid
TDataType & aDataType

CancelListPopulationCompleteObserver()

IMPORT_C TIntCancelListPopulationCompleteObserver()const

CancelNotify()

IMPORT_C voidCancelNotify()

CancelRecognizeFiles()

IMPORT_C voidCancelRecognizeFiles()

CleanupOperation(TAny *)

voidCleanupOperation(TAny *aAny)[private, static]

Parameters

TAny * aAny

Connect()

IMPORT_C TIntConnect()

CreateDocument(const TDesC &, TUid, TThreadId &, TLaunchType)

IMPORT_C TIntCreateDocument(const TDesC &aDocFileName,
TUidaAppUid,
TThreadId &aThreadId,
TLaunchTypeaUnused = ELaunchNewApp
)

Parameters

const TDesC & aDocFileName
TUid aAppUid
TThreadId & aThreadId
TLaunchType aUnused = ELaunchNewApp

CreateRegFilesBufferL(const RPointerArray< TDesC > &)

CBufFlat *CreateRegFilesBufferL(const RPointerArray< TDesC > &aRegFiles)[private, static]

Parameters

const RPointerArray< TDesC > & aRegFiles

DeleteDataMapping(const TDataType &)

IMPORT_C TIntDeleteDataMapping(const TDataType &aDataType)

Parameters

const TDataType & aDataType

DeletePointerToPointerToTAny(TAny *)

voidDeletePointerToPointerToTAny(TAny *aPointerToPointerToTAny)[private, static]

Parameters

TAny * aPointerToPointerToTAny

DeregisterNonNativeApplicationL(TUid)

IMPORT_C voidDeregisterNonNativeApplicationL(TUidaApplication)

Parameters

TUid aApplication

DoAppForDocumentOptionallySpecifyingService(const TDesC &, TUid, TUid &, TDataType &, TInt)

TInt DoAppForDocumentOptionallySpecifyingService(const TDesC &aFileName,
TUidaServiceUid,
TUid &aAppUid,
TDataType &aDataType,
TIntaOpcode
)const [private]

Parameters

const TDesC & aFileName
TUid aServiceUid
TUid & aAppUid
TDataType & aDataType
TInt aOpcode

DoGetAppIconSizesL(TUid, CArrayFixFlat< TSize > &)

voidDoGetAppIconSizesL(TUidaAppUid,
CArrayFixFlat< TSize > &aArrayToFill
)const [private]

Parameters

TUid aAppUid
CArrayFixFlat< TSize > & aArrayToFill

DoGetAppOwnedFilesL(CDesCArray &, TUid)

voidDoGetAppOwnedFilesL(CDesCArray &aArrayToFill,
TUidaAppUid
)const [private]

Parameters

CDesCArray & aArrayToFill
TUid aAppUid

DoGetAppViewsL(CApaAppViewArray &, TUid)

voidDoGetAppViewsL(CApaAppViewArray &aArrayToFill,
TUidaAppUid
)const [private]

Parameters

CApaAppViewArray & aArrayToFill
TUid aAppUid

DoStartAppL(const CApaCommandLine &, TThreadId *, TRequestStatus *)

voidDoStartAppL(const CApaCommandLine &aCommandLine,
TThreadId *aThreadId,
TRequestStatus *aRequestStatusForRendezvous
)[private]

Parameters

const CApaCommandLine & aCommandLine
TThreadId * aThreadId
TRequestStatus * aRequestStatusForRendezvous

DoStartApplicationL(const TDesC &, const CApaCommandLine &, TThreadId &, TRequestStatus *)

voidDoStartApplicationL(const TDesC &aNativeExecutableName,
const CApaCommandLine &aCommandLine,
TThreadId &aThreadId,
TRequestStatus *aRequestStatusForRendezvous
)[private]

Parameters

const TDesC & aNativeExecutableName
const CApaCommandLine & aCommandLine
TThreadId & aThreadId
TRequestStatus * aRequestStatusForRendezvous

EmbeddableAppCount(TInt &)

IMPORT_C TIntEmbeddableAppCount(TInt &aCount)const

Gets the total number of embeddable applications.

Control panel applications are excluded.

Parameters

TInt & aCountOn return, the total number of embeddable applications.

FetchArrayL(MArrayFiller &, TUid, TInt, TInt)

voidFetchArrayL(MArrayFiller &aArrayFiller,
TUidaAppUid,
TIntaOpcode,
TIntaInitialBufSize
)const [private]

This method implementes a generic mechanism for retrieving data items from the AppArc server. The data items can be either TSize, TApaAppViewInfo, or TDesC (see MArrayFiller).

Parameters

MArrayFiller & aArrayFiller
TUid aAppUid
TInt aOpcode
TInt aInitialBufSize

ForceCommitNonNativeApplicationsUpdatesL()

IMPORT_C voidForceCommitNonNativeApplicationsUpdatesL()

Commits the non-native application updates. This is an asynchronous method which will not wait until the application list is updated. CApaAppListNotifier class should be used to synchronize the completion of updating the application list.

CommitNonNativeApplicationsUpdatesL CApaAppListNotifier

ForceRegistration(const RPointerArray< TDesC > &)

IMPORT_C TIntForceRegistration(const RPointerArray< TDesC > &aRegFiles)

Parameters

const RPointerArray< TDesC > & aRegFiles

FsSession()

IMPORT_C RFs *FsSession()[static]

GetAcceptedConfidence(TInt &)

IMPORT_C TIntGetAcceptedConfidence(TInt &aConfidence)const

Parameters

TInt & aConfidence

GetAllApps()

IMPORT_C TIntGetAllApps()const

Initialises the process of getting all applications in the cached list.

Control panel applications are excluded.

A call to this function is followed by subsequent and repeated calls to GetNextApp() to retrieve all applications in the cached list.

GetAppByDataType(const TDataType &, TUid, TUid &)

IMPORT_C TIntGetAppByDataType(const TDataType &aDataType,
TUidaServiceUid,
TUid &aAppUid
)const

Gets the application associated with the data type and the service uid from the datatype store.

The function will only look into the datatype store and will not use the default type associations. This is different from the AppForDataTypeAndService() function.

Parameters

const TDataType & aDataTypeThe data (MIME) type.
TUid aServiceUidThe UID of the service.
TUid & aAppUidOn return, the UID of the application that can handle the data (MIME) type; this may be NULL.

GetAppCapability(TDes8 &, TUid)

IMPORT_C TIntGetAppCapability(TDes8 &aCapabilityBuf,
TUidaAppUid
)const

Gets the capabilities of the application with the specified UID.

Parameters

TDes8 & aCapabilityBufA modifiable descriptor that, on return, contains the application's capability information. The data returned in the descriptor is mapped by the TApaAppCapability class. If no matching application is found, then the content of this descriptor is not changed.
TUid aAppUidThe application specific UID.

GetAppIcon(TUid, TInt, CApaMaskedBitmap &)

IMPORT_C TIntGetAppIcon(TUidaAppUid,
TIntaSize,
CApaMaskedBitmap &aAppBitmap
)const

gets the bitmap handles from the Server, forms these up into a CApaMaskedBitmap

Sets aAppBitmap to be the small, medium or large app icon of the app with uid aAppUid, when aSize=0, 1 or 2 respectively. Panics the caller if a different index is specified. The overload which takes a TSize should be used instead.

Parameters

TUid aAppUidThe application specific UID.
TInt aSizeThe required size of the icon.
CApaMaskedBitmap & aAppBitmapOn return, the application icon.

GetAppIcon(TUid, TSize, CApaMaskedBitmap &)

IMPORT_C TIntGetAppIcon(TUidaAppUid,
TSizeaSize,
CApaMaskedBitmap &aAppBitmap
)const

Parameters

TUid aAppUid
TSize aSize
CApaMaskedBitmap & aAppBitmap

GetAppIcon(TUid, HBufC *&)

IMPORT_C TIntGetAppIcon(TUidaAppUid,
HBufC *&aFullFileName
)const

Parameters

TUid aAppUid
HBufC *& aFullFileName

GetAppIconSizes(TUid, CArrayFixFlat< TSize > &)

IMPORT_C TIntGetAppIconSizes(TUidaAppUid,
CArrayFixFlat< TSize > &aArrayToFill
)const

Gets the available icon sizes for the application with the specified UID.

Parameters

TUid aAppUidThe application specific UID.
CArrayFixFlat< TSize > & aArrayToFillOn return, the array contains all of the available icon sizes.

GetAppInfo(TApaAppInfo &, TUid)

IMPORT_C TIntGetAppInfo(TApaAppInfo &aInfo,
TUidaAppUid
)const

Gets information about the application with the specified UID.

Parameters

TApaAppInfo & aInfoOn return, contains the application information, if an application with the specified UID is found. If no matching application is found, then this object is not changed.
TUid aAppUidThe application specific UID.

GetAppOwnedFiles(CDesCArray &, TUid)

IMPORT_C TIntGetAppOwnedFiles(CDesCArray &aAppOwnedFiles,
TUidaAppUid
)const

Gets the list of file names for which the application with the specified UID claims ownership.

The list is written to a descriptor array supplied by the caller.

Note that if the function fails due to lack of memory, the array is left in an undefined state.

Parameters

CDesCArray & aAppOwnedFilesOn return, the descriptor array contains the file names.
TUid aAppUidThe application specific UID.

GetAppServiceOpaqueDataLC(TUid, TUid)

IMPORT_C CApaAppServiceInfoArray *GetAppServiceOpaqueDataLC(TUidaAppUid,
TUidaServiceUid
)const

Parameters

TUid aAppUid
TUid aServiceUid

GetAppServicesL(TUid, CArrayFixFlat< TUid > &)

IMPORT_C voidGetAppServicesL(TUidaAppUid,
CArrayFixFlat< TUid > &aServiceUids
)const

Parameters

TUid aAppUid
CArrayFixFlat< TUid > & aServiceUids

GetAppServicesLC(TUid)

IMPORT_C CApaAppServiceInfoArray *GetAppServicesLC(TUidaAppUid)const

Gets the services implemented by the application that has the specified application UID.

The returned CApaAppServiceInfoArray object contains an array of TApaAppServiceInfo objects.

Information on each service implementation is contained in a TApaAppServiceInfo object.

TApaAppServiceInfo::Uid() returns the service UID of the service implemented by the specified application UID.

leave
KErrNotFound No matching application can be found, or a matching application does not implement any services.
leave
KErrNotSupported The specified application does not provide an application registration file.
leave
KErrNoMemory There is insufficient memory to perform the operation.
CApaAppServiceInfoArray::Array() TApaAppServiceInfo

Parameters

TUid aAppUidThe application specific UID.

GetAppType(TUid &, TUid)

IMPORT_C TIntGetAppType(TUid &aTypeUid,
TUidaAppUid
)const

Parameters

TUid & aTypeUid
TUid aAppUid

GetAppViewIcon(TUid, TUid, const TSize &, CApaMaskedBitmap &)

IMPORT_C TIntGetAppViewIcon(TUidaAppUid,
TUidaViewUid,
const TSize &aSize,
CApaMaskedBitmap &aViewBitmap
)const

Gets the icon for the specified view published by the application that has the specified UID.

The icon returned is that which is closest in size to the specified size.

Parameters

TUid aAppUidThe application specific UID.
TUid aViewUidThe UID identifying the view.
const TSize & aSizeThe requested size of the icon.
CApaMaskedBitmap & aViewBitmapOn return, the icon that is closest in size to the requested size.

GetAppViewIcon(TUid, TUid, HBufC *&)

IMPORT_C TIntGetAppViewIcon(TUidaAppUid,
TUidaViewUid,
HBufC *&aFullFileName
)const

Parameters

TUid aAppUid
TUid aViewUid
HBufC *& aFullFileName

GetAppViews(CApaAppViewArray &, TUid)

IMPORT_C TIntGetAppViews(CApaAppViewArray &aAppViews,
TUidaAppUid
)const

Gets the views published by the application that has the specified UID.

Information on each view is contained in a TApaAppViewInfo object, and this set of objects is put into the array supplied by the caller.

TApaAppViewInfo

Parameters

CApaAppViewArray & aAppViewsOn return, the array contains information on all of the views published by the specified application.
TUid aAppUidThe application specific UID.

GetDefaultScreenNumber(TInt &, TUid)

IMPORT_C TIntGetDefaultScreenNumber(TInt &aDefaultScreenNumber,
TUidaAppUid
)const

Gets the default screen-number of the application with the specified UID.

Parameters

TInt & aDefaultScreenNumberOn return, contains the default screen-number, if an application with the specified UID is found. If no matching application is found, then this object is not changed.
TUid aAppUidThe application specific UID.

GetEmbeddableApps()

IMPORT_C TIntGetEmbeddableApps()const

Initialises the process of getting all embeddable applications from the cached list.

Control panel applications are excluded.

A call to this function is followed by subsequent and repeated calls to GetNextApp() to retrieve embeddable applications in the cached list.

Only applications which specify KAppEmbeddable or KAppEmbeddableOnly in their application information file will be returned by subsequent calls to GetNextApp().

GetEmbeddableApps(TInt)

IMPORT_C TIntGetEmbeddableApps(TIntaScreenMode)const

Parameters

TInt aScreenMode

GetFilteredApps(const TApaEmbeddabilityFilter &)

IMPORT_C TIntGetFilteredApps(const TApaEmbeddabilityFilter &aFilter)const

Initialises the process of getting all applications matching aFilter in the cached list.

Control panel applications are excluded.

A call to this function is followed by subsequent and repeated calls to GetNextApp() to retrieve all applications matching aFilter in the cached list.

Parameters

const TApaEmbeddabilityFilter & aFilterDefines the filter to be applied to the cached list.

GetFilteredApps(const TApaEmbeddabilityFilter &, TInt)

IMPORT_C TIntGetFilteredApps(const TApaEmbeddabilityFilter &aFilter,
TIntaScreenMode
)const

Parameters

const TApaEmbeddabilityFilter & aFilter
TInt aScreenMode

GetFilteredApps(TUint, TUint)

IMPORT_C TIntGetFilteredApps(TUintaCapabilityAttributeMask,
TUintaCapabilityAttributeValue
)const

Parameters

TUint aCapabilityAttributeMask
TUint aCapabilityAttributeValue

GetFilteredApps(TUint, TUint, TInt)

IMPORT_C TIntGetFilteredApps(TUintaCapabilityAttributeMask,
TUintaCapabilityAttributeValue,
TIntaScreenMode
)const

Parameters

TUint aCapabilityAttributeMask
TUint aCapabilityAttributeValue
TInt aScreenMode

GetMainThreadIdL(TThreadId &, const RProcess &)

voidGetMainThreadIdL(TThreadId &aThreadId,
const RProcess &aProcess
)[private, static]

Get the ID of the process's main thread.

Parameters

TThreadId & aThreadId
const RProcess & aProcess

GetNewBufferFromFile(HBufC8 *&, const TDesC &)

TInt GetNewBufferFromFile(HBufC8 *&aBuffer,
const TDesC &aFileName
)const [private]

Parameters

HBufC8 *& aBuffer
const TDesC & aFileName

GetNewOpaqueData(HBufC8 *&, TInt)

TInt GetNewOpaqueData(HBufC8 *&aOpaqueData,
TIntaLengthOfOpaqueData
)const [private]

Allocated a new buffer for aOpaqueData containing data fetched fronm AppArc server. Returns an error code if no opaque data could be allocated or fetched.

Parameters

HBufC8 *& aOpaqueData
TInt aLengthOfOpaqueData

GetNextApp(TApaAppInfo &)

IMPORT_C TIntGetNextApp(TApaAppInfo &aInfo)const

Gets information about the next application or embeddable application from the cached list.

A sequence of calls to this function must always be preceded by a call to one of GetAllApps(), GetEmbeddableApps() or GetFilteredApps().

Parameters

TApaAppInfo & aInfoOn return, contains application information.

GetNextApp(TApaAppInfo &, TInt)

IMPORT_C TIntGetNextApp(TApaAppInfo &aInfo,
TIntaScreenMode
)const

Parameters

TApaAppInfo & aInfo
TInt aScreenMode

GetPreferredBufSize(TInt &)

IMPORT_C TIntGetPreferredBufSize(TInt &aPreferredBufSize)const

Gets the preferred number of bytes of data to read from a file for the purpose of recognizing the data type.

This should be used to determine the size of buffer to pass to the 3-parameter overload of RecognizeData() or to the 4-parameter overload of RecognizeSpecificData().

GetMaxDataBufSize()

Parameters

TInt & aPreferredBufSizeOn return, contains either the largest buffer size required by any of the currently installed data-recognizers, or the value that would be returned by GetMaxDataBufSize(), whichever is less.

GetServerApps(TUid)

IMPORT_C TIntGetServerApps(TUidaServiceUid)const

Initialises the process of getting server applications in the cached list.

Control panel applications are excluded.

A call to this function is followed by subsequent and repeated calls to GetNextApp() to retrieve server applications in the cached list.

Only applications which specify one or more services in their application information file will be returned by subsequent calls to GetNextApp().

Parameters

TUid aServiceUid

GetServerApps(TUid, TInt)

IMPORT_C TIntGetServerApps(TUidaServiceUid,
TIntaScreenMode
)const

Parameters

TUid aServiceUid
TInt aScreenMode

GetServiceBufferLC(TInt, TUid, TUid)

CBufBase *GetServiceBufferLC(TIntaOpcode,
TUidaUid1,
TUidaUid2 = KNullUid
)const [private]

Parameters

TInt aOpcode
TUid aUid1
TUid aUid2 = KNullUid

GetServiceImplementationsLC(TUid)

IMPORT_C CApaAppServiceInfoArray *GetServiceImplementationsLC(TUidaServiceUid)const

Gets the service implementations for the specified service UID.

The returned CApaAppServiceInfoArray object contains an array of TApaAppServiceInfo objects.

Information on each implementation is contained in a TApaAppServiceInfo object.

TApaAppServiceInfo::Uid() returns the UID of the application that implements the specified service UID.

leave
KErrNotFound No service implementations for the specified service UID can be found.
leave
EAppListInvalid The server's initial population of the list has not completed.
leave
KErrNoMemory There is insufficient memory to perform the operation.
CApaAppServiceInfoArray::Array() TApaAppServiceInfo

Parameters

TUid aServiceUidThe service UID.

GetServiceImplementationsLC(TUid, const TDataType &)

IMPORT_C CApaAppServiceInfoArray *GetServiceImplementationsLC(TUidaServiceUid,
const TDataType &aDataType
)const

Parameters

TUid aServiceUid
const TDataType & aDataType

GetSupportedDataTypesL(CDataTypeArray &)

IMPORT_C TIntGetSupportedDataTypesL(CDataTypeArray &aDataTypes)const

Gets a list of recognized data(MIME) types by all recognizers.

Parameters

CDataTypeArray & aDataTypesThe array of data (MIME) types.

InsertDataMapping(const TDataType &, TDataTypePriority, TUid)

IMPORT_C TIntInsertDataMapping(const TDataType &aDataType,
TDataTypePriorityaPriority,
TUidaUid
)

Changes an existing data type mapping, or adds a new one.

If the data type is not currently mapped, a new mapping is added. If the data type is mapped, its mapping is replaced.

capability
WriteDeviceData Prevent addition of data type mappings by malicious programs.

Parameters

const TDataType & aDataTypeA new or existing data type.
TDataTypePriority aPriorityThe priority with which the application handles the data type.
TUid aUidThe UID of the application to associate with the data type.

InsertDataMapping(const TDataType &, TDataTypePriority, TUid, TUid)

IMPORT_C TIntInsertDataMapping(const TDataType &aDataType,
TDataTypePriorityaPriority,
TUidaUid,
TUidaServiceUid
)

Changes an existing data type mapping, or adds a new one.

If the data type is not currently mapped, a new mapping is added. If the data type is mapped, its mapping is replaced.

capability
WriteDeviceData Prevent addition of data type mappings by malicious programs.

Parameters

const TDataType & aDataTypeA new or existing data type.
TDataTypePriority aPriorityThe priority with which the application handles the data type.
TUid aUidThe UID of the application to associate with the data type.
TUid aServiceUidThe UID of the service.

InsertDataMappingIfHigher(const TDataType &, TDataTypePriority, TUid, TBool &)

IMPORT_C TIntInsertDataMappingIfHigher(const TDataType &aDataType,
TDataTypePriorityaPriority,
TUidaUid,
TBool &aInserted
)

Changes an existing data type mapping, or adds a new one. If the data type is not currently mapped, it is added. If the data type is mapped with a priority lower than aPriority, the new mapping replaces the existing one. Otherwise, no change is made.

capability
WriteDeviceData Prevent addition of data type mappings by malicious programs.

Parameters

const TDataType & aDataTypeA new or existing data type.
TDataTypePriority aPriorityThe priority with which the application handles the data type.
TUid aUidThe UID of the application to associate with the data type.
TBool & aInsertedNon-zero if the new mapping was added or an existing mapping replaced, zero otherwise.

IsProgram(const TDesC &, TBool &)

IMPORT_C TIntIsProgram(const TDesC &aFileName,
TBool &aProgram
)const

Tests whether the file is a native executable (DLL or EXE).

Parameters

const TDesC & aFileNameThe name of the file containing the data.
TBool & aProgramOn return, true, if the file contains application code; false, otherwise.

MatchesSecurityPolicy(TBool &, TUid, const TSecurityPolicy &)

IMPORT_C TIntMatchesSecurityPolicy(TBool &aMatches,
TUidaAppUid,
const TSecurityPolicy &aSecurityPolicy
)const

Tests whether the given TSecurityPolicy matches with the application TSecurityPolicy.

TSecurityPolicy

Parameters

TBool & aMatchesOn return, contains the result. ETrue if the application TSecurityPolicy matches the given TSecurityPolicy or else EFalse
TUid aAppUidUid of the application for which the security policy has to be matched
const TSecurityPolicy & aSecurityPolicyTSecurityPolicy to test whether the application with given uid matches with its TSecurityPolicy or not.

NotifyOnDataMappingChange(TRequestStatus &)

IMPORT_C voidNotifyOnDataMappingChange(TRequestStatus &aRequestStatus)

Notification of changes in data-type mapping

This asynchronous function (whose corresponding "cancel" operation is CancelNotifyOnDataTypeMappingChange) completes when any data-type / application-UID association changes, i.e. when the default application handling a particular MIME-type changes.

CancelNotifyOnDataTypeMappingChange

Parameters

TRequestStatus & aRequestStatusAs is normal for an asynchronous operation, this object is set to something other than KRequestPending when the asynchronous operation that has been triggered by this function completes.

NumberOfOwnDefinedIcons(TUid, TInt &)

IMPORT_C TIntNumberOfOwnDefinedIcons(TUidaAppUid,
TInt &aCount
)const

Gets the number of icons defined by the app that has the specified UID

Applications that don't define icons in their application information file will return an aCount value of zero when this function is called.

Parameters

TUid aAppUidThe application specific UID
TInt & aCountOn return, contains the number of icons defined by the application

PrepareNonNativeApplicationsUpdatesL()

IMPORT_C voidPrepareNonNativeApplicationsUpdatesL()

RApaLsSession_Reserved1()

IMPORT_C voidRApaLsSession_Reserved1()[private, virtual]

RApaLsSession_Reserved2()

IMPORT_C voidRApaLsSession_Reserved2()[private, virtual]

RecognizeData(const TDesC8 &, TDataRecognitionResult &)

IMPORT_C TIntRecognizeData(const TDesC8 &aBuffer,
TDataRecognitionResult &aDataType
)const

Gets the data (MIME) type of data passed by buffer.

RApaLsSession::GetPreferredBufSize()

Parameters

const TDesC8 & aBufferA buffer containing data; Provide preferred size of buffer. If MIME type could not be recognized using this buffer, provide a buffer of larger size.
TDataRecognitionResult & aDataTypeOn return, contains the result of the attempt to recognize data.

RecognizeData(const TDesC &, const TDesC8 &, TDataRecognitionResult &)

IMPORT_C TIntRecognizeData(const TDesC &aName,
const TDesC8 &aBuffer,
TDataRecognitionResult &aDataType
)const

Parameters

const TDesC & aName
const TDesC8 & aBuffer
TDataRecognitionResult & aDataType

RecognizeFilesL(const TDesC &, CDataRecognitionResultArray &)

IMPORT_C TIntRecognizeFilesL(const TDesC &aPath,
CDataRecognitionResultArray &aResult
)const

Gets the data (MIME) type for files in a specified directory. Because this call may take a long time to complete, the asynchronous version is strongly recommended. Furthermore, it is not possible to use this synchronous function while an asynchronous request is still active.

Parameters

const TDesC & aPathA valid path. Note that the path must end with a backslash.
CDataRecognitionResultArray & aResultIf the call was successful, this parameter contains the recognition result.

RecognizeFilesL(const TDesC &, CDataRecognitionResultArray &, TRequestStatus &)

IMPORT_C voidRecognizeFilesL(const TDesC &aPath,
CDataRecognitionResultArray &aResult,
TRequestStatus &aStatus
)

Parameters

const TDesC & aPath
CDataRecognitionResultArray & aResult
TRequestStatus & aStatus

RecognizeFilesL(const TDesC &, const TDesC8 &, CDataRecognitionResultArray &)

IMPORT_C TIntRecognizeFilesL(const TDesC &aPath,
const TDesC8 &aDataType,
CDataRecognitionResultArray &aResult
)const

Parameters

const TDesC & aPath
const TDesC8 & aDataType
CDataRecognitionResultArray & aResult

RecognizeFilesL(const TDesC &, const TDesC8 &, CDataRecognitionResultArray &, TRequestStatus &)

IMPORT_C voidRecognizeFilesL(const TDesC &aPath,
const TDesC8 &aDataType,
CDataRecognitionResultArray &aResult,
TRequestStatus &aStatus
)

Parameters

const TDesC & aPath
const TDesC8 & aDataType
CDataRecognitionResultArray & aResult
TRequestStatus & aStatus

RecognizeSpecificData(const TDesC &, const TDesC8 &, const TDataType &, TBool &)

IMPORT_C TIntRecognizeSpecificData(const TDesC &aName,
const TDesC8 &aBuffer,
const TDataType &aDataType,
TBool &aResult
)const

Tests whether data taken from a named file has the specified data (MIME) type.

RApaLsSession::GetPreferredBufSize()

Parameters

const TDesC & aNameThe name of the file containing the data.
const TDesC8 & aBufferA buffer containing data taken from the specified file; Provide preferred size of buffer from beginning of the file. If MIME type could not be recognized using this buffer, provide a buffer of larger size.
const TDataType & aDataTypeThe data (MIME) type.
TBool & aResultOn return, contains the result of the test.

RecognizeSpecificData(const RFile &, const TDataType &, TBool &)

IMPORT_C TIntRecognizeSpecificData(const RFile &aFile,
const TDataType &aDataType,
TBool &aResult
)const

Parameters

const RFile & aFile
const TDataType & aDataType
TBool & aResult

RegisterListPopulationCompleteObserver(TRequestStatus &)

IMPORT_C voidRegisterListPopulationCompleteObserver(TRequestStatus &aStatus)const

Parameters

TRequestStatus & aStatus

RegisterNonNativeApplicationL(TUid, const TDriveUnit &, CApaRegistrationResourceFileWriter &, CApaLocalisableResourceFileWriter *, const RFile *)

IMPORT_C voidRegisterNonNativeApplicationL(TUidaApplicationType,
const TDriveUnit &aDrive,
CApaRegistrationResourceFileWriter &aRegistrationResourceFile,
CApaLocalisableResourceFileWriter *aLocalisableResourceFile,
const RFile *aIconFile
)

Parameters

TUid aApplicationType
const TDriveUnit & aDrive
CApaRegistrationResourceFileWriter & aRegistrationResourceFile
CApaLocalisableResourceFileWriter * aLocalisableResourceFile
const RFile * aIconFile

RegisterNonNativeApplicationTypeL(TUid, const TDesC &)

IMPORT_C voidRegisterNonNativeApplicationTypeL(TUidaApplicationType,
const TDesC &aNativeExecutable
)

Parameters

TUid aApplicationType
const TDesC & aNativeExecutable

RollbackNonNativeApplicationsUpdates()

IMPORT_C TIntRollbackNonNativeApplicationsUpdates()

Rolls back all changes made to the list of installed non-native applications since the last call to PrepareNonNativeApplicationsUpdatesL().

This function can be called even if PrepareNonNativeApplicationsUpdatesL() hasn't been called before (in which case it does nothing).

SendReceiveWithReconnect(TInt, const TIpcArgs &)

TInt SendReceiveWithReconnect(TIntaFunction,
const TIpcArgs &aIpcArgs
)const [private]

Make a call to AppArc server's aFunction, passing it aIpcArgs.

Parameters

TInt aFunction
const TIpcArgs & aIpcArgs

SetAcceptedConfidence(TInt)

IMPORT_C TIntSetAcceptedConfidence(TIntaConfidence)

Sets the confidence threshold for successful data recognition.

This is the minimum acceptable confidence level that must be reported by a data recognizer for data to be accepted as of a given type.

capability
WriteDeviceData

Parameters

TInt aConfidenceThe confidence threshold. Although this is an integer value, data recognizers use the discrete values defined by the CApaDataRecognizerType::TRecognitionConfidence enumeration.

SetAppShortCaption(const TDesC &, TLanguage, TUid)

IMPORT_C TIntSetAppShortCaption(const TDesC &aShortCaption,
TLanguageaLanguage,
TUidaAppUid
)

Sets the short caption of the application.

Overrides the short caption specified in the localizable resource file for this application. Short captions set using this API will only take effect until the next device reset.

Parameters

const TDesC & aShortCaptionThe short caption of the application. The maximum length allowed is KApaMaxAppCaption.
TLanguage aLanguageThe language corresponding to the caption. If this is ELangNone the caption is used for all languages for which a language specific short caption has not been set.
TUid aAppUidThe uid of the application.

SetFsSessionL(RFs &)

IMPORT_C voidSetFsSessionL(RFs &aFsSession)[static]

Parameters

RFs & aFsSession

SetMaxDataBufSize(TInt)

IMPORT_C TIntSetMaxDataBufSize(TIntaBufSize)

Sets the maximum size of the data that can be read from a file for the purpose of recognizing the data type.

The value is not used when the client explicitly supplies a buffer, for example in calls to RecognizeData() and RecognizeSpecificData(), but is used in the implementation of functions such as StartDocument() and CreateDocument().

Unless explicitly set, a default value of KApaAppListServMaxBuffer is used.

CreateDocument() StartDocument() RecognizeData() RecognizeSpecificData()

Parameters

TInt aBufSizeThe maximum size of data to be read.

SetNotify(TBool, TRequestStatus &)

IMPORT_C voidSetNotify(TBoolaCompleteImmediatelyIfNoScanImpendingOrInProgress,
TRequestStatus &aStatus
)

Parameters

TBool aCompleteImmediatelyIfNoScanImpendingOrInProgress
TRequestStatus & aStatus

StartApp(const CApaCommandLine &)

IMPORT_C TIntStartApp(const CApaCommandLine &aCommandLine)

Starts an application defined by the specified command line information. This is an asynchronous method which doesn't wait for the process creation to complete. To be informed of the process creation success, then appropriate overloaded method taking a TRequestStatus parameter should be used.

This is only recommended for non document based applications.

View based applications are usually started by activating a specific view using CCoeAppUi::ActivateViewL. Alternatively, using StartApp() to start a view based application will activate the application's default view.

CCoeAppUi::ActivateViewL()

Parameters

const CApaCommandLine & aCommandLineThe command line.

StartApp(const CApaCommandLine &, TThreadId &)

IMPORT_C TIntStartApp(const CApaCommandLine &aCommandLine,
TThreadId &aThreadId
)

Parameters

const CApaCommandLine & aCommandLine
TThreadId & aThreadId

StartApp(const CApaCommandLine &, TThreadId &, TRequestStatus *)

IMPORT_C TIntStartApp(const CApaCommandLine &aCommandLine,
TThreadId &aThreadId,
TRequestStatus *aRequestStatusForRendezvous
)

Parameters

const CApaCommandLine & aCommandLine
TThreadId & aThreadId
TRequestStatus * aRequestStatusForRendezvous

StartApplicationPassingDocumentName(const TDesC &, const TDesC &, const TDesC8 *, const TDesC &, TThreadId &, TApaCommand, TRequestStatus *)

TInt StartApplicationPassingDocumentName(const TDesC &aNativeExecutableName,
const TDesC &aLogicalExecutableName,
const TDesC8 *aOpaqueData,
const TDesC &aDocumentName,
TThreadId &aThreadId,
TApaCommandaCommand,
TRequestStatus *aRequestStatusForRendezvous
)[private]

Parameters

const TDesC & aNativeExecutableName
const TDesC & aLogicalExecutableName
const TDesC8 * aOpaqueData
const TDesC & aDocumentName
TThreadId & aThreadId
TApaCommand aCommand
TRequestStatus * aRequestStatusForRendezvous

StartApplicationPassingFileHandle(const TDesC &, const TDesC &, const TDesC8 *, const RFile &, TThreadId &, TRequestStatus *)

TInt StartApplicationPassingFileHandle(const TDesC &aNativeExecutableName,
const TDesC &aLogicalExecutableName,
const TDesC8 *aOpaqueData,
const RFile &aFile,
TThreadId &aThreadId,
TRequestStatus *aRequestStatusForRendezvous
)[private]

Parameters

const TDesC & aNativeExecutableName
const TDesC & aLogicalExecutableName
const TDesC8 * aOpaqueData
const RFile & aFile
TThreadId & aThreadId
TRequestStatus * aRequestStatusForRendezvous

StartDocument(const TDesC &, TThreadId &, TLaunchType)

IMPORT_C TIntStartDocument(const TDesC &aDocFileName,
TThreadId &aThreadId,
TLaunchTypeaUnused = ELaunchNewApp
)

Finds and launches an application to handle the document contained in the specified file.

Parameters

const TDesC & aDocFileNameThe document name.
TThreadId & aThreadIdOn return, the id of the main thread started.
TLaunchType aUnused = ELaunchNewApp

StartDocument(const TDesC &, const TDataType &, TThreadId &, TLaunchType)

IMPORT_C TIntStartDocument(const TDesC &aDocFileName,
const TDataType &aDataType,
TThreadId &aThreadId,
TLaunchTypeaUnused = ELaunchNewApp
)

Parameters

const TDesC & aDocFileName
const TDataType & aDataType
TThreadId & aThreadId
TLaunchType aUnused = ELaunchNewApp

StartDocument(const TDesC &, TUid, TThreadId &, TLaunchType)

IMPORT_C TIntStartDocument(const TDesC &aDocFileName,
TUidaAppUid,
TThreadId &aThreadId,
TLaunchTypeaUnused = ELaunchNewApp
)

Parameters

const TDesC & aDocFileName
TUid aAppUid
TThreadId & aThreadId
TLaunchType aUnused = ELaunchNewApp

StartDocument(RFile &, TThreadId &, TRequestStatus *)

IMPORT_C TIntStartDocument(RFile &aDocFile,
TThreadId &aThreadId,
TRequestStatus *aRequestStatusForRendezvous = NULL
)

Parameters

RFile & aDocFile
TThreadId & aThreadId
TRequestStatus * aRequestStatusForRendezvous = NULL

StartDocument(RFile &, const TDataType &, TThreadId &, TRequestStatus *)

IMPORT_C TIntStartDocument(RFile &aDocFile,
const TDataType &aDataType,
TThreadId &aThreadId,
TRequestStatus *aRequestStatusForRendezvous = NULL
)

Parameters

RFile & aDocFile
const TDataType & aDataType
TThreadId & aThreadId
TRequestStatus * aRequestStatusForRendezvous = NULL

StartDocument(RFile &, TUid, TThreadId &, TRequestStatus *)

IMPORT_C TIntStartDocument(RFile &aDocFile,
TUidaAppUid,
TThreadId &aThreadId,
TRequestStatus *aRequestStatusForRendezvous = NULL
)

Parameters

RFile & aDocFile
TUid aAppUid
TThreadId & aThreadId
TRequestStatus * aRequestStatusForRendezvous = NULL

TransferAndInternalizeDataL(const TDesC &, const TInt, CDataRecognitionResultArray &)

TInt TransferAndInternalizeDataL(const TDesC &aPath,
const TIntaRequiredBufferSize,
CDataRecognitionResultArray &aResult
)const [private]

This function transfers the data to the client-side and "fills" the CDataRecognitionResultArray object.

Parameters

const TDesC & aPath
const TInt aRequiredBufferSize
CDataRecognitionResultArray & aResult

Version()

IMPORT_C TVersionVersion()const

Gets the version of the application architecture server.

Member Enumerations Documentation

Enum TApaLsErrorCode

Enumerators

ENoMoreAppsInList = 1

A possible return value from GetNextApp(), to indicate that there are no more applications in the list.

EAppListInvalid

Indicates that an RApaLsSession member function was called before the session's application list is fully populated.

Enum TLaunchType

Defines the way an application is launched. This is no longer in use. Has no effect!

Enumerators

ELaunchNewApp = 1
ESwitchFiles

Member Data Documentation

CApaLsSessionExtension * iExtension

CApaLsSessionExtension *iExtension[private]