test-manager.cpp

Go to the documentation of this file.

/*
 * test-manager.cpp
 *
 * Copyright (C) 2010  Thomas A. Vaughan
 * All rights reserved.
 *
 * Simple test of the gamepad::Manager object.
 */

// includes --------------------------------------------------------------------
#include <iostream>
#include <signal.h>

#include "gamepad/manager.h"
#include "perf/perf.h"
#include "threadsafe/threadsafe.h"


// map from source device unique ID --> gamepad
//  (limitation here: only support 1 gamepad per source device!)
typedef std::map<std::string, smart_ptr<gamepad::Gamepad> > gamepad_map_t;

static bool s_keepLooping               = true;


////////////////////////////////////////////////////////////////////////////////
//
//      static methods
//
////////////////////////////////////////////////////////////////////////////////

static void
handleSignal
(
IN int sig
)
{
        s_keepLooping = false;
}



static smart_ptr<gamepad::Gamepad>
createDefaultGamepad
(
IN gamepad::Manager * mgr,
IN smart_ptr<gamepad::SourceDevice>& device
)
{
        perf::Timer timer("createDefaultGamepad");
        ASSERT(mgr, "null");
        ASSERT(device, "null");

        DPRINTF("Looking for a default gamepad mapping for device: '%s'",
            device->getPublicName());

        VecString mapNames;
        gamepad::getRecommendedMappings(mgr, device, mapNames);
        DPRINTF("  Found %d recommended mappings", (int) mapNames.size());
        if (!mapNames.size()) {
                DPRINTF("  Source device not recognized!  Skipping...");
                return NULL;
        }

        const char * name = mapNames[0].c_str();
        ASSERT(name, "null");
        DPRINTF("  Using the first recommended mapping: %s", name);

        smart_ptr<gamepad::Map> mapping = mgr->getMapping(name);
        if (!mapping) {
                DPRINTF("  Mapping not found!  Skipping...");
                return NULL;
        }

        DPRINTF("  Found mapping: %s", mapping->getName());

        // okay, create gamepad
        smart_ptr<gamepad::Gamepad> gpad;
        gamepad::Manager::eResult result =
            mgr->createGamepad(device, mapping, gpad);
        if (gamepad::Manager::eResult_Success != result) {
                DPRINTF("  Gamepad create attempt failed!");
                switch (result) {
                case gamepad::Manager::eResult_BadSource:
                        DPRINTF("  Source device is bad/gone.");
                        break;
                case gamepad::Manager::eResult_BadMap:
                        DPRINTF("  Mapping is bad");
                        break;
                default:
                        DPRINTF("  Unknown reason: %d", result);
                }
                DPRINTF("  Skipping...");
                return NULL;
        }
        ASSERT_THROW(gpad, "failed to create gamepad object");
        return gpad;
}



static void
printButtons
(
IN gamepad::buttons_t buttons,
IN const gamepad::Type * type
)
{
        ASSERT(type, "null");

        // this is very slow!  Fine for a demo, but for real programs you'll
        // want to precompute most of these bit masks so you can use quick bit
        // tests rather than loops.
        char buffer[128];

        std::string output;
        int nMax = type->getInputCount(gamepad::eInput_Button);
        int bitmask = 1;
        for (int i = 0; i < nMax; ++i, bitmask *= 2) {
                if (buttons & bitmask) {
                        // button i is pressed!  What is its name?
                        const char * name =
                            type->getLogicalName(gamepad::eInput_Button, i);

                        sprintf(buffer, " %s", name);
                        output += buffer;
                }
        }
        DPRINTF("  buttons: %s", output.c_str());
}



static void
doTest
(
IN const char * dataDir
)
{
        ASSERT(dataDir, "null");

        // create nstream::Folder for data directory
        smart_ptr<nstream::Manager> fsMgr =
            nstream::getFilesystemManager(dataDir);
        ASSERT_THROW(fsMgr,
            "Failed to open filesystem manager for data directory: " <<
            dataDir);
        smart_ptr<nstream::Folder> root = fsMgr->getRoot();
        ASSERT(root, "null");
        smart_ptr<gamepad::Manager> mgr = gamepad::Manager::create(root);
        ASSERT_THROW(mgr, "failed to create gamepad manager?");

        int nSDevs = mgr->getSourceDeviceCount();
        DPRINTF("Found %d source devices", nSDevs);

        mgr->rediscover();
        nSDevs = mgr->getSourceDeviceCount();
        DPRINTF("Found %d source devices", nSDevs);
        ASSERT_THROW(nSDevs > 0, "No source devices!");

        int nSDevs2 = mgr->getSourceDeviceCount();
        DPRINTF("Found %d source devices (again)", nSDevs2);
        ASSERT_THROW(nSDevs == nSDevs2, "found different number of devices?");

        smart_ptr<gamepad::SourceDevice> device = mgr->getSourceDevice(0);
        ASSERT_THROW(device, "failed to acquire first device");

        device = mgr->getSourceDevice(nSDevs - 1);
        ASSERT_THROW(device, "failed to acquire last device");

        int nTypes = mgr->getTypeCount();
        DPRINTF("Found %d types", nTypes);
        for (int i = 0; i < nTypes; ++i) {
                smart_ptr<gamepad::Type> type = mgr->getType(i);
                ASSERT_THROW(type, "failed to acquire type " << i);
        }

        int nMaps = mgr->getMappingCount();
        DPRINTF("Found %d mappings", nMaps);

        for (int i = 0; i < nMaps; ++i) {
                smart_ptr<gamepad::Map> map = mgr->getMapping(i);
                ASSERT_THROW(map, "Failed to acquire mapping " << i);
        }

        // now loop and keep looking for gamepads/devices
        // NOTE: this isn't a perfect example!  In an attempt to avoid
        //   additional UI concerns, I haven't supported multiple gampepads
        //   per source device.  In the real world, you'll want to do that.
        //   There are a lot of USB devices that support multiple gamepads.
        const int desiredHz = 100;
        long msSleep = 1000 / desiredHz;
        DPRINTF("Want sampling at %d Hz, so polling every %d ms",
            desiredHz, (int) msSleep);

        // how often do we poll for new devices?
        const int deviceHz = 2;
        const int checkCounter = desiredHz / deviceHz;
        DPRINTF("Will look for new source devices every %d iterations",
            checkCounter);
        int counter = 0;

        // now loop
        gamepad_map_t gamepads;
        while (s_keepLooping) {
                sleepMilliseconds(msSleep);

                ++counter;
                if (!(counter % checkCounter)) {
                        mgr->rediscover();
                        int newCount = mgr->getSourceDeviceCount();
                        if (newCount != nSDevs) {
                                DPRINTF("Device count: %d", newCount);
                        }
                        nSDevs = newCount;

                        // loop through all devices and see if we already have a
                        //      gamepad.
                        VecString badIds;
                        for (int i = 0; i < nSDevs; ++i) {
                                smart_ptr<gamepad::SourceDevice> device =
                                    mgr->getSourceDevice(i);
                                ASSERT_THROW(device, "null");
                                const char * id = device->getUniqueId();

                                // is this device gone?
                                if (gamepad::eDevice_Detached == device->getState()) {
                                        badIds.push_back(id);
                                        continue;
                                }

                                // not gone.  Do we already know about it?
                                if (gamepads.end() != gamepads.find(id)) {
                                        continue;       // already have this
                                }

                                // need to create gamepad for this source
                                // device!
                                smart_ptr<gamepad::Gamepad> gpad =
                                    createDefaultGamepad(mgr, device);
                                // ASSERT(gpad) -- can be null!
                                gamepads[id] = gpad;
                        }

                        // nuke any detached devices
                        for (VecString::iterator i = badIds.begin();
                             i != badIds.end(); ++i) {
                                gamepad_map_t::iterator bad =
                                    gamepads.find(*i);
                                ASSERT(gamepads.end() != bad,
                                    "bad device not in gamepad map");
                                gamepads.erase(bad);
                        }

                        //DPRINTF("Have %d gamepads", gamepads.size());
                }

                mgr->update();

                // loop through all gamepad objects
                for (gamepad_map_t::iterator i = gamepads.begin();
                     i != gamepads.end(); ++i) {
                        gamepad::Gamepad * gpad = i->second;
                        if (!gpad)
                                continue;       // no gamepad for device

                        const gamepad::Type * type = gpad->getType();
                        ASSERT(type, "null type");

                        gamepad::buttons_t buttons = gpad->getButtons();
                        if (buttons) {
                                printButtons(buttons, gpad->getType());
                        }
                }
        }
        DPRINTF("---- Stopping due to signal ----");
}



////////////////////////////////////////////////////////////////////////////////
//
//      entry point
//
////////////////////////////////////////////////////////////////////////////////

int
main
(
IN int argc,
IN const char * argv[]
)
{
        int result = 0;

        ASSERT(2 == argc, "Usage: gamepad-test-manager <data-directory>");
        const char * dataDir = argv[1];
        DPRINTF("Using data directory: '%s'", dataDir);

#ifndef WIN32
        struct sigaction sigact;
        sigact.sa_handler = handleSignal;
        sigact.sa_flags = 0;
        sigemptyset(&sigact.sa_mask);
        sigaction(SIGINT, &sigact, NULL);
        sigaction(SIGHUP, &sigact, NULL);
#endif  // WIN32

        try {
                perf::Timer timer("overall timer");

                doTest(dataDir);

        } catch (std::exception& e) {
                DPRINTF("Exception: %s", e.what());
                result = 1;
        }

        perf::dumpTimingSummary(std::cerr);

        return result;
}