RThread Class Reference

Creates a Rendezvous request with the thread.

The request is an asynchronous request, and completes:

Note that a request requires memory to be allocated; if this is unavailable, then this call to Rendezvous() returns, and the asynchronous request completes immediately.

See also: RThread::Rendezvous(TInt aReason) RThread::RendezvousCancel(TRequestStatus& aStatus)

Completes all Rendezvous' with the current thread.

See also: RThread::Rendezvous(TRequestStatus& aStatus)

Cancels a previously requested Rendezvous with the thread

The request completes with the value KErrCancel (if it was still outstanding).

See also: RThread::Rendezvous(TRequestStatus& aStatus)

Signals this thread that an asynchronous request originating from this thread, is complete.

The request is associated with the specified request status object supplied by this thread.

Typically, the caller of this function is the service provider responsible for satisfying the request made by this thread.

The request is completed with the completion code passed in aReason. This value is copied into this thread's request status, *aStatus, before signalling this thread's request semaphore.

The meaning of the completion code is a matter of convention to be decided between the service provider and this thread.

In a client-server situation, completion of a request takes place in the context of the server thread, but the pointer is interpreted in the address space of the client.

It is often the case in client-server situations that the client and the server are in the same address space (i.e. the same process).

Setting the pointer to the request status to NULL is a convenience, not all servers need it.

Gets this thread's request semaphore count.

The request semaphore is created when a thread is created, and is used to support asynchronous requests.

A negative value implies that this thread is waiting for at least one asynchronous request to complete.

Signal this threads request semaphore.

This is similar to RThread::RequestComplete() except that no TRequestStatus object is modified.

May only be used to signal a thread in the same process as the callers.

Makes the thread eligible for execution.

After a thread is created, it is put into a suspended state; the thread is not eligible to run until Resume() is called.

This function must also be called to resume execution of this thread after it has been explicitly suspended by a call to Suspend().

Note that when a thread is created, it is given the priority EPriorityNormal by default. The fact that a thread is initially put into a suspended state means that the thread priority can be changed by calling the thread's SetPriority() member function before the thread is started by a call to Resume().

Return the Secure ID of the process to which the thread belongs.

If an intended use of this method is to check that the Secure ID is a given value, then the use of a TSecurityPolicy object should be considered. E.g. Instead of something like:

		RThread& thread;
		TInt error = thread.SecureId()==KRequiredSecureId ? KErrNone : KErrPermissionDenied;

this could be used;

		RThread& thread;
		static _LIT_SECURITY_POLICY_S0(mySidPolicy, KRequiredSecureId);
		TBool pass = mySidPolicy().CheckPolicy(thread);

This has the benefit that the TSecurityPolicy::CheckPolicy methods are configured by the system wide Platform Security configuration. I.e. are capable of emitting diagnostic messages when a check fails and/or the check can be forced to always pass.

See also: TSecurityPolicy::CheckPolicy(RThread aThread, const char* aDiagnostic) const _LIT_SECURITY_POLICY_S0

Sets the priority of the thread to one of the values defined by the TThreadPriority enumeration.

The resulting absolute priority of the thread depends on the value of aPriority and the priority of the owning process.

Use of the priority value EPriorityNull is restricted to Symbian OS, and any attempt to explicitly set this value causes a KERN-EXEC 14 panic to be raised.

Sets the priority of the process which owns this thread to one of the values defined by the TProcessPriority enumeration.

The priority can be set to one of the four values:

EPriorityLow

EPriorityBackground

EPriorityForeground

EPriorityHigh

The absolute priority of all threads owned by the process (and all threads owned by those threads etc.) are re-calculated.

Note:

The use of the priority values EPriorityWindowServer, EPriorityFileServer, EPriorityRealTimeServer and EPrioritySupervisor is restricted to Symbian OS, and any attempt to explicitly set any of these priority values raises a KERN-EXEC 14 panic.

DeprecatedNot allowed on threads in a different process. Replace with RProcess::SetPriority or RMessagePtr2::SetProcessPriority

Gets information about a thread's user mode stack.

See also: TThreadStackInfo

Suspends execution of this thread.

The thread is not scheduled to run until a subsequent call to Resume() is made.

Ends the thread, specifying a reason code.

This function is dangerous and should be used only in cases where the target thread cannot end itself via the normal methods of calling User::Exit() or completing its thread function. A hypothetical example might be where a thread gets 'stuck' in a third-party DLL.

The target thread gets no opportunity to execute any clean-up code, therefore incautious use of this function may lead to memory leaks.

It is functionally identical to RThread::Kill(), the only difference between the two is a legacy distinction between a 'normal' reason for exiting (use Kill) and an 'abnormal' reason (use Terminate). The choice of function is reflected in the return value of RThread::ExitType().

The thread must be in the current process otherwise a panic is raised.

If the thread is process critical or process permanent, or the thread is the last thread in the process, then the process is also terminated. If the thread is system critical or system permanent, the entire system is rebooted.

WARNING: If the target thread uses a shared heap then use of this function will cause an internal array used for thread-local storage (TLS) to be leaked. This leak is specific to ARM platforms which implement the CP15 feature and will not occur on other platforms.

See also: User::Exit() User::SetCritical() User::Critical() RThread::Kill() RThread::ExitType()

Return the Vendor ID of the process to which the thread belongs.

If an intended use of this method is to check that the Vendor ID is a given value, then the use of a TSecurityPolicy object should be considered. E.g. Instead of something like:

		RThread& thread;
		TInt error = thread.VendorId()==KRequiredVendorId ? KErrNone : KErrPermissionDenied;

this could be used;

		RThread& thread;
		static _LIT_SECURITY_POLICY_V0(myVidPolicy, KRequiredVendorId);
		TBool pass = myVidPolicy().CheckPolicy(thread);

This has the benefit that the TSecurityPolicy::CheckPolicy methods are configured by the system wide Platform Security configuration. I.e. are capable of emitting diagnostic messages when a check fails and/or the check can be forced to always pass.

See also: TSecurityPolicy::CheckPolicy(RThread aThread, const char* aDiagnostic) const _LIT_SECURITY_POLICY_V0