--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/phonesrv_plat/converged_call_provider_api/inc/mccpcallobserver.h Tue Feb 02 01:11:09 2010 +0200
@@ -0,0 +1,252 @@
+/*
+* Copyright (c) 2006 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description: CCP Call observer
+*
+*/
+
+
+#ifndef MCCPCALLOBSERVER_H
+#define MCCPCALLOBSERVER_H
+
+// INCLUDES
+#include <e32base.h>
+#include "ccpdefs.h" // error defenitions
+
+class MCCPCall;
+
+/**
+* CCP API Call observer class
+*
+* @since S60 3.2
+*/
+class MCCPCallObserver
+ {
+public:
+ /** Call states */
+ enum TCCPCallState
+ {
+ /** Indicates initial call state after call creation. Basic state. */
+ ECCPStateIdle,
+ /** Indicates that the MT call is ringing but not answered yet by the local user. Basic state.*/
+ ECCPStateRinging,
+ /** MO Call: the network notifies to the MS that the remote party is now ringing. Basic state.*/
+ ECCPStateConnecting,
+ /** Indicates that call is connected and active. Basic state.*/
+ ECCPStateConnected,
+ /** Indicates that call is disconnecting. Basic state.*/
+ ECCPStateDisconnecting,
+ /** Indicates that the call is connected but on hold. Basic state.*/
+ ECCPStateHold,
+
+ /** Call is transfering. Optional state.*/
+ ECCPStateTransferring,
+ /** MO call is being forwarded at receiver end. Optional state. */
+ ECCPStateForwarding,
+ /** Call is queued locally. Optional state. */
+ ECCPStateQueued,
+
+ /** Indicates that the local user has answered the MT call but the network has not
+ acknowledged the call connection yet. Must be sent after MCCPCall::Answer method has been completed. */
+ ECCPStateAnswering,
+
+ /** Indicates that the call is dialing. Must be sent after MCCPCall::Dial method has been completed. */
+ ECCPStateDialling,
+
+ };
+
+ /** Describes the possible call events. */
+ enum TCCPCallEvent
+ {
+ /** Call has been placed on hold as a result of a local action. */
+ ECCPLocalHold,
+ /** Call has been placed on hold by the remote connected party. */
+ ECCPRemoteHold,
+ /** Call has been resumed as a result of a local action. */
+ ECCPLocalResume,
+ /** Call has been resumed by the remote connected party. */
+ ECCPRemoteResume,
+ /** Outgoing call has been barred by the local party. */
+ ECCPLocalBarred,
+ /** Outgoing call has been barred by the remote party. */
+ ECCPRemoteBarred,
+ /** Call is waiting at the remote end. Obsolote, use supplementary service ESsCallWaiting */
+ ECCPRemoteWaiting,
+ /** Call has been terminated by the remote party. */
+ ECCPRemoteTerminated,
+ /** Call is in queue */
+ ECCPQueued,
+
+ /** VoIP specific */
+ ECCCSPEarlyMediaStarted,
+
+ /** Call is secure */
+ ECCPSecureCall,
+ /** Call is not secure */
+ ECCPNotSecureCall,
+
+ /** VoIP specific
+ User has called with address containing "SIPS:" prefix. This event notifies that
+ secure call signaling is not possible. **/
+ ECCPNotSecureSessionWithSips,
+
+ /** Call has been added to remote conference call at remote end */
+ ECCPRemoteConferenceCreate,
+
+ ////////////////////////////
+ // CS call specific events
+ ///////////////////////////
+
+ /** CS call specific event */
+ ECCPCSDataPortLoaned,
+ /** CS call specific event */
+ ECCPCSDataPortRecovered,
+
+ /** One or more of following information has been changed
+ * - Remote party name
+ * - Remote party number/address
+ * - Call parameters ( ie. service id )
+ */
+ ECCPNotifyRemotePartyInfoChange,
+
+ /** Call secure status cannot be determined */
+ ECCPSecureNotSpecified
+ };
+
+
+ /** Flags indicating all the possible call control capabilities. */
+ enum TCCPCallControlCaps
+ {
+ /** Call supports data calls. */
+ ECCPCapsData = 0x00000001,
+ /** Call supports fax calls. */
+ ECCPCapsFax = 0x00000002,
+ /** Call supports voice calls. */
+ ECCPCapsVoice = 0x00000004,
+ /** The Dial request is currently a valid action. */
+ ECCPCapsDial = 0x00000008,
+ /** The Connect request is currently a valid action. */
+ ECCPCapsConnect = 0x00000010,
+ /** The Hang Up request is currently a valid action. */
+ ECCPCapsHangUp = 0x00000020,
+ /** The Answer request is currently a valid action. */
+ ECCPCapsAnswer = 0x00000040,
+ /** The Loan Data Port request is currently a valid action. */
+ ECCPCapsLoanDataPort = 0x00000080,
+ /** The Recover Data Port request is currently a valid action. */
+ ECCPCapsRecoverDataPort= 0x00000100,
+ /** Indicates that this call can be put on hold. This implies that the call is currently
+ active and that there is no other held call. */
+ ECCPCapsHold = 0x00000200,
+ /** Indicates that this call can be resumed. This implies that the call is currently
+ on hold and that there is no other active call. */
+ ECCPCapsResume = 0x00000400,
+ /** Indicates that this call's state can be swapped to the opposite state. This
+ implies that this call is either active or held. There may be another call
+ in the opposite state and if this is the case then both calls will be simultaneously
+ swapped to their opposite state. */
+ ECCPCapsSwap = 0x00000800,
+ /** Indicates that this incoming call can be deflected to another destination.*/
+ ECCPCapsDeflect = 0x00001000,
+ /** Indicates that this call can be transferred to the remote party of another call.
+ For this capability to be set there must be one active call and one held or
+ dialing call.*/
+ ECCPCapsTransfer = 0x00002000,
+ /** Indicates that this call can be joined either to another single call to form
+ a conference call or to an existing conference call.*/
+ ECCPCapsJoin = 0x00004000,
+ /** Indicates that this call (within a conference call) can go into One to One mode.
+ This action would put the rest of the conference call on hold. */
+ ECCPCapsOneToOne = 0x00008000,
+ /** Indicates that the user can activate a CCBS request on this failed call set-up.*/
+ ECCPCapsActivateCCBS = 0x00010000,
+ /** Indicates that this call is part of an alternating call and the client can call
+ SwitchAlternatingCall() on this call in order to switch it to its other mode.*/
+ ECCPCapsSwitchAlternatingCall = 0x00020000,
+ /** Indicates that this call can use/create a new bearer. This means that multiple
+ calls (multicall) can be active at the same time using no more that 7 bearers
+ simultaneously. The other option is to swap with an active call, therefore
+ it becomes held and shares the same bearer.*/
+ ECCPCapsMulticall = 0x00040000,
+ /** Indicates that this call is an packet switched call */
+ ECCPCapsPSCall = 0x00080000,
+ /** Indicates that this call supports unattended transfer method and that this call
+ is currently active */
+ ECCPCapsUnattendedTransfer = 0x00100000,
+ /** Indicates that a conference call can be created. */
+ KCCPCapsCreate = 0x00200000
+ };
+
+
+protected:
+ /**
+ * Protects the observer being deleted through the observer interface
+ * @since S60 3.2
+ */
+ virtual inline ~MCCPCallObserver() {};
+
+public:
+ /**
+ * An error has occurred concerning a specific call.
+ * @since S60 3.2
+ * @param aError Error code.
+ * @param aCall Pointer to used ccp call, can be NULL in emergency call
+ * @return none
+ */
+ virtual void ErrorOccurred( const TCCPError aError, MCCPCall* aCall ) = 0;
+
+ /**
+ * The state of the call has changed.
+ * @since S60 3.2
+ * @param aState Call state.
+ * @param aCall Pointer to used ccp call, can be NULL in emergency call
+ * @return none
+ */
+ virtual void CallStateChanged( const MCCPCallObserver::TCCPCallState aState,
+ MCCPCall* aCall) = 0;
+
+ /**
+ * The state of the call has changed with inband tone, meaning network is playing
+ * the tone relating to the state.
+ * @since S60 3.2
+ * @param aState Call state.
+ * @param aCall Pointer to used ccp call, can be NULL in emergency call
+ * @return none
+ */
+ virtual void CallStateChangedWithInband( const MCCPCallObserver::TCCPCallState aState,
+ MCCPCall* aCall ) = 0;
+
+ /**
+ * An event has occurred concerning a specific call.
+ * @since S60 3.2
+ * @param aEvent Occurred event.
+ * @param aCall Pointer to used ccp call, can be NULL in emergency call
+ * @return none
+ */
+ virtual void CallEventOccurred( const MCCPCallObserver::TCCPCallEvent aEvent,
+ MCCPCall* aCall ) = 0;
+
+ /**
+ * Notifies changed call capabilities.
+ * @since S60 3.2
+ * @param aCapsFlags New capabilities for the call
+ * @param aCall Pointer to used ccp call, can be NULL in emergency call
+ * @return none
+ */
+ virtual void CallCapsChanged( const TUint32 aCapsFlags,
+ MCCPCall* aCall ) = 0;
+ };
+
+#endif // MCCPCALLOBSERVER_H
+
+// End of File