phonecmdhandler/phonecmdhnlr/inc/PhoneHandlerControl.h
branchRCL_3
changeset 20 987c9837762f
parent 19 7d48bed6ce0c
equal deleted inserted replaced
19:7d48bed6ce0c 20:987c9837762f
    18 
    18 
    19 #ifndef CPHONEHANDLERCONTROL_H
    19 #ifndef CPHONEHANDLERCONTROL_H
    20 #define CPHONEHANDLERCONTROL_H
    20 #define CPHONEHANDLERCONTROL_H
    21 
    21 
    22 //  INCLUDES
    22 //  INCLUDES
    23 #include "phonehandlerservice.h" 
    23 #include "PhoneHandlerService.h"
    24 #include <RemConExtensionApi.h> 
    24 #include <RemConExtensionApi.h>
    25 #include <RemConCallHandlingTargetObserver.h> 
    25 #include <RemConCallHandlingTargetObserver.h>
    26 #include <e32base.h>
    26 #include <e32base.h>
    27 #include <phclttypes.h> 
    27 #include <PhCltTypes.h>	
    28 #include <e32property.h> 
    28 #include <e32property.h> 
       
    29 #include <ccpdefs.h>
    29 
    30 
    30 // CONSTANTS
    31 // CONSTANTS
    31 
    32 
    32 // MACROS
    33 // MACROS
    33 
    34 
    40 // CLASS DECLARATION
    41 // CLASS DECLARATION
    41 class CRemConInterfaceSelector;
    42 class CRemConInterfaceSelector;
    42 class CRemConCallHandlingTarget;
    43 class CRemConCallHandlingTarget;
    43 class CPhoneHandlerResponse;
    44 class CPhoneHandlerResponse;
    44 class CPhoneHandlerCallState;
    45 class CPhoneHandlerCallState;
       
    46 class CPhoneHandlerCallArray;
       
    47 class MCall;
    45 
    48 
    46 /**
    49 /**
    47 * Receives call handling related key presses from accessories and executes 
    50 * Receives call handling related key presses from accessories and executes 
    48 * them.
    51 * them.
    49 *
    52 *
    50 *  @lib PhoneCmdHandler
    53 *  @lib PhoneCmdHandler
    51 *  @since S60 3.1
    54 *  @since S60 3.1
    52 */
    55 */
    53 NONSHARABLE_CLASS( CPhoneHandlerControl ) : public CBase,
    56 NONSHARABLE_CLASS( CPhoneHandlerControl ) : public CBase,
    54                                             public MRemConCallHandlingTargetObserver
    57 											public MRemConCallHandlingTargetObserver
    55     {
    58 	{
    56     public:  // Constructors and destructor
    59     public:  // Constructors and destructor
    57     
    60     
    58         /**
    61         /**
    59         * Two-phased constructor.
    62         * Two-phased constructor.
    60         */
    63         */
    61         static CPhoneHandlerControl* NewL( 
    64         static CPhoneHandlerControl* NewL( 
    62             CRemConInterfaceSelector* aIfSelector = NULL );
    65         	CRemConInterfaceSelector* aIfSelector = NULL );
    63 
    66 
    64         /**
    67         /**
    65         * Destructor.
    68         * Destructor.
    66         */
    69         */
    67         virtual ~CPhoneHandlerControl();
    70         virtual ~CPhoneHandlerControl();
    68 
    71 
    69     public: // New functions
    72     public: // New functions
    70     
    73     
    71         /**
    74     	/**
    72         * Returns phone number for dial or speed dial.
    75         * Returns phone number for dial or speed dial.
    73         * @since S60 3.1
    76         * @since S60 3.1
    74         * @param void
    77         * @param void
    75         * @return TPhCltTelephoneNumber phone number
    78         * @return TPhCltTelephoneNumber phone number
    76         */
    79         */
   105         * @since S60 3.1
   108         * @since S60 3.1
   106         * @param void
   109         * @param void
   107         * @return TChar DTMF tone
   110         * @return TChar DTMF tone
   108         */
   111         */
   109         const TChar& Tone() const;
   112         const TChar& Tone() const;
   110         
   113     	
   111         /**
   114     	/**
   112         * Returns reference to API used to communicate with accessory who 
   115         * Returns reference to API used to communicate with accessory who 
   113         * initiated key press.
   116         * initiated key press.
   114         * @since S60 3.1
   117         * @since S60 3.1
   115         * @param void
   118         * @param void
   116         * @return CRemConCallHandlingTarget& reference to API
   119         * @return CRemConCallHandlingTarget& reference to API
   117         */  
   120         */	
   118         CRemConCallHandlingTarget& CommandInitiator() const;
   121 		CRemConCallHandlingTarget& CommandInitiator() const;
   119         
   122 		
   120         /**
   123 		/**
   121         * Informs the latest call state.
   124         * Informs the latest call state.
   122         * @since S60 3.1
   125         * @since S60 9.2
   123         * @param aState Call state from KTelephonyCallState P&S key
   126         * @param aCall Call from MCallInformationObserver
   124         * @return void
   127           * @return void
   125         */
   128         */
   126         void NotifyCallState( const TInt aState );
   129 		void NotifyCallStateL( const MCall* aCall );
   127 
   130 
   128         /**
   131 		/**
   129         * Get iSwitchCall flag, if this flag is ETrue, it means
   132         * Get iSwitchCall flag, if this flag is ETrue, it means
   130         * "Send" key in remote target is pressed in multiparty call,
   133         * "Send" key in remote target is pressed in multiparty call,
   131         * otherwise EFalse
   134         * otherwise EFalse
   132         * @since S60 3.1
   135         * @since S60 3.1
   133         * @return TBool
   136         * @return TBool
   134         */
   137         */
   135         TBool SwitchCall();
   138 		TBool SwitchCall();
   136 
   139 
   137                     
   140 	    	        
   138     public: // Functions from base classes
   141     public: // Functions from base classes
   139                 
   142     	        
   140     protected:  // New functions
   143     protected:  // New functions
   141         
   144         
   142     protected:  // Functions from base classes
   145     protected:  // Functions from base classes
   143     
   146     
   144     private:
   147     private:
   150 
   153 
   151         /**
   154         /**
   152         * By default Symbian 2nd phase constructor is private.
   155         * By default Symbian 2nd phase constructor is private.
   153         */
   156         */
   154         void ConstructL( CRemConInterfaceSelector* aIfSelector = NULL );
   157         void ConstructL( CRemConInterfaceSelector* aIfSelector = NULL );
   155                 
   158 				
   156         /**
   159 		/**
   157         * From MRemConCallHandlingTargetObserver. Answer an incoming phone call.
   160 		* From MRemConCallHandlingTargetObserver. Answer an incoming phone call.
   158         */
   161 		*/
   159         virtual void AnswerCall();
   162 		virtual void AnswerCall();
   160 
   163 
   161         /**
   164 		/**
   162         * From MRemConCallHandlingTargetObserver. End an incoming/ongoing 
   165 		* From MRemConCallHandlingTargetObserver. End an incoming/ongoing 
   163         * phone call.
   166 		* phone call.
   164         */
   167 		*/
   165         virtual void EndCall();
   168 		virtual void EndCall();
   166     
   169 	
   167         /**
   170 		/**
   168         * From MRemConCallHandlingTargetObserver. Answer an incoming phone call, 
   171 		* From MRemConCallHandlingTargetObserver. Answer an incoming phone call, 
   169         * or end an ongoing call according to call status. 
   172 		* or end an ongoing call according to call status. 
   170         */
   173 		*/
   171         virtual void AnswerEndCall();
   174 		virtual void AnswerEndCall();
   172         
   175 		
   173         /**
   176 		/**
   174         * From MRemConCallHandlingTargetObserver. Make a voice call.
   177 		* From MRemConCallHandlingTargetObserver. Make a voice call.
   175         */
   178 		*/
   176         virtual void VoiceDial( const TBool aActivate );
   179 		virtual void VoiceDial( const TBool aActivate );
   177     
   180 	
   178         /**
   181 		/**
   179         * From MRemConCallHandlingTargetObserver. Redial last phone call.
   182 		* From MRemConCallHandlingTargetObserver. Redial last phone call.
   180         */
   183 		*/
   181         virtual void LastNumberRedial();
   184 		virtual void LastNumberRedial();
   182     
   185 	
   183         /**
   186 		/**
   184         * From MRemConCallHandlingTargetObserver. Dial a phone call.
   187 		* From MRemConCallHandlingTargetObserver. Dial a phone call.
   185         */
   188 		*/
   186         virtual void DialCall( const TDesC8& aTelNumber );
   189 		virtual void DialCall( const TDesC8& aTelNumber );
   187     
   190 	
   188         /**
   191 		/**
   189         * From MRemConCallHandlingTargetObserver. Make multiparty call.
   192 		* From MRemConCallHandlingTargetObserver. Make multiparty call.
   190         */
   193 		*/
   191         virtual void MultipartyCalling( const TDesC8& aData );
   194 		virtual void MultipartyCalling( const TDesC8& aData );
   192     
   195 	
   193         /**
   196 		/**
   194         * Generates DTMF signal.
   197 		* Generates DTMF signal.
   195         */
   198 		*/
   196         virtual void GenerateDTMF( const TChar aChar );
   199 		virtual void GenerateDTMF( const TChar aChar );
   197     
   200 	
   198         /**
   201 		/**
   199         * From MRemConCallHandlingTargetObserver. Make a speed dial call.
   202 		* From MRemConCallHandlingTargetObserver. Make a speed dial call.
   200         */
   203 		*/
   201         virtual void SpeedDial( const TInt aIndex );
   204 		virtual void SpeedDial( const TInt aIndex );
   202         
   205 		
   203         /**
   206 		/**
   204         * Starts processing service corresponding to key press.
   207 		* Starts processing service corresponding to key press.
   205         */
   208 		*/
   206         void StartProcessing( 
   209 		void StartProcessing( 
   207             const TRemConExtCallHandlingApiOperationId aOperation );
   210 			const TRemConExtCallHandlingApiOperationId aOperation );
   208         
   211 		
   209         /**
   212 		/**
   210         * Creates service.
   213 		* Creates service.
   211         */
   214 		*/
   212         MPhoneHandlerService* CreateServiceL( 
   215 		MPhoneHandlerService* CreateServiceL( 
   213             const TRemConExtCallHandlingApiOperationId aOperation );
   216 			const TRemConExtCallHandlingApiOperationId aOperation );
   214         
   217 		
   215         /**
   218 		/**
   216         * Returns call status.
   219 		* Initializes speed dial.
   217         */
   220 		*/
   218         void CallStatusL( RPhone::TLineInfo& aLineInfo );
   221 		void InitializeSpeedDialL();
   219         
   222 		
   220                 
   223 		/**
       
   224 		* Returns call status.
       
   225 		*/
       
   226 		void CallStatusL( RPhone::TLineInfo& aLineInfo );
       
   227 		
       
   228 		/**
       
   229         * Returns autolock status
       
   230         */
       
   231 		TBool IsAutoLockOn() const;
       
   232 		
       
   233 		/**
       
   234         * Returns BT accessory command status
       
   235         */
       
   236 		TBool IsBTAccessoryCmd() const;
       
   237 		
   221     private:    // Data
   238     private:    // Data
   222         
   239         
   223         // Provides e.g. service to listen accessory key presses.
   240         // Provides e.g. service to listen accessory key presses.
   224         CRemConInterfaceSelector* iInterfaceSelector;   // owned
   241         CRemConInterfaceSelector* iInterfaceSelector;	// owned
   225         
   242         
   226         //  API notifying PhoneCmdHandler about call handling key presses.
   243         //  API notifying PhoneCmdHandler about call handling key presses.
   227         CRemConCallHandlingTarget* iTarget; // owned
   244         CRemConCallHandlingTarget* iTarget;	// owned
   228                 
   245                 
   229         // Phone number for dial call/speed dial.
   246         // Phone number for dial call/speed dial.
   230         TPhCltTelephoneNumber iTelNumber;
   247         TPhCltTelephoneNumber iTelNumber;
   231         
   248         
   232         // Voice recognition status
   249         // Voice recognition status
   251         RProperty iProperty;
   268         RProperty iProperty;
   252         
   269         
   253         // Previous call state
   270         // Previous call state
   254         TInt iPrevState;
   271         TInt iPrevState;
   255         
   272         
   256         // Number of active calls
       
   257         // Used to determine whether there's a multicall case when call state
       
   258         TInt iActiveCalls;
       
   259         
       
   260         // switch phonecall by press "Send" key
   273         // switch phonecall by press "Send" key
   261         TBool iSwitchCall;
   274         TBool iSwitchCall;
   262         
   275         
   263         // Listens to phone call state changes.
   276         // Listens to phone call state changes.
   264         CPhoneHandlerCallState* iCallStateObserver;
   277         CPhoneHandlerCallState* iCallStateObserver;
   265         
   278         
       
   279         CPhoneHandlerCallArray* iCallArray;
   266                     
   280                     
   267     public:     // Friend classes
   281     public:     // Friend classes
   268     
   282     
   269     protected:  // Friend classes
   283     protected:  // Friend classes
   270     
   284