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