Main Page   Class Hierarchy   Alphabetical List   Compound List   File List   Compound Members   File Members   Related Pages  

XFuBluetoothNetwork.cpp

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

   
X-Forge Documentation
Confidential
Copyright © 2002-2003 Fathammer
   
Documentation generated
with doxygen
by Dimitri van Heesch