FHEM/mod-HEOS
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Groupmodul mit Notify erweitert. Diverse Änderungen und Bugfixes, Warteschlange in Inputs integriert,

Browse Source
This commit is contained in:
Marko Oldenburg 2017-02-25 07:42:15 +01:00
parent 0b383df032
commit bc9eb8ec8e
3 changed files with 624 additions and 1281 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

345
21_HEOSGroup.pm
View File

@ -29,7 +29,6 @@
#
###############################################################################
package main;
use strict;
@ -37,17 +36,14 @@ use warnings;
use JSON qw(decode_json);
use Encode qw(encode_utf8);
my $version = "0.1.57";
my $version = "0.1.58";
# Declare functions
sub HEOSGroup_Initialize($);
sub HEOSGroup_Define($$);
sub HEOSGroup_Undef($$);
sub HEOSGroup_Attr(@);
sub HEOSGroup_Notify($$);
sub HEOSGroup_Parse($$);
sub HEOSGroup_WriteReadings($$);
sub HEOSGroup_Set($$@);
@ -56,12 +52,7 @@ sub HEOSGroup_GetGroupInfo($);
sub HEOSGroup_GetGroupVolume($);
sub HEOSGroup_GetGroupMute($);
sub HEOSGroup_Initialize($) {
my ($hash) = @_;
$hash->{Match} = '.*{"command":."group.*|.*{"command":."event\/group.*';
@ -70,16 +61,13 @@ sub HEOSGroup_Initialize($) {
$hash->{SetFn} = "HEOSGroup_Set";
$hash->{DefFn} = "HEOSGroup_Define";
$hash->{UndefFn} = "HEOSGroup_Undef";
$hash->{NotifyFn} = "HEOSGroup_Notify";
$hash->{AttrFn} = "HEOSGroup_Attr";
$hash->{ParseFn} = "HEOSGroup_Parse";
$hash->{AttrList} = "IODev ".
"disable:1 ".
"mute2play:1 ".
$readingFnAttributes;
foreach my $d(sort keys %{$modules{HEOSGroup}{defptr}}) {
my $hash = $modules{HEOSGroup}{defptr}{$d};
$hash->{VERSION} = $version;
@ -87,9 +75,7 @@ sub HEOSGroup_Initialize($) {
}
sub HEOSGroup_Define($$) {
my ( $hash, $def ) = @_;
my @a = split( "[ \t]+", $def );
splice( @a, 1, 1 );
my $iodev;
@ -101,46 +87,32 @@ sub HEOSGroup_Define($$) {
splice( @a, $i, 3 );
last;
}
$i++;
}
return "too few parameters: define <name> HEOSGroup <gid>" if( @a < 2 );
my ($name,$gid) = @a;
$hash->{GID} = $gid;
$hash->{VERSION} = $version;
$hash->{NOTIFYDEV} = "HEOSPlayer".abs($gid);
AssignIoPort($hash,$iodev) if( !$hash->{IODev} );
if(defined($hash->{IODev}->{NAME})) {
Log3 $name, 3, "HEOSGroup ($name) - I/O device is " . $hash->{IODev}->{NAME};
} else {
Log3 $name, 1, "HEOSGroup ($name) - no I/O device";
}
$iodev = $hash->{IODev}->{NAME};
my $code = abs($gid);
$code = $iodev."-".$code if( defined($iodev) );
my $d = $modules{HEOSGroup}{defptr}{$code};
return "HEOSGroup device $hash->{GID} on HEOSMaster $iodev already defined as $d->{NAME}."
if( defined($d)
&& $d->{IODev} == $hash->{IODev}
&& $d->{NAME} ne $name );
if( defined($d) && $d->{IODev} == $hash->{IODev} && $d->{NAME} ne $name );
Log3 $name, 3, "HEOSGroup ($name) - defined with Code: $code";
$attr{$name}{room} = "HEOS" if( !defined( $attr{$name}{room} ) );
$attr{$name}{devStateIcon} = "on:10px-kreis-gruen off:10px-kreis-rot" if( !defined( $attr{$name}{devStateIcon} ) );
if( $init_done ) {
InternalTimer( gettimeofday()+int(rand(2)), "HEOSGroup_GetGroupInfo", $hash, 0 );
InternalTimer( gettimeofday()+int(rand(4)), "HEOSGroup_GetGroupVolume", $hash, 0 );
@ -150,40 +122,28 @@ sub HEOSGroup_Define($$) {
InternalTimer( gettimeofday()+15+int(rand(4)), "HEOSGroup_GetGroupVolume", $hash, 0 );
InternalTimer( gettimeofday()+15+int(rand(6)), "HEOSGroup_GetGroupMute", $hash, 0 );
}
readingsBeginUpdate($hash);
readingsBulkUpdate($hash, 'state','Initialized');
readingsBulkUpdate($hash, 'volumeUp', 5);
readingsBulkUpdate($hash, 'volumeDown', 5);
readingsEndUpdate($hash, 1);
$modules{HEOSGroup}{defptr}{$code} = $hash;
return undef;
}
sub HEOSGroup_Undef($$) {
my ( $hash, $arg ) = @_;
my $gid = $hash->{GID};
my $name = $hash->{NAME};
RemoveInternalTimer($hash);
my $code = abs($gid);
my $code = abs($hash->{GID});
$code = $hash->{IODev}->{NAME} ."-". $code if( defined($hash->{IODev}->{NAME}) );
delete($modules{HEOSGroup}{defptr}{$code});
Log3 $name, 3, "HEOSGroup ($name) - device $name deleted with Code: $code";
return undef;
}
sub HEOSGroup_Attr(@) {
my ( $cmd, $name, $attrName, $attrVal ) = @_;
my $hash = $defs{$name};
my $token = $hash->{IODev}->{TOKEN};
@ -193,19 +153,16 @@ sub HEOSGroup_Attr(@) {
readingsSingleUpdate ( $hash, "state", "disabled", 1 );
Log3 $name, 3, "HEOSGroup ($name) - disabled";
}
elsif( $cmd eq "del" ) {
readingsSingleUpdate ( $hash, "state", "active", 1 );
Log3 $name, 3, "HEOSGroup ($name) - enabled";
}
}
if( $attrName eq "disabledForIntervals" ) {
if( $cmd eq "set" ) {
Log3 $name, 3, "HEOSGroup ($name) - enable disabledForIntervals";
readingsSingleUpdate ( $hash, "state", "Unknown", 1 );
}
elsif( $cmd eq "del" ) {
readingsSingleUpdate ( $hash, "state", "active", 1 );
Log3 $name, 3, "HEOSGroup ($name) - delete disabledForIntervals";
@ -213,235 +170,185 @@ sub HEOSGroup_Attr(@) {
}
}
sub HEOSGroup_Set($$@) {
sub HEOSGroup_Notify($$) {
my ($hash,$dev) = @_;
my $name = $hash->{NAME};
return undef if(IsDisabled($name));
my $events = deviceEvents($dev,1);
#print "notify ####################################################\n".Dumper($events);
return if( !$events );
readingsBeginUpdate($hash);
#my %playerEevents = map { my ( $key, $value ) = split ":"; $value =~ s/^\s+//; ( $key, $value ) } @$events;
my %playerEevents = map { my ( $key, $value ) = split /:\s/; $value =~ s/^\s+//; ( $key, $value ) } @$events;
foreach my $key ( keys %playerEevents ) {
#### playing Infos
readingsBulkUpdate( $hash, $key, $playerEevents{$key} ) if( grep { $_ =~ /$key/ } ("channel", "currentAlbum", "currentArtist", "currentImageUrl", "currentMedia", "currentMid", "currentQid", "currentSid", "currentStation", "currentTitle", "error", "playStatus", "repeat", "shuffle" ) );
}
readingsEndUpdate( $hash, 1 );
}
sub HEOSGroup_Set($$@) {
my ($hash, $name, @aa) = @_;
my ($cmd, @args) = @aa;
my $gid = $hash->{GID};
my $action;
my $heosCmd;
my $rvalue;
my $favcount = 1;
my $favorit;
my $favoritcount = 1;
my $string = "gid=$gid";
#senden von Befehlen unterdrücken solange state nicht on ist
return undef unless ( ReadingsVal($name, "state", "off") eq "on" );
if( $cmd eq 'getGroupInfo' ) {
return "usage: getGroupInfo" if( @args != 0 );
$heosCmd = $cmd;
} elsif( $cmd eq 'mute' ) {
return "usage: mute on/off" if( @args != 1 );
$heosCmd = 'setGroupMute';
$action = "state=$args[0]";
} elsif( $cmd eq 'volume' ) {
return "usage: volume 0-100" if( @args != 1 );
$heosCmd = 'setGroupVolume';
$action = "level=$args[0]";
} elsif( $cmd eq 'volumeUp' ) {
return "usage: volumeUp 0-10" if( @args != 1 );
$heosCmd = 'GroupVolumeUp';
$action = "step=$args[0]";
} elsif( $cmd eq 'volumeDown' ) {
return "usage: volumeDown 0-10" if( @args != 1 );
$heosCmd = 'groupVolumeDown';
$action = "step=$args[0]";
} elsif( $cmd eq 'clearGroup' ) {
return "usage: clearGroup" if( @args != 0 );
$heosCmd = 'createGroup';
$string = "pid=$gid";
} elsif( grep { $_ =~ /\Q$cmd\E/ } ("play", "stop", "pause", "next", "prev", "channel", "channelUp", "channelDown", "playlist" ) ) {
#ab hier Playerbefehle emuliert
$string = "pid=$gid";
if( $cmd eq 'repeat' ) {
return "usage: repeat one,all,off" if( @args != 1 );
$heosCmd = 'setPlayMode';
$rvalue = 'on_'.$args[0];
$rvalue = 'off' if($rvalue eq 'on_off');
$action = "repeat=$rvalue&shuffle=".ReadingsVal($name,'shuffle','off');
} elsif( $cmd eq 'shuffle' ) {
return "usage: shuffle on,off" if( @args != 1 );
$heosCmd = 'setPlayMode';
$rvalue = 'on_'.ReadingsVal($name,'repeat','off');
$rvalue = 'off' if($rvalue eq 'on_off');
$action = "repeat=$rvalue&shuffle=$args[0]";
} elsif( $cmd eq 'play' ) {
return "usage: play" if( @args != 0 );
$heosCmd = 'setPlayState';
$action = "state=$cmd";
} elsif( $cmd eq 'stop' ) {
return "usage: stop" if( @args != 0 );
$heosCmd = 'setPlayState';
$action = "state=$cmd";
$string = "pid=$gid";
} elsif( $cmd eq 'pause' ) {
return "usage: pause" if( @args != 0 );
$heosCmd = 'setPlayState';
$action = "state=$cmd";
$string = "pid=$gid";
} elsif( $cmd eq 'next' ) {
return "usage: next" if( @args != 0 );
$heosCmd = 'playNext';
$string = "pid=$gid";
} elsif( $cmd eq 'prev' ) {
return "usage: prev" if( @args != 0 );
$heosCmd = 'playPrev';
$string = "pid=$gid";
} elsif ( $cmd eq 'channel' ) {
$favcount = scalar(@{$hash->{IODev}{helper}{favorites}}) if ( defined $hash->{IODev}{helper}{favorites} );
return "usage: channel 1-$favcount" if( @args != 1 );
$favoritcount = scalar(@{$hash->{IODev}{helper}{favorites}}) if ( defined $hash->{IODev}{helper}{favorites} );
return "usage: channel 1-$favoritcount" if( @args != 1 );
$heosCmd = 'playPresetStation';
$action = "preset=$args[0]";
$string = "pid=$gid";
} elsif( $cmd eq 'channelUp' ) {
return "usage: channelUp" if( @args != 0 );
$favcount = scalar(@{$hash->{IODev}{helper}{favorites}}) if ( defined $hash->{IODev}{helper}{favorites} );
$favoritcount = scalar(@{$hash->{IODev}{helper}{favorites}}) if ( defined $hash->{IODev}{helper}{favorites} );
$heosCmd = 'playPresetStation';
my $fav = ReadingsVal($name,"channel", 0) + 1;
$fav = $favcount if ( $fav > $favcount);
$action = "preset=".$fav;
$string = "pid=$gid";
$favorit = ReadingsVal($name,"channel", 0) + 1;
$favorit = $favoritcount if ( $favorit > $favoritcount);
$action = "preset=".$favorit;
} elsif( $cmd eq 'channelDown' ) {
return "usage: channelDown" if( @args != 0 );
$heosCmd = 'playPresetStation';
my $fav = ReadingsVal($name,"channel", 0) - 1;
$fav = 1 if ($fav <= 0);
$action = "preset=".$fav;
$string = "pid=$gid";
} elsif ( $cmd eq 'playlist' ) {
$favorit = ReadingsVal($name,"channel", 0) - 1;
$favorit = 1 if ($favorit <= 0);
$action = "preset=".$favorit;
} elsif ( $cmd =~ /Playlist/ ) {
my @cids = map { $_->{cid} } grep { $_->{name} =~ /$args[0]/i } (@{ $hash->{IODev}{helper}{playlists} });
if ( scalar @args == 1 && scalar @cids == 1 ) {
$heosCmd = 'playPlaylist';
if ( scalar @args == 1 && scalar @cids > 0 ) {
if ( $cmd eq 'playPlaylist' ) {
$heosCmd = $cmd;
$action = "sid=1025&cid=$cids[0]&aid=4";
$string = "pid=$gid";
} else {
my @playlists = map { $_->{name} } (@{ $hash->{IODev}{helper}{playlists}});
return "usage: playlist ".join(",",@playlists);
} elsif ( $cmd eq 'deletePlaylist' ) {
$heosCmd = $cmd;
$action = "cid=$cids[0]";
$string = "sid=1025";
}
} else {
my @playlists;
my $list = "getGroupInfo:noArg mute:on,off volume:slider,0,5,100 volumeUp:slider,0,1,10 volumeDown:slider,0,1,10 clearGroup:noArg play:noArg stop:noArg pause:noArg next:noArg prev:noArg channelUp:noArg channelDown:noArg ";
IOWrite($hash,'browseSource','sid=1025');
my @playlists = map { $_->{name} } (@{ $hash->{IODev}{helper}{playlists}});
return "usage: $cmd ".join(",",@playlists);
}
}
} else {
my $list = "getGroupInfo:noArg mute:on,off volume:slider,0,5,100 volumeUp:slider,0,1,10 volumeDown:slider,0,1,10 clearGroup:noArg repeat:one,all,off shuffle:on,off play:noArg stop:noArg pause:noArg next:noArg prev:noArg channelUp:noArg channelDown:noArg ";
$list .= " channel:slider,1,1,".scalar(@{$hash->{IODev}{helper}{favorites}}) if ( defined $hash->{IODev}{helper}{favorites} );
if ( defined $hash->{IODev}{helper}{playlists} ) {
@playlists = map { my %n; $n{name} = $_->{name}; $n{name} =~ s/\s+/\&nbsp;/g; $n{name} } (@{ $hash->{IODev}{helper}{playlists}});
my @playlists = map { my %n; $n{name} = $_->{name}; $n{name} =~ s/\s+/\&nbsp;/g; $n{name} } (@{ $hash->{IODev}{helper}{playlists}});
$list .= " playlist:".join(",",@playlists) if( scalar @playlists > 0 );
}
return "Unknown argument $cmd, choose one of $list";
}
#senden von Befehlen unterdrücken solange state nicht on ist
if ( ReadingsVal($name, "state", "off") eq "on" ) {
$string .= "&$action" if( defined($action));
IOWrite($hash,"$heosCmd","$string");
Log3 $name, 4, "HEOSGroup ($name) - IOWrite: $heosCmd $string IODevHash=$hash->{IODev}";
}
return undef;
}
sub HEOSGroup_Parse($$) {
my ($io_hash,$json) = @_;
my $name = $io_hash->{NAME};
my $gid;
my $decode_json;
my $code;
$decode_json = decode_json(encode_utf8($json));
Log3 $name, 4, "HEOSGroup ($name) - ParseFn wurde aufgerufen";
if( defined($decode_json->{gid}) ) {
$gid = $decode_json->{gid};
my $code = abs($gid);
$code = abs($gid);
$code = $io_hash->{NAME} ."-". $code if( defined($io_hash->{NAME}) );
#print "code #######################################################################\n".Dumper($code);
if( my $hash = $modules{HEOSGroup}{defptr}{$code} ) {
my $name = $hash->{NAME};
#print "hash #######################################################################\n".Dumper($hash);
IOWrite($hash,'getGroupInfo',"gid=$hash->{GID}");
Log3 $name, 4, "HEOSGroup ($name) - find logical device: $hash->{NAME}";
Log3 $name, 4, "HEOSGroup ($name) - find GID in root from decode_json";
Log3 $hash->{NAME}, 4, "HEOSGroup ($hash->{NAME}) - find logical device: $hash->{NAME}";
Log3 $hash->{NAME}, 4, "HEOSGroup ($hash->{NAME}) - find GID in root from decode_json";
return $hash->{NAME};
} else {
my $devname = "HEOSGroup".abs($gid);
return "UNDEFINED $devname HEOSGroup $gid IODev=$name";
}
} else {
my %message = map { my ( $key, $value ) = split "="; $key => $value } split('&', $decode_json->{heos}{message});
#return Log3 $name, 3, "result not success"
#unless($decode_json->{heos}{result} eq "success"); # Klappt bei Events nicht!! Lieber Fehlermeldung im Reading
if( defined($decode_json->{payload}{gid}) ) {
$gid = $decode_json->{payload}{gid};
} elsif ( $decode_json->{heos}{message} =~ /^gid=/ or $decode_json->{heos}{message} =~ /^pid=/ ) { # das mit dem PID wird nicht klappen, da solche Telegramme erst gar nicht an das Groupmodul gesendet werden
#pid wird bei leerer gruppe zurück gegeben
my @gid = split('&', $decode_json->{heos}{message});
$gid = substr($gid[0],4);
Log3 $name, 4, "HEOSGroup ($name) - gid[0]: $gid[0] and gid: $gid";
}
my $code = abs($gid);
$gid = $message{pid} if( defined($message{pid}) );
$gid = $message{gid} if( defined($message{gid}) );
$gid = $decode_json->{payload}{gid} if( defined($decode_json->{payload}{gid}) );
Log3 $name, 4, "HEOSGroup ($name) - GID: $gid";
$code = abs($gid);
$code = $io_hash->{NAME} ."-". $code if( defined($io_hash->{NAME}) );
if( my $hash = $modules{HEOSGroup}{defptr}{$code} ) {
my $name = $hash->{NAME};
HEOSGroup_WriteReadings($hash,$decode_json);
Log3 $name, 4, "HEOSGroup ($name) - find logical device: $hash->{NAME}";
Log3 $hash->{NAME}, 4, "HEOSGroup ($hash->{NAME}) - find logical device: $hash->{NAME}";
return $hash->{NAME};
} else {
my $devname = "HEOSGroup".abs($gid);
return "UNDEFINED $devname HEOSGroup $gid IODev=$name";
}
@ -449,175 +356,101 @@ sub HEOSGroup_Parse($$) {
}
sub HEOSGroup_WriteReadings($$) {
my ($hash,$decode_json) = @_;
my $name = $hash->{NAME};
my $leaderchannel;
my $leaderStation;
my $leaderStatus;
Log3 $name, 3, "HEOSGroup ($name) - processing data to write readings";
############################
#### Aufbereiten der Daten soweit nötig (bei Events zum Beispiel)
my $readingsHash = HEOSGroup_PreProcessingReadings($hash,$decode_json)
if( $decode_json->{heos}{message} =~ /^gid=/ );
my $code = abs($hash->{GID});
$code = $hash->{IODev}{NAME} ."-". $code if( defined($hash->{IODev}{NAME}) );
#print "code #######################################################################\n".Dumper($code);
if( my $leaderhash = $modules{HEOSPlayer}{defptr}{$code} ) {
my $leadername = $leaderhash->{NAME};
#print "hash #######################################################################\n".Dumper($leaderhash);
$leaderchannel = ReadingsVal($leadername, 'channel', '');
$leaderStation = ReadingsVal($leadername, 'currentStation', '');
$leaderStatus = ReadingsVal($leadername, 'playStatus', 'stop');
Log3 $name, 4, "HEOSGroup ($name) - read readings from $leadername";
}
############################
#### schreiben der Readings
readingsBeginUpdate($hash);
### Event Readings
if( ref($readingsHash) eq "HASH" ) {
Log3 $name, 4, "HEOSGroup ($name) - response json Hash back from HEOSGroup_PreProcessingReadings";
my $t;
my $v;
while( ( $t, $v ) = each (%{$readingsHash}) ) {
if( defined( $v ) ) {
readingsBulkUpdate( $hash, $t, $v );
readingsBulkUpdate( $hash, $t, $v ) if( defined( $v ) );
}
}
}
readingsBulkUpdate( $hash, 'state', 'on' );
### GroupInfos
readingsBulkUpdate( $hash, 'name', $decode_json->{payload}{name} );
readingsBulkUpdate( $hash, 'gid', $decode_json->{payload}{gid} );
readingsBulkUpdate( $hash, 'state', 'on' );
readingsBulkUpdate( $hash, 'channel', $leaderchannel );
readingsBulkUpdate( $hash, 'currentStation', $leaderStation );
readingsBulkUpdate( $hash, 'playStatus', $leaderStatus );
#gruppe wurde geleert
if ( $decode_json->{heos}{message} =~ /^pid=/ ) {
readingsBulkUpdate( $hash, 'member', "" );
readingsBulkUpdate( $hash, 'name', "" );
readingsBulkUpdate( $hash, 'state', "off" );
} elsif ( ref($decode_json->{payload}{players}) eq "ARRAY" ) {
if ( ref($decode_json->{payload}{players}) eq "ARRAY" ) {
my @members;
foreach my $player (@{ $decode_json->{payload}{players} }) {
readingsBulkUpdate( $hash, 'leader', $player->{name} ) if ( $player->{role} eq "leader" );
push( @members, $player->{name}) if ( $player->{role} eq "member" );
}
if ( scalar @members > 1 ) {
readingsBulkUpdate( $hash, 'member', join(",",@members) );
} else {
readingsBulkUpdate( $hash, 'member', $members[0] );
}
}
readingsEndUpdate( $hash, 1 );
Log3 $name, 5, "HEOSGroup ($name) - readings set for $name";
return undef;
}
###############
### my little Helpers
sub HEOSGroup_PreProcessingReadings($$) {
my ($hash,$decode_json) = @_;
my $name = $hash->{NAME};
my $reading;
my %buffer;
my %message = map { my ( $key, $value ) = split "="; $key => $value } split('&', $decode_json->{heos}{message});
Log3 $name, 4, "HEOSGroup ($name) - preprocessing readings";
if ( $decode_json->{heos}{command} =~ /volume_changed/ or $decode_json->{heos}{command} =~ /set_volume/ or $decode_json->{heos}{command} =~ /get_volume/ ) {
my @value = split('&', $decode_json->{heos}{message});
$buffer{'volume'} = substr($value[1],6);
$buffer{'mute'} = substr($value[2],5) if( $decode_json->{heos}{command} =~ /volume_changed/ );
} elsif ( $decode_json->{heos}{command} =~ /volume_up/ or $decode_json->{heos}{command} =~ /volume_down/ ) {
my @value = split('&', $decode_json->{heos}{message});
$buffer{'volumeUp'} = substr($value[1],5) if( $decode_json->{heos}{command} =~ /volume_up/ );
$buffer{'volumeDown'} = substr($value[1],5) if( $decode_json->{heos}{command} =~ /volume_down/ );
} elsif ( $decode_json->{heos}{command} =~ /get_mute/ ) {
my @value = split('&', $decode_json->{heos}{message});
$buffer{'mute'} = substr($value[1],6);
} else {
Log3 $name, 3, "HEOSGroup ($name) - no match found";
return undef;
}
Log3 $name, 4, "HEOSGroup ($name) - Match found for decode_json";
return \%buffer;
}
sub HEOSGroup_GetGroupInfo($) {
my $hash = shift;
RemoveInternalTimer($hash,'HEOSGroup_GetGroupInfo');
IOWrite($hash,'getGroupInfo',"gid=$hash->{GID}");
}
sub HEOSGroup_GetGroupVolume($) {
my $hash = shift;
RemoveInternalTimer($hash,'HEOSGroup_GetGroupVolume');
IOWrite($hash,'getGroupVolume',"gid=$hash->{GID}");
}
sub HEOSGroup_GetGroupMute($) {
my $hash = shift;
RemoveInternalTimer($hash,'HEOSGroup_GetGroupMute');
IOWrite($hash,'getGroupMute',"gid=$hash->{GID}");
}

525
21_HEOSMaster.pm
View File

File diff suppressed because it is too large Load Diff

543
21_HEOSPlayer.pm
View File

@ -29,19 +29,15 @@
#
###############################################################################
package main;
use strict;
use warnings;
use JSON qw(decode_json);
use Encode qw(encode_utf8);
use Data::Dumper;
my $version = "0.1.57";
my $version = "0.1.58";
# Declare functions
sub HEOSPlayer_Initialize($);
@ -60,12 +56,7 @@ sub HEOSPlayer_GetVolume($);
sub HEOSPlayer_Get($$@);
sub HEOSPlayer_GetMute($);
sub HEOSPlayer_Initialize($) {
my ($hash) = @_;
$hash->{Match} = '.*{"command":."player.*|.*{"command":."event/player.*|.*{"command":."event\/repeat_mode_changed.*|.*{"command":."event\/shuffle_mode_changed.*|.*{"command":."event\/favorites_changed.*';
@ -77,14 +68,11 @@ sub HEOSPlayer_Initialize($) {
$hash->{UndefFn} = "HEOSPlayer_Undef";
$hash->{AttrFn} = "HEOSPlayer_Attr";
$hash->{ParseFn} = "HEOSPlayer_Parse";
$hash->{AttrList} = "IODev ".
"disable:1 ".
"mute2play:1 ".
$readingFnAttributes;
foreach my $d(sort keys %{$modules{HEOSPlayer}{defptr}}) {
my $hash = $modules{HEOSPlayer}{defptr}{$d};
$hash->{VERSION} = $version;
@ -92,9 +80,7 @@ sub HEOSPlayer_Initialize($) {
}
sub HEOSPlayer_Define($$) {
my ( $hash, $def ) = @_;
my @a = split( "[ \t]+", $def );
splice( @a, 1, 1 );
my $iodev;
@ -106,46 +92,31 @@ sub HEOSPlayer_Define($$) {
splice( @a, $i, 3 );
last;
}
$i++;
}
return "too few parameters: define <name> HEOSPlayer <pid>" if( @a < 2 );
my ($name,$pid) = @a;
$hash->{PID} = $pid;
$hash->{VERSION} = $version;
AssignIoPort($hash,$iodev) if( !$hash->{IODev} );
if(defined($hash->{IODev}->{NAME})) {
Log3 $name, 3, "HEOSPlayer ($name) - I/O device is " . $hash->{IODev}->{NAME};
} else {
Log3 $name, 1, "HEOSPlayer ($name) - no I/O device";
}
$iodev = $hash->{IODev}->{NAME};
my $code = abs($pid);
$code = $iodev."-".$code if( defined($iodev) );
my $d = $modules{HEOSPlayer}{defptr}{$code};
return "HEOSPlayer device $hash->{pid} on HEOSMaster $iodev already defined as $d->{NAME}."
if( defined($d)
&& $d->{IODev} == $hash->{IODev}
&& $d->{NAME} ne $name );
if( defined($d) && $d->{IODev} == $hash->{IODev} && $d->{NAME} ne $name );
Log3 $name, 3, "HEOSPlayer ($name) - defined with Code: $code";
$attr{$name}{room} = "HEOS" if( !defined( $attr{$name}{room} ) );
$attr{$name}{devStateIcon} = "on:10px-kreis-gruen off:10px-kreis-rot" if( !defined( $attr{$name}{devStateIcon} ) );
if( $init_done ) {
InternalTimer( gettimeofday()+int(rand(2)), "HEOSPlayer_GetPlayerInfo", $hash, 0 );
InternalTimer( gettimeofday()+int(rand(4)), "HEOSPlayer_GetPlayState", $hash, 0 );
@ -161,40 +132,29 @@ sub HEOSPlayer_Define($$) {
InternalTimer( gettimeofday()+15+int(rand(10)), "HEOSPlayer_GetVolume", $hash, 0 );
InternalTimer( gettimeofday()+15+int(rand(12)), "HEOSPlayer_GetMute", $hash, 0 );
}
readingsBeginUpdate($hash);
readingsBulkUpdate($hash, 'state','Initialized');
readingsBulkUpdate($hash, 'volumeUp', 5);
readingsBulkUpdate($hash, 'volumeDown', 5);
readingsEndUpdate($hash, 1);
$modules{HEOSPlayer}{defptr}{$code} = $hash;
return undef;
}
sub HEOSPlayer_Undef($$) {
my ( $hash, $arg ) = @_;
my $pid = $hash->{PID};
my $name = $hash->{NAME};
RemoveInternalTimer($hash);
my $code = abs($pid);
$code = $hash->{IODev}->{NAME} ."-". $code if( defined($hash->{IODev}->{NAME}) );
delete($modules{HEOSPlayer}{defptr}{$code});
Log3 $name, 3, "HEOSPlayer ($name) - device $name deleted with Code: $code";
return undef;
}
sub HEOSPlayer_Attr(@) {
my ( $cmd, $name, $attrName, $attrVal ) = @_;
my $hash = $defs{$name};
my $token = $hash->{IODev}->{TOKEN};
@ -204,19 +164,16 @@ sub HEOSPlayer_Attr(@) {
readingsSingleUpdate ( $hash, "state", "disabled", 1 );
Log3 $name, 3, "HEOSPlayer ($name) - disabled";
}
elsif( $cmd eq "del" ) {
readingsSingleUpdate ( $hash, "state", "active", 1 );
Log3 $name, 3, "HEOSPlayer ($name) - enabled";
}
}
if( $attrName eq "disabledForIntervals" ) {
if( $cmd eq "set" ) {
Log3 $name, 3, "HEOSPlayer ($name) - enable disabledForIntervals";
readingsSingleUpdate ( $hash, "state", "Unknown", 1 );
}
elsif( $cmd eq "del" ) {
readingsSingleUpdate ( $hash, "state", "active", 1 );
Log3 $name, 3, "HEOSPlayer ($name) - delete disabledForIntervals";
@ -225,314 +182,235 @@ sub HEOSPlayer_Attr(@) {
}
sub HEOSPlayer_Get($$@) {
my ($hash, $name, @aa) = @_;
my ($cmd, @args) = @aa;
my $pid = $hash->{PID};
my $result = "";
#print "CL ###################################################\n".Dumper($hash->{CL});
$hash->{helper}{cl} = $hash->{CL} if( ref($hash->{CL}) eq 'HASH' );
#Leerzeichen müßen für die Rückgabe escaped werden sonst werden sie falsch angezeigt
if( $cmd eq 'playlists' ) {
#gibt die Playlisten durch Komma getrennt zurück
my @playlists = map { my %n; $n{name} = $_->{name}; $n{name} =~ s/\s+/\&nbsp;/g; $n{name} } (@{ $hash->{IODev}{helper}{playlists}});
$result .= join(",",@playlists) if( scalar @playlists > 0 );
return $result;
} elsif( $cmd eq 'channels' ) {
#gibt die Favoriten durch Komma getrennt zurück
my @channels = map { my %n; $n{name} = $_->{name}; $n{name} =~ s/\s+/\&nbsp;/g; $n{name} } (@{ $hash->{IODev}{helper}{favorites}});
$result .= join(",",@channels) if( scalar @channels > 0 );
return $result;
} elsif( $cmd eq 'channelscount' ) {
#gibt die Favoritenanzahl zurück
return scalar(@{$hash->{IODev}{helper}{favorites}}) if ( defined $hash->{IODev}{helper}{favorites} );
} elsif( $cmd eq 'inputs' ) {
#gibt die Quellen durch Komma getrennt zurück
my @inputs = map { my %n; $n{name} = $_->{name}; $n{name} =~ s/\s+/\&nbsp;/g; $n{name} } (@{ $hash->{IODev}{helper}{sources}});
push(@inputs, "Warteschlange");
$result .= join(",",@inputs) if( scalar @inputs > 0 );
return $result;
}
} elsif( $cmd eq 'search' ) {
return "usage: search <keywords>" if( @args != 1 );
my $list = 'playlists:noArg channels:noArg channelscount:noArg inputs:noArg';
}
my $list = 'playlists:noArg channels:noArg channelscount:noArg inputs:noArg ls search';
return "Unknown argument $cmd, choose one of $list";
}
sub HEOSPlayer_Set($$@) {
my ($hash, $name, @aa) = @_;
my ($cmd, @args) = @aa;
my $pid = $hash->{PID};
my $action;
my $heosCmd;
my $rvalue;
my $favcount = 1;
my $favoritcount = 1;
my $qcount = 1;
my $string = "pid=$pid";
#print "cmd ###################################################\n".Dumper($cmd);
if( $cmd eq 'getPlayerInfo' ) {
return "usage: getPlayerInfo" if( @args != 0 );
$heosCmd = $cmd;
} elsif( $cmd eq 'getPlayState' ) {
return "usage: getPlayState" if( @args != 0 );
$heosCmd = $cmd;
} elsif( $cmd eq 'getPlayMode' ) {
return "usage: getPlayMode" if( @args != 0 );
$heosCmd = $cmd;
} elsif( $cmd eq 'getNowPlayingMedia' ) {
return "usage: getNowPlayingMedia" if( @args != 0 );
$heosCmd = $cmd;
} elsif( $cmd eq 'repeat' ) {
return "usage: repeat" if( @args != 1 );
return "usage: repeat one,all,off" if( @args != 1 );
$heosCmd = 'setPlayMode';
if($args[0] eq 'all') {
$rvalue = 'on_all';
} elsif($args[0] eq 'one') {
$rvalue = 'on_one';
} else {
$rvalue = $args[0];
}
$rvalue = 'on_'.$args[0];
$rvalue = 'off' if($rvalue eq 'on_off');
$action = "repeat=$rvalue&shuffle=".ReadingsVal($name,'shuffle','off');
} elsif( $cmd eq 'shuffle' ) {
return "usage: shuffle" if( @args != 1 );
return "usage: shuffle on,off" if( @args != 1 );
$heosCmd = 'setPlayMode';
if(ReadingsVal($name,'repeat','off') eq 'all') {
$rvalue = 'on_all';
} elsif(ReadingsVal($name,'repeat','off') eq 'one') {
$rvalue = 'on_one';
}
$rvalue = 'on_'.ReadingsVal($name,'repeat','off');
$rvalue = 'off' if($rvalue eq 'on_off');
$action = "repeat=$rvalue&shuffle=$args[0]";
} elsif( $cmd eq 'play' ) {
return "usage: play" if( @args != 0 );
$heosCmd = 'setPlayState';
$action = "state=$cmd";
} elsif( $cmd eq 'stop' ) {
return "usage: stop" if( @args != 0 );
$heosCmd = 'setPlayState';
$action = "state=$cmd";
} elsif( $cmd eq 'pause' ) {
return "usage: pause" if( @args != 0 );
$heosCmd = 'setPlayState';
$action = "state=$cmd";
} elsif( $cmd eq 'mute' ) {
return "usage: mute on/off" if( @args != 1 );
$heosCmd = 'setMute';
$action = "state=$args[0]";
} elsif( $cmd eq 'volume' ) {
return "usage: volume 0-100" if( @args != 1 );
$heosCmd = 'setVolume';
$action = "level=$args[0]";
} elsif( $cmd eq 'volumeUp' ) {
return "usage: volumeUp 0-10" if( @args != 1 );
$heosCmd = $cmd;
$action = "step=$args[0]";
} elsif( $cmd eq 'volumeDown' ) {
return "usage: volumeDown 0-10" if( @args != 1 );
$heosCmd = $cmd;
$action = "step=$args[0]";
} elsif( $cmd eq 'groupWithMember' ) {
return "usage: groupWithMember" if( @args != 1 );
$pid .= ",$defs{$args[0]}->{PID}";
$heosCmd = 'createGroup';
} elsif( $cmd eq 'clearGroup' ) {
return "usage: clearGroup" if( @args != 0 );
$heosCmd = 'createGroup';
} elsif( $cmd eq 'next' ) {
return "usage: next" if( @args != 0 );
$heosCmd = 'playNext';
} elsif( $cmd eq 'prev' ) {
return "usage: prev" if( @args != 0 );
$heosCmd = 'playPrev';
} elsif( $cmd eq 'reReadSources' ) {
return "usage: reReadSources" if( @args != 0 );
$heosCmd = 'getMusicSources';
} elsif ( $cmd eq 'channel' ) {
$favcount = scalar(@{$hash->{IODev}{helper}{favorites}}) if ( defined $hash->{IODev}{helper}{favorites} );
return "usage: channel 1-$favcount" if( @args != 1 );
#} elsif( $cmd eq 'reReadSources' ) {
# return "usage: reReadSources" if( @args != 0 );
# $heosCmd = 'getMusicSources';
} elsif ( $cmd =~ /channel/ ) {
my $favorit = ReadingsVal($name,"channel", 0);
$favoritcount = scalar(@{$hash->{IODev}{helper}{favorites}}) if ( defined $hash->{IODev}{helper}{favorites} );
$heosCmd = 'playPresetStation';
if ( $cmd eq 'channel' ) {
return "usage: channel 1-$favoritcount" if( @args != 1 );
$action = "preset=$args[0]";
} elsif( $cmd eq 'channelUp' ) {
return "usage: channelUp" if( @args != 0 );
#$favcount = scalar(@{$hash->{IODev}{helper}{favorites}}) if ( defined $hash->{IODev}{helper}{favorites} );
$heosCmd = 'playPresetStation';
my $fav = ReadingsVal($name,"channel", 0) + 1;
$fav = $favcount if ( $fav > $favcount);
$action = "preset=".$fav;
$favorit = $favoritcount if ( ++$favorit > $favoritcount );
$action = "preset=".$favorit;
} elsif( $cmd eq 'channelDown' ) {
return "usage: channelDown" if( @args != 0 );
$heosCmd = 'playPresetStation';
my $fav = ReadingsVal($name,"channel", 0) - 1;
$fav = 1 if ($fav <= 0);
$action = "preset=".$fav;
} elsif ( $cmd eq 'playlist' ) {
$favorit = 1 if ( --$favorit <= 0 );
$action = "preset=".$favorit;
}
} elsif ( $cmd =~ /Playlist/ ) {
my @cids = map { $_->{cid} } grep { $_->{name} =~ /$args[0]/i } (@{ $hash->{IODev}{helper}{playlists} });
if ( scalar @args == 1 && scalar @cids == 1 ) {
$heosCmd = 'playPlaylist';
if ( scalar @args == 1 && scalar @cids > 0 ) {
if ( $cmd eq 'playPlaylist' ) {
$heosCmd = $cmd;
$action = "sid=1025&cid=$cids[0]&aid=4";
} else {
my @playlists = map { $_->{name} } (@{ $hash->{IODev}{helper}{playlists}});
return "usage: playlist ".join(",",@playlists);
} elsif ( $cmd eq 'deletePlaylist' ) {
$heosCmd = $cmd;
$action = "cid=$cids[0]";
$string = "sid=1025";
}
} else {
IOWrite($hash,'browseSource','sid=1025');
my @playlists = map { $_->{name} } (@{ $hash->{IODev}{helper}{playlists}});
return "usage: $cmd ".join(",",@playlists);
}
} elsif( $cmd eq 'input' ) {
my @sids;
my $search = $args[0];
my @sids = map { $_->{sid} } grep { $_->{name} =~ /$search/i } (@{ $hash->{IODev}{helper}{sources} });
#$search =~ s/\s+/\&nbsp;/g;
$search =~ s/\xC2\xA0/ /g;
if ( scalar @args == 1 && scalar @sids == 1 ) {
#$search =~ s/\s+/\&nbsp;/g;
if ( $search =~ /Warteschlange/ ) {
push(@sids, "9999");
} else {
@sids = map { $_->{sid} } grep { $_->{name} =~ /\Q$search\E/i } (@{ $hash->{IODev}{helper}{sources} });
}
if ( scalar @args == 1 && scalar @sids > 0 ) {
readingsSingleUpdate($hash, "input", $args[0], 1);
#sid des Input für Container merken
readingsSingleUpdate($hash, ".input", $sids[0], 1);
#alten Container löschen bei Inputwechsel
readingsSingleUpdate($hash, ".cid", 0, 1);
if ( $sids[0] eq "9999" ) {
$heosCmd = 'getQueue';
} else {
$heosCmd = 'browseSource';
$action = "sid=$sids[0]";
}
Log3 $name, 4, "HEOSPlayer ($name) - set input with sid $sids[0] and name $args[0]";
} else {
my @inputs = map { $_->{name} } (@{ $hash->{IODev}{helper}{sources}});
push(@inputs, "Warteschlange");
return "usage: input ".join(",",@inputs);
}
} elsif( $cmd eq 'media' ) {
if ( scalar @args == 1 ) {
#sid des Input holen
my $sid = ReadingsVal($name,".input", undef);
return "usage: set input first" unless( defined($sid) );
my @ids;
my $search = $args[0];
my $sid = ReadingsVal($name,".input", "9999");
return "usage: set input first" unless( defined($sid) );
if ( scalar @args == 1 ) {
$search =~ s/\xC2\xA0/ /g;
my @ids = grep { $_->{name} =~ /\Q$search\E/i } (@{ $hash->{IODev}{helper}{media} });
#print "gefundenes Medium\n".Dumper(@ids);
if ( scalar @ids == 1 ) {
if ( $sid eq "9999" ) {
@ids = grep { $_->{song} =~ /\Q$search\E/i } (@{ $hash->{helper}{queue} });
} else {
@ids = grep { $_->{name} =~ /\Q$search\E/i } (@{ $hash->{IODev}{helper}{media} });
}
if ( scalar @ids > 0 ) {
if ( exists $ids[0]{cid} ) {
#hier Container verarbeiten
if ( $ids[0]{playable} eq "yes" ) {
#alles abspielen
$heosCmd = 'playPlaylist';
$action = "sid=$sid&cid=$ids[0]{cid}&aid=4";
#Container merken
readingsSingleUpdate($hash, ".cid", 0, 1);
} else {
#mehr einlesen
readingsSingleUpdate($hash, ".cid", $ids[0]{cid}, 1);
$heosCmd = 'browseSource';
$action = "sid=$sid&cid=$ids[0]{cid}";
}
} elsif ( exists $ids[0]{qid} ) {
$heosCmd = 'playQueue';
$action = "qid=$ids[0]{qid}";
} elsif ( exists $ids[0]{mid} ) {
#hier Medien verarbeiten
if ( $ids[0]{mid} =~ /inputs\// ) {
#Input abspielen
$heosCmd = 'playInput';
$action = "input=$ids[0]{mid}";
} else {
#aktuellen Container holen
my $cid = ReadingsVal($name,".cid", undef);
if ( defined $cid ) {
if ( $ids[0]{type} eq "station" ) {
#Radio abspielen
$heosCmd = 'playStream';
$action = "sid=$sid&cid=$cid&mid=$ids[0]{mid}";
} else {
#Song abspielen
$heosCmd = 'playPlaylist';
$action = "sid=$sid&cid=$cid&mid=$ids[0]{mid}&aid=4";
@ -541,143 +419,120 @@ sub HEOSPlayer_Set($$@) {
}
}
}
} else {
my @media;
my @media = map { $_->{name} } (@{ $hash->{IODev}{helper}{media}});
if ( $sid eq "9999" ) {
@media = map { $_->{song} } (@{ $hash->{helper}{queue}});
} else {
@media = map { $_->{name} } (@{ $hash->{IODev}{helper}{media}});
}
return "usage: media ".join(",",@media);
}
} elsif ( $cmd eq 'clearqueue' ) {
} elsif ( $cmd eq 'clearQueue' ) {
#löscht die Warteschlange
return "usage: clearqueue" if( @args != 0 );
return "usage: clearQueue" if( @args != 0 );
$heosCmd = 'clearQueue';
} elsif ( $cmd eq 'savequeue' ) {
#speichert die aktuelle Warteschlange als Favorit ab
return "usage: savequeue" if( @args != 1 );
$heosCmd = 'saveQueue name';
delete $hash->{helper}{queue};
} elsif ( $cmd eq 'saveQueue' ) {
#speichert die aktuelle Warteschlange als Playlist ab
return "usage: saveQueue" if( @args != 1 );
$heosCmd = 'saveQueue';
$action = "name=$args[0]";
#} elsif( $cmd eq 'sayText' ) {
# return "usage: sayText Text" if( @args != 1 );
} elsif ( $cmd eq 'history' ) {
return "usage: history track,channel" if( @args != 1 );
$heosCmd = "browseSource";
$action = "sid=1026&cid=TRACKS" if ( $args[0] eq "track" );
$action = "sid=1026&cid=STATIONS" if ( $args[0] eq "channel" );
} else {
my @playlists;
my @inputs;
my @media;
my $list = "getPlayerInfo:noArg getPlayState:noArg getNowPlayingMedia:noArg getPlayMode:noArg play:noArg stop:noArg pause:noArg mute:on,off volume:slider,0,5,100 volumeUp:slider,0,1,10 volumeDown:slider,0,1,10 repeat:one,all,off shuffle:on,off clearqueue:noArg savequeue channelUp:noArg channelDown:noArg next:noArg prev:noArg ";
my @queue;
my $sid = ReadingsVal($name,".input", "9999");
my $list = "getPlayerInfo:noArg getPlayState:noArg getNowPlayingMedia:noArg getPlayMode:noArg play:noArg stop:noArg pause:noArg mute:on,off volume:slider,0,5,100 volumeUp:slider,0,1,10 volumeDown:slider,0,1,10 repeat:one,all,off shuffle:on,off channelUp:noArg channelDown:noArg next:noArg prev:noArg history:track,channel ";
$list .= "groupWithMember:" . join( ",", devspec2array("TYPE=HEOSPlayer:FILTER=NAME!=$name") );
#Parameterlisten für FHEMWeb zusammen bauen
$list .= " channel:slider,1,1,".scalar(@{$hash->{IODev}{helper}{favorites}}) if ( defined $hash->{IODev}{helper}{favorites} );
#$list .= " playQueue:slider,1,1,".scalar(@{$hash->{helper}{queue}}) if ( defined $hash->{helper}{queue} );
if ( defined $hash->{IODev}{helper}{playlists} ) {
@playlists = map { my %n; $n{name} = $_->{name}; $n{name} =~ s/\s+/\&nbsp;/g; $n{name} } (@{ $hash->{IODev}{helper}{playlists}});
$list .= " playlist:".join(",",@playlists) if( scalar @playlists > 0 );
$list .= " playPlaylist:".join(",",@playlists) if( scalar @playlists > 0 );
$list .= " deletePlaylist:".join(",",@playlists) if( scalar @playlists > 0 );
#$list .= " renamePlaylist:".join(",",@playlists) if( scalar @playlists > 0 );
}
if ( defined $hash->{IODev}{helper}{sources}) {
@inputs = map { my %n; $n{name} = $_->{name}; $n{name} =~ s/\s+/\&nbsp;/g; $n{name} } (@{ $hash->{IODev}{helper}{sources}});
push(@inputs, "Warteschlange");
$list .= " input:".join(",",@inputs) if( scalar @inputs > 0 );
}
if ( defined $hash->{IODev}{helper}{media}) {
@media = map { my %n; $n{name} = $_->{name}; $n{name} =~ s/\s+/\&nbsp;/g; $n{name} } (@{ $hash->{IODev}{helper}{media}});
push(@media,"Alle") if grep { $_->{container} =~ /yes/i && $_->{playable} =~ /yes/i} (@{ $hash->{IODev}{helper}{media} });
$list .= " media:".join(",",@media) if( scalar @media > 0 );
if ( $sid eq "9999" ) {
@media = map { my %n; $n{name} = $_->{song}; $n{name} =~ s/\s+/\&nbsp;/g; $n{name} } (@{ $hash->{helper}{queue}});
$list .= " clearQueue:noArg saveQueue";
} else {
@media = map { my %n; $n{name} = $_->{name}; $n{name} =~ s/\s+/\&nbsp;/g; $n{name} } (@{ $hash->{IODev}{helper}{media}}) if ( defined $hash->{IODev}{helper}{media});
}
$list .= " media:".join(",",@media) if( scalar @media > 0 );
return "Unknown argument $cmd, choose one of $list";
}
my $string = "pid=$pid";
$string .= "&$action" if( defined($action));
IOWrite($hash,"$heosCmd","$string");
Log3 $name, 4, "HEOSPlayer ($name) - IOWrite: $heosCmd $string IODevHash=$hash->{IODev}";
return undef;
}
sub HEOSPlayer_Parse($$) {
my ($io_hash,$json) = @_;
my $name = $io_hash->{NAME};
my $pid;
my $decode_json;
my $code;
$decode_json = decode_json(encode_utf8($json));
Log3 $name, 4, "HEOSPlayer ($name) - ParseFn wurde aufgerufen";
Log3 $name, 4, "HEOSPlayer - ParseFn wurde aufgerufen";
if( defined($decode_json->{pid}) ) {
$pid = $decode_json->{pid};
my $code = abs($pid);
$code = abs($pid);
$code = $io_hash->{NAME} ."-". $code if( defined($io_hash->{NAME}) );
if( my $hash = $modules{HEOSPlayer}{defptr}{$code} ) {
my $name = $hash->{NAME};
IOWrite($hash,'getPlayerInfo',"pid=$hash->{PID}");
Log3 $name, 4, "HEOSPlayer ($name) - find logical device: $hash->{NAME}";
Log3 $name, 4, "HEOSPlayer ($name) - find PID in root from decode_json";
Log3 $hash->{NAME}, 4, "HEOSPlayer ($hash->{NAME}) - find logical device: $hash->{NAME}";
Log3 $hash->{NAME}, 4, "HEOSPlayer ($hash->{NAME}) - find PID in root from decode_json";
return $hash->{NAME};
} else {
my $devname = "HEOSPlayer".abs($pid);
return "UNDEFINED $devname HEOSPlayer $pid IODev=$name";
}
} else {
my %message = map { my ( $key, $value ) = split "="; $key => $value } split('&', $decode_json->{heos}{message});
#return Log3 $name, 3, "result not success"
#unless($decode_json->{heos}{result} eq "success"); # Klappt bei Events nicht!! Lieber Fehlermeldung im Reading
if( defined($decode_json->{payload}{pid}) ) {
$pid = $decode_json->{payload}{pid};
} elsif ( $decode_json->{heos}{message} =~ /^pid=/ ) {
my @pid = split('&', $decode_json->{heos}{message});
$pid = substr($pid[0],4);
Log3 $name, 4, "HEOSPlayer ($name) - PID[0]: $pid[0] and PID: $pid";
}
my $code = abs($pid);
$pid = $message{pid} if( defined($message{pid}) );
$pid = $decode_json->{payload}{pid} if( defined($decode_json->{payload}{pid}) );
Log3 $name, 4, "HEOSPlayer ($name) PID: $pid";
$code = abs($pid);
$code = $io_hash->{NAME} ."-". $code if( defined($io_hash->{NAME}) );
if( my $hash = $modules{HEOSPlayer}{defptr}{$code} ) {
my $name = $hash->{NAME};
if ( $decode_json->{heos}{command} =~ /get_queue/ ) {
Log3 $name, 3, "HEOSPlayer ($name) - call getQueue for $message{pid}";
if ( defined $message{range} ) { $message{range} =~ s/(\d+)\,\d+/$1/; }
else { $message{range} = 0;
$hash->{helper}{queue} = [];
}
my $start = $message{range} + $message{returned};
push( @{$hash->{helper}{queue}}, (@{$decode_json->{payload}}) );
if ( $start < $message{count} ) {
IOWrite($hash,'getQueue',"pid=$message{pid}&range=$start,".($start + 100));
Log3 $name, 3, "HEOSMaster ($name) - call getQueue with pid $message{pid} next Range from $message{returned}";
}
} else {
HEOSPlayer_WriteReadings($hash,$decode_json);
Log3 $name, 4, "HEOSPlayer ($name) - find logical device: $hash->{NAME}";
}
return $hash->{NAME};
} else {
my $devname = "HEOSPlayer".abs($pid);
return "UNDEFINED $devname HEOSPlayer $pid IODev=$name";
}
@ -685,43 +540,27 @@ sub HEOSPlayer_Parse($$) {
}
sub HEOSPlayer_WriteReadings($$) {
my ($hash,$decode_json) = @_;
my $name = $hash->{NAME};
Log3 $name, 3, "HEOSPlayer ($name) - processing data to write readings";
############################
#### Aufbereiten der Daten soweit nötig (bei Events zum Beispiel)
my $readingsHash = HEOSPlayer_PreProcessingReadings($hash,$decode_json)
if( $decode_json->{heos}{message} =~ /^pid=/ );
if( $decode_json->{heos}{message} =~ /^pid=/ and $decode_json->{heos}{command} ne "player\/get_now_playing_media");
############################
#### schreiben der Readings
readingsBeginUpdate($hash);
### Event Readings
if( ref($readingsHash) eq "HASH" ) {
Log3 $name, 4, "HEOSPlayer ($name) - response json Hash back from HEOSPlayer_PreProcessingReadings";
my $t;
my $v;
while( ( $t, $v ) = each (%{$readingsHash}) ) {
if( defined( $v ) ) {
readingsBulkUpdate( $hash, $t, $v );
readingsBulkUpdate( $hash, $t, $v ) if( defined( $v ) );
}
}
}
### PlayerInfos
readingsBulkUpdate( $hash, 'name', $decode_json->{payload}{name} );
@ -749,10 +588,8 @@ sub HEOSPlayer_WriteReadings($$) {
my $search = ReadingsVal($name,"currentStation" ,undef);
my( @index )= grep { $presets[$_] eq $search } 0..$#presets if ( defined $search );
readingsBulkUpdate( $hash, 'channel', $index[0]+1 ) if ( scalar @index > 0 );
readingsBulkUpdate( $hash, 'state', 'on' );
readingsEndUpdate( $hash, 1 );
Log3 $name, 5, "HEOSPlayer ($name) - readings set for $name";
return undef;
}
@ -762,167 +599,97 @@ sub HEOSPlayer_WriteReadings($$) {
### my little Helpers
sub HEOSPlayer_PreProcessingReadings($$) {
my ($hash,$decode_json) = @_;
my $name = $hash->{NAME};
my $reading;
my %buffer;
my %message = map { my ( $key, $value ) = split "="; $key => $value } split('&', $decode_json->{heos}{message});
Log3 $name, 4, "HEOSPlayer ($name) - preprocessing readings";
if ( $decode_json->{heos}{command} =~ /play_state/ or $decode_json->{heos}{command} =~ /player_state_changed/ ) {
my @value = split('&', $decode_json->{heos}{message});
$buffer{'playStatus'} = substr($value[1],6);
$buffer{'playStatus'} = $message{state};
} elsif ( $decode_json->{heos}{command} =~ /volume_changed/ or $decode_json->{heos}{command} =~ /set_volume/ or $decode_json->{heos}{command} =~ /get_volume/ ) {
my @value = split('&', $decode_json->{heos}{message});
$buffer{'volume'} = substr($value[1],6);
$buffer{'mute'} = substr($value[2],5) if( $decode_json->{heos}{command} =~ /volume_changed/ );
$buffer{'volume'} = $message{level};
$buffer{'mute'} = $message{mute} if( $decode_json->{heos}{command} =~ /volume_changed/ );
if (defined($buffer{'mute'}) && AttrVal($name, 'mute2play', 0) == 1) {
IOWrite($hash,'setPlayState',"pid=$hash->{PID}&state=play") if $buffer{'mute'} eq "off";
IOWrite($hash,'setPlayState',"pid=$hash->{PID}&state=stop") if $buffer{'mute'} eq "on";
}
} elsif ( $decode_json->{heos}{command} =~ /play_mode/ ) {
my @value = split('&', $decode_json->{heos}{message});
if(substr($value[1],7) eq 'on_all') {
$buffer{'repeat'} = 'all';
} elsif (substr($value[1],7) eq 'on_one') {
$buffer{'repeat'} = 'one';
} else {
$buffer{'repeat'} = substr($value[1],7);
}
$buffer{'shuffle'} = substr($value[2],8);
} elsif ( $decode_json->{heos}{command} =~ /play_mode/ or $decode_json->{heos}{command} =~ /repeat_mode_changed/ or $decode_json->{heos}{command} =~ /shuffle_mode_changed/ ) {
$buffer{'shuffle'} = $message{shuffle};
$buffer{'repeat'} = $message{repeat};
$buffer{'repeat'} ==~ s/.*\_(.*)/$1/g;
} elsif ( $decode_json->{heos}{command} =~ /get_mute/ ) {
my @value = split('&', $decode_json->{heos}{message});
$buffer{'mute'} = substr($value[1],6);
$buffer{'mute'} = $message{state};
} elsif ( $decode_json->{heos}{command} =~ /volume_up/ or $decode_json->{heos}{command} =~ /volume_down/ ) {
my @value = split('&', $decode_json->{heos}{message});
$buffer{'volumeUp'} = substr($value[1],5) if( $decode_json->{heos}{command} =~ /volume_up/ );
$buffer{'volumeDown'} = substr($value[1],5) if( $decode_json->{heos}{command} =~ /volume_down/ );
} elsif ( $decode_json->{heos}{command} =~ /repeat_mode_changed/ ) {
my @value = split('&', $decode_json->{heos}{message});
if(substr($value[1],7) eq 'on_all') {
$buffer{'repeat'} = 'all';
} elsif (substr($value[1],7) eq 'on_one') {
$buffer{'repeat'} = 'one';
} else {
$buffer{'repeat'} = substr($value[1],7);
}
} elsif ( $decode_json->{heos}{command} =~ /shuffle_mode_changed/ ) {
my @value = split('&', $decode_json->{heos}{message});
$buffer{'shuffle'} = substr($value[1],8);
$buffer{'volumeUp'} = $message{step} if( $decode_json->{heos}{command} =~ /volume_up/ );
$buffer{'volumeDown'} = $message{step} if( $decode_json->{heos}{command} =~ /volume_down/ );
} elsif ( $decode_json->{heos}{command} =~ /player_now_playing_changed/ or $decode_json->{heos}{command} =~ /favorites_changed/ ) {
IOWrite($hash,'getNowPlayingMedia',"pid=$hash->{PID}");
} elsif ( $decode_json->{heos}{command} =~ /play_preset/ ) {
my @value = split('&', $decode_json->{heos}{message});
$buffer{'channel'} = substr($value[1],7);
$buffer{'channel'} = $message{preset}
} elsif ( $decode_json->{heos}{command} =~ /play_input/ ) {
my @value = split('&', $decode_json->{heos}{message});
$buffer{'input'} = substr($value[1],6);
$buffer{'input'} = $message{input};
} elsif ( $decode_json->{heos}{command} =~ /playback_error/ ) {
my @value = split('&', $decode_json->{heos}{message});
$buffer{'error'} = substr($value[1],6);
$buffer{'error'} = $message{error};
} else {
Log3 $name, 3, "HEOSPlayer ($name) - no match found";
return undef;
}
Log3 $name, 4, "HEOSPlayer ($name) - Match found for decode_json";
return \%buffer;
}
sub HEOSPlayer_GetPlayerInfo($) {
my $hash = shift;
RemoveInternalTimer($hash,'HEOSPlayer_GetPlayerInfo');
IOWrite($hash,'getPlayerInfo',"pid=$hash->{PID}");
}
sub HEOSPlayer_GetPlayState($) {
my $hash = shift;
RemoveInternalTimer($hash,'HEOSPlayer_GetPlayState');
IOWrite($hash,'getPlayState',"pid=$hash->{PID}");
}
sub HEOSPlayer_GetPlayMode($) {
my $hash = shift;
RemoveInternalTimer($hash,'HEOSPlayer_GetPlayMode');
IOWrite($hash,'getPlayMode',"pid=$hash->{PID}");
}
sub HEOSPlayer_GetNowPlayingMedia($) {
my $hash = shift;
RemoveInternalTimer($hash,'HEOSPlayer_GetNowPlayingMedia');
IOWrite($hash,'getNowPlayingMedia',"pid=$hash->{PID}");
}
sub HEOSPlayer_GetVolume($) {
my $hash = shift;
RemoveInternalTimer($hash,'HEOSPlayer_GetVolume');
IOWrite($hash,'getVolume',"pid=$hash->{PID}");
}
sub HEOSPlayer_GetMute($) {
my $hash = shift;
RemoveInternalTimer($hash,'HEOSPlayer_GetMute');
IOWrite($hash,'getMute',"pid=$hash->{PID}");
}
sub HEOSPlayer_GetQueue($) {
my $hash = shift;
RemoveInternalTimer($hash,'HEOSPlayer_GetQueue');
IOWrite($hash,'getQueue',"pid=$hash->{PID}");
}