Nokia N97 SDK
Example Applications Guide

IsvTelCallAppDlg.cpp

00001 /*        
00002 * ============================================================================  
00003 *  Name        : IsvTelCallAppDlg.cpp
00004 *  Part of     : IsvTelCallApp
00005 *  Interface   : 
00006 *  Description : Functions of the CIsvTelCallAppDlg class
00007 *  Version     : 
00008 *
00009 *  Copyright (c) 2005-2006 Nokia Corporation.
00010 *  This material, including documentation and any related 
00011 *  computer programs, is protected by copyright controlled by 
00012 *  Nokia Corporation.
00013 * ==============================================================================
00014 */
00015 
00016 // INCLUDE FILES    
00017 #include <eikmenub.h>
00018 #include <eikcapc.h>
00019 #include <avkon.hrh>
00020 #include <avkon.rsg>
00021 #include <aknnotewrappers.h>
00022 #include <akntitle.h>
00023 #include <etel3rdparty.h> 
00024 #include <IsvTelCallApp.rsg>
00025 #include "IsvTelCallAppContainer.h"
00026 #include "IsvTelCallAppTelephonyNotify.h"
00027 #include "IsvTelCallAppTelephony.h"
00028 #include "IsvTelCallAppDlg.h"
00029 #include "IsvTelCallAppUi.h"
00030 #include <EikEdwin.h>
00031 
00032 // ================= MEMBER FUNCTIONS =========================================
00033 
00034 // ----------------------------------------------------------------------------
00035 // CIsvTelCallAppDlg::NewL()
00036 // Two-phased constructor.
00037 // ----------------------------------------------------------------------------
00038 //
00039 CIsvTelCallAppDlg* CIsvTelCallAppDlg::NewL()
00040     {
00041     CIsvTelCallAppDlg* self = 
00042         new (ELeave) CIsvTelCallAppDlg();
00043     CleanupStack::PushL(self);
00044     self->ConstructL();
00045     CleanupStack::Pop();
00046     return self;
00047     }
00048 
00049 // ----------------------------------------------------------------------------
00050 // CIsvTelCallAppDlg::~CIsvTelCallAppDlg()
00051 // Destructor.
00052 // ----------------------------------------------------------------------------
00053 //
00054 CIsvTelCallAppDlg::~CIsvTelCallAppDlg()
00055     {
00056 
00057         SetMainPageTitleOnPaneL();
00058 
00059         if (iVoiceLineAsyncTelephony)
00060         {
00061         delete(iVoiceLineAsyncTelephony);
00062         }
00063         if (iCall1StatusAsyncTelephony)
00064         {
00065         delete(iCall1StatusAsyncTelephony);
00066         }
00067         if (iCall2StatusAsyncTelephony)
00068         {
00069         delete(iCall2StatusAsyncTelephony);
00070         }
00071         if (iAnswerInCallTelephony)
00072         {
00073         delete(iAnswerInCallTelephony);
00074         }
00075     
00076     //Delete the CTelephony object
00077     if ( iTelephony->GetTelephonyPtr() )
00078         {
00079         delete ( iTelephony->GetTelephonyPtr() );
00080         }        
00081     
00082     //Delete the telephony pointer
00083     if ( iTelephony )
00084         {
00085         delete iTelephony;
00086         }
00087     }
00088 
00089 // ----------------------------------------------------------------------------
00090 // CIsvTelCallAppDlg::ExecuteLD( TInt aResourceId )
00091 // Over-riding function from base-class. It sets the page title for the first
00092 // page and then invokes the base-class function.
00093 // ----------------------------------------------------------------------------
00094 //
00095 TInt CIsvTelCallAppDlg::ExecuteLD( TInt aResourceId )
00096     {
00097 
00098     TInt retCode;
00099 
00100     //Set page title for first page
00101     SetPageTitleOnPaneL(iPageId);
00102       
00103     //Call the base-class routine
00104     retCode = CAknForm::ExecuteLD( aResourceId );
00105 
00106     TryChangeFocusToL(EIsvTelCallAppDlgCtrlIdPhone1);
00107 
00108     return( retCode );
00109     }
00110 
00111 // ----------------------------------------------------------------------------
00112 // CIsvTelCallAppDlg::OfferKeyEventL()
00113 // An over-riding routine that captures the Green dial key and the Red hang-up
00114 // key from the key-pad when they are pressed with the focus being present 
00115 // on the Phone-numbers in the dialog screen.
00116 // For other keys, it calls the base-class routine for handling.
00117 // ----------------------------------------------------------------------------
00118 //
00119 TKeyResponse CIsvTelCallAppDlg::OfferKeyEventL(
00120     const TKeyEvent& aKeyEvent,
00121     TEventCode aType)
00122     {
00123     if (aType == EEventKey)
00124         {
00125         //Catch the dial button
00126         switch (aKeyEvent.iCode)
00127             {
00128             case EKeyYes:
00129                 {
00130                 TInt focusControlId = IdOfFocusControl();
00131                 switch (focusControlId)
00132                     {
00133                     case EIsvTelCallAppDlgCtrlIdPhone1:
00134                     case EIsvTelCallAppDlgCtrlIdPhone2:
00135                                 {
00136                         ProcessCommandL(EIsvTelCallAppCmdAPITestCall);
00137                         return EKeyWasConsumed; 
00138                         }
00139                     default:
00140                         break;
00141                     }
00142                 }
00143                 break;
00144             case EKeyNo:
00145                 {
00146                 TInt focusControlId = IdOfFocusControl();
00147                 switch (focusControlId)
00148                     {
00149                     case EIsvTelCallAppDlgCtrlIdPhone1:
00150                     case EIsvTelCallAppDlgCtrlIdPhone2:
00151                         {
00152                                                 ProcessCommandL(EIsvTelCallAppCmdAPITestHangup);
00153                         return EKeyWasConsumed;                         
00154                         }
00155                     default:
00156                         break;
00157                     }
00158                 }
00159                 break;
00160             case EKeyUpArrow:
00161             case EKeyDownArrow:
00162                 {
00163                 if( iIsInEditMode )
00164                     {
00165                     return EKeyWasConsumed;
00166                     }
00167                 }
00168                 break;
00169             case EKeyOK:
00170                 {
00171                 if(iIsInEditMode)
00172                     {
00173                     ProcessCommandL(EAknFormCmdSave);
00174                     }
00175                 else
00176                     {
00177                     ProcessCommandL(EAknFormCmdEdit);
00178                     }
00179                 return EKeyWasConsumed;
00180                 }
00181             default:
00182                 break;
00183             }
00184         }
00185     return CAknForm::OfferKeyEventL(aKeyEvent, aType);
00186     }
00187 
00188 // ----------------------------------------------------------------------------
00189 // CIsvTelCallAppDlg::DynInitMenuPaneL()
00190 // Different controls/dialog items/pages on the multi-page dialog require their
00191 // own context sensitive menus to be able to choose only the applicable
00192 // operations on the item. For this purpose, this function, loads menu panes
00193 // that are appropriate and applicable for the respective menu items.
00194 // ----------------------------------------------------------------------------
00195 //
00196 void CIsvTelCallAppDlg::DynInitMenuPaneL(
00197     TInt aResourceId,
00198     CEikMenuPane* aMenuPane )
00199     {
00200 
00201     TInt pageId = ActivePageId();
00202     TInt focusControlId = IdOfFocusControl();
00203 
00204     if (aResourceId == R_AVKON_FORM_MENUPANE)  
00205         {
00206         switch (pageId)
00207             {
00208             case EIsvTelCallAppPageCtrlIdPagePhone1:
00209                 {
00210                 //Phone Menu
00211                 switch (focusControlId)    
00212                     {
00213                     case EIsvTelCallAppDlgCtrlIdPhone1:
00214                         {
00215                                                 //Menu for Phone-1 and Phone-2 numbers
00216                                                 aMenuPane->AddMenuItemsL(R_PHONE_MENU_PANE,0,1);
00217                         aMenuPane->SetItemDimmed(EAknFormCmdAdd,TRUE);
00218                         aMenuPane->SetItemDimmed(EAknFormCmdLabel,TRUE);
00219                         aMenuPane->SetItemDimmed(EAknFormCmdDelete,TRUE);
00220                         break;
00221                         }
00222                     case EIsvTelCallAppDlgCtrlIdDtmfSeq1:
00223                         {
00224                                                 //Menu for DTMF sequence
00225                         aMenuPane->SetItemDimmed(EAknFormCmdAdd,TRUE);
00226                         aMenuPane->SetItemDimmed(EAknFormCmdLabel,TRUE);
00227                         aMenuPane->SetItemDimmed(EAknFormCmdDelete,TRUE);
00228                         break;                          
00229                         }
00230                     case EIsvTelCallAppDlgCtrlIdCall1Status:
00231                         {
00232                                                 aMenuPane->AddMenuItemsL(
00233                                     R_GENERAL_STATUS_MENU_PANE,0,1);
00234                         aMenuPane->SetItemDimmed(EAknFormCmdEdit,TRUE);
00235                         aMenuPane->SetItemDimmed(EAknFormCmdSave,TRUE);
00236                         aMenuPane->SetItemDimmed(EAknFormCmdAdd,TRUE);
00237                         aMenuPane->SetItemDimmed(EAknFormCmdLabel,TRUE);
00238                         aMenuPane->SetItemDimmed(EAknFormCmdDelete,TRUE);
00239                         }
00240                     default:
00241                         break;
00242                     }
00243                 }
00244                 break;
00245             case EIsvTelCallAppPageCtrlIdPagePhone2:
00246                 {
00247                 //Phone Menu
00248                 switch (focusControlId)    
00249                     {
00250                     case EIsvTelCallAppDlgCtrlIdPhone2:
00251                         {
00252                         //Menu for Phone-1 and Phone-2 numbers
00253                         aMenuPane->AddMenuItemsL(R_PHONE_MENU_PANE,0,1);
00254                         aMenuPane->SetItemDimmed(EAknFormCmdAdd,TRUE);
00255                         aMenuPane->SetItemDimmed(EAknFormCmdLabel,TRUE);
00256                         aMenuPane->SetItemDimmed(EAknFormCmdDelete,TRUE);
00257                         break;
00258                         }
00259                     case EIsvTelCallAppDlgCtrlIdDtmfSeq2:
00260                         {
00261                         //Menu for DTMF sequence
00262                         aMenuPane->SetItemDimmed(EAknFormCmdAdd,TRUE);
00263                         aMenuPane->SetItemDimmed(EAknFormCmdLabel,TRUE);
00264                         aMenuPane->SetItemDimmed(EAknFormCmdDelete,TRUE);
00265                         break;
00266                             }
00267                     case EIsvTelCallAppDlgCtrlIdCall2Status:
00268                             {
00269                         aMenuPane->AddMenuItemsL(
00270                                     R_GENERAL_STATUS_MENU_PANE,0,1);
00271                         aMenuPane->SetItemDimmed(EAknFormCmdEdit,TRUE);
00272                         aMenuPane->SetItemDimmed(EAknFormCmdSave,TRUE);
00273                         aMenuPane->SetItemDimmed(EAknFormCmdAdd,TRUE);
00274                         aMenuPane->SetItemDimmed(EAknFormCmdLabel,TRUE);
00275                         aMenuPane->SetItemDimmed(EAknFormCmdDelete,TRUE);
00276                         }
00277                     default:
00278                         break;
00279                     }
00280                 }
00281                 break;
00282             case EIsvTelCallAppPageCtrlIdPageCallLineStatus:
00283                 {
00284                 aMenuPane->AddMenuItemsL(
00285                             R_GENERAL_STATUS_MENU_PANE,0,1);
00286                 aMenuPane->SetItemDimmed(EAknFormCmdEdit,TRUE);
00287                 aMenuPane->SetItemDimmed(EAknFormCmdSave,TRUE);
00288                 aMenuPane->SetItemDimmed(EAknFormCmdAdd,TRUE);
00289                 aMenuPane->SetItemDimmed(EAknFormCmdLabel,TRUE);
00290                 aMenuPane->SetItemDimmed(EAknFormCmdDelete,TRUE);
00291                 break;
00292                 }
00293             default:
00294                 break;
00295             }
00296         }
00297     else
00298         {
00299         CAknForm::DynInitMenuPaneL(aResourceId, aMenuPane);
00300         }    
00301     }
00302 
00303 // ----------------------------------------------------------------------------
00304 // CIsvTelCallAppDlg::ProcessCommandL()
00305 // An over-riding function that handles all commands loaded by the
00306 // DynInitMenuPaneL. For the remaining commands like Edit & Save, it invokes 
00307 // the base class routine.
00308 // ----------------------------------------------------------------------------
00309 //
00310 void CIsvTelCallAppDlg::ProcessCommandL( TInt aCommandId )
00311     {
00312     
00313     switch (aCommandId)
00314         {
00315         ////////////////////////////////////////////////////////////////////
00316         case EIsvTelCallAppCmdAPITestCall:
00317             {
00318             TInt afocusControlId = IdOfFocusControl();
00319             MakeNewCallProcessCommandL(afocusControlId);
00320             }
00321             break;
00322             
00323         ////////////////////////////////////////////////////////////////////
00324         case EIsvTelCallAppCmdAPITestHangup:
00325             {
00326             //Branch to the appropriate page and control
00327             TInt pageId = ActivePageId();
00328             HangupProcessCommandL(pageId);
00329             }
00330             break;
00331     
00332         ////////////////////////////////////////////////////////////////////
00333         case EIsvTelCallAppCmdAPITestHold:
00334             {
00335             //Branch to the appropriate page and control
00336             TInt pageId = ActivePageId();
00337             HoldProcessCommandL(pageId);
00338             }
00339             break;
00340             
00341         ////////////////////////////////////////////////////////////////////
00342         case EIsvTelCallAppCmdAPITestResume:
00343             {
00344             //Branch to the appropriate page and control
00345             TInt pageId = ActivePageId();
00346             ResumeProcessCommandL(pageId);
00347             }
00348             break;
00349                     
00350         ////////////////////////////////////////////////////////////////////
00351         case EIsvTelCallAppCmdAPITestSwap:
00352             {
00353             SwapProcessCommamndL();
00354             }
00355             break;
00356                 
00357         ////////////////////////////////////////////////////////////////////
00358         case EIsvTelCallAppCmdAPITestFetch:
00359             {
00360             //Branch to the appropriate page and control
00361             TInt pageId = ActivePageId();
00362             switch (pageId)
00363                 {
00364                 /////////////////////////////////////////////////////////////
00365                 case EIsvTelCallAppPageCtrlIdPagePhone1:
00366                         {
00367                         //Fetch information for call status control.  
00368                     //This helps user to stay updated
00369                     //all the time. These are synchronous calls
00370                     GetCallStatusL(CTelephony::EISVCall1);
00371                         }
00372                     break;
00373 
00374                 /////////////////////////////////////////////////////////////
00375                 case EIsvTelCallAppPageCtrlIdPagePhone2:
00376                         {
00377                         //Fetch information for call status control.  
00378                     //This helps user to stay updated
00379                     //all the time. These are synchronous calls
00380                     GetCallStatusL(CTelephony::EISVCall2);
00381                         }
00382                     break;
00383                         /////////////////////////////////////////////////////////////   
00384                         case EIsvTelCallAppPageCtrlIdPageCallLineStatus:
00385                         {
00386                         //Fetch EIsvTelCallAppDlgCtrlIdVoiceLineStatus:
00387                         iTelephony->TelApiWrapperGetVoiceLineStatusL( );
00388      
00389                         //Fetch EIsvTelCallAppDlgCtrlIdDataLineStatus:
00390                         iTelephony->TelApiWrapperGetDataLineStatusL( );
00391                                                                 
00392                         //Fetch EIsvTelCallAppDlgCtrlIdFaxLineStatus:
00393                         iTelephony->TelApiWrapperGetFaxLineStatusL( );
00394                   }                
00395                   break;  
00396                /////////////////////////////////////////////////////////////
00397                 default:
00398                     break;
00399                 }//Switch pageId
00400             }//Fetch Case
00401             break;
00402         
00403         //////////// /////////////////////////////////////////////////     
00404         case EIsvTelCallAppCmdAPITestSendDTMF:
00405             {
00406             TInt focusControlId = IdOfFocusControl();  
00407             SendDTMFProcessCommandL(focusControlId);
00408             }
00409             break;
00410 
00411         ////////////////////////////////////////////////////////////////////
00412         case EAknFormCmdEdit:
00413             {
00414             iIsInEditMode = ETrue;
00415             }
00416             break;
00417 
00418         ////////////////////////////////////////////////////////////////////
00419         default:
00420             break;
00421         }
00422 
00423     //Call the base class routine
00424     CAknForm::ProcessCommandL(aCommandId);
00425     }
00426 
00427 // ----------------------------------------------------------------------------
00428 // CIsvTelCallAppDlg::PageChangedL()
00429 // Derived from base-class. It invokes the base-class function and after the
00430 // page switch is executed, it sets the appropriate title for the page.
00431 // ----------------------------------------------------------------------------
00432 //
00433 void CIsvTelCallAppDlg::PageChangedL(TInt aPageId)
00434     {
00435     //Invoke the base class routine
00436     CAknForm::PageChangedL(aPageId);
00437 
00438     //Call SetPageTitleOnPaneL to set the appropriate title on pane
00439     SetPageTitleOnPaneL(aPageId);
00440     }
00441        
00442 // ----------------------------------------------------------------------------
00443 // CIsvTelCallAppDlg::SetDlgPage()
00444 // Is called from the container class to set the start page.
00445 // ----------------------------------------------------------------------------
00446 //
00447 void CIsvTelCallAppDlg::SetDlgPage(TInt aPageId)
00448     {
00449     iPageId = aPageId;
00450     }
00451            
00452 // ----------------------------------------------------------------------------
00453 // CIsvTelCallAppDlg::SetTitlePane()
00454 // It is called by the container class that creates this dialog, to set a
00455 // pointer to the Title pane. This is required to update the name of the
00456 // current page to on the title pane when a page change happens in the dialog.
00457 // ----------------------------------------------------------------------------
00458 //
00459 void CIsvTelCallAppDlg::SetTitlePane(CAknTitlePane* aTitlePane)
00460     {
00461     iTitlePane = aTitlePane;
00462     }
00463  
00464 // ----------------------------------------------------------------------------
00465 // CIsvTelCallAppDlg::SetContainer()
00466 // It is called by the container class that creates this dialog, to set a
00467 // pointer to itself. The dialog class uses this pointer from some command 
00468 // completion handlers to bring the view back to foreground.
00469 // ----------------------------------------------------------------------------
00470 //
00471 void CIsvTelCallAppDlg::SetContainer(CIsvTelCallAppContainer* aContainer)
00472     {
00473     iContainer = aContainer;
00474     }
00475 
00476 // ----------------------------------------------------------------------------
00477 // CIsvTelCallAppDlg::SetPageTitleOnPaneL()
00478 // For each page, it sets the appropriate page title on the pane
00479 // ----------------------------------------------------------------------------
00480 //
00481 void CIsvTelCallAppDlg::SetPageTitleOnPaneL(TInt aPageId)
00482     {
00483     const TInt KTitlePaneBufLength = 256;
00484     TBuf<KTitlePaneBufLength> titleText( NULL );
00485     
00486     //Select the page title
00487     switch (aPageId)
00488         {
00489         case EIsvTelCallAppPageCtrlIdPagePhone1:
00490                 {
00491                 iEikonEnv->ReadResource( titleText, 
00492                 R_ISVTELCALLAPP_TEXT_STATUS_PANE_PHONE1 );
00493             break;
00494                 }
00495         case EIsvTelCallAppPageCtrlIdPagePhone2:
00496                 {
00497                 iEikonEnv->ReadResource( titleText, 
00498                 R_ISVTELCALLAPP_TEXT_STATUS_PANE_PHONE2 );
00499             break;
00500                 }
00501         case EIsvTelCallAppPageCtrlIdPageCallLineStatus:
00502             {
00503                 iEikonEnv->ReadResource(titleText, 
00504                 R_ISVTELCALLAPP_TEXT_STATUS_PANE_CALL_LINE_STATUS);
00505             break;
00506                 }
00507         default:
00508             break;
00509         }
00510         
00511     //Set the appropriate title on the pane
00512     if (iTitlePane)
00513         {
00514         iTitlePane->SetTextL( titleText );
00515         }
00516     }
00517 
00518 // ----------------------------------------------------------------------------
00519 // CIsvTelCallAppDlg::SetMainPageTitleOnPaneL()
00520 // Sets the Application's title on the pane
00521 // ----------------------------------------------------------------------------
00522 //
00523 void CIsvTelCallAppDlg::SetMainPageTitleOnPaneL( )
00524     {
00525     const TInt KTitlePaneBufLength = 256;
00526     TBuf<KTitlePaneBufLength> titleText( NULL );
00527     
00528     iEikonEnv->ReadResource(titleText, 
00529         R_ISVTELCALLAPP_TEXT_STATUS_PANE_MAIN_PAGE);
00530      
00531      //Set the appropriate title on the pane
00532     if (iTitlePane)
00533         {
00534         iTitlePane->SetTextL( titleText );
00535         }
00536     }
00537 
00538 // ----------------------------------------------------------------------------
00539 // CIsvTelCallAppDlg::MakeNewCallProcessCommandL()
00540 // Dials a new call by invoking the CIsvTelCallAppTelephony object
00541 // ----------------------------------------------------------------------------
00542 //
00543 void CIsvTelCallAppDlg::MakeNewCallProcessCommandL(TInt aFocusControlId)
00544     {
00545     switch (aFocusControlId)
00546         {
00547         
00548         case EIsvTelCallAppDlgCtrlIdPhone1:
00549             {
00550             if (ControlOrNull(EIsvTelCallAppDlgCtrlIdPhone1))
00551                 {
00552                 CEikEdwin* edwinText = reinterpret_cast <CEikEdwin*> (ControlOrNull(EIsvTelCallAppDlgCtrlIdPhone1));
00553                 edwinText->GetText(iEdwinPhone1);
00554                 //GetEdwinText(iEdwinPhone1, EIsvTelCallAppDlgCtrlIdPhone1);
00555                 iTelephony->TelApiWrapperMakeNewCallL(CTelephony::EISVCall1, 
00556                     iEdwinPhone1);
00557                 }
00558             }
00559             break;
00560             
00561         case EIsvTelCallAppDlgCtrlIdPhone2:
00562             {
00563             if (ControlOrNull(EIsvTelCallAppDlgCtrlIdPhone2))
00564                 {
00565                 CEikEdwin* edwinText = reinterpret_cast <CEikEdwin*> (ControlOrNull(EIsvTelCallAppDlgCtrlIdPhone1));
00566                 edwinText->GetText(iEdwinPhone2);
00567                 //GetEdwinText(iEdwinPhone2, EIsvTelCallAppDlgCtrlIdPhone2);
00568                 iTelephony->TelApiWrapperMakeNewCallL(CTelephony::EISVCall2,
00569                     iEdwinPhone2);
00570                 }
00571             }
00572             break;
00573             
00574         default:
00575             break;
00576         }    
00577     }
00578 
00579 // ----------------------------------------------------------------------------
00580 // CIsvTelCallAppDlg::HoldProcessCommandL()
00581 // Puts a call on hold by invoking the CIsvTelCallAppTelephony object
00582 // ----------------------------------------------------------------------------
00583 //
00584 void CIsvTelCallAppDlg::HoldProcessCommandL(TInt aPageId)
00585     {
00586     switch (aPageId)
00587         {
00588         /////////////////////////////////////////////////////////////
00589         case EIsvTelCallAppPageCtrlIdPagePhone1:
00590             //Hold Call 1
00591             {
00592             iTelephony->TelApiWrapperHoldL( CTelephony::EISVCall1 );
00593             }
00594             break;
00595 
00596         /////////////////////////////////////////////////////////////
00597         case EIsvTelCallAppPageCtrlIdPagePhone2:
00598             //Hold Call 2
00599             {
00600             iTelephony->TelApiWrapperHoldL( CTelephony::EISVCall2 );
00601             }
00602             break;
00603         }    
00604     }
00605 
00606 // ----------------------------------------------------------------------------
00607 // CIsvTelCallAppDlg::ResumeProcessCommandL()
00608 // Resumes a call by invoking the CIsvTelCallAppTelephony object
00609 // ----------------------------------------------------------------------------
00610 //
00611 void CIsvTelCallAppDlg::ResumeProcessCommandL(TInt aPageId)
00612     {
00613     switch (aPageId)
00614         {
00615         /////////////////////////////////////////////////////////////
00616         case EIsvTelCallAppPageCtrlIdPagePhone1:
00617             //Resume Call 1
00618             {
00619             iTelephony->TelApiWrapperResumeL( CTelephony::EISVCall1 );
00620             }
00621             break;
00622 
00623         /////////////////////////////////////////////////////////////
00624         case EIsvTelCallAppPageCtrlIdPagePhone2:
00625             //Resume Call 2
00626             {
00627             iTelephony->TelApiWrapperResumeL( CTelephony::EISVCall2 );
00628             }
00629             break;
00630         }    
00631     }
00632 
00633 // ----------------------------------------------------------------------------
00634 // CIsvTelCallAppDlg::HangupProcessCommandL()
00635 // Hangs-up a call by invoking the CIsvTelCallAppTelephony object
00636 // ----------------------------------------------------------------------------
00637 //
00638 void CIsvTelCallAppDlg::HangupProcessCommandL(TInt aPageId)
00639     {
00640     switch (aPageId)
00641         {
00642         /////////////////////////////////////////////////////////////
00643         case EIsvTelCallAppPageCtrlIdPagePhone1:
00644             //Hangup Call 1
00645             {
00646             iTelephony->TelApiWrapperHangupL( CTelephony::EISVCall1 );
00647             }
00648             break;
00649 
00650         /////////////////////////////////////////////////////////////
00651         case EIsvTelCallAppPageCtrlIdPagePhone2:
00652             //Hangup Call 1
00653             {
00654             iTelephony->TelApiWrapperHangupL( CTelephony::EISVCall2 );
00655             }
00656             break;
00657         }    
00658     }
00659 
00660 // ----------------------------------------------------------------------------
00661 // CIsvTelCallAppDlg::SendDTMFProcessCommandL()
00662 // Sends a DTMF string on a call by invoking the CIsvTelCallAppTelephony 
00663 // object
00664 // ----------------------------------------------------------------------------
00665 //
00666 void CIsvTelCallAppDlg::SendDTMFProcessCommandL(TInt aFocusControlId)
00667     {
00668     TBuf<KMaxDTMFLength> edwinData;
00669               
00670     switch (aFocusControlId)
00671         {
00672         case EIsvTelCallAppDlgCtrlIdPhone1:
00673             {
00674             CEikEdwin* edwinText = reinterpret_cast <CEikEdwin*> (ControlOrNull(EIsvTelCallAppDlgCtrlIdDtmfSeq1));
00675             edwinText->GetText(edwinData);
00676             //GetEdwinText(edwinData, EIsvTelCallAppDlgCtrlIdDtmfSeq1);  
00677                 if (edwinData.Length() > KMaxDTMFLength)
00678                         {
00679                         TBuf<KMaxErrMsgSize> errNoteMsg;
00680                         iCoeEnv->ReadResource(errNoteMsg,
00681                         R_ISVTELCALLAPP_UIERR_DTMFTOOLONG);
00682 
00683                         CAknErrorNote* errorNote = new (ELeave) CAknErrorNote;
00684                         errorNote->ExecuteLD(errNoteMsg);
00685                         }
00686                 else
00687                         {                   
00688                         iTelephony->TelApiWrapperSendDTMFL( CTelephony::EISVCall1,
00689                                 edwinData);    
00690                         }                       
00691             }
00692             break;
00693             
00694         case EIsvTelCallAppDlgCtrlIdPhone2:
00695             {
00696             CEikEdwin* edwinText = reinterpret_cast <CEikEdwin*> (ControlOrNull(EIsvTelCallAppDlgCtrlIdDtmfSeq2));
00697             edwinText->GetText(edwinData);
00698             //GetEdwinText(edwinData, EIsvTelCallAppDlgCtrlIdDtmfSeq2);    
00699                 if (edwinData.Length() > KMaxDTMFLength)
00700                         {
00701                         TBuf<KMaxErrMsgSize> errNoteMsg;
00702                         iCoeEnv->ReadResource(errNoteMsg,
00703                         R_ISVTELCALLAPP_UIERR_DTMFTOOLONG);
00704 
00705                         CAknErrorNote* errorNote = new (ELeave) CAknErrorNote;
00706                         errorNote->ExecuteLD(errNoteMsg);
00707                         }
00708                 else
00709                         {                   
00710                         iTelephony->TelApiWrapperSendDTMFL( CTelephony::EISVCall2,
00711                                 edwinData);    
00712                         }                       
00713             }
00714             break;
00715         
00716         default:    
00717             break;
00718         }
00719     }
00720 
00721 // ----------------------------------------------------------------------------
00722 // CIsvTelCallAppDlg::SwapProcessCommamnd()
00723 // Swaps two calls by invoking the CIsvTelCallAppTelephony object
00724 // ----------------------------------------------------------------------------
00725 //
00726 void CIsvTelCallAppDlg::SwapProcessCommamndL()
00727     {
00728     //Swap Call1 and Call2
00729     //Format the string with command & parameters 
00730     iTelephony->TelApiWrapperSwapL( );    
00731     }
00732 
00733 // ----------------------------------------------------------------------------
00734 // CIsvTelCallAppDlg::GetCallDynCapsLockStatus()
00735 // Fetches the Call status, Dynamic Capabilities and Line Lock status on Page-1
00736 // ----------------------------------------------------------------------------
00737 //
00738 void CIsvTelCallAppDlg::GetCallStatusL(const CTelephony::TCallId aCallId)
00739     {
00740     iTelephony->TelApiWrapperGetCallStatusL( aCallId );
00741     }        
00742 
00743 // ----------------------------------------------------------------------------
00744 // CIsvTelCallAppDlg::MakeNewCallApiCompleteL()
00745 // Command completion routine called from the CIsvTelCallAppTelephony class
00746 // once the request to dial a new call is complete.
00747 // It also implements the function of status auto-update by calling the
00748 // respective status update routines.
00749 // ----------------------------------------------------------------------------
00750 //
00751 void CIsvTelCallAppDlg::MakeNewCallApiCompleteL(
00752     TInt aStatus, 
00753     const CTelephony::TCallId aCallId,
00754     CTelephony::TTelNumber& aTelNum,
00755     TDesC16& aErrMsg)
00756     {
00757     if (aStatus != KErrNone)
00758         {
00759         TBuf<KMaxErrMsgSize> errorNoteMsg;
00760         errorNoteMsg.Copy(aErrMsg);
00761         CAknErrorNote* errorNote = new (ELeave) CAknErrorNote;
00762         errorNote->ExecuteLD(errorNoteMsg);
00763         }
00764     else
00765         {   
00766 
00767         //Set the Phone number to the page where the corresponding Call ID
00768         //is handled. If the first call is made on the second page ie., 
00769         //Phone-2, since it is the first call, the Call ID returned is 1
00770         //and hence, in the GUI, the call will have to be set to Phone-1
00771         //page. Also the focus will have to be changed to the corresponding
00772         //page.
00773         switch ((TInt)aCallId)
00774             {
00775             case CTelephony::EISVCall1:
00776                 {
00777                 if ( aTelNum == iEdwinPhone2 )
00778                     {
00779                     //Swap Phone1 and Phone2
00780                     iEdwinPhone2.Copy(iEdwinPhone1);
00781                     }
00782                 iEdwinPhone1.Copy(aTelNum);
00783                 
00784                 if (iEdwinPhone1 == iEdwinPhone2)
00785                     {
00786                     //Set Phone-2 to NULL
00787                     _LIT(KNullStr,"");
00788                     iEdwinPhone2 = KNullStr;
00789                     }
00790                 }
00791                 SetEdwinTextL((TInt)EIsvTelCallAppDlgCtrlIdPhone1,
00792                     &iEdwinPhone1);
00793                 SetEdwinTextL((TInt)EIsvTelCallAppDlgCtrlIdPhone2,
00794                     &iEdwinPhone2);
00795                 TryChangeFocusToL(EIsvTelCallAppDlgCtrlIdPhone1);
00796                 break;
00797                 
00798             case CTelephony::EISVCall2:
00799                 {
00800                 iEdwinPhone2.Copy(aTelNum);
00801                 SetEdwinTextL((TInt)EIsvTelCallAppDlgCtrlIdPhone2,
00802                     &iEdwinPhone2);
00803                 TryChangeFocusToL(EIsvTelCallAppDlgCtrlIdPhone2);
00804                 }
00805                 break;
00806 
00807             default:
00808                 break;
00809             }
00810         //Fetch status for both the call ids
00811         GetCallStatusL(CTelephony::EISVCall1);
00812         GetCallStatusL(CTelephony::EISVCall2);        
00813         }
00814     //Bring back the view to foreground
00815     iContainer->BringToForeGroundL();
00816     }
00817    
00818 // ----------------------------------------------------------------------------
00819 // CIsvTelCallAppDlg::HangupCompleteL()
00820 // Command completion routine called from the CIsvTelCallAppTelephony class
00821 // once the request to Hangup a call is complete
00822 // ----------------------------------------------------------------------------
00823 //
00824 void CIsvTelCallAppDlg::HangupCompleteL( TInt aStatus, TDesC16& aErrMsg)
00825     {
00826     if (aStatus != KErrNone)
00827         {
00828         TBuf<KMaxErrMsgSize> errNoteMsg; 
00829         errNoteMsg.Copy(aErrMsg);
00830  
00831         CAknErrorNote* errorNote = new (ELeave) CAknErrorNote;
00832         errorNote->ExecuteLD(errNoteMsg);
00833         }
00834     else
00835         {
00836         //Fetch status for both the call ids
00837         GetCallStatusL(CTelephony::EISVCall1);
00838         GetCallStatusL(CTelephony::EISVCall2);        
00839         }
00840 
00841     //Bring back the view to foreground
00842     iContainer->BringToForeGroundL();
00843     }
00844   
00845 // ----------------------------------------------------------------------------
00846 // CIsvTelCallAppDlg::HoldCompleteL()
00847 // Command completion routine called from the CIsvTelCallAppTelephony class
00848 // once the request to place a call on hold is complete
00849 // ----------------------------------------------------------------------------
00850 //
00851 void CIsvTelCallAppDlg::HoldCompleteL( TInt aStatus, TDesC16& aErrMsg)
00852     {
00853     if (aStatus != KErrNone)
00854         {
00855         TBuf<KMaxErrMsgSize> errNoteMsg;
00856         errNoteMsg.Copy(aErrMsg);
00857 
00858         CAknErrorNote* errorNote = new (ELeave) CAknErrorNote;
00859         errorNote->ExecuteLD(errNoteMsg);
00860         }
00861     else
00862         {
00863         //Fetch status for both the call ids
00864         GetCallStatusL(CTelephony::EISVCall1);
00865         GetCallStatusL(CTelephony::EISVCall2);        
00866         }
00867 
00868     //Bring back the view to foreground
00869     iContainer->BringToForeGroundL();
00870     }
00871  
00872 // ----------------------------------------------------------------------------
00873 // CIsvTelCallAppDlg::ResumeCompleteL()
00874 // Command completion routine called from the CIsvTelCallAppTelephony class
00875 // once the request to resume a call is complete
00876 // ----------------------------------------------------------------------------
00877 //
00878 void CIsvTelCallAppDlg::ResumeCompleteL( TInt aStatus, TDesC16& aErrMsg )
00879     {
00880     if (aStatus != KErrNone)
00881         {
00882         TBuf<KMaxErrMsgSize> errNoteMsg;
00883         errNoteMsg.Copy(aErrMsg);
00884  
00885         CAknErrorNote* errorNote = new (ELeave) CAknErrorNote;
00886         errorNote->ExecuteLD(errNoteMsg);
00887         }
00888     else
00889         {
00890         //Fetch status for both the call ids
00891         GetCallStatusL(CTelephony::EISVCall1);
00892         GetCallStatusL(CTelephony::EISVCall2);        
00893         }
00894         
00895     //Bring back the view to foreground
00896     iContainer->BringToForeGroundL();
00897     }
00898 
00899 // ----------------------------------------------------------------------------
00900 // CIsvTelCallAppDlg::SwapCompleteL()
00901 // Command completion routine called from the CIsvTelCallAppTelephony class
00902 // once the request to swap two calls is complete
00903 // ----------------------------------------------------------------------------
00904 //
00905 void CIsvTelCallAppDlg::SwapCompleteL(
00906     TInt aStatus,
00907     TDesC16& aErrMsg)
00908     {
00909     if (aStatus != KErrNone)
00910         {
00911         TBuf<KMaxErrMsgSize> errNoteMsg;
00912         errNoteMsg.Copy(aErrMsg);
00913 
00914         CAknErrorNote* errorNote = new (ELeave) CAknErrorNote;
00915         errorNote->ExecuteLD(errNoteMsg);
00916         }
00917     else
00918         {
00919         //Fetch status for both the call ids
00920         GetCallStatusL(CTelephony::EISVCall1);
00921         GetCallStatusL(CTelephony::EISVCall2);        
00922         }
00923 
00924     //Bring back the view to foreground
00925     iContainer->BringToForeGroundL();
00926     }
00927 
00928 // ----------------------------------------------------------------------------
00929 // CIsvTelCallAppDlg::GetCallStatusCompleteL()
00930 // Command completion routine called from the CIsvTelCallAppTelephony class
00931 // once the request to Get Call Status is complete
00932 // ----------------------------------------------------------------------------
00933 //
00934 void CIsvTelCallAppDlg::GetCallStatusCompleteL(
00935     TInt aStatus, 
00936     const CTelephony::TCallId aCallId,
00937     CTelephony::TCallStatusV1& aCallStatus,
00938     TDesC16& aErrMsg)
00939     {
00940 
00941     TBuf<EIsvTelCallAppEdwinMaxLength> callStatusStr;
00942 
00943     if (aStatus != KErrNone)
00944         {
00945         callStatusStr.Copy(iErrString);
00946         }
00947     else
00948         {
00949         switch (aCallStatus.iStatus)
00950             {
00951             case CTelephony::EStatusUnknown:
00952                 {
00953                 callStatusStr.Copy(iUnknownStr);
00954                 }
00955                 break;
00956                 
00957             case CTelephony::EStatusIdle:
00958                 {
00959                 callStatusStr.Copy(iIdleStr);
00960                 }
00961                 break;
00962                 
00963             case CTelephony::EStatusDialling:
00964                 {
00965                 callStatusStr.Copy(iDiallingStr);
00966                 }
00967                 break;
00968                 
00969             case CTelephony::EStatusRinging:
00970                 {
00971                 callStatusStr.Copy(iRingingStr);
00972                 }
00973                 break;
00974                 
00975             case CTelephony::EStatusAnswering:
00976                 {
00977                 callStatusStr.Copy(iAnsweringStr);
00978                 }
00979                 break;
00980                 
00981             case CTelephony::EStatusConnecting:
00982                 {
00983                 callStatusStr.Copy(iConnectingStr);
00984                 }
00985                 break;
00986                 
00987             case CTelephony::EStatusConnected:
00988                 {
00989                 callStatusStr.Copy(iConnectedStr);
00990                 }
00991                 break;
00992                 
00993             case CTelephony::EStatusReconnectPending:
00994                 {
00995                 callStatusStr.Copy(iReconnectPendingStr);
00996                 }
00997                 break;
00998 
00999             case CTelephony::EStatusDisconnecting:
01000                 {
01001                 callStatusStr.Copy(iDisconnectingStr);
01002                 }
01003                 break;
01004 
01005             case CTelephony::EStatusHold:
01006                 {
01007                 callStatusStr.Copy(iHoldStr);
01008                 }
01009                 break;
01010 
01011             case CTelephony::EStatusTransferring:
01012                 {
01013                 callStatusStr.Copy(iTransferringStr);
01014                 }
01015                 break;
01016 
01017             case CTelephony::EStatusTransferAlerting:
01018                 {
01019                 callStatusStr.Copy(iTransferAlertingStr);
01020                 }
01021                 break;
01022 
01023             default:
01024                 {
01025                 callStatusStr.Copy(iErrString);
01026                 }
01027                 break;
01028             }
01029         }
01030         //Update the UI
01031     switch (aCallId)
01032         {
01033         case CTelephony::EISVCall1:
01034             {
01035             if ( aStatus != KErrNone )
01036                 {
01037                 iEdwinCall1Status.Copy(aErrMsg);
01038                 }
01039             else
01040                 {
01041                 iEdwinCall1Status.Copy(callStatusStr);
01042                 }
01043             SetEdwinTextL((TInt)EIsvTelCallAppDlgCtrlIdCall1Status,
01044                 &iEdwinCall1Status);
01045             }
01046             break;
01047             
01048         case CTelephony::EISVCall2:
01049             {
01050             if ( aStatus != KErrNone )
01051                 {
01052                 iEdwinCall2Status.Copy(aErrMsg);
01053                 }
01054             else
01055                 {
01056                 iEdwinCall2Status.Copy(callStatusStr);
01057                 }
01058             SetEdwinTextL((TInt)EIsvTelCallAppDlgCtrlIdCall2Status,
01059                 &iEdwinCall2Status);
01060             }
01061             break;
01062             
01063         default:
01064             break;
01065         }
01066     }
01067 
01068 // ----------------------------------------------------------------------------
01069 // CIsvTelCallAppDlg::GetVoiceLineStatusCompleteL()
01070 // Command completion routine called from the CIsvTelCallAppTelephony class
01071 // once the request to Get Voice Line Status is complete
01072 // ----------------------------------------------------------------------------
01073 //
01074 void CIsvTelCallAppDlg::GetVoiceLineStatusCompleteL(
01075     TInt aStatus, 
01076     TDesC16& aErrMsg, 
01077     CTelephony::TCallStatusV1& aCallStatus)
01078     {
01079     if (aStatus != KErrNone)
01080         {
01081         iEdwinVoiceLineStatus.Copy(aErrMsg);
01082         SetEdwinTextL((TInt)EIsvTelCallAppDlgCtrlIdVoiceLineStatus,
01083             &iEdwinVoiceLineStatus);
01084         }
01085     else
01086         {
01087         TBuf<EIsvTelCallAppEdwinMaxLength> callStatusStr;
01088         switch (aCallStatus.iStatus)
01089             {
01090             case CTelephony::EStatusUnknown:
01091                 {
01092                 callStatusStr.Copy(iUnknownStr);
01093                 }
01094                 break;
01095             case CTelephony::EStatusIdle:
01096                 {
01097                 callStatusStr.Copy(iIdleStr);
01098                 }
01099                 break;
01100             case CTelephony::EStatusDialling:
01101                 {
01102                 callStatusStr.Copy(iDiallingStr);
01103                 }
01104                 break;
01105             case CTelephony::EStatusRinging:
01106                 {
01107                 callStatusStr.Copy(iRingingStr);
01108                 }
01109                 break;
01110             case CTelephony::EStatusAnswering:
01111                 {
01112                 callStatusStr.Copy(iAnsweringStr);
01113                 }
01114                 break;
01115             case CTelephony::EStatusConnecting:
01116                 {
01117                 callStatusStr.Copy(iConnectingStr);
01118                 }
01119                 break;
01120             case CTelephony::EStatusConnected:
01121                 {
01122                 callStatusStr.Copy(iConnectedStr);
01123                 }
01124                 break;
01125             case CTelephony::EStatusReconnectPending:
01126                 {
01127                 callStatusStr.Copy(iReconnectPendingStr);
01128                 }
01129                 break;
01130             case CTelephony::EStatusDisconnecting:
01131                 {
01132                 callStatusStr.Copy(iDisconnectingStr);
01133                 }
01134                 break;
01135             case CTelephony::EStatusHold:
01136                 {
01137                 callStatusStr.Copy(iHoldStr);
01138                 }
01139                 break;
01140             case CTelephony::EStatusTransferring:
01141                 {
01142                 callStatusStr.Copy(iTransferringStr);
01143                 }
01144                 break;
01145             case CTelephony::EStatusTransferAlerting:
01146                 {
01147                 callStatusStr.Copy(iTransferAlertingStr);
01148                 }
01149                 break;
01150             default:
01151                 {
01152                 callStatusStr.Copy(iErrString);
01153                 }
01154                 break;
01155             }
01156 
01157         //Update line status to UI
01158         iEdwinVoiceLineStatus.Copy(callStatusStr);
01159         SetEdwinTextL((TInt)EIsvTelCallAppDlgCtrlIdVoiceLineStatus,
01160                                            &iEdwinVoiceLineStatus);
01161        // Register the Call 1 and 2 Status Active Object
01162         iCall1StatusAsyncTelephony->
01163             RegisterForAsyncNotification(
01164             CTelephony::EOwnedCall1StatusChange);
01165         iCall2StatusAsyncTelephony->
01166             RegisterForAsyncNotification(
01167             CTelephony::EOwnedCall2StatusChange);
01168 
01169         // Invoke Answer Incoming Call Wrapper function, 
01170         // if voice line status is ringing
01171         if ( aCallStatus.iStatus  == CTelephony::EStatusRinging )
01172             {
01173             iAnswerInCallTelephony->TelApiWrapperAnswerInCallL();
01174             } 
01175                 }
01176     }
01177 
01178 // ----------------------------------------------------------------------------
01179 // CIsvTelCallAppDlg::GetDataLineStatusCompleteL()
01180 // Command completion routine called from the CIsvTelCallAppTelephony class
01181 // once the request to Get Data Line Status is complete
01182 // ----------------------------------------------------------------------------
01183 //
01184 void CIsvTelCallAppDlg::GetDataLineStatusCompleteL(
01185     TInt aStatus, 
01186     TDesC16& aErrMsg,
01187     CTelephony::TCallStatusV1& aCallStatus)
01188     {
01189     if (aStatus != KErrNone)
01190         {
01191         iEdwinDataLineStatus.Copy(aErrMsg);
01192         SetEdwinTextL((TInt)EIsvTelCallAppDlgCtrlIdDataLineStatus,
01193             &iEdwinDataLineStatus);
01194         }
01195     else
01196         {
01197         TBuf<EIsvTelCallAppEdwinMaxLength> callStatusStr;
01198         switch (aCallStatus.iStatus)
01199             {
01200             case CTelephony::EStatusUnknown:
01201                 {
01202                 callStatusStr.Copy(iUnknownStr);
01203                 }
01204                 break;
01205             case CTelephony::EStatusIdle:
01206                 {
01207                 callStatusStr.Copy(iIdleStr);
01208                 }
01209                 break;
01210             case CTelephony::EStatusDialling:
01211                 {
01212                 callStatusStr.Copy(iDiallingStr);
01213                 }
01214                 break;
01215             case CTelephony::EStatusRinging:
01216                 {
01217                 callStatusStr.Copy(iRingingStr);
01218                 }
01219                 break;
01220             case CTelephony::EStatusAnswering:
01221                 {
01222                 callStatusStr.Copy(iAnsweringStr);
01223                 }
01224                 break;
01225             case CTelephony::EStatusConnecting:
01226                 {
01227                 callStatusStr.Copy(iConnectingStr);
01228                 }
01229                 break;
01230             case CTelephony::EStatusConnected:
01231                 {
01232                 callStatusStr.Copy(iConnectedStr);
01233                 }
01234                 break;
01235             case CTelephony::EStatusReconnectPending:
01236                 {
01237                 callStatusStr.Copy(iReconnectPendingStr);
01238                 }
01239                 break;
01240             case CTelephony::EStatusDisconnecting:
01241                 {
01242                 callStatusStr.Copy(iDisconnectingStr);
01243                 }
01244                 break;
01245             case CTelephony::EStatusHold:
01246                 {
01247                 callStatusStr.Copy(iHoldStr);
01248                 }
01249                 break;
01250             case CTelephony::EStatusTransferring:
01251                 {
01252                 callStatusStr.Copy(iTransferringStr);
01253                 }
01254                 break;
01255             case CTelephony::EStatusTransferAlerting:
01256                 {
01257                 callStatusStr.Copy(iTransferAlertingStr);
01258                 }
01259                 break;
01260             default:
01261                 {
01262                 callStatusStr.Copy(iErrString);
01263                 }
01264                 break;
01265             }
01266         //Update line status to UI
01267         iEdwinDataLineStatus.Copy(callStatusStr);
01268         SetEdwinTextL((TInt)EIsvTelCallAppDlgCtrlIdDataLineStatus,
01269                                            &iEdwinDataLineStatus);
01270         }    
01271     }
01272 
01273 // ----------------------------------------------------------------------------
01274 // CIsvTelCallAppDlg::GetFaxLineStatusCompleteL()
01275 // Command completion routine called from the CIsvTelCallAppTelephony class
01276 // once the request to Get Fax Line Status is complete
01277 // ----------------------------------------------------------------------------
01278 //
01279 void CIsvTelCallAppDlg::GetFaxLineStatusCompleteL(
01280     TInt aStatus, 
01281     TDesC16& aErrMsg,
01282     CTelephony::TCallStatusV1& aCallStatus)
01283     {
01284 
01285     if (aStatus != KErrNone)
01286         {
01287         iEdwinFaxLineStatus.Copy(aErrMsg);
01288         SetEdwinTextL((TInt)EIsvTelCallAppDlgCtrlIdFaxLineStatus,
01289             &iEdwinFaxLineStatus);
01290             }
01291     else
01292         {
01293         TBuf<EIsvTelCallAppEdwinMaxLength> callStatusStr;
01294         switch (aCallStatus.iStatus)
01295             {
01296             case CTelephony::EStatusUnknown:
01297                 {
01298                 callStatusStr.Copy(iUnknownStr);
01299                 }
01300                 break;
01301             case CTelephony::EStatusIdle:
01302                 {
01303                 callStatusStr.Copy(iIdleStr);
01304                 }
01305                 break;
01306             case CTelephony::EStatusDialling:
01307                 {
01308                 callStatusStr.Copy(iDiallingStr);
01309                 }
01310                 break;
01311             case CTelephony::EStatusRinging:
01312                 {
01313                 callStatusStr.Copy(iRingingStr);
01314                 }
01315                 break;
01316             case CTelephony::EStatusAnswering:
01317                 {
01318                 callStatusStr.Copy(iAnsweringStr);
01319                 }
01320                 break;
01321             case CTelephony::EStatusConnecting:
01322                 {
01323                 callStatusStr.Copy(iConnectingStr);
01324                 }
01325                 break;
01326             case CTelephony::EStatusConnected:
01327                 {
01328                 callStatusStr.Copy(iConnectedStr);
01329                 }
01330                 break;
01331             case CTelephony::EStatusReconnectPending:
01332                 {
01333                 callStatusStr.Copy(iReconnectPendingStr);
01334                 }
01335                 break;
01336             case CTelephony::EStatusDisconnecting:
01337                 {
01338                 callStatusStr.Copy(iDisconnectingStr);
01339                 }
01340                 break;
01341             case CTelephony::EStatusHold:
01342                 {
01343                 callStatusStr.Copy(iHoldStr);
01344                 }
01345                 break;
01346             case CTelephony::EStatusTransferring:
01347                 {
01348                 callStatusStr.Copy(iTransferringStr);
01349                 }
01350                 break;
01351             case CTelephony::EStatusTransferAlerting:
01352                 {
01353                 callStatusStr.Copy(iTransferAlertingStr);
01354                 }
01355                 break;
01356             default:
01357                 {
01358                 callStatusStr.Copy(iErrString);
01359                 }
01360                 break;
01361             }
01362         //Update Line status to UI
01363         iEdwinFaxLineStatus.Copy(callStatusStr);
01364         SetEdwinTextL((TInt)EIsvTelCallAppDlgCtrlIdFaxLineStatus,
01365             &iEdwinFaxLineStatus);
01366         }    
01367     }
01368 
01369 // ----------------------------------------------------------------------------
01370 // CIsvTelCallAppDlg::SendDTMFApiCompleteL()
01371 // Command completion routine called from the CIsvTelCallAppTelephony class
01372 // once the request to Send a DTMF string is complete
01373 // ----------------------------------------------------------------------------
01374 //
01375 void CIsvTelCallAppDlg::SendDTMFApiCompleteL(TInt aStatus, TDesC16& aErrMsg)
01376     {
01377     
01378     if (aStatus != KErrNone)
01379         {
01380         TBuf<KMaxErrMsgSize> errNoteMsg;
01381         errNoteMsg.Copy(aErrMsg);
01382         CAknErrorNote* errorNote = new (ELeave) CAknErrorNote;
01383         errorNote->ExecuteLD(errNoteMsg);
01384         }
01385     }
01386 
01387 // ----------------------------------------------------------------------------
01388 // CIsvTelCallAppDlg::AnswerIncomingCallApiCompleteL()
01389 // Command completion routine called from the CIsvTelCallAppTelephony class
01390 // once the request to Get Id Service status is complete
01391 // ----------------------------------------------------------------------------
01392 //
01393 void CIsvTelCallAppDlg::AnswerIncomingCallApiCompleteL(
01394     TInt aStatus, 
01395     const CTelephony::TCallId aCallId,
01396     TDesC16& aErrMsg)
01397     {
01398     if (aStatus == KErrNone)
01399         {
01400         // Getting Call Status here, just to display on Dialog
01401         TInt retCode;
01402         retCode = iAnswerInCallTelephony->iTel->GetCallStatus( aCallId, 
01403             iAnswerInCallTelephony->iCallStatusPckg );
01404 
01405         //Find the type of error message and store in errMsgBuffer.
01406         TBuf16<KMaxErrMsgSize> errMsgBuffer;
01407         errMsgBuffer.Copy(aErrMsg);
01408         iAnswerInCallTelephony->GeneralErrorMessage( retCode, &errMsgBuffer );
01409 
01410         GetCallStatusCompleteL( retCode, 
01411             aCallId,
01412             iAnswerInCallTelephony->iCallStatus,
01413             errMsgBuffer);       
01414          
01415         if((TInt)aCallId == CTelephony::EISVCall1 )
01416             {
01417             //Writing Incoming Call1 on dialog
01418             SetEdwinTextL((TInt) EIsvTelCallAppDlgCtrlIdPhone1,
01419                 &iAnswerInCallPhNum1);
01420             // Registering here to update dialog fields, based on this 
01421             // answered call
01422             iCall1StatusAsyncTelephony->RegisterForAsyncNotification(
01423                 CTelephony::EOwnedCall1StatusChange);
01424             }
01425         else
01426             {
01427             //Writing Incoming Call2 on dialog
01428             SetEdwinTextL((TInt) EIsvTelCallAppDlgCtrlIdPhone2,
01429                 &iAnswerInCallPhNum2);
01430             iCall2StatusAsyncTelephony->RegisterForAsyncNotification(
01431                 CTelephony::EOwnedCall2StatusChange);
01432             }
01433         }
01434     }
01435 
01436 // ----------------------------------------------------------------------------
01437 // CIsvTelCallAppDlg::CIsvTelCallAppDlg()
01438 // Default constructor.
01439 // ----------------------------------------------------------------------------
01440 //
01441 CIsvTelCallAppDlg::CIsvTelCallAppDlg()
01442     {
01443     }
01444 
01445 // ----------------------------------------------------------------------------
01446 // CIsvTelCallAppDlg::ConstructL()
01447 // Second-phase constructor.
01448 // ----------------------------------------------------------------------------
01449 //
01450 void CIsvTelCallAppDlg::ConstructL()
01451     {
01452     iTitlePane = NULL;
01453 
01454     iIsAnswerInCall = ETrue;
01455     
01456     //Load strings from resource
01457     LoadStringsFromResource();
01458         
01459     CAknForm::ConstructL();
01460 
01461     // Create the telephony object for execution from GUI
01462     iTelephony = CIsvTelCallAppTelephony::NewL(*this);
01463     iAnswerInCallTelephony = CIsvTelCallAppTelephony::NewL(*this);
01464     iVoiceLineAsyncTelephony = CIsvTelCallAppTelephony::NewL(*this);
01465     iCall1StatusAsyncTelephony = CIsvTelCallAppTelephony::NewL(*this);
01466     iCall2StatusAsyncTelephony = CIsvTelCallAppTelephony::NewL(*this);
01467         
01468 #ifdef __WINS__ 
01469 
01470 #else
01471     iTelephony->CreateTelephonyPtrL();
01472 
01473     iAnswerInCallTelephony->SetTelephonyPtr(iTelephony->GetTelephonyPtr());
01474        
01475     iVoiceLineAsyncTelephony->SetTelephonyPtr(
01476         iTelephony->GetTelephonyPtr());
01477     iVoiceLineAsyncTelephony->RegisterForAsyncNotification(
01478         CTelephony::EVoiceLineStatusChange );
01479             
01480     iCall1StatusAsyncTelephony->SetTelephonyPtr(
01481         iTelephony->GetTelephonyPtr());
01482                 
01483     iCall2StatusAsyncTelephony->SetTelephonyPtr(
01484         iTelephony->GetTelephonyPtr());
01485 #endif                  
01486             
01487     //Initilalise the delimiter string
01488     _LIT8(KSpaceStr," ");
01489     iDelimiterStr.Copy(KSpaceStr);
01490 
01491     //Initialise the new line string
01492     _LIT8(KNewLineStr,"\n");
01493     iNewLineStr.Format(KNewLineStr);
01494     }
01495 
01496 // ----------------------------------------------------------------------------
01497 // CIsvTelCallAppDlg::PostLayoutDynInitL()
01498 // An over-riding routine which Initialises values to certain default fields
01499 // Also calls the base-class routine
01500 // ----------------------------------------------------------------------------
01501 //
01502 void CIsvTelCallAppDlg::PostLayoutDynInitL()
01503     {
01504     //Call the base class routine
01505     CAknForm::PostLayoutDynInitL();
01506 
01507     //Set edit mode to false
01508     iIsInEditMode = EFalse;
01509     }
01510 
01511 // ----------------------------------------------------------------------------
01512 // CIsvTelCallAppDlg::QuerySaveChangesL()
01513 // Show save query. If user answers "No" to this query.
01514 // return field value to the value which is before editing.
01515 // This is called Back-softkey when edit mode.
01516 // ----------------------------------------------------------------------------
01517 //
01518 TBool CIsvTelCallAppDlg::QuerySaveChangesL()
01519     {
01520     TBool isAnsYes(CAknForm::QuerySaveChangesL());
01521 
01522     if (isAnsYes)
01523         {
01524         SaveFormDataL();
01525         }
01526     else 
01527         {
01528         // Case that answer "No" to query.
01529         DoNotSaveFormDataL();
01530         }
01531     return isAnsYes;
01532     }
01533        
01534 // ----------------------------------------------------------------------------
01535 // CIsvTelCallAppDlg::SaveFormDataL()
01536 // Save form data.
01537 // ----------------------------------------------------------------------------
01538 //
01539 TBool CIsvTelCallAppDlg::SaveFormDataL()
01540     {
01541     CEikEdwin* edwinText1 = reinterpret_cast <CEikEdwin*> (ControlOrNull(EIsvTelCallAppDlgCtrlIdPhone1));
01542     edwinText1->GetText(iEdwinPhone1);
01543     //GetEdwinText(iEdwinPhone1,          EIsvTelCallAppDlgCtrlIdPhone1);
01544     
01545     CEikEdwin* edwinText2 = reinterpret_cast <CEikEdwin*> (ControlOrNull(EIsvTelCallAppDlgCtrlIdPhone2));
01546     edwinText2->GetText(iEdwinPhone2);
01547     //GetEdwinText(iEdwinPhone2,          EIsvTelCallAppDlgCtrlIdPhone2);
01548     
01549     CEikEdwin* edwinText3 = reinterpret_cast <CEikEdwin*> (ControlOrNull(EIsvTelCallAppDlgCtrlIdDtmfSeq1));
01550     edwinText3->GetText(iEdwinDtmfSeq1);
01551     //GetEdwinText(iEdwinDtmfSeq1,        EIsvTelCallAppDlgCtrlIdDtmfSeq1);
01552     
01553     CEikEdwin* edwinText4 = reinterpret_cast <CEikEdwin*> (ControlOrNull(EIsvTelCallAppDlgCtrlIdDtmfSeq2));
01554     edwinText4->GetText(iEdwinDtmfSeq2);
01555     //GetEdwinText(iEdwinDtmfSeq2,        EIsvTelCallAppDlgCtrlIdDtmfSeq2);
01556 
01557     //Set edit mode to false
01558     iIsInEditMode = EFalse;
01559     return ETrue;
01560     }
01561 
01562 // ----------------------------------------------------------------------------
01563 // CIsvTelCallAppDlg::DoNotSaveFormDataL()
01564 // Does not save form data.
01565 // ----------------------------------------------------------------------------
01566 //
01567 void CIsvTelCallAppDlg::DoNotSaveFormDataL()
01568     {
01569     SetEdwinTextL(EIsvTelCallAppDlgCtrlIdPhone1,       &iEdwinPhone1);
01570     SetEdwinTextL(EIsvTelCallAppDlgCtrlIdPhone2,       &iEdwinPhone2);
01571     SetEdwinTextL(EIsvTelCallAppDlgCtrlIdDtmfSeq1,     &iEdwinDtmfSeq1);
01572     SetEdwinTextL(EIsvTelCallAppDlgCtrlIdDtmfSeq2,     &iEdwinDtmfSeq2);
01573 
01574     //Set edit mode to false
01575     iIsInEditMode = EFalse;
01576     }
01577      
01578 // ----------------------------------------------------------------------------
01579 // CIsvTelCallAppDlg::LoadStringsFromResource()
01580 // Loads strings from resource
01581 // ----------------------------------------------------------------------------
01582 //
01583 void CIsvTelCallAppDlg::LoadStringsFromResource( )
01584     {
01585     TBuf16<KMaxCmdSize> resStr;
01586 
01587     //Load general error and success strings
01588     iCoeEnv->ReadResource(resStr, 
01589         R_ISVTELCALLAPP_TELSTR_ERRSTRING);
01590     iErrString.Copy(resStr);
01591 
01592     iCoeEnv->ReadResource(resStr, 
01593         R_ISVTELCALLAPP_TELSTR_SUCCESSSTRING);
01594     iSuccessString.Copy(resStr);
01595     
01596     //Load GetCallStatus strings from resource
01597     iCoeEnv->ReadResource(resStr, 
01598         R_ISVTELCALLAPP_UNKNOWN);
01599     iUnknownStr.Copy(resStr);
01600     
01601     iCoeEnv->ReadResource(resStr, 
01602         R_ISVTELCALLAPP_CALLSTATUS_IDLE);
01603     iIdleStr.Copy(resStr);
01604     
01605     iCoeEnv->ReadResource(resStr, 
01606         R_ISVTELCALLAPP_CALLSTATUS_DIALLING);
01607     iDiallingStr.Copy(resStr);
01608     
01609     iCoeEnv->ReadResource(resStr, 
01610         R_ISVTELCALLAPP_CALLSTATUS_RINGING);
01611     iRingingStr.Copy(resStr);
01612     
01613     iCoeEnv->ReadResource(resStr, 
01614         R_ISVTELCALLAPP_CALLSTATUS_ANSWERING);
01615     iAnsweringStr.Copy(resStr);
01616     
01617     iCoeEnv->ReadResource(resStr, 
01618         R_ISVTELCALLAPP_CALLSTATUS_CONNECTING);
01619     iConnectingStr.Copy(resStr);
01620     
01621     iCoeEnv->ReadResource(resStr, 
01622         R_ISVTELCALLAPP_CALLSTATUS_CONNECTED);
01623     iConnectedStr.Copy(resStr);
01624     
01625     iCoeEnv->ReadResource(resStr, 
01626         R_ISVTELCALLAPP_CALLSTATUS_RECONNECTPENDING);
01627     iReconnectPendingStr.Copy(resStr);
01628     
01629     iCoeEnv->ReadResource(resStr, 
01630         R_ISVTELCALLAPP_CALLSTATUS_DISCONNECTING);
01631     iDisconnectingStr.Copy(resStr);
01632 
01633     iCoeEnv->ReadResource(resStr, 
01634         R_ISVTELCALLAPP_CALLSTATUS_HOLD);
01635     iHoldStr.Copy(resStr);
01636 
01637     iCoeEnv->ReadResource(resStr, 
01638         R_ISVTELCALLAPP_CALLSTATUS_TRANSFERRING);
01639     iTransferringStr.Copy(resStr);
01640 
01641     iCoeEnv->ReadResource(resStr, 
01642         R_ISVTELCALLAPP_CALLSTATUS_TRANSFERALERTING);
01643     iTransferAlertingStr.Copy(resStr);  
01644     
01645     //Answer Incoming Call Phone Number
01646     iCoeEnv->ReadResource(resStr, 
01647         R_ISVTELCALLAPP_TELSTR_ANSWERINCALLPHONENUM1);
01648     iAnswerInCallPhNum1.Copy(resStr);  
01649 
01650     iCoeEnv->ReadResource(resStr, 
01651         R_ISVTELCALLAPP_TELSTR_ANSWERINCALLPHONENUM2);
01652     iAnswerInCallPhNum2.Copy(resStr);  
01653 
01654         iCoeEnv->ReadResource(iEmuApiNotSupported,
01655             R_ISVTELCALLAPP_ERR_EMUAPINOTSUPPORTED);        
01656 
01657     return;
01658     }
01659     
01660     
01661 
01662 //End of file

© Nokia 2009

Back to top