libs/indibase/indicontroller.cpp

/*******************************************************************************
  Copyright (C) 2013 Jasem Mutlaq <mutlaqja@ikarustech.com>

 This library is free software; you can redistribute it and/or
 modify it under the terms of the GNU Library General Public
 License version 2 as published by the Free Software Foundation.

 This library is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 Library General Public License for more details.

 You should have received a copy of the GNU Library General Public License
 along with this library; see the file COPYING.LIB.  If not, write to
 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 Boston, MA 02110-1301, USA.
*******************************************************************************/

#include "indicontroller.h"

#include <cstring>

namespace INDI
{
Controller::Controller(DefaultDevice *cdevice)
{
    device = cdevice;

    JoystickSettingT      = nullptr;
    JoystickSettingTP.ntp = 0;

    joystickCallbackFunc = joystickEvent;
    axisCallbackFunc     = axisEvent;
    buttonCallbackFunc   = buttonEvent;
}

Controller::~Controller()
{
    for (int i = 0; i < JoystickSettingTP.ntp; i++)
        free(JoystickSettingT[i].aux0);

    free(JoystickSettingT);
}

void Controller::mapController(const char *propertyName, const char *propertyLabel, ControllerType type,
                               const char *initialValue)
{
    if (JoystickSettingT == nullptr)
        JoystickSettingT = static_cast<IText *>(malloc(sizeof(IText)));

    // Ignore duplicates
    for (int i = 0; i < JoystickSettingTP.ntp; i++)
    {
        if (!strcmp(propertyName, JoystickSettingT[i].name))
            return;
    }

    IText *buf = static_cast<IText *>(realloc(JoystickSettingT, (JoystickSettingTP.ntp + 1) * sizeof(IText)));
    if (buf == nullptr)
    {
        free (JoystickSettingT);
        perror("Failed to allocate memory for joystick controls.");
        return;
    }
    else
        JoystickSettingT = buf;

    ControllerType *ctype = static_cast<ControllerType *>(malloc(sizeof(ControllerType)));
    *ctype                = type;

    memset(JoystickSettingT + JoystickSettingTP.ntp, 0, sizeof(IText));
    IUFillText(&JoystickSettingT[JoystickSettingTP.ntp], propertyName, propertyLabel, initialValue);

    JoystickSettingT[JoystickSettingTP.ntp++].aux0 = ctype;

    IUFillTextVector(&JoystickSettingTP, JoystickSettingT, JoystickSettingTP.ntp, device->getDeviceName(),
                     "JOYSTICKSETTINGS", "Settings", "Joystick", IP_RW, 0, IPS_IDLE);
}

void Controller::clearMap()
{
    for (int i = 0; i < JoystickSettingTP.ntp; i++)
    {
        free(JoystickSettingT[i].aux0);
        free(JoystickSettingT[i].text);
    }

    JoystickSettingTP.ntp = 0;
    free(JoystickSettingT);
    JoystickSettingT = nullptr;
}

bool Controller::initProperties()
{
    IUFillSwitch(&UseJoystickS[0], "ENABLE", "Enable", ISS_OFF);
    IUFillSwitch(&UseJoystickS[1], "DISABLE", "Disable", ISS_ON);
    IUFillSwitchVector(&UseJoystickSP, UseJoystickS, 2, device->getDeviceName(), "USEJOYSTICK", "Joystick", OPTIONS_TAB,
                       IP_RW, ISR_1OFMANY, 0, IPS_IDLE);

    IUFillText(&JoystickDeviceT[0], "SNOOP_JOYSTICK_DEVICE", "Device", "Joystick");
    IUFillTextVector(&JoystickDeviceTP, JoystickDeviceT, 1, device->getDeviceName(), "SNOOP_JOYSTICK", "Snoop Joystick",
                     OPTIONS_TAB, IP_RW, 60, IPS_IDLE);

    return true;
}

void Controller::ISGetProperties(const char *dev)
{
    if (dev != nullptr && strcmp(dev, device->getDeviceName()))
        return;

    if (device->isConnected())
    {
        device->defineProperty(&UseJoystickSP);
        device->defineProperty(&JoystickDeviceTP);

        if (JoystickSettingT && UseJoystickS[0].s == ISS_ON)
            device->defineProperty(&JoystickSettingTP);
    }
}

bool Controller::updateProperties()
{
    if (device->isConnected())
    {
        device->defineProperty(&UseJoystickSP);
        device->defineProperty(&JoystickDeviceTP);

        if (JoystickSettingT && UseJoystickS[0].s == ISS_ON)
            device->defineProperty(&JoystickSettingTP);
    }
    else
    {
        device->deleteProperty(UseJoystickSP.name);
        device->deleteProperty(JoystickDeviceTP.name);
        device->deleteProperty(JoystickSettingTP.name);
    }

    return true;
}

bool Controller::ISNewSwitch(const char *dev, const char *name, ISState *states, char *names[], int n)
{
    if (strcmp(dev, device->getDeviceName()) == 0)
    {
        // Enable joystick support
        if (!strcmp(name, UseJoystickSP.name))
        {
            IUUpdateSwitch(&UseJoystickSP, states, names, n);

            UseJoystickSP.s = IPS_OK;

            if (UseJoystickSP.sp[0].s == ISS_ON)
                enableJoystick();
            else
                disableJoystick();

            IDSetSwitch(&UseJoystickSP, nullptr);

            return true;
        }
    }

    return false;
}

bool Controller::ISNewText(const char *dev, const char *name, char *texts[], char *names[], int n)
{
    if (strcmp(dev, device->getDeviceName()) == 0)
    {
        if (!strcmp(name, "SNOOP_JOYSTICK"))
        {
            IUUpdateText(&JoystickDeviceTP, texts, names, n);
            JoystickDeviceTP.s = IPS_IDLE;

            IDSetText(&JoystickDeviceTP, nullptr);

            if (UseJoystickSP.sp[0].s == ISS_ON)
            {
                // Let's switch over to the new joystick.
                enableJoystick();
            }

            return true;
        }

        if (!strcmp(name, "JOYSTICKSETTINGS") && n <= JoystickSettingTP.ntp)
        {
            for (int i = 0; i < JoystickSettingTP.ntp; i++)
            {
                IText *tp = IUFindText(&JoystickSettingTP, names[i]);
                if (tp)
                {
                    ControllerType cType  = getControllerType(texts[i]);
                    ControllerType myType = *(static_cast<ControllerType *>(JoystickSettingT[i].aux0));
                    if (cType != myType)
                    {
                        JoystickSettingTP.s = IPS_ALERT;
                        IDSetText(&JoystickSettingTP, nullptr);
                        DEBUGFDEVICE(dev, INDI::Logger::DBG_ERROR, "Cannot change controller type to %s.", texts[i]);
                        return false;
                    }
                }
            }

            IUUpdateText(&JoystickSettingTP, texts, names, n);

            for (int i = 0; i < n; i++)
            {
                if (strstr(JoystickSettingT[i].text, "JOYSTICK_"))
                    IDSnoopDevice(JoystickDeviceT[0].text, JoystickSettingT[i].text);
            }

            JoystickSettingTP.s = IPS_OK;
            IDSetText(&JoystickSettingTP, nullptr);
            return true;
        }
    }

    return false;
}

bool Controller::ISSnoopDevice(XMLEle *root)
{
    XMLEle *ep = nullptr;
    double mag = 0, angle = 0;

    // If joystick is disabled, do not process anything.
    if (UseJoystickSP.sp[0].s == ISS_OFF)
        return false;

    const char *propName = findXMLAttValu(root, "name");

    // Check axis
    if (!strcmp("JOYSTICK_AXES", propName))
    {
        for (ep = nextXMLEle(root, 1); ep != nullptr; ep = nextXMLEle(root, 0))
        {
            const char *elemName = findXMLAttValu(ep, "name");
            const char *setting  = getControllerSetting(elemName);
            if (setting == nullptr)
                continue;

            mag = atof(pcdataXMLEle(ep));

            axisCallbackFunc(setting, mag, device);
        }
    }
    // Check buttons
    else if (!strcmp("JOYSTICK_BUTTONS", propName))
    {
        for (ep = nextXMLEle(root, 1); ep != nullptr; ep = nextXMLEle(root, 0))
        {
            const char *elemName = findXMLAttValu(ep, "name");
            const char *setting  = getControllerSetting(elemName);

            if (setting == nullptr)
                continue;

            buttonCallbackFunc(setting, strcmp(pcdataXMLEle(ep), "Off") ? ISS_ON : ISS_OFF, device);
        }
    }
    // Check joysticks
    else if (strstr(propName, "JOYSTICK_"))
    {
        const char *setting = getControllerSetting(propName);

        // We don't have this here, so let's not process it
        if (setting == nullptr)
            return false;

        for (ep = nextXMLEle(root, 1); ep != nullptr; ep = nextXMLEle(root, 0))
        {
            if (!strcmp("JOYSTICK_MAGNITUDE", findXMLAttValu(ep, "name")))
                mag = atof(pcdataXMLEle(ep));
            else if (!strcmp("JOYSTICK_ANGLE", findXMLAttValu(ep, "name")))
                angle = atof(pcdataXMLEle(ep));
        }

        joystickCallbackFunc(setting, mag, angle, device);
    }

    return false;
}

bool Controller::saveConfigItems(FILE *fp)
{
    IUSaveConfigSwitch(fp, &UseJoystickSP);
    IUSaveConfigText(fp, &JoystickSettingTP);
    IUSaveConfigText(fp, &JoystickDeviceTP);

    return true;
}

void Controller::enableJoystick()
{
    device->defineProperty(&JoystickSettingTP);

    for (int i = 0; i < JoystickSettingTP.ntp; i++)
    {
        if (strstr(JoystickSettingTP.tp[i].text, "JOYSTICK_"))
            IDSnoopDevice(JoystickDeviceT[0].text, JoystickSettingTP.tp[i].text);
    }

    IDSnoopDevice(JoystickDeviceT[0].text, "JOYSTICK_AXES");
    IDSnoopDevice(JoystickDeviceT[0].text, "JOYSTICK_BUTTONS");
}

void Controller::disableJoystick()
{
    device->deleteProperty(JoystickSettingTP.name);
}

void Controller::setJoystickCallback(joystickFunc JoystickCallback)
{
    joystickCallbackFunc = JoystickCallback;
}

void Controller::setAxisCallback(axisFunc AxisCallback)
{
    axisCallbackFunc = AxisCallback;
}

void Controller::setButtonCallback(buttonFunc buttonCallback)
{
    buttonCallbackFunc = buttonCallback;
}

void Controller::joystickEvent(const char *joystick_n, double mag, double angle, void *context)
{
    INDI_UNUSED(joystick_n);
    INDI_UNUSED(mag);
    INDI_UNUSED(angle);
    INDI_UNUSED(context);
}

void Controller::axisEvent(const char *axis_n, int value, void *context)
{
    INDI_UNUSED(axis_n);
    INDI_UNUSED(value);
    INDI_UNUSED(context);
}

void Controller::buttonEvent(const char *button_n, int button_value, void *context)
{
    INDI_UNUSED(button_n);
    INDI_UNUSED(button_value);
    INDI_UNUSED(context);
}

Controller::ControllerType Controller::getControllerType(const char *name)
{
    ControllerType targetType = CONTROLLER_UNKNOWN;

    if (strstr(name, "JOYSTICK_"))
        targetType = CONTROLLER_JOYSTICK;
    else if (strstr(name, "AXIS_"))
        targetType = CONTROLLER_AXIS;
    else if (strstr(name, "BUTTON_"))
        targetType = CONTROLLER_BUTTON;

    return targetType;
}

const char *Controller::getControllerSetting(const char *name)
{
    for (int i = 0; i < JoystickSettingTP.ntp; i++)
        if (!strcmp(JoystickSettingT[i].text, name))
            return JoystickSettingT[i].name;

    return nullptr;
}
}