Como remover o atraso do caps lock no teclado de alumínio Apple MacBook Pro quando inicializado no Linux

O MacBook Pro da Apple tem um pequeno atraso na tecla Caps Lock . Ou seja, a tecla Caps Lock deve ser mantida pressionada um pouco mais do que o normal para registrar a pressão da tecla necessária para ativar a Caps Lock.

Isso é super chato. Alguém sabe como impedir que isso aconteça?

(Acima, copiado do stackoverflow , pois foi fechado lá como "off topic".)

Para aprofundar: A Apple considera isso um recurso, e o artigo da base de conhecimento não divulga como desativar esse atraso.

No entanto, tenho motivos para acreditar que é possível fazer isso.

Notavelmente, eu descobri que, pelo menos na minha experiência, se você remapear a tecla caps-lock no Mac OS X (em Preferências do sistema .. Teclado .. Teclas modificadoras) e, por exemplo, mapeá-la para Control, o atraso desaparecerá enquanto eu estiver conectado ao Mac OS X.

Meu problema é que o atraso permanece quando eu inicializo no Ubuntu Linux e, nesse contexto, mesmo quando eu remapeado a tecla Caps Lock para Control, o atraso ainda está presente.

Portanto, a pergunta é: como a Apple está desabilitando o atraso e, mais importante, como replicar isso que atua no contexto de uma instalação do Linux no topo do laptop?

Atualização: Há um encadeamento no superusuário que pode fornecer soluções alternativas. Ainda não tentei as sugestões lá (a saber: (1) ativar / desativar CapsLock-NoAction e (2) uma atualização de firmware). Não posso dizer pelo contexto desse segmento se as soluções alternativas foram testadas em uma instalação do Ubuntu.

Eu descobri como fazer isso. Em resumo, você deve enviar um "Relatório de recursos" que consiste nos bytes 0x9, 0x0, 0x0, 0x0para o dispositivo hidraw apropriado como raiz.

Você pode encontrar o dispositivo hidraw correto com este comando:

dmesg | grep Apple | grep Keyboard | grep input0 | tail -1 | sed -e 's/.*hidraw\([[:digit:]]\+\).*/\/dev\/hidraw\1/'

O código para enviar o pacote de controle mágico está abaixo. Compila com o gcc, usa o dispositivo hidraw como parâmetro. Portanto, todo o fluxo é:

1. salve o código abaixo como disable-capslock-delay.c
2. gcc -o disable-capslock-delay disable-capslock-delay.c
3. HIDDEVICE=$(dmesg | grep Apple | grep Keyboard | grep input0 | tail -1 | sed -e 's/.*hidraw\([[:digit:]]\+\).*/\/dev\/hidraw\1/')
4. sudo ./disable-capslock-delay $HIDDEVICE

As etapas 3 e 4 devem ser executadas sempre que você reiniciar (ou desconecte e reconecte o teclado); você pode colocá-los no /etc/rc.local(ou o equivalente da sua distribuição) para executá-los na inicialização (não é necessário sudonesse caso; e você pode mover o binário compilado para /usr/local/sbin/algo assim).

Fiz algumas verificações de segurança quanto ao ID do fornecedor, ID do dispositivo e comprimento do descritor do relatório. Pode ser necessário alterar os dois últimos se o modelo for diferente do meu.

#include <linux/hidraw.h>
#include <sys/ioctl.h>
#include <fcntl.h>
#include <stdio.h>
#include <string.h>


int main(int argc, char **argv) {
  if (argc != 2 || strcmp(argv[1], "-h") == 0) {
    printf("Pass a hidraw device as the first and only parameter!\n");
    printf("You may find the right device with:\n");
    printf("  dmesg | grep Apple | grep Keyboard | grep input0 | tail -1 | "
           "sed -e 's/.hidraw\([[:digit:]]\+\)./\/dev\/hidraw\1/'\n");
    return 1;
  }
  int fd, i, res, desc_size = 0;
  char buf[256];
  struct hidraw_devinfo info;
  char *device = argv[1];
  fd = open(device, O_RDWR | O_NONBLOCK);
  if (fd < 0) {
    perror("Unable to open device");
    return 1;
  }
  memset(&info, 0, sizeof(info));
  memset(buf, 0, sizeof(buf));
  // Get Report Descriptor Size
  res = ioctl(fd, HIDIOCGRDESCSIZE, &desc_size);
  if (res < 0) {
    perror("HIDIOCGRDESCSIZE");
  }
  if (desc_size != 75) {
    printf("Error: unexpected descriptor size %d; you've probably got "
           "the wrong hidraw device!\n", desc_size);
    return 1;
  }
  // Get Raw Info
  res = ioctl(fd, HIDIOCGRAWINFO, &info);
  if (res < 0) {
    perror("HIDIOCGRAWINFO");
  } else {
    if (info.vendor != 0x05ac) {
      printf("Error: Wrong vendor ID, make sure you got the right "
             "hidraw device!\n");
      return 1;
    }
    if (info.product != 0x0250) {
      printf("Warning: Unknown product ID 0x%x!\n", info.product);
    }
  }
  // Get Feature
  buf[0] = 0x09;  // Report Number
  res = ioctl(fd, HIDIOCGFEATURE(256), buf);
  if (res < 0) {
    perror("HIDIOCGFEATURE");
  } else {
    printf("HID Feature Report (before change):\n\t");
    for (i = 0; i < res; i++) printf("%hhx ", buf[i]);
    puts("\n");
  }
  // Set Feature
  buf[0] = 0x09;  // Report Number
  buf[1] = 0x00;  // Report data
  buf[2] = 0x00;  // padding
  buf[3] = 0x00;  // padding
  res = ioctl(fd, HIDIOCSFEATURE(4), buf);
  if (res < 0) {
    perror("HIDIOCSFEATURE");
  } else {
    printf("Caps lock delay disabled.\n");
  }
  // Get Feature
  buf[0] = 0x09;  // Report Number
  res = ioctl(fd, HIDIOCGFEATURE(256), buf);
  if (res < 0) {
    perror("HIDIOCGFEATURE");
  } else {
    printf("HID Feature Report (after change):\n\t");
    for (i = 0; i < res; i++) printf("%hhx ", buf[i]);
    puts("\n");
  }
  close(fd);
  return 0;
}

Aqui está a correção para o macOS Sierra.

Vá para Preferências do Sistema > Acessibilidade

Quando a janela de acessibilidade estiver aberta - à esquerda da janela - clique em Teclado

Depois, haverá as 2 opções - para teclas fixas e para teclas lentas - clique na caixa ao lado de teclas lentas para ativá-lo - clique no Options...botão - uma nova janela será exibida com um controle deslizante para alterar o atraso de aceitação - por padrão isso está no meio. Deslize o botão totalmente para a esquerda, para que seja o menor tempo possível.

Agora deve ser consertado. Não experimentei para ver se a correção permanece após a reinicialização, mas espero que seja.

EDIT: esta parece ser uma pergunta popular de pouso para usuários que desejam remover o atraso na tecla caps lock no OS X. A partir do OS X Mojave,

Vá para Preferências do Sistema; Acessibilidade; Teclado; ative as teclas lentas e entre em opções; reduza o atraso para o mínimo. O único efeito colateral indesejado que notei até agora é a ação lenta do backspace ao pressioná-lo. Geralmente eu uso CMD + A / CMD + SHIFT + L / R / CMD + SHIFT + CTRL + L / R de qualquer maneira, portanto não é um grande problema.

A partir de El Capitan e anteriores,

A solução é bastante ilusória e você realmente não saberia que a removeu, a menos que estivesse especificamente tentando se livrar dela em primeiro lugar. O jeito que eu vou lhe mostrar é apenas para a versão mais recente (atual) do OSX, Yosemite. No entanto, você pode aplicar esse método absolutamente a versões anteriores e futuras.

A solução é simples. Se você navegar para o teclado nas preferências do sistema, através do logotipo da apple no canto superior esquerdo, chegará a esta tela! [Insira a descrição da imagem aqui] [1]

[1]: http://i.stack.imgur.com/DIbZD.png

Se você clicar no botão das teclas modificadoras, poderá alterar a função de cada uma das teclas programáveis. Tudo o que você precisa fazer é definir a tecla caps lock para nenhuma ação e pressionar ok para retornar ao menu do teclado. Uma vez feito, volte para as teclas modificadoras e mude a tecla caps lock novamente para caps lock e isso removerá o atraso! Observe que essa correção permanece no local até você dormir, reiniciar ou desligar o dispositivo. Nesse momento, o atraso é restabelecido.

São correções estranhas, e isso levanta a questão: por que elas não fornecem uma opção para remover o atraso quando essa correção é puramente baseada em software? Mas ei, pelo menos há um caminho!

Feliz virada.

Vá para preferências do sistema> acessibilidade> teclado> habilite teclas lentas> altere o atraso da aceitação até a esquerda (curta)! Isso funcionou para mim.

Sei com certeza que o atraso do caps lock é um recurso do firmware no próprio teclado - para que você possa ter certeza de que o tempo de atraso ocorre, independentemente do sistema operacional em que o teclado está operando no momento.

Sei também que a Apple não oferece um caminho para atualizar o firmware para um nível inferior; portanto, todos teremos que esperar até que alguém com experiência de hardware suficiente faça o blog das ferramentas e etapas que eles executaram para induzir o hardware a carregar o firmware mais antigo (ou fornecer o que parece ser um firmware mais recente que regride o atraso para como ele funcionava antes sem nenhum atraso.)

Peço desculpas pela não resposta, mas o caminho para isso é bem iluminado e pode ajudar outras pessoas a agir (selecionando um teclado mais antigo - ou evitando atualizar o firmware) enquanto isso, enquanto esperamos por uma solução real para implementar um temporizador curto ou nenhum na tecla caps lock.

A solução "ativar / desativar o CapsLock-NoAction" ao qual o OP se refere funciona tanto no teclado Mac com fio quanto no teclado do MacBookPro. Bradley diz que isso só funciona em Yosemite, mas eu o usei com sucesso no Snow Leopard (10.6.8) e Mavericks (10.9.5). Também testei isso dentro de uma VM Kubuntu e o Caps Lock continuou funcionando corretamente dentro da VM.

• Abra a Preferência do sistema de teclado e clique em Modifier Keys...:

• Defina a tecla Caps Lock como No Actione clique em OK:

• Clique Modifier Keys...novamente e defina a tecla Caps Lock como Caps Locke clique em OK:

Isso permanece em vigor até a próxima reinicialização.