1 /*

     2 * Copyright (c) 2002,2007 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:   This is view that handles listing and 

    15  *  unblocking blocked devices view.

    16  *

    17 */

    18 

    19 #include <avkon.hrh>                    // AVKON components

    20 #include <akntitle.h>

    21 #include <aknViewAppUi.h>

    22 #include <BtuiViewResources.rsg>        // Compiled resource ids

    23 #include <featmgr.h>                    // Feature Manager

    24 

    25 #include <AknGlobalNote.h>

    26 #include <aknnotewrappers.h>

    27 #include <StringLoader.h>   			// Series 60 localisation stringloader

    28 #include <AknMediatorFacade.h>

    29 #include <aknmessagequerydialog.h>

    30 #include <aknnotewrappers.h>

    31 #include <aknnavi.h>

    32 #include <hlplch.h>         			// Help launcher

    33 #include <btengdiscovery.h> 			// for device search

    34 

    35 #include <ctsydomainpskeys.h>

    36 #include <bt_subscribe.h>

    37 #include <btengsettings.h>

    38 #include <centralrepository.h>

    39 #include <CoreApplicationUIsSDKCRKeys.h>

    40 #include <bamdesca.h>

    41 

    42 #include "debug.h"             

    43 #include "btui.h" 						// Global declarations

    44 #include "BTUIPairedDevicesView.h"

    45 #include "BTUIDeviceContainer.h"

    46 #include <secondarydisplay/BtuiSecondaryDisplayAPI.h>

    47 #include <csxhelp/bt.hlp.hrh>   // Help IDs

    48 

    49 #include <gstabhelper.h>

    50 #include <btui.mbg>						// Tab icon for General Setting

    51 #include <bluetoothuiutil.h>

    52 #include "BTUIMainView.h" 				// base View.

    53 

    54 

    55 const TInt KAutoConnect2ndTry = 1;

    56 const TUint32 SetExcludePairedDeviceMask = 0x800000;

    57 

    58 // ================= MEMBER FUNCTIONS =======================

    59 

    60 // ---------------------------------------------------------

    61 // CBTUIPairedDevicesView::NewL

    62 // Two phased constructor called by BT AppUI when serve as part of btui.exe

    63 // ---------------------------------------------------------

    64 //

    65 CBTUIPairedDevicesView* CBTUIPairedDevicesView::NewL(MBtuiPluginViewActivationObserver* aObserver)

    66     {

    67     CBTUIPairedDevicesView* self = new (ELeave) CBTUIPairedDevicesView(aObserver);

    68 	CleanupStack::PushL(self);

    69 	

    70 	self->iConstructAsGsPlugin = EFalse;	

    71  	self->ConstructL();

    72 	CleanupStack::Pop(self);

    73     return self;

    74     }

    75 

    76 // ---------------------------------------------------------

    77 // CBTUIPairedDevicesView::NewLC

    78 // Two phased constructor called by mainView when serve as GS Plugin.

    79 // ---------------------------------------------------------

    80 //

    81 CBTUIPairedDevicesView* CBTUIPairedDevicesView::NewLC(CBTUIMainView* aBaseView, CArrayPtrFlat<MGSTabbedView>* aTabViewArray)

    82     {

    83     CBTUIPairedDevicesView* self = new (ELeave) CBTUIPairedDevicesView();    

    84 	CleanupStack::PushL( self );

    85 		

    86 	self->iConstructAsGsPlugin = ETrue;

    87  	self->ConstructL( aBaseView, aTabViewArray );

    88 

    89     return self;

    90     }

    91     

    92 

    93 // ---------------------------------------------------------

    94 // CBTUIPairedDevicesView::ConstructL

    95 // Symbian 2nd phase constructor can leave.

    96 // ---------------------------------------------------------

    97 //

    98 void CBTUIPairedDevicesView::ConstructL()

    99     {

   100 	TRACE_FUNC_ENTRY

   101 

   102     BaseConstructL(R_BTUI_OTHER_DEVICES_VIEW);

   103 

   104     iCoverDisplayEnabled = FeatureManager::FeatureSupported(KFeatureIdCoverDisplay); 

   105     iHelpEnabled = FeatureManager::FeatureSupported(KFeatureIdHelp);

   106     

   107    	iDeviceSearcher = CBTEngDiscovery::NewL(this);   	

   108 	iBtEngSettings = CBTEngSettings::NewL(this);

   109 	iBTPluginMan = CBTUIPluginMan::NewL( AppUi() );

   110 	iIsAlreadyConnected = EFalse;

   111 	iExpectedCallBack = 0;

   112 	TRACE_INFO(_L("Initial iIsAlreadyConnected -> False"))

   113     TRACE_FUNC_EXIT

   114     }

   115 

   116 void CBTUIPairedDevicesView::ConstructL( CBTUIMainView* aBaseView, CArrayPtrFlat<MGSTabbedView>* aTabViewArray )

   117     {

   118     TRACE_FUNC_ENTRY

   119     

   120 	iBaseView = aBaseView,

   121     iTabHelper = CGSTabHelper::NewL();

   122     aTabViewArray->AppendL(this); 

   123     

   124     BaseConstructL(R_BTUI_OTHER_DEVICES_VIEW_GS);

   125     iCoverDisplayEnabled = FeatureManager::FeatureSupported(KFeatureIdCoverDisplay); 

   126     iHelpEnabled = FeatureManager::FeatureSupported(KFeatureIdHelp);

   127     

   128    	iDeviceSearcher = CBTEngDiscovery::NewL(this);

   129     iBtEngSettings=CBTEngSettings::NewL(this);	

   130     iBTPluginMan = CBTUIPluginMan::NewL( AppUi() );

   131 	iIsAlreadyConnected = EFalse;

   132 	TRACE_INFO(_L("Initial iIsAlreadyConnected = False"))

   133     iExpectedCallBack = 0;

   134 	

   135 	TRACE_FUNC_EXIT

   136     }

   137   

   138 // ---------------------------------------------------------

   139 // CBTUIBlockedDevicesView::CBTUIBlockedDevicesView

   140 // ---------------------------------------------------------

   141     

   142 CBTUIPairedDevicesView::CBTUIPairedDevicesView( MBtuiPluginViewActivationObserver* aObserver )

   143 	: iActivationObserver(aObserver)

   144 	{

   145 	}        

   146 

   147 // ---------------------------------------------------------

   148 // Destructor

   149 // ---------------------------------------------------------

   150 //

   151 CBTUIPairedDevicesView::~CBTUIPairedDevicesView()

   152     {

   153 	TRACE_FUNC_ENTRY

   154 

   155 	//close dialogs if any

   156 	TRAP_IGNORE(

   157 		DialogDismissedL(EAknSoftkeyCancel);

   158 	);

   159 

   160 	delete iActive;

   161 	

   162     if (iContainer)

   163         {

   164         AppUi()->RemoveFromViewStack(*this, iContainer);

   165 		delete iContainer;           

   166 		iContainer = NULL;

   167         }

   168             

   169     if(iDeviceSearcher)

   170         {

   171     	// Canceling devicesearches is done by DialogDismissedL(),

   172     	// so it is not done here    	

   173     	delete iDeviceSearcher;

   174     	iDeviceSearcher = NULL ;

   175         }

   176 	delete iConnectDevice;

   177 	iConnectDevice=NULL;

   178 	

   179 	delete iPairingDevice;

   180 	delete iBtEngSettings;

   181 	delete iBTPluginMan;

   182 	

   183 	if(iConstructAsGsPlugin)

   184 	    	delete iTabHelper;	

   185 	

   186 	CancelDisconnectQueryDlg();

   187 	

   188     TRACE_FUNC_EXIT

   189     }

   190 

   191 // ---------------------------------------------------------

   192 // From CAknView

   193 // CBTUIPairedDevicesView::Id

   194 // ---------------------------------------------------------

   195 //

   196 TUid CBTUIPairedDevicesView::Id() const

   197     {

   198 	TRACE_FUNC_ENTRY    

   199     return KBtuiPluginUidPairedDevicesView;//KBTOtherDevicesViewId;

   200     }

   201 

   202 

   203 

   204 

   205 // ---------------------------------------------------------

   206 // From CAknView

   207 // CBTUIPairedDevicesView::HandleCommandL 

   208 // Redirects commands to the appui class.

   209 // ---------------------------------------------------------

   210 //

   211 void CBTUIPairedDevicesView::HandleCommandL(TInt aCommand)

   212     {

   213 	TRACE_FUNC_ENTRY

   214 

   215     switch (aCommand)

   216         {

   217         

   218         case EAknSoftkeyBack:      

   219             // do not exit if devicechange is in progress.

   220             if(iModel->DeviceChangeInProgress() )

   221             	return;                

   222 	        AppUi()->ActivateLocalViewL(iBaseView->GetParentView().iViewUid );

   223             break;

   224             

   225         case EAknSoftkeyExit:

   226             {

   227 			TRACE_INFO(_L("EAknSoftkeyExit"))

   228             // do not exit if devicechange or bt discovery is in progress.				

   229             if(iModel->DeviceChangeInProgress() 

   230                     || iSearchOngoing )   

   231             	{

   232             	TRACE_INFO(_L("exit denied, due to operation"))

   233             	return;

   234 	           	}

   235 	           	

   236 			TRACE_INFO(_L("exit in progress"))

   237 			AppUi()->ProcessCommandL(EEikCmdExit);            

   238             break;

   239             }

   240 

   241         case EAknCmdHelp:

   242             {

   243             #ifdef __SERIES60_HELP

   244                 HlpLauncher::LaunchHelpApplicationL(iEikonEnv->WsSession(),AppUi()->AppHelpContextL());

   245             #endif

   246             break;

   247             }          

   248         	

   249         case EBTUICmdNewPairedDevice:

   250             {

   251             iSearchOngoing=ETrue;

   252             NewPairedDeviceDlgL();

   253             break;

   254             }

   255 

   256         case EBTUICmdDelete:

   257             {

   258             DeleteDeviceDlgL();

   259             break;

   260             }

   261 

   262         case EBTUICmdDeleteAll:

   263             {

   264             DeleteAllDevicesDlgL();

   265             break;

   266             }

   267 

   268         case EBTUICmdGiveNickname:

   269             {

   270             RenameDeviceDlgL();

   271             break;

   272             }

   273 

   274         case EBTUICmdSetTrusted:

   275             {

   276             ChangeDeviceSecurityL(ETrue);

   277             break;

   278             }

   279 

   280         case EBTUICmdSetUnTrusted:

   281             {

   282             ChangeDeviceSecurityL(EFalse);

   283             break;

   284             }

   285 

   286         case EBTUICmdConnect:

   287         case EBTUICmdConnectAudio: 

   288             {

   289             TBTDevice device;

   290             device.iIndex = iContainer->CurrentItemIndex();

   291             iModel->GetDevice(device);

   292             if ( device.iStatus & EStatusBtuiConnected )

   293                 {

   294                 // If device is already connected, we do nothing here. 

   295                 break;

   296                 }

   297             device.iOperation = EOpConnect;

   298             ConnectL( device, ETrue );

   299 	        break;            	

   300             }

   301 

   302         case EBTUICmdDisconnect:

   303             {

   304             DisconnectL();

   305             break;

   306             }

   307   

   308         case EBTUICmdSetBlocked:

   309         	{

   310         	BlockDeviceDlgL();

   311         	break;

   312         	}

   313         	

   314         case EBTUICmdSettings:

   315         	{

   316         	LaunchSettingViewL();

   317         	break;

   318         	}

   319         	

   320         default:

   321             {

   322             AppUi()->HandleCommandL(aCommand);

   323             break;

   324             }

   325         }

   326 	TRACE_FUNC_EXIT        

   327     }

   328 

   329 

   330 // ---------------------------------------------------------

   331 // From CAknView

   332 // CBTUIPairedDevicesView::DoActivateL

   333 // ---------------------------------------------------------

   334 //

   335 void CBTUIPairedDevicesView::DoActivateL(const TVwsViewId& /*aPrevViewId*/,

   336                                                TUid /*aCustomMessageId*/,

   337                                          const TDesC8& /*aCustomMessage*/)

   338     {

   339 	TRACE_FUNC_ENTRY

   340 

   341     iModel = CBTDevModel::NewL(EGroupPaired, this);

   342     iContainer = CBTUiDeviceContainer::NewL(ClientRect(), this, EGroupPaired, this);

   343     iContainer->SetMopParent(this); // MObjectProvider

   344 

   345     // Setup title

   346     HBufC* btTitlePairedDevices = 

   347     	iCoeEnv->AllocReadResourceLC(R_BT_TITLE_PAIRED_DEV);

   348     CEikStatusPane* statusPane = StatusPane();

   349     CAknTitlePane* titlePane;

   350     titlePane = (CAknTitlePane*) statusPane->ControlL(

   351     	TUid::Uid(EEikStatusPaneUidTitle));

   352     titlePane->SetTextL(btTitlePairedDevices->Des());

   353     CleanupStack::PopAndDestroy(btTitlePairedDevices); // btTitlePairedDevices

   354     btTitlePairedDevices = NULL;

   355 

   356     AppUi()->AddToStackL(*this, iContainer);

   357 

   358     if( iBaseView && iConstructAsGsPlugin)

   359         {

   360         iTabHelper->CreateTabGroupL( Id(), 

   361             static_cast<CArrayPtrFlat<MGSTabbedView>*>

   362             (iBaseView->TabbedViews()) ); 

   363         } 

   364         

   365 	// MSK menu is added here.

   366 	// the left key menu is added by resources.

   367     MenuBar()->SetContextMenuTitleResourceId(

   368     	R_BTUI_MENUBAR_OTHER_DEVICES_VIEW_CONTEXT);		

   369 	// notify observer   

   370     if( iActivationObserver  && iConstructAsGsPlugin == EFalse)

   371     {    	    

   372         iActivationObserver->PluginViewActivated(EPairedDevicesViewId);        

   373     }

   374 

   375 	TRACE_FUNC_EXIT

   376     }

   377 

   378 // ---------------------------------------------------------

   379 // From CAknView

   380 // CBTUIPairedDevicesView::DoDeactivate

   381 // ---------------------------------------------------------

   382 //

   383 void CBTUIPairedDevicesView::DoDeactivate()

   384     {

   385 	TRACE_FUNC_ENTRY

   386 

   387     if (iContainer)

   388         {

   389         AppUi()->RemoveFromStack(iContainer);

   390         delete iContainer;

   391         iContainer = NULL;

   392         }

   393 	if ( iDeviceSearcher )

   394 	    {

   395 	    iDeviceSearcher->CancelSearchRemoteDevice();

   396 	    }

   397     delete iModel;

   398     iModel=NULL;

   399     if(iConstructAsGsPlugin)

   400 	    iTabHelper->RemoveTabGroup();  

   401     delete iActive;

   402     iActive = NULL;

   403     iIsPairConnect = EFalse;

   404     TRACE_FUNC_EXIT

   405     }

   406 

   407 // ---------------------------------------------------------

   408 // From CAknView

   409 // CBTUIPairedDevicesView::DynInitMenuPaneL

   410 // Shows only options supported for selected device, if any.

   411 // If not show only options supported regardless of selected

   412 // device

   413 // ---------------------------------------------------------

   414 //

   415 void CBTUIPairedDevicesView::DynInitMenuPaneL(TInt aResId, CEikMenuPane* aMenu)

   416     {

   417 	TRACE_FUNC_ENTRY

   418 	iActiveMenuPane = aMenu;

   419 	// dim help if it exists and is not supported	

   420 	TInt tmp;	

   421 	if (  aMenu->MenuItemExists(EAknCmdHelp,tmp ) )			

   422 		{			

   423 		aMenu->SetItemDimmed(EAknCmdHelp,

   424 		  !FeatureManager::FeatureSupported( KFeatureIdHelp ) );

   425 		}

   426 	

   427 	if ( aResId == R_BTUI_OTHER_DEVICES_VIEW_MENU  )

   428 	    {

   429         TInt index = iContainer->CurrentItemIndex();

   430 

   431         // we only show "new pair device", "help" , "Exit" and "Delete All" if view contains device(s).  

   432         aMenu->SetItemDimmed(EBTUICmdSetTrusted, ETrue);   

   433         aMenu->SetItemDimmed(EBTUICmdDelete,ETrue);

   434         aMenu->SetItemDimmed(EBTUICmdSetTrusted,ETrue);

   435         aMenu->SetItemDimmed(EBTUICmdSetUnTrusted,ETrue);

   436         aMenu->SetItemDimmed(EBTUICmdConnect,ETrue);

   437         aMenu->SetItemDimmed(EBTUICmdConnectAudio,ETrue); 

   438         aMenu->SetItemDimmed(EBTUICmdDisconnect,ETrue);

   439         aMenu->SetItemDimmed(EBTUICmdSetBlocked,ETrue);

   440         aMenu->SetItemDimmed(EBTUICmdSettings,ETrue);

   441         aMenu->SetItemDimmed(EBTUICmdGiveNickname, ETrue);         

   442         

   443         if ( index < 0 ) // No devices at list. Hide all device related commands.

   444             {

   445             aMenu->SetItemDimmed(EBTUICmdDeleteAll, ETrue); 

   446             }

   447         

   448 	    }

   449 	

   450     if ( aResId == R_BTUI_OTHER_DEVICES_VIEW_MENU_CONTEXT )

   451         {

   452         TInt index = iContainer->CurrentItemIndex();

   453           

   454         // If user is fast enough to click the RSK option between 

   455         // bt discovery view and device found view,  bt ui will crash.

   456         // Therefore, we disable commands if bt discovery is onging.

   457         //          

   458         if(iSearchOngoing)

   459             {

   460             aMenu->SetItemDimmed(EBTUICmdGiveNickname, ETrue);

   461             aMenu->SetItemDimmed(EBTUICmdSetTrusted, ETrue);

   462             aMenu->SetItemDimmed(EBTUICmdSetUnTrusted, ETrue);

   463             aMenu->SetItemDimmed(EBTUICmdSetBlocked, ETrue);

   464             aMenu->SetItemDimmed(EBTUICmdDelete, ETrue);

   465             aMenu->SetItemDimmed(EBTUICmdConnect, ETrue);

   466             aMenu->SetItemDimmed(EBTUICmdConnectAudio, ETrue);

   467             aMenu->SetItemDimmed(EBTUICmdDisconnect, ETrue);            

   468             aMenu->SetItemDimmed(EBTUICmdNewPairedDevice, ETrue);

   469             return;

   470             }

   471         

   472         if(index < 0)  // No devices at list. Hide all device related commands.

   473             {            

   474             TRACE_INFO(_L("no devices in list"))

   475             

   476             aMenu->SetItemDimmed(EBTUICmdGiveNickname, ETrue);

   477             aMenu->SetItemDimmed(EBTUICmdSetTrusted, ETrue);

   478             aMenu->SetItemDimmed(EBTUICmdSetUnTrusted, ETrue);

   479             aMenu->SetItemDimmed(EBTUICmdSetBlocked, ETrue);

   480             aMenu->SetItemDimmed(EBTUICmdDelete, ETrue);

   481             aMenu->SetItemDimmed(EBTUICmdConnect, ETrue);

   482             aMenu->SetItemDimmed(EBTUICmdConnectAudio, ETrue);

   483             aMenu->SetItemDimmed(EBTUICmdDisconnect, ETrue);

   484             aMenu->SetItemDimmed(EBTUICmdSettings, ETrue);

   485             }

   486         else // There are devices at list

   487             {

   488 	        TBTDevice device;

   489             device.iIndex = index;

   490     	    iModel->GetDevice(device);

   491             iMenuDevice = device;    	    

   492             

   493             TRACE_INFO(_L("there are device in list"))

   494           

   495             TBool dim = (device.iStatus & EStatusTrusted) == EStatusTrusted;

   496             

   497             aMenu->SetItemDimmed(EBTUICmdSetTrusted, dim);

   498             aMenu->SetItemDimmed(EBTUICmdSetUnTrusted, !dim);

   499              

   500             // Check if device can be connected or disconnected

   501 			dim = (! (device.iStatus & EStatusConnectable) 

   502 			|| device.iStatus & EStatusBtuiConnected);

   503 			

   504 			if (dim) 

   505 				{

   506             	aMenu->SetItemDimmed(EBTUICmdConnect, dim);

   507             	aMenu->SetItemDimmed(EBTUICmdConnectAudio, dim);

   508 				}

   509 			else

   510 				{

   511 				if ( device.iDeviceClass.MajorDeviceClass() == EMajorDeviceComputer) 

   512             		{

   513             		aMenu->SetItemDimmed(EBTUICmdConnect, ETrue);

   514             		}

   515             	else 

   516             		{

   517             		aMenu->SetItemDimmed(EBTUICmdConnectAudio, ETrue);

   518             		}

   519 				}

   520 			dim = (device.iStatus & EStatusBtuiConnected) != EStatusBtuiConnected;

   521             aMenu->SetItemDimmed(EBTUICmdDisconnect, dim);

   522 

   523             if ( !iBTPluginMan->IsPluginAvaiable(device.iDeviceClass) ) 

   524                 {

   525                 aMenu->SetItemDimmed(EBTUICmdSettings, ETrue);

   526                 }

   527             else

   528                 {                

   529                 dim = (device.iStatus & EStatusBtuiConnected) != EStatusBtuiConnected;

   530                 aMenu->SetItemDimmed(EBTUICmdSettings, dim);

   531                 }

   532             //Hide New pair device

   533             aMenu->SetItemDimmed(EBTUICmdNewPairedDevice, ETrue);

   534             }

   535         }

   536 	TRACE_FUNC_EXIT        

   537     }

   538     

   539 

   540 // ----------------------------------------------------------

   541 // CBTUIPairedDevicesView::RenameDeviceDlgL

   542 // ----------------------------------------------------------

   543 //

   544 void CBTUIPairedDevicesView::RenameDeviceDlgL()

   545     {

   546 	TRACE_FUNC_ENTRY

   547 

   548 	TInt index = iContainer->CurrentItemIndex();

   549 	if(index == KErrNotFound) return;

   550     

   551 	TBTDevice device;

   552     device.iIndex = index;

   553 	iModel->GetDevice(device);

   554 	TBTDeviceName name = device.iName;

   555 	

   556     CAknTextQueryDialog* dlg = CAknTextQueryDialog::NewL(device.iName);

   557     TInt keypress = dlg->ExecuteLD(R_BT_ENTER_NICKNAME_QUERY);

   558 

   559     if(keypress)  // User has accepted the dialog

   560         {

   561         if(device.iName != name) // Check if the user really changed the name

   562         	{

   563     		device.iOperation = EOpChangeName;        

   564     		// Remove trouble making control chars

   565 		    AknTextUtils::StripCharacters(device.iName, KAknStripListControlChars);    

   566 	        device.iName.TrimAll();  // Remove extra spaces    		

   567         	iModel->ChangeDevice(device);        	

   568         	}

   569         }

   570 	TRACE_FUNC_EXIT        

   571     }

   572     

   573 

   574 // ----------------------------------------------------------

   575 // CBTUIPairedDevicesView::NewPairedDeviceDlgL

   576 //

   577 // Initiate bonding (pairing) by opening the search dialog.

   578 // DeviceSearchComplete is called after that.

   579 // ----------------------------------------------------------

   580 //

   581 void CBTUIPairedDevicesView::NewPairedDeviceDlgL()

   582 	{

   583 	TRACE_FUNC_ENTRY	

   584 	// we must not have other pairing in progress.

   585 	// we maight issue an error, but none is defined by 

   586 	// ui spec. Anyhow this should be possible

   587 	// only by pressing everything roo rapidly.

   588 	if(iPairingDevice!=NULL)

   589 		return;

   590 	iPairingDevice = CBTDevice::NewL();

   591 	

   592 	// Here we use last bit in device class to inform bt inquiry notifier 

   593 	// not to display the device which is already paired and in the paired 

   594 	// device list.  

   595 	    

   596 	// We use DeviceClass to tell btnotif not to show paired device in 

   597 	// bt discovery notifier through bteng.

   598 	// Set bit 24 to 1 ( bit 24 is not used for any other purpose currently )	

   599 	iPairingDevice->SetDeviceClass(iPairingDevice->DeviceClass().DeviceClass() | SetExcludePairedDeviceMask );

   600 	TInt err = iDeviceSearcher->SearchRemoteDevice(iPairingDevice,

   601                                                    &iPairingDevNameEntry, 

   602                                                    iPairingDevice->DeviceClass().DeviceClass());

   603 

   604 

   605 	if(err != KErrNone)

   606 		{

   607 		delete iPairingDevice;

   608 		iPairingDevice=NULL;

   609         TBTUIViewsCommonUtils::ShowGeneralErrorNoteL();        

   610     	}

   611 	TRACE_FUNC_EXIT    	

   612 	}

   613 

   614 // ----------------------------------------------------------

   615 // CBTUIPairedDevicesView::DeleteDeviceDlgL

   616 // ----------------------------------------------------------

   617 //

   618 void CBTUIPairedDevicesView::DeleteDeviceDlgL()

   619     {

   620 	TRACE_FUNC_ENTRY

   621 	

   622     iExpectedCallBack = 0;

   623 	TInt index = iContainer->CurrentItemIndex();

   624 	if(index == KErrNotFound) return;

   625 

   626     TBTDevice device;

   627     device.iIndex = index;

   628     iModel->GetDevice(device);

   629 

   630     RBuf stringholder;

   631     CleanupClosePushL( stringholder );

   632 

   633 	TInt tmp=EStatusBtuiConnected|EStatusPhysicallyConnected;

   634     // Choose confirmation phrase

   635     TInt resourceId = ( device.iStatus & tmp ) ? R_BT_WARN_ERASE_CONNECTED :

   636         R_BT_WARN_ERASE;

   637     BluetoothUiUtil::LoadResourceAndSubstringL( 

   638             stringholder, resourceId, device.iName, 0 );

   639 

   640     // Create confirmation query

   641     //

   642     CAknQueryDialog* dlg = CAknQueryDialog::NewL();

   643 

   644 	if(iCoverDisplayEnabled)

   645 		{

   646         CleanupStack::PushL(dlg); 

   647 	    dlg->PublishDialogL(ECmdShowBtWarnEraseNote, KUidCoverUiCategoryBtui); 

   648 	    // initializes cover support    

   649         CleanupStack::Pop(dlg); 

   650 

   651 		CAknMediatorFacade* covercl = AknMediatorFacade(dlg); // uses MOP, so control provided 

   652 		if (covercl) // returns null if __COVER_DISPLAY is not defined

   653 		    {	    

   654 		    covercl->BufStream() << BTDeviceNameConverter::ToUTF8L(device.iName) ;// takes copy so consts are ok too

   655 		    covercl->BufStream().CommitL(); // no more data to send so commit buf

   656 		    }  

   657 		}

   658     TInt keypress = dlg->ExecuteLD(R_BT_WARN_ERASE_QUERY, stringholder);

   659 

   660     CleanupStack::PopAndDestroy(&stringholder);  // stringholder

   661 

   662     if(keypress)  // User has accepted the dialog

   663         {

   664         // If device is connected we need to first to disconnect 

   665         // then unpair, otherwise unpairing does not succeed.

   666         if((device.iStatus & EStatusBtuiConnected) == EStatusBtuiConnected)

   667         {

   668             iExpectedCallBack++;

   669             DisconnectWithoutQuery();            

   670             return;

   671         }

   672         device.iOperation = EOpUnpair;

   673         iModel->ChangeDevice(device);       

   674         }

   675 

   676 	TRACE_FUNC_EXIT

   677     }

   678 

   679 // ----------------------------------------------------------

   680 // CBTUIPairedDevicesView::DeleteAllDevicesDlgL

   681 // ----------------------------------------------------------

   682 //

   683 void CBTUIPairedDevicesView::DeleteAllDevicesDlgL()

   684     {

   685 	TRACE_FUNC_ENTRY

   686 	

   687     iExpectedCallBack = 0;

   688     CAknQueryDialog* dlg = CAknQueryDialog::NewL();

   689     TInt keypress = KErrNone;

   690     

   691     CleanupStack::PushL(dlg); 

   692 

   693     // Choose and execute confirmation query

   694     //

   695     if (iModel->IsAnyDeviceConnected())

   696         {

   697 		if(iCoverDisplayEnabled)

   698 			{

   699             dlg->PublishDialogL(ECmdShowBtWarnEraseAllConnectedQuery, KUidCoverUiCategoryBtui); // initializes cover support    

   700 			}

   701 

   702         keypress = dlg->ExecuteLD(R_BT_WARN_ERASE_ALL_CONNECTED_QUERY);

   703         }

   704     else

   705         {        

   706 		if(iCoverDisplayEnabled)

   707 			{

   708 	        dlg->PublishDialogL(ECmdShowBtWarnEraseAllQuery, KUidCoverUiCategoryBtui); // initializes cover support    

   709 			}

   710 

   711         keypress = dlg->ExecuteLD(R_BT_WARN_ERASE_ALL_QUERY);

   712         }

   713     CleanupStack::Pop(dlg); 

   714 

   715     if(keypress)  // User has accepted the dialog

   716         {

   717         TInt count = iContainer->CountItems();   

   718         for (TInt i = 0; i < count; i++)

   719            {

   720            // If device is connected we need to first to disconnect 

   721            // then unpair, otherwise unpairing does not succeed.                      

   722            TBTDevice device;

   723            device.iIndex = i;

   724            iModel->GetDevice(device);

   725            if((device.iStatus & EStatusBtuiConnected) == EStatusBtuiConnected)

   726                {

   727                iExpectedCallBack++;

   728                }

   729            }

   730         TRACE_INFO((_L("iExpectedCallBack %d"), iExpectedCallBack ))

   731         

   732         for (TInt i = 0; i < count; i++)

   733             {

   734             // If device is connected we need to first to disconnect 

   735             // then unpair, otherwise unpairing does not succeed.                      

   736             TBTDevice device;

   737             device.iIndex = i;

   738             iModel->GetDevice(device);           

   739             

   740             if((device.iStatus & EStatusBtuiConnected) == EStatusBtuiConnected)

   741                 {

   742                 //disconnect it first, removal will be done in 

   743                 //callback NotifyChangeDeviceCompleteL for ChangeDevice() below

   744                 TRACE_INFO((_L("EOpDisconnect issued for %d"), i ))

   745                 device.iOperation = EOpDisconnect;

   746                 iModel->ChangeDevice(device);  

   747                 }

   748             else

   749                 {

   750                 //otherwise, just remove it from the paired view

   751                 device.iOperation = EOpUnpair;

   752                 iModel->ChangeDevice(device);

   753                 }

   754             }

   755         }

   756 

   757 	TRACE_FUNC_EXIT

   758     }

   759 // ----------------------------------------------------------

   760 // CBTUIPairedDevicesView::BlockDeviceDlgL

   761 // ----------------------------------------------------------

   762 void CBTUIPairedDevicesView::BlockDeviceDlgL()

   763 	{

   764 	TRACE_FUNC_ENTRY

   765 

   766 	TInt index = iContainer->CurrentItemIndex();

   767 	if(index == KErrNotFound) return;

   768 			

   769     TBTDevice device;

   770     device.iIndex = index;

   771     iModel->GetDevice(device);

   772 

   773 	//check if this is connected device

   774 		

   775 	HBufC* header= iCoeEnv->AllocReadResourceLC(R_BT_OPTION_BLOCK_DEVICE_HEADER); 

   776 	

   777 	RBuf stringHolder;

   778 	CleanupClosePushL( stringHolder );

   779 	TInt resouseId;

   780 	if (device.iStatus & (EStatusBtuiConnected|EStatusPhysicallyConnected) )

   781 	    {

   782 	    resouseId = iHelpEnabled? R_BT_OPTION_BLOCK_PAIRED_DEVICE_HELP : 

   783             R_BT_OPTION_BLOCK_PAIRED_DEVICE_NOHELP;

   784 	    }

   785 	else

   786 	    {

   787 	    resouseId = iHelpEnabled ? R_BT_OPTION_BLOCK_PAIRED_DEVICE_HELP :

   788             R_BT_OPTION_BLOCK_PAIRED_DEVICE_NOHELP;

   789 	    }

   790 	BluetoothUiUtil::LoadResourceAndSubstringL( 

   791 	        stringHolder, resouseId, device.iName, 0 );

   792 	

   793 	CAknMessageQueryDialog *queryDialog = CAknMessageQueryDialog::NewL (stringHolder, 

   794 	  CAknQueryDialog::EConfirmationTone);		

   795 	queryDialog->PrepareLC(R_BT_MESSAGE_QUERY);

   796 	

   797 	(queryDialog)->Heading()->SetTextL(*header);

   798 	queryDialog->SetFocus(ETrue);

   799 

   800     TInt keypress=EFalse;

   801 #ifdef __SERIES60_HELP    

   802 	if (iHelpEnabled)

   803         {

   804 		HBufC* queryLink = StringLoader::LoadL(R_BT_BLOCK_DEVICE_LINK);

   805 		TCoeHelpContext hc(KBtuiUid3,KBT_HLP_BLOCKED);

   806 		TCallBack helpCallBack(CBTUIPairedDevicesView::LaunchHelp , &hc);

   807 		

   808 		TRAPD(err,

   809 			static_cast<CAknMessageQueryDialog*>(queryDialog)->SetLinkTextL(*queryLink);

   810 			static_cast<CAknMessageQueryDialog*>(queryDialog)->SetLink(helpCallBack););

   811 		if(err==KErrNone)

   812 			{

   813 			keypress = queryDialog->RunLD();

   814 			}

   815         	

   816 		delete queryLink; 

   817         queryLink = NULL;

   818         }

   819     else

   820 #endif    

   821         {

   822         keypress = queryDialog->RunLD();

   823         }

   824 	

   825 	CleanupStack::PopAndDestroy(&stringHolder);  				 

   826 	CleanupStack::PopAndDestroy(header);

   827 	        

   828 	if(keypress)

   829 		{

   830 		device.iOperation = EOpBlock;

   831 		iModel->ChangeDevice(device);

   832 		}

   833 	TRACE_FUNC_EXIT		

   834 	}

   835 // ----------------------------------------------------------

   836 // CBTUIPairedDevicesView::ChangeDeviceSecurityL

   837 // ----------------------------------------------------------

   838 //

   839 void CBTUIPairedDevicesView::ChangeDeviceSecurityL(TBool aTrusted)

   840     {

   841    	TRACE_FUNC_ENTRY

   842 

   843 	TInt index = iContainer->CurrentItemIndex();

   844 	if(index == KErrNotFound) return;

   845 			

   846     TBTDevice device;

   847     device.iIndex = index;

   848     iModel->GetDevice(device);

   849     

   850     if(aTrusted)

   851         {

   852         // set to trusted

   853         CAknQueryDialog* dlg = CAknQueryDialog::NewL();

   854         

   855 		if(iCoverDisplayEnabled)

   856 			{

   857 			CleanupStack::PushL(dlg); 

   858 	        dlg->PublishDialogL(ECmdShowBtAuthConfirmQuery, KUidCoverUiCategoryBtui); // initializes cover support    

   859 		    CleanupStack::Pop(dlg); 

   860 			}

   861         TInt keypress = dlg->ExecuteLD(R_BT_SET_TRUSTED_QUERY);

   862 

   863         if(keypress)  // User has accepted the dialog

   864             {

   865             device.iOperation = EOpTrust;

   866             iModel->ChangeDevice(device);

   867             }

   868         }

   869     else

   870         {

   871         device.iOperation = EOpUntrust;

   872         iModel->ChangeDevice(device);        

   873         }

   874 	TRACE_FUNC_EXIT        

   875     }

   876     

   877 // ----------------------------------------------------

   878 // CBTUIMainView::VisibilityModeChanged

   879 // ----------------------------------------------------

   880 //    

   881 void CBTUIPairedDevicesView::VisibilityModeChanged( TBTVisibilityMode  )

   882     {

   883 	TRACE_FUNC_ENTRY

   884 	

   885 	

   886 	TRACE_FUNC_EXIT	

   887     }

   888     

   889         

   890 // ----------------------------------------------------

   891 // CBTUIMainView::PowerStateChanged

   892 // ----------------------------------------------------

   893 //

   894 void CBTUIPairedDevicesView::PowerStateChanged( TBTPowerStateValue  )

   895     {

   896 	TRACE_FUNC_ENTRY

   897 	

   898 	if ( iIsConnectDevice )

   899 		{

   900 		iModel->ChangeDevice(*iConnectDevice);

   901 		iIsConnectDevice = EFalse;   // reset flag

   902 		}

   903 	

   904 	TRACE_FUNC_EXIT	

   905     }

   906     

   907 // ----------------------------------------------------------

   908 // CBTUIPairedDevicesView::ConnectL

   909 // ----------------------------------------------------------

   910 //

   911 void CBTUIPairedDevicesView::ConnectL(

   912         const TBTDevice& aDevice, TBool aNewWaitNote )

   913 	{

   914 	TRACE_FUNC_ENTRY

   915 	

   916 	iIsAlreadyConnected = EFalse;

   917 	TRACE_INFO(_L("Set iIsAlreadyConnected -> False"))

   918 	//Check that there is not more than max amount of connections allready.		

   919 	TInt connNum = 0;

   920     RProperty::Get(KPropertyUidBluetoothCategory, KPropertyKeyBluetoothPHYCount, connNum);

   921 	if(connNum > KBtUiMaxConnections) 

   922   		{

   923         ConnectCompleteL(KErrServerBusy, aDevice);

   924   		}

   925   	else if(CallOnGoing()&& connNum > 1)

   926 	  	{

   927     	CAknNoteDialog* dlg = new (ELeave) CAknNoteDialog(CAknNoteDialog::ENoTone,

   928                                                        CAknNoteDialog::ELongTimeout);

   929 		if(iCoverDisplayEnabled)

   930 			{

   931 			CleanupStack::PushL(dlg); 

   932     		dlg->PublishDialogL(ECmdShowBtImpossibleIncallNote, KUidCoverUiCategoryBtui); // initializes cover support    

   933 			CleanupStack::Pop(dlg); 

   934 			}

   935 	

   936     	dlg->ExecuteLD(R_BT_NOT_INCALL_NOTE);    	

   937   		}

   938     else

   939         {

   940 		if(TBTUIViewsCommonUtils::TurnBTOnIfNeededL(iBtEngSettings,iCoverDisplayEnabled)!= KErrNone)

   941 			return;

   942 		

   943 		TInt errorCode = KErrNone;  

   944 		TBTPowerStateValue currentPowerMode;		

   945 		errorCode=iBtEngSettings->GetPowerState(currentPowerMode); 

   946 		

   947 	    if(errorCode)    

   948 	    	{

   949 	    	// handle the error code

   950 	    	return;

   951 	    	}

   952 	    if ( aNewWaitNote )

   953 	        {

   954             // Launch wait note              

   955             OpenWaitNoteL(iWaitForConnectDlg,R_BT_CONNECTING_TO_WAIT_NOTE,R_BT_CONNECTING_TO ,

   956                 ECmdShowBtWaitConnectingToNote,aDevice.iName); 

   957 	        }

   958 		iConnectDevice=new(ELeave) TBTDevice(aDevice);            

   959 		iConnectDevice->iOperation=EOpConnect;

   960 		     

   961 		if( currentPowerMode == EBTPowerOff )

   962 			{

   963 				// turn on the flag IsConnectDevice

   964 				//

   965 				iIsConnectDevice = ETrue;

   966 			}

   967         else

   968         	{	

   969         		// connect device

   970         		//

   971         		iModel->ChangeDevice(*iConnectDevice);

   972         		

   973         		// reset IsConnectDevice flag

   974         		iIsConnectDevice = EFalse;

   975         	}

   976         }

   977     TRACE_FUNC_EXIT

   978 	}

   979 	

   980 // ----------------------------------------------------------

   981 // CBTUIPairedDevicesView::OpenWaitNoteL

   982 // ----------------------------------------------------------

   983 void CBTUIPairedDevicesView::OpenWaitNoteL(CAknWaitDialog*& aWaitDialog,TUint aNoteResource,TUint aNoteTextResource,

   984 		TSecondaryDisplayBtuiDialogs aSec,const TDesC& aDevName)

   985 	{

   986 	TRAPD(err,

   987 	        RBuf stringholder;

   988 	        CleanupClosePushL( stringholder );

   989 	        BluetoothUiUtil::LoadResourceAndSubstringL( 

   990 	                stringholder, aNoteTextResource, aDevName, 0 );

   991 	    aWaitDialog = new (ELeave) CAknWaitDialog(

   992                     reinterpret_cast<CEikDialog**>(&aWaitDialog), ETrue);

   993 	    aWaitDialog->PrepareLC(aNoteResource);

   994 	    aWaitDialog->SetTextL(stringholder);

   995 

   996 	    if(iCoverDisplayEnabled)

   997 	        {

   998 	        aWaitDialog->PublishDialogL(

   999 	          aSec, KUidCoverUiCategoryBtui); // initializes cover support    

  1000 	        CAknMediatorFacade* covercl = AknMediatorFacade(aWaitDialog); // uses MOP, so control provided 

  1001 	        if (covercl) // returns null if __COVER_DISPLAY is not defined

  1002 	            {	    

  1003 	            covercl->BufStream() << BTDeviceNameConverter::ToUTF8L(aDevName);// takes copy so consts are ok too

  1004 	            covercl->BufStream().CommitL(); // no more data to send so commit buf

  1005 	            }  

  1006 	        }	        

  1007 	    aWaitDialog->SetCallback(this); // for capturing Cancel keypress	            

  1008 	    aWaitDialog->RunLD();

  1009 	    

  1010     	CleanupStack::PopAndDestroy(&stringholder); // stringholder

  1011     );

  1012     // if the above functions leaves the iWaitNote is deleted, but

  1013     // not set to NULL. This will cause a problem, when

  1014     // the items may be deleted again, since it has to

  1015     // be a member variable, in order to be closed

  1016     // programmatically.

  1017     if(err!=KErrNone)

  1018     	{

  1019     	// that is why we set it to NULL here and

  1020     	// continue leaving further.

  1021         aWaitDialog=NULL;

  1022 		User::Leave(err);	

  1023     	}

  1024 	}

  1025 

  1026 // ----------------------------------------------------------

  1027 // CBTUIPairedDevicesView::LaunchSettingViewL

  1028 // ----------------------------------------------------------

  1029 //

  1030 void CBTUIPairedDevicesView::LaunchSettingViewL()

  1031 	{

  1032 	TRACE_FUNC_ENTRY

  1033 	

  1034 	TInt index = iContainer->CurrentItemIndex();

  1035 	if(index == KErrNotFound) return;			

  1036 	TBTDevice device;

  1037 	device.iIndex = index;

  1038 	iModel->GetDevice(device);

  1039 	

  1040 	CAknView* settingView = iBTPluginMan->GetSettingViewL(device);

  1041 	if(settingView != NULL)

  1042 		{

  1043 		TUid viewId = settingView->Id();		

  1044         if(( device.iStatus & EStatusBtuiConnected) == EStatusBtuiConnected )

  1045             {

  1046             TBuf8<KMaxBCBluetoothNameLen> DeviceName;

  1047             DeviceName.Copy(device.iName);

  1048             AppUi()->ActivateLocalViewL( viewId, KNullUid, DeviceName); 

  1049             }

  1050         else

  1051             {

  1052             AppUi()->ActivateLocalViewL( viewId ); 

  1053             }

  1054 		}

  1055 	else 

  1056 		{

  1057 		User::Leave(KErrNotFound);

  1058 		}	

  1059 		

  1060 	TRACE_FUNC_EXIT

  1061 	}

  1062 

  1063 // ----------------------------------------------------------

  1064 // CBTUIPairedDevicesView::DisconnectL

  1065 // ----------------------------------------------------------

  1066 //

  1067 void CBTUIPairedDevicesView::DisconnectL()

  1068     {

  1069 	TRACE_FUNC_ENTRY

  1070     

  1071 	TInt index = iContainer->CurrentItemIndex();

  1072 	if(index == KErrNotFound) return;

  1073 			

  1074     TBTDevice device;

  1075     device.iIndex = index;

  1076     iModel->GetDevice(device);

  1077     

  1078     if ( !( device.iStatus & EStatusBtuiConnected) )

  1079         {

  1080         // If device is already disconnected, return immediately.

  1081         return;

  1082         }

  1083     

  1084 	iDisconnectQueryDevice = device;//remember device related with query dialog

  1085 

  1086     // Create confirmation query

  1087     RBuf stringholder;

  1088     CleanupClosePushL( stringholder );

  1089     BluetoothUiUtil::LoadResourceAndSubstringL( 

  1090             stringholder, R_BT_DISCONNECT_FROM, device.iName, 0 );

  1091     if ( !iDisconnectQueryDlg )

  1092         {

  1093         iDisconnectQueryDlg = CAknQueryDialog::NewL();

  1094         }

  1095 

  1096 	if(iCoverDisplayEnabled)

  1097 		{

  1098 	    iDisconnectQueryDlg->PublishDialogL(ECmdShowDisconnectQuery, KUidCoverUiCategoryBtui); // initializes cover support    

  1099 	

  1100 		CAknMediatorFacade* covercl = AknMediatorFacade(iDisconnectQueryDlg); // uses MOP, so control provided 

  1101 		if (covercl) // returns null if __COVER_DISPLAY is not defined

  1102 		    {	    

  1103 		    covercl->BufStream() << BTDeviceNameConverter::ToUTF8L(device.iName);// takes copy so consts are ok too

  1104 		    covercl->BufStream().CommitL(); // no more data to send so commit buf

  1105 		    }  

  1106 		}

  1107 			

  1108     TInt keypress = iDisconnectQueryDlg->ExecuteLD(R_BT_DISCONNECT_FROM_QUERY, stringholder);

  1109 

  1110     CleanupStack::PopAndDestroy(&stringholder);  // stringholder

  1111 

  1112 	iDisconnectQueryDlg = NULL;

  1113     if(keypress)  // User has accepted the dialog

  1114         {

  1115         device.iOperation = EOpDisconnect;

  1116 	    iModel->ChangeDevice(device);

  1117 		}

  1118 	TRACE_FUNC_EXIT		

  1119 	}

  1120 	

  1121 // ----------------------------------------------------------

  1122 // CBTUIPairedDevicesView::CancelDisconnectQueryDlgL

  1123 // ----------------------------------------------------------

  1124 //

  1125 void CBTUIPairedDevicesView::CancelDisconnectQueryDlg()

  1126 {

  1127 	TRACE_FUNC_ENTRY

  1128 	

  1129 	if(iDisconnectQueryDlg)

  1130 	{

  1131 		delete iDisconnectQueryDlg;

  1132 		iDisconnectQueryDlg = NULL;

  1133 	}

  1134