common/action.c

   1 #include "host.h"
   2 #include "timer.h"
   3 //#include "keymap.h"
   4 #include "keycode.h"
   5 #include "keyboard.h"
   6 #include "mousekey.h"
   7 #include "command.h"
   8 #include "util.h"
   9 #include "debug.h"
  10 #include "action.h"
  11
  12 #define Kdebug(s)       do { if (debug_keyboard) debug(s); } while(0)
  13 #define Kdebug_P(s)     do { if (debug_keyboard) debug_P(s); } while(0)
  14 #define Kdebug_hex(s)   do { if (debug_keyboard) debug_hex(s); } while(0)
  15
  16
  17 /*
  18  *
  19  * Event/State|IDLE          PRESSING      DELAYING[f]      WAITING[f,k]
  20  * -----------+------------------------------------------------------------------
  21  * Fn  Down   |(L+)          -*1           WAITING(Sk)      IDLE(Rf,Ps)*7
  22  *     Up     |(L-)          IDLE(L-)*8    IDLE(L-)*8       IDLE(L-)*8
  23  * Fnk Down   |DELAYING(Sf)* (Rf)          WAITING(Sk)      IDLE(Rf,Ps,Rf)
  24  *     Up     |(L-)          IDLE(L-/Uf)*8 IDLE(Rf,Uf/L-)*3 IDLE(Rf,Ps,Uf/L-)*3
  25  * Key Down   |PRESSING(Rk)  (Rk)          WAITING(Sk)      IDLE(Rf,Ps,Rk)
  26  *     Up     |(Uk)          IDLE(Uk)*4    (Uk)             IDLE(L+,Ps,Pk)/(Uk)*a
  27  *            |
  28  * Delay      |-             -             IDLE(L+)         IDLE(L+,Ps)
  29  * Magic Key  |COMMAND*5
  30  *
  31  * *1: ignore Fn if other key is down.
  32  * *2: register Fnk if any key is pressing
  33  * *3: register/unregister delayed Fnk and move to IDLE if code == delayed Fnk, else *8
  34  * *4: if no keys registered to host
  35  * *5: unregister all keys
  36  * *6: only if no keys down
  37  * *7: ignore Fn because Fnk key and stored key are down.
  38  * *8: move to IDLE if layer switch(off) occurs, else stay at current state
  39  * *9: repeat key if pressing Fnk twice quickly(move to PRESSING)
  40  * *a: layer switch and process waiting key and code if code == wainting key, else unregister key
  41  *
  42  * States:
  43  *      IDLE: No key is down except modifiers
  44  *      DELAYING: delay layer switch after pressing Fn with alt keycode
  45  *      WAITING: key is pressed during DELAYING
  46  *
  47  * Events:
  48  *      Fn: Fn key without alternative keycode
  49  *      Fnk: Fn key with alternative keycode
  50  *      -: ignore
  51  *      Delay: layer switch delay term is elapsed
  52  *
  53  * Actions:
  54  *      Rk: register key
  55  *      Uk: unregister key
  56  *      Rf: register Fn(alt keycode)
  57  *      Uf: unregister Fn(alt keycode)
  58  *      Rs: register stored key
  59  *      Us: unregister stored key
  60  *      Sk: Store key(waiting Key)
  61  *      Sf: Store Fn(delayed Fn)
  62  *      Ps: Process stored key
  63  *      Ps: Process key
  64  *      Is: Interpret stored keys in current layer
  65  *      L+: Switch to new layer(*unregister* all keys but modifiers)
  66  *      L-: Switch back to last layer(*unregister* all keys but modifiers)
  67  *      Ld: Switch back to default layer(*unregister* all keys but modifiers)
  68  */
  69
  70
  71 typedef enum { IDLE, DELAYING, WAITING, PRESSING } kbdstate_t;
  72 #define NEXT(state)     do { \
  73     Kdebug("NEXT: "); Kdebug_P(state_str(kbdstate)); \
  74     kbdstate = state; \
  75     Kdebug(" -> "); Kdebug_P(state_str(kbdstate)); Kdebug("\n"); \
  76 } while (0)
  77
  78
  79 static kbdstate_t kbdstate = IDLE;
  80 static uint8_t fn_state_bits = 0;
  81 static keyrecord_t delayed_fn = {};
  82 static keyrecord_t waiting_key = {};
  83
  84 static const char *state_str(kbdstate_t state)
  85 {
  86     if (state == IDLE)      return PSTR("IDLE");
  87     if (state == DELAYING)  return PSTR("DELAYING");
  88     if (state == WAITING)   return PSTR("WAITING");
  89     if (state == PRESSING)  return PSTR("PRESSING");
  90     return PSTR("UNKNOWN");
  91 }
  92 static bool anykey_sent_to_host(void)
  93 {
  94     return (host_has_anykey() || host_mouse_in_use() ||
  95             host_last_sysytem_report() || host_last_consumer_report());
  96 }
  97
  98
  99
 100 /*
 101 static void layer_switch_on(uint8_t code);
 102 static void layer_switch_off(uint8_t code);
 103 static void key_action(uint8_t code, keyevent_t event);
 104 static void key_pressed(uint8_t code, keyevent_t event);
 105 static void key_released(uint8_t code, keyevent_t event);
 106 static void mod_pressed(uint8_t code, keyevent_t event);
 107 static void mod_released(uint8_t code, keyevent_t event);
 108 */
 109
 110 static void register_code(uint8_t code);
 111 static void unregister_code(uint8_t code);
 112 static void register_mods(uint8_t mods);
 113 static void unregister_mods(uint8_t mods);
 114 static void clear_keyboard(void);
 115 static void clear_keyboard_but_mods(void);
 116 static void layer_switch(uint8_t new_layer);
 117
 118
 119 /* tap */
 120 #define TAP_TIME    200
 121 static keyevent_t last_event = {};
 122 static uint16_t last_event_time = 0;
 123 static uint8_t tap_count = 0;
 124
 125 /* layer */
 126 uint8_t default_layer = 0;
 127 uint8_t current_layer = 0;
 128 uint8_t waiting_layer = 0;
 129
 130
 131 void action_exec(action_t action, keyevent_t event)
 132 {
 133     /* count tap when key is up */
 134     if (KEYEQ(event.key, last_event.key) && timer_elapsed(last_event_time) < TAP_TIME) {
 135         if (!event.pressed) tap_count++;
 136     } else {
 137         tap_count = 0;
 138     }
 139
 140     debug("action: "); debug_hex16(action.code); debug("\n");
 141     debug("kind.id: "); debug_hex(action.kind.id); debug("\n");
 142     debug("kind.param: "); debug_hex16(action.kind.param); debug("\n");
 143     debug("key.code: "); debug_hex(action.key.code); debug("\n");
 144     debug("key.mods: "); debug_hex(action.key.mods); debug("\n");
 145
 146     switch (action.kind.id) {
 147         case ACT_LMODS:
 148             if (event.pressed) {
 149                 register_mods(action.key.mods);
 150                 register_code(action.key.code);
 151             } else {
 152                 unregister_code(action.key.code);
 153                 unregister_mods(action.key.mods);
 154             }
 155             break;
 156         case ACT_RMODS:
 157             if (event.pressed) {
 158                 register_mods(action.key.mods<<4);
 159                 register_code(action.key.code);
 160             } else {
 161                 unregister_code(action.key.code);
 162                 unregister_mods(action.key.mods<<4);
 163             }
 164             break;
 165         case ACT_LAYER:
 166             switch (action.layer_key.code) {
 167                 case 0x00:  // Momentary switch
 168                     // TODO: history of layer switch
 169                     if (event.pressed) {
 170                         layer_switch(action.layer_key.layer);
 171                     } else {
 172                         layer_switch(default_layer);
 173                     }
 174                     break;
 175                 case 0x01:  // Oneshot switch
 176                     // TODO:
 177                     break;
 178                 case 0x02:  // reserved
 179                 case 0x03:  // reserved
 180                     break;
 181                 case 0xF0 ... 0xF7: // Tap to enable/disable
 182                 case 0xF8 ... 0xFF: // Tap to toggle layer
 183                     // TODO:
 184                     break;
 185                 default:    // with keycode for tap
 186                     debug("tap: "); debug_hex(tap_count); debug("\n");
 187                     // TODO: layer switch
 188                     // TODO: in case tap is interrupted by other key
 189
 190
 191                     if (event.pressed) {
 192                         // when any key down
 193                         if (host_has_anykey()) {
 194                             if (tap_count == 0)
 195                             register_code(action.layer_key.code);
 196                         } else {
 197                         }
 198
 199                         if (tap_count == 0) {
 200                             if (host_has_anykey()) {
 201                                 register_code(action.layer_key.code);
 202                             } else {
 203                                 waiting_layer = action.layer_key.layer;
 204                             }
 205                         }
 206                         // register key when press after a tap
 207                         if (tap_count > 0) {
 208                             register_code(action.layer_key.code);
 209                         }
 210                     } else {
 211                         // type key after tap
 212                         if (tap_count == 1) {
 213                             register_code(action.layer_key.code);
 214                         }
 215                         unregister_code(action.layer_key.code);
 216                     }
 217                     break;
 218             }
 219             break;
 220         case ACT_USAGE:
 221 #ifdef EXTRAKEY_ENABLE
 222             switch (action.usage.page) {
 223                 case ACTION_USAGE_PAGE_SYSTEM:
 224                     if (event.pressed) {
 225                         host_system_send(action.usage.code);
 226                     } else {
 227                         host_system_send(0);
 228                     }
 229                     break;
 230                 case ACTION_USAGE_PAGE_CONSUMER:
 231                     if (event.pressed) {
 232                         host_consumer_send(action.usage.code);
 233                     } else {
 234                         host_consumer_send(0);
 235                     }
 236                     break;
 237             }
 238 #endif
 239             break;
 240         case ACT_MOUSEKEY:
 241 #ifdef MOUSEKEY_ENABLE
 242             if (event.pressed) {
 243                 mousekey_on(action.key.code);
 244                 mousekey_send();
 245             } else {
 246                 mousekey_off(action.key.code);
 247                 mousekey_send();
 248             }
 249 #endif
 250             break;
 251         case ACT_LMOD_TAP:
 252         case ACT_RMOD_TAP:
 253         case ACT_MACRO:
 254         case ACT_COMMAND:
 255         case ACT_FUNCTION:
 256         default:
 257             break;
 258     }
 259
 260     /* last event */
 261     last_event = event;
 262     last_event_time = timer_read();
 263 }
 264
 265
 266 #if 0
 267 /* Key Action */
 268 inline
 269 static void key_action(uint8_t code, keyevent_t event)
 270 {
 271     if (event.pressed)
 272         key_pressed(code, event);
 273     else
 274         key_released(code, event);
 275 }
 276
 277 void fn_action(uint8_t code, keyevent_t event)
 278 {
 279 }
 280
 281 /* Key */
 282 inline static void key_pressed(uint8_t code, keyevent_t event)
 283 {
 284     uint8_t tmp_mods;
 285     switch (kbdstate) {
 286         case IDLE:
 287             register_code(code);
 288             NEXT(PRESSING);
 289             break;
 290         case PRESSING:
 291             register_code(code);
 292             break;
 293         case DELAYING:
 294             waiting_key = (keyrecord_t) {
 295                 .event = event,
 296                 .code = code,
 297                 .mods = keyboard_report->mods,
 298                 .time = timer_read()
 299             };
 300             NEXT(WAITING);
 301             break;
 302         case WAITING:
 303             // play back key stroke
 304             tmp_mods = keyboard_report->mods;
 305             host_set_mods(delayed_fn.mods);
 306             register_code(delayed_fn.code);
 307             host_set_mods(waiting_key.mods);
 308             register_code(waiting_key.code);
 309             host_set_mods(tmp_mods);
 310             register_code(code);
 311             NEXT(IDLE);
 312             break;
 313     }
 314 }
 315 inline static void key_released(uint8_t code, keyevent_t event)
 316 {
 317     uint8_t tmp_mods;
 318     switch (kbdstate) {
 319         case IDLE:
 320             unregister_code(code);
 321             break;
 322         case PRESSING:
 323             unregister_code(code);
 324             if (!anykey_sent_to_host())
 325                 NEXT(IDLE);
 326             break;
 327         case DELAYING:
 328             unregister_code(code);
 329             break;
 330         case WAITING:
 331             if (code == waiting_key.code) {
 332                 layer_switch_on(delayed_fn.code);
 333                 NEXT(IDLE);
 334                 // process waiting_key
 335                 tmp_mods = keyboard_report->mods;
 336                 host_set_mods(waiting_key.mods);
 337                 keymap_process_event(waiting_key.event);
 338                 host_set_mods(tmp_mods);
 339                 keymap_process_event(event);
 340             } else {
 341                 unregister_code(code);
 342             }
 343             break;
 344     }
 345 }
 346
 347 /* layer switch momentary */
 348 inline static void layerkey_pressed(uint8_t code, keyevent_t event)
 349 {
 350     uint8_t tmp_mods;
 351     switch (kbdstate) {
 352         case IDLE:
 353             layer_switch_on(code);
 354             break;
 355         case PRESSING:
 356             // ignore
 357             break;
 358         case DELAYING:
 359             waiting_key = (keyrecord_t) {
 360                 .event = event,
 361                 .code = code,
 362                 .mods = keyboard_report->mods,
 363                 .time = timer_read()
 364             };
 365             NEXT(WAITING);
 366             break;
 367         case WAITING:
 368             tmp_mods = keyboard_report->mods;
 369             host_set_mods(delayed_fn.mods);
 370             register_code(delayed_fn.code);
 371             host_set_mods(waiting_key.mods);
 372             register_code(waiting_key.code);
 373             host_set_mods(tmp_mods);
 374             if (kind == FN_DOWN) {
 375                 // ignore Fn
 376             } else if (kind == FNK_DOWN) {
 377                 register_code(code);
 378             } else if (kind == KEY_DOWN) {
 379                 register_code(code);
 380             }
 381             NEXT(IDLE);
 382             break;
 383     }
 384 }
 385 inline static void layerkey_released(uint8_t code, keyevent_t event)
 386 {
 387     switch (kbdstate) {
 388         case IDLE:
 389             layer_switch_off(code);
 390             break;
 391         case PRESSING:
 392         case DELAYING:
 393         case WAITING:
 394             if (layer_switch_off(code))
 395                 NEXT(IDLE);
 396             break;
 397     }
 398 }
 399 #endif
 400
 401
 402 static void register_code(uint8_t code)
 403 {
 404     if (code == KC_NO) {
 405         return;
 406     }
 407     else if IS_KEY(code) {
 408         // TODO: should push command_proc out of this block?
 409         if (!command_proc(code)) {
 410             host_add_key(code);
 411             host_send_keyboard_report();
 412         }
 413     }
 414     else if IS_MOD(code) {
 415         host_add_mods(MOD_BIT(code));
 416         host_send_keyboard_report();
 417     }
 418 #ifdef MOUSEKEY_ENABLE
 419     else if IS_MOUSEKEY(code) {
 420         mousekey_on(code);
 421         mousekey_send();
 422     }
 423 #endif
 424 #ifdef EXTRAKEY_ENABLE
 425     else if IS_CONSUMER(code) {
 426         uint16_t usage = 0;
 427         switch (code) {
 428             case KC_AUDIO_MUTE:
 429                 usage = AUDIO_MUTE;
 430                 break;
 431             case KC_AUDIO_VOL_UP:
 432                 usage = AUDIO_VOL_UP;
 433                 break;
 434             case KC_AUDIO_VOL_DOWN:
 435                 usage = AUDIO_VOL_DOWN;
 436                 break;
 437             case KC_MEDIA_NEXT_TRACK:
 438                 usage = TRANSPORT_NEXT_TRACK;
 439                 break;
 440             case KC_MEDIA_PREV_TRACK:
 441                 usage = TRANSPORT_PREV_TRACK;
 442                 break;
 443             case KC_MEDIA_STOP:
 444                 usage = TRANSPORT_STOP;
 445                 break;
 446             case KC_MEDIA_PLAY_PAUSE:
 447                 usage = TRANSPORT_PLAY_PAUSE;
 448                 break;
 449             case KC_MEDIA_SELECT:
 450                 usage = AL_CC_CONFIG;
 451                 break;
 452             case KC_MAIL:
 453                 usage = AL_EMAIL;
 454                 break;
 455             case KC_CALCULATOR:
 456                 usage = AL_CALCULATOR;
 457                 break;
 458             case KC_MY_COMPUTER:
 459                 usage = AL_LOCAL_BROWSER;
 460                 break;
 461             case KC_WWW_SEARCH:
 462                 usage = AC_SEARCH;
 463                 break;
 464             case KC_WWW_HOME:
 465                 usage = AC_HOME;
 466                 break;
 467             case KC_WWW_BACK:
 468                 usage = AC_BACK;
 469                 break;
 470             case KC_WWW_FORWARD:
 471                 usage = AC_FORWARD;
 472                 break;
 473             case KC_WWW_STOP:
 474                 usage = AC_STOP;
 475                 break;
 476             case KC_WWW_REFRESH:
 477                 usage = AC_REFRESH;
 478                 break;
 479             case KC_WWW_FAVORITES:
 480                 usage = AC_BOOKMARKS;
 481                 break;
 482         }
 483         host_consumer_send(usage);
 484     }
 485     else if IS_SYSTEM(code) {
 486         uint16_t usage = 0;
 487         switch (code) {
 488             case KC_SYSTEM_POWER:
 489                 usage = SYSTEM_POWER_DOWN;
 490                 break;
 491             case KC_SYSTEM_SLEEP:
 492                 usage = SYSTEM_SLEEP;
 493                 break;
 494             case KC_SYSTEM_WAKE:
 495                 usage = SYSTEM_WAKE_UP;
 496                 break;
 497         }
 498         host_system_send(usage);
 499     }
 500 #endif
 501 }
 502
 503 static void unregister_code(uint8_t code)
 504 {
 505     if IS_KEY(code) {
 506         host_del_key(code);
 507         host_send_keyboard_report();
 508     }
 509     else if IS_MOD(code) {
 510         host_del_mods(MOD_BIT(code));
 511         host_send_keyboard_report();
 512     }
 513 #ifdef MOUSEKEY_ENABLE
 514     else if IS_MOUSEKEY(code) {
 515         mousekey_off(code);
 516         mousekey_send();
 517     }
 518 #endif
 519 #ifdef EXTRAKEY_ENABLE
 520     else if IS_CONSUMER(code) {
 521         host_consumer_send(0x0000);
 522     }
 523     else if IS_SYSTEM(code) {
 524         host_system_send(0x0000);
 525     }
 526 #endif
 527 }
 528
 529 static void register_mods(uint8_t mods)
 530 {
 531     if (!mods) return;
 532     host_add_mods(mods);
 533     host_send_keyboard_report();
 534 }
 535
 536 static void unregister_mods(uint8_t mods)
 537 {
 538     if (!mods) return;
 539     host_del_mods(mods);
 540     host_send_keyboard_report();
 541 }
 542
 543 static void clear_keyboard(void)
 544 {
 545     host_clear_mods();
 546     clear_keyboard_but_mods();
 547 }
 548
 549 static void clear_keyboard_but_mods(void)
 550 {
 551     host_clear_keys();
 552     host_send_keyboard_report();
 553 #ifdef MOUSEKEY_ENABLE
 554     mousekey_clear();
 555     mousekey_send();
 556 #endif
 557 #ifdef EXTRAKEY_ENABLE
 558     host_system_send(0);
 559     host_consumer_send(0);
 560 #endif
 561 }
 562
 563 static void layer_switch(uint8_t new_layer)
 564 {
 565     if (current_layer != new_layer) {
 566         Kdebug("Layer Switch: "); Kdebug_hex(current_layer);
 567         Kdebug(" -> "); Kdebug_hex(new_layer); Kdebug("\n");
 568
 569         current_layer = new_layer;
 570         clear_keyboard_but_mods(); // To avoid stuck keys
 571     }
 572 }