267 lines
8.5 KiB
Go
267 lines
8.5 KiB
Go
package ui
|
|
|
|
import (
|
|
"context"
|
|
"io"
|
|
"io/ioutil"
|
|
"log"
|
|
"os"
|
|
"os/exec"
|
|
"syscall"
|
|
"time"
|
|
|
|
"github.com/eiannone/keyboard"
|
|
"github.com/knadh/koanf"
|
|
|
|
"git.kemonine.info/PiFrame/config"
|
|
)
|
|
|
|
const (
|
|
PATH_TEMP_FOR_SLIDESHOW = "/run/piframe/fim"
|
|
)
|
|
|
|
// fim placeholders so we can reset them as needed
|
|
var fim *exec.Cmd = nil
|
|
var stdin io.WriteCloser = nil
|
|
|
|
func setupFim(PATH_TEMP_FOR_SLIDESHOW string) {
|
|
// Prep slideshow command and arguments
|
|
// NOTE: The random flag is seeded with time() ; this is bad as we will be restarting the slideshow at about the same time per the configurd schedule
|
|
// We use the non-seeded form to ensure that it's a little more random (or at least hope it's a little more random)
|
|
CMD_FIM := "/usr/bin/fim"
|
|
ARGS_FIM := []string{"--no-commandline", "--no-history", "--etc-fimrc", "/usr/local/etc/fimrc",
|
|
"--device", "/dev/fb0", "--vt", "1",
|
|
"--execute-commands-early", "\"clear\"", "--final-commands", "\"clear\"",
|
|
"--autozoom", "--random", "--recursive", "--cd-and-readdir",
|
|
PATH_TEMP_FOR_SLIDESHOW}
|
|
|
|
// fim command that'll be executed
|
|
fim = exec.Command(CMD_FIM, ARGS_FIM...)
|
|
// Put fim into a process group so ALL processes that may be executed are exited when main process exits
|
|
fim.SysProcAttr = &syscall.SysProcAttr{Setpgid: true}
|
|
|
|
// Setup stdin for fim to control slideshow
|
|
stdinLocal, err := fim.StdinPipe()
|
|
if err != nil {
|
|
log.Fatalf("Error getting fim stdin : %s", err)
|
|
}
|
|
stdin = stdinLocal
|
|
}
|
|
|
|
func Slideshow(pfconfig *koanf.Koanf) {
|
|
// Prep folder setup needed for fim
|
|
// fim does NOT allow multiple folders passed on the CLI (as far as KemoNine can tell)
|
|
// We build a temp folder stup in /run/piframe/fim that has symlinks to selected albums
|
|
// After we build up this directory setup we'll kick off fim against the temp dir with recursive
|
|
// /run is a tmpfs so this won't wear on the sd card storage
|
|
|
|
// Create temp folder
|
|
_, err := os.Stat(PATH_TEMP_FOR_SLIDESHOW)
|
|
if os.IsNotExist(err) {
|
|
errDir := os.MkdirAll(PATH_TEMP_FOR_SLIDESHOW, 0755)
|
|
if errDir != nil {
|
|
log.Fatalf("Error setting up slideshow : %s", err)
|
|
}
|
|
}
|
|
|
|
// Cleanup temp folder if it already existed
|
|
dirRead, err := os.Open(PATH_TEMP_FOR_SLIDESHOW)
|
|
if err != nil {
|
|
log.Fatalf("Error setting up slideshow : %s", err)
|
|
}
|
|
dirFiles, err := dirRead.Readdir(0)
|
|
if err != nil {
|
|
log.Fatalf("Error setting up slideshow : %s", err)
|
|
}
|
|
// Loop over the directory's files.
|
|
for index := range dirFiles {
|
|
fileHere := dirFiles[index]
|
|
|
|
// Get name of file and its full path.
|
|
nameHere := fileHere.Name()
|
|
fullPath := PATH_TEMP_FOR_SLIDESHOW + "/" + nameHere
|
|
|
|
// Remove the file.
|
|
err = os.Remove(fullPath)
|
|
if err != nil {
|
|
log.Fatalf("Error setting up slideshow : %s", err)
|
|
}
|
|
}
|
|
|
|
// Setup symlinks to selected albums to be used with slideshow
|
|
// Add albums full paths to command line args for fim
|
|
albumRootPath := pfconfig.String(config.CONFIG_KEY_ALBUMS_ROOT)
|
|
for _, album := range pfconfig.Strings(config.CONFIG_KEY_ALBUMS_SELECTED) {
|
|
source := albumRootPath + album
|
|
destination := PATH_TEMP_FOR_SLIDESHOW + album
|
|
if album == "/" {
|
|
files, err := ioutil.ReadDir(albumRootPath)
|
|
if err != nil {
|
|
log.Fatalf("Error setting up slideshow : %s", err)
|
|
}
|
|
|
|
for _, file := range files {
|
|
filePath := albumRootPath + "/" + file.Name()
|
|
fileStat, err := os.Stat(filePath)
|
|
if err != nil {
|
|
log.Fatalf("Error setting up slideshow : %s", err)
|
|
}
|
|
mode := fileStat.Mode()
|
|
if mode.IsRegular() {
|
|
err = os.Symlink(filePath, PATH_TEMP_FOR_SLIDESHOW+"/"+file.Name())
|
|
if err != nil {
|
|
log.Fatalf("Error setting up slideshow : %s", err)
|
|
}
|
|
}
|
|
}
|
|
continue
|
|
}
|
|
err = os.Symlink(source, destination)
|
|
if err != nil {
|
|
log.Fatalf("Error setting up slideshow : %s", err)
|
|
}
|
|
}
|
|
|
|
// Setup fim for run
|
|
// Commands can't be re-used so we move this to a function to support the restart interval cleanly
|
|
setupFim(PATH_TEMP_FOR_SLIDESHOW)
|
|
|
|
// Advance slideshow every interval as defined in const()
|
|
slideshowAdvanceDurationString := pfconfig.String(config.CONFIG_KEY_SLIDESHOW_INTERVAL)
|
|
slideshowAdvanceDuration, err := time.ParseDuration(slideshowAdvanceDurationString)
|
|
if err != nil {
|
|
log.Fatalf("Error parsing slide duration : %s", err)
|
|
}
|
|
ticker := time.NewTicker(slideshowAdvanceDuration)
|
|
stop_ticker := make(chan struct{})
|
|
go func() {
|
|
for {
|
|
select {
|
|
case <-ticker.C:
|
|
_, err = io.WriteString(stdin, "n")
|
|
if err != nil {
|
|
log.Fatalf("Error advancing slides : %s", err)
|
|
}
|
|
case <-stop_ticker:
|
|
ticker.Stop()
|
|
stdin.Close()
|
|
return
|
|
}
|
|
}
|
|
}()
|
|
|
|
// Start watching for key strokes and echo them back to stdout
|
|
keysEvents, err := keyboard.GetKeys(10)
|
|
if err != nil {
|
|
log.Fatalf("Error setting up keyboard listener : %s", err)
|
|
}
|
|
// NOT deferring keyboard.close as we do that by hand further down when fim exits ahead of showing the config UI
|
|
|
|
// Keep running fim until we're signaled by the user to do otherwise
|
|
// Common reasons that we MUST do this kind of goofy (bugs / behavior)
|
|
// - fim doesn't quite see the /run changes where the albums are linked and bails out
|
|
// - OOM kicks in and kills fim (it's kinda RAM heavy sometimes)
|
|
// - Corrupt or invalid image causes fim to crash
|
|
// - The timeout for re-randomizing kicked free and fim needs to restart
|
|
// - fim thinks the slideshow has 'ended' for whatever reason and we really want to always show no matter what
|
|
STOP_SLIDESHOW := false
|
|
|
|
// Goroutine for tracking which keys are pressed and controlling fim if appropriate
|
|
keyboardCtx, keyboardCancel := context.WithCancel(context.Background())
|
|
go func(keyboardCtx context.Context) {
|
|
for {
|
|
select {
|
|
case <-keyboardCtx.Done():
|
|
return
|
|
case event := <-keysEvents:
|
|
if event.Err != nil {
|
|
log.Fatalf("Error listening to key events : %s", err)
|
|
}
|
|
|
|
// Keys for fim event management (previous/next in particular)
|
|
fimKey := ""
|
|
if event.Key == keyboard.KeyArrowLeft || event.Key == keyboard.KeyArrowDown {
|
|
fimKey = "p"
|
|
}
|
|
if event.Key == keyboard.KeyArrowRight || event.Key == keyboard.KeyArrowUp {
|
|
fimKey = "n"
|
|
}
|
|
|
|
// Exit fim and move to the config UI
|
|
if event.Key == keyboard.KeyEsc || event.Key == keyboard.KeyEnter || event.Key == keyboard.KeySpace {
|
|
// We are being told to stop the slideshow, oblidge the user
|
|
STOP_SLIDESHOW = true
|
|
if fim != nil { // Just in case someone lays on exit key or similar during startup
|
|
pgid, err := syscall.Getpgid(fim.Process.Pid)
|
|
if err == nil {
|
|
if err := syscall.Kill(-pgid, 9); err != nil {
|
|
log.Fatalf("failed to kill fim : %s", err)
|
|
}
|
|
}
|
|
}
|
|
break
|
|
}
|
|
|
|
// Control fim if we received a valid key for next/previous slide
|
|
if fimKey != "" {
|
|
_, err = io.WriteString(stdin, fimKey)
|
|
if err != nil {
|
|
log.Fatalf("Error controlling fim : %s", err)
|
|
}
|
|
ticker.Reset(pfconfig.Duration(config.CONFIG_KEY_SLIDESHOW_INTERVAL))
|
|
}
|
|
}
|
|
}
|
|
}(keyboardCtx)
|
|
|
|
// Restart fim after configured timeout ; This is setup as a ticker due to KemoNine not getting CommandWithContext stuff to work properly (lots of pointer related crashes and the like)
|
|
fimRestartDurationString := pfconfig.String(config.CONFIG_KEY_SLIDESHOW_RESTART_INTERVAL)
|
|
fimRestartDuration, err := time.ParseDuration(fimRestartDurationString)
|
|
if err != nil {
|
|
log.Fatalf("Error parsing restart duration : %S", err)
|
|
}
|
|
fimTicker := time.NewTicker(fimRestartDuration)
|
|
stop_fim_ticker := make(chan struct{})
|
|
go func() {
|
|
for {
|
|
select {
|
|
case <-fimTicker.C:
|
|
if fim != nil { // Just in case someone lays on exit key or similar during startup
|
|
pgid, err := syscall.Getpgid(fim.Process.Pid)
|
|
if err == nil {
|
|
if err := syscall.Kill(-pgid, 9); err != nil {
|
|
log.Fatalf("failed to kill fim : %s", err)
|
|
}
|
|
}
|
|
}
|
|
case <-stop_fim_ticker:
|
|
fimTicker.Stop()
|
|
return
|
|
}
|
|
}
|
|
}()
|
|
|
|
// Run fim
|
|
for !STOP_SLIDESHOW {
|
|
if err := fim.Run(); err != nil {
|
|
// Unwrap the error a bit so we can find out if a signal killed fim or something else
|
|
// An exit code of -1 means the program didn't exit in time or was terminated by a signal (per the docs)
|
|
if exitError, ok := err.(*exec.ExitError); ok && exitError.ExitCode() != -1 {
|
|
// We are NOT going to fatal here as there are many 'valid' reasons fim would exit for no good reason ;)
|
|
log.Printf("Error running fim : %s", err)
|
|
}
|
|
}
|
|
setupFim(PATH_TEMP_FOR_SLIDESHOW)
|
|
}
|
|
|
|
// Stop fim slideshow advancing go routine
|
|
close(stop_ticker)
|
|
// Stop restart go routine
|
|
close(stop_fim_ticker)
|
|
|
|
// Stop listening to keyboard events
|
|
keyboard.Close()
|
|
keyboardCancel()
|
|
|
|
}
|