Workspace Stopwatch?

Question

Existe um programa que pode servir como um cronômetro dependente do espaço de trabalho? Gostaria de saber quanto tempo passei em cada espaço de trabalho todos os dias.

Editar: estou usando o Unity.

    

Answer 1

Boa pergunta!

O script abaixo cria um arquivo de log: ~/viewport_log.txt em seu diretório inicial, onde ele relata o tempo de uso da porta de visualização da sessão atual (área de trabalho) por porta de visualização.

O relatório é atualizado uma vez por dois segundos, parecendo (em uma execução rápida):

workspace1 0:00:24
workspace2 0:00:05
workspace6 0:00:04
workspace8 0:00:05

no formato

hours:minutse:seconds

Como você pode ver, usei apenas o espaço de trabalho 1, 2, 6 e 8.

Como usar

O script usa o comando wmctrl -d para obter os dados da viewport atual, portanto, é necessário instalá-lo primeiro:

sudo apt-get install wmctrl

Então:

1. Copie o script abaixo em um arquivo vazio, salve-o como workspace_log.py

2. Teste-o pelo comando:

   python3 /path/to/workspace_log.py
   

   Navegue pelos diferentes espaços de trabalho e abra o arquivo ~/viewport_log.txt para ver o resultado (alternativamente, execute em um terminal cat ~/viewport_log.txt para leitura conveniente, pois o registro é atualizado uma vez por segundo).

3. se tudo funcionar conforme o esperado, adicione o comando aos seus aplicativos de inicialização. Como ele provavelmente falhará se o script for iniciado muito cedo (antes que a área de trabalho esteja totalmente carregada), você provavelmente precisará adicionar uma pequena quebra no comando de inicialização para fazê-lo funcionar como um aplicativo de inicialização, então o comando é:

   /bin/bash -c "sleep 15&&python3 /path/to/workspace_log.py"
   

   Para adicioná-lo a aplicativos de inicialização: Dash > Aplicativos de inicialização > Adicione e adicione o comando.

O script

import subprocess
import os
import time

# define / clear log file
home = os.environ["HOME"]
logfile = home+"/"+"viewport_log.txt"
open(logfile, "wt").write("")
vplist = []

def get_res():
    # get resolution
    xr = subprocess.check_output(["xrandr"]).decode("utf-8").split()
    pos = xr.index("current")
    return [int(xr[pos+1]), int(xr[pos+3].replace(",", "") )]

def get_dt():
    # get the current viewport
    res = get_res()
    vp_data = subprocess.check_output(["wmctrl", "-d"]).decode("utf-8").split()
    dt = [int(n) for n in vp_data[3].split("x")]
    cols = int(dt[0]/res[0])
    curr_vpdata = [int(n) for n in vp_data[5].split(",")]
    curr_col = int(curr_vpdata[0]/res[0])+1; curr_row = int(curr_vpdata[1]/res[1])
    return str(curr_col+curr_row*cols)

def time_format(s):
    # convert time format from seconds to h:m:s
    m, s = divmod(s, 60)
    h, m = divmod(m, 60)
    return "%d:%02d:%02d" % (h, m, s)

current_time1 = float(time.time())
curr_dt1 = get_dt()

while True:
    time.sleep(2)
    curr_dt2 = get_dt()
    if curr_dt2 == curr_dt1:
        current_time2 = float(time.time())
        span = current_time2-current_time1
        vp = "workspace "+curr_dt1+" . "*10
        vplist.sort(key=lambda x: x[0])
        if not vp in [v[0] for v in vplist]:
            vplist.append([vp, span])
        else: 
            index = vplist.index([vplist[i] for i in range(len(vplist)) if vplist[i][0] == vp][0])
            vplist[index][1] = float(vplist[index][1])+span
        with open(logfile, "wt") as out:
            for item in vplist:
                out.write(item[0]+" "+time_format(item[1])+"\n")
    current_time1 = current_time2
    curr_dt1 = curr_dt2

Propriedades do script

O script calcula o intervalo de tempo exato entre dois momentos i.c.w. as áreas de trabalho usadas desses momentos (2 segundos como estão, o intervalo na linha time.sleep(2) ) se os espaços de trabalho em ambos os momentos são os mesmos, o tempo é adicionado ao tempo de uso total da área de trabalho correspondente.

Se os espaços de trabalho em ambos os momentos forem diferentes, fica claro que havia um comutador de espaço de trabalho e o tempo é adicionado ao tempo produtivo de nenhum espaço de trabalho; o tempo na visão geral em ~/viewport_log.txt é, portanto, arredondado para dois segundos por período por área de trabalho.

Editar

Executando o script acima em segundo plano, você pode visualizar o (s) horário (s) de uso atual por espaço de trabalho colocando o script abaixo sob uma combinação de teclas:

#!/bin/bash
lines="$( cat ~/viewport_log.txt )"
zenity --info --title='Usage per Viewport' --text="$lines"

1. Copie o script em um arquivo vazio, salve-o como view_vplog.sh

2. Execute-o, enquanto o primeiro script estiver sendo executado em segundo plano , pelo comando:

   sh /path/to/view_vplog.sh
   

3. Disponibilize-o (após o teste) com uma combinação de teclas de atalho: escolha: Configurações do sistema > "Teclado" > "Atalhos" > "Atalhos personalizados". Clique no botão "+" e adicione o comando a uma combinação de teclas à sua escolha.