bluetooth/btstack/linkmgr/Subscribers.cpp
changeset 0 29b1cd4cb562
child 11 20fda83a6398
equal deleted inserted replaced
-1:000000000000 0:29b1cd4cb562
       
     1 // Copyright (c) 2003-2009 Nokia Corporation and/or its subsidiary(-ies).
       
     2 // All rights reserved.
       
     3 // This component and the accompanying materials are made available
       
     4 // under the terms of "Eclipse Public License v1.0"
       
     5 // which accompanies this distribution, and is available
       
     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".
       
     7 //
       
     8 // Initial Contributors:
       
     9 // Nokia Corporation - initial contribution.
       
    10 //
       
    11 // Contributors:
       
    12 //
       
    13 // Description:
       
    14 // Implements stack-side objects that subscribe to properties
       
    15 // 
       
    16 //
       
    17 
       
    18 #include <bt_subscribe.h>
       
    19 #include <bt_sock.h>
       
    20 #include <utf.h>
       
    21 #include "Subscribers.h"
       
    22 #include "linkmgr.h"
       
    23 #include "physicallinksmanager.h"
       
    24 
       
    25 CSubscriber::CSubscriber(CLinkMgrProtocol& aLinkMgrProtocol)
       
    26 : CActive(CActive::EPriorityStandard), iParent(aLinkMgrProtocol)
       
    27 	{
       
    28 	CActiveScheduler::Add(this);
       
    29 	}
       
    30 
       
    31 void CSubscriber::DoCancel()
       
    32 	{
       
    33 	iProperty.Cancel();
       
    34 	}
       
    35 
       
    36 CSubscriber::~CSubscriber()
       
    37 	{
       
    38 	Cancel();
       
    39 	iProperty.Close();
       
    40 	}
       
    41 
       
    42 TInt CSubscriber::RunError(TInt /*aError*/)
       
    43 	{
       
    44 	return KErrNone;
       
    45 	}
       
    46 
       
    47 void CSubscriber::ConstructL(const TUint aKey)
       
    48 	{
       
    49 	User::LeaveIfError(iProperty.Attach(KPropertyUidBluetoothCategory,
       
    50 										aKey));
       
    51 	Subscribe();
       
    52 	}
       
    53 
       
    54 void CSubscriber::Subscribe()
       
    55    	{
       
    56    	iProperty.Subscribe(iStatus);
       
    57    	SetActive();
       
    58    	}
       
    59 
       
    60 CDiscoverabilitySubscriber* CDiscoverabilitySubscriber::NewL(CLinkMgrProtocol& aLinkMgrProtocol)
       
    61 	{
       
    62 	CDiscoverabilitySubscriber* s = new(ELeave) CDiscoverabilitySubscriber(aLinkMgrProtocol);
       
    63 	CleanupStack::PushL(s);
       
    64 	s->ConstructL(KPropertyKeyBluetoothSetScanningStatus);
       
    65 	CleanupStack::Pop(s);
       
    66 	return s;
       
    67 	}
       
    68 
       
    69 CDiscoverabilitySubscriber::CDiscoverabilitySubscriber(CLinkMgrProtocol& aLinkMgrProtocol)
       
    70 : CSubscriber(aLinkMgrProtocol)
       
    71 	{
       
    72 	}
       
    73 
       
    74 void CDiscoverabilitySubscriber::RunL()
       
    75 	{
       
    76 	Subscribe();
       
    77 	iParent.SetInquiryAndPageScanningL();
       
    78 	}
       
    79 
       
    80 
       
    81 CLimitedSubscriber* CLimitedSubscriber::NewL(CLinkMgrProtocol& aLinkMgrProtocol)
       
    82 	{
       
    83 	CLimitedSubscriber* s = new(ELeave) CLimitedSubscriber(aLinkMgrProtocol);
       
    84 	CleanupStack::PushL(s);
       
    85 	s->ConstructL(KPropertyKeyBluetoothSetLimitedDiscoverableStatus);
       
    86 	CleanupStack::Pop(s);
       
    87 	return s;
       
    88 	}
       
    89 
       
    90 CLimitedSubscriber::CLimitedSubscriber(CLinkMgrProtocol& aLinkMgrProtocol)
       
    91 : CSubscriber(aLinkMgrProtocol)
       
    92 	{
       
    93 	}
       
    94 
       
    95 void CLimitedSubscriber::RunL()
       
    96 	{
       
    97 	Subscribe();
       
    98 	TBool limited;
       
    99 	iProperty.Get(limited);
       
   100 	iParent.SetLimitedDiscoverableIfChangedL(limited);
       
   101 	}
       
   102 
       
   103 //-----------------
       
   104 
       
   105 CDeviceClassSubscriber* CDeviceClassSubscriber::NewL(CLinkMgrProtocol& aLinkMgrProtocol)
       
   106 	{
       
   107 	CDeviceClassSubscriber* s = new(ELeave) CDeviceClassSubscriber(aLinkMgrProtocol);
       
   108 	CleanupStack::PushL(s);
       
   109 	s->ConstructL(KPropertyKeyBluetoothSetDeviceClass);
       
   110 	CleanupStack::Pop(s);
       
   111 	return s;
       
   112 	}
       
   113 
       
   114 CDeviceClassSubscriber::CDeviceClassSubscriber(CLinkMgrProtocol& aLinkMgrProtocol)
       
   115 : CSubscriber(aLinkMgrProtocol)
       
   116 	{
       
   117 	}
       
   118 
       
   119 void CDeviceClassSubscriber::RunL()
       
   120 	{
       
   121 	Subscribe();
       
   122 	TInt cod;
       
   123 	iProperty.Get(cod);
       
   124 	iParent.SetDeviceClassL(static_cast<TUint32>(cod));
       
   125 	}
       
   126 
       
   127 //-----------------
       
   128 
       
   129 CDeviceNameSubscriber* CDeviceNameSubscriber::NewL(CLinkMgrProtocol& aLinkMgrProtocol)
       
   130 	{
       
   131 	CDeviceNameSubscriber* s = new(ELeave) CDeviceNameSubscriber(aLinkMgrProtocol);
       
   132 	CleanupStack::PushL(s);
       
   133 	s->ConstructL(KPropertyKeyBluetoothSetDeviceName);
       
   134 	CleanupStack::Pop(s);
       
   135 	return s;
       
   136 	}
       
   137 
       
   138 CDeviceNameSubscriber::CDeviceNameSubscriber(CLinkMgrProtocol& aLinkMgrProtocol)
       
   139 : CSubscriber(aLinkMgrProtocol)
       
   140 	{
       
   141 	}
       
   142 
       
   143 void CDeviceNameSubscriber::RunL()
       
   144 	{
       
   145 	Subscribe();
       
   146 	
       
   147 	// The P&S value is in Unicode for the convenience of clients ...
       
   148 	TBuf16<KHCILocalDeviceNameMaxLength> unicodeName;
       
   149 	iProperty.Get(unicodeName);
       
   150 	
       
   151 	// ... but the BT spec requires the device name in UTF-8 so do the conversion here:
       
   152 	TBuf8<KHCILocalDeviceNameMaxLength> utf8Name;
       
   153 	TInt ret = CnvUtfConverter::ConvertFromUnicodeToUtf8(utf8Name, unicodeName);
       
   154 
       
   155 	// ret should never be > 0 since unicodeName is the same size as utf8Name hence we 
       
   156 	// shouldn't have any unconverted chars left over.
       
   157 	if (ret == KErrNone)
       
   158 		{
       
   159 		iParent.SetLocalDeviceName(utf8Name);
       
   160 		}
       
   161 	else
       
   162 		{
       
   163 		// Set the P&S key with the old value so that clients can figure out their set failed.
       
   164 		TBuf16<KHCILocalDeviceNameMaxLength> oldUnicodeName;
       
   165 		RProperty::Get(KPropertyUidBluetoothCategory, KPropertyKeyBluetoothGetDeviceName, oldUnicodeName);
       
   166 		RProperty::Set(KPropertyUidBluetoothCategory, KPropertyKeyBluetoothGetDeviceName, oldUnicodeName);
       
   167 		}
       
   168 	}
       
   169 
       
   170 //-----------------
       
   171 
       
   172 CAFHChannelAssessmentModeSubscriber* CAFHChannelAssessmentModeSubscriber::NewL(CLinkMgrProtocol& aLinkMgrProtocol)
       
   173 	{
       
   174 	CAFHChannelAssessmentModeSubscriber* s = new(ELeave) CAFHChannelAssessmentModeSubscriber(aLinkMgrProtocol);
       
   175 	CleanupStack::PushL(s);
       
   176 	s->ConstructL(KPropertyKeyBluetoothSetAFHChannelAssessmentMode);
       
   177 	CleanupStack::Pop(s);
       
   178 	return s;
       
   179 	}
       
   180 
       
   181 CAFHChannelAssessmentModeSubscriber::CAFHChannelAssessmentModeSubscriber(CLinkMgrProtocol& aLinkMgrProtocol)
       
   182 : CSubscriber(aLinkMgrProtocol)
       
   183 	{
       
   184 	}
       
   185 
       
   186 void CAFHChannelAssessmentModeSubscriber::RunL()
       
   187 	{
       
   188 	//Get this value first before we subscribe again
       
   189 	TInt ret = iStatus.Int();
       
   190 	Subscribe();
       
   191 	if(ret==KErrNone)
       
   192 		{
       
   193 		TInt mode;
       
   194 		ret = iProperty.Get(mode);
       
   195 		if(ret==KErrNone)
       
   196 			{
       
   197 			iParent.SetAFHChannelAssessmentModeL(static_cast<TBool>(mode));
       
   198 			}
       
   199 		}
       
   200 	}
       
   201 
       
   202 
       
   203 //-----------------
       
   204 
       
   205 CAFHHostChannelClassificationSubscriber* CAFHHostChannelClassificationSubscriber::NewL(CLinkMgrProtocol& aLinkMgrProtocol)
       
   206 	{
       
   207 	CAFHHostChannelClassificationSubscriber* s = new(ELeave) CAFHHostChannelClassificationSubscriber(aLinkMgrProtocol);
       
   208 	CleanupStack::PushL(s);
       
   209 	s->ConstructL(KPropertyKeyBluetoothSetAFHHostChannelClassification);
       
   210 	CleanupStack::Pop(s);
       
   211 	return s;
       
   212 	}
       
   213 
       
   214 CAFHHostChannelClassificationSubscriber::CAFHHostChannelClassificationSubscriber(CLinkMgrProtocol& aLinkMgrProtocol)
       
   215 : CSubscriber(aLinkMgrProtocol)
       
   216 	{
       
   217 	}
       
   218 
       
   219 void CAFHHostChannelClassificationSubscriber::RunL()
       
   220 	{
       
   221 	//Get this value first before we subscribe again
       
   222 	TInt ret = iStatus.Int();
       
   223 	Subscribe();
       
   224 	if(ret==KErrNone)
       
   225 		{
       
   226 		TBTAFHHostChannelClassification classification;
       
   227 		ret = iProperty.Get(classification);
       
   228 		if(ret==KErrNone)
       
   229 			{
       
   230 			iParent.SetAFHHostChannelClassificationL(classification);
       
   231 			}
       
   232 		}
       
   233 	}
       
   234 
       
   235 //-----------------
       
   236 
       
   237 CRegistryRemoteTableSubscriber* CRegistryRemoteTableSubscriber::NewL(CLinkMgrProtocol& aLinkMgrProtocol)
       
   238 	{
       
   239 	CRegistryRemoteTableSubscriber* s = new(ELeave) CRegistryRemoteTableSubscriber(aLinkMgrProtocol);
       
   240 	CleanupStack::PushL(s);
       
   241 	s->ConstructL(KPropertyKeyBluetoothGetRegistryTableChange);
       
   242 	CleanupStack::Pop(s);
       
   243 	return s;
       
   244 	}
       
   245 
       
   246 CRegistryRemoteTableSubscriber::CRegistryRemoteTableSubscriber(CLinkMgrProtocol& aLinkMgrProtocol)
       
   247 : CSubscriber(aLinkMgrProtocol)
       
   248 	{
       
   249 	}
       
   250 
       
   251 void CRegistryRemoteTableSubscriber::RunL()
       
   252 	{
       
   253 	//Get this value first before we subscribe again
       
   254 	TInt ret = iStatus.Int();
       
   255 	Subscribe();
       
   256 	
       
   257 	if(ret==KErrNone)
       
   258 		{
       
   259 		// To accommodate race conditions, do this whichever table has been updated.
       
   260 		iParent.PhysicalLinksMgr().UpdateRemoteDevicesDetails();
       
   261 		}
       
   262 	}
       
   263 
       
   264 //-----------------
       
   265 
       
   266 CAcceptPairedOnlySubscriber* CAcceptPairedOnlySubscriber::NewL(CLinkMgrProtocol& aLinkMgrProtocol)
       
   267 	{
       
   268 	CAcceptPairedOnlySubscriber* s = new(ELeave) CAcceptPairedOnlySubscriber(aLinkMgrProtocol);
       
   269 	CleanupStack::PushL(s);
       
   270 	s->ConstructL(KPropertyKeyBluetoothSetAcceptPairedOnlyMode);
       
   271 	CleanupStack::Pop(s);
       
   272 	return s;
       
   273 	}
       
   274 
       
   275 CAcceptPairedOnlySubscriber::CAcceptPairedOnlySubscriber(CLinkMgrProtocol& aLinkMgrProtocol)
       
   276 : CSubscriber(aLinkMgrProtocol)
       
   277 	{
       
   278 	}
       
   279 
       
   280 void CAcceptPairedOnlySubscriber::RunL()
       
   281 	{
       
   282 	//Get this value first before we subscribe again
       
   283 	TInt ret = iStatus.Int();
       
   284 	Subscribe();
       
   285 	
       
   286 	if(ret==KErrNone)
       
   287 		{
       
   288 		TInt acceptPairedOnlyMode;
       
   289 		ret = iProperty.Get(acceptPairedOnlyMode);
       
   290 		if(ret==KErrNone)
       
   291 			{
       
   292 			iParent.PhysicalLinksMgr().SetAcceptPairedOnlyMode(static_cast<TBool>(acceptPairedOnlyMode));
       
   293 			}
       
   294 		}
       
   295 	}
       
   296 
       
   297 
       
   298 //-----------------
       
   299 
       
   300 CDebugModeSubscriber* CDebugModeSubscriber::NewL(CLinkMgrProtocol& aLinkMgrProtocol)
       
   301 	{
       
   302 	CDebugModeSubscriber* s = new(ELeave) CDebugModeSubscriber(aLinkMgrProtocol);
       
   303 	CleanupStack::PushL(s);
       
   304 	s->ConstructL(KPropertyKeyBluetoothSetSimplePairingDebugMode);
       
   305 	CleanupStack::Pop(s);
       
   306 	return s;
       
   307 	}
       
   308 
       
   309 CDebugModeSubscriber::CDebugModeSubscriber(CLinkMgrProtocol& aLinkMgrProtocol)
       
   310 	: CSubscriber(aLinkMgrProtocol)
       
   311 	{
       
   312 	}
       
   313 
       
   314 void CDebugModeSubscriber::RunL()
       
   315 	{
       
   316 	//Get this value first before we subscribe again
       
   317 	TInt ret = iStatus.Int();
       
   318 	Subscribe();
       
   319 	
       
   320 	if(ret==KErrNone)
       
   321 		{
       
   322 		TInt debugMode;
       
   323 		ret = iProperty.Get(debugMode);
       
   324 		if(ret==KErrNone)
       
   325 			{
       
   326 			iParent.PhysicalLinksMgr().SetSimplePairingDebugMode(static_cast<TBool>(debugMode));
       
   327 			}
       
   328 		}
       
   329 	}
       
   330 
       
   331