bluetoothengine/btui/btuidelegate/btdelegatedisconnect.cpp
changeset 57 5ebadcda06cb
parent 42 b72428996822
equal deleted inserted replaced
51:625f43ae9362 57:5ebadcda06cb
    20 #include <QModelIndex>
    20 #include <QModelIndex>
    21 #include <hblabel.h>
    21 #include <hblabel.h>
    22 #include <btsettingmodel.h>
    22 #include <btsettingmodel.h>
    23 #include <btdevicemodel.h>
    23 #include <btdevicemodel.h>
    24 #include <hbnotificationdialog.h>
    24 #include <hbnotificationdialog.h>
       
    25 #include <bluetoothuitrace.h>
    25 
    26 
    26 BtDelegateDisconnect::BtDelegateDisconnect(            
    27 BtDelegateDisconnect::BtDelegateDisconnect(            
    27         BtSettingModel* settingModel, 
    28         BtSettingModel* settingModel, 
    28         BtDeviceModel* deviceModel, QObject *parent) :
    29         BtDeviceModel* deviceModel, QObject *parent) :
    29     BtAbstractDelegate(settingModel, deviceModel, parent), mBtengConnMan(0), mPhyLinks(0),
    30     BtAbstractDelegate(settingModel, deviceModel, parent), mBtengConnMan(0), mPhyLinks(0),
    30 	 mMajorRole(0), mActiveHandling(false), mAddrArrayIndex(0), mDisconOpt(DisconUnknown)
    31 	 mActiveHandling(false), mAddrArrayIndex(0), mDisconOpt(DisconUnknown)
    31 {
    32 {
    32     
    33     BOstraceFunctionEntry1( DUMMY_DEVLIST, this );   
       
    34     BOstraceFunctionExit1( DUMMY_DEVLIST, this );
    33 }
    35 }
    34 
    36 
    35 BtDelegateDisconnect::~BtDelegateDisconnect()
    37 BtDelegateDisconnect::~BtDelegateDisconnect()
    36 {
    38 {
       
    39     BOstraceFunctionEntry1( DUMMY_DEVLIST, this );   
    37     delete mBtengConnMan;
    40     delete mBtengConnMan;
    38     delete mPhyLinks;
    41     delete mPhyLinks;
    39     mSocketServ.Close();
    42     mSocketServ.Close();
    40 }
    43     BOstraceFunctionExit1( DUMMY_DEVLIST, this );
    41 
    44 }
       
    45 
       
    46 
       
    47 /*!
       
    48     Returns the supported editor types.
       
    49     \return the sum of supported editor types
       
    50  */
       
    51 int BtDelegateDisconnect::supportedEditorTypes() const
       
    52 {
       
    53     return BtDelegate::DisconnectService
       
    54            | BtDelegate::DisconnectAllConnections;
       
    55 }
       
    56 
       
    57 /*!
       
    58  * disconnects remote device(s) from local device
       
    59  * params of type QList<QVariant>: 
       
    60  *         1) DisconnectOption (either ServiceLevel, PhysicalLink or AllOngoingConnections)
       
    61  *         2) remote device address (QString, not needed for AllOngoingConnections)
       
    62  */
    42 void BtDelegateDisconnect::exec( const QVariant &params )
    63 void BtDelegateDisconnect::exec( const QVariant &params )
    43 {
    64 {
       
    65     BOstraceFunctionEntry1( DUMMY_DEVLIST, this );   
    44     int err;
    66     int err;
       
    67     
       
    68     // check if in use already
       
    69     if ( mActiveHandling ) {
       
    70         emit delegateCompleted(KErrInUse, this);
       
    71         BOstraceFunctionExitExt( DUMMY_DEVLIST, this, KErrInUse);
       
    72         return;
       
    73     }
       
    74     
       
    75     // check parameters
       
    76     QList<QVariant> paramList = params.value< QList<QVariant> >(); 
       
    77     if (!((paramList.count() == 1) || (paramList.count() == 2))) {
       
    78         // wrong parameter count
       
    79         emit delegateCompleted( KErrArgument, this ); 
       
    80         BOstraceFunctionExitExt( DUMMY_DEVLIST, this, KErrArgument );
       
    81         return;
       
    82     }
       
    83     
       
    84     // create btengconnman
    45     if ( ! mBtengConnMan ){
    85     if ( ! mBtengConnMan ){
    46         TRAP( err, mBtengConnMan = CBTEngConnMan::NewL(this) );
    86         TRAP( err, mBtengConnMan = CBTEngConnMan::NewL(this) );
    47     }
    87     }
    48     if(err) {
    88     if( err ) {
    49         emit commandCompleted(err);
    89         emit delegateCompleted(err, this);
    50         return;
    90         BOstraceFunctionExitExt( DUMMY_DEVLIST, this, err );
    51     }
    91         return;
    52     if (params.canConvert<int>()){
    92     }
    53         mDisconOpt = (DisconnectOption)params.toInt();
    93     
       
    94     mDisconOpt = (DisconnectOption)paramList.at(0).toInt();    // DisconnectOption
       
    95     
       
    96     if ( (mDisconOpt == ServiceLevel) || (mDisconOpt == PhysicalLink) ) {
       
    97         // check 2nd parameter is ok
       
    98         if ((paramList.count() != 2) || !paramList.at(1).canConvert<QString>()) {
       
    99             emit delegateCompleted( KErrArgument, this ); 
       
   100             BOstraceFunctionExitExt( DUMMY_DEVLIST, this, KErrArgument );
       
   101             return;
       
   102         }
       
   103         QString strBtAddr = paramList.at(1).toString();  // remote device to operate on
       
   104         BtTraceQString1( TRACE_DEBUG, DUMMY_DEVLIST, "device addr=", strBtAddr);
       
   105         addrReadbleStringToSymbian( strBtAddr, mBtEngAddr );
       
   106         
       
   107         mActiveHandling = true;
       
   108 
       
   109         if (mDisconOpt == ServiceLevel){
       
   110             disconnectServiceLevel();
       
   111         }
       
   112         else if (mDisconOpt == PhysicalLink){
       
   113             disconnectPhysicalLink();       
       
   114         }
       
   115     } 
       
   116     else if ( mDisconOpt == AllOngoingConnections ) {
       
   117         err = mBtengConnMan->GetConnectedAddresses(mDevAddrArray);
       
   118         //Added this condition because GetConnectedAddresses returns 0 even if no addresses
       
   119         //are returned.
       
   120         if(err || !(mDevAddrArray.Count())) {
       
   121             emit delegateCompleted(err, this);
       
   122             BOstraceFunctionExitExt( DUMMY_DEVLIST, this, err );
       
   123             return;
       
   124         }
       
   125         
    54         mActiveHandling = true;
   126         mActiveHandling = true;
    55         
   127         
    56         if (mDisconOpt == AllOngoingConnections){
   128         disconnectAllConnections_service();
    57             err = mBtengConnMan->GetConnectedAddresses(mDevAddrArray);
   129     } 
    58             disconnectAllConnections_service();
   130     else {
    59         }
   131         BTUI_ASSERT_X( 0, "BtDelegateDisconnect::exec()", "incorrect parameter" );
    60         if(err) {
   132     }
    61             emit commandCompleted(err);
   133     BOstraceFunctionExit1( DUMMY_DEVLIST, this );
    62         }
   134 }
    63     }
   135 
    64     else{
   136 
    65         QList<QVariant> paramList = params.value< QList<QVariant> >(); 
   137 void BtDelegateDisconnect::disconnectAllConnections_service() 
    66         QVariant indexVariant = paramList.at(0); 
   138 {
    67         QModelIndex index = indexVariant.value<QModelIndex>();
   139     BOstraceFunctionEntry1( DUMMY_DEVLIST, this );   
    68         QVariant optionVariant = paramList.at(1); 
   140     QString btStringAddr;
    69         mDisconOpt = (DisconnectOption)optionVariant.toInt();
   141     addrSymbianToReadbleString( btStringAddr, mDevAddrArray[mAddrArrayIndex] );
    70         int error = KErrNone;
   142     QModelIndex start = deviceModel()->index(0,0);
    71         
   143     QModelIndexList indexList = deviceModel()->match(start,BtDeviceModel::ReadableBdaddrRole, btStringAddr);
    72         mActiveHandling = true;
   144     // ToDo:  what happens if device not found from the model?  error handling needed!
    73         mDeviceName = getDeviceModel()->data(index,BtDeviceModel::NameAliasRole).toString();
   145     QModelIndex index = indexList.at(0);
    74         mMajorRole = (index.data(BtDeviceModel::MajorPropertyRole)).toInt();
   146     
    75         
   147     mBtEngAddr = mDevAddrArray[mAddrArrayIndex];
    76         QString strBtAddr = getDeviceModel()->data(index,BtDeviceModel::ReadableBdaddrRole).toString();
   148     
    77         
   149     disconnectServiceLevel(); 
    78         // todo: address converting should be simplified. check other delegates for example.
   150     BOstraceFunctionExit1( DUMMY_DEVLIST, this );
    79         
   151 }
    80         TPtrC ptrName(reinterpret_cast<const TText*>(strBtAddr.constData()));
   152 
    81             
   153 void BtDelegateDisconnect::disconnectAllConnections_physical()
    82         RBuf16 btName;
   154 {
    83         error = btName.Create(ptrName.Length());
   155     BOstraceFunctionEntry1( DUMMY_DEVLIST, this );   
    84         
   156     QString btStringAddr;
    85         if(error == KErrNone) {
   157     addrSymbianToReadbleString( btStringAddr, mDevAddrArray[mAddrArrayIndex] );
    86             btName.Copy(ptrName);
   158     QModelIndex start = deviceModel()->index(0,0);
    87             mBtEngAddr.SetReadable(btName);
   159     QModelIndexList indexList = deviceModel()->match(start,BtDeviceModel::ReadableBdaddrRole, btStringAddr);
    88             if (mDisconOpt == ServiceLevel){
   160     // ToDo:  what happens if device not found from the model?  error handling needed!
    89                 disconnectSeviceLevel();
   161     QModelIndex index = indexList.at(0);
    90             }
   162     
    91             else if (mDisconOpt == PhysicalLink){
   163     mBtEngAddr = mDevAddrArray[mAddrArrayIndex];
    92                 disconnectPhysicalLink();       
   164     
    93             }
   165     disconnectPhysicalLink();
    94         }
   166     BOstraceFunctionExit1( DUMMY_DEVLIST, this );
    95         btName.Close();
   167 }
    96         
   168 
    97         if(error) {
   169 void BtDelegateDisconnect::disconnectServiceLevel()
    98             emit commandCompleted(error);
   170 {
    99         }
   171     BOstraceFunctionEntry1( DUMMY_DEVLIST, this );   
   100     }  
       
   101 }
       
   102 
       
   103 
       
   104 void BtDelegateDisconnect::disconnectAllConnections_service(){
       
   105     
       
   106         TBuf<KBTDevAddrSize*3> addrBuf;
       
   107         mDevAddrArray[mAddrArrayIndex].GetReadable(addrBuf);
       
   108         QString btStringAddr= QString::fromUtf16( addrBuf.Ptr(), addrBuf.Length());
       
   109         QModelIndex start = getDeviceModel()->index(0,0);
       
   110         QModelIndexList indexList = getDeviceModel()->match(start,BtDeviceModel::ReadableBdaddrRole, btStringAddr);
       
   111         QModelIndex index = indexList.at(0);
       
   112         
       
   113         mDeviceName = getDeviceModel()->data(index,BtDeviceModel::NameAliasRole).toString();
       
   114         mBtEngAddr = mDevAddrArray[mAddrArrayIndex];
       
   115         mMajorRole = (index.data(BtDeviceModel::MajorPropertyRole)).toInt();
       
   116         
       
   117         disconnectSeviceLevel();        
       
   118 }
       
   119 
       
   120 void BtDelegateDisconnect::disconnectAllConnections_physical(){
       
   121     
       
   122         TBuf<KBTDevAddrSize*3> addrBuf;
       
   123         mDevAddrArray[mAddrArrayIndex].GetReadable(addrBuf);
       
   124         QString btStringAddr= QString::fromUtf16( addrBuf.Ptr(), addrBuf.Length());
       
   125         QModelIndex start = getDeviceModel()->index(0,0);
       
   126         QModelIndexList indexList = getDeviceModel()->match(start,BtDeviceModel::ReadableBdaddrRole, btStringAddr);
       
   127         QModelIndex index = indexList.at(0);
       
   128         
       
   129         mDeviceName = getDeviceModel()->data(index,BtDeviceModel::NameAliasRole).toString();
       
   130         mBtEngAddr = mDevAddrArray[mAddrArrayIndex];
       
   131         
       
   132         disconnectPhysicalLink();
       
   133         
       
   134 }
       
   135 void BtDelegateDisconnect::disconnectSeviceLevel(){
       
   136     int err;
   172     int err;
   137     TBTEngConnectionStatus connStatus = EBTEngNotConnected;
   173     TBTEngConnectionStatus connStatus = EBTEngNotConnected;
       
   174     BtTraceBtAddr1( TRACE_DEBUG, DUMMY_DEVLIST, "calling btengconnman->isConnected() with device addr=", mBtEngAddr );
   138     err = mBtengConnMan->IsConnected(mBtEngAddr, connStatus);
   175     err = mBtengConnMan->IsConnected(mBtEngAddr, connStatus);
   139     if (connStatus == EBTEngConnected){
   176     BOstraceExt2( TRACE_DEBUG, DUMMY_DEVLIST, "isConnected() ret = %d, conn status (0/2) = %d",  err, connStatus);
   140         err = mBtengConnMan->Disconnect(mBtEngAddr, EBTDiscGraceful);
   177     
   141     }
   178     //if ( !err && (connStatus == EBTEngConnected) ) {
   142     if(err) {
   179         // asynchronous call, see callback DisconnectComplete()
   143         if (mDisconOpt == AllOngoingConnections){
   180         BtTraceBtAddr1( TRACE_DEBUG, DUMMY_DEVLIST, "btengconnman->Disconnect() with param device addr=", mBtEngAddr );
   144             disconnectServiceLevelCompleted(err);
   181         err = mBtengConnMan->Disconnect(mBtEngAddr, EBTDiscGraceful);  
   145         }
   182         BOstraceExt1( TRACE_DEBUG, DUMMY_DEVLIST, "Disconnect() ret = %d",  err);
   146         else{ 
   183     //}
   147             emit commandCompleted(err);
   184     if (err) {
   148         }
   185         // handle error
   149     }
   186         disconnectServiceLevelCompleted(err);
       
   187     }
       
   188     BOstraceFunctionExit1( DUMMY_DEVLIST, this );
   150 }
   189 }
   151         
   190         
   152 void BtDelegateDisconnect::disconnectPhysicalLink(){
   191 void BtDelegateDisconnect::disconnectPhysicalLink()
       
   192 {
       
   193     BOstraceFunctionEntry1( DUMMY_DEVLIST, this );   
   153     int err;
   194     int err;
   154     if ( !mSocketServ.Handle() ) {
   195     if ( !mSocketServ.Handle() ) {
   155         err = mSocketServ.Connect();
   196         err = mSocketServ.Connect();
   156     }
   197     }
   157     if ( !err && !mPhyLinks ) {
   198     if ( !err && !mPhyLinks ) {
   158         TRAP( err, 
   199         TRAP( err, 
   159             mPhyLinks = CBluetoothPhysicalLinks::NewL( *this, mSocketServ ) );
   200             mPhyLinks = CBluetoothPhysicalLinks::NewL( *this, mSocketServ ) );
   160         Q_CHECK_PTR( mPhyLinks );
   201         if (err) {
   161     }
   202             disconnectPhysicalLinkCompleted(err); // handle error
   162     err = mPhyLinks->Disconnect( mBtEngAddr );
   203         }
   163     if(err) {
   204     }
   164         if (mDisconOpt == AllOngoingConnections){
   205     // ToDo:  consider using DisconnectAll()
   165             disconnectPhysicalLinkCompleted(err);
   206     BtTraceBtAddr1( TRACE_DEBUG, DUMMY_DEVLIST, "phy->Disconnect() with param device addr=", mBtEngAddr );
   166         }
   207     err = mPhyLinks->Disconnect( mBtEngAddr );  // async call, see callback HandleDisconnectCompleteL()
   167         else{ 
   208     BOstraceExt1( TRACE_DEBUG, DUMMY_DEVLIST, "Phy Disconnect() ret = %d",  err);
   168             emit commandCompleted(err);
   209     if (err) {
   169         }
   210         disconnectPhysicalLinkCompleted(err);  // handle error
   170     }
   211     }
   171     
   212     BOstraceFunctionExit1( DUMMY_DEVLIST, this );
   172 }
   213 }
   173 
   214 
   174 void BtDelegateDisconnect::disconnectServiceLevelCompleted(int err){
   215 void BtDelegateDisconnect::disconnectServiceLevelCompleted(int err)
       
   216 {
       
   217     BOstraceFunctionEntryExt( DUMMY_DEVLIST, this, err );   
   175     if (mDisconOpt == ServiceLevel){
   218     if (mDisconOpt == ServiceLevel){
   176         mActiveHandling = false;
   219         mActiveHandling = false;
   177         emit commandCompleted(err);
   220         emit delegateCompleted(err, this);
   178     }
   221     }
   179     else if (mDisconOpt == AllOngoingConnections){
   222     else if (mDisconOpt == AllOngoingConnections){
   180         if (err){
   223         if (err){
   181             mActiveHandling = false;
   224             mActiveHandling = false;
   182             emit commandCompleted(err);
   225             emit delegateCompleted(err, this);
   183         }
   226         }
   184         else{
   227         else{
   185             mAddrArrayIndex++;
   228             mAddrArrayIndex++;
   186             if ( mAddrArrayIndex < mDevAddrArray.Count()){
   229             if ( mAddrArrayIndex < mDevAddrArray.Count()) {
   187                 disconnectAllConnections_service();
   230                 disconnectAllConnections_service();  // recursive call
   188             }
   231             }
   189             else{
   232             else {
   190                 mDevAddrArray.Reset();
   233                 mDevAddrArray.Reset();
       
   234                 mAddrArrayIndex = 0;
   191                 err = mBtengConnMan->GetConnectedAddresses(mDevAddrArray);
   235                 err = mBtengConnMan->GetConnectedAddresses(mDevAddrArray);
   192                 if(err) {
   236                 if(err) {
   193                     emit commandCompleted(err);
   237                     mActiveHandling = false;
       
   238                     emit delegateCompleted(err, this);
       
   239                     BOstraceFunctionExitExt( DUMMY_DEVLIST, this, err );
   194                     return;
   240                     return;
   195                 }
   241                 }
   196                 mAddrArrayIndex = 0;
       
   197                 //connect( mDisconnectDelegate, SIGNAL(commandCompleted(int)), this, SLOT(disconnectPhysicalLinkCompleted(int)) );         
       
   198                 disconnectAllConnections_physical();
   242                 disconnectAllConnections_physical();
   199             }
   243             }
   200         }
   244         }
   201     }
   245     }
   202 }
   246     BOstraceFunctionExit1( DUMMY_DEVLIST, this );
   203 
   247 }
   204 void BtDelegateDisconnect::disconnectPhysicalLinkCompleted(int err){
   248 
       
   249 void BtDelegateDisconnect::disconnectPhysicalLinkCompleted(int err)
       
   250 {
       
   251     BOstraceFunctionEntryExt( DUMMY_DEVLIST, this, err );   
   205     if (mDisconOpt == PhysicalLink){
   252     if (mDisconOpt == PhysicalLink){
   206         //emitCommandComplete(err);
       
   207         mActiveHandling = false;
   253         mActiveHandling = false;
   208         emit commandCompleted(err);
   254         emit delegateCompleted(err, this);
   209     }
   255     }
   210     else if (mDisconOpt == AllOngoingConnections){
   256     else if (mDisconOpt == AllOngoingConnections) {
   211         if (err){
   257         if (err) {
   212             mActiveHandling = false;
   258             mActiveHandling = false;
   213             emit commandCompleted(err);
   259             emit delegateCompleted(err, this);
   214         }
   260         }
   215         else{
   261         else{
   216             mAddrArrayIndex++;
   262             mAddrArrayIndex++;
   217             if ( mAddrArrayIndex < mDevAddrArray.Count()){
   263             if ( mAddrArrayIndex < mDevAddrArray.Count()) {
   218                 disconnectAllConnections_physical();
   264                 disconnectAllConnections_physical();  // recursive call
   219             }
   265             }
   220             else{
   266             else {  // DONE!
   221                 //TODO: check if there is still ongoing connection from BTEngVonnMan. and close them again if there is any new 
   267                 //TODO: check if there is still ongoing connection from BTEngConnMan. and close them again if there is any new 
   222                 mActiveHandling = false;
   268                 mActiveHandling = false;
   223                 emit commandCompleted(err);
   269                 emit delegateCompleted(KErrNone, this);
   224             }
   270             }
   225         }
   271         }
   226         
   272     }
   227     }
   273     BOstraceFunctionExit1( DUMMY_DEVLIST, this );
   228     
   274 }
   229 }
   275 
   230 void BtDelegateDisconnect::ConnectComplete( TBTDevAddr& aAddr, TInt aErr, 
   276 void BtDelegateDisconnect::ConnectComplete( TBTDevAddr& aAddr, TInt aErr, 
   231                                    RBTDevAddrArray* aConflicts )
   277                                    RBTDevAddrArray* aConflicts )
   232 {
   278 {
       
   279     BOstraceFunctionEntryExt( DUMMY_DEVLIST, this, aErr );  
       
   280     BtTraceBtAddr1( TRACE_DEBUG, DUMMY_DEVLIST, "device addr=", aAddr );
   233     Q_UNUSED(aAddr);
   281     Q_UNUSED(aAddr);
   234     Q_UNUSED(aConflicts);  
   282     Q_UNUSED(aConflicts);  
   235     Q_UNUSED(aErr);
   283     Q_UNUSED(aErr);
       
   284     BOstraceFunctionExit1( DUMMY_DEVLIST, this );
   236 }
   285 }
   237 
   286 
   238 void BtDelegateDisconnect::DisconnectComplete( TBTDevAddr& aAddr, TInt aErr )
   287 void BtDelegateDisconnect::DisconnectComplete( TBTDevAddr& aAddr, TInt aErr )
   239 {
   288 {
   240     if ( mBtEngAddr != aAddr || !mActiveHandling ) {  
   289     BOstraceFunctionEntryExt( DUMMY_DEVLIST, this, aErr );  
   241         return;
   290     BtTraceBtAddr1( TRACE_DEBUG, DUMMY_DEVLIST, "device addr=", aAddr );
   242     }
   291     if ( mBtEngAddr != aAddr || !mActiveHandling ) { 
   243     DisplayCommandCompleteNotif(aErr);
   292         BOstraceFunctionExit1( DUMMY_DEVLIST, this );
   244     disconnectServiceLevelCompleted(aErr);    
   293         return;
       
   294     }
       
   295     disconnectServiceLevelCompleted(aErr);  
       
   296     BOstraceFunctionExit1( DUMMY_DEVLIST, this );
   245 }
   297 }
   246 
   298 
   247 
   299 
   248 void BtDelegateDisconnect::cancel()
   300 void BtDelegateDisconnect::cancel()
   249 {
   301 {
   250     
   302     BOstraceFunctionEntry1( DUMMY_DEVLIST, this );  
   251 }
   303     BOstraceFunctionExit1( DUMMY_DEVLIST, this );
   252 
   304 }
   253 void BtDelegateDisconnect::HandleCreateConnectionCompleteL( TInt err ){
   305 
       
   306 void BtDelegateDisconnect::HandleCreateConnectionCompleteL( TInt err )
       
   307 {
       
   308     BOstraceFunctionEntryExt( DUMMY_DEVLIST, this, err );   
   254     Q_UNUSED( err );
   309     Q_UNUSED( err );
   255 }
   310     BOstraceFunctionExit1( DUMMY_DEVLIST, this );
   256 
   311 }
   257 void BtDelegateDisconnect::HandleDisconnectCompleteL( TInt err ){
   312 
   258     if ( !mActiveHandling ) {  
   313 // callback for CBluetoothPhysicalLinks::Disconnect()
       
   314 void BtDelegateDisconnect::HandleDisconnectCompleteL( TInt err )
       
   315 {
       
   316     BOstraceFunctionEntryExt( DUMMY_DEVLIST, this, err );  
       
   317     if ( !mActiveHandling ) {
       
   318         BOstraceFunctionExit1( DUMMY_DEVLIST, this );
   259         return;
   319         return;
   260     } 
   320     } 
   261     disconnectPhysicalLinkCompleted(err);
   321     disconnectPhysicalLinkCompleted(err);
   262           
   322     BOstraceFunctionExit1( DUMMY_DEVLIST, this );
   263 }
   323 }
   264 
   324 
   265 void BtDelegateDisconnect::HandleDisconnectAllCompleteL( TInt err ){
   325 // callback for CBluetoothPhysicalLinks::DisconnectAll()
       
   326 void BtDelegateDisconnect::HandleDisconnectAllCompleteL( TInt err )
       
   327 {
       
   328     BOstraceFunctionEntryExt( DUMMY_DEVLIST, this, err );   
   266     Q_UNUSED( err );
   329     Q_UNUSED( err );
   267 }
   330     BOstraceFunctionExit1( DUMMY_DEVLIST, this );
   268 
   331 }
   269 void BtDelegateDisconnect::DisplayCommandCompleteNotif(int error)
   332 
   270 {
   333 
   271     
   334 
   272     if(error == KErrNone) {
   335 
   273         // success, show indicator with connection status
       
   274         HbIcon icon = getBadgedDeviceTypeIcon( mCod, mMajorRole, 0 );  // no badging required, only icon
       
   275         QString str( hbTrId("txt_bt_dpopinfo_disconnected_from_1") );
       
   276         HbNotificationDialog::launchDialog( icon, hbTrId("txt_bt_dpophead_disconnected"), 
       
   277             str.arg(mDeviceName) );  
       
   278     }
       
   279 	
       
   280 }
       
   281 
       
   282