main.cc

/*
    Source part of project WeJoy
    Copyright (C) 2023 Johannes Bergmark

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program 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 General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <https://www.gnu.org/licenses/>.
*/

#include <array>
#include <unistd.h> //sleep
#include <thread>
#include <mutex>
#include <csignal>
#include <atomic>
#include <condition_variable>

#include "LuaScript.h"
#include "global.h"
#include "CKeyboard.h"

bool bPoll = true;
std::mutex mtx;

void updateThreadJoysticks(LuaScript& lScript)
{
	//Sleep one second to give the X11 system time to adapt.
	sleep(1);

	JoystickEvent event;
	while(bPoll)
    {
        usleep(1000);
        for(unsigned int i=0; i<GLOBAL::joyList.size(); i++)
        {
            if(GLOBAL::joyList[i]->readJoy(&event))
            {
                mtx.lock();
                if(event.isButton()) lScript.call_device_function("d" + std::to_string(i) + "_b" + std::to_string(event.number) + "_event", event.value);
                else if(event.isAxis()) lScript.call_device_function("d" + std::to_string(i) + "_a" + std::to_string(event.number) + "_event", event.value);
                mtx.unlock();
            }//if

        }//for
    }//while
}

void updateThreadKeyboard(LuaScript& lScript)
{
	sleep(1);

    CKeyboardEvent kbdEvent;
	while(bPoll)
    {
		usleep(1000);
		for(unsigned int i=0; i<GLOBAL::kbdList.size(); i++)
       	{
			if(GLOBAL::kbdList[i]->readEvent(&kbdEvent))
			{
				mtx.lock();
				if(kbdEvent.state == CKeyboardEvent::PRESSED) lScript.call_device_function("kbd" + std::to_string(i) + "_pressed", kbdEvent.code);
				else if (kbdEvent.state == CKeyboardEvent::RELEASED) lScript.call_device_function("kbd" + std::to_string(i) + "_released", kbdEvent.code);
				mtx.unlock();
			}//if
			else if(GLOBAL::kbdList[i]->call_kbd_down_LuaFunction)
			{
				for(auto pressedKey : GLOBAL::kbdList[i]->pressedKeys)
				{
					mtx.lock();
					lScript.call_device_function("kbd" + std::to_string(i) + "_down", pressedKey);
					mtx.unlock();
				}
			}
		}//for
    }//while
}

//Called from user via lua script
int l_send_keyboard_event(lua_State* L)
{
	int type = lua_tonumber(L, 1);
	int value = lua_tonumber(L, 2);
	GLOBAL::vKeyboard->send_key_event(type, value);
	return 0;
}

//Called from user via lua script
int l_get_joy_button_status(lua_State* L)
{
	unsigned int id = lua_tonumber(L, 1);
	int type = lua_tonumber(L, 2);
	if(id>=GLOBAL::joyList.size())
	{
		std::cout << "ERROR get_joy_button_status: Device " << id << " does not exist.\n";
		lua_pushnumber(L, -1);
		return 1;
	}
	int status = GLOBAL::joyList[id]->get_button_status(type);
	lua_pushnumber(L, status);
	return 1;	
}


//Called from user via lua script
int l_get_joy_axis_status(lua_State* L)
{
	unsigned int id = lua_tonumber(L, 1);
	int type = lua_tonumber(L, 2);
	if(id>=GLOBAL::joyList.size())
	{
		std::cout << "ERROR get_joy_axis_status: Device " << id << " does not exist.\n";
		lua_pushnumber(L, -1);
		return 1;
	}
	int status = GLOBAL::joyList[id]->get_axis_status(type);
	lua_pushnumber(L, status);
	return 1;	
}

//Called from user via lua script
int l_send_vjoy_button_event(lua_State* _L)
{
	unsigned int id = lua_tonumber(_L, 1);
	int type = lua_tonumber(_L, 2);
	int value = lua_tonumber(_L, 3);

	if(id >= GLOBAL::vJoyList.size())
	{
		std::cout << "ERROR send_vjoy_button_event: Virtual device " << id << " does not exist.\n";
		return 0;	
	}//if
	GLOBAL::vJoyList[id]->send_button_event(type, value);
	return 0;
}

//Called from user via lua script
int l_send_vjoy_axis_event(lua_State* _L)
{
	unsigned int id = lua_tonumber(_L, 1);
	int type = lua_tonumber(_L, 2);
	int value = lua_tonumber(_L, 3);

	if(id >= GLOBAL::vJoyList.size())
	{
		std::cout << "ERROR send_vjoy_axis_event: Virtual device " << id << " does not exist.\n";
		return 0;	
	}//if
	GLOBAL::vJoyList[id]->send_axis_event(type, value);
	
	return 0;
}

//Called from user via lua script
int l_get_vjoy_button_status(lua_State* L)
{
	unsigned int id = lua_tonumber(L, 1);
	int type = lua_tonumber(L, 2);
	if(id>=GLOBAL::vJoyList.size())
	{
		std::cout << "ERROR get_vjoy_button_status: Virtual device " << id << " does not exist.\n";
		lua_pushnumber(L, -1);
		return 1;
	}
	int status = GLOBAL::vJoyList[id]->get_button_status(type);
	lua_pushnumber(L, status);
	return 1;	
}


//Called from user via lua script
int l_get_vjoy_axis_status(lua_State* L)
{
	unsigned int id = lua_tonumber(L, 1);
	int type = lua_tonumber(L, 2);
	if(id>=GLOBAL::vJoyList.size())
	{
		std::cout << "ERROR get_vjoy_axis_status: Virtual device " << id << " does not exist.\n";
		lua_pushnumber(L, -1);
		return 1;
	}
	int status = GLOBAL::vJoyList[id]->get_axis_status(type);
	lua_pushnumber(L, status);
	return 1;	
}


//Populate a list of physical devices defined in user lua file
bool populate_devices(LuaScript& lScript)
{
	//Get the data from the user lua file	
	std::vector<std::array<int, 2>> dList;
	std::array<int, 2> val;
	int cIndex = 0;
	while(1)
	{
		bool noerr;
		val[0] = lScript.get<int>("devices.d" + std::to_string(cIndex) + ".vendorid", noerr);
		if(!noerr) break;
		val[1] = lScript.get<int>("devices.d" + std::to_string(cIndex) + ".productid", noerr);
		if(!noerr) break;

		dList.push_back(val);
		
		cIndex++;
	}//for


	//Populate the list of found joysticks
	for(unsigned int i=0; i<dList.size(); i++)
	{
        Joystick* cJoy = new Joystick(dList[i][0], dList[i][1], GLOBAL::joyList);
		if(!cJoy->isFound())
		{
			std::cout << "WARNING: Joystick " << std::hex << dList[i][0] << ":" << std::hex << dList[i][1] << " is not found.\n";
			delete cJoy;
			return false;
		}

		GLOBAL::joyList.push_back(cJoy);
	}//for


    //Initilize the keyboards for input
    cIndex = 0;
    while(1)
    {
        bool noerr;
        std::string kbdEventPath = lScript.get<std::string>("devices.kbd" + std::to_string(cIndex), noerr);
        if(!noerr) break;

        CKeyboard* nKBG = new CKeyboard(kbdEventPath);
		if(nKBG->isOpen()) GLOBAL::kbdList.push_back(nKBG);
		else {delete nKBG; return false;}

        cIndex++;
    }//while

	//Check if kbd_down function exist in Lua script (to save performance)
	for(unsigned int i=0; i<GLOBAL::kbdList.size(); i++)
	{
		if(lScript.doFunctionExist("kbd" + std::to_string(i) + "_pressed")) GLOBAL::kbdList[i]->call_kbd_down_LuaFunction = true;
	}

	return true;
}

//Populate a alist of virtual devices defined in user lua file
bool populate_virtual_devices(LuaScript& lScript)
{
	GLOBAL::vKeyboard = new CVirtualKeyboard();

	std::vector<std::array<int, 2>> dList;
	std::array<int, 2> val;
	int cIndex = 0;
	while(1)
	{
		bool noerr;
		
		val[0] = lScript.get<int>("v_devices.v" + std::to_string(cIndex) + ".buttons", noerr);
		if(!noerr) break;
		val[1] = lScript.get<int>("v_devices.v" + std::to_string(cIndex) + ".axes", noerr);
		if(!noerr) break;

		dList.push_back(val);
		
		cIndex++;
	}//for

	//Create and populate the list of user defined virtual devices
	for(unsigned int i=0; i<dList.size(); i++)
	{
		CVirtualJoy* vJoy = new CVirtualJoy(dList[i][0], dList[i][1]);
		if (!vJoy->isOpen()){ delete vJoy; return false;}
		GLOBAL::vJoyList.push_back(vJoy);
	}//for

	return true;
}

//Initialize lua functions
void link_lua_functions(LuaScript& lScript)
{
	lScript.pushcfunction(l_send_vjoy_button_event, "send_button_event");
	lScript.pushcfunction(l_send_vjoy_axis_event, "send_axis_event");
	lScript.pushcfunction(l_send_keyboard_event, "send_keyboard_event");
	lScript.pushcfunction(l_get_joy_button_status, "get_button_status");
	lScript.pushcfunction(l_get_joy_axis_status, "get_axis_status");
	lScript.pushcfunction(l_get_vjoy_button_status, "get_vjoy_button_status");
	lScript.pushcfunction(l_get_vjoy_axis_status, "get_vjoy_axis_status");
}


std::atomic<bool> exit_signal(false);
std::mutex mutex_signal;
std::condition_variable cv_signal;

void exit_handler(int signum)
{
	exit_signal = true;
	cv_signal.notify_one();
}

void cleanup()
{
	std::cout << "Cleaning up memory ...\n";
	for(unsigned int i=0; i<GLOBAL::kbdList.size(); i++) delete GLOBAL::kbdList[i];
	for(unsigned int i=0; i<GLOBAL::joyList.size(); i++) delete GLOBAL::joyList[i];
	for(unsigned int i=0; i<GLOBAL::vJoyList.size(); i++) delete GLOBAL::vJoyList[i];

   	if(GLOBAL::vKeyboard) delete GLOBAL::vKeyboard;
}

int main(int argc, char** argv)
{
	//TODO I need to search for information on which buttons and axes is required to correctly be found in applications, as sometimes i.e. axes are found in system, but not by applications.

	std::cout << "WeJoy v0.3 by Johannes Bergmark\n";
	
	if(argc<2)
	{
		std::cout << "Please type the path of your lua file.\n";
		std::cout << "I.e. 'wejoy config.lua'\n";
		return 0;
	}

	signal(SIGTERM, exit_handler);
	signal(SIGINT, exit_handler);
	signal(SIGHUP, exit_handler);

	//Open the user lua file.
	LuaScript lScript(argv[1]);

	if(!lScript.isOpen() || !populate_devices(lScript) || !populate_virtual_devices(lScript))
	{
		cleanup();
		std::cout << "WeJoy failed to start because of errors.\n";
		return 1;
	}

	link_lua_functions(lScript);

	std::cout << "Press 'Ctrl C' to quit.\n";	

	std::thread threadUpdateJoysticks(updateThreadJoysticks, std::ref(lScript));
	std::thread threadUpdateKeyboard(updateThreadKeyboard, std::ref(lScript));
	
	// Wait for signal
	std::unique_lock<std::mutex> lock(mutex_signal);
	cv_signal.wait(lock, [&] { return exit_signal.load();});
	bPoll = false;

	std::cout << "\nClosing threads ...\n";
	threadUpdateJoysticks.join();
	threadUpdateKeyboard.join();
	sleep(1);

	cleanup();
	std::cout << "See you later, goodbye!\n";
	return 0;
}