manager.cpp

Go to the documentation of this file.

/*
 * manager.cpp
 *
 * Copyright (C) 2010  Thomas A. Vaughan
 * All rights reserved.
 *
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * Neither the name of the <organization> nor the
 *       names of its contributors may be used to endorse or promote products
 *       derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THOMAS A. VAUGHAN ''AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THOMAS A. VAUGHAN BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 *
 * gamepad manager implementation.  See manager.h
 */

// includes --------------------------------------------------------------------
#include "manager.h"            // always include our own header first

#ifdef WIN32
        // windows: use direct input device factory
#include "direct-input/direct-input.h"
#else   // WIN32
        // linux: use linux input device factory
#include "linux-joystick/linux-joystick.h"
#endif  // WIN32

#include "datahash/datahash_text.h"
#include "perf/perf.h"
#include "resources/resources-internal.h"
#include "util/file.h"


namespace gamepad {

// interface destructors
Gamepad::~Gamepad(void) throw() { }
Manager::~Manager(void) throw() { }


// what percentage must pot be pushed for button to count as "pressed"?
static const float s_buttonRatio                = 0.2;

static const float s_4potRatio                  = 0.08;


static const char * s_gamepadExtension          = "gamepad";
static const char * s_mappingExtension          = "map";


////////////////////////////////////////////////////////////////////////////////
//
//      static helper methods
//
////////////////////////////////////////////////////////////////////////////////

static smart_ptr<Map>
readMapFromString
(
IN const char * val
)
{
        ASSERT(val, "null");

        smart_ptr<Datahash> hash = readHashFromString(val);
        ASSERT(hash, "null");

        smart_ptr<Map> map = readMap(hash);
        ASSERT(map, "null");

        return map;
}



static int
getDpadFromPot
(
IN SourceDevice * device,
IN int idx
)
{
        ASSERT(device, "null");
        ASSERT(idx >= 0, "Bad pot index: %d", idx);

        const pot_value_t& pv = device->getPotValue(idx);

        int iThreshold = s_buttonRatio * (pv.maxSeen - pv.minSeen);
        if ((pv.value - pv.minSeen) <= iThreshold)
                return -1;
        if ((pv.maxSeen - pv.value) <= iThreshold)
                return +1;
        return 0;
}



static bool
potMoved
(
IN SourceDevice * device,
IN int idx
)
{
        ASSERT(device, "null");
        ASSERT(idx >= 0, "bad index: %d", idx);

        const pot_value_t& pv = device->getPotValue(idx);

        int iThreshold = s_4potRatio * (pv.maxSeen - pv.minSeen);
        if ((pv.value - pv.minSeen) >= iThreshold)
                return true;
        return false;
}



static nstream::eIterationFlag
loadFilesCallback
(
IN nstream::Entry * entry,
IN void * context
)
{
        ASSERT(entry, "null");
        Manager * mgr = (Manager *) context;
        ASSERT(mgr, "null context");

        // only care about Files, not Folders
        nstream::File * file = dynamic_cast<nstream::File *>(entry);
        if (!file)
                return nstream::eIterate_Continue;      // skip folders

        // get the extension of the name (.gamepad or .map, for instance)
        const char * filename = file->getName();
        const char * ext = GetExtension(filename);
        //DPRINTF("Load Files: extension='%s'", ext);
        if (!strcmp(s_gamepadExtension, ext)) {
                // this is a gamepad file!  Load it
                //DPRINTF("  Attempting to load type at '%s'", filename);
                smart_ptr<nstream::Stream> stream = file->openStream();
                ASSERT(stream, "null");
                if (stream->good()) {
                        smart_ptr<Type> type = readType(stream);
                        ASSERT(type, "null");
                        //DPRINTF("    Adding type: '%s'", type->getName());
                        mgr->addType(type);
                } else {
                        DPRINTF("File is bad: '%s'", filename);
                }
        } else if (!strcmp(s_mappingExtension, ext)) {
                // this is a gamepad mapping file!  Load it
                //DPRINTF("  Attempting to load mapping at '%s'", filename);
                smart_ptr<nstream::Stream> stream = file->openStream();
                ASSERT(stream, "null");
                std::istream& in = stream->getStream();
                if (in.good()) {
                        smart_ptr<Datahash> hash =
                            readHashFromStream("map", in);
                        ASSERT(hash, "null");
                        smart_ptr<Map> map = readMap(hash);
                        ASSERT(map, "null");
                        //DPRINTF("    Adding mapping: '%s'", map->getName());
                        mgr->addMapping(map);
                } else {
                        DPRINTF("File is bad: '%s'", filename);
                }
        }

        // okay, next...
        return nstream::eIterate_Continue;
}



static bool
sourceAndMapInUse
(
IN Manager * mgr,
IN const char * deviceId,
IN const char * mappingId
)
{
        ASSERT(mgr, "null");
        ASSERT(deviceId, "null");
        ASSERT(mappingId, "null");

        // loop through all gamepads and see if any are using this combo
        int nGamepads = mgr->getGamepadCount();
        for (int i = 0; i < nGamepads; ++i) {
                smart_ptr<Gamepad> gp = mgr->getGamepad(i);
                if (!gp) {
                        DPRINTF("Gamepad %d has disappeared", i);
                        continue;
                }

                if (!strcmp(deviceId, gp->getSourceDeviceId()) &&
                    !strcmp(mappingId, gp->getMappingId())) {
                        // gamepad i uses the same source + mapping!
                        return true;
                }
        }

        // no gamepads used this device + mapping
        return false;
}



////////////////////////////////////////////////////////////////////////////////
//
//      GPad -- class that implements the gamepad::Gamepad interface
//
////////////////////////////////////////////////////////////////////////////////

class GPad : public Gamepad {
public:
        // constructor, destructor ---------------------------------------------
        ~GPad(void) throw() { }

        // public class methods ------------------------------------------------
        void initialize(IN Type * type,
                                IN smart_ptr<SourceDevice>& device,
                                IN smart_ptr<Map>& mapping);

        // gamepad::Gamepad class interface methods ----------------------------
        Type * getType(void) const throw();
        const char * getId(void) throw();
        const char * getSourceDeviceId(void) throw();
        const char * getMappingId(void) throw();
        eDeviceState getState(void) throw();
        buttons_t getButtons(void) throw();
        eButton getButton(IN int idx) throw();
        void getJoystick(IN int idx,
                                OUT joystick_t& joy) throw();
        void getPot(IN int idx,
                                OUT pot_value_t& pv) throw();
        eDpad getDpad(IN int idx) throw();

private:
        // private typedefs ----------------------------------------------------
        typedef std::vector<button_map_t> btn_vec_t;
        typedef std::vector<dpad_map_t> dpad_vec_t;
        typedef std::vector<joystick_map_t> joy_vec_t;
        typedef std::vector<pot_map_t> pot_vec_t;

        // private helper functions --------------------------------------------
        // private member data -------------------------------------------------
        Type *                  m_type; // weak reference
        smart_ptr<SourceDevice> m_device;// our source device
        std::string             m_mappingId; // GUID of mapping
        std::string             m_id; // id of gamepad
//      smart_ptr<Map>          m_mapping;// mapping from device -> gamepad
        btn_vec_t               m_button; // button mappings
        dpad_vec_t              m_dpad; // dpad mappings
        pot_vec_t               m_pot;  // potentiometer mappings
        joy_vec_t               m_joystick; // joystick mappings
};



void
GPad::initialize
(
IN Type * type,
IN smart_ptr<SourceDevice>& device,
IN smart_ptr<Map>& mapping
)
{
        ASSERT(type, "null");
        ASSERT(device, "null");
        ASSERT(mapping, "null");

        //DPRINTF("Creating gamepad of type '%s'", type->getName());

        m_type = type;
        m_device = device;
//      m_mapping = mapping;
        m_mappingId = mapping->getId();

        // construct ID
        m_id = device->getUniqueId();
        m_id += ":";
        m_id += mapping->getId();

        DPRINTF("Gamepad id: '%s'", m_id.c_str());

        // determine button mappings
        int nButtons = type->getInputCount(eInput_Button);
        //DPRINTF("  Contains %d buttons", nButtons);
        m_button.reserve(nButtons);
        for (int i = 0; i < nButtons; ++i) {
                const char * name = type->getLogicalName(eInput_Button, i);
                //DPRINTF("  Button %d: '%s'", i, name);
                const button_map_t * bmap = mapping->getButtonMapping(name);
        //      if (bmap)
        //              bmap->dump(name);
                ASSERT_THROW(bmap && bmap->isValid(),
                    "Missing or invalid mapping found for button: '" << name
                    << "', gamepad type: '" << type->getName() <<
                    "', mapping name: '" << mapping->getName() << "'");

                m_button.push_back(*bmap);
        }
        //DPRINTF("Have %d buttons", (int) m_button.size());
        ASSERT(nButtons == (int) m_button.size(), "should match");

        // determine joystick mappings
        int nJoys = type->getInputCount(eInput_Joystick);
        //DPRINTF("  Contains %d joysticks", nJoys);
        m_joystick.reserve(nJoys);
        for (int i = 0; i < nJoys; ++i) {
                const char * name = type->getLogicalName(eInput_Joystick, i);
                //DPRINTF("  Joystick %d: '%s'", i, name);
                const joystick_map_t * jmap = mapping->getJoystickMapping(name);
        //      if (jmap)
        //              jmap->dump(name);
                ASSERT_THROW(jmap && jmap->isValid(),
                    "Missing or invalid mapping found for joystick: '" << name
                    << "', gamepad type: '" << type->getName() << 
                    "', mapping name: '" << mapping->getName() << "'");

                m_joystick.push_back(*jmap);
        }

        // determine dpad mappings
        int nDpads = type->getInputCount(eInput_Dpad);
        //DPRINTF("  Contains %d dpads", nDpads);
        m_dpad.reserve(nDpads);
        for (int i = 0; i < nDpads; ++i) {
                const char * name = type->getLogicalName(eInput_Dpad, i);
                //DPRINTF("  Dpad %d: '%s'", i, name);
                const dpad_map_t * dmap = mapping->getDpadMapping(name);
        //      if (dmap)
        //              dmap->dump(name);
                ASSERT_THROW(dmap && dmap->isValid(),
                    "Missing or invalid mapping found for dpad: '" << name
                    << "', gamepad type: '" << type->getName() <<
                    "', mapping name: '" << mapping->getName() << "'");

                m_dpad.push_back(*dmap);
        }
        //DPRINTF("Have %d dpads", (int) m_dpad.size());
        ASSERT(nDpads == (int) m_dpad.size(), "should match");

        // determine potentiometer mappings
        int nPots = type->getInputCount(eInput_Pot);
        //DPRINTF("  Contains %d potentiometers", nPots);
        m_pot.reserve(nPots);
        for (int i = 0; i < nPots; ++i) {
                const char * name = type->getLogicalName(eInput_Pot, i);
                //DPRINTF("  Pot %d: '%s'", i, name);
                const pot_map_t * pmap = mapping->getPotMapping(name);
                if (pmap) {
                        // have an explicitly-defined mapping
        //              pmap->dump(name);
                        m_pot.push_back(*pmap);
                } else {
                        ASSERT_THROW(false,
                            "Missing or invalid mapping found for potentiometer: '" <<
                            name << "', gamepad type: '" << type->getName() <<
                            "', mapping name: '" << mapping->getName() << "'");
                }
        }
        //DPRINTF("Have %d potentiometers", (int) m_pot.size());
        ASSERT(nPots == (int) m_pot.size(), "should match");
}



////////////////////////////////////////////////////////////////////////////////
//
//      GPad -- gamepad::Gamepad class interface methods
//
////////////////////////////////////////////////////////////////////////////////

Type *
GPad::getType
(
void
)
const
throw()
{
        return m_type;
}



const char *
GPad::getId
(
void
)
throw()
{
        return m_id.c_str();
}



const char *
GPad::getSourceDeviceId
(
void
)
throw()
{
        ASSERT(m_device, "null");

        return m_device->getUniqueId();
}



const char *
GPad::getMappingId
(
void
)
throw()
{
        return m_mappingId.c_str();
}



eDeviceState
GPad::getState
(
void
)
throw()
{
        ASSERT(m_device, "null");
        return m_device->getState();
}



buttons_t
GPad::getButtons
(
void
)
throw()
{
        ASSERT(m_device, "null");
        buttons_t retval = 0;

        int bit = 1;
        for (btn_vec_t::iterator i = m_button.begin(); i != m_button.end();
             ++i, bit = 2 * bit) {
                const button_map_t& bmap = *i;
                eButton val = m_device->getButtonValue(bmap.index);
                //DPRINTF("  Button[0x%08x] (binary): %d", bit, val);
                if (val) {
                        retval |= bit;
                }
        }
        return retval;
}



eButton
GPad::getButton
(
IN int idx
)
throw()
{
        ASSERT(idx >= 0 && idx < (int) m_button.size(), "Bad index: %d", idx);

        const button_map_t& bmap = m_button[idx];
        return m_device->getButtonValue(bmap.index);
}



void
GPad::getJoystick
(
IN int idx,
OUT joystick_t& joy
)
throw()
{
        ASSERT(idx >= 0, "Bad joystick index: %d", idx);
        ASSERT(idx < (int) m_joystick.size(), "Bad joystick index: %d", idx);
        ASSERT(m_device, "NULL");
        joy.clear();

        const joystick_map_t& jmap = m_joystick[idx];
        joy.x = m_device->getPotValue(jmap.xIndex);
        joy.y = m_device->getPotValue(jmap.yIndex);
}



void
GPad::getPot
(
IN int idx,
OUT pot_value_t& pv
)
throw()
{
        ASSERT(idx >= 0, "Bad pot index: %d", idx);
        ASSERT(idx < (int) m_pot.size(), "Bad pot index: %d", idx);
        ASSERT(m_device, "null");

        const pot_map_t& pmap = m_pot[idx];
        pv = m_device->getPotValue(pmap.index);
}



eDpad
GPad::getDpad
(
IN int idx
)
throw()
{
        ASSERT(idx >= 0, "Bad dpad index: %d", idx);
        ASSERT(idx < (int) m_dpad.size(), "Bad dpad index: %d", idx);
        ASSERT(m_device, "null");

        const dpad_map_t& dmap = m_dpad[idx];

        int xPos = 0;
        int yPos = 0;
        // is this a potentiometer-based dpad, or button-based?
        if (dpad_map_t::eType_2Pot == dmap.type) {
                // this is a dpad with two pots
                xPos = getDpadFromPot(m_device, dmap.index[dpad_map_t::eLeft]);
                yPos = getDpadFromPot(m_device, dmap.index[dpad_map_t::eUp]);
        } else if (dpad_map_t::eType_4Pot == dmap.type) {
                // this is a dpad with four pots
                if (potMoved(m_device, dmap.index[dpad_map_t::eLeft]))
                        xPos = -1;
                if (potMoved(m_device, dmap.index[dpad_map_t::eRight]))
                        xPos = +1;
                if (potMoved(m_device, dmap.index[dpad_map_t::eUp]))
                        yPos = -1;
                if (potMoved(m_device, dmap.index[dpad_map_t::eDown]))
                        yPos = +1;
        } else {
                // button-based dpad
                if (eButtonDown & m_device->getButtonValue(dmap.index[dpad_map_t::eLeft]))
                        xPos = -1;
                if (eButtonDown & m_device->getButtonValue(dmap.index[dpad_map_t::eRight]))
                        xPos = +1;
                if (eButtonDown & m_device->getButtonValue(dmap.index[dpad_map_t::eUp]))
                        yPos = -1;
                if (eButtonDown & m_device->getButtonValue(dmap.index[dpad_map_t::eDown]))
                        yPos = +1;
                //DPRINTF("  xpos=%d  ypos=%d", xPos, yPos);
        }

        // flip axes?
        if (dmap.flipX)
                xPos = -xPos;
        if (dmap.flipY)
                yPos = -yPos;

        // okay, based on x/y, determine dpad state
        int retval = eDpad_Centered;
        if (xPos < 0)
                retval = eDpad_Left;
        else if (xPos > 0)
                retval = eDpad_Right;
        
        if (yPos < 0)
                retval |= eDpad_Up;
        else if (yPos > 0)
                retval |= eDpad_Down;

        return (eDpad) retval;
}



////////////////////////////////////////////////////////////////////////////////
//
//      Mgr -- class that implements the gamepad::Manager interface
//
////////////////////////////////////////////////////////////////////////////////

class Mgr : public Manager {
public:
        // constructor, destructor ---------------------------------------------
        ~Mgr(void) throw() { }

        // public class methods ------------------------------------------------
        void initialize(IN smart_ptr<nstream::Folder>& dataDir);

        // gamepad::Manager class interface methods ----------------------------
        nstream::Folder * getDataDirectory(void);
        bool rediscover(void);
        int getSourceDeviceCount(void) { return m_devices.size(); }
        smart_ptr<SourceDevice> getSourceDevice(IN int index);
        smart_ptr<SourceDevice> getSourceDeviceById(IN const char * id);
        int getTypeCount(void);
        smart_ptr<Type> getType(IN int index);
        smart_ptr<Type> getType(IN const char * id);
        void addType(IN smart_ptr<Type>& type);
        int getMappingCount(void);
        smart_ptr<Map> getMapping(IN int index);
        smart_ptr<Map> getMapping(IN const char * id);
        void addMapping(IN smart_ptr<Map>& map);
        eResult createGamepad(IN smart_ptr<SourceDevice>& device,
                                IN smart_ptr<Map>& map,
                                OUT smart_ptr<Gamepad>& gamepad);
        int getGamepadCount(void);
        smart_ptr<Gamepad> getGamepad(IN int index);
        smart_ptr<Gamepad> getGamepad(IN const char * id);
        bool deleteGamepad(IN const char * id);
        void update(void);

private:
        // private typedefs ----------------------------------------------------
        typedef std::vector<smart_ptr<SourceDeviceFactory> > vec_factory_t;
        typedef std::map<std::string, smart_ptr<SourceDevice> > device_map_t;
        typedef std::map<std::string, smart_ptr<Type> > map_type_t;
        typedef std::map<std::string, smart_ptr<Map> > map_map_t;
        typedef std::map<std::string, smart_ptr<Gamepad> > gamepad_map_t;

        // private member data -------------------------------------------------
        smart_ptr<nstream::Folder> m_folder;    // our data directory
        vec_factory_t           m_factories;
        device_map_t            m_devices;
        map_type_t              m_types;
        map_map_t               m_mappings;
        gamepad_map_t           m_gamepads;
};



////////////////////////////////////////////////////////////////////////////////
//
//      Mgr -- public class methods
//
////////////////////////////////////////////////////////////////////////////////

nstream::Folder *
Mgr::getDataDirectory
(
void
)
{
        ASSERT(m_folder, "null");

        return m_folder;
}



void
Mgr::initialize
(
IN smart_ptr<nstream::Folder>& folder
)
{
        ASSERT(folder, "null");

        // recursively walk folder for interesting gamepad data files
        m_folder = folder;      // save data directory
        void * context = (Manager *) this;
        nstream::walkChildFolders(folder, loadFilesCallback, context);

        // populate factory objects
#if WIN32
        // win32 setup here
        smart_ptr<SourceDeviceFactory> factory =
           getDirectInputSourceDeviceFactory();
        ASSERT(factory, "failed to create direct input source device factory");
        m_factories.push_back(factory);

#else   // WIN32
        // assume linux!
        smart_ptr<SourceDeviceFactory> factory =
            getLinuxJoystickSourceDeviceFactory();
        ASSERT(factory, "failed to create linux joystick source device factory");
        m_factories.push_back(factory);

#endif  // WIN32

        DPRINTF("Have %d factory objects", (int) m_factories.size());
}



////////////////////////////////////////////////////////////////////////////////
//
//      Mgr -- gamepad::Manager class interface methods
//
////////////////////////////////////////////////////////////////////////////////

bool
Mgr::rediscover
(
void
)
{
        perf::Timer timer("gamepad::Manager::rediscover");

        bool changes = false;

        // clear out any bad devices
        VecString badIds;
        for (device_map_t::iterator i = m_devices.begin(); i != m_devices.end();
             ++i) {
                const char * id = i->first.c_str();
                SourceDevice * sd = i->second;
                ASSERT(sd, "null device in map");

                //DPRINTF("Checking device '%s'...", id);

                if (eDevice_Detached == sd->getState()) {
                        badIds.push_back(id);
                        changes = true;
                }
        }
        //DPRINTF("Found %d devices that need to be nuked", badIds.size());

        for (VecString::const_iterator i = badIds.begin(); i != badIds.end();
             ++i) {
                const char * id = i->c_str();
                device_map_t::iterator bad = m_devices.find(id);
                if (m_devices.end() == bad) {
                        DPRINTF("ERROR: bad id not in map?  '%s'", id);
                        continue;
                }
                m_devices.erase(bad);
        }
        //DPRINTF("%d devices remain in map after cleaning", m_devices.size());

        // walk through factories and update map
        for (vec_factory_t::iterator i = m_factories.begin();
             i != m_factories.end(); ++i) {
                SourceDeviceFactory * factory = *i;
                ASSERT(factory, "null factory in map");

                int N = factory->getCount();
                //DPRINTF("%d devices from '%s'", N, factory->getName());

                for (int j = 0; j < N; ++j) {
                        smart_ptr<SourceDevice> device =
                            factory->getSourceDevice(j);
                        if (!device) {
                                DPRINTF("Device %d was null", j);
                                continue;
                        }

                        const char * id = device->getUniqueId();
                        //DPRINTF("Device %d has ID '%s'", j, id);

                        device_map_t::iterator existing = m_devices.find(id);
                        if (m_devices.end() != existing) {
                                //DPRINTF("  ...already in map");
                                continue;
                        }

                        // new device!
                        changes = true;
                        m_devices[id] = device;
                }
        }

        // walk through and remove any gamepads no longer supported by devices
        VecString badGamepadIds;
        int nGamepads = this->getGamepadCount();
        for (int i = 0; i < nGamepads; ++i) {
                smart_ptr<gamepad::Gamepad> gp = this->getGamepad(i);
                if (!gp)
                        continue;

                const char * deviceId = gp->getSourceDeviceId();
                if (!deviceId || !this->getSourceDeviceById(deviceId)) {
                        DPRINTF("Gamepad is gone");
                        badGamepadIds.push_back(gp->getId());
                }
        }

        int nBadIds = badGamepadIds.size();
        for (int i = 0; i < nBadIds; ++i) {
                const char * badId = badGamepadIds[i].c_str();
                this->deleteGamepad(badId);
        }

        // all done!
        return changes;
}



smart_ptr<SourceDevice>
Mgr::getSourceDevice
(
IN int index
)
{
        ASSERT(index >= 0, "Bad index: %d", index);

        // we don't do anything clever here, just walk the map...
        for (device_map_t::iterator i = m_devices.begin();
             i != m_devices.end(); ++i, --index) {
                if (!index) {
                        // this must be it
                        return i->second;
                }
        }

        // got here?  ran out of entries
        return NULL;
}



smart_ptr<SourceDevice>
Mgr::getSourceDeviceById
(
IN const char * id
)
{
        ASSERT(id, "null");

        // again, no indexing.  Just walk the map
        for (device_map_t::iterator i = m_devices.begin();
             i != m_devices.end(); ++i) {
                smart_ptr<SourceDevice> device = i->second;
                if (device &&
                    !strcmp(id, device->getUniqueId())) {
                        return device;
                }
        }

        // got here?  ran out of entries
        return NULL;
}



int
Mgr::getTypeCount
(
void
)
{
        return m_types.size();
}



smart_ptr<Type>
Mgr::getType
(
IN int index
)
{
        ASSERT(index >= 0, "Bad index: %d", index);

        for (map_type_t::iterator i = m_types.begin();
             i != m_types.end(), index >= 0; ++i, --index) {
                if (!index) {
                        return i->second;
                }
        }

        // not found?
        return NULL;
}



smart_ptr<Type>
Mgr::getType
(
IN const char * id
)
{
        ASSERT(id, "null");

        map_type_t::iterator i = m_types.find(id);
        if (m_types.end() == i) {
                return NULL;            // ID not found
        }
        return i->second;
}



void
Mgr::addType
(
IN smart_ptr<Type>& type
)
{
        ASSERT(type, "null");

        const char * id = type->getId();
        ASSERT(id, "null id from type");

        // don't check for collisions--IDs should be unique!
        m_types[id] = type;
}



int
Mgr::getMappingCount
(
void
)
{
        return m_mappings.size();
}



smart_ptr<Map>
Mgr::getMapping
(
IN int index
)
{
        ASSERT(index >= 0, "Bad index: %d", index);

        for (map_map_t::iterator i = m_mappings.begin();
             i != m_mappings.end(), index >= 0; ++i, --index) {
                if (!index) {
                        return i->second;
                }
        }

        // not found
        return NULL;
}



smart_ptr<Map>
Mgr::getMapping
(
IN const char * id
)
{
        ASSERT(id, "null");

        map_map_t::iterator i = m_mappings.find(id);
        if (m_mappings.end() == i) {
                return NULL;            // not found
        }
        return i->second;
}



void
Mgr::addMapping
(
IN smart_ptr<Map>& map
)
{
        ASSERT(map, "null");

        const char * id = map->getId();
        ASSERT(id, "null id for gamepad mapping");

        // don't check for collisions -- IDs should be unique
        m_mappings[id] = map;
}



Manager::eResult
Mgr::createGamepad
(
IN smart_ptr<SourceDevice>& device,
IN smart_ptr<Map>& map,
OUT smart_ptr<Gamepad>& gamepad
)
{
        ASSERT(device, "null");
        ASSERT(map, "null");
        gamepad = NULL;         // initialize output

        // verify we recognize this type
        const char * typeId = map->getTypeId();
        DPRINTF("Creating gamepad from mapping with type=%s", typeId);
        ASSERT(typeId, "bad type id");

        map_type_t::iterator i = m_types.find(typeId);
        ASSERT_THROW(m_types.end() != i,
            "Cannot create gamepad since type specified in mapping is not "
            "recognized.  Mapping name: '" << map->getName() << "', type id: '"
            << typeId << "'");
        Type * type = i->second;
ASSERT(type, "null type object in type map?");

        // do any gamepads already use this source + mapping?
        if (sourceAndMapInUse(this, device->getUniqueId(), map->getId())) {
                DPRINTF("  Cannot create gamepad: source and map already used");
                return Manager::eResult_SourceInUse;
        }

        // okay, create gamepad of this type, with device and mapping
        smart_ptr<GPad> gpad = new GPad;
        ASSERT(gpad, "out of memory");
        gpad->initialize(type, device, map);

        // hand over (and downcast)
        gamepad = gpad;

        // store ourselves
        m_gamepads[gamepad->getId()] = gamepad;

        return Manager::eResult_Success;
}



int
Mgr::getGamepadCount
(
void
)
{
        return m_gamepads.size();
}



smart_ptr<Gamepad>
Mgr::getGamepad
(
IN int index
)
{
        ASSERT(index >= 0, "invalid gamepad index: %d", index);

        for (gamepad_map_t::iterator i = m_gamepads.begin();
             index >= 0 && i != m_gamepads.end(); ++i, --index) {
                if (!index)
                        return i->second;
        }

        // not found
        return NULL;
}



smart_ptr<Gamepad>
Mgr::getGamepad
(
IN const char * id
)
{
        ASSERT(id, "null");

        gamepad_map_t::iterator i = m_gamepads.find(id);
        if (m_gamepads.end() == i) {
                DPRINTF("Gamepad not found, id='%s'", id);
                return NULL;
        }

        return i->second;
}



bool
Mgr::deleteGamepad
(
IN const char * id
)
{
        ASSERT(id, "null");

        gamepad_map_t::iterator i = m_gamepads.find(id);
        if (m_gamepads.end() == i) {
                DPRINTF("Gamepad not found, id='%s'", id);
                return false;
        }

        m_gamepads.erase(i);
        return true;
}



void
Mgr::update
(
void
)
{
        for (device_map_t::iterator i = m_devices.begin(); i != m_devices.end();
             ++i) {
                SourceDevice * device = i->second;
                ASSERT(device, "null");

                device->poll();
        }
}



////////////////////////////////////////////////////////////////////////////////
//
//      public API
//
////////////////////////////////////////////////////////////////////////////////

smart_ptr<Manager>
Manager::create
(
IN smart_ptr<nstream::Folder>& dataDirectory
)
{
        ASSERT(dataDirectory, "null");

        smart_ptr<Mgr> local = new Mgr;
        ASSERT(local, "out of memory");

        local->initialize(dataDirectory);

        return local;
}



void
getRecommendedMappings
(
IN Manager * mgr,
IN SourceDevice * device,
OUT VecString& mapNames
)
{
        ASSERT(mgr, "null");
        ASSERT(device, "null");
        mapNames.clear();

        // what is the public name?
        const char * devName = device->getPublicName();
        ASSERT(devName, "null");
//      DPRINTF("Determining recommended mappings for device: '%s'", devName);

        // loop through all mappings
        int nMaps = mgr->getMappingCount();
        for (int i = 0; i < nMaps; ++i) {
                smart_ptr<Map> mapping = mgr->getMapping(i);
                ASSERT(mapping, "null");

                // get the list of devices supported by this mapping
                const VecString& mapDevNames = mapping->getDeviceNames();
                for (VecString::const_iterator j = mapDevNames.begin();
                     j != mapDevNames.end(); ++j) {
                        if (*j == devName) {
                                // mapping claims to support this device!
                                const char * id = mapping->getId();
                                ASSERT(id, "null");
                                mapNames.push_back(id);
                        }
                }
        }
//      DPRINTF("  Found %d mappings that support device",
//          (int) mapNames.size());
}



void
autoconfigureGamepads
(
IN Manager * mgr
)
{
        ASSERT(mgr, "null");

        DPRINTF("Attempting to autoconfigure gamepads...");

        // loop through all discovered source devices
        int nDevices = mgr->getSourceDeviceCount();
        for (int i = 0; i < nDevices; ++i) {
                smart_ptr<SourceDevice> device = mgr->getSourceDevice(i);
                if (!device) {
                        DPRINTF("Source device %d is no longer available", i);
                        continue;
                }

                VecString names;
                getRecommendedMappings(mgr, device, names);

                DPRINTF("  Seeing if I can autoconfigure device: '%s'",
                    device->getPublicName());
                int nMappings = names.size();
                DPRINTF("    %d recommended mappings found", nMappings);
                if (nMappings < 1) {
                        continue;       // no recommendations for this one
                }
                if (nMappings > 1) {
                        DPRINTF("    Found %d recommended mappings.",
                            nMappings);
                        DPRINTF("    I'll use the first one that works.");
                }
                smart_ptr<Map> map;
                for (int j = 0; j < nMappings; ++j) {
                        const char * mapName = names[j].c_str();
                        DPRINTF("    Trying mapping: %d='%s'", j, mapName);
                        map = mgr->getMapping(mapName);
                        if (map)
                                break;

                        DPRINTF("      ...could not generate mapping");
                }
                if (!map) {
                        DPRINTF("    No mappings worked!  Skipping device.");
                        continue;
                }

                // attempt to create!
                smart_ptr<Gamepad> gamepad;
                Manager::eResult result =
                    mgr->createGamepad(device, map, gamepad);
                if (Manager::eResult_Success == result) {
                        DPRINTF("    Autoconfigured gamepad!");
                } else if (Manager::eResult_SourceInUse == result) {
                        DPRINTF("    (this gamepad is already configured)");
                } else {
                        DPRINTF("    Autoconfig failed, reason: %d", result);
                }
        }
}



};      // gamepad namespace