remote.cc

   1 /*
   2     Copyright 2004-2005 Chris Tallon
   3
   4     This file is part of VOMP.
   5
   6     VOMP is free software; you can redistribute it and/or modify
   7     it under the terms of the GNU General Public License as published by
   8     the Free Software Foundation; either version 2 of the License, or
   9     (at your option) any later version.
  10
  11     VOMP is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14     GNU General Public License for more details.
  15
  16     You should have received a copy of the GNU General Public License
  17     along with VOMP; if not, write to the Free Software
  18     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  19 */
  20
  21 #include "remote.h"
  22 #include "wremoteconfig.h"
  23 #include "i18n.h"
  24 #include "log.h"
  25 #include "vdr.h"
  26 #include "wtabbar.h"
  27
  28 Remote* Remote::instance = NULL;
  29
  30
  31 const ULONG Remote::NOLEARNMODE;
  32 // Not buttons
  33 const  UCHAR Remote::NA_LEARN;
  34 const  UCHAR Remote::NA_NONE;
  35 const  UCHAR Remote::NA_UNKNOWN;
  36 const  UCHAR Remote::NA_SIGNAL;
  37 const  UCHAR Remote::DF_UP;
  38 const  UCHAR Remote::DF_DOWN;
  39 const  UCHAR Remote::DF_LEFT;
  40 const  UCHAR Remote::DF_RIGHT;
  41
  42 // Problem common buttons
  43 const  UCHAR Remote::VOLUMEUP;
  44 const  UCHAR Remote::VOLUMEDOWN;
  45 const  UCHAR Remote::CHANNELUP;
  46 const  UCHAR Remote::CHANNELDOWN;
  47
  48 // Common buttons
  49 const  UCHAR Remote::ZERO;
  50 const  UCHAR Remote::ONE;
  51 const  UCHAR Remote::TWO;
  52 const  UCHAR Remote::THREE;
  53 const  UCHAR Remote::FOUR;
  54 const  UCHAR Remote::FIVE;
  55 const  UCHAR Remote::SIX;
  56 const  UCHAR Remote::SEVEN;
  57 const  UCHAR Remote::EIGHT;
  58 const  UCHAR Remote::NINE;
  59 const  UCHAR Remote::POWER;
  60 const  UCHAR Remote::GO;
  61 const  UCHAR Remote::BACK;
  62 const  UCHAR Remote::MENU;
  63 const  UCHAR Remote::RED;
  64 const  UCHAR Remote::GREEN;
  65 const  UCHAR Remote::YELLOW;
  66 const  UCHAR Remote::BLUE;
  67 const  UCHAR Remote::MUTE;
  68 const  UCHAR Remote::RADIO;
  69 const  UCHAR Remote::REVERSE;
  70 const  UCHAR Remote::PLAY;
  71 const  UCHAR Remote::FORWARD;
  72 const  UCHAR Remote::RECORD;
  73 const  UCHAR Remote::STOP;
  74 const  UCHAR Remote::PAUSE;
  75 const  UCHAR Remote::SKIPBACK;
  76 const  UCHAR Remote::SKIPFORWARD;
  77 const  UCHAR Remote::OK;
  78
  79 // Old remote only
  80 const  UCHAR Remote::FULL;
  81
  82 // New remote only
  83 const  UCHAR Remote::TV;
  84 const  UCHAR Remote::VIDEOS;
  85 const  UCHAR Remote::MUSIC;
  86 const  UCHAR Remote::PICTURES;
  87 const  UCHAR Remote::GUIDE;
  88 const  UCHAR Remote::UP;
  89 const  UCHAR Remote::DOWN;
  90 const  UCHAR Remote::LEFT;
  91 const  UCHAR Remote::RIGHT;
  92 const  UCHAR Remote::PREVCHANNEL;
  93 const  UCHAR Remote::STAR;
  94 const  UCHAR Remote::HASH;
  95
  96 // Android only
  97 const  UCHAR Remote::PLAYPAUSE;
  98
  99
 100 // Remote types
 101 const  UCHAR Remote::OLDREMOTE;
 102 const  UCHAR Remote::NEWREMOTE;
 103
 104 Remote::Remote()
 105 {
 106   if (instance) return;
 107   instance = this;
 108   remoteType = OLDREMOTE;
 109   learnmode = NOLEARNMODE;
 110 }
 111
 112 Remote::~Remote()
 113 {
 114   instance = NULL;
 115 }
 116
 117 Remote* Remote::getInstance()
 118 {
 119   return instance;
 120 }
 121
 122 void Remote::setRemoteType(UCHAR newType)
 123 {
 124   if ((newType != OLDREMOTE) && (newType != NEWREMOTE)) return;
 125   remoteType = newType;
 126 }
 127
 128 void Remote::EnterLearningMode(UCHAR command)
 129 {
 130     learnmode = command; //Armed
 131 }
 132
 133 void Remote::ResetToDefault()
 134 {
 135   translist.clear();
 136   InitHWCListwithDefaults();
 137 }
 138
 139
 140 UCHAR Remote::TranslateHWCFixed(ULLONG code)
 141 {
 142   switch (code)
 143   {
 144     case DOWN:
 145       return DOWN;
 146     case UP:
 147       return UP;
 148     case LEFT:
 149       return LEFT;
 150     case RIGHT:
 151       return RIGHT;
 152     case DF_DOWN:
 153       return DOWN;
 154     case DF_UP:
 155       return UP;
 156     case DF_LEFT:
 157       return LEFT;
 158     case DF_RIGHT:
 159       return RIGHT;
 160     case MENU:
 161       return MENU;
 162     case BACK:
 163       return BACK;
 164     case OK:
 165       return OK;
 166     default:
 167       return NA_UNKNOWN;
 168   }
 169 }
 170
 171 const char*Remote::HardcodedTranslateStr(UCHAR command)
 172 {
 173   switch (command)
 174   {
 175     case DOWN:
 176       return tr("Down");
 177     case UP:
 178       return tr("Up");
 179     case LEFT:
 180       return tr("Left");
 181     case RIGHT:
 182       return tr("Right");
 183     case MENU:
 184       return tr("Menu");
 185     case BACK:
 186       return tr("Back");
 187     case OK:
 188       return tr("Ok");
 189     default:
 190       return NULL;
 191   }
 192 }
 193
 194 UCHAR Remote::TranslateHWCList(ULLONG code)
 195 {
 196   if (learnmode != NOLEARNMODE)
 197   {
 198     setHWCtoCommand(code, learnmode);
 199     learnmode = NOLEARNMODE;
 200     return NA_LEARN;
 201   }
 202   RemoteTranslationList::iterator it = translist.find(code);
 203   if (it == translist.end())
 204   {
 205     return NA_UNKNOWN;
 206   }
 207   else
 208   {
 209     return it->second;
 210   }
 211 }
 212
 213 UCHAR Remote::TranslateHWC(ULLONG code)
 214 {
 215   UCHAR ret = TranslateHWCFixed(code);
 216   if (ret == NA_UNKNOWN)
 217   {
 218     ret = TranslateHWCList(code);
 219   }
 220   else
 221   {
 222     learnmode = NOLEARNMODE;
 223   }
 224
 225   if (ret == NA_UNKNOWN)
 226   {
 227     return NA_UNKNOWN;
 228   }
 229   return ret;
 230 }
 231
 232 void Remote::setHWCtoCommand(ULLONG hcw, UCHAR command)
 233 {
 234   translist[hcw] = command;
 235 }
 236
 237 void Remote::unsetHWC(ULLONG hcw)
 238 {
 239   translist.erase(hcw);
 240 }
 241
 242 void Remote::LoadKeysConfig(VDR *vdr,const char *cfg)
 243 {
 244         ULONG number=0;
 245         if (sscanf(cfg,"%ld",&number) != 1) return;
 246         Log::getInstance()->log("Remote", Log::INFO, "Config General/Remote keys num keys %d",number);
 247         char buffer[1024];
 248         char keybuf[1024];
 249         for (int i = 0; i < number; i++) {
 250                 sprintf(keybuf, "RemoteKey%d", i);
 251                 const char *keytrans = vdr->configLoad("General", keybuf);
 252                 if (keytrans) {
 253                         ULONG ul1, ul2;
 254                         ULONG uc;
 255                         if (sscanf(keytrans, "%lXI%lXK%lX", &ul1, &ul2, &uc) == 3) {
 256                                 translist[((ULLONG) ul1) | ((ULLONG) ul2) << 32] = (UCHAR) uc;
 257                         }
 258                 }
 259
 260         }
 261 }
 262
 263 void Remote::SaveKeysConfig()
 264 {
 265   int number=0;
 266   char buffer[1024];
 267   char keybuf[1024];
 268   RemoteTranslationList::const_iterator it;
 269   for (it = translist.begin(); it != translist.end(); it++)
 270   {
 271           sprintf(buffer,"%08lXI%08lXK%02X",
 272                           (ULONG)it->first ,(ULONG) (it->first >> 32), it->second);
 273           sprintf(keybuf,"RemoteKey%d",number);
 274           VDR::getInstance()->configSave("General",keybuf,buffer);
 275           number++;
 276   }
 277   sprintf(buffer,"%d",number);
 278   VDR::getInstance()->configSave("General","RemoteKeyNum",buffer);
 279 }
 280
 281
 282 void Remote::InitHWCListwithDefaults()
 283 {
 284   translist[VOLUMEUP] = VOLUMEUP;
 285   translist[VOLUMEDOWN] = VOLUMEDOWN;
 286   translist[CHANNELUP] = CHANNELUP;
 287   translist[CHANNELDOWN] = CHANNELDOWN;
 288
 289   // Common buttons
 290   translist[ZERO] = ZERO;
 291   translist[ONE] = ONE;
 292   translist[TWO] = TWO;
 293   translist[THREE] = THREE;
 294   translist[FOUR] = FOUR;
 295   translist[FIVE] = FIVE;
 296   translist[SIX] = SIX;
 297   translist[SEVEN] = SEVEN;
 298   translist[EIGHT] = EIGHT;
 299   translist[NINE] = NINE;
 300   translist[POWER] = POWER;
 301   translist[GO] = GO;
 302   translist[RED] = RED;
 303   translist[GREEN] = GREEN;
 304   translist[YELLOW] = YELLOW;
 305   translist[BLUE] = BLUE;
 306
 307   translist[MUTE] = MUTE;
 308   translist[RADIO] = RADIO;
 309   translist[REVERSE] = REVERSE;
 310   translist[FORWARD] = FORWARD;
 311   translist[RECORD] = RECORD;
 312   translist[STOP] = STOP;
 313   translist[PAUSE] = PAUSE;
 314   translist[PLAY] = PLAY;
 315   translist[SKIPBACK] = SKIPBACK;
 316   translist[SKIPFORWARD] = SKIPFORWARD;
 317
 318   // Old remote only
 319   translist[FULL] = FULL;
 320
 321   // New remote only
 322   translist[TV] = TV;
 323   translist[VIDEOS] = VIDEOS;
 324   translist[MUSIC] = MUSIC;
 325   translist[PICTURES] = PICTURES;
 326   translist[GUIDE] = GUIDE;
 327   translist[PREVCHANNEL] = PREVCHANNEL;
 328   translist[STAR] = STAR;
 329   translist[HASH] = HASH;
 330 }
 331
 332 const char *Remote::CommandDesc(UCHAR number)
 333 {
 334   switch (number)
 335   {
 336     case VOLUMEUP:
 337       return tr("Volume Up");
 338
 339     case VOLUMEDOWN:
 340       return tr("Volume Down");
 341     case CHANNELUP:
 342       return tr("Channel up");
 343     case CHANNELDOWN:
 344       return tr("Channel down");
 345     case ZERO:
 346       return "0";
 347     case ONE:
 348       return "1";
 349     case TWO:
 350       return "2";
 351     case THREE:
 352       return "3";
 353     case FOUR:
 354       return "4";
 355     case FIVE:
 356       return "5";
 357     case SIX:
 358       return "6";
 359     case SEVEN:
 360       return "7";
 361     case EIGHT:
 362       return "8";
 363     case NINE:
 364       return "9";
 365     case POWER:
 366       return tr("Power");
 367     case GO:
 368       return tr("Go");
 369     case BACK:
 370       return tr("Back");
 371     case MENU:
 372       return tr("Menu");
 373     case RED:
 374       return tr("Red");
 375     case GREEN:
 376       return tr("Green");
 377     case YELLOW:
 378       return tr("Yellow");
 379     case BLUE:
 380       return tr("Blue");
 381     case MUTE:
 382       return tr("Mute");
 383     case RADIO:
 384       return tr("Radio");
 385     case REVERSE:
 386       return tr("Reverse");
 387     case PLAY:
 388       return tr("Play");
 389     case FORWARD:
 390       return tr("Forward");
 391     case RECORD:
 392       return tr("Record");
 393     case STOP:
 394       return tr("Stop");
 395     case PAUSE:
 396       return tr("Pause");
 397     case SKIPBACK:
 398       return tr("Skip back");
 399     case SKIPFORWARD:
 400       return tr("Skip forward");
 401     case OK:
 402       return tr("Ok");
 403     case FULL:
 404       return tr("Fullscreen");
 405     case TV:
 406       return tr("TV");
 407     case VIDEOS:
 408       return tr("Videos");
 409     case MUSIC:
 410       return tr("Music");
 411     case PICTURES:
 412       return tr("Pictures");
 413     case GUIDE:
 414       return tr("Guide");
 415     case UP:
 416       return tr("Up");
 417     case DOWN:
 418       return tr("Down");
 419     case LEFT:
 420       return tr("Left");
 421     case RIGHT:
 422       return tr("Right");
 423     case PREVCHANNEL:
 424       return tr("Previous Channel");
 425     case STAR:
 426       return tr("Star");
 427     case HASH:
 428       return tr("Hash");
 429     case PLAYPAUSE:
 430        return tr("Play/Pause");
 431
 432     default:
 433       return NULL;
 434   }
 435 }
 436
 437 char* Remote::HCWDesc(ULLONG hcw)
 438 {
 439   char *dest,*temp;
 440   temp=(char*)CommandDesc((UCHAR)hcw);
 441   if (temp != NULL)
 442   {
 443     dest=new char[strlen(temp)+1];
 444     strcpy(dest,temp);
 445   }
 446   else
 447   {
 448     dest=new char[20];
 449     sprintf(dest,"C:%lX",(ULONG)hcw);
 450   }
 451   return dest;
 452 }
 453
 454 char *Remote::CommandTranslateStr(UCHAR command)
 455 {
 456   char *desc;
 457   int length=5;//:+\t+0
 458   int keys=0; //max 10;
 459   char *commanddesc=(char*)CommandDesc(command);
 460   if (commanddesc != NULL)
 461   {
 462     length+=strlen(commanddesc);
 463   }
 464   char *preassigneddesc=(char*)HardcodedTranslateStr(command);
 465   if (preassigneddesc != NULL)
 466   {
 467     length+=strlen(preassigneddesc);
 468   }
 469
 470   char *keydesc[10];
 471   RemoteTranslationList::const_iterator it;
 472   for (it = translist.begin(); it != translist.end(); it++)
 473   {
 474     if (it->second == command)
 475     {
 476       keydesc[keys] = HCWDesc(it->first);
 477       length += strlen(keydesc[keys])+2;
 478       keys ++;
 479       if (keys == 10) break;
 480     }
 481   }
 482
 483   desc=new char [length];
 484   char *current=desc;
 485   if (commanddesc != NULL)
 486   {
 487     current+=sprintf(current,"%s:\t ",commanddesc);
 488   }
 489   else
 490   {
 491     current+=sprintf(current,":\t ");
 492   }
 493   if (preassigneddesc != NULL)
 494   {
 495     current+=sprintf(current,"%s\t",preassigneddesc);
 496   }
 497   else
 498   {
 499     current+=sprintf(current,"\t");
 500   }
 501   for (int i = 0;i < keys; i++)
 502   {
 503     current += sprintf(current,"%s, ",keydesc[i]);
 504     delete [] keydesc[i];
 505   }
 506   return desc;
 507 }
 508
 509 bool Remote::addOptionPagesToWTB(WTabBar *wtb)
 510 {
 511     WRemoteConfig* wrc = new WRemoteConfig();
 512     wtb->addTab(tr("Remote Control"), wrc);
 513     return true;
 514 }
 515
 516 bool Remote::loadOptionsfromServer(VDR* vdr)
 517 {
 518    // Set remote keys
 519   char * config;
 520   config = vdr->configLoad("General", "RemoteKeyNum");
 521
 522   if (config)
 523   {
 524     Log::getInstance()->log("Remote", Log::INFO, "Config General/Remote keys load");
 525     LoadKeysConfig(vdr,config);
 526     delete[] config;
 527   }
 528   else
 529   {
 530     Log::getInstance()->log("Remote", Log::INFO, "Config General/Remote keys not found");
 531     InitHWCListwithDefaults();
 532   }
 533   return true;
 534 }
 535
 536 bool Remote::saveOptionstoServer()
 537 {
 538     SaveKeysConfig();
 539     return true;
 540 }