00001 /*! 00002 * \file 00003 * X-Forge Engine <br> 00004 * Copyright 2000-2002 Fathammer Ltd 00005 * 00006 * \brief Default implementation for a Bluetooth communication manager. 00007 * 00008 * $Id: XFuBluetoothNetwork.cpp,v 1.14 2003/10/15 07:56:53 slehti Exp $ 00009 * $Date: 2003/10/15 07:56:53 $ 00010 * $Revision: 1.14 $ 00011 */ 00012 00013 #include <xforge.h> 00014 00015 #include <xfcore/net/XFcBtHandler.h> 00016 #include <xfcore/net/XFcBtClientWin.h> 00017 #include <xfcore/net/XFcObjectDataFrame.h> 00018 #include <xfcore/net/XFcCommunicationScheduler.h> 00019 #include <xfcore/net/XFcCommunicationConstants.h> 00020 #include <xfcore/net/socket/XFcSocketConstants.h> 00021 #include <xfcore/net/socket/XFcBtAddress.h> 00022 #include <xfcore/net/XFcUnknownSender.h> 00023 #include <xfcore/net/XFcClientLost.h> 00024 #include <xfcore/net/XFcDataReceiver.h> 00025 #include <xfcore/net/XFcObjectDataFrame.h> 00026 #include <xfcore/net/socket/XFcHostEntry.h> 00027 #include <xfcore/net/socket/XFcBtHostResolver.h> 00028 #include <xfcore/net/socket/XFcBtAdvertiser.h> 00029 #include <xfcore/net/XFcUdpEngine.h> 00030 #include <xfcore/net/socket/XFcBtCommService.h> 00031 #include <xfcore/net/socket/XFcBtServerSearch.h> 00032 #include <xfcore/net/socket/XFcName.h> 00033 #include <xfutil/XFuSerializable.h> 00034 #include <xfutil/XFuNetwork.h> 00035 #include <xfutil/XFuNetworkEventHandler.h> 00036 #include <xfutil/XFuBluetoothNetwork.h> 00037 00038 00039 XFuBluetoothNetwork * XFuBluetoothNetwork::create() 00040 { 00041 XFuBluetoothNetwork * manager = new XFuBluetoothNetwork; 00042 if (manager != NULL && !manager->init()) 00043 { 00044 delete manager; 00045 return NULL; 00046 } 00047 return manager; 00048 } 00049 00050 00051 XFuBluetoothNetwork::XFuBluetoothNetwork() 00052 { 00053 mNetworkEventHandlers = NULL; 00054 mCommunicationScheduler = NULL; 00055 mCommunicationHandler = NULL; 00056 mDefaultDataReceiver = NULL; 00057 mHostResolver = NULL; 00058 mCommunicationService = NULL; 00059 00060 mAcceptGameToken = 0; 00061 mCommunicationHandlerId = -1; 00062 mGamePort = 0; 00063 mClientId = -1; 00064 mClient = NULL; 00065 mService = NULL; 00066 mBtServerSearch = NULL; 00067 } 00068 00069 00070 XFuBluetoothNetwork::~XFuBluetoothNetwork() 00071 { 00072 closeService(); 00073 deleteAllClients(); 00074 removeAllEventHandlers(); 00075 00076 delete mService; 00077 delete mHostResolver; 00078 delete mNetworkEventHandlers; 00079 delete mCommunicationHandler; 00080 delete mBtServerSearch; 00081 } 00082 00083 00084 INT XFuBluetoothNetwork::init() 00085 { 00086 mCommunicationScheduler = (XFcCommunicationScheduler *)XFcCore::getCommunicationScheduler(); 00087 if (mNetworkEventHandlers == NULL) 00088 mNetworkEventHandlers = XFuDynamicArray<XFuNetworkEventHandler*>::create(5); 00089 00090 if (mCommunicationScheduler == NULL || 00091 mNetworkEventHandlers == NULL) return 0; 00092 00093 return 1; 00094 00095 } 00096 00097 00098 void XFuBluetoothNetwork::runCommunicationScheduler() 00099 { 00100 mCommunicationScheduler->runScheduler(); 00101 } 00102 00103 00104 void XFuBluetoothNetwork::reset() 00105 { 00106 closeService(); 00107 deleteAllClients(); 00108 removeAllEventHandlers(); 00109 mAcceptGameToken = 0; 00110 init(); 00111 00112 } 00113 00114 00115 INT XFuBluetoothNetwork::initEnable(UINT16 aPort, INT aIsServer) 00116 { 00117 closeService(); 00118 deleteAllClients(); 00119 00120 mService = XFcBtCommService::create(); 00121 mGamePort = aPort; 00122 00123 // Are we Bluetooth server, bt-slave. 00124 if (aIsServer) 00125 { 00126 if (aPort == 0 && mService) 00127 mGamePort = mService->getFirstFreeRFCOMMPort(); 00128 } 00129 else 00130 { 00131 // Create piconet. Works only with master device. 00132 mService->createPiconet(); 00133 mService->lockPiconet(); 00134 } 00135 00136 if (mGamePort == XFCNET_NOT_SUPPORTED) 00137 mGamePort = 0; 00138 00139 mCommunicationHandler = XFcBtHandler::create(aIsServer); 00140 00141 return (mCommunicationHandler && mService) ? 1 : 0; 00142 } 00143 00144 00145 INT XFuBluetoothNetwork::enableClientService() 00146 { 00147 INT error = 0; 00148 00149 if (initEnable(0, 0)) 00150 { 00151 mCommunicationHandler->setUnknownSenderHandler(this); 00152 mCommunicationHandler->setClientLost(this); 00153 00154 mCommunicationHandlerId = mCommunicationScheduler->addCommunicationHandler(mCommunicationHandler); 00155 error = 1; 00156 } 00157 return error; 00158 } 00159 00160 00161 INT XFuBluetoothNetwork::enableServerService(UINT16 aPort) 00162 { 00163 XFcBtAddress *address = XFcBtAddress::create(); 00164 XFcBtClientWin *client = XFcBtClientWin::create(NULL); 00165 00166 if (address && client && initEnable(aPort, 1)) 00167 { 00168 00169 address->setPort(mGamePort); 00170 00171 // Max client count must be more than 1 00172 INT32 maxClients = 2; 00173 00174 // Open server, will return 1 if success else 0 00175 if (mCommunicationHandler->openServer(*address, maxClients)) 00176 { 00177 mCommunicationHandler->setUnknownSenderHandler(this); 00178 mCommunicationHandler->setClientLost(this); 00179 00180 00181 mCommunicationHandlerId = mCommunicationScheduler->addCommunicationHandler(mCommunicationHandler); 00182 mCommunicationHandler->listenConnection(*client); 00183 00184 INT32 clientId = mCommunicationScheduler->addClient(client); 00185 00186 if (clientId != XFCNET_CLIENTADD_ERROR) 00187 { 00188 00189 mClient = client; 00190 mClientId = clientId; 00191 delete address; 00192 address = NULL; 00193 00194 return 1; 00195 } 00196 } 00197 } 00198 delete address; 00199 address = NULL; 00200 delete client; 00201 client = NULL; 00202 00203 mClient = NULL; 00204 mClientId = -1; 00205 return 0; 00206 } 00207 00208 00209 void XFuBluetoothNetwork::closeService() 00210 { 00211 // Unlock and destroy piconet if any. 00212 mService->unlockPiconet(); 00213 mService->destroyPiconet(); 00214 00215 stopDeviceDiscovery(); 00216 stopServerDiscovery(); 00217 stopAdvertiser(); 00218 00219 if (mCommunicationHandler != NULL) 00220 { 00221 mCommunicationHandler->closeService(); 00222 mCommunicationScheduler->removeCommunicationHandler(mCommunicationHandlerId); 00223 delete mCommunicationHandler; 00224 mCommunicationHandler = NULL; 00225 } 00226 delete mService; 00227 mService = NULL; 00228 } 00229 00230 00231 UINT32 XFuBluetoothNetwork::getAcceptGameToken() 00232 { 00233 return mAcceptGameToken; 00234 } 00235 00236 00237 void XFuBluetoothNetwork::setAcceptGameToken(UINT32 aAcceptGameToken) 00238 { 00239 mAcceptGameToken = aAcceptGameToken; 00240 } 00241 00242 00243 void XFuBluetoothNetwork::sendGameConnectPacket(INT32 aClientId, UINT32 aGameToken) 00244 { 00245 XFcObjectDataFrame *frame = getPacketFrame(aClientId, XFCNET_NONGUARANTEED); 00246 if (frame) 00247 { 00248 frame->setReceiverId(0); 00249 void *buffer = frame->lock(); 00250 if (buffer) 00251 { 00252 memcpy(buffer, &aGameToken, 4); 00253 frame->setPacketSize(4); 00254 } 00255 frame->unlock(); 00256 } 00257 } 00258 00259 00260 void XFuBluetoothNetwork::deleteAllClients() 00261 { 00262 if (!mClient) 00263 return; 00264 00265 if (!mCommunicationScheduler) 00266 return; 00267 00268 mCommunicationScheduler->removeClient(mClientId); 00269 mClient->deinitializeClient(); 00270 delete mClient; 00271 mClient = NULL; 00272 mClientId = -1; 00273 } 00274 00275 00276 void XFuBluetoothNetwork::removeAllClients() 00277 { 00278 if (!mCommunicationHandler) 00279 return; 00280 00281 removeClient(mClientId); 00282 } 00283 00284 00285 XFcDataReceiver * XFuBluetoothNetwork::getDefaultDataReceiver() 00286 { 00287 return mDefaultDataReceiver; 00288 } 00289 00290 00291 void XFuBluetoothNetwork::setDefaultDataReceiver(XFcDataReceiver *aReceiver) 00292 { 00293 mDefaultDataReceiver = aReceiver; 00294 mCommunicationScheduler->setDataReceiver(aReceiver); 00295 } 00296 00297 00298 XFcDataReceiver * XFuBluetoothNetwork::getDataReceiver(UINT32 aId) 00299 { 00300 return mCommunicationScheduler->getDataReceiver(aId); 00301 } 00302 00303 00304 INT XFuBluetoothNetwork::addDataReceiver(UINT32 aId, XFcDataReceiver *aReceiver) 00305 { 00306 return mCommunicationScheduler->addDataReceiver(aId, aReceiver); 00307 } 00308 00309 00310 XFcDataReceiver * XFuBluetoothNetwork::removeDataReceiver(UINT32 aId) 00311 { 00312 return mCommunicationScheduler->removeDataReceiver(aId); 00313 } 00314 00315 00316 void XFuBluetoothNetwork::addEventHandler(XFuNetworkEventHandler *aHandler) 00317 { 00318 mNetworkEventHandlers->put(aHandler); 00319 } 00320 00321 00322 void XFuBluetoothNetwork::removeEventHandler(XFuNetworkEventHandler *aHandler) 00323 { 00324 mNetworkEventHandlers->remove(aHandler); 00325 } 00326 00327 00328 void XFuBluetoothNetwork::removeAllEventHandlers() 00329 { 00330 while (!mNetworkEventHandlers->isEmpty()) mNetworkEventHandlers->remove(); 00331 } 00332 00333 00334 XFcClientCommWin * XFuBluetoothNetwork::getClient(INT32 /*aClientId*/) 00335 { 00336 return mClient; 00337 } 00338 00339 00340 INT32 XFuBluetoothNetwork::addClient(XFcAddress *aAddress, INT32 /*aTimeoutTime*/) 00341 { 00342 XFcBtClientWin *client = NULL; 00343 INT32 clientId = -1; 00344 00345 if (!aAddress) 00346 return -1; 00347 00348 if ((client = XFcBtClientWin::create(aAddress)) == NULL) 00349 return -1; 00350 00351 switch (aAddress->getType()) 00352 { 00353 case XFCNET_AFBT: 00354 if (client->openClient() != -1) 00355 { 00356 clientId = mCommunicationScheduler->addClient(client); 00357 if (clientId != XFCNET_CLIENTADD_ERROR && clientId != XFCNET_ERROR) 00358 { 00359 mClient = client; 00360 } 00361 } 00362 00363 break; 00364 default: 00365 XFcCore::systemPanic(XFCSTR("This address type is not supported")); 00366 break; 00367 } 00368 00369 if (clientId == -1) 00370 delete client; 00371 00372 mClientId = clientId; 00373 return clientId; 00374 } 00375 00376 00377 void XFuBluetoothNetwork::removeClient(INT32 aClientId) 00378 { 00379 INT32 cId = 0; 00380 00381 // If communication handler is not created we do not have anything to do. 00382 if (!mCommunicationHandler) 00383 return; 00384 00385 if (mClient == NULL) 00386 return; 00387 00388 // Remove client and deinitialize it 00389 mCommunicationScheduler->removeClient(aClientId); 00390 mClient->deinitializeClient(); 00391 00392 delete mClient; 00393 mClient = NULL; 00394 mClientId = -1; 00395 00396 // Listening client is created to backbuffer for incoming connections. 00397 // If client is removed we create new for new connection. 00398 if (mCommunicationHandler->isServer()) 00399 { 00400 XFcBtClientWin *client = NULL; 00401 if ((client = XFcBtClientWin::create(NULL)) != NULL) 00402 { 00403 mCommunicationHandler->listenConnection(*client); 00404 cId = mCommunicationScheduler->addClient(client); 00405 00406 if (cId != XFCNET_CLIENTADD_ERROR && cId != XFCNET_ERROR) 00407 { 00408 mClientId = cId; 00409 mClient = client; 00410 } 00411 else 00412 XFcCore::systemPanic(XFCSTR("removeClient(), add client")); 00413 } 00414 else 00415 XFcCore::systemPanic(XFCSTR("removeClient(), new listener")); 00416 } 00417 } 00418 00419 00420 INT32 XFuBluetoothNetwork::getRoundTripTime(INT32 aClientId) 00421 { 00422 return mCommunicationScheduler->getRoundTripTime(aClientId); 00423 } 00424 00425 00426 XFcObjectDataFrame * XFuBluetoothNetwork::getPacketFrame(INT32 aClientId, XFCNET_MESSAGE_SLOT aSlot) 00427 { 00428 return mCommunicationScheduler->getPacketFrame(aClientId, aSlot); 00429 } 00430 00431 00432 XFcObjectDataFrame * XFuBluetoothNetwork::getRecentStateFrame(INT32 aClientId, INT32 aRecentId) 00433 { 00434 return mCommunicationScheduler->getRecentStateFrame(aClientId, aRecentId); 00435 } 00436 00437 00438 void XFuBluetoothNetwork::removeRecentStateFrame(INT32 aClientId, INT32 aRecentId) 00439 { 00440 mCommunicationScheduler->removeRecentStateFrame(aClientId, aRecentId); 00441 } 00442 00443 00444 INT32 XFuBluetoothNetwork::send(INT32 aClientId, UINT32 aReceiverId, XFCNET_MESSAGE_SLOT aSlot, XFuSerializable *aSerializable) 00445 { 00446 XFcObjectDataFrame *frame = getPacketFrame(aClientId, aSlot); 00447 INT32 size = -1; 00448 if (frame) 00449 { 00450 00451 void *buffer = frame->lock(); 00452 if (buffer) 00453 { 00454 size = aSerializable->serialize((CHAR8*)buffer, frame->sizeofBuffer()); 00455 // If size is set to -1 XForge does not send the frame and frame is released. 00456 frame->setPacketSize(size); 00457 frame->setReceiverId(aReceiverId); 00458 00459 } 00460 frame->unlock(); 00461 } 00462 return size; 00463 } 00464 00465 00466 INT32 XFuBluetoothNetwork::sendRecentState(INT32 aClientId, UINT32 aReceiverId, INT32 aRecentId, XFuSerializable *aSerializable) 00467 { 00468 XFcObjectDataFrame *frame = getRecentStateFrame(aClientId, aRecentId); 00469 INT32 size = -1; 00470 00471 if (frame) 00472 { 00473 void *buffer = frame->lock(); 00474 if (buffer) 00475 { 00476 size = aSerializable->serialize((CHAR8*)buffer, frame->sizeofBuffer()); 00477 frame->setPacketSize(size); 00478 frame->setReceiverId(aReceiverId); 00479 00480 } 00481 frame->unlock(); 00482 } 00483 return size; 00484 } 00485 00486 00487 void XFuBluetoothNetwork::clientLost(INT32 aClientId) 00488 { 00489 removeClient(aClientId); 00490 00491 INT32 handlersNum = mNetworkEventHandlers->size(); 00492 INT32 i; 00493 00494 for (i = 0; i < handlersNum; i++) 00495 { 00496 mNetworkEventHandlers->get(i)->handleClientLost(aClientId); 00497 } 00498 } 00499 00500 00501 INT XFuBluetoothNetwork::handleSender(const void *aAddress, const CHAR8 *aData, INT32 aLen) 00502 { 00503 // Used magic number mAcceptGameToken here. 00504 // Make sure that gameToken is not addjusted with same value than mAcceptGameToken is. 00505 UINT32 gameToken = ~mAcceptGameToken; 00506 00507 if (((XFcAddress *)aAddress)->getType() == (INT32)XFCNET_AFBT && aLen == 4) 00508 { 00509 // Get packet data 00510 memcpy(&gameToken, aData, 4); 00511 00512 // Test if packet data is game connect token packet 00513 if (gameToken == mAcceptGameToken) 00514 { 00515 if (mClient->isClientActive() == XFCNET_BT_LINESTATUS_ONHOLD) 00516 { 00517 // Accept client connection 00518 mClient->acceptConnection(1); 00519 00520 INT32 i; 00521 for (i = 0; i < (INT32)mNetworkEventHandlers->size(); i++) 00522 { 00523 // Notify event handler 00524 mNetworkEventHandlers->get(i)->handleClientAccepted(i); 00525 00526 } 00527 } 00528 } 00529 } 00530 if (((XFcAddress *)aAddress)->getType() != (INT32)XFCNET_AFBT || 00531 aLen != 4 || 00532 gameToken != mAcceptGameToken) 00533 { 00534 00535 if (mClient->isClientActive() == XFCNET_BT_LINESTATUS_ONHOLD) 00536 { 00537 // Disconnect client 00538 mClient->acceptConnection(0); 00539 00540 // Remove client 00541 removeClient(mClientId); 00542 } 00543 } 00544 return 0; 00545 } 00546 00547 00548 INT XFuBluetoothNetwork::startDeviceDiscovery() 00549 { 00550 // Stop device discovery 00551 stopDeviceDiscovery(); 00552 00553 // Delete host resolver 00554 if (!mHostResolver) 00555 mHostResolver = XFcBtHostResolver::create(); 00556 00557 // Do the device discovery, async found devices are returned througth deviceDiscovery callback. 00558 if (mHostResolver) 00559 return (mHostResolver->inquiry(this) == XFCNET_ERROR) ? 0 : 1; 00560 00561 return 0; 00562 } 00563 00564 00565 void XFuBluetoothNetwork::stopDeviceDiscovery() 00566 { 00567 if (mHostResolver) 00568 mHostResolver->cancelInquiry(); 00569 } 00570 00571 00572 INT XFuBluetoothNetwork::startServerDiscovery(const XFcBtUUID &aUuid, const XFcBtAddress *aAddress) 00573 { 00574 INT retval = 0; 00575 00576 if (!mService) 00577 return 0; 00578 00579 mUUID = aUuid; 00580 00581 if (aAddress) 00582 { 00583 // Have to fix this. 00584 XFcAdvertiser *advr = NULL; 00585 if ((advr = XFcBtAdvertiser::create(*aAddress, NULL, 0)) != NULL) 00586 retval = mService->inquiry(*advr, this, &mUUID); 00587 delete advr; 00588 return retval; 00589 } 00590 else 00591 { 00592 delete mBtServerSearch; 00593 if ((mBtServerSearch = XFcBtServerSearch::create()) != NULL) 00594 return (mBtServerSearch->inquiry(this, mUUID) == XFCNET_ERROR) ? 0 : 1; 00595 } 00596 return retval; 00597 } 00598 00599 00600 void XFuBluetoothNetwork::stopServerDiscovery() 00601 { 00602 if (mService) 00603 mService->cancelInquiry(); 00604 00605 if (mBtServerSearch) 00606 mBtServerSearch->cancelInquiry(); 00607 00608 delete mBtServerSearch; 00609 mBtServerSearch = NULL; 00610 } 00611 00612 00613 void XFuBluetoothNetwork::deviceDiscovery(const XFcLinkedList<XFcHostEntry *> &aHostEntry) 00614 { 00615 XFcLinkedList<XFcHostEntry *>::forwardIterator it; 00616 INT32 handlersNum = mNetworkEventHandlers->size(); 00617 INT32 i; 00618 00619 if (aHostEntry.size() != 0) 00620 { 00621 for (it = aHostEntry.forwardBegin(); it != aHostEntry.forwardEnd(); it++) 00622 { 00623 for (i = 0; i < handlersNum; ++i) 00624 mNetworkEventHandlers->get(i)->handleDeviceDiscovered(it.getData()); 00625 } 00626 } 00627 else 00628 { 00629 for (i = 0; i < handlersNum; ++i) 00630 mNetworkEventHandlers->get(i)->handleDeviceDiscovered(NULL); 00631 } 00632 } 00633 00634 00635 void XFuBluetoothNetwork::deviceDiscovery(const XFcLinkedList<XFcAdvertiser *> &aAdvertiser) 00636 { 00637 XFcLinkedList<XFcAdvertiser *>::forwardIterator it; 00638 INT32 handlersNum = mNetworkEventHandlers->size(); 00639 INT32 i; 00640 00641 if (aAdvertiser.size() != 0) 00642 { 00643 for (it = aAdvertiser.forwardBegin(); it != aAdvertiser.forwardEnd(); it++) 00644 { 00645 for (i = 0; i < handlersNum; i++) 00646 mNetworkEventHandlers->get(i)->handleAdvertiseDiscovered(it.getData()); 00647 } 00648 } 00649 else 00650 { 00651 for (i = 0; i < handlersNum; ++i) 00652 mNetworkEventHandlers->get(i)->handleAdvertiseDiscovered(NULL); 00653 } 00654 00655 } 00656 00657 00658 INT XFuBluetoothNetwork::startAdvertiser(const XFcBtUUID &aUuid, const CHAR8 *aMessage) 00659 { 00660 XFcBtAdvertiser *advertise = NULL; 00661 00662 if (!mService) 00663 return 0; 00664 00665 if ((advertise = XFcBtAdvertiser::create()) == NULL) 00666 return 0; 00667 00668 mUUID = aUuid; 00669 00670 // Create default message if not given any 00671 if (aMessage == NULL) 00672 advertise->setMessageHeader("X-Forge server", 14); 00673 else 00674 advertise->setMessageHeader(aMessage, strlen(aMessage)); 00675 00676 // Set game port for advertiser 00677 advertise->setGamePort(mGamePort); 00678 00679 advertise->setAvailability(0xff); // Fully available. 00680 00681 INT error = mService->advertise(*advertise, &mUUID); 00682 00683 delete advertise; 00684 00685 return (error == XFCNET_ERROR) ? 0 : 1; 00686 00687 } 00688 00689 00690 void XFuBluetoothNetwork::stopAdvertiser() 00691 { 00692 if (!mService) 00693 return; 00694 00695 mService->cancelAdvertise(); 00696 } 00697 00698 00699 INT XFuBluetoothNetwork::deviceLocalName(XFcName &aName) 00700 { 00701 // Delete host resolver 00702 if (!mHostResolver) 00703 mHostResolver = XFcBtHostResolver::create(); 00704 00705 // Do the device discovery, async found devices are returned througth deviceDiscovery callback. 00706 if (mHostResolver) 00707 { 00708 INT error = mHostResolver->localName(aName); 00709 00710 if (error != XFCNET_ERROR) 00711 { 00712 if (aName.mLen < 0x40) 00713 aName.mName[aName.mLen] = '\0'; 00714 00715 return 1; 00716 } 00717 } 00718 return 0; 00719 }
![]() | ||||
![]() |
Confidential Copyright © 2002-2003 Fathammer | with doxygen by Dimitri van Heesch |