[profile] / bin / disorder-notify

#! /usr/bin/perl -w

use autodie qw{:all};
use strict;

use DisOrder;
use File::FcntlLock;
use Getopt::Long qw{:config gnu_compat bundling
		    require_order no_getopt_compat};
use POSIX qw{:errno_h :fcntl_h};

###--------------------------------------------------------------------------
### Configuration.

my %C = (config => "$ENV{HOME}/.disorder/passwd",
	 lockdir => "$ENV{HOME}/.disorder/",
	 mixer => "Master,0");

(my $PROG = $0) =~ s:^.*/::;
my $TITLE = "DisOrder";
my $VARIANT = "default";
if (-l $C{config} && (my $t = readlink $C{config}) =~ /^passwd\.(.*)$/)
  { $VARIANT = $1; $TITLE .= " ($1)"; }

###--------------------------------------------------------------------------
### Random utilities.

sub run_discard_output (@) {
  my $kid = fork();
  if (!$kid) {
    open STDOUT, ">/dev/null" or die "open /dev/null: $!";
    exec @_;
  }
  waitpid $kid, 0;
  if ($?) {
    my $st;
    if ($? >= 256) { $st = sprintf "rc = %d", $? >> 8; }
    else { $st = sprintf "signal %d", $?; }
    die "$_[0] failed ($st)";
  }
}

sub notify ($$) {
  my ($head, $body) = @_;

  $body =~ s:\&:&amp;:g;
  $body =~ s:\<:&lt;:g;
  $body =~ s:\>:&gt;:g;

  ##print "****************\n$head\n\n$body\n"; return;

  run_discard_output "notify-send",
    "-c", "DisOrder", "-i", "audio-volume-high", "-t", "5000",
    $head, $body;
}

sub try_unlink ($) {
  my ($f) = @_;
  eval { unlink $f; };
  die $@ if $@ and $@->errno != ENOENT;
}

###--------------------------------------------------------------------------
### Locking protocol.

my $LKFILE = "$C{lockdir}/disorder-notify-$VARIANT.lock";
my $LKFH;

sub locked_by () {

  ## Try to open the lock file.  If it's not there, then obviously it's not
  ## locked.
  my $fh;
  eval { open $fh, "<", $LKFILE; };
  if ($@) {
    return undef if $@->errno == ENOENT;
    die $@;
  }

  ## Take out a non-exclusive lock on the lock file.
  my $lk = new File::FcntlLock;
  $lk->l_type(F_RDLCK); $lk->l_whence(SEEK_SET);
  $lk->l_start(0); $lk->l_len(0);
  if ($lk->lock($fh, F_SETLK)) { close $fh; return undef; }

  ## Read the pid of the current lock-holder.
  chomp (my $pid = (readline $fh) // "<unknown>");
  close $fh;
  return $pid;
}

sub claim_lock () {
  sysopen my $fh, $LKFILE, O_CREAT | O_WRONLY;

  my $lk = new File::FcntlLock;
  $lk->l_type(F_WRLCK); $lk->l_whence(SEEK_SET);
  $lk->l_start(0); $lk->l_len(0);
  if (!$lk->lock($fh, F_SETLK)) {
    return undef if $! == EAGAIN;
    die "failed to lock `$LKFILE': $!";
  }

  truncate $fh, 0;
  print $fh "$$\n";
  flush $fh;
  $LKFH = $fh;
  1;
}

###--------------------------------------------------------------------------
### DisOrder utilities.

sub get_state0 ($) {
  my ($sk) = @_;
  my %st = ();

  LINE: for (;;) {
    my @f = split_fields readline $sk;
    if ($f[1] ne "state") { last LINE; }
    elsif ($f[2] eq "enable_random") { $st{random} = 1; }
    elsif ($f[2] eq "disable_random") { $st{random} = 0; }
    elsif ($f[2] eq "enable_play") { $st{play} = 1; }
    elsif ($f[2] eq "disable_play") { $st{play} = 0; }
    elsif ($f[2] eq "resume") { $st{pause} = 0; }
    elsif ($f[2] eq "pause") { $st{pause} = 1; }
  }
  return \%st;
}

my $CONF = undef;

sub configured_connection (;$) {
  my ($quietp) = @_;
  $CONF //= load_config $C{config};
  return connect_to_server %$CONF, $quietp // 0;
}

sub get_state () {
  my $sk = configured_connection;
  send_command0 $sk, "log";
  my $st = get_state0 $sk;
  close $sk;
  return $st;
}

sub decode_track_name ($\%) {
  my ($sk, $info) = @_;
  return unless exists $info->{track};
  my $track = $info->{track};
  for my $i ("artist", "album", "title") {
    my @f = split_fields send_command $sk, "part", $track, "display", "$i";
    $info->{$i} = $f[0];
  }
}

sub fmt_duration ($) {
  my ($n) = @_;
  return sprintf "%d:%02d", int $n/60, $n%60;
}

sub get_now_playing ($) {
  my ($sk) = @_;
  my $r = send_command $sk, "playing";
  defined $r or return {};
  my %info = split_fields $r;
  decode_track_name $sk, %info;
  exists $info{sofar} and
    $info{length} = send_command $sk, "length", $info{track};
  return \%info;
}

sub format_now_playing (;\%) {
  my ($info) = @_;
  unless (defined $info) {
    my $sk = configured_connection;
    $info = get_now_playing $sk;
    close $sk;
  }
  exists $info->{track} or return "Nothing.";
  my $r = "$info->{artist}: ‘$info->{title}’";
  $r .= ", from ‘$info->{album}’" if $info->{album};
  exists $info->{sofar} && exists $info->{length} and
    $r .= sprintf " (%s/%s)",
      fmt_duration $info->{sofar}, fmt_duration $info->{length};
  $r .= "\n(chosen by $info->{submitter})" if exists $info->{submitter};
  return $r;
}

sub watch_and_notify0 ($) {
  my ($now_playing) = @_;

  my $sk = configured_connection 1;
  my $sk_log = configured_connection 1;

  send_command0 $sk_log, "log";
  my $st = get_state0 $sk_log;
  my $msg = "playing " . ($st->{play} ? "enabled" : "disabled");
  $msg .= "; random play " . ($st->{random} ? "enabled" : "disabled");
  $msg .= "; " . ($st->{pause} ? "paused" : "playing");
  notify "$TITLE state", "Connected: $msg";
  if ($st->{play} && $now_playing) {
    my $info = get_now_playing $sk;
    notify "$TITLE: Now playing", format_now_playing %$info;
  }

  fcntl $sk_log, F_SETFL, (fcntl $sk_log, F_GETFL, 0) | O_NONBLOCK;
  my $buffer = "";
  my @lines = ();
  my $rdin = ""; vec($rdin, (fileno $sk_log), 1) = 1;
  my $loss;

  WATCH: for (;;) {
    for my $line (@lines) {
      my @f = split_fields $line;
      if ($f[1] eq "state") {
	my $msg = undef;
	if ($f[2] eq "disable_random")
	  { $st->{random} = 0; $msg = "Random play disabled"; }
	elsif ($f[2] eq "enable_random")
	  { $st->{random} = 1; $msg = "Random play enabled"; }
	elsif ($f[2] eq "disable_play")
	  { $st->{play} = 0; $msg = "Playing disabled"; }
	elsif ($f[2] eq "enable_play")
	  { $st->{play} = 1; $msg = "Playing enabled"; }
	elsif ($f[2] eq "pause")
	  { $st->{pause} = 1; $msg = "Paused"; }
	elsif ($f[2] eq "resume")
	  { $st->{pause} = 0; $msg = "Playing"; }
	notify "$TITLE state", $msg if defined $msg;
      } elsif ($f[1] eq "playing") {
	my %info;
	$info{track} = $f[2];
	$info{submitter} = $f[3] if @f > 3;
	decode_track_name $sk, %info;
	notify "$TITLE: Now playing", format_now_playing %info;
      } elsif ($f[1] eq "scratched") {
	my %info;
	$info{track} = $f[2];
	decode_track_name $sk, %info;
	notify "$TITLE: Scratched by $f[3]", format_now_playing %info;
      }
    }

    if (!$sk_log) { $loss = "EOF from server"; last WATCH; }
    my $nfd = select my $rdout = $rdin, undef, undef, 60;
    if (!$nfd) {
      eval { print $sk_log "."; flush $sk_log; };
      if ($@) { $loss = "error from write: " . $@->errno; last WATCH; }
      @lines = ();
    } else {
      READ: for (;;) {
	my ($b, $n);
	eval { $n = sysread $sk_log, $b, 4096; };
	if ($@ && $@->errno == EAGAIN) { last READ; }
	elsif ($@) { $loss = "error from read: " . $@->errno; last WATCH; }
	elsif (!$n) { close $sk_log; $sk_log = undef; last READ; }
	else { $buffer .= $b; }
      }

      @lines = split /\n/, $buffer, -1;
      $buffer = pop @lines;
    }
  }

  notify "$TITLE state", "Lost connection: $loss";

  close $sk;
  close $sk_log if defined $sk_log;
}

sub watch_and_notify ($) {
  my ($now_playing) = @_;

  claim_lock or exit 1;

  for (;;) {
    eval { watch_and_notify0 $now_playing; };
    $now_playing = 1;
    sleep 5;
  }
}

###--------------------------------------------------------------------------
### User-facing operations.

my %OP;

$OP{"volume-up"} =
  sub { run_discard_output "amixer", "sset", $C{mixer}, "5\%+"; };
$OP{"volume-down"} =
  sub { run_discard_output "amixer", "sset", $C{mixer}, "5\%-"; };

$OP{"scratch"} = sub {
  my $sk = configured_connection;
  send_command $sk, "scratch";
  close $sk;
};

$OP{"enable/disable"} = sub {
  my $st = get_state;
  my $sk = configured_connection;
  if ($st->{play}) { send_command $sk, "disable"; }
  else { send_command $sk, "enable"; }
  close $sk;
};

$OP{"play/pause"} = sub {
  my $st = get_state;
  my $sk = configured_connection;
  if (!$st->{play}) {
    send_command $sk, "enable";
    if ($st->{pause}) { send_command $sk, "resume"; }
  } else {
    if ($st->{pause}) { send_command $sk, "resume"; }
    else { send_command $sk, "pause"; }
  }
  close $sk;
};

$OP{"watch"} = sub {
  if (defined (my $lkpid = locked_by)) {
    print STDERR "$0: already watched by pid $lkpid\n";
    exit 2;
  }
  watch_and_notify 1;
};

$OP{"now-playing"} = sub {
  my $sk = configured_connection;
  my $info = get_now_playing $sk;
  close $sk;
  print format_now_playing %$info;
  print "\n";
};

$OP{"notify-now-playing"} = sub {
  my $sk = configured_connection;
  my $info = get_now_playing $sk;
  close $sk;
  notify "$TITLE: Now playing", format_now_playing %$info;
  unless (defined locked_by) {
    fork and exit 0;
    watch_and_notify 0;
  }
};

$OP{"next-config"} = sub {
  (my $dir = $C{config}) =~ s:/[^/]*$::;
  my (@conf, $curr, $conf, $min);

  if (-l $C{config} && (my $t = readlink $C{config}) =~ /^passwd\.(.*)$/)
    { $curr = $1; }

  opendir my $dh, +$dir;
  FILE: while (my $f = readdir $dh)
    { push @conf, $1 if $f =~ /^passwd\.(.*[^~])$/; }

  for (my $i = 0; $i < @conf; $i++) {
    $min = $conf[$i] if (!defined $min) || $conf[$i] lt $min;
    $conf = $conf[$i]
      if ((!defined $curr) || $curr lt $conf[$i]) &&
	 ((!defined $conf) || $conf[$i] lt $conf);
  }
  $conf = $min unless defined $conf;

  try_unlink "$dir/passwd.new";
  symlink "passwd.$conf", "$dir/passwd.new";
  rename "$dir/passwd.new", "$dir/passwd";
  notify "DisOrder configuration", "Switched to `$conf'";
};

###--------------------------------------------------------------------------
### Main program.

sub usage (\*) {
  my ($fh) = @_;
  print $fh "usage: $PROG [-u CONFIG] COMMAND\n";
}

sub help () {
  usage *STDOUT;
  print <<EOF;

Command-line options:
  -h, --help		Show this help text
  -u, --user-config	Set user configuration file

Commands:
  volume-up
  volume-down
  scratch
  enable/disable
  play/pause
  watch
  now-playing
  notify-now-playing
  next-config
EOF
}

my $bad = 0;
GetOptions
  "h|help" => sub { help; exit 0; },
  "u|user-config=s" => \$C{config}
    or $bad = 1;
@ARGV == 1 or $bad = 1;
if ($bad) { usage *STDERR; exit 2; }
my $op = $ARGV[0];
if (!exists $OP{$op}) { print STDERR "$0: unknown op `$op'\n"; exit 2; }
$OP{$op}();

###----- That's all, folks --------------------------------------------------
Commit	Line	Data
a1b30762 MW	1	#! /usr/bin/perl -w
	2
	3	use autodie qw{:all};
	4	use strict;
	5
	6	use DisOrder;
	7	use File::FcntlLock;
21ec4bc8 MW	8	use Getopt::Long qw{:config gnu_compat bundling
21ec4bc8 MW	9	require_order no_getopt_compat};
a1b30762 MW	10	use POSIX qw{:errno_h :fcntl_h};
	11
	12	###--------------------------------------------------------------------------
	13	### Configuration.
	14
	15	my %C = (config => "$ENV{HOME}/.disorder/passwd",
	16	lockdir => "$ENV{HOME}/.disorder/",
	17	mixer => "Master,0");
	18
21ec4bc8	19	(my $PROG = $0) =~ s:^.*/::;
a1b30762 MW	20	my $TITLE = "DisOrder";
	21	my $VARIANT = "default";
	22	if (-l $C{config} && (my $t = readlink $C{config}) =~ /^passwd\.(.*)$/)
	23	{ $VARIANT = $1; $TITLE .= " ($1)"; }
	24
	25	###--------------------------------------------------------------------------
	26	### Random utilities.
	27
	28	sub run_discard_output (@) {
	29	my $kid = fork();
	30	if (!$kid) {
	31	open STDOUT, ">/dev/null" or die "open /dev/null: $!";
	32	exec @_;
	33	}
	34	waitpid $kid, 0;
	35	if ($?) {
	36	my $st;
	37	if ($? >= 256) { $st = sprintf "rc = %d", $? >> 8; }
	38	else { $st = sprintf "signal %d", $?; }
	39	die "$_[0] failed ($st)";
	40	}
	41	}
6bdf3aad MW	42
	43	sub notify ($$) {
	44	my ($head, $body) = @_;
	45
0452eefc MW	46	$body =~ s:\&:&:g;
	47	$body =~ s:\<:<:g;
	48	$body =~ s:\>:>:g;
a1b30762 MW	49
	50	##print "****************\n$head\n\n$body\n"; return;
	51
	52	run_discard_output "notify-send",
	53	"-c", "DisOrder", "-i", "audio-volume-high", "-t", "5000",
	54	$head, $body;
	55	}
	56
	57	sub try_unlink ($) {
	58	my ($f) = @_;
	59	eval { unlink $f; };
	60	die $@ if $@ and $@->errno != ENOENT;
	61	}
	62
	63	###--------------------------------------------------------------------------
	64	### Locking protocol.
	65
	66	my $LKFILE = "$C{lockdir}/disorder-notify-$VARIANT.lock";
	67	my $LKFH;
	68
	69	sub locked_by () {
	70
	71	## Try to open the lock file. If it's not there, then obviously it's not
	72	## locked.
	73	my $fh;
	74	eval { open $fh, "<", $LKFILE; };
	75	if ($@) {
	76	return undef if $@->errno == ENOENT;
	77	die $@;
6bdf3aad	78	}
a1b30762 MW	79
	80	## Take out a non-exclusive lock on the lock file.
	81	my $lk = new File::FcntlLock;
	82	$lk->l_type(F_RDLCK); $lk->l_whence(SEEK_SET);
	83	$lk->l_start(0); $lk->l_len(0);
	84	if ($lk->lock($fh, F_SETLK)) { close $fh; return undef; }
	85
	86	## Read the pid of the current lock-holder.
	87	chomp (my $pid = (readline $fh) // "<unknown>");
	88	close $fh;
	89	return $pid;
6bdf3aad MW	90	}
6bdf3aad MW	91
a1b30762 MW	92	sub claim_lock () {
	93	sysopen my $fh, $LKFILE, O_CREAT \| O_WRONLY;
	94
	95	my $lk = new File::FcntlLock;
	96	$lk->l_type(F_WRLCK); $lk->l_whence(SEEK_SET);
	97	$lk->l_start(0); $lk->l_len(0);
	98	if (!$lk->lock($fh, F_SETLK)) {
	99	return undef if $! == EAGAIN;
	100	die "failed to lock `$LKFILE': $!";
	101	}
	102
	103	truncate $fh, 0;
	104	print $fh "$$\n";
	105	flush $fh;
	106	$LKFH = $fh;
	107	1;
994838b7 MW	108	}
994838b7 MW	109
a1b30762 MW	110	###--------------------------------------------------------------------------
	111	### DisOrder utilities.
	112
	113	sub get_state0 ($) {
	114	my ($sk) = @_;
	115	my %st = ();
	116
	117	LINE: for (;;) {
	118	my @f = split_fields readline $sk;
	119	if ($f[1] ne "state") { last LINE; }
	120	elsif ($f[2] eq "enable_random") { $st{random} = 1; }
	121	elsif ($f[2] eq "disable_random") { $st{random} = 0; }
	122	elsif ($f[2] eq "enable_play") { $st{play} = 1; }
	123	elsif ($f[2] eq "disable_play") { $st{play} = 0; }
	124	elsif ($f[2] eq "resume") { $st{pause} = 0; }
	125	elsif ($f[2] eq "pause") { $st{pause} = 1; }
a367c2fe	126	}
a1b30762	127	return \%st;
f1b1fa59 MW	128	}
f1b1fa59 MW	129
be626dd5 MW	130	my $CONF = undef;
	131
	132	sub configured_connection (;$) {
	133	my ($quietp) = @_;
	134	$CONF //= load_config $C{config};
	135	return connect_to_server %$CONF, $quietp // 0;
	136	}
	137
a1b30762	138	sub get_state () {
be626dd5	139	my $sk = configured_connection;
a1b30762 MW	140	send_command0 $sk, "log";
	141	my $st = get_state0 $sk;
	142	close $sk;
	143	return $st;
	144	}
	145
	146	sub decode_track_name ($\%) {
	147	my ($sk, $info) = @_;
	148	return unless exists $info->{track};
	149	my $track = $info->{track};
	150	for my $i ("artist", "album", "title") {
	151	my @f = split_fields send_command $sk, "part", $track, "display", "$i";
	152	$info->{$i} = $f[0];
	153	}
	154	}
	155
16e1b76d MW	156	sub fmt_duration ($) {
	157	my ($n) = @_;
	158	return sprintf "%d:%02d", int $n/60, $n%60;
	159	}
	160
a1b30762 MW	161	sub get_now_playing ($) {
	162	my ($sk) = @_;
	163	my $r = send_command $sk, "playing";
	164	defined $r or return {};
	165	my %info = split_fields $r;
	166	decode_track_name $sk, %info;
16e1b76d MW	167	exists $info{sofar} and
16e1b76d MW	168	$info{length} = send_command $sk, "length", $info{track};
a1b30762 MW	169	return \%info;
	170	}
	171
578deb0e MW	172	sub format_now_playing (;\%) {
	173	my ($info) = @_;
	174	unless (defined $info) {
	175	my $sk = configured_connection;
	176	$info = get_now_playing $sk;
	177	close $sk;
	178	}
	179	exists $info->{track} or return "Nothing.";
	180	my $r = "$info->{artist}: ‘$info->{title}’";
	181	$r .= ", from ‘$info->{album}’" if $info->{album};
	182	exists $info->{sofar} && exists $info->{length} and
	183	$r .= sprintf " (%s/%s)",
	184	fmt_duration $info->{sofar}, fmt_duration $info->{length};
	185	$r .= "\n(chosen by $info->{submitter})" if exists $info->{submitter};
	186	return $r;
	187	}
	188
a1b30762 MW	189	sub watch_and_notify0 ($) {
	190	my ($now_playing) = @_;
	191
be626dd5 MW	192	my $sk = configured_connection 1;
be626dd5 MW	193	my $sk_log = configured_connection 1;
a1b30762 MW	194
	195	send_command0 $sk_log, "log";
	196	my $st = get_state0 $sk_log;
	197	my $msg = "playing " . ($st->{play} ? "enabled" : "disabled");
	198	$msg .= "; random play " . ($st->{random} ? "enabled" : "disabled");
	199	$msg .= "; " . ($st->{pause} ? "paused" : "playing");
	200	notify "$TITLE state", "Connected: $msg";
	201	if ($st->{play} && $now_playing) {
	202	my $info = get_now_playing $sk;
	203	notify "$TITLE: Now playing", format_now_playing %$info;
	204	}
	205
f6ef7584 MW	206	fcntl $sk_log, F_SETFL, (fcntl $sk_log, F_GETFL, 0) \| O_NONBLOCK;
	207	my $buffer = "";
	208	my @lines = ();
	209	my $rdin = ""; vec($rdin, (fileno $sk_log), 1) = 1;
c7eee684	210	my $loss;
f6ef7584 MW	211
	212	WATCH: for (;;) {
	213	for my $line (@lines) {
	214	my @f = split_fields $line;
	215	if ($f[1] eq "state") {
	216	my $msg = undef;
73d8ef9e MW	217	if ($f[2] eq "disable_random")
	218	{ $st->{random} = 0; $msg = "Random play disabled"; }
	219	elsif ($f[2] eq "enable_random")
	220	{ $st->{random} = 1; $msg = "Random play enabled"; }
	221	elsif ($f[2] eq "disable_play")
	222	{ $st->{play} = 0; $msg = "Playing disabled"; }
	223	elsif ($f[2] eq "enable_play")
	224	{ $st->{play} = 1; $msg = "Playing enabled"; }
	225	elsif ($f[2] eq "pause")
	226	{ $st->{pause} = 1; $msg = "Paused"; }
	227	elsif ($f[2] eq "resume")
	228	{ $st->{pause} = 0; $msg = "Playing"; }
f6ef7584 MW	229	notify "$TITLE state", $msg if defined $msg;
	230	} elsif ($f[1] eq "playing") {
	231	my %info;
	232	$info{track} = $f[2];
	233	$info{submitter} = $f[3] if @f > 3;
	234	decode_track_name $sk, %info;
	235	notify "$TITLE: Now playing", format_now_playing %info;
	236	} elsif ($f[1] eq "scratched") {
	237	my %info;
	238	$info{track} = $f[2];
	239	decode_track_name $sk, %info;
	240	notify "$TITLE: Scratched by $f[3]", format_now_playing %info;
	241	}
6bdf3aad	242	}
f6ef7584	243
c7eee684	244	if (!$sk_log) { $loss = "EOF from server"; last WATCH; }
50d7331d MW	245	my $nfd = select my $rdout = $rdin, undef, undef, 60;
	246	if (!$nfd) {
	247	eval { print $sk_log "."; flush $sk_log; };
	248	if ($@) { $loss = "error from write: " . $@->errno; last WATCH; }
	249	@lines = ();
	250	} else {
	251	READ: for (;;) {
	252	my ($b, $n);
	253	eval { $n = sysread $sk_log, $b, 4096; };
	254	if ($@ && $@->errno == EAGAIN) { last READ; }
	255	elsif ($@) { $loss = "error from read: " . $@->errno; last WATCH; }
ba19b1ea	256	elsif (!$n) { close $sk_log; $sk_log = undef; last READ; }
50d7331d MW	257	else { $buffer .= $b; }
50d7331d MW	258	}
f6ef7584	259
50d7331d MW	260	@lines = split /\n/, $buffer, -1;
	261	$buffer = pop @lines;
	262	}
6bdf3aad	263	}
a1b30762	264
c7eee684	265	notify "$TITLE state", "Lost connection: $loss";
a1b30762 MW	266
a1b30762 MW	267	close $sk;
f6ef7584	268	close $sk_log if defined $sk_log;
6bdf3aad	269	}
a1b30762 MW	270
	271	sub watch_and_notify ($) {
	272	my ($now_playing) = @_;
	273
a1b30762 MW	274	claim_lock or exit 1;
	275
	276	for (;;) {
	277	eval { watch_and_notify0 $now_playing; };
	278	$now_playing = 1;
	279	sleep 5;
	280	}
	281	}
	282
	283	###--------------------------------------------------------------------------
	284	### User-facing operations.
	285
	286	my %OP;
	287
	288	$OP{"volume-up"} =
	289	sub { run_discard_output "amixer", "sset", $C{mixer}, "5\%+"; };
	290	$OP{"volume-down"} =
	291	sub { run_discard_output "amixer", "sset", $C{mixer}, "5\%-"; };
	292
	293	$OP{"scratch"} = sub {
be626dd5	294	my $sk = configured_connection;
a1b30762 MW	295	send_command $sk, "scratch";
	296	close $sk;
	297	};
	298
	299	$OP{"enable/disable"} = sub {
	300	my $st = get_state;
969abb5a	301	my $sk = configured_connection;
a1b30762 MW	302	if ($st->{play}) { send_command $sk, "disable"; }
	303	else { send_command $sk, "enable"; }
	304	close $sk;
	305	};
	306
	307	$OP{"play/pause"} = sub {
	308	my $st = get_state;
be626dd5	309	my $sk = configured_connection;
a1b30762 MW	310	if (!$st->{play}) {
	311	send_command $sk, "enable";
	312	if ($st->{pause}) { send_command $sk, "resume"; }
	313	} else {
	314	if ($st->{pause}) { send_command $sk, "resume"; }
	315	else { send_command $sk, "pause"; }
	316	}
	317	close $sk;
	318	};
	319
	320	$OP{"watch"} = sub {
	321	if (defined (my $lkpid = locked_by)) {
	322	print STDERR "$0: already watched by pid $lkpid\n";
	323	exit 2;
	324	}
	325	watch_and_notify 1;
	326	};
	327
	328	$OP{"now-playing"} = sub {
be626dd5	329	my $sk = configured_connection;
a1b30762 MW	330	my $info = get_now_playing $sk;
	331	close $sk;
	332	print format_now_playing %$info;
	333	print "\n";
	334	};
	335
	336	$OP{"notify-now-playing"} = sub {
be626dd5	337	my $sk = configured_connection;
a1b30762 MW	338	my $info = get_now_playing $sk;
	339	close $sk;
	340	notify "$TITLE: Now playing", format_now_playing %$info;
a9e2532b MW	341	unless (defined locked_by) {
	342	fork and exit 0;
	343	watch_and_notify 0;
	344	}
a1b30762 MW	345	};
a1b30762 MW	346
70291d8d MW	347	$OP{"next-config"} = sub {
	348	(my $dir = $C{config}) =~ s:/[^/]*$::;
	349	my (@conf, $curr, $conf, $min);
	350
	351	if (-l $C{config} && (my $t = readlink $C{config}) =~ /^passwd\.(.*)$/)
	352	{ $curr = $1; }
	353
	354	opendir my $dh, +$dir;
	355	FILE: while (my $f = readdir $dh)
	356	{ push @conf, $1 if $f =~ /^passwd\.(.*[^~])$/; }
	357
	358	for (my $i = 0; $i < @conf; $i++) {
	359	$min = $conf[$i] if (!defined $min) \|\| $conf[$i] lt $min;
	360	$conf = $conf[$i]
	361	if ((!defined $curr) \|\| $curr lt $conf[$i]) &&
	362	((!defined $conf) \|\| $conf[$i] lt $conf);
	363	}
	364	$conf = $min unless defined $conf;
	365
	366	try_unlink "$dir/passwd.new";
	367	symlink "passwd.$conf", "$dir/passwd.new";
	368	rename "$dir/passwd.new", "$dir/passwd";
	369	notify "DisOrder configuration", "Switched to `$conf'";
	370	};
	371
a1b30762 MW	372	###--------------------------------------------------------------------------
	373	### Main program.
	374
21ec4bc8 MW	375	sub usage (\*) {
	376	my ($fh) = @_;
	377	print $fh "usage: $PROG [-u CONFIG] COMMAND\n";
	378	}
	379
	380	sub help () {
	381	usage *STDOUT;
	382	print <<EOF;
	383
	384	Command-line options:
	385	-h, --help Show this help text
	386	-u, --user-config Set user configuration file
	387
	388	Commands:
	389	volume-up
	390	volume-down
	391	scratch
	392	enable/disable
	393	play/pause
	394	watch
	395	now-playing
	396	notify-now-playing
	397	next-config
	398	EOF
	399	}
	400
	401	my $bad = 0;
	402	GetOptions
	403	"h\|help" => sub { help; exit 0; },
	404	"u\|user-config=s" => \$C{config}
	405	or $bad = 1;
	406	@ARGV == 1 or $bad = 1;
	407	if ($bad) { usage *STDERR; exit 2; }
a1b30762 MW	408	my $op = $ARGV[0];
	409	if (!exists $OP{$op}) { print STDERR "$0: unknown op `$op'\n"; exit 2; }
	410	$OP{$op}();
	411
	412	###----- That's all, folks --------------------------------------------------