1
0
mirror of https://github.com/VDR4Arch/vdr.git synced 2023-10-10 13:36:52 +02:00
vdr/remote.c

437 lines
11 KiB
C

/*
* remote.c: General Remote Control handling
*
* See the main source file 'vdr.c' for copyright information and
* how to reach the author.
*
* $Id: remote.c 3.3 2015/01/20 14:53:57 kls Exp $
*/
#include "remote.h"
#include <fcntl.h>
#define __STDC_FORMAT_MACROS // Required for format specifiers
#include <inttypes.h>
#include <netinet/in.h>
#include <string.h>
#include <sys/types.h>
#include <sys/time.h>
#include <unistd.h>
#include "tools.h"
// --- cRemote ---------------------------------------------------------------
#define INITTIMEOUT 10000 // ms
#define REPEATTIMEOUT 1000 // ms
eKeys cRemote::keys[MaxKeys];
int cRemote::in = 0;
int cRemote::out = 0;
cTimeMs cRemote::repeatTimeout(-1);
cRemote *cRemote::learning = NULL;
char *cRemote::unknownCode = NULL;
cMutex cRemote::mutex;
cCondVar cRemote::keyPressed;
const char *cRemote::keyMacroPlugin = NULL;
const char *cRemote::callPlugin = NULL;
bool cRemote::enabled = true;
time_t cRemote::lastActivity = 0;
cRemote::cRemote(const char *Name)
{
name = Name ? strdup(Name) : NULL;
Remotes.Add(this);
}
cRemote::~cRemote()
{
Remotes.Del(this, false);
free(name);
}
const char *cRemote::GetSetup(void)
{
return Keys.GetSetup(Name());
}
void cRemote::PutSetup(const char *Setup)
{
Keys.PutSetup(Name(), Setup);
}
bool cRemote::Initialize(void)
{
if (Ready()) {
char *NewCode = NULL;
eKeys Key = Get(INITTIMEOUT, &NewCode);
if (Key != kNone || NewCode)
return true;
}
return false;
}
void cRemote::Clear(void)
{
cMutexLock MutexLock(&mutex);
in = out = 0;
if (learning) {
free(unknownCode);
unknownCode = NULL;
}
}
bool cRemote::Put(eKeys Key, bool AtFront)
{
if (Key != kNone) {
cMutexLock MutexLock(&mutex);
if (in != out && (keys[out] & k_Repeat) && (Key & k_Release))
Clear();
int d = out - in;
if (d <= 0)
d = MaxKeys + d;
if (d - 1 > 0) {
if (AtFront) {
if (--out < 0)
out = MaxKeys - 1;
keys[out] = Key;
}
else {
keys[in] = Key;
if (++in >= MaxKeys)
in = 0;
}
keyPressed.Broadcast();
return true;
}
return false;
}
return true; // only a real key shall report an overflow!
}
bool cRemote::PutMacro(eKeys Key)
{
const cKeyMacro *km = KeyMacros.Get(Key);
if (km) {
keyMacroPlugin = km->Plugin();
cMutexLock MutexLock(&mutex);
for (int i = km->NumKeys(); --i > 0; ) {
if (!Put(km->Macro()[i], true))
return false;
}
}
return true;
}
bool cRemote::Put(uint64_t Code, bool Repeat, bool Release)
{
char buffer[32];
snprintf(buffer, sizeof(buffer), "%016" PRIX64, Code);
return Put(buffer, Repeat, Release);
}
bool cRemote::Put(const char *Code, bool Repeat, bool Release)
{
if (learning && this != learning)
return false;
eKeys Key = Keys.Get(Name(), Code);
if (Key != kNone) {
if (Repeat)
Key = eKeys(Key | k_Repeat);
if (Release)
Key = eKeys(Key | k_Release);
return Put(Key);
}
if (learning) {
free(unknownCode);
unknownCode = strdup(Code);
keyPressed.Broadcast();
}
return false;
}
bool cRemote::CallPlugin(const char *Plugin)
{
cMutexLock MutexLock(&mutex);
if (!callPlugin) {
callPlugin = Plugin;
Put(k_Plugin);
return true;
}
return false;
}
const char *cRemote::GetPlugin(void)
{
cMutexLock MutexLock(&mutex);
const char *p = keyMacroPlugin;
if (p)
keyMacroPlugin = NULL;
else {
p = callPlugin;
callPlugin = NULL;
}
return p;
}
bool cRemote::HasKeys(void)
{
cMutexLock MutexLock(&mutex);
return in != out && !(keys[out] & k_Repeat);
}
eKeys cRemote::Get(int WaitMs, char **UnknownCode)
{
for (;;) {
cMutexLock MutexLock(&mutex);
if (in != out) {
eKeys k = keys[out];
if (++out >= MaxKeys)
out = 0;
if ((k & k_Repeat) != 0)
repeatTimeout.Set(REPEATTIMEOUT);
TriggerLastActivity();
return enabled ? k : kNone;
}
else if (!WaitMs || !keyPressed.TimedWait(mutex, WaitMs) && repeatTimeout.TimedOut())
return kNone;
else if (learning && UnknownCode && unknownCode) {
*UnknownCode = unknownCode;
unknownCode = NULL;
return kNone;
}
}
}
void cRemote::TriggerLastActivity(void)
{
lastActivity = time(NULL);
}
// --- cRemotes --------------------------------------------------------------
cRemotes Remotes;
// --- cKbdRemote ------------------------------------------------------------
struct tKbdMap {
eKbdFunc func;
uint64_t code;
};
static tKbdMap KbdMap[] = {
{ kfF1, 0x0000001B5B31317EULL },
{ kfF2, 0x0000001B5B31327EULL },
{ kfF3, 0x0000001B5B31337EULL },
{ kfF4, 0x0000001B5B31347EULL },
{ kfF5, 0x0000001B5B31357EULL },
{ kfF6, 0x0000001B5B31377EULL },
{ kfF7, 0x0000001B5B31387EULL },
{ kfF8, 0x0000001B5B31397EULL },
{ kfF9, 0x0000001B5B32307EULL },
{ kfF10, 0x0000001B5B32317EULL },
{ kfF11, 0x0000001B5B32327EULL },
{ kfF12, 0x0000001B5B32337EULL },
{ kfUp, 0x00000000001B5B41ULL },
{ kfDown, 0x00000000001B5B42ULL },
{ kfLeft, 0x00000000001B5B44ULL },
{ kfRight, 0x00000000001B5B43ULL },
{ kfHome, 0x00000000001B5B48ULL },
{ kfEnd, 0x00000000001B5B46ULL },
{ kfPgUp, 0x000000001B5B357EULL },
{ kfPgDown, 0x000000001B5B367EULL },
{ kfIns, 0x000000001B5B327EULL },
{ kfDel, 0x000000001B5B337EULL },
{ kfNone, 0x0000000000000000ULL }
};
bool cKbdRemote::kbdAvailable = false;
bool cKbdRemote::rawMode = false;
cKbdRemote::cKbdRemote(void)
:cRemote("KBD")
,cThread("KBD remote control")
{
tcgetattr(STDIN_FILENO, &savedTm);
struct termios tm;
if (tcgetattr(STDIN_FILENO, &tm) == 0) {
tm.c_iflag = 0;
tm.c_lflag &= ~(ICANON | ECHO);
tm.c_cc[VMIN] = 0;
tm.c_cc[VTIME] = 0;
tcsetattr(STDIN_FILENO, TCSANOW, &tm);
}
kbdAvailable = true;
systemIsUtf8 = !cCharSetConv::SystemCharacterTable() || strcmp(cCharSetConv::SystemCharacterTable(), "UTF-8") == 0;
Start();
}
cKbdRemote::~cKbdRemote()
{
kbdAvailable = false;
Cancel(3);
tcsetattr(STDIN_FILENO, TCSANOW, &savedTm);
}
void cKbdRemote::SetRawMode(bool RawMode)
{
rawMode = RawMode;
}
uint64_t cKbdRemote::MapFuncToCode(int Func)
{
for (tKbdMap *p = KbdMap; p->func != kfNone; p++) {
if (p->func == Func)
return p->code;
}
return (Func <= 0xFF) ? Func : 0;
}
int cKbdRemote::MapCodeToFunc(uint64_t Code)
{
for (tKbdMap *p = KbdMap; p->func != kfNone; p++) {
if (p->code == Code)
return p->func;
}
if (Code <= 0xFF)
return Code;
return kfNone;
}
void cKbdRemote::PutKey(uint64_t Code, bool Repeat, bool Release)
{
if (rawMode || (!Put(Code, Repeat, Release) && !IsLearning())) {
if (int func = MapCodeToFunc(Code))
Put(KBDKEY(func), Repeat, Release);
}
}
int cKbdRemote::ReadKey(void)
{
cPoller Poller(STDIN_FILENO);
if (Poller.Poll(50)) {
uchar ch = 0;
int r = safe_read(STDIN_FILENO, &ch, 1);
if (r == 1)
return ch;
if (r < 0)
LOG_ERROR_STR("cKbdRemote");
}
return -1;
}
uint64_t cKbdRemote::ReadKeySequence(void)
{
uint64_t k = 0;
int key1;
if ((key1 = ReadKey()) >= 0) {
k = key1;
if (systemIsUtf8 && (key1 & 0xC0) == 0xC0) {
char bytes[4] = { 0 };
bytes[0] = key1;
int bytescount = 1;
if ((key1 & 0xF0) == 0xF0)
bytescount = 3;
else if ((key1 & 0xE0) == 0xE0)
bytescount = 2;
for (int i = 0; i < bytescount; i++) {
if ((key1 = ReadKey()) >= 0)
bytes[i + 1] = key1;
}
k = Utf8CharGet(bytes);
if (k > 0xFF)
k = 0;
}
else if (key1 == 0x1B) {
// Start of escape sequence
if ((key1 = ReadKey()) >= 0) {
k <<= 8;
k |= key1 & 0xFF;
switch (key1) {
case 0x4F: // 3-byte sequence
if ((key1 = ReadKey()) >= 0) {
k <<= 8;
k |= key1 & 0xFF;
}
break;
case 0x5B: // 3- or more-byte sequence
if ((key1 = ReadKey()) >= 0) {
k <<= 8;
k |= key1 & 0xFF;
switch (key1) {
case 0x31 ... 0x3F: // more-byte sequence
case 0x5B: // strange, may apparently occur
do {
if ((key1 = ReadKey()) < 0)
break; // Sequence ends here
k <<= 8;
k |= key1 & 0xFF;
} while (key1 != 0x7E);
break;
default: ;
}
}
break;
default: ;
}
}
}
}
return k;
}
void cKbdRemote::Action(void)
{
cTimeMs FirstTime;
cTimeMs LastTime;
uint64_t FirstCommand = 0;
uint64_t LastCommand = 0;
bool Delayed = false;
bool Repeat = false;
while (Running()) {
uint64_t Command = ReadKeySequence();
if (Command) {
if (Command == LastCommand) {
// If two keyboard events with the same command come in without an intermediate
// timeout, this is a long key press that caused the repeat function to kick in:
Delayed = false;
FirstCommand = 0;
if (FirstTime.Elapsed() < (uint)Setup.RcRepeatDelay)
continue; // repeat function kicks in after a short delay
if (LastTime.Elapsed() < (uint)Setup.RcRepeatDelta)
continue; // skip same keys coming in too fast
PutKey(Command, true);
Repeat = true;
LastTime.Set();
}
else if (Command == FirstCommand) {
// If the same command comes in twice with an intermediate timeout, we
// need to delay the second command to see whether it is going to be
// a repeat function or a separate key press:
Delayed = true;
}
else {
// This is a totally new key press, so we accept it immediately:
PutKey(Command);
Delayed = false;
FirstCommand = Command;
FirstTime.Set();
}
}
else if (Repeat) {
// Timeout after a repeat function, so we generate a 'release':
PutKey(LastCommand, false, true);
Repeat = false;
}
else if (Delayed && FirstCommand) {
// Timeout after two normal key presses of the same key, so accept the
// delayed key:
PutKey(FirstCommand);
Delayed = false;
FirstCommand = 0;
FirstTime.Set();
}
LastCommand = Command;
}
}