DialProxy Class Reference
[QtTelephonyModule]

Detailed Description

The DialProxy class provides generic dial string processing and enables the routing of dialtone and call audio.

The DialProxy implements the back-end of the DialerService. It is responsible for the processing of dial strings, dial related key events such as the handset hook, the speaker and headset button as well as the accept and hangup operations. User interface elements request dial operations via requestDial() and connect to the various signals to receive notifications related to dial requests.

A dial operation can be initiated via DialerService's dial() functions or via requestDial() which can be called by user interface elements of the Qt Extended server. This class utilizes the DialerControl class to connect to the Telephony backend. However it provides a much simpler API for the most common dial operations. If specific updates about the progress of calls are required the DialerControl should be used instead.

The various dial functions can process normal phone numbers as well as VoIP numbers/identifiers. To determine what call type is required QAbstractCallPolicyManager::handling() is used. If more than one call type is possible the CallTypeSelector dialog is shown and the user has to select the call type.

The various implementations of the QAbstractDialerScreen and QAbstractCallScreen are the most likely user interface elements that would be connected to this class. For this purpose this class provides various signals which indicate when the dialer or callscreen should be shown. This is particularly important if the dial is initiated via the dialer service rather than via the user interface (in which case the dialer screen is already shown on the screen and now it is just a matter of processing the dial string).

Most desk phones have hardware buttons which allow the user to change between a handset, the speaker or the headset. In addition to the obvious audio routing features each of these buttons may also require some interfaction with the dialer. Lifting the phone craddle should e.g. show the dialer and play dialtones for each pressed key on the hard/soft-keypad. After a certain time out (while no further digit was entered) the phone starts dialing and enables call audio. This behavior is different from a situation whereby the user requested the dialer screen to be shown (w/o lifting the handset), dials a number (which plays dial tones) and then explicitly presses the dial button to initiate the call. In this situation the phone would not automatically start the dial process until it was told to do so.

The hook gesture signals onHookGesture() and offHookGesture() help to identify whether the current dial process requires an explicit press on the dial button or not. Both signals should be connected to the dialer. When onHookGesture() is emitted the dialer should initiate the dial process as soon as no dial button has been pressed for a given time out period or until the offHookGesture() signal has been received.

This class is a Qt Extended server task and cannot be used by other Qt Extended applications.

See also DialerService, DialerControl, and CallTypeSelector.

Member Type Documentation

enum DialProxy::CallScreenTrigger
flags DialProxy::CallScreenTriggers

This enum defines the call events that should trigger the call screen to be displayed.

The CallScreenTriggers type is a typedef for QFlags<CallScreenTrigger>. It stores an OR combination of CallScreenTrigger values.

Member Function Documentation

DialProxy::DialProxy ( QObject * parent = 0 )

Creates a new DialProxy instance with the given parent.

DialProxy::~DialProxy ()

Destroys the Dialproxy instance.

void DialProxy::acceptIncoming ()   [slot]

The incoming call is accepted. If more than two calls are active a message box opens that asks the user how to proceed.

CallScreenTriggers DialProxy::callScreenTriggers () const

Returns the call screen trigger conditions.

See also setCallScreenTriggers().

void DialProxy::doShowDialer ( const QString & number )   [signal]

Emitted when the dialer should be shown. This usually happens as a result of DialerService::showDialer() service request or if a speaker, handset or headset action was performed. The dialer should be prepopulated with the given number.

bool DialProxy::hangupPressed ()   [slot]

Hangs the active call up and returns true. If no call was hangup as a result of this function call this function returns false.

void DialProxy::offHookGesture ()   [signal]

Emitted when the off hook period starts. During an off hook period the dialer immediately starts the dial process if no further digit has been entered for a given time period.

See also onHookGesture().

void DialProxy::onHookGesture ()   [signal]

Emitted when the off hook period stops. During an off hook period the dialer immediately starts the dial process if no further digit has been entered for a given time period.

See also offHookGesture().

void DialProxy::requestDial ( const QString & number, const QUniqueId & contact = QUniqueId() )   [slot]

Dials the given number which is associated to contact. If contact is default constrcuted the dialing process searches for contact details and displays the result if there is a known contact with the given number.

number can be any type of number as long as it can be interpreted by QAbstractCallPolicyManager::handling().

This function does nothing if the number is empty.

See also QAbstractCallPolicyManager.

void DialProxy::resetScreen ()   [signal]

Emitted when the last call was stopped. User interfaces connecting to this signal would usually change to the idle/home screen.

void DialProxy::setCallScreenTriggers ( CallScreenTriggers triggers )

Sets the call screen trigger conditions to triggers.

See also callScreenTriggers().

void DialProxy::showCallScreen ()   [signal]

Emitted when the dial screen should be shown to inform the user about an ongoing dial process.