]"};}
$hash->{HELPER}{PNUMBER} = $prop;
$hash->{HELPER}{PNAME} = $prop1?$prop1:$prop; # wenn keine Presetname angegeben -> Presetnummer als Name verwenden
$hash->{HELPER}{PSPEED} = $prop2 if($prop2);
setPreset($hash);
} elsif ($opt eq "setHome" && IsModelCam($hash)) {
if (!$hash->{CREDENTIALS}) {return qq{Credentials of $name are not set - make sure you've set it with "set $name credentials username password"};}
if (!$prop) {return "Function \"$opt\" needs a \"Presetname\" as argument";}
$hash->{HELPER}{SETHOME} = $prop;
setHome($hash);
} elsif ($opt eq "delPreset" && IsModelCam($hash)) {
if (!$hash->{CREDENTIALS}) {return qq{Credentials of $name are not set - make sure you've set it with "set $name credentials username password"};}
if (!$prop) {return qq{Function "$opt" needs a "Presetname" as argument};}
$hash->{HELPER}{DELPRESETNAME} = $prop;
delPreset($hash);
} else {
return "$setlist";
}
return;
}
################################################################
sub Get {
my ($hash, @a) = @_;
return "\"get X\" needs at least an argument" if ( @a < 2 );
my $name = shift @a;
my $opt = shift @a;
my $arg = shift @a;
my $arg1 = shift @a;
my $arg2 = shift @a;
my $ret = "";
my $getlist;
if(!$hash->{CREDENTIALS}) {
return;
} elsif(IsModelCam($hash)) {
# getlist für Cams
$getlist = "Unknown argument $opt, choose one of ".
"caminfoall:noArg ".
"caminfo:noArg ".
((AttrVal($name,"snapGalleryNumber",undef) || AttrVal($name,"snapGalleryBoost",0))
? "snapGallery:noArg " : "snapGallery:$defSnum ").
(IsCapPTZPan($hash) ? "listPresets:noArg " : "").
"snapinfo:noArg ".
"svsinfo:noArg ".
"saveRecording ".
"snapfileinfo:noArg ".
"eventlist:noArg ".
"stmUrlPath:noArg ".
"storedCredentials:noArg ".
"scanVirgin:noArg ".
"versionNotes "
;
} else {
# getlist für SVS Devices
$getlist = "Unknown argument $opt, choose one of ".
"caminfoall:noArg ".
($hash->{HELPER}{APIHMMAXVER}?"homeModeState:noArg ": "").
"svsinfo:noArg ".
"listLog ".
"storedCredentials:noArg ".
"scanVirgin:noArg ".
"versionNotes "
;
}
return if(IsDisabled($name));
if ($opt eq "caminfo") {
# "1" ist Statusbit für manuelle Abfrage, kein Einstieg in Pollingroutine
if (!$hash->{CREDENTIALS}) {return "Credentials of $name are not set - make sure you've set it with \"set $name credentials username password\"";}
getCamInfo($hash);
} elsif ($opt eq "caminfoall") {
# "1" ist Statusbit für manuelle Abfrage, kein Einstieg in Pollingroutine
if (!$hash->{CREDENTIALS}) {return "Credentials of $name are not set - make sure you've set it with \"set $name credentials username password\"";}
getCaminfoAll($hash,1);
} elsif ($opt eq "homeModeState" && !IsModelCam($hash)) {
if (!$hash->{CREDENTIALS}) {return "Credentials of $name are not set - make sure you've set it with \"set $name credentials username password\"";}
getHomeModeState($hash);
} elsif ($opt eq "listLog" && !IsModelCam($hash)) {
if (!$hash->{CREDENTIALS}) {return "Credentials of $name are not set - make sure you've set it with \"set $name credentials username password\"";}
# übergebenen CL-Hash (FHEMWEB) in Helper eintragen
getClHash($hash,1);
extlogargs($hash, $arg) if($arg);
extlogargs($hash, $arg1) if($arg1);
extlogargs($hash, $arg2) if($arg2);
getSvsLog ($hash);
} elsif ($opt eq "listPresets" && IsModelCam($hash)) {
if (!$hash->{CREDENTIALS}) {return "Credentials of $name are not set - make sure you've set it with \"set $name credentials username password\"";}
# übergebenen CL-Hash (FHEMWEB) in Helper eintragen
getClHash($hash,1);
getPresets($hash);
} elsif ($opt eq "saveRecording") {
if (!$hash->{CREDENTIALS}) {return "Credentials of $name are not set - make sure you've set it with \"set $name credentials username password\"";}
$hash->{HELPER}{RECSAVEPATH} = $arg if($arg);
getRecAndSave($hash);
} elsif ($opt eq "svsinfo") {
if (!$hash->{CREDENTIALS}) {return "Credentials of $name are not set - make sure you've set it with \"set $name credentials username password\"";}
getSvsInfo($hash);
} elsif ($opt eq "storedCredentials") {
if (!$hash->{CREDENTIALS}) {return "Credentials of $name are not set - make sure you've set it with \"set $name credentials username password\"";}
# Credentials abrufen
my ($success, $username, $password) = getCredentials($hash,0,"svs");
unless ($success) {return "Credentials couldn't be retrieved successfully - see logfile"};
my ($smtpsuccess, $smtpuname, $smtpword) = getCredentials($hash,0,"smtp");
my $so;
if($smtpsuccess) {
$so = "SMTP-Username: $smtpuname, SMTP-Password: $smtpword";
} else {
$so = "SMTP credentials are not set";
}
return "Stored Credentials to access surveillance station or DSM:\n".
"=========================================================\n".
"Username: $username, Password: $password\n".
"\n".
"Stored Credentials to access SMTP server:\n".
"=========================================\n".
"$so\n";
} elsif ($opt eq "snapGallery" && IsModelCam($hash)) {
if (!$hash->{CREDENTIALS}) {return qq{Credentials of $name are not set - make sure you've set it with "set $name credentials username password"};}
my $txt = getClHash($hash);
return $txt if($txt);
if(!AttrVal($name, "snapGalleryBoost",0)) {
# Snaphash ist nicht vorhanden und wird abgerufen
$hash->{HELPER}{GETSNAPGALLERY} = 1;
# snap-Infos für Gallerie abrufen
my ($sg,$slim,$ssize);
$slim = $arg // AttrVal($name,"snapGalleryNumber",$defSlim); # Anzahl der abzurufenden Snapshots
$ssize = (AttrVal($name,"snapGallerySize","Icon") eq "Icon") ? 1 : 2; # Image Size 1-Icon, 2-Full
getSnapInfo("$name:$slim:$ssize");
} else {
# Snaphash ist vorhanden und wird zur Ausgabe aufbereitet
$hash->{HELPER}{SNAPLIMIT} = AttrVal($name,"snapGalleryNumber",$defSlim);
my %pars = ( linkparent => $name,
linkname => '',
ftui => 0
);
my $htmlCode = composeGallery(\%pars);
for (my $k=1; (defined($hash->{HELPER}{CL}{$k})); $k++ ) {
if ($hash->{HELPER}{CL}{$k}->{COMP}) {
# CL zusammengestellt (Auslösung durch Notify)
asyncOutput($hash->{HELPER}{CL}{$k}, "$htmlCode");
} else {
# Output wurde über FHEMWEB ausgelöst
return $htmlCode;
}
}
delete($hash->{HELPER}{CL});
}
} elsif ($opt eq "snapinfo" && IsModelCam($hash)) {
# Schnappschußgalerie abrufen oder nur Info des letzten Snaps
if (!$hash->{CREDENTIALS}) {return "Credentials of $name are not set - make sure you've set it with \"set $name credentials username password\"";}
my ($slim,$ssize) = snapLimSize($hash,1); # Force-Bit, es wird $hash->{HELPER}{GETSNAPGALLERY} gesetzt !
getSnapInfo("$name:$slim:$ssize");
} elsif ($opt eq "snapfileinfo" && IsModelCam($hash)) {
if (!$hash->{CREDENTIALS}) {return "Credentials of $name are not set - make sure you've set it with \"set $name credentials username password\"";}
if (!ReadingsVal("$name", "LastSnapId", undef)) {return "Reading LastSnapId is empty - please take a snapshot before !"}
getSnapFilename($hash);
} elsif ($opt eq "eventlist" && IsModelCam($hash)) {
if (!$hash->{CREDENTIALS}) {return "Credentials of $name are not set - make sure you've set it with \"set $name credentials username password\"";}
getEventList ($hash);
} elsif ($opt eq "stmUrlPath" && IsModelCam($hash)) {
if (!$hash->{CREDENTIALS}) {return "Credentials of $name are not set - make sure you've set it with \"set $name credentials username password\"";}
getStmUrlPath ($hash);
} elsif ($opt eq "scanVirgin") {
if (!$hash->{CREDENTIALS}) {return "Credentials of $name are not set - make sure you've set it with \"set $name credentials username password\"";}
sessionOff($hash);
delete $hash->{HELPER}{APIPARSET};
delete $hash->{CAMID};
# alte Readings außer state löschen
my @allrds = keys%{$defs{$name}{READINGS}};
for my $key(@allrds) {
# Log3 ($name, 1, "DbRep $name - Reading Schlüssel: $key");
delete($defs{$name}{READINGS}{$key}) if($key ne "state");
}
# "1" ist Statusbit für manuelle Abfrage, kein Einstieg in Pollingroutine
getCaminfoAll($hash,1);
} elsif ($opt =~ /versionNotes/x) {
my $header = "Module release information Helpful hints $header1
");
$ret .= "
";
$ret .= "";
$ret .= "";
if($arg && $arg =~ /[\d]+/x) {
my @hints = split(",",$arg);
for (@hints) {
if(AttrVal("global","language","EN") eq "DE") {
$hs{$_} = $vHintsExt_de{$_};
} else {
$hs{$_} = $vHintsExt_en{$_};
}
}
} else {
if(AttrVal("global","language","EN") eq "DE") {
%hs = %vHintsExt_de;
} else {
%hs = %vHintsExt_en;
}
}
$i = 0;
for my $key (sortVersion("desc",keys %hs)) {
$val0 = $hs{$key};
$ret .= sprintf("$key $val0 " );
$ret .= " ";
$i++;
if ($i & 1) {
# $i ist ungerade
$ret .= "";
} else {
$ret .= " ";
}
}
$ret .= " ";
$ret .= " ";
$ret .= "
";
$ret .= "
$header
");
$ret .= "
";
$ret .= "";
$ret .= "";
$i = 0;
for my $key (sortVersion("desc",keys %vNotesExtern)) {
($val0,$val1) = split(/\s/x,$vNotesExtern{$key},2);
$ret .= sprintf("$key $val0 $val1 " );
$ret .= " ";
$i++;
if ($i & 1) {
# $i ist ungerade
$ret .= "";
} else {
$ret .= " ";
}
}
$ret .= " ";
$ret .= " ";
$ret .= "
";
$ret .= "
Because SVS version 8.2.3-5828 is running you cannot see the MJPEG-Stream. Please upgrade to a higher SVS version ! $imgstop ";
$ret .= $imgblank;
if($hash->{HELPER}{RUNVIEW} =~ /live_fw/x) {
if(ReadingsVal($d, "Record", "Stop") eq "Stop") {
# Aufnahmebutton endlos Start
$ret .= "$imgrecendless ";
} else {
# Aufnahmebutton Stop
$ret .= "$imgrecstop ";
}
$ret .= "$imgdosnap ";
}
$ret .= "{HELPER}{AUDIOLINK} preload='none' volume='0.5' controls>".
"Your browser does not support the audio element.".
" ";
}
} elsif($wltype eq "iframe") {
$ret .= "";
$ret .= "$imgstop ";
if($hash->{HELPER}{AUDIOLINK} && ReadingsVal($d, "CamAudioType", "Unknown") !~ /Unknown/x) {
$ret .= "{HELPER}{AUDIOLINK} preload='none' volume='0.5' controls>".
"Your browser does not support the audio element.".
" ";
}
} elsif($wltype eq "embed") {
$ret .= "";
if($hash->{HELPER}{AUDIOLINK} && ReadingsVal($d, "CamAudioType", "Unknown") !~ /Unknown/x) {
$ret .= "{HELPER}{AUDIOLINK} preload='none' volume='0.5' controls>".
"Your browser does not support the audio element.".
" ";
}
} elsif($wltype eq "link") {
$alias = $hash->{HELPER}{ALIAS};
$ret .= "$alias $imgstop ";
$ret .= $imgblank;
$ret .= "$imgdosnap ";
} elsif($wltype eq "hls") {
$alias = $hash->{HELPER}{ALIAS};
$ret .= "".
"".
"".
"Your browser does not support the video tag".
" ";
$ret .= "$imgstop ";
$ret .= "$imghlsreact ";
$ret .= $imgblank;
if(ReadingsVal($d, "Record", "Stop") eq "Stop") {
# Aufnahmebutton endlos Start
$ret .= "$imgrecendless ";
} else {
# Aufnahmebutton Stop
$ret .= "$imgrecstop ";
}
$ret .= "$imgdosnap ";
} elsif($wltype eq "video") {
$ret .= "".
"".
"".
"".
"Your browser does not support the video tag.".
" ";
$ret .= "$imgstop ";
$ret .= "{HELPER}{AUDIOLINK} preload='none' volume='0.5' controls>".
"Your browser does not support the audio element.".
" ";
}
}
return $ret;
}
######################################################################################
# Detailanzeige
######################################################################################
sub FWdetailFn {
my ($FW_wname, $name, $room, $pageHash) = @_; # pageHash is set for summaryFn.
my $hash = $defs{$name};
my $ret = "";
checkIconpath ($name, $FW_wname);
$hash->{".setup"} = FWconfCam($name,$room);
if($hash->{".setup"} ne "") {
$ret .= $hash->{".setup"};
}
my %pars = ( linkparent => $name,
linkname => $name,
ftui => 0
);
$hash->{".ptzhtml"} = ptzPanel(\%pars) if($hash->{".ptzhtml"} eq "");
if($hash->{".ptzhtml"} ne "" && AttrVal($name,"ptzPanel_use",1)) {
$ret .= $hash->{".ptzhtml"};
}
return $ret;
}
###############################################################################
# Aufruf Konfigseite Kamera
###############################################################################
sub FWconfCam {
my ($name,$room) = @_;
my $hash = $defs{$name};
my $cip = ReadingsVal("$name","CamIP","");
my $svsip = $hash->{SERVERADDR};
my $svsport = $hash->{SERVERPORT};
my $svsprot = $hash->{PROTOCOL};
my $ttjs = "/fhem/pgm2/sscam_tooltip.js";
my $attr = AttrVal($name, "htmlattr", "");
my $alias = AttrVal($name, "alias", $name);
my $winname = $name."_view";
my $cicon = 'edit_settings.svg'; # Icon für Cam/SVS Setup-Screen
my $hicon = 'info_info.svg'; # Icon für SVS Hilfeseite
my $w = 150;
my ($ret,$cexpl,$hexpl) = ("","","");
my ($cs,$bs,$ch,$bh,);
if(IsModelCam($hash)) { # Camera Device
return $ret if(!$cip);
if(AttrVal("global","language","EN") =~ /DE/x) {
$cexpl = $ttips_de{confcam}; $cexpl =~ s/§NAME§/$alias/gx; $cexpl =~ s/\s+/ /gx;
} else {
$cexpl = $ttips_en{confcam}; $cexpl =~ s/§NAME§/$alias/gx; $cexpl =~ s/\s+/ /gx;
}
$cs = "window.open('http://$cip')";
} else { # SVS-Device
return $ret if(!$svsip);
if(AttrVal("global","language","EN") =~ /DE/x) {
$cexpl = $ttips_de{confsvs}; $cexpl =~ s/§NAME§/$alias/gx; $cexpl =~ s/\s+/ /gx;
} else {
$cexpl = $ttips_en{confsvs}; $cexpl =~ s/§NAME§/$alias/gx; $cexpl =~ s/\s+/ /gx;
}
$cs = "window.open('$svsprot://$svsip:$svsport/cam')";
}
if(AttrVal("global","language","EN") =~ /DE/x) {
$hexpl = $ttips_de{"helpsvs"}; $hexpl =~ s/\s/ /gx;
$ch = "window.open('https://www.synology.com/de-de/knowledgebase/Surveillance/help')";
} else {
$hexpl = $ttips_en{"helpsvs"}; $hexpl =~ s/\s/ /gx;
$ch = "window.open('https://www.synology.com/en-global/knowledgebase/Surveillance/help')";
}
$cicon = FW_makeImage($cicon); $hicon = FW_makeImage($hicon);
$bs = "Tip(`$cexpl`)";
$bh = "Tip(`$hexpl`)";
$ret .= "";
$ret .= "";
$ret .= "";
$ret .= '';
$ret .= "";
$ret .= " $cicon ";
$ret .= " ";
$ret .= " $hicon ";
$ret .= " ";
$ret .= "";
$ret .= ' ';
$ret .= "
";
$ret .= " on [rectime]" verwendet -> dann [rectime] nutzen,
# sonst Attribut "rectime" wenn es gesetzt ist, falls nicht -> "RECTIME_DEF"
if (defined($hash->{HELPER}{RECTIME_TEMP})) {
$rectime = delete $hash->{HELPER}{RECTIME_TEMP};
} else {
$rectime = AttrVal($name, "rectime", $hash->{HELPER}{RECTIME_DEF});
}
if ($rectime == 0) {
Log3($name, 3, "$name - Camera $camname endless Recording started - stop it by stop-command !");
} else {
if (ReadingsVal("$name", "Record", "Stop") eq "Start") {
# Aufnahme läuft schon und wird verlängert
Log3($name, 3, "$name - running recording renewed to $rectime s");
} else {
Log3($name, 3, "$name - Camera $camname recording with recording time $rectime s started");
}
}
readingsBeginUpdate($hash);
readingsBulkUpdate($hash,"Record","Start");
readingsBulkUpdate($hash,"state", "on");
readingsBulkUpdate($hash,"Errorcode","none");
readingsBulkUpdate($hash,"Error","none");
readingsEndUpdate($hash, 1);
if ($rectime != 0) {
# Stop der Aufnahme nach Ablauf $rectime, wenn rectime = 0 -> endlose Aufnahme
my $emtxt = $hash->{HELPER}{SMTPRECMSG}?$hash->{HELPER}{SMTPRECMSG}:"";
my $teletxt = $hash->{HELPER}{TELERECMSG}?$hash->{HELPER}{TELERECMSG}:"";
RemoveInternalTimer($hash, "FHEM::SSCam::camStopRec");
InternalTimer(gettimeofday()+$rectime, "FHEM::SSCam::camStopRec", $hash);
}
roomRefresh($hash,0,0,1); # kein Room-Refresh, kein SSCam-state-Event, SSCamSTRM-Event
} elsif ($OpMode eq "Stop") {
readingsBeginUpdate($hash);
readingsBulkUpdate ($hash, "Record", "Stop");
readingsBulkUpdate ($hash, "state", "off" );
readingsBulkUpdate ($hash, "Errorcode", "none");
readingsBulkUpdate ($hash, "Error" , "none");
readingsEndUpdate ($hash, 1);
Log3($name, 3, "$name - Camera $camname Recording stopped");
roomRefresh($hash,0,0,1); # kein Room-Refresh, kein SSCam-state-Event, SSCamSTRM-Event
# Aktualisierung Eventlist der letzten Aufnahme
getEventList($hash);
} elsif ($OpMode eq "ExpMode") {
readingsBeginUpdate($hash);
readingsBulkUpdate ($hash, "Errorcode", "none");
readingsBulkUpdate ($hash, "Error" , "none");
readingsEndUpdate ($hash, 1);
Log3($name, 3, "$name - Camera $camname exposure mode was set to \"$hash->{HELPER}{EXPMODE}\"");
} elsif ($OpMode eq "setZoom") {
readingsBeginUpdate($hash);
readingsBulkUpdate ($hash, "Errorcode", "none");
readingsBulkUpdate ($hash, "Error" , "none");
readingsEndUpdate ($hash, 1);
Log3($name, 3, qq{$name - Zoom operation "$hash->{HELPER}{ZOOM}{DIR}:$hash->{HELPER}{ZOOM}{MOVETYPE}" of Camera $camname successfully done} );
} elsif ($OpMode eq "GetRec") {
my $recid = ReadingsVal("$name", "CamLastRecId", "");
my $createdTm = ReadingsVal("$name", "CamLastRecTime", "");
my $lrec = ReadingsVal("$name", "CamLastRec", "");
my ($tdir,$fileName) = split("/",$lrec);
my $sn = 0;
my $tac = openOrgetTrans($hash); # Transaktion starten
my $cache;
if($hash->{HELPER}{CANSENDREC} || $hash->{HELPER}{CANTELEREC} || $hash->{HELPER}{CANCHATREC}) {
$cache = cache($name, "c_init"); # Cache initialisieren für Versandhash
Log3($name, 1, "$name - Fall back to internal Cache due to preceding failure.") if(!$cache);
if(!$cache || $cache eq "internal" ) {
$data{SSCam}{$name}{SENDRECS}{$tac}{$sn}{recid} = $recid;
$data{SSCam}{$name}{SENDRECS}{$tac}{$sn}{createdTm} = $createdTm;
$data{SSCam}{$name}{SENDRECS}{$tac}{$sn}{fileName} = $fileName;
$data{SSCam}{$name}{SENDRECS}{$tac}{$sn}{tdir} = $tdir;
$data{SSCam}{$name}{SENDRECS}{$tac}{$sn}{imageData} = $myjson;
} else {
cache($name, "c_write", "{SENDRECS}{$tac}{$sn}{recid}" ,$recid);
cache($name, "c_write", "{SENDRECS}{$tac}{$sn}{createdTm}" ,$createdTm);
cache($name, "c_write", "{SENDRECS}{$tac}{$sn}{fileName}" ,$fileName);
cache($name, "c_write", "{SENDRECS}{$tac}{$sn}{tdir}" ,$tdir);
cache($name, "c_write", "{SENDRECS}{$tac}{$sn}{imageData}" ,$myjson);
}
Log3($name, 4, "$name - Recording '$sn' added to send recording hash: ID => $recid, File => $fileName, Created => $createdTm");
}
# Recording als Email / Telegram / Chat versenden
if(!$cache || $cache eq "internal" ) {
prepareSendData ($hash, $OpMode, $data{SSCam}{$name}{SENDRECS}{$tac});
} else {
prepareSendData ($hash, $OpMode, "{SENDRECS}{$tac}");
}
closeTrans ($hash); # Transaktion beenden
readingsBeginUpdate ($hash);
readingsBulkUpdate ($hash,"Errorcode","none");
readingsBulkUpdate ($hash,"Error",$err);
readingsEndUpdate ($hash, 1);
} elsif ($OpMode eq "SaveRec") {
my $lrec = ReadingsVal("$name", "CamLastRec", "");
$lrec = (split("/",$lrec))[1];
my $sp = $hash->{HELPER}{RECSAVEPATH} // $attr{global}{modpath};
my $file = $sp."/$lrec";
delete $hash->{HELPER}{RECSAVEPATH};
open my $fh, '>', $file or do { $err = qq{Can't open file "$file": $!};
Log3($name, 2, "$name - $err");
};
if(!$err) {
binmode $fh;
print $fh $myjson;
close($fh);
$err = "none";
Log3($name, 3, qq{$name - Recording was saved to local file "$file"});
}
readingsBeginUpdate ($hash);
readingsBulkUpdate ($hash,"Errorcode","none");
readingsBulkUpdate ($hash,"Error",$err);
readingsEndUpdate ($hash, 1);
} elsif ($OpMode eq "sethomemode") {
readingsBeginUpdate($hash);
readingsBulkUpdate($hash,"Errorcode","none");
readingsBulkUpdate($hash,"Error","none");
readingsEndUpdate($hash, 1);
Log3($name, 3, "$name - HomeMode was set to \"$hash->{HELPER}{HOMEMODE}\" ");
# Token freigeben vor nächstem Kommando
delActiveToken($hash);
# neuen HomeModeState abrufen
getHomeModeState($hash);
} elsif ($OpMode eq "gethomemodestate") {
my $hmst = $data->{'data'}{'on'};
my $hmststr = ($hmst == 1)?"on":"off";
($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst) = localtime;
if($lang eq "DE") {
$update_time = sprintf "%02d.%02d.%04d / %02d:%02d:%02d" , $mday , $mon+=1 ,$year+=1900 , $hour , $min , $sec ;
} else {
$update_time = sprintf "%04d-%02d-%02d / %02d:%02d:%02d" , $year+=1900 , $mon+=1 , $mday , $hour , $min , $sec ;
}
readingsBeginUpdate ($hash);
readingsBulkUpdate ($hash,"HomeModeState",$hmststr);
readingsBulkUpdate ($hash,"LastUpdateTime",$update_time);
readingsBulkUpdate ($hash,"Errorcode","none");
readingsBulkUpdate ($hash,"Error","none");
readingsEndUpdate ($hash, 1);
} elsif ($OpMode eq "getsvslog") {
my $lec = $data->{'data'}{'total'}; # abgerufene Anzahl von Log-Einträgen
my $log = '';
my $log0 = "";
my $i = 0;
while ($data->{'data'}->{'log'}->[$i]) {
my $id = $data->{'data'}->{'log'}->[$i]{'id'};
my $un = $data->{'data'}->{'log'}->[$i]{'user_name'};
my $desc = $data->{'data'}->{'log'}->[$i]{'desc'};
my $level = $data->{'data'}->{'log'}->[$i]{'type'};
$level = ($level == 3)?"Error":($level == 2)?"Warning":"Information";
my $time = $data->{'data'}->{'log'}->[$i]{'time'};
$time = FmtDateTime($time);
$log0 = $time." - ".$level." - ".$desc if($i == 0);
$log .= "$time - $level - $descSurveillance Station Server \"$hash->{SERVERADDR}\" Log ( $i/$lec entries are displayed )Preset positions saved of camera \"$hash->{CAMNAME}\" ".
"(PresetNumber => Name: ..., Speed: ..., Type: ...) \"");
delActiveToken($hash);
return;
}
if($hash->{HELPER}{LOGINRETRIES} >= $lrt) {
# login wird abgebrochen, Freigabe Funktionstoken
delActiveToken($hash);
Log3($name, 2, "$name - ERROR - Login or privilege of user $username unsuccessful");
return;
}
my $httptimeout = AttrVal($name,"httptimeout",60);
$httptimeout = 60 if($httptimeout < 60);
Log3($name, 4, "$name - HTTP-Call login will be done with httptimeout-Value: $httptimeout s");
my $urlwopw; # nur zur Anzeige bei verbose >= 4 und "showPassInLog" == 0
# sid in Quotes einschliessen oder nicht -> bei Problemen mit 402 - Permission denied
my $sid = AttrVal($name, "noQuotesForSID", "0") == 1 ? "sid" : "\"sid\"";
if (AttrVal($name,"session","DSM") eq "SurveillanceStation") {
$url = "$proto://$serveraddr:$serverport/webapi/$apiauthpath?api=$apiauth&version=$apiauthmaxver&method=Login&account=$username&passwd=$password&session=SurveillanceStation&format=$sid";
$urlwopw = "$proto://$serveraddr:$serverport/webapi/$apiauthpath?api=$apiauth&version=$apiauthmaxver&method=Login&account=$username&passwd=*****&session=SurveillanceStation&format=$sid";
} else {
$url = "$proto://$serveraddr:$serverport/webapi/$apiauthpath?api=$apiauth&version=$apiauthmaxver&method=Login&account=$username&passwd=$password&format=$sid";
$urlwopw = "$proto://$serveraddr:$serverport/webapi/$apiauthpath?api=$apiauth&version=$apiauthmaxver&method=Login&account=$username&passwd=*****&format=$sid";
}
AttrVal($name, "showPassInLog", "0") == 1 ? Log3($name, 4, "$name - Call-Out now: $url") : Log3($name, 4, "$name - Call-Out now: $urlwopw");
$hash->{HELPER}{LOGINRETRIES}++;
$param = {
url => $url,
timeout => $httptimeout,
hash => $hash,
user => $username,
funcret => $fret,
method => "GET",
header => "Accept: application/json",
callback => \&loginReturn
};
HttpUtils_NonblockingGet ($param);
return;
}
sub loginReturn {
my ($param, $err, $myjson) = @_;
my $hash = $param->{hash};
my $name = $hash->{NAME};
my $username = $param->{user};
my $fret = $param->{funcret};
my $subref = \&$fret;
my $success;
# Verarbeitung der asynchronen Rückkehrdaten aus sub "login_nonbl"
if ($err ne "") {
# ein Fehler bei der HTTP Abfrage ist aufgetreten
Log3($name, 2, "$name - error while requesting ".$param->{url}." - $err");
readingsSingleUpdate($hash, "Error", $err, 1);
return login($hash,$fret);
} elsif ($myjson ne "") {
# wenn die Abfrage erfolgreich war ($data enthält die Ergebnisdaten des HTTP Aufrufes)
# Evaluiere ob Daten im JSON-Format empfangen wurden
($hash, $success) = evaljson($hash,$myjson);
unless ($success) {
Log3($name, 4, "$name - no JSON-Data returned: ".$myjson);
delActiveToken($hash);
return;
}
my $data = decode_json($myjson);
# Logausgabe decodierte JSON Daten
Log3($name, 5, "$name - JSON decoded: ". Dumper $data);
$success = $data->{'success'};
if ($success) {
# login war erfolgreich
my $sid = $data->{'data'}->{'sid'};
# Session ID in hash eintragen
$hash->{HELPER}{SID} = $sid;
readingsBeginUpdate($hash);
readingsBulkUpdate($hash,"Errorcode","none");
readingsBulkUpdate($hash,"Error","none");
readingsEndUpdate($hash, 1);
Log3($name, 4, "$name - Login of User $username successful - SID: $sid");
return &$subref($hash);
} else {
# Errorcode aus JSON ermitteln
my $errorcode = $data->{'error'}->{'code'};
# Fehlertext zum Errorcode ermitteln
my $error = expErrorsAuth($hash,$errorcode);
readingsBeginUpdate($hash);
readingsBulkUpdate($hash,"Errorcode",$errorcode);
readingsBulkUpdate($hash,"Error",$error);
readingsEndUpdate($hash, 1);
Log3($name, 3, "$name - Login of User $username unsuccessful. Code: $errorcode - $error - try again");
return login($hash,$fret);
}
}
return login($hash,$fret);
}
###################################################################################
# Funktion logout
###################################################################################
sub logout {
my $hash = shift;
my $name = $hash->{NAME};
my $serveraddr = $hash->{SERVERADDR};
my $serverport = $hash->{SERVERPORT};
my $apiauth = $hash->{HELPER}{APIAUTH};
my $apiauthpath = $hash->{HELPER}{APIAUTHPATH};
my $apiauthmaxver = $hash->{HELPER}{APIAUTHMAXVER};
my $sid = $hash->{HELPER}{SID};
my $proto = $hash->{PROTOCOL};
my $url;
my $param;
my $httptimeout;
Log3($name, 4, "$name - ####################################################");
Log3($name, 4, "$name - ### start cam operation $hash->{OPMODE} ");
Log3($name, 4, "$name - ####################################################");
Log3($name, 4, "$name - --- Begin Function logout nonblocking ---");
$httptimeout = AttrVal($name,"httptimeout",4);
Log3($name, 5, "$name - HTTP-Call will be done with httptimeout-Value: $httptimeout s");
if (AttrVal($name,"session","DSM") eq "SurveillanceStation") {
$url = "$proto://$serveraddr:$serverport/webapi/$apiauthpath?api=$apiauth&version=$apiauthmaxver&method=Logout&session=SurveillanceStation&_sid=$sid";
} else {
$url = "$proto://$serveraddr:$serverport/webapi/$apiauthpath?api=$apiauth&version=$apiauthmaxver&method=Logout&_sid=$sid";
}
$param = {
url => $url,
timeout => $httptimeout,
hash => $hash,
method => "GET",
header => "Accept: application/json",
callback => \&logoutReturn
};
HttpUtils_NonblockingGet ($param);
return;
}
sub logoutReturn {
my ($param, $err, $myjson) = @_;
my $hash = $param->{hash};
my $name = $hash->{NAME};
my $sid = $hash->{HELPER}{SID};
my ($success, $username) = getCredentials($hash,0,"svs");
my $OpMode = $hash->{OPMODE};
my $data;
my $error;
my $errorcode;
if ($err ne "") {
# wenn ein Fehler bei der HTTP Abfrage aufgetreten ist
Log3($name, 2, "$name - error while requesting ".$param->{url}." - $err");
readingsSingleUpdate($hash, "Error", $err, 1);
} elsif ($myjson ne "") {
# wenn die Abfrage erfolgreich war ($data enthält die Ergebnisdaten des HTTP Aufrufes)
Log3($name, 4, "$name - URL-Call: ".$param->{url});
# Evaluiere ob Daten im JSON-Format empfangen wurden
($hash, $success) = evaljson($hash,$myjson);
unless ($success) {
Log3($name, 4, "$name - Data returned: ".$myjson);
delActiveToken($hash);
return;
}
$data = decode_json($myjson);
# Logausgabe decodierte JSON Daten
Log3($name, 4, "$name - JSON returned: ". Dumper $data);
$success = $data->{'success'};
if ($success) {
# die Logout-URL konnte erfolgreich aufgerufen werden
Log3($name, 2, "$name - Session of User \"$username\" terminated - session ID \"$sid\" deleted");
} else {
# Errorcode aus JSON ermitteln
$errorcode = $data->{'error'}->{'code'};
# Fehlertext zum Errorcode ermitteln
$error = expErrorsAuth($hash,$errorcode);
Log3($name, 2, "$name - ERROR - Logout of User $username was not successful, however SID: \"$sid\" has been deleted. Errorcode: $errorcode - $error");
}
}
# Session-ID aus Helper-hash löschen
delete $hash->{HELPER}{SID};
# ausgeführte Funktion ist erledigt (auch wenn logout nicht erfolgreich), Freigabe Funktionstoken
delActiveToken($hash);
CancelDelayedShutdown($name);
return;
}
#############################################################################################
# Autocreate für Kameras
# $sn = Name der Kamera in SVS
#############################################################################################
sub setAutocreate {
my ($hash,$sn) = @_;
my $name = $hash->{NAME};
my $type = $hash->{TYPE};
my ($cmd, $err, $camname, $camhash);
my $dcn = (devspec2array("TYPE=SSCam:FILTER=CAMNAME=$sn"))[0]; # ist das Device aus der SVS bereits angelegt ?
$camhash = $defs{$dcn} if($dcn); # existiert ein Hash des Devices ?
if(!$camhash) {
$camname = "SSCam.".makeDeviceName($sn); # erlaubten Kameranamen für FHEM erzeugen
my $arg = $hash->{SERVERADDR}." ".$hash->{SERVERPORT}." ".$hash->{PROTOCOL};
$cmd = "$camname $type $sn $arg";
Log3($name, 2, "$name - Autocreate camera: define $cmd");
$err = CommandDefine(undef, $cmd);
if($err) {
Log3($name, 1, "ERROR: $err");
} else {
my $room = AttrVal($name, "room", "SSCam");
my $session = AttrVal($name, "session", "DSM");
CommandAttr (undef,"$camname room $room");
CommandAttr (undef,"$camname session $session");
CommandAttr (undef,"$camname icon it_camera");
CommandAttr (undef,"$camname devStateIcon .*isable.*:set_off .*nap:li_wht_on");
CommandAttr (undef,"$camname pollcaminfoall 210");
CommandAttr (undef,"$camname pollnologging 1");
CommandAttr (undef,"$camname httptimeout 20");
# Credentials abrufen und setzen
my ($success, $username, $password) = getCredentials($hash,0,"svs");
if($success) {
CommandSet(undef, "$camname credentials $username $password");
}
}
} else {
Log3($name, 4, "$name - Autocreate - SVS camera \"$sn\" already defined by \"$dcn\" ");
$camname = "";
}
return ($err,$camname);
}
###############################################################################
# Test ob JSON-String empfangen wurde
###############################################################################
sub evaljson {
my ($hash,$myjson) = @_;
my $OpMode = $hash->{OPMODE};
my $name = $hash->{NAME};
my $success = 1;
eval {decode_json($myjson)} or do
{
if( ($hash->{HELPER}{RUNVIEW} && $hash->{HELPER}{RUNVIEW} =~ m/^live_.*hls$/x) || $OpMode =~ m/^.*_hls$/x ) {
# HLS aktivate/deaktivate bringt kein JSON wenn bereits aktiviert/deaktiviert
Log3($name, 5, "$name - HLS-activation data return: $myjson");
if ($myjson =~ m/{"success":true}/x) {
$success = 1;
$myjson = '{"success":true}';
}
} else {
$success = 0;
readingsBeginUpdate($hash);
readingsBulkUpdate($hash,"Errorcode","none");
readingsBulkUpdate($hash,"Error","malformed JSON string received");
readingsEndUpdate($hash, 1);
}
};
return ($hash,$success,$myjson);
}
######################################################################################################
# Refresh eines Raumes
# $hash, $pload (1=Page reload), SSCam-state-Event(1=Event), SSCamSTRM-Event (1=Event)
######################################################################################################
sub roomRefresh {
my ($hash,$pload,$lpoll_scm,$lpoll_strm) = @_;
my ($name,$st);
if (ref $hash ne "HASH") {
($name,$pload,$lpoll_scm,$lpoll_strm) = split ",",$hash;
$hash = $defs{$name};
} else {
$name = $hash->{NAME};
}
my $fpr = 0;
# SSCamSTRM-Device mit hinterlegter FUUID ($hash->{HELPER}{INFORM}) selektieren
my @spgs = devspec2array("TYPE=SSCamSTRM"); # alle Streaming Devices !
my @mstd = devspec2array("TYPE=SSCamSTRM:FILTER=MODEL=master"); # alle Streaming MODEL=master Devices
my $room = "";
for my $sd (@spgs) {
if($defs{$sd}{LINKPARENT} eq $name) {
next if(IsDisabled($defs{$sd}{NAME}) || !$hash->{HELPER}{INFORM} || $hash->{HELPER}{INFORM} ne $defs{$sd}{FUUID});
$fpr = AttrVal($defs{$sd}{NAME},"forcePageRefresh",0);
$room = AttrVal($defs{$sd}{NAME},"room","");
Log3($name, 4, qq{$name - roomRefresh - pagerefresh forced by $defs{$sd}{NAME}}) if($fpr);
}
}
# Page-Reload
if($pload && $room && !$fpr) {
# nur Räume mit dem SSCamSTRM-Device reloaden
my @rooms = split(",",$room);
for my $r (@rooms) {
{ map { FW_directNotify("FILTER=room=$r", "#FHEMWEB:$_", "location.reload('true')", "") } devspec2array("TYPE=FHEMWEB") } ## no critic 'void context'
}
} elsif ($pload || $fpr) {
# trifft zu bei Detailansicht oder im FLOORPLAN bzw. Dashboard oder wenn Seitenrefresh mit dem
# SSCamSTRM-Attribut "forcePageRefresh" erzwungen wird
{ map { FW_directNotify("#FHEMWEB:$_", "location.reload('true')", "") } devspec2array("TYPE=FHEMWEB") } ## no critic 'void context'
}
# Aufnahmestatus/Disabledstatus in state abbilden & SSCam-Device state setzen (mit/ohne Event)
$st = (ReadingsVal($name, "Availability", "enabled") eq "disabled")?"disabled":(ReadingsVal($name, "Record", "") eq "Start")?"on":"off";
if($lpoll_scm) {
readingsSingleUpdate($hash,"state", $st, 1);
} else {
readingsSingleUpdate($hash,"state", $st, 0);
}
# parentState des SSCamSTRM-Device updaten ($hash->{HELPER}{INFORM} des LINKPARENT Devices muss FUUID des Streaming Devices haben)
if($lpoll_strm) {
$st = ReadingsVal($name, "state", "initialized");
for my $sp (@spgs) { # $sp = ein Streaming Device aus allen Streaming Devices
if($defs{$sp}{LINKPARENT} eq $name) {
next if(IsDisabled($defs{$sp}{NAME}) || !$hash->{HELPER}{INFORM} || $hash->{HELPER}{INFORM} ne $defs{$sp}{FUUID});
readingsBeginUpdate($defs{$sp});
readingsBulkUpdate ($defs{$sp},"parentState", $st);
readingsBulkUpdate ($defs{$sp},"state", "updated");
readingsEndUpdate ($defs{$sp}, 1);
for my $sm (@mstd) { # Wenn Streaming Device von Streaming Master adoptiert wurde auch den Master updaten
next if($defs{$sm}{LINKNAME} ne $sp);
readingsBeginUpdate($defs{$sm});
readingsBulkUpdate ($defs{$sm},"parentState", $st);
readingsBulkUpdate ($defs{$sm},"state", "updated");
readingsEndUpdate ($defs{$sm}, 1);
Log3($name, 4, "$name - roomRefresh - caller: $sp, Master: $sm updated");
}
Log3($name, 4, "$name - roomRefresh - caller: $sp, FUUID: $hash->{HELPER}{INFORM}");
delete $hash->{HELPER}{INFORM};
}
}
}
return;
}
###############################################################################
# Eigenschaften des Device liefern
###############################################################################
sub IsModelCam { # Modelleigenschaft liefern Cam-> 1 , sonst 0
my $hash = shift;
my $m = ($hash->{MODEL} ne "SVS") ? 1 : 0;
return $m;
}
sub IsCapHLS { # HLS Lieferfähigkeit (existiert "SYNO.SurveillanceStation.VideoStream" & Reading)
my ($hash) = @_;
my $name = $hash->{NAME};
my $cap = 0;
my $api = $hash->{HELPER}{APIVIDEOSTMSMAXVER};
my $csf = (ReadingsVal($name,"CamStreamFormat","MJPEG") eq "HLS")?1:0;
$cap = 1 if($api && $csf);
return $cap;
}
sub IsCapZoom { # PTZ Zoom Eigenschaft
my $hash = shift;
my $name = $hash->{NAME};
my $cap = ReadingsVal($name, "CapPTZZoom", "false") ne "false" ? 1 : 0;
return $cap;
}
sub IsCapPTZ { # PTZ Directions möglich Eigenschaft
my $hash = shift;
my $name = $hash->{NAME};
my $cap = ReadingsVal($name, "DeviceType", "Camera") eq "PTZ" ? 1 : 0;
return $cap;
}
sub IsCapPTZPan { # PTZ Pan Eigenschaft
my $hash = shift;
my $name = $hash->{NAME};
my $cap = (ReadingsVal($name, "CapPTZPan", "false") ne "false" && !AttrVal($name, "ptzNoCapPrePat", 0)) ? 1 : 0;
return $cap;
}
sub IsCapPTZTilt { # PTZ Tilt Eigenschaft
my $hash = shift;
my $name = $hash->{NAME};
my $cap = ReadingsVal($name, "CapPTZTilt", "false") ne "false" ? 1 : 0;
return $cap;
}
sub IsCapPTZObjTrack { # PTZ Objekt Tracking Eigenschaft
my $hash = shift;
my $name = $hash->{NAME};
my $cap = ReadingsVal($name, "CapPTZObjTracking", "false") ne "false" ? 1 : 0;
return $cap;
}
sub IsCapPTZAbs { # PTZ go to absolute Position Eigenschaft
my $hash = shift;
my $name = $hash->{NAME};
my $cap = ReadingsVal($name, "CapPTZAbs", "false") ne "false" ? 1 : 0;
return $cap;
}
sub IsCapPTZDir { # PTZ Directions möglich Eigenschaft
my $hash = shift;
my $name = $hash->{NAME};
my $cap = ReadingsVal($name, "CapPTZDirections", 0) > 0 ? 1 : 0;
return $cap;
}
sub IsCapPIR { # hat Kamera einen PIR
my $hash = shift;
my $name = $hash->{NAME};
my $cap = ReadingsVal($name, "CapPIR", "false") ne "false" ? 1 : 0;
return $cap;
}
sub IsModelMaster { # ist des Streamdevices MODEL=master
my $model = shift;
my $mm = $model eq "master" ? 1 : 0;
return $mm;
}
###############################################################################
# JSON Boolean Test und Mapping
###############################################################################
sub jboolmap {
my ($bool)= @_;
if(JSON::is_bool($bool)) {
$bool = $bool?"true":"false";
}
return $bool;
}
###############################################################################
# Ermittlung Anzahl und Größe der abzurufenden Schnappschußdaten
#
# $force = wenn auf jeden Fall der/die letzten Snaps von der SVS
# abgerufen werden sollen unabhängig ob LastSnapId vorhanden ist
###############################################################################
sub snapLimSize {
my ($hash,$force) = @_;
my $name = $hash->{NAME};
my ($slim,$ssize);
if(!AttrVal($name,"snapGalleryBoost",0)) {
$slim = 1;
$ssize = 0;
} else {
$hash->{HELPER}{GETSNAPGALLERY} = 1;
$slim = AttrVal($name,"snapGalleryNumber",$defSlim); # Anzahl der abzurufenden Snaps
}
if(AttrVal($name,"snapGallerySize","Icon") eq "Full") {
$ssize = 2; # Full Size
} else {
$ssize = 1; # Icon Size
}
if($hash->{HELPER}{CANSENDSNAP} || $hash->{HELPER}{CANTELESNAP} || $hash->{HELPER}{CANCHATSNAP}) {
# Versand Schnappschuß darf erfolgen falls gewünscht
$ssize = 2; # Full Size für EMail/Telegram/SSChatBot -Versand
}
if($hash->{HELPER}{SNAPNUM}) {
$slim = delete $hash->{HELPER}{SNAPNUM}; # enthält die Anzahl der ausgelösten Schnappschüsse
$hash->{HELPER}{GETSNAPGALLERY} = 1; # Steuerbit für Snap-Galerie bzw. Daten mehrerer Schnappschüsse abrufen
}
my @strmdevs = devspec2array("TYPE=SSCamSTRM:FILTER=PARENT=$name:FILTER=MODEL=lastsnap");
if(scalar(@strmdevs) >= 1) {
Log3($name, 4, "$name - Streaming devs of type \"lastsnap\": @strmdevs");
}
$hash->{HELPER}{GETSNAPGALLERY} = 1 if($force); # Bugfix 04.03.2019 Forum:https://forum.fhem.de/index.php/topic,45671.msg914685.html#msg914685
return ($slim,$ssize);
}
###############################################################################
# Helper für listLog-Argumente extrahieren
###############################################################################
sub extlogargs {
my ($hash,$a) = @_;
$hash->{HELPER}{LISTLOGSEVERITY} = (split("severity:",$a))[1] if(lc($a) =~ m/^severity:/x);
$hash->{HELPER}{LISTLOGLIMIT} = (split("limit:",$a))[1] if(lc($a) =~ m/^limit:/x);
$hash->{HELPER}{LISTLOGMATCH} = (split("match:",$a))[1] if(lc($a) =~ m/^match:/x);
return;
}
###############################################################################
# Helper für optimizeParams-Argumente extrahieren
###############################################################################
sub extoptpar {
my ($hash,$a,$cpcl) = @_;
$hash->{HELPER}{MIRROR} = (split("mirror:",$a))[1] if(lc($a) =~ m/^mirror:/x);
$hash->{HELPER}{FLIP} = (split("flip:",$a))[1] if(lc($a) =~ m/^flip:/x);
$hash->{HELPER}{ROTATE} = (split("rotate:",$a))[1] if(lc($a) =~ m/^rotate:/x);
$hash->{HELPER}{NTPSERV} = (split("ntp:",$a))[1] if(lc($a) =~ m/^ntp:/x);
$hash->{HELPER}{CHKLIST} = ($hash->{HELPER}{NTPSERV}?$cpcl->{ntp}:0)+
($hash->{HELPER}{MIRROR}?$cpcl->{mirror}:0)+
($hash->{HELPER}{FLIP}?$cpcl->{flip}:0)+
($hash->{HELPER}{ROTATE}?$cpcl->{rotate}:0);
return;
}
###############################################################################
# Clienthash übernehmen oder zusammenstellen
# Identifikation ob über FHEMWEB ausgelöst oder nicht -> erstellen $hash->CL
###############################################################################
sub getClHash {
my ($hash,$nobgd)= @_;
my $name = $hash->{NAME};
my $ret;
if($nobgd) {
# nur übergebenen CL-Hash speichern,
# keine Hintergrundverarbeitung bzw. synthetische Erstellung CL-Hash
$hash->{HELPER}{CL}{1} = $hash->{CL};
return;
}
if (!defined($hash->{CL})) {
# Clienthash wurde nicht übergeben und wird erstellt (FHEMWEB Instanzen mit canAsyncOutput=1 analysiert)
my $outdev;
my @webdvs = devspec2array("TYPE=FHEMWEB:FILTER=canAsyncOutput=1:FILTER=STATE=Connected");
my $i = 1;
for (@webdvs) {
$outdev = $_;
next if(!$defs{$outdev});
$hash->{HELPER}{CL}{$i}->{NAME} = $defs{$outdev}{NAME};
$hash->{HELPER}{CL}{$i}->{NR} = $defs{$outdev}{NR};
$hash->{HELPER}{CL}{$i}->{COMP} = 1;
$i++;
}
} else {
# übergebenen CL-Hash in Helper eintragen
$hash->{HELPER}{CL}{1} = $hash->{CL};
}
# Clienthash auflösen zur Fehlersuche (aufrufende FHEMWEB Instanz
if (defined($hash->{HELPER}{CL}{1})) {
for (my $k=1; (defined($hash->{HELPER}{CL}{$k})); $k++ ) {
Log3($name, 4, "$name - Clienthash number: $k");
while (my ($key,$val) = each(%{$hash->{HELPER}{CL}{$k}})) {
$val = $val?$val:" ";
Log3($name, 4, "$name - Clienthash: $key -> $val");
}
}
} else {
Log3($name, 2, "$name - Clienthash was neither delivered nor created !");
$ret = "Clienthash was neither delivered nor created. Can't use asynchronous output for function.";
}
return ($ret);
}
###############################################################################
# konvertiere alle ptzPanel_rowXX-attribute zu html-Code für
# das generierte Widget und das weblink-Device ptzPanel_$name
###############################################################################
sub ptzPanel {
my $paref = shift;
my $name = $paref->{linkparent};
my $ptzcdev = $paref->{linkname};
my $ftui = $paref->{ftui};
my $hash = $defs{$name};
my $iconpath = AttrVal ("$name", "ptzPanel_iconPath", "www/images/sscam");
my $iconprefix = AttrVal ("$name", "ptzPanel_iconPrefix", "black_btn_" );
my $valPresets = ReadingsVal("$name", "Presets", "" );
my $valPatrols = ReadingsVal("$name", "Patrols", "" );
my $rowisset = 0;
my ($pbs,$pbsf) = ("","");
my ($row,$ptz_ret);
return "" if(myVersion($hash) <= 71);
$pbs = AttrVal($ptzcdev,"ptzButtonSize", 100); # Größe der Druckbuttons in %
$pbsf = AttrVal($ptzcdev,"ptzButtonSizeFTUI", 100); # Größe der Druckbuttons im FTUI in %
$ptz_ret = "";
$ptz_ret .= "";
$ptz_ret .= "";
$ptz_ret .= "";
### PTZ-Elemente
#########################
$ptz_ret .= '';
$ptz_ret .= "";
$ptz_ret .= "PTZ Control ";
$ptz_ret .= " ";
$ptz_ret .= "";
$ptz_ret .= " ";
for my $rownr (0..9) {
$rownr = sprintf("%2.2d",$rownr);
$row = AttrVal("$name","ptzPanel_row$rownr",undef);
next if (!$row);
$rowisset = 1;
$ptz_ret .= "";
my @btn = split (",",$row); # die Anzahl Buttons in einer Reihe
for my $btnnr (0..$#btn) {
$ptz_ret .= "";
if ($btn[$btnnr] ne "") {
my ($cmd,$img);
if ($btn[$btnnr] =~ /(.*?):(.*)/x) { # enthält Komando -> :
$cmd = $1;
$img = $2;
} else { # button has format or is empty
$cmd = $btn[$btnnr];
$img = $btn[$btnnr];
}
if ($img =~ m/\.svg/x) { # Verwendung für SVG's
$img = FW_makeImage($img, $cmd, "rc-button");
} else { # $FW_ME = URL-Pfad unter dem der FHEMWEB-Server via HTTP erreichbar ist, z.B. /fhem
if($ftui) {
$img = "$img ";
} else {
$ptz_ret .= $img;
}
}
$ptz_ret .= " ";
$ptz_ret .= "\n";
}
$ptz_ret .= " \n";
}
### Zoom
###############################
if(IsCapZoom($hash)) { # wenn Zoom Eigenschaft
$ptz_ret .= "";
$ptz_ret .= " ";
$ptz_ret .= "";
my @za = qw(.++ + stop - --.);
for my $cmd (@za) {
$ptz_ret .= "";
my $img = $zd{$cmd}{panimg};
if(!$img) {
$ptz_ret .= $cmd;
$ptz_ret .= " ";
next;
}
if ($img =~ m/\.svg/x) { # Verwendung für SVG's
$img = FW_makeImage($img, $cmd, "rc-button");
} else { # $FW_ME = URL-Pfad unter dem der FHEMWEB-Server via HTTP erreichbar ist, z.B. /fhem
my $iPath = FW_iconPath($img); # automatisches Suchen der Icons im FHEMWEB iconPath
if($iPath) {
$iPath = "$FW_ME/$FW_icondir/$iPath";
} else {
$iPath = "$FW_ME/$iconpath/$img";
}
if($ftui) {
$img = "$img ";
$ptz_ret .= "";
}
$ptz_ret .= " ";
}
$ptz_ret .= "
";
### add Preset / Patrols
###############################
if(!$ftui) {
my ($Presets,$Patrols);
my $cmdPreset = "goPreset";
my $cmdPatrol = "runPatrol";
## Presets
for my $fn (sort keys %{$data{webCmdFn}}) {
next if($data{webCmdFn}{$fn} ne "FW_widgetFallbackFn");
no strict "refs"; ## no critic 'NoStrict'
$Presets = &{$data{webCmdFn}{$fn}}($FW_wname,$name,"",$cmdPreset,$valPresets);
use strict "refs";
last if(defined($Presets));
}
if($Presets) {
$Presets =~ s,^]*>(.*) $,$1,x;
} else {
$Presets = FW_pH "cmd.$name=set $name $cmdPreset", $cmdPreset, 0, "", 1, 1;
}
## Patrols
for my $fn (sort keys %{$data{webCmdFn}}) {
next if($data{webCmdFn}{$fn} ne "FW_widgetFallbackFn");
no strict "refs"; ## no critic 'NoStrict'
$Patrols = &{$data{webCmdFn}{$fn}}($FW_wname,$name,"",$cmdPatrol,$valPatrols);
use strict "refs";
last if(defined($Patrols));
}
if($Patrols) {
$Patrols =~ s,^]*>(.*)$,$1,x;
} else {
$Patrols = FW_pH "cmd.$name=set $name $cmdPatrol", $cmdPatrol, 0, "", 1, 1;
}
## Ausgabe
$ptz_ret .= '';
if($valPresets) {
$ptz_ret .= "";
$ptz_ret .= "Preset: $Presets ";
$ptz_ret .= " ";
}
if($valPatrols) {
$ptz_ret .= "";
$ptz_ret .= "Patrol: $Patrols ";
$ptz_ret .= " ";
}
$ptz_ret .= "
";
}
if ($rowisset) {
return $ptz_ret;
} else {
return "";
}
}
###############################################################################
# spezielle Attribute für PTZ-ControlPanel verfügbar machen
###############################################################################
sub addptzattr {
my $name = shift;
my $hash = $defs{$name};
my $actvs;
my @vl = split (/\.|-/x,ReadingsVal($name, "SVSversion", ""));
if(@vl) {
$actvs = $vl[0];
$actvs.= $vl[1];
}
return if(ReadingsVal($name,"DeviceType","Camera") ne "PTZ" || $actvs <= 71);
for my $n (0..9) {
$n = sprintf("%2.2d",$n);
addToDevAttrList($name, "ptzPanel_row$n");
}
my $p = ReadingsVal("$name","Presets","");
if($p ne "") {
my @h;
my $arg = "ptzPanel_Home";
my @ua = split(" ", $attr{$name}{userattr});
for (@ua) {
push(@h,$_) if($_ !~ m/$arg.*/x);
}
$attr{$name}{userattr} = join(' ',@h);
addToDevAttrList($name, "ptzPanel_Home:".$p);
}
addToDevAttrList($name, "ptzPanel_iconPrefix");
addToDevAttrList($name, "ptzPanel_iconPath");
addToDevAttrList($name, "ptzPanel_use:0,1");
# PTZ Panel Widget initial generieren
my $upleftfast = "move upleft";
my $upfast = "move up";
my $uprightfast = "move upright";
my $upleft = "move upleft 0.5";
my $up = "move up 0.5";
my $upright = "move upright 0.5";
my $leftfast = "move left";
my $leftslow = "move left 0.5";
my $home = "goPreset ".AttrVal($name,"ptzPanel_Home",ReadingsVal($name,"PresetHome",""));
my $rightslow = "move right 0.5";
my $rightfast = "move right";
my $downleft = "move downleft 0.5";
my $down = "move down 0.5";
my $downright = "move downright 0.5";
my $downleftfast = "move downleft";
my $downfast = "move down";
my $downrightfast = "move downright";
$attr{$name}{ptzPanel_row00} = "$upleftfast:CAMUPLEFTFAST.png,:CAMBLANK.png,$upfast:CAMUPFAST.png,:CAMBLANK.png,$uprightfast:CAMUPRIGHTFAST.png"
if(!AttrVal($name,"ptzPanel_row00",undef));
$attr{$name}{ptzPanel_row01} = ":CAMBLANK.png,$upleft:CAMUPLEFT.png,$up:CAMUP.png,$upright:CAMUPRIGHT.png"
if(!AttrVal($name,"ptzPanel_row01",undef));
$attr{$name}{ptzPanel_row02} = "$leftfast:CAMLEFTFAST.png,$leftslow:CAMLEFT.png,$home:CAMHOME.png,$rightslow:CAMRIGHT.png,$rightfast:CAMRIGHTFAST.png"
if(!AttrVal($name,"ptzPanel_row02",undef) || $home ne $hash->{HELPER}{OLDPTZHOME});
$attr{$name}{ptzPanel_row03} = ":CAMBLANK.png,$downleft:CAMDOWNLEFT.png,$down:CAMDOWN.png,$downright:CAMDOWNRIGHT.png"
if(!AttrVal($name,"ptzPanel_row03",undef));
$attr{$name}{ptzPanel_row04} = "$downleftfast:CAMDOWNLEFTFAST.png,:CAMBLANK.png,$downfast:CAMDOWNFAST.png,:CAMBLANK.png,$downrightfast:CAMDOWNRIGHTFAST.png"
if(!AttrVal($name,"ptzPanel_row04",undef));
$hash->{HELPER}{OLDPTZHOME} = $home;
$hash->{".ptzhtml"} = ""; # ptzPanel wird neu durchlaufen
return;
}
######################################################################################
# Funktion für SSCamSTRM-Devices
#
# $camname = Name der Kamaera (Parent-Device)
# $strmdev = Name des Streaming-Devices
# $fmt = Streaming Format (Vergleich auf "eq" !)
# $omodel = originäres MODEL des Streaming Devices (wg. master)
# $oname = originäres NAME des Streaming Devices (wg. master)
#
######################################################################################
sub streamDev { ## no critic 'complexity'
my $paref = shift;
my $camname = $paref->{linkparent};
my $strmdev = $paref->{linkname};
my $fmt = $paref->{linkmodel};
my $omodel = $paref->{omodel};
my $oname = $paref->{oname};
my $ftui = $paref->{ftui};
my $hash = $defs{$camname};
my $streamHash = $defs{$strmdev}; # Hash des SSCamSTRM-Devices
my $uuid = $streamHash->{FUUID}; # eindeutige UUID des Streamingdevices
my $hdrAlign = "center";
delete $streamHash->{HELPER}{STREAM};
delete $streamHash->{HELPER}{STREAMACTIVE}; # Statusbit ob ein Stream aktiviert ist
my ($show,$cause,$ret);
# Definition Tasten
my $imgblank = "$alias ";
$dlink = $alias if(AttrVal($strmdev, "noLink", 0)); # keine Links im Stream-Dev generieren
my $StmKey = ReadingsVal($camname,"StmKey",undef);
my %params = (
camname => $camname,
strmdev => $strmdev,
ftui => $ftui,
uuid => $uuid,
ha => $ha,
hb => $hb,
hau => $hau,
pws => $pws,
serveraddr => $hash->{SERVERADDR},
serverport => $hash->{SERVERPORT},
apivideostm => $hash->{HELPER}{APIVIDEOSTM},
apivideostmpath => $hash->{HELPER}{APIVIDEOSTMPATH},
apivideostmmaxver => $hash->{HELPER}{APIVIDEOSTMMAXVER},
apiaudiostm => $hash->{HELPER}{APIAUDIOSTM},
apiaudiostmpath => $hash->{HELPER}{APIAUDIOSTMPATH},
apiaudiostmmaxver => $hash->{HELPER}{APIAUDIOSTMMAXVER},
apivideostms => $hash->{HELPER}{APIVIDEOSTMS},
apivideostmspath => $hash->{HELPER}{APIVIDEOSTMSPATH},
apivideostmsmaxver => $hash->{HELPER}{APIVIDEOSTMSMAXVER},
camid => $hash->{CAMID},
sid => $hash->{HELPER}{SID},
proto => $hash->{PROTOCOL},
cmdstop => $cmdstop,
cmdhlsreact => $cmdhlsreact,
cmdmjpegrun => $cmdmjpegrun,
cmdhlsrun => $cmdhlsrun,
cmdlrirun => $cmdlrirun,
cmdlh264run => $cmdlh264run,
cmdlmjpegrun => $cmdlmjpegrun,
cmdlsnaprun => $cmdlsnaprun,
cmdrecendless => $cmdrecendless,
cmdrecstop => $cmdrecstop,
cmddosnap => $cmddosnap,
cmdrefresh => $cmdrefresh,
imgblank => $imgblank,
imgstop => $imgstop,
imghlsreact => $imghlsreact,
imgmjpegrun => $imgmjpegrun,
imghlsrun => $imghlsrun,
imglrirun => $imglrirun,
imglh264run => $imglh264run,
imglmjpegrun => $imglmjpegrun,
imglsnaprun => $imglsnaprun,
imgrecendless => $imgrecendless,
imgrecstop => $imgrecstop,
imgdosnap => $imgdosnap,
imgrefresh => $imgrefresh,
ttrefresh => $ttrefresh,
ttrecstart => $ttrecstart,
ttrecstop => $ttrecstop,
ttsnap => $ttsnap,
ttcmdstop => $ttcmdstop,
tthlsreact => $tthlsreact,
ttmjpegrun => $ttmjpegrun,
tthlsrun => $tthlsrun,
ttlrrun => $ttlrrun,
tth264run => $tth264run,
ttlmjpegrun => $ttlmjpegrun,
ttlsnaprun => $ttlsnaprun,
);
$ret = "";
$ret .= "";
$ret .= '';
if($ftui) {
$ret .= "$dlink $show $dlink $show ';
$ret .= '';
my $ismm = IsModelMaster($omodel); # prüfen ob Streaming Dev ist MODEL = master
if(!$ismm && (!$StmKey || ReadingsVal($camname, "Availability", "") ne "enabled" || IsDisabled($camname))) {
# Ausgabe bei Fehler
my $cam = AttrVal($camname, "alias", $camname); # Linktext als Aliasname oder Devicename setzen
$cause = !$StmKey ? "Camera $cam has no Reading \"StmKey\" set !" : "Cam \"$cam\" is disabled";
$cause = "Camera \"$cam\" is disabled" if(IsDisabled($camname));
$ret .= " $cause ";
$ret .= ' ';
$ret .= ' ';
$ret .= '
';
$ret .= '';
return $ret;
}
# Streaming ausführen
no strict "refs"; ## no critic 'NoStrict'
if($sdfn{$fmt}) {
$ret .= &{$sdfn{$fmt}{fn}} (\%params) if(defined &{$sdfn{$fmt}{fn}});
} else {
$cause = qq{Streaming of format "$fmt" is not supported};
$cause = qq{Select a Streaming client with the "adopt" command.} if($ismm);
$ret .= " $cause ";
}
use strict "refs";
$ret .= '';
$ret .= '';
$ret .= '';
return $ret;
}
######################################################################################
# Streaming Device Typ: mjpeg
sub _streamDevMJPEG { ## no critic 'complexity not used'
my $params = shift;
my $camname = $params->{camname};
my $strmdev = $params->{strmdev};
my $hash = $defs{$camname};
my $streamHash = $defs{$strmdev};
my $camid = $params->{camid} // return "";
my $sid = $params->{sid} // return "";
my $ftui = $params->{ftui};
my $proto = $params->{proto};
my $pws = $params->{pws};
my $ha = $params->{ha};
my $hb = $params->{hb};
my $hau = $params->{hau};
my $serveraddr = $params->{serveraddr};
my $serverport = $params->{serverport};
my $apivideostms = $params->{apivideostms};
my $apivideostmspath = $params->{apivideostmspath};
my $apivideostmsmaxver = $params->{apivideostmsmaxver};
my $apiaudiostm = $params->{apiaudiostm};
my $apiaudiostmpath = $params->{apiaudiostmpath};
my $apiaudiostmmaxver = $params->{apiaudiostmmaxver};
my $cmdrecendless = $params->{cmdrecendless};
my $ttrecstart = $params->{ttrecstart};
my $imgrecendless = $params->{imgrecendless};
my $cmdrecstop = $params->{cmdrecstop};
my $ttrecstop = $params->{ttrecstop};
my $imgrecstop = $params->{imgrecstop};
my $cmddosnap = $params->{cmddosnap};
my $ttsnap = $params->{ttsnap};
my $imgdosnap = $params->{imgdosnap};
my ($link,$audiolink);
my $ret = "";
if(ReadingsVal($camname, "SVSversion", "8.2.3-5828") eq "8.2.3-5828" && ReadingsVal($camname, "CamVideoType", "") !~ /MJPEG/x) {
$ret .= " Because SVS version 8.2.3-5828 is running you cannot play back MJPEG-Stream. Please upgrade to a higher SVS version ! popupStream" speichern
$streamHash->{HELPER}{STREAMACTIVE} = 1 if($link); # Statusbit wenn ein Stream aktiviert ist
}
if(!$hb) {
if(ReadingsVal($camname, "Record", "Stop") eq "Stop") {
# Aufnahmebutton endlos Start
$ret .= "$imgrecendless ";
} else {
# Aufnahmebutton Stop
$ret .= "$imgrecstop ";
}
$ret .= "$imgdosnap ";
}
$ret .= " $ptz_ret ";
}
}
if($audiolink && ReadingsVal($camname, "CamAudioType", "Unknown") !~ /Unknown/x && !$hau) {
$ret .= '';
$ret .= '';
$ret .= "".
"Your browser does not support the audio element.".
" ";
$ret .= "$imgdosnap ";
}
$ret .= " popupStream" speichern
$streamHash->{HELPER}{STREAMACTIVE} = 1 if($link); # Statusbit wenn ein Stream aktiviert ist
} else {
$cause = "no snapshot available to display";
$cause = "kein Schnappschuss zur Anzeige vorhanden" if(AttrVal("global","language","EN") =~ /DE/ix);
$ret .= " $cause ";
}
Log3($strmdev, 4, "$strmdev - Link called: $link") if($link);
undef $link;
return $ret;
}
######################################################################################
# Streaming Device Typ: generic
sub _streamDevGENERIC { ## no critic 'not used'
my $params = shift;
my $camname = $params->{camname};
my $strmdev = $params->{strmdev};
my $hash = $defs{$camname};
my $streamHash = $defs{$strmdev};
my $ftui = $params->{ftui};
my $pws = $params->{pws};
my $ha = $params->{ha};
my $hb = $params->{hb};
my $cmdrefresh = $params->{cmdrefresh};
my $cmdrecendless = $params->{cmdrecendless};
my $cmdrecstop = $params->{cmdrecstop};
my $cmddosnap = $params->{cmddosnap};
my $imgrecendless = $params->{imgrecendless};
my $imgrecstop = $params->{imgrecstop};
my $imgdosnap = $params->{imgdosnap};
my $imgrefresh = $params->{imgrefresh};
my $imgblank = $params->{imgblank};
my $ttrefresh = $params->{ttrefresh};
my $ttsnap = $params->{ttsnap};
my $ttrecstop = $params->{ttrecstop};
my $ttrecstart = $params->{ttrecstart};
my $ret = "";
my $htag = AttrVal( $strmdev, "genericStrmHtmlTag", AttrVal($camname, "genericStrmHtmlTag", "") );
if($htag =~ m/^\s*(.*)\s*$/sx) {
$htag = $1;
$htag =~ s/\$NAME/$camname/xg;
$htag =~ s/\$HTMLATTR/$ha/xg;
$htag =~ s/\$PWS/$pws/xg;
}
if(!$htag) {
$ret .= " Set attribute \"genericStrmHtmlTag\" in device $camname or in device $strmdev ";
$ret .= ' ';
$ret .= '';
$ret .= '';
$ret .= '';
return $ret;
}
$ret .= "";
$ret .= "$htag";
if($htag) {
# Popup-Tag um den Popup-Teil bereinigen
my $ptag = $htag;
$ptag =~ m/^\s+?(?<)\s+?(?.*?)\s+?onClick=.*?\s+?(?>)\s+?$/s;
$ptag = $+{heart} ? $+{b}.$+{heart}.$+{e} : $ptag;
$streamHash->{HELPER}{STREAM} = "$ptag"; # Stream für "set popupStream" speichern
$streamHash->{HELPER}{STREAM} =~ s/["']//gx;
$streamHash->{HELPER}{STREAM} =~ s/\s+/ /gx;
$streamHash->{HELPER}{STREAMACTIVE} = 1; # Statusbit wenn ein Stream aktiviert ist
}
$ret .= "$imgrefresh ";
$ret .= $imgblank;
if(ReadingsVal($camname, "Record", "Stop") eq "Stop") { # Aufnahmebutton endlos Start
$ret .= "$imgrecendless ";
} else { # Aufnahmebutton Stop
$ret .= "$imgrecstop ";
}
$ret .= "$imgdosnap ";
}
$ret .= " ";
if(AttrVal($camname,"ptzPanel_use",1)) {
my %pars = ( linkparent => $camname,
linkname => $strmdev,
ftui => $ftui
);
my $ptz_ret = ptzPanel(\%pars);
if($ptz_ret) {
$ret .= "$ptz_ret ";
}
}
return $ret;
}
######################################################################################
# Streaming Device Typ: hls
sub _streamDevHLS { ## no critic 'not used'
my $params = shift;
my $camname = $params->{camname};
my $strmdev = $params->{strmdev};
my $hash = $defs{$camname};
my $streamHash = $defs{$strmdev};
my $ftui = $params->{ftui};
my $pws = $params->{pws};
my $ha = $params->{ha};
my $hb = $params->{hb};
my $cmdrefresh = $params->{cmdrefresh};
my $cmdrecendless = $params->{cmdrecendless};
my $cmdrecstop = $params->{cmdrecstop};
my $cmddosnap = $params->{cmddosnap};
my $imgrecendless = $params->{imgrecendless};
my $imgrecstop = $params->{imgrecstop};
my $imgdosnap = $params->{imgdosnap};
my $imgrefresh = $params->{imgrefresh};
my $imgblank = $params->{imgblank};
my $ttrefresh = $params->{ttrefresh};
my $ttsnap = $params->{ttsnap};
my $ttrecstop = $params->{ttrecstop};
my $ttrecstart = $params->{ttrecstart};
my ($cause,$ret) = ("","");
# es ist ein .m3u8-File bzw. ein Link dorthin zu übergeben
my $cam = AttrVal($camname, "alias", $camname);
my $m3u8 = AttrVal($camname, "hlsStrmObject", "");
if( $m3u8 =~ m/^\s*(.*)\s*$/sx ) {
$m3u8 = $1;
$m3u8 =~ s/\$NAME/$camname/gx;
}
my $d = $camname;
$d =~ s/\./_/x; # Namensableitung zur javascript Codeanpassung
if(!$m3u8) {
$cause = "You have to specify attribute \"hlsStrmObject\" in Camera $cam !";
$ret .= " $cause ";
$ret .= '';
$ret .= '';
$ret .= '';
$ret .= '';
return $ret;
}
$ret .= " popupStream" speichern
$streamHash->{HELPER}{STREAMACTIVE} = 1; # Statusbit wenn ein Stream aktiviert ist
if(!$hb) {
$ret .= "$imgrefresh ";
$ret .= $imgblank;
if(ReadingsVal($camname, "Record", "Stop") eq "Stop") { # Aufnahmebutton endlos Start
$ret .= "$imgrecendless ";
} else { # Aufnahmebutton Stop
$ret .= "$imgrecstop ";
}
$ret .= "$imgdosnap ";
}
$ret .= " $ptz_ret ";
}
}
return $ret;
}
######################################################################################
# Streaming Device Typ: switched
sub _streamDevSWITCHED { ## no critic 'not used'
my $params = shift;
my $camname = $params->{camname};
my $strmdev = $params->{strmdev};
my $hash = $defs{$camname};
my $cmdmjpegrun = $params->{cmdmjpegrun};
my $cmdhlsrun = $params->{cmdhlsrun};
my $cmdlrirun = $params->{cmdlrirun};
my $cmdlh264run = $params->{cmdlh264run};
my $cmdlsnaprun = $params->{cmdlsnaprun};
my $cmdlmjpegrun = $params->{cmdlmjpegrun};
my $imgmjpegrun = $params->{imgmjpegrun};
my $imghlsrun = $params->{imghlsrun};
my $imglh264run = $params->{imglh264run};
my $imglmjpegrun = $params->{imglmjpegrun};
my $imglsnaprun = $params->{imglsnaprun};
my $imglrirun = $params->{imglrirun};
my $ttmjpegrun = $params->{ttmjpegrun};
my $tthlsrun = $params->{tthlsrun};
my $ttlrrun = $params->{ttlrrun};
my $tth264run = $params->{tth264run};
my $ttlmjpegrun = $params->{ttlmjpegrun};
my $ttlsnaprun = $params->{ttlsnaprun};
my ($link,$cause,$ret) = ("","","");
my $wltype = $hash->{HELPER}{WLTYPE};
$link = $hash->{HELPER}{LINK};
if(!$link) {
my $cam = AttrVal($camname, "alias", $camname);
$cause = "Playback cam \"$cam\" switched off";
$ret .= " $cause $imgmjpegrun ";
$ret .= "$imghlsrun " if(IsCapHLS($hash));
$ret .= "$imglrirun ";
$ret .= "$imglh264run ";
$ret .= "$imglmjpegrun ";
$ret .= "$imglsnaprun ";
$ret .= " ";
return $ret;
}
# Streaming ausführen
no strict "refs"; ## no critic 'NoStrict'
if($sdswfn{$wltype}) {
$ret .= &{$sdswfn{$wltype}{fn}} ($params) if(defined &{$sdswfn{$wltype}{fn}});
} else {
$cause = qq{Streaming of format "$wltype" is not supported};
$ret .= " $cause ";
}
use strict "refs";
Log3($strmdev, 4, "$strmdev - Link called: $link");
undef $link;
return $ret;
}
######################################################################################
# Streaming Device Typ: switched image
sub __switchedIMAGE { ## no critic 'not used'
my $params = shift;
my $camname = $params->{camname};
my $strmdev = $params->{strmdev};
my $hash = $defs{$camname};
my $streamHash = $defs{$strmdev};
my $ftui = $params->{ftui};
my $pws = $params->{pws};
my $ha = $params->{ha};
my $hau = $params->{hau};
my $cmdrecendless = $params->{cmdrecendless};
my $cmdrecstop = $params->{cmdrecstop};
my $cmddosnap = $params->{cmddosnap};
my $cmdstop = $params->{cmdstop};
my $imgrecendless = $params->{imgrecendless};
my $imgrecstop = $params->{imgrecstop};
my $imgdosnap = $params->{imgdosnap};
my $imgblank = $params->{imgblank};
my $imgstop = $params->{imgstop};
my $ttsnap = $params->{ttsnap};
my $ttrecstop = $params->{ttrecstop};
my $ttrecstart = $params->{ttrecstart};
my $ttcmdstop = $params->{ttcmdstop};
my ($link,$ret) = ("","");
$link = $hash->{HELPER}{LINK};
if(ReadingsVal($camname, "SVSversion", "8.2.3-5828") eq "8.2.3-5828" && ReadingsVal($camname, "CamVideoType", "") !~ /MJPEG/x) {
$ret .= " Because SVS version 8.2.3-5828 is running you cannot see the MJPEG-Stream. Please upgrade to a higher SVS version ! popupStream" speichern
$streamHash->{HELPER}{STREAMACTIVE} = 1; # Statusbit wenn ein Stream aktiviert ist
}
$ret .= "$imgstop ";
$ret .= $imgblank;
if($hash->{HELPER}{RUNVIEW} =~ /live_fw/x) {
if(ReadingsVal($camname, "Record", "Stop") eq "Stop") { # Aufnahmebutton endlos Start
$ret .= "$imgrecendless ";
} else { # Aufnahmebutton Stop
$ret .= "$imgrecstop ";
}
$ret .= "$imgdosnap ";
}
$ret .= " $ptz_ret ";
}
}
if($hash->{HELPER}{AUDIOLINK} && ReadingsVal($camname, "CamAudioType", "Unknown") !~ /Unknown/x && !$hau) {
$ret .= "";
$ret .= '';
$ret .= "{HELPER}{AUDIOLINK} preload='none' volume='0.5' controls>".
"Your browser does not support the audio element.".
" ";
$ret .= " popupStream" speichern
$streamHash->{HELPER}{STREAMACTIVE} = 1; # Statusbit wenn ein Stream aktiviert ist
$ret .= "$imgstop ";
$ret .= "$imgrefresh ";
$ret .= " ";
$ret .= '';
$ret .= "{HELPER}{AUDIOLINK} preload='none' volume='0.5' controls>".
"Your browser does not support the audio element.".
" ";
$ret .= "".
"".
"".
"".
"Your browser does not support the video tag".
" ".
"".
"".
"".
"Your browser does not support the video tag".
" "; # Stream für "set popupStream" speichern
$streamHash->{HELPER}{STREAMACTIVE} = 1; # Statusbit wenn ein Stream aktiviert ist
$ret .= "$imgstop ";
$ret .= " ";
$ret .= '';
$ret .= "{HELPER}{AUDIOLINK} preload='none' volume='0.5' controls>".
"Your browser does not support the audio element.".
" ";
$ret .= " popupStream" speichern
$streamHash->{HELPER}{STREAMACTIVE} = 1; # Statusbit wenn ein Stream aktiviert ist
$ret .= "$imgstop ";
$ret .= $imgblank;
$ret .= "$imgdosnap ";
$ret .= " ')\"> "; # Stream für "set popupStream" speichern
$streamHash->{HELPER}{STREAMACTIVE} = 1; # Statusbit wenn ein Stream aktiviert ist
return $ret;
}
######################################################################################
# Streaming Device Typ: switched hls
sub __switchedHLS { ## no critic 'not used'
my $params = shift;
my $camname = $params->{camname};
my $strmdev = $params->{strmdev};
my $hash = $defs{$camname};
my $streamHash = $defs{$strmdev};
my $ftui = $params->{ftui};
my $pws = $params->{pws};
my $ha = $params->{ha};
my $cmdrecendless = $params->{cmdrecendless};
my $cmdrecstop = $params->{cmdrecstop};
my $cmddosnap = $params->{cmddosnap};
my $cmdstop = $params->{cmdstop};
my $cmdrefresh = $params->{cmdrefresh};
my $cmdhlsreact = $params->{cmdhlsreact};
my $imgrecendless = $params->{imgrecendless};
my $imgrecstop = $params->{imgrecstop};
my $imgdosnap = $params->{imgdosnap};
my $imgblank = $params->{imgblank};
my $imgstop = $params->{imgstop};
my $imgrefresh = $params->{imgrefresh};
my $imghlsreact = $params->{imghlsreact};
my $ttsnap = $params->{ttsnap};
my $ttrecstop = $params->{ttrecstop};
my $ttrecstart = $params->{ttrecstart};
my $ttcmdstop = $params->{ttcmdstop};
my $ttrefresh = $params->{ttrefresh};
my $tthlsreact = $params->{tthlsreact};
my ($link,$ret) = ("","");
$link = $hash->{HELPER}{LINK};
$ret .= "".
"".
"".
"Your browser does not support the video tag".
" ".
"".
"".
"Your browser does not support the video tag".
" "; # Stream für "set popupStream" speichern
$streamHash->{HELPER}{STREAMACTIVE} = 1; # Statusbit wenn ein Stream aktiviert ist
$ret .= "$imgstop ";
$ret .= "$imgrefresh ";
$ret .= "$imghlsreact ";
$ret .= $imgblank;
if(ReadingsVal($camname, "Record", "Stop") eq "Stop") { # Aufnahmebutton endlos Start
$ret .= "$imgrecendless ";
} else { # Aufnahmebutton Stop
$ret .= "$imgrecstop ";
}
$ret .= "$imgdosnap ";
$ret .= " $ptz_ret ";
}
}
return $ret;
}
#############################################################################################
# hls.js laden für Streamimgdevice Typen HLS, RTSP
# $m3u8 - ein .m3u8-File oder ein entsprechender Link
# $d - ein Unique-Name zur Codeableitung (darf keinen . enthalten)
#############################################################################################
sub bindhlsjs {
my ($camname, $strmdev, $m3u8, $d) = @_;
my $hlsjs = "sscam_hls.js"; # hls.js Release von Projekteite https://github.com/video-dev/hls.js/releases
my ($ret,$uns);
$ret .= "$alias ";
}
}
my $cmddosnap = "FW_cmd('$FW_ME$FW_subdir?XHR=1&cmd=set $name snap 1 2 STRM:$uuid')"; # Snapshot auslösen mit Kennzeichnung "by STRM-Device"
my $imgdosnap = "CAUTION - No snapshots can be retrieved. Please set the attribute \"snapGalleryBoost=1\" in device $name " if ($lang eq "EN");
$sgbnote = "ACHTUNG - Es können keine Schnappschüsse abgerufen werden. Bitte setzen sie das Attribut \"snapGalleryBoost=1\" im Device $name " if ($lang eq "DE");
}
# Javascript Bibliothek für Tooltips (http://www.walterzorn.de/tooltip/tooltip.htm#download) und Texte
my $ttjs = "/fhem/pgm2/sscam_tooltip.js";
my $ttsnap = $ttips_en{"ttsnap"}; $ttsnap =~ s/§NAME§/$camname/xg;
if(AttrVal("global","language","EN") =~ /DE/x) {
$ttsnap = $ttips_de{"ttsnap"}; $ttsnap =~ s/§NAME§/$camname/xg;
}
# Header Generierung
my $header;
if($strmdev) { # Forum: https://forum.fhem.de/index.php/topic,45671.msg975610.html#msg975610
if($ftui) {
$header .= "$dlink $camname - newest Snapshot: $lss$camname - neueste Aufnahme: $lss $header
";
$htmlCode .= '
';
$htmlCode .= "";
$htmlCode .= "";
my $cell = 1;
my $idata = "";
$cache = cache($name, "c_init"); # Cache initialisieren
Log3($name, 1, "$name - Fall back to internal Cache due to preceding failure.") if(!$cache);
if(!$cache || $cache eq "internal" ) {
for my $key (sort{$a<=>$b}keys %{$data{SSCam}{$name}{SNAPHASH}}) {
if(!$ftui) {
$idata = "onClick=\"FW_okDialog('$data{SSCam}{$name}{SNAPHASH}{$key}{createdTm} " );
$htmlCode .= " ";
$htmlCode .= "";
$cell = 1;
} else {
$htmlCode .= sprintf("$data{SSCam}{$name}{SNAPHASH}{$key}{createdTm} " );
}
$idata = "";
}
} else {
my @as;
for my $ck (cache($name, "c_getkeys")) { # relevant keys aus allen vorkommenden selektieren
next if $ck !~ /\{SNAPHASH\}\{\d+\}\{.*\}/x;
$ck =~ s/\{SNAPHASH\}\{(\d+)\}\{.*\}/$1/x;
push @as,$ck if($ck =~ /^\d+$/x);
}
my %seen;
my @unique = sort{$a<=>$b} grep { !$seen{$_}++ } @as; # distinct / unique the keys
for my $key (@unique) {
$imgdat = cache($name, "c_read", "{SNAPHASH}{$key}{imageData}");
$imgTm = cache($name, "c_read", "{SNAPHASH}{$key}{createdTm}");
if(!$ftui) {
$idata = "onClick=\"FW_okDialog('$imgTm " );
$htmlCode .= " ";
$htmlCode .= "";
$cell = 1;
} else {
$htmlCode .= sprintf("$imgTm " );
}
$idata = "";
}
}
if ( $cell == 2 ) {
$htmlCode .= " ";
}
$htmlCode .= " ";
if(!$hb) {
$htmlCode .= "";
$htmlCode .= "";
$htmlCode .= "$imgdosnap " if($strmdev);
$htmlCode .= " ";
$htmlCode .= " ";
}
$htmlCode .= " ";
$htmlCode .= "
";
$htmlCode .= "
################################################################
sub sortVersion {
my ($sseq,@versions) = @_;
my @sorted = map {$_->[0]}
sort {$a->[1] cmp $b->[1]}
map {[$_, pack "C*", split /\./x]} @versions;
@sorted = map {join ".", unpack "C*", $_}
sort
map {pack "C*", split /\./x} @versions;
if($sseq eq "desc") {
@sorted = reverse @sorted;
}
return @sorted;
}
##############################################################################
# Zusätzliche Redings in Rotation erstellen
# Sub ($hash,,,,)
##############################################################################
sub rotateReading {
my ($hash,$readingName,$val,$rotnum,$do_trigger) = @_;
my $name = $hash->{NAME};
readingsBeginUpdate($hash);
my $o = ReadingsVal($name,$readingName,"n.a.");
if($val ne "n.a." && $rotnum >= 1) {
if("$o" ne "$val") {
for (my $i=$rotnum;$i>0;$i--) {
my $l = $i-1;
my $g = ReadingsVal($name,$readingName.$i,"n.a.");
if($l) {
$l = ReadingsVal($name,$readingName.$l,"n.a.");
} else {
$l = ReadingsVal($name,$readingName,"n.a.");
}
if("$l" ne "$g") {
readingsBulkUpdate($hash,$readingName.$i,$l);
Log3($name, 4, "$name - Rotate \"$readingName.$i\" to value: $l");
}
}
}
}
readingsBulkUpdate($hash,$readingName,$val);
readingsEndUpdate($hash, $do_trigger);
return;
}
#############################################################################################
# Vorbereitung SMTP EMail-Versand
# $OpMode = aktueller Operation Mode zur Unterscheidung was versendet werden soll
# $dat = zu versendende Daten, evtl. als Hash Referenz
#############################################################################################
sub prepareSendData {
my ($hash, $OpMode, $dat) = @_;
my $name = $hash->{NAME};
my $calias = AttrVal($name,"alias",$hash->{CAMNAME}); # Alias der Kamera wenn gesetzt oder Originalname aus SVS
my $type = AttrVal($name,"cacheType","internal");
my ($ret,$vdat,$fname,$snapid,$tac) = ('','','','','');
my @as;
# prüfen ob Schnappschnüsse aller Kameras durch ein SVS-Device angefordert wurde,
# Bilddaten jeder Kamera werden nach Erstellung dem zentralen Schnappshußhash hinzugefügt
# Bilddaten werden erst zum Versand weitergeleitet wenn Schnappshußhash komplett gefüllt ist
my $asref;
my @allsvs = devspec2array("TYPE=SSCam:FILTER=MODEL=SVS");
for (@allsvs) {
my $svshash;
$svshash = $defs{$_} if($defs{$_});
next if(!$svshash || !AttrVal($_, "snapEmailTxt", "") || !$svshash->{HELPER}{CANSENDSNAP}); # Sammel-Schnappschüsse nur senden wenn CANSENDSNAP und Attribut gesetzt ist
if($svshash->{HELPER}{ALLSNAPREF}) {
$asref = $svshash->{HELPER}{ALLSNAPREF}; # Hashreferenz zum summarischen Snaphash
for my $key (keys%{$asref}) {
if($key eq $name) { # Kamera Key im Bildhash matcht -> Bilddaten übernehmen
if($type eq "internal") {
for my $pkey (keys%{$dat}) {
my $nkey = time()+int(rand(1000));
$asref->{$nkey.$pkey}{createdTm} = $dat->{$pkey}{createdTm}; # Aufnahmezeit der Kamera werden im summarischen Snaphash eingefügt
$asref->{$nkey.$pkey}{imageData} = $dat->{$pkey}{imageData}; # Bilddaten der Kamera werden im summarischen Snaphash eingefügt
$asref->{$nkey.$pkey}{fileName} = $dat->{$pkey}{fileName}; # Filenamen der Kamera werden im summarischen Snaphash eingefügt
Log3($_, 4, "$_ - Central Snaphash filled up with snapdata of cam \"$name\" and key [".$nkey.$pkey."]");
}
} else {
# alle Serial Numbers "{$sn}" der Transaktion ermitteln
# Muster: {SENDSNAPS}{2222}{0}{imageData}
extractTIDfromCache ( { name => $name,
media => "SENDSNAPS",
mode => "serial",
aref => \@as
}
);
my %seen;
my @unique = sort{$a<=>$b} grep { !$seen{$_}++ } @as; # distinct / unique the keys
for my $pkey (@unique) {
next if(!cache($name, "c_isvalidkey", "$dat"."{$pkey}{imageData}"));
my $nkey = time()+int(rand(1000));
$asref->{$nkey.$pkey}{createdTm} = cache($name, "c_read", "$dat"."{$pkey}{createdTm}"); # Aufnahmezeit der Kamera werden im summarischen Snaphash eingefügt
$asref->{$nkey.$pkey}{imageData} = cache($name, "c_read", "$dat"."{$pkey}{imageData}"); # Bilddaten der Kamera werden im summarischen Snaphash eingefügt
$asref->{$nkey.$pkey}{fileName} = cache($name, "c_read", "$dat"."{$pkey}{fileName}"); # Filenamen der Kamera werden im summarischen Snaphash eingefügt
Log3($_, 4, "$_ - Central Snaphash filled up with snapdata of cam \"$name\" and key [".$nkey.$pkey."]");
}
}
delete $hash->{HELPER}{CANSENDSNAP}; # Flag im Kamera-Device !! löschen
delete $asref->{$key}; # ursprünglichen Key (Kameranamen) löschen
}
}
$asref = $svshash->{HELPER}{ALLSNAPREF}; # Hashreferenz zum summarischen Snaphash
for my $key (keys%{$asref}) { # prüfen ob Bildhash komplett ?
if(!$asref->{$key}) {
return; # Bildhash noch nicht komplett
}
}
delete $svshash->{HELPER}{ALLSNAPREF}; # ALLSNAPREF löschen -> gemeinsamer Versand beendet
$hash = $svshash; # Hash durch SVS-Hash ersetzt
$name = $svshash->{NAME}; # Name des auslösenden SVS-Devices wird eingesetzt
Log3($name, 4, "$name - Central Snaphash fillup completed by all selected cams. Send it now ...");
my $cache = cache($name, "c_init"); # Cache initialisieren (im SVS Device)
if(!$cache || $cache eq "internal" ) {
delete $data{SSCam}{RS};
for my $key (keys%{$asref}) { # Referenz zum summarischen Hash einsetzen
$data{SSCam}{RS}{$key} = delete $asref->{$key};
}
$dat = $data{SSCam}{RS}; # Referenz zum summarischen Hash einsetzen
} else {
cache($name, "c_clear");
for my $key (keys%{$asref}) {
cache($name, "c_write", "{RS}{multiple_snapsend}{$key}{createdTm}", delete $asref->{$key}{createdTm});
cache($name, "c_write", "{RS}{multiple_snapsend}{$key}{imageData}", delete $asref->{$key}{imageData});
cache($name, "c_write", "{RS}{multiple_snapsend}{$key}{fileName}", delete $asref->{$key}{fileName});
}
$dat = "{RS}{multiple_snapsend}"; # Referenz zum summarischen Hash einsetzen
}
$calias = AttrVal($name,"alias",$hash->{NAME}); # Alias des SVS-Devices
$hash->{HELPER}{TRANSACTION} = "multiple_snapsend"; # fake Transaction im SVS Device setzen
last; # Schleife verlassen und mit Senden weiter
}
}
my $sp = AttrVal($name, "smtpPort", 25);
my $nousessl = AttrVal($name, "smtpNoUseSSL", 0);
my ($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst) = localtime;
my $date = sprintf "%02d.%02d.%04d" , $mday , $mon+=1 ,$year+=1900;
my $time = sprintf "%02d:%02d:%02d" , $hour , $min , $sec;
my $sslfrominit = 0;
my $smtpsslport = 465;
if(AttrVal($name,"smtpSSLPort",0)) {
$sslfrominit = 1;
$smtpsslport = AttrVal($name,"smtpSSLPort",0);
}
$tac = $hash->{HELPER}{TRANSACTION}; # Code der laufenden Transaktion
$data{SSCam}{$name}{SENDCOUNT}{$tac} = 0; # Hilfszähler Senden, init -> +1 , done -> -1, keine Daten
# d. Transaktion werden gelöscht bis Zähler wieder 0 !! (siehe closeTrans)
Log3($name, 1, "$name - Send Counter transaction \"$tac\": ".$data{SSCam}{$name}{SENDCOUNT}{$tac}) if(AttrVal($name,"debugactivetoken",0));
### Schnappschüsse als Email versenden wenn $hash->{HELPER}{CANSENDSNAP} definiert ist
if($OpMode =~ /^getsnap/x && $hash->{HELPER}{CANSENDSNAP}) {
delete $hash->{HELPER}{CANSENDSNAP};
$data{SSCam}{$name}{SENDCOUNT}{$tac}++;
Log3($name, 1, "$name - Send Counter transaction \"$tac\": ".$data{SSCam}{$name}{SENDCOUNT}{$tac}) if(AttrVal($name,"debugactivetoken",0));
my $mt = delete $hash->{HELPER}{SMTPMSG};
$mt =~ s/['"]//xg;
my($subj,$body) = split(",", $mt, 2);
my($subjk,$subjt) = split("=>", $subj);
my($bodyk,$bodyt) = split("=>", $body);
$subjk = trim($subjk);
$subjt = trim($subjt);
$subjt =~ s/\$CAM/$calias/gx;
$subjt =~ s/\$DATE/$date/gx;
$subjt =~ s/\$TIME/$time/gx;
$bodyk = trim($bodyk);
$bodyt = trim($bodyt);
$bodyt =~ s/\$CAM/$calias/gx;
$bodyt =~ s/\$DATE/$date/gx;
$bodyt =~ s/\$TIME/$time/gx;
my %smtpmsg = ();
$smtpmsg{$subjk} = "$subjt";
$smtpmsg{$bodyk} = "$bodyt";
$ret = sendEmail($hash, {'subject' => $smtpmsg{subject},
'part1txt' => $smtpmsg{body},
'part2type' => 'image/jpeg',
'smtpport' => $sp,
'sdat' => $dat,
'opmode' => $OpMode,
'smtpnousessl' => $nousessl,
'sslfrominit' => $sslfrominit,
'smtpsslport' => $smtpsslport,
'tac' => $tac,
}
);
readingsSingleUpdate($hash, "sendEmailState", $ret, 1) if ($ret);
}
### Aufnahmen als Email versenden wenn $hash->{HELPER}{CANSENDREC} definiert ist
if($OpMode =~ /^GetRec/x && $hash->{HELPER}{CANSENDREC}) {
delete $hash->{HELPER}{CANSENDREC};
$data{SSCam}{$name}{SENDCOUNT}{$tac}++;
Log3($name, 1, "$name - Send Counter transaction \"$tac\": ".$data{SSCam}{$name}{SENDCOUNT}{$tac}) if(AttrVal($name,"debugactivetoken",0));
my $mt = delete $hash->{HELPER}{SMTPRECMSG};
$mt =~ s/['"]//gx;
my($subj,$body) = split(",", $mt, 2);
my($subjk,$subjt) = split("=>", $subj);
my($bodyk,$bodyt) = split("=>", $body);
$subjk = trim($subjk);
$subjt = trim($subjt);
$subjt =~ s/\$CAM/$calias/gx;
$subjt =~ s/\$DATE/$date/gx;
$subjt =~ s/\$TIME/$time/gx;
$bodyk = trim($bodyk);
$bodyt = trim($bodyt);
$bodyt =~ s/\$CAM/$calias/gx;
$bodyt =~ s/\$DATE/$date/gx;
$bodyt =~ s/\$TIME/$time/gx;
my %smtpmsg = ();
$smtpmsg{$subjk} = "$subjt";
$smtpmsg{$bodyk} = "$bodyt";
$ret = sendEmail($hash, {'subject' => $smtpmsg{subject},
'part1txt' => $smtpmsg{body},
'part2type' => 'video/mpeg',
'smtpport' => $sp,
'vdat' => $dat,
'opmode' => $OpMode,
'smtpnousessl' => $nousessl,
'sslfrominit' => $sslfrominit,
'smtpsslport' => $smtpsslport,
'tac' => $tac,
}
);
readingsSingleUpdate($hash, "sendEmailState", $ret, 1) if ($ret);
}
### Schnappschüsse mit Telegram versenden
if($OpMode =~ /^getsnap/x && $hash->{HELPER}{CANTELESNAP}) {
# snapTelegramTxt aus $hash->{HELPER}{TELEMSG}
# Format in $hash->{HELPER}{TELEMSG} muss sein: tbot => , peers => , subject =>
delete $hash->{HELPER}{CANTELESNAP};
$data{SSCam}{$name}{SENDCOUNT}{$tac}++;
Log3($name, 1, "$name - Send Counter transaction \"$tac\": ".$data{SSCam}{$name}{SENDCOUNT}{$tac}) if(AttrVal($name,"debugactivetoken",0));
my $mt = delete $hash->{HELPER}{TELEMSG};
$mt =~ s/['"]//gx;
my ($tbotk,$tbott,$peerk,$peert,$subjk,$subjt);
my ($telebot,$peers,$subj) = split(",", $mt, 3 );
($tbotk,$tbott) = split("=>", $telebot) if($telebot);
($peerk,$peert) = split("=>", $peers ) if($peers);
($subjk,$subjt) = split("=>", $subj ) if($subj);
$tbotk = trim($tbotk) if($tbotk);
$tbott = trim($tbott) if($tbott);
$peerk = trim($peerk) if($peerk);
$peert = trim($peert) if($peert);
$subjk = trim($subjk) if($subjk);
if($subjt) {
$subjt = trim($subjt);
$subjt =~ s/\$CAM/$calias/gx;
$subjt =~ s/\$DATE/$date/gx;
$subjt =~ s/\$TIME/$time/gx;
}
my %telemsg = ();
$telemsg{$tbotk} = "$tbott" if($tbott);
$telemsg{$peerk} = "$peert" if($peert);
$telemsg{$subjk} = "$subjt" if($subjt);
$ret = sendTelegram($hash, {'subject' => $telemsg{subject},
'part2type' => 'image/jpeg',
'sdat' => $dat,
'opmode' => $OpMode,
'tac' => $tac,
'telebot' => $telemsg{$tbotk},
'peers' => $telemsg{$peerk},
'MediaStream' => '-1', # Code für MediaStream im TelegramBot (png/jpg = -1)
}
);
readingsSingleUpdate($hash, "sendTeleState", $ret, 1) if ($ret);
}
### Aufnahmen mit Telegram versenden
if($OpMode =~ /^GetRec/x && $hash->{HELPER}{CANTELEREC}) {
# recTelegramTxt aus $hash->{HELPER}{TELERECMSG}
# Format in $hash->{HELPER}{TELEMSG} muss sein: tbot => , peers => , subject =>
delete $hash->{HELPER}{CANTELEREC};
$data{SSCam}{$name}{SENDCOUNT}{$tac}++;
Log3($name, 1, "$name - Send Counter transaction \"$tac\": ".$data{SSCam}{$name}{SENDCOUNT}{$tac}) if(AttrVal($name,"debugactivetoken",0));
my $mt = delete $hash->{HELPER}{TELERECMSG};
$mt =~ s/['"]//gx;
my ($tbotk,$tbott,$peerk,$peert,$subjk,$subjt);
my ($telebot,$peers,$subj) = split(",", $mt, 3 );
($tbotk,$tbott) = split("=>", $telebot) if($telebot);
($peerk,$peert) = split("=>", $peers ) if($peers);
($subjk,$subjt) = split("=>", $subj ) if($subj);
$tbotk = trim($tbotk) if($tbotk);
$tbott = trim($tbott) if($tbott);
$peerk = trim($peerk) if($peerk);
$peert = trim($peert) if($peert);
$subjk = trim($subjk) if($subjk);
if($subjt) {
$subjt = trim($subjt);
$subjt =~ s/\$CAM/$calias/gx;
$subjt =~ s/\$DATE/$date/gx;
$subjt =~ s/\$TIME/$time/gx;
}
my %telemsg = ();
$telemsg{$tbotk} = "$tbott" if($tbott);
$telemsg{$peerk} = "$peert" if($peert);
$telemsg{$subjk} = "$subjt" if($subjt);
$vdat = $dat;
$ret = sendTelegram($hash, {'subject' => $telemsg{subject},
'vdat' => $vdat,
'opmode' => $OpMode,
'telebot' => $telemsg{$tbotk},
'peers' => $telemsg{$peerk},
'tac' => $tac,
'MediaStream' => '-30', # Code für MediaStream im TelegramBot (png/jpg = -1)
}
);
readingsSingleUpdate($hash, "sendTeleState", $ret, 1) if ($ret);
}
### Schnappschüsse mit Synology Chat versenden
if($OpMode =~ /^getsnap/x && $hash->{HELPER}{CANCHATSNAP}) {
# snapChatTxt aus $hash->{HELPER}{CHATMSG}
# Format in $hash->{HELPER}{CHATMSG} muss sein: snapChatTxt:"chatbot => , peers => , subject => "
delete $hash->{HELPER}{CANCHATSNAP};
$data{SSCam}{$name}{SENDCOUNT}{$tac}++;
Log3($name, 1, "$name - Send Counter transaction \"$tac\": ".$data{SSCam}{$name}{SENDCOUNT}{$tac}) if(AttrVal($name,"debugactivetoken",0));
my $mt = delete $hash->{HELPER}{CHATMSG};
$mt =~ s/['"]//gx;
my ($cbotk,$cbott,$peerk,$peert,$subjk,$subjt);
my ($chatbot,$peers,$subj) = split(",", $mt, 3 );
($cbotk,$cbott) = split("=>", $chatbot) if($chatbot);
($peerk,$peert) = split("=>", $peers ) if($peers);
($subjk,$subjt) = split("=>", $subj ) if($subj);
$cbotk = trim($cbotk) if($cbotk);
$cbott = trim($cbott) if($cbott);
$peerk = trim($peerk) if($peerk);
$peert = trim($peert) if($peert);
$subjk = trim($subjk) if($subjk);
if($subjt) {
$subjt = trim($subjt);
$subjt =~ s/\$CAM/$calias/gx;
$subjt =~ s/\$DATE/$date/gx;
$subjt =~ s/\$TIME/$time/gx;
}
my %chatmsg = ();
$chatmsg{$cbotk} = "$cbott" if($cbott);
$chatmsg{$peerk} = "$peert" if($peert);
$chatmsg{$subjk} = "$subjt" if($subjt);
$ret = sendChat($hash, {'subject' => $chatmsg{subject},
'opmode' => $OpMode,
'tac' => $tac,
'sdat' => $dat,
'chatbot' => $chatmsg{$cbotk},
'peers' => $chatmsg{$peerk},
}
);
readingsSingleUpdate($hash, "sendChatState", $ret, 1) if ($ret);
}
### Aufnahmen mit Synology Chat versenden
if($OpMode =~ /^GetRec/x && $hash->{HELPER}{CANCHATREC}) {
# recChatTxt aus $hash->{HELPER}{CHATRECMSG}
# Format in $hash->{HELPER}{CHATRECMSG} muss sein: chatbot => , peers => , subject =>
delete $hash->{HELPER}{CANCHATREC};
$data{SSCam}{$name}{SENDCOUNT}{$tac}++;
Log3($name, 1, "$name - Send Counter transaction \"$tac\": ".$data{SSCam}{$name}{SENDCOUNT}{$tac}) if(AttrVal($name,"debugactivetoken",0));
my $mt = delete $hash->{HELPER}{CHATRECMSG};
$mt =~ s/['"]//gx;
my ($cbotk,$cbott,$peerk,$peert,$subjk,$subjt);
my ($chatbot,$peers,$subj) = split(",", $mt, 3 );
($cbotk,$cbott) = split("=>", $chatbot) if($chatbot);
($peerk,$peert) = split("=>", $peers ) if($peers);
($subjk,$subjt) = split("=>", $subj ) if($subj);
$cbotk = trim($cbotk) if($cbotk);
$cbott = trim($cbott) if($cbott);
$peerk = trim($peerk) if($peerk);
$peert = trim($peert) if($peert);
$subjk = trim($subjk) if($subjk);
if($subjt) {
$subjt = trim($subjt);
$subjt =~ s/\$CAM/$calias/gx;
$subjt =~ s/\$DATE/$date/gx;
$subjt =~ s/\$TIME/$time/gx;
}
my %chatmsg = ();
$chatmsg{$cbotk} = "$cbott" if($cbott);
$chatmsg{$peerk} = "$peert" if($peert);
$chatmsg{$subjk} = "$subjt" if($subjt);
$ret = sendChat($hash, {'subject' => $chatmsg{subject},
'opmode' => $OpMode,
'tac' => $tac,
'vdat' => $dat,
'chatbot' => $chatmsg{$cbotk},
'peers' => $chatmsg{$peerk},
}
);
readingsSingleUpdate($hash, "sendChatState", $ret, 1) if ($ret);
}
closeTrans($hash) if($hash->{HELPER}{TRANSACTION} eq "multiple_snapsend"); # Transaction Sammelversand (SVS) schließen, Daten bereinigen
return;
}
#############################################################################################
# Synology Chat-Versand
#############################################################################################
sub sendChat {
my ($hash, $extparamref) = @_;
my $name = $hash->{NAME};
my $type = AttrVal($name,"cacheType","internal");
my $mtype = "";
my ($params,$ret,$cache);
Log3($name, 4, "$name - ####################################################");
Log3($name, 4, "$name - ### start send Snap or Video by SSChatBot ");
Log3($name, 4, "$name - ####################################################");
my %chatparams = (
'subject' => { 'default'=>'', 'required'=>1, 'set'=>1},
'opmode' => { 'default'=>'', 'required'=>1, 'set'=>1}, # OpMode muss gesetzt sein
'tac' => { 'default'=>'', 'required'=>0, 'set'=>1}, # übermittelter Transaktionscode der ausgewerteten Transaktion
'sdat' => { 'default'=>'', 'required'=>0, 'set'=>1}, # Hashref der Bilddaten (Bilddaten base64 codiert)
'vdat' => { 'default'=>'', 'required'=>0, 'set'=>1}, # Hashref der Videodaten
'chatbot' => { 'default'=>'', 'required'=>1, 'set'=>1}, # SSChatBot-Device welches zum Senden verwendet werden soll
'peers' => { 'default'=>'', 'required'=>0, 'set'=>1}, # SSChatBot Peers
'videofolderMap' => {'attr'=>'videofolderMap', 'default'=>'', 'required'=>1, 'set'=>1}, # Wert des Attributs videofolderMap (muss gesetzt sein !)
);
my $tac = $extparamref->{tac};
for my $key (keys %chatparams) {
$data{SSCam}{$name}{PARAMS}{$tac}{$key} = AttrVal($name, $chatparams{$key}->{attr}, $chatparams{$key}->{default})
if(exists $chatparams{$key}->{attr});
if($chatparams{$key}->{set}) {
$data{SSCam}{$name}{PARAMS}{$tac}{$key} = $chatparams{$key}->{default} if (!$extparamref->{$key} && !$chatparams{$key}->{attr});
$data{SSCam}{$name}{PARAMS}{$tac}{$key} = delete $extparamref->{$key} if(exists $extparamref->{$key});
}
Log3($name, 4, "$name - param $key is set to \"".($data{SSCam}{$name}{PARAMS}{$tac}{$key} // "")."\" ") if($key !~ /[sv]dat/x);
Log3($name, 4, "$name - param $key is set") if($key =~ /[sv]dat/x && $data{SSCam}{$name}{PARAMS}{$tac}{$key} ne '');
}
$data{SSCam}{$name}{PARAMS}{$tac}{name} = $name;
my @err = ();
for my $key (keys(%chatparams)) {
push(@err, $key) if ($chatparams{$key}->{required} && !$data{SSCam}{$name}{PARAMS}{$tac}{$key});
}
if ($#err >= 0) {
$ret = "Missing at least one required parameter or attribute: ".join(', ',@err);
Log3($name, 2, "$name - $ret");
readingsBeginUpdate ($hash);
readingsBulkUpdate ($hash,"sendChatState",$ret);
readingsEndUpdate ($hash, 1);
$data{SSCam}{$name}{SENDCOUNT}{$tac} -= 1;
return $ret;
}
my $chatbot = $data{SSCam}{$name}{PARAMS}{$tac}{chatbot};
my $peers = $data{SSCam}{$name}{PARAMS}{$tac}{peers};
my $rootUrl = $data{SSCam}{$name}{PARAMS}{$tac}{videofolderMap};
if(!$defs{$chatbot}) {
$ret = "No SSChatBot device \"$chatbot\" available";
readingsSingleUpdate($hash, "sendChatState", $ret, 1);
Log3($name, 2, "$name - $ret");
$data{SSCam}{$name}{SENDCOUNT}{$tac} -= 1;
return;
}
if(!$peers) {
$peers = AttrVal($chatbot,"defaultPeer", "");
if(!$peers) {
$ret = "No peers of SSChatBot device \"$chatbot\" found";
readingsSingleUpdate($hash, "sendChatState", $ret, 1);
Log3($name, 2, "$name - $ret");
$data{SSCam}{$name}{SENDCOUNT}{$tac} -= 1;
return;
}
} else {
$peers = join(",", split(" ", $peers));
}
if(!$data{SSCam}{$name}{PARAMS}{$tac}{sdat} && !$data{SSCam}{$name}{PARAMS}{$tac}{vdat}) {
$ret = "no video or image data existing for send process by SSChatBot \"$chatbot\" ";
readingsSingleUpdate($hash, "sendChatState", $ret, 1);
Log3($name, 2, "$name - $ret");
$data{SSCam}{$name}{SENDCOUNT}{$tac} -= 1;
return;
}
#no strict "refs";
my ($subject,$fileUrl,$uid,$fname,@as,%seen,@unique);
$cache = cache($name, "c_init"); # Cache initialisieren
Log3($name, 1, "$name - Fall back to internal Cache due to preceding failure.") if(!$cache);
if(!$cache || $cache eq "internal" ) {
if($data{SSCam}{$name}{PARAMS}{$tac}{sdat}) { # Images liegen in einem Hash (Ref in $sdat) base64-codiert vor
@as = sort{$b<=>$a}keys%{$data{SSCam}{$name}{PARAMS}{$tac}{sdat}};
$mtype = "\@Snapshot";
} elsif($data{SSCam}{$name}{PARAMS}{$tac}{vdat}) { # Aufnahmen liegen in einem Hash-Ref in $vdat vor
@as = sort{$b<=>$a}keys%{$data{SSCam}{$name}{PARAMS}{$tac}{vdat}};
$mtype = $hash->{CAMNAME};
}
for my $key (@as) {
($subject,$fname) = extractForChat($name,$key,$data{SSCam}{$name}{PARAMS}{$tac});
# User aufsplitten und zu jedem die ID ermitteln
my @ua = split(",", $peers);
for (@ua) {
next if(!$_);
$uid = $defs{$chatbot}{HELPER}{USERS}{$_}{id};
if(!$uid) {
$ret = "The receptor \"$_\" seems to be unknown because its ID coulnd't be found.";
readingsSingleUpdate($hash, "sendChatState", $ret, 1);
Log3($name, 2, "$name - $ret");
$data{SSCam}{$name}{SENDCOUNT}{$tac} -= 1;
return;
}
# Eintrag zur SendQueue hinzufügen
# Werte: (name,opmode,method,userid,text,fileUrl,channel,attachment)
$fileUrl = $rootUrl."/".$mtype."/".$fname;
$subject = FHEM::SSChatBot::formString ($subject, "text");
$params = {
name => $chatbot,
opmode => "sendItem",
method => "chatbot",
userid => $uid,
text => $subject,
fileUrl => $fileUrl,
channel => "",
attachment => ""
};
$ret = FHEM::SSChatBot::addQueue ($params);
if($ret) {
readingsSingleUpdate($hash, "sendChatState", $ret, 1);
Log3($name, 2, "$name - ERROR: $ret");
} else {
$ret = "Chat message [$key] of transaction \"$tac\" for \"$_\" added to \"$chatbot\" sendqueue";
readingsSingleUpdate($hash, "sendChatState", $ret, 1);
Log3($name, 3, "$name - $ret");
}
}
}
$data{SSCam}{$name}{SENDCOUNT}{$tac} -= 1;
Log3($name, 1, "$name - Send Counter transaction \"$tac\": ".$data{SSCam}{$name}{SENDCOUNT}{$tac}) if(AttrVal($name,"debugactivetoken",0));
} else {
# alle Serial Numbers "{$sn}" der Transaktion ermitteln
if($data{SSCam}{$name}{PARAMS}{$tac}{sdat}) { # Images liegen in einem Hash (Ref in $sdat) base64-codiert vor
extractTIDfromCache ( { name => $name,
tac => $tac,
media => "SENDSNAPS",
mode => "serial",
aref => \@as
}
);
$mtype = "\@Snapshot";
} elsif($data{SSCam}{$name}{PARAMS}{$tac}{vdat}) { # Aufnahmen liegen in einem Hash-Ref in $vdat vor
extractTIDfromCache ( { name => $name,
tac => $tac,
media => "SENDRECS",
mode => "serial",
aref => \@as
}
);
$mtype = $hash->{CAMNAME};
}
@unique = sort{$b<=>$a} grep { !$seen{$_}++ } @as; # distinct / unique the keys
for my $key (@unique) {
($subject,$fname) = extractForChat($name,$key,$data{SSCam}{$name}{PARAMS}{$tac});
# User aufsplitten und zu jedem die ID ermitteln
my @ua = split(/,/x, $peers);
for (@ua) {
next if(!$_);
$uid = $defs{$chatbot}{HELPER}{USERS}{$_}{id};
if(!$uid) {
$ret = "The receptor \"$_\" seems to be unknown because its ID coulnd't be found.";
readingsSingleUpdate($hash, "sendChatState", $ret, 1);
Log3($name, 2, "$name - $ret");
$data{SSCam}{$name}{SENDCOUNT}{$tac} -= 1;
return;
}
# Eintrag zur SendQueue hinzufügen
# Werte: (name,opmode,method,userid,text,fileUrl,channel,attachment)
$fileUrl = $rootUrl."/".$mtype."/".$fname;
$subject = FHEM::SSChatBot::formString ($subject, "text");
$params = {
name => $chatbot,
opmode => "sendItem",
method => "chatbot",
userid => $uid,
text => $subject,
fileUrl => $fileUrl,
channel => "",
attachment => ""
};
$ret = FHEM::SSChatBot::addQueue ($params);
if($ret) {
readingsSingleUpdate($hash, "sendChatState", $ret, 1);
Log3($name, 2, "$name - ERROR: $ret");
} else {
$ret = "Chat message [$key] of transaction \"$tac\" for \"$_\" added to \"$chatbot\" sendqueue";
readingsSingleUpdate($hash, "sendChatState", $ret, 1);
Log3($name, 3, "$name - $ret");
}
}
}
$data{SSCam}{$name}{SENDCOUNT}{$tac} -= 1;
Log3($name, 1, "$name - Send Counter transaction \"$tac\": ".$data{SSCam}{$name}{SENDCOUNT}{$tac}) if(AttrVal($name,"debugactivetoken",0));
}
FHEM::SSChatBot::getApiSites ($chatbot); # Übertragung Sendqueue starten
# use strict "refs";
undef %chatparams;
undef %{$extparamref};
return;
}
####################################################################################################
# Daten extrahieren für SSChatBot Versand
####################################################################################################
sub extractForChat {
my ($name,$key,$paref) = @_;
my $hash = $defs{$name};
my $subject = $paref->{subject};
my $sdat = $paref->{sdat}; # Hash von Imagedaten base64 codiert
my $vdat = $paref->{vdat}; # Hashref der Videodaten
my ($fname,$tdir,$ct,$cache);
if($sdat) {
$cache = cache($name, "c_init"); # Cache initialisieren
if(!$cache || $cache eq "internal" ) {
$ct = delete $paref->{sdat}{$key}{createdTm};
$fname = trim(delete $paref->{sdat}{$key}{fileName});
} else {
$ct = cache($name, "c_read", "$sdat"."{$key}{createdTm}");
$fname = trim( cache($name, "c_read", "$sdat"."{$key}{fileName}") );
}
}
if($vdat) {
$cache = cache($name, "c_init"); # Cache initialisieren
if(!$cache || $cache eq "internal" ) {
$ct = delete $paref->{vdat}{$key}{createdTm};
$fname = trim(delete $paref->{vdat}{$key}{fileName});
$tdir = trim(delete $paref->{vdat}{$key}{tdir});
} else {
$ct = cache($name, "c_read", "$vdat"."{$key}{createdTm}");
$fname = trim( cache($name, "c_read", "$vdat"."{$key}{fileName}") );
$tdir = trim( cache($name, "c_read", "$vdat"."{$key}{tdir}") );
}
$fname = $tdir."/".$fname;
}
$subject =~ s/\$FILE/$fname/gx;
$subject =~ s/\$CTIME/$ct/gx;
return ($subject,$fname);
}
#############################################################################################
# Telegram-Versand
#############################################################################################
sub sendTelegram {
my ($hash, $extparamref) = @_;
my $name = $hash->{NAME};
my $type = AttrVal($name,"cacheType","internal");
my ($ret,$cache);
Log3($name, 4, "$name - ####################################################");
Log3($name, 4, "$name - ### start send Snap or Video by TelegramBot ");
Log3($name, 4, "$name - ####################################################");
my %teleparams = (
'subject' => { 'default'=>'', 'required'=>0, 'set'=>1},
'part1type' => { 'default'=>'text/plain; charset=UTF-8', 'required'=>1, 'set'=>1},
'part1txt' => { 'default'=>'', 'required'=>0, 'set'=>1},
'part2type' => { 'default'=>'', 'required'=>0, 'set'=>1},
'sdat' => { 'default'=>'', 'required'=>0, 'set'=>1}, # Hashref der Bilddaten (Bilddaten base64 codiert), wenn gesetzt muss 'part2type' auf 'image/jpeg' gesetzt sein
'image' => { 'default'=>'', 'required'=>0, 'set'=>1}, # Daten als File, wenn gesetzt muss 'part2type' auf 'image/jpeg' gesetzt sein
'fname' => { 'default'=>'', 'required'=>0, 'set'=>1}, # Filename für "image"
'lsnaptime' => { 'default'=>'', 'required'=>0, 'set'=>1}, # Zeitstempel der Bilddaten
'opmode' => { 'default'=>'', 'required'=>1, 'set'=>1}, # OpMode muss gesetzt sein
'tac' => { 'default'=>'', 'required'=>0, 'set'=>1}, # übermittelter Transaktionscode der ausgewerteten Transaktion
'vdat' => { 'default'=>'', 'required'=>0, 'set'=>1}, # Hashref der Videodaten
'telebot' => { 'default'=>'', 'required'=>1, 'set'=>1}, # TelegramBot-Device welches zum Senden verwendet werden soll
'peers' => { 'default'=>'', 'required'=>0, 'set'=>1}, # TelegramBot Peers
'MediaStream' => { 'default'=>'', 'required'=>0, 'set'=>1}, # Code für MediaStream im TelegramBot (png/jpg = -1)
);
my $tac = $extparamref->{tac};
for my $key (keys %teleparams) {
$data{SSCam}{$name}{PARAMS}{$tac}{$key} = AttrVal($name, $teleparams{$key}->{attr}, $teleparams{$key}->{default})
if(exists $teleparams{$key}->{attr});
if($teleparams{$key}->{set}) {
$data{SSCam}{$name}{PARAMS}{$tac}{$key} = $teleparams{$key}->{default} if (!$extparamref->{$key} && !$teleparams{$key}->{attr});
$data{SSCam}{$name}{PARAMS}{$tac}{$key} = delete $extparamref->{$key} if(exists $extparamref->{$key});
}
Log3($name, 4, "$name - param $key is set to \"".($data{SSCam}{$name}{PARAMS}{$tac}{$key} // "")."\" ") if($key !~ /[sv]dat/x);
Log3($name, 4, "$name - param $key is set") if($key =~ /[sv]dat/x && $data{SSCam}{$name}{PARAMS}{$tac}{$key} ne '');
}
$data{SSCam}{$name}{PARAMS}{$tac}{name} = $name;
my @err = ();
for my $key (keys(%teleparams)) {
push(@err, $key) if ($teleparams{$key}->{required} && !$data{SSCam}{$name}{PARAMS}{$tac}{$key});
}
if ($#err >= 0) {
$ret = "Missing at least one required parameter or attribute: ".join(', ',@err);
Log3($name, 2, "$name - $ret");
readingsBeginUpdate($hash);
readingsBulkUpdate($hash,"sendTeleState",$ret);
readingsEndUpdate($hash, 1);
$data{SSCam}{$name}{SENDCOUNT}{$tac} -= 1;
return $ret;
}
my $telebot = $data{SSCam}{$name}{PARAMS}{$tac}{telebot};
my $peers = $data{SSCam}{$name}{PARAMS}{$tac}{peers};
if(!$defs{$telebot}) {
$ret = "No TelegramBot device \"$telebot\" available";
readingsSingleUpdate($hash, "sendTeleState", $ret, 1);
Log3($name, 2, "$name - $ret");
$data{SSCam}{$name}{SENDCOUNT}{$tac} -= 1;
return;
}
if(!$peers) {
$peers = AttrVal($telebot,"defaultPeer", "");
if(!$peers) {
$ret = "No peers of TelegramBot device \"$telebot\" found";
readingsSingleUpdate($hash, "sendTeleState", $ret, 1);
Log3($name, 2, "$name - $ret");
$data{SSCam}{$name}{SENDCOUNT}{$tac} -= 1;
return;
}
}
if(!$data{SSCam}{$name}{PARAMS}{$tac}{sdat} && !$data{SSCam}{$name}{PARAMS}{$tac}{vdat}) {
$ret = "no video or image data existing for send process by TelegramBot \"$telebot\" ";
readingsSingleUpdate($hash, "sendTeleState", $ret, 1);
Log3($name, 2, "$name - $ret");
$data{SSCam}{$name}{SENDCOUNT}{$tac} -= 1;
return;
}
my ($msg,$subject,$MediaStream,$fname,@as,%seen,@unique);
$cache = cache($name, "c_init"); # Cache initialisieren
Log3($name, 1, "$name - Fall back to internal Cache due to preceding failure.") if(!$cache);
if(!$cache || $cache eq "internal" ) {
if($data{SSCam}{$name}{PARAMS}{$tac}{sdat}) { # Images liegen in einem Hash (Ref in $sdat) base64-codiert vor
@as = sort{$b<=>$a}keys%{$data{SSCam}{$name}{PARAMS}{$tac}{sdat}};
} elsif($data{SSCam}{$name}{PARAMS}{$tac}{vdat}) { # Aufnahmen liegen in einem Hash-Ref in $vdat vor
@as = sort{$b<=>$a}keys%{$data{SSCam}{$name}{PARAMS}{$tac}{vdat}};
}
for my $key (@as) {
($msg,$subject,$MediaStream,$fname) = extractForTelegram($name,$key,$data{SSCam}{$name}{PARAMS}{$tac});
$ret = TBotSendIt($defs{$telebot}, $name, $fname, $peers, $msg, $subject, $MediaStream, undef, "");
if($ret) {
readingsSingleUpdate($hash, "sendTeleState", $ret, 1);
Log3($name, 2, "$name - ERROR: $ret");
} else {
$ret = "Telegram message [$key] of transaction \"$tac\" sent to \"$peers\" by \"$telebot\" ";
readingsSingleUpdate($hash, "sendTeleState", $ret, 1);
Log3($name, 3, "$name - $ret");
}
}
$data{SSCam}{$name}{SENDCOUNT}{$tac} -= 1;
Log3($name, 1, "$name - Send Counter transaction \"$tac\": ".$data{SSCam}{$name}{SENDCOUNT}{$tac}) if(AttrVal($name,"debugactivetoken",0));
} else {
# alle Serial Numbers "{$sn}" der Transaktion ermitteln
if($data{SSCam}{$name}{PARAMS}{$tac}{sdat}) { # Images liegen in einem Hash (Ref in $sdat) base64-codiert vor
extractTIDfromCache ( { name => $name,
tac => $tac,
media => "SENDSNAPS",
mode => "serial",
aref => \@as
}
);
} elsif($data{SSCam}{$name}{PARAMS}{$tac}{vdat}) { # Aufnahmen liegen in einem Hash-Ref in $vdat vor
extractTIDfromCache ( { name => $name,
tac => $tac,
media => "SENDRECS",
mode => "serial",
aref => \@as
}
);
}
@unique = sort{$b<=>$a} grep { !$seen{$_}++ } @as; # distinct / unique the keys
for my $key (@unique) {
($msg,$subject,$MediaStream,$fname) = extractForTelegram($name,$key,$data{SSCam}{$name}{PARAMS}{$tac});
$ret = TBotSendIt($defs{$telebot}, $name, $fname, $peers, $msg, $subject, $MediaStream, undef, "");
if($ret) {
readingsSingleUpdate($hash, "sendTeleState", $ret, 1);
Log3($name, 2, "$name - ERROR: $ret");
} else {
$ret = "Telegram message [$key] of transaction \"$tac\" sent to \"$peers\" by \"$telebot\" ";
readingsSingleUpdate($hash, "sendTeleState", $ret, 1);
Log3($name, 3, "$name - $ret");
}
}
$data{SSCam}{$name}{SENDCOUNT}{$tac} -= 1;
Log3($name, 1, "$name - Send Counter transaction \"$tac\": ".$data{SSCam}{$name}{SENDCOUNT}{$tac}) if(AttrVal($name,"debugactivetoken",0));
}
undef %teleparams;
undef %{$extparamref};
undef $msg;
return;
}
####################################################################################################
# Bilddaten extrahieren für Telegram Versand
####################################################################################################
sub extractForTelegram {
my ($name,$key,$paref) = @_;
my $hash = $defs{$name};
my $subject = $paref->{subject};
my $MediaStream = $paref->{MediaStream};
my $sdat = $paref->{sdat}; # Hash von Imagedaten base64 codiert
my $vdat = $paref->{vdat}; # Hashref der Videodaten
my ($data,$fname,$ct,$img,$cache);
if($sdat) {
$cache = cache($name, "c_init"); # Cache initialisieren
if(!$cache || $cache eq "internal" ) {
$ct = delete $paref->{sdat}{$key}{createdTm};
$img = delete $paref->{sdat}{$key}{imageData};
$fname = trim(delete $paref->{sdat}{$key}{fileName});
$data = MIME::Base64::decode_base64($img);
Log3($name, 4, "$name - Image data sequence [$key] decoded from internal Cache for TelegramBot prepare");
undef $img;
} else {
$ct = cache($name, "c_read", "$sdat"."{$key}{createdTm}");
$img = cache($name, "c_read", "$sdat"."{$key}{imageData}");
$fname = trim( cache($name, "c_read", "$sdat"."{$key}{fileName}") );
$data = MIME::Base64::decode_base64($img);
Log3($name, 4, "$name - Image data sequence [$key] decoded from CHI-Cache for TelegramBot prepare");
}
}
if($vdat) {
$cache = cache($name, "c_init"); # Cache initialisieren
if(!$cache || $cache eq "internal" ) {
$ct = delete $paref->{vdat}{$key}{createdTm};
$data = delete $paref->{vdat}{$key}{imageData};
$fname = trim(delete $paref->{vdat}{$key}{fileName});
Log3($name, 4, "$name - Video data sequence [$key] got from internal Cache for TelegramBot prepare");
} else {
$ct = cache($name, "c_read", "$vdat"."{$key}{createdTm}");
$data = cache($name, "c_read", "$vdat"."{$key}{imageData}");
$fname = trim( cache($name, "c_read", "$vdat"."{$key}{fileName}") );
Log3($name, 4, "$name - Video data sequence [$key] got from CHI-Cache for TelegramBot prepare");
}
}
$subject =~ s/\$FILE/$fname/gx;
$subject =~ s/\$CTIME/$ct/gx;
return ($data,$subject,$MediaStream,$fname);
}
####################################################################################################
# Telegram Send Foto & Aufnahmen
# Adaption der Sub "SendIt" aus TelegramBot
# $hash = Hash des verwendeten TelegramBot-Devices !
# $isMedia = -1 wenn Foto, -30 wenn Aufnahme
####################################################################################################
sub TBotSendIt {
my ($hash, $camname, $fname, @args) = @_;
my ($peers, $msg, $addPar, $isMedia, $replyid, $options, $retryCount) = @args;
my $name = $hash->{NAME};
my $TBotHeader = "agent: TelegramBot/1.0\r\nUser-Agent: TelegramBot/1.0\r\nAccept: application/json\r\nAccept-Charset: utf-8";
my $TBotArgRetrycnt = 6;
$retryCount = 0 if (!defined($retryCount));
$options = "" if (!defined($options));
# increase retrycount for next try
$args[$TBotArgRetrycnt] = $retryCount+1;
Log3($camname, 5, "$camname - TBotSendIt: called ");
# ignore all sends if disabled
return if (AttrVal($name,"disable",0));
# ensure sentQueue exists
$hash->{sentQueue} = [] if (!defined($hash->{sentQueue}));
if ((defined( $hash->{sentMsgResult})) && ($hash->{sentMsgResult} =~ /^WAITING/x) && ($retryCount == 0) ){
# add to queue
Log3($camname, 4, "$camname - TBotSendIt: add send to queue :$peers: -:".
TelegramBot_MsgForLog($msg, ($isMedia<0)).": - :".(defined($addPar)?$addPar:"").":");
push(@{$hash->{sentQueue}}, \@args);
return;
}
my $ret;
$hash->{sentMsgResult} = "WAITING";
$hash->{sentMsgResult} .= " retry $retryCount" if ($retryCount>0);
$hash->{sentMsgId} = "";
my $peer;
($peer,$peers) = split(" ", $peers, 2);
# handle addtl peers specified (will be queued since WAITING is set already)
if (defined( $peers )) {
# remove msgid from options and also replyid reset
my $sepoptions = $options;
$sepoptions =~ s/-msgid-//x;
TBotSendIt($hash,$camname,$fname,$peers,$msg,$addPar,$isMedia,undef,$sepoptions);
}
Log3($camname, 5, "$camname - TBotSendIt: try to send message to :$peer: -:".
TelegramBot_MsgForLog($msg, ($isMedia<0) ).": - add :".(defined($addPar)?$addPar:"").
": - replyid :".(defined($replyid)?$replyid:"").
":".": options :".$options.":");
# trim and convert spaces in peer to underline
$peer = 0 if ( ! $peer );
my $peer2 = (!$peer)?$peer:TelegramBot_GetIdForPeer($hash, $peer);
if (!defined($peer2)) {
$ret = "FAILED peer not found :$peer:";
$peer2 = "";
}
$hash->{sentMsgPeer} = TelegramBot_GetFullnameForContact($hash,$peer2);
$hash->{sentMsgPeerId} = $peer2;
$hash->{sentMsgOptions} = $options;
# init param hash
$hash->{HU_DO_PARAMS}->{hash} = $hash;
$hash->{HU_DO_PARAMS}->{header} = $TBotHeader;
delete $hash->{HU_DO_PARAMS}{args};
delete $hash->{HU_DO_PARAMS}{boundary};
delete $hash->{HU_DO_PARAMS}{data};
my $timeout = AttrVal($name,'cmdTimeout',30);
$hash->{HU_DO_PARAMS}->{timeout} = $timeout;
$hash->{HU_DO_PARAMS}->{loglevel} = 4;
# Start Versand
if (!defined($ret)) {
# add chat / user id (no file) --> this will also do init
$ret = TBotAddMultipart($hash, $fname, $hash->{HU_DO_PARAMS}, "chat_id", undef, $peer2, 0 ) if ( $peer );
if (abs($isMedia) == 1) {
# Foto send
$hash->{sentMsgText} = "Image: ".TelegramBot_MsgForLog($msg,($isMedia<0)).((defined($addPar))?" - ".$addPar:"");
$hash->{HU_DO_PARAMS}->{url} = TelegramBot_getBaseURL($hash)."sendPhoto";
# add caption
if (defined($addPar)) {
$addPar =~ s/(?{HU_DO_PARAMS}, "caption", undef, $addPar, 0 ) if (!defined($ret));
$addPar = undef;
}
# add msg or file or stream
Log3($camname, 4, "$camname - TBotSendIt: Filename for image file :".
TelegramBot_MsgForLog($msg, ($isMedia<0) ).":");
$ret = TBotAddMultipart($hash, $fname, $hash->{HU_DO_PARAMS}, "photo", undef, $msg, $isMedia) if(!defined($ret));
} elsif ( abs($isMedia) == 30 ) {
# Video send
$hash->{sentMsgText} = "Image: ".TelegramBot_MsgForLog($msg,($isMedia<0)).((defined($addPar))?" - ".$addPar:"");
$hash->{HU_DO_PARAMS}->{url} = TelegramBot_getBaseURL($hash)."sendVideo";
# add caption
if (defined( $addPar) ) {
$addPar =~ s/(?{HU_DO_PARAMS}, "caption", undef, $addPar, 0) if(!defined($ret));
$addPar = undef;
}
# add msg or file or stream
Log3($camname, 4, "$camname - TBotSendIt: Filename for image file :".$fname.":");
$ret = TBotAddMultipart($hash, $fname, $hash->{HU_DO_PARAMS}, "video", undef, $msg, $isMedia) if(!defined($ret));
} else {
# nur Message senden
$msg = "No media File was created by SSCam. Can't send it.";
$hash->{HU_DO_PARAMS}->{url} = TelegramBot_getBaseURL($hash)."sendMessage";
my $parseMode = TelegramBot_AttrNum($name,"parseModeSend","0" );
if ($parseMode == 1) {
$parseMode = "Markdown";
} elsif ($parseMode == 2) {
$parseMode = "HTML";
} elsif ($parseMode == 3) {
$parseMode = 0;
if ($msg =~ /^markdown(.*)$/ix) {
$msg = $1;
$parseMode = "Markdown";
} elsif ($msg =~ /^HTML(.*)$/ix) {
$msg = $1;
$parseMode = "HTML";
}
} else {
$parseMode = 0;
}
Log3($camname, 4, "$camname - TBotSendIt: parseMode $parseMode");
if (length($msg) > 1000) {
$hash->{sentMsgText} = substr($msg, 0, 1000)."...";
} else {
$hash->{sentMsgText} = $msg;
}
$msg =~ s/(?{HU_DO_PARAMS}, "text", undef, $msg, 0) if(!defined($ret));
# add parseMode
$ret = TBotAddMultipart($hash, $fname, $hash->{HU_DO_PARAMS}, "parse_mode", undef, $parseMode, 0) if((!defined($ret)) && ($parseMode));
# add disable_web_page_preview
$ret = TBotAddMultipart($hash, $fname, $hash->{HU_DO_PARAMS}, "disable_web_page_preview", undef, \1, 0)
if ((!defined($ret))&&(!AttrVal($name,'webPagePreview',1)));
}
if (defined($replyid)) {
$ret = TBotAddMultipart($hash, $fname, $hash->{HU_DO_PARAMS}, "reply_to_message_id", undef, $replyid, 0) if(!defined($ret));
}
if (defined($addPar)) {
$ret = TBotAddMultipart($hash, $fname, $hash->{HU_DO_PARAMS}, "reply_markup", undef, $addPar, 0) if(!defined($ret));
} elsif ($options =~ /-force_reply-/x) {
$ret = TBotAddMultipart($hash, $fname, $hash->{HU_DO_PARAMS}, "reply_markup", undef, "{\"force_reply\":true}", 0 ) if(!defined($ret));
}
if ($options =~ /-silent-/x) {
$ret = TBotAddMultipart($hash, $fname, $hash->{HU_DO_PARAMS}, "disable_notification", undef, "true", 0) if(!defined($ret));
}
# finalize multipart
$ret = TBotAddMultipart($hash, $fname, $hash->{HU_DO_PARAMS}, undef, undef, undef, 0) if(!defined($ret));
}
if (defined($ret)) {
Log3($camname, 3, "$camname - TBotSendIt: Failed with :$ret:");
TelegramBot_Callback($hash->{HU_DO_PARAMS}, $ret, "");
} else {
$hash->{HU_DO_PARAMS}->{args} = \@args;
# if utf8 is set on string this will lead to length wrongly calculated in HTTPUtils (char instead of bytes) for some installations
if ((AttrVal($name,'utf8Special',0)) && (utf8::is_utf8($hash->{HU_DO_PARAMS}->{data}))) {
Log3 $camname, 4, "$camname - TBotSendIt: utf8 encoding for data in message ";
utf8::downgrade($hash->{HU_DO_PARAMS}->{data});
}
Log3($camname, 4, "$camname - TBotSendIt: timeout for sent :".$hash->{HU_DO_PARAMS}->{timeout}.": ");
HttpUtils_NonblockingGet($hash->{HU_DO_PARAMS});
}
undef $msg;
return $ret;
}
####################################################################################################
# Telegram Media zusammenstellen
# Adaption der Sub "AddMultipart" aus TelegramBot
#
# Parameter:
# $hash = Hash des verwendeten TelegramBot-Devices !
# params = (hash for building up the data)
# paramname --> if not sepecifed / undef - multipart will be finished
# header for multipart
# content
# isFile to specify if content is providing a file to be read as content
#
# returns string in case of error or undef
####################################################################################################
sub TBotAddMultipart {
my ($hash, $fname, $params, $parname, $parheader, $parcontent, $isMedia ) = @_;
my $name = $hash->{NAME};
my $ret;
# Check if boundary is defined
if ( ! defined( $params->{boundary} ) ) {
$params->{boundary} = "TelegramBot_boundary-x0123";
$params->{header} .= "\r\nContent-Type: multipart/form-data; boundary=".$params->{boundary};
$params->{method} = "POST";
$params->{data} = "";
}
# ensure parheader is defined and add final header new lines
$parheader = "" if (!defined($parheader));
$parheader .= "\r\n" if ((length($parheader) > 0) && ($parheader !~ /\r\n$/x));
# add content
my $finalcontent;
if (defined($parname)) {
$params->{data} .= "--".$params->{boundary}."\r\n";
if ($isMedia > 0) {
# url decode filename
$parcontent = uri_unescape($parcontent) if(AttrVal($name,'filenameUrlEscape',0));
my $baseFilename = basename($parcontent);
$parheader = "Content-Disposition: form-data; name=\"".$parname."\"; filename=\"".$baseFilename."\"\r\n".$parheader."\r\n";
return("FAILED file :$parcontent: not found or empty" ) if(! -e $parcontent) ;
my $size = -s $parcontent;
my $limit = AttrVal($name,'maxFileSize',10485760);
return("FAILED file :$parcontent: is too large for transfer (current limit: ".$limit."B)") if($size > $limit) ;
$finalcontent = TelegramBot_BinaryFileRead($hash, $parcontent);
if ($finalcontent eq "") {
return("FAILED file :$parcontent: not found or empty");
}
} elsif ($isMedia < 0) {
my ($im, $ext) = TBotIdentifyStream($hash, $parcontent);
$fname =~ s/.mp4$/.$ext/x;
$parheader = "Content-Disposition: form-data; name=\"".$parname."\"; filename=\"".$fname."\"\r\n".$parheader."\r\n";
$finalcontent = $parcontent;
} else {
$parheader = "Content-Disposition: form-data; name=\"".$parname."\"\r\n".$parheader."\r\n";
$finalcontent = $parcontent;
}
$params->{data} .= $parheader.$finalcontent."\r\n";
} else {
return( "No content defined for multipart" ) if ( length( $params->{data} ) == 0 );
$params->{data} .= "--".$params->{boundary}."--";
}
return;
}
####################################################################################################
# Telegram Media Identifikation
# Adaption der Sub "IdentifyStream" aus TelegramBot
# $hash = Hash des verwendeten TelegramBot-Devices !
####################################################################################################
sub TBotIdentifyStream {
my ($hash, $msg) = @_;
# signatures for media files are documented here --> https://en.wikipedia.org/wiki/List_of_file_signatures
# seems sometimes more correct: https://wangrui.wordpress.com/2007/06/19/file-signatures-table/
# Video Signatur aus: https://www.garykessler.net/library/file_sigs.html
return (-1,"png") if ( $msg =~ /^\x89PNG\r\n\x1a\n/x ); # PNG
return (-1,"jpg") if ( $msg =~ /^\xFF\xD8\xFF/x ); # JPG not necessarily complete, but should be fine here
return (-30,"mpg") if ( $msg =~ /^....\x66\x74\x79\x70\x69\x73\x6f\x6d/x ); # mp4
return (0,undef);
}
#############################################################################################
# SMTP EMail-Versand
#############################################################################################
sub sendEmail {
my ($hash, $extparamref) = @_;
my $name = $hash->{NAME};
my $timeout = 60;
my $ret;
Log3($name, 4, "$name - ####################################################");
Log3($name, 4, "$name - ### start send snapshot or recording by email ");
Log3($name, 4, "$name - ####################################################");
my $m1 = "Net::SMTP";
my $m2 = "MIME::Lite";
my $m3 = "Net::SMTP::SSL";
my $sslfb = 0; # Flag für Verwendung altes Net::SMTP::SSL
my ($vm1,$vm2,$vm3);
eval { require Net::SMTP; ## no critic 'eval not tested'
Net::SMTP->import;
$vm1 = $Net::SMTP::VERSION;
# Version von Net::SMTP prüfen, wenn < 3.00 dann Net::SMTP::SSL verwenden
# (libnet-3.06 hat SSL inkludiert)
my $sv = $vm1;
$sv =~ s/[^0-9.].*$//x;
if($sv < 3.00) {
require Net::SMTP::SSL;
Net::SMTP::SSL->import;
$vm3 = $Net::SMTP::SSL::VERSION;
$sslfb = 1;
}
require MIME::Lite;
MIME::Lite->import;
$vm2 = $MIME::Lite::VERSION;
};
if(!$vm1 || !$vm2 || ($sslfb && !$vm3)) {
my $nl = !$vm2?$m2." ":"";
$nl .= !$vm1?$m1." ":"";
$nl .= ($sslfb && !$vm3)?$m3:"";
$ret = "required module for sending Email couldn't be loaded. You have to install: $nl";
Log3($name, 1, "$name - $ret");
readingsBeginUpdate($hash);
readingsBulkUpdate ($hash,"sendEmailState",$ret);
readingsEndUpdate ($hash, 1);
return $ret;
}
Log3($name, 4, "$name - version of loaded module \"$m1\" is \"$vm1\"");
Log3($name, 4, "$name - version of \"$m1\" is too old. Use SSL-fallback module \"$m3\" with version \"$vm3\"") if($sslfb && $vm3);
Log3($name, 4, "$name - version of loaded module \"$m2\" is \"$vm2\"");
my %mailparams = (
'smtpFrom' => {'attr'=>'smtpFrom', 'default'=>'', 'required'=>1, 'set'=>1},
'smtpTo' => {'attr'=>'smtpTo', 'default'=>'', 'required'=>1, 'set'=>1},
'subject' => {'attr'=>'subject', 'default'=>'', 'required'=>1, 'set'=>1},
'smtpCc' => {'attr'=>'smtpCc', 'default'=>'', 'required'=>0, 'set'=>1},
'part1type' => { 'default'=>'text/plain; charset=UTF-8', 'required'=>1, 'set'=>1},
'part1txt' => { 'default'=>'', 'required'=>0, 'set'=>1},
'part2type' => { 'default'=>'', 'required'=>0, 'set'=>1},
'smtphost' => {'attr'=>'smtpHost', 'default'=>'', 'required'=>1, 'set'=>0},
'smtpport' => {'attr'=>'smtpPort', 'default'=>'25', 'required'=>1, 'set'=>0},
'smtpsslport' => {'attr'=>'smtpSSLPort', 'default'=>'', 'required'=>0, 'set'=>1}, # SSL-Port, verwendet bei direktem SSL-Aufbau
'smtpnousessl' => {'attr'=>'smtpNoUseSSL','default'=>'0', 'required'=>0, 'set'=>1},
'smtpdebug' => {'attr'=>'smtpDebug', 'default'=>'0', 'required'=>0, 'set'=>0},
'sdat' => { 'default'=>'', 'required'=>0, 'set'=>1}, # Hashref der Bilddaten (Bilddaten base64 codiert), wenn gesetzt muss 'part2type' auf 'image/jpeg' gesetzt sein
'image' => { 'default'=>'', 'required'=>0, 'set'=>1}, # Daten als File, wenn gesetzt muss 'part2type' auf 'image/jpeg' gesetzt sein
'fname' => { 'default'=>'image.jpg', 'required'=>0, 'set'=>1}, # Filename für "image"
'lsnaptime' => { 'default'=>'', 'required'=>0, 'set'=>1}, # Zeitstempel der Bilddaten
'opmode' => { 'default'=>'', 'required'=>1, 'set'=>1}, # OpMode muss gesetzt sein
'sslfb' => { 'default'=>$sslfb, 'required'=>0, 'set'=>1}, # Flag für Verwendung altes Net::SMTP::SSL
'sslfrominit' => { 'default'=>'', 'required'=>0, 'set'=>1}, # SSL soll sofort ! aufgebaut werden
'tac' => { 'default'=>'', 'required'=>0, 'set'=>1}, # übermittelter Transaktionscode der ausgewerteten Transaktion
'vdat' => { 'default'=>'', 'required'=>0, 'set'=>1}, # Videodaten, wenn gesetzt muss 'part2type' auf 'video/mpeg' gesetzt sein
);
my $tac = $extparamref->{tac};
for my $key (keys %mailparams) {
$data{SSCam}{$name}{PARAMS}{$tac}{$key} = AttrVal($name, $mailparams{$key}->{attr}, $mailparams{$key}->{default})
if(exists $mailparams{$key}->{attr});
if($mailparams{$key}->{set}) {
$data{SSCam}{$name}{PARAMS}{$tac}{$key} = $mailparams{$key}->{default} if (!$extparamref->{$key} && !$mailparams{$key}->{attr});
$data{SSCam}{$name}{PARAMS}{$tac}{$key} = delete $extparamref->{$key} if (exists $extparamref->{$key});
}
Log3($name, 4, "$name - param $key is now \"".$data{SSCam}{$name}{PARAMS}{$tac}{$key}."\" ") if($key !~ /sdat/x);
Log3($name, 4, "$name - param $key is set") if($key =~ /sdat/x && $data{SSCam}{$name}{PARAMS}{$tac}{$key} ne '');
}
$data{SSCam}{$name}{PARAMS}{$tac}{name} = $name;
my @err = ();
for my $key (keys(%mailparams)) {
push(@err, $key) if ($mailparams{$key}->{required} && !$data{SSCam}{$name}{PARAMS}{$tac}{$key});
}
if ($#err >= 0) {
$ret = "Missing at least one required parameter or attribute: ".join(', ',@err);
Log3($name, 2, "$name - $ret");
readingsBeginUpdate($hash);
readingsBulkUpdate ($hash,"sendEmailState",$ret);
readingsEndUpdate ($hash, 1);
return $ret;
}
$hash->{HELPER}{RUNNING_PID} = BlockingCall("FHEM::SSCam::sendEmailblocking", $data{SSCam}{$name}{PARAMS}{$tac}, "FHEM::SSCam::sendEmaildone", $timeout, "FHEM::SSCam::sendEmailto", $hash);
$hash->{HELPER}{RUNNING_PID}{loglevel} = 5 if($hash->{HELPER}{RUNNING_PID}); # Forum #77057
undef %mailparams;
undef %$extparamref;
return;
}
####################################################################################################
# nichtblockierendes Send EMail
####################################################################################################
sub sendEmailblocking {
my ($paref) = @_; # der Referent wird in cleanData gelöscht
my $name = delete $paref->{name};
my $cc = delete $paref->{smtpCc};
my $from = delete $paref->{smtpFrom};
my $part1type = delete $paref->{part1type};
my $part1txt = delete $paref->{part1txt};
my $part2type = delete $paref->{part2type};
my $smtphost = delete $paref->{smtphost};
my $smtpport = delete $paref->{smtpport};
my $smtpsslport = delete $paref->{smtpsslport};
my $smtpnousessl = delete $paref->{smtpnousessl}; # SSL Verschlüsselung soll NICHT genutzt werden
my $subject = delete $paref->{subject};
my $to = delete $paref->{smtpTo};
my $msgtext = delete $paref->{msgtext};
my $smtpdebug = delete $paref->{smtpdebug};
my $sdat = delete $paref->{sdat}; # Hash von Imagedaten base64 codiert
my $image = delete $paref->{image}; # Image, wenn gesetzt muss 'part2type' auf 'image/jpeg' gesetzt sein
my $fname = delete $paref->{fname}; # Filename -> verwendet wenn $image ist gesetzt
my $lsnaptime = delete $paref->{lsnaptime}; # Zeit des letzten Schnappschusses wenn gesetzt
my $opmode = delete $paref->{opmode}; # aktueller Operation Mode
my $sslfb = delete $paref->{sslfb}; # Flag für Verwendung altes Net::SMTP::SSL
my $sslfrominit = delete $paref->{sslfrominit}; # SSL soll sofort ! aufgebaut werden
my $tac = delete $paref->{tac}; # übermittelter Transaktionscode der ausgewerteten Transaktion
my $vdat = delete $paref->{vdat}; # Videodaten, wenn gesetzt muss 'part2type' auf 'video/mpeg' gesetzt sein
my $hash = $defs{$name};
my $sslver = "";
my ($err,$smtp,@as,$cache);
# Credentials abrufen
my ($success, $username, $password) = getCredentials($hash,0,"smtp");
unless ($success) {
$err = "SMTP credentials couldn't be retrieved successfully - make sure you've set it with \"set $name smtpcredentials \"";
Log3($name, 2, "$name - $err");
$err = encode_base64($err,"");
return "$name|$err|''";
}
$subject = decode_utf8($subject);
my $mailmsg = MIME::Lite->new(
From => $from,
To => $to,
Subject => $subject,
Type => 'multipart/mixed', #'multipart/mixed', # was 'text/plain'
);
### Add the text message part:
### (Note that "attach" has same arguments as "new"):
$part1txt = decode_utf8($part1txt);
$mailmsg->attach(
Type => $part1type,
Data => $part1txt,
);
### Add image, Das Image liegt bereits als File vor
if($image) {
$mailmsg->attach(
Type => $part2type,
Path => $image,
Filename => $fname,
Disposition => 'attachment',
);
}
# no strict "refs";
if($sdat) {
### Images liegen in einem Hash (Ref in $sdat) base64-codiert vor
my ($ct,$img,$decoded);
$cache = cache($name, "c_init"); # Cache initialisieren
if(!$cache || $cache eq "internal" ) {
@as = sort{$a<=>$b}keys%{$sdat};
for my $key (@as) {
$ct = delete $sdat->{$key}{createdTm};
$img = delete $sdat->{$key}{imageData};
$fname = delete $sdat->{$key}{fileName};
$decoded = MIME::Base64::decode_base64($img);
$mailmsg->attach(
Type => $part2type,
Data => $decoded,
Filename => $fname,
Disposition => 'attachment',
);
Log3($name, 4, "$name - Image data sequence [$key] decoded from internal Cache for Email attachment") if($decoded);
}
BlockingInformParent("FHEM::SSCam::subaddFromBlocking", [$name, "-", $tac], 0);
} else {
# alle Serial Numbers "{$sn}" der Transaktion ermitteln
extractTIDfromCache ( { name => $name,
tac => $tac,
media => "SENDSNAPS|RS",
mode => "serial",
aref => \@as
}
);
my %seen;
my @unique = sort{$a<=>$b} grep { !$seen{$_}++ } @as; # distinct / unique the keys
# attach mail
for my $key (@unique) {
next if(!cache($name, "c_isvalidkey", "$sdat"."{$key}{imageData}"));
$ct = cache($name, "c_read", "$sdat"."{$key}{createdTm}");
$img = cache($name, "c_read", "$sdat"."{$key}{imageData}");
$fname = cache($name, "c_read", "$sdat"."{$key}{fileName}");
$decoded = MIME::Base64::decode_base64($img);
$mailmsg->attach(
Type => $part2type,
Data => $decoded,
Filename => $fname,
Disposition => 'attachment',
);
Log3($name, 4, "$name - Image data sequence [$key] decoded from CHI-Cache for Email attachment");
}
BlockingInformParent("FHEM::SSCam::subaddFromBlocking", [$name, "-", $tac], 0);
}
}
if($vdat) {
### Videodaten (mp4) wurden geliefert
my ($ct,$video);
$cache = cache($name, "c_init"); # Cache initialisieren
if(!$cache || $cache eq "internal" ) {
@as = sort{$a<=>$b}keys%{$vdat};
for my $key (@as) {
$ct = delete $vdat->{$key}{createdTm};
$video = delete $vdat->{$key}{imageData};
$fname = delete $vdat->{$key}{fileName};
$mailmsg->attach(
Type => $part2type,
Data => $video,
Filename => $fname,
Disposition => 'attachment',
);
Log3($name, 4, "$name - Video data sequence [$key] decoded from internal Cache for Email attachment");
}
BlockingInformParent("FHEM::SSCam::subaddFromBlocking", [$name, "-", $tac], 0);
} else {
# alle Serial Numbers "{$sn}" der Transaktion ermitteln
extractTIDfromCache ( { name => $name,
tac => $tac,
media => "SENDRECS",
mode => "serial",
aref => \@as
}
);
my %seen;
my @unique = sort{$a<=>$b} grep { !$seen{$_}++ } @as; # distinct / unique the keys
# attach mail
for my $key (@unique) {
next if(!cache($name, "c_isvalidkey", "$vdat"."{$key}{imageData}"));
$ct = cache($name, "c_read", "$vdat"."{$key}{createdTm}");
$video = cache($name, "c_read", "$vdat"."{$key}{imageData}");
$fname = cache($name, "c_read", "$vdat"."{$key}{fileName}");
$mailmsg->attach(
Type => $part2type,
Data => $video,
Filename => $fname,
Disposition => 'attachment',
);
Log3($name, 4, "$name - Video data sequence [$key] decoded from CHI-Cache for Email attachment");
}
BlockingInformParent("FHEM::SSCam::subaddFromBlocking", [$name, "-", $tac], 0);
}
}
$mailmsg->attr('content-type.charset' => 'UTF-8');
##### SMTP-Connection #####
# login to SMTP Host
if($sslfb) {
# Verwendung altes Net::SMTP::SSL <= 3.00 -> immer direkter SSL-Aufbau, Attribut "smtpNoUseSSL" wird ignoriert
Log3($name, 3, "$name - Attribute \"smtpNoUseSSL\" will be ignored due to usage of Net::SMTP::SSL") if(AttrVal($name,"smtpNoUseSSL",0));
$smtp = Net::SMTP::SSL->new(Host => $smtphost, Port => $smtpsslport, Debug => $smtpdebug);
} else {
# Verwendung neues Net::SMTP::SSL > 3.00
if($sslfrominit) {
# sofortiger SSL connect
$smtp = Net::SMTP->new(Host => $smtphost, Port => $smtpsslport, SSL => 1, Debug => $smtpdebug);
} else {
# erst unverschlüsselt, danach switch zu encrypted
$smtp = Net::SMTP->new(Host => $smtphost, Port => $smtpport, SSL => 0, Debug => $smtpdebug);
}
}
if(!$smtp) {
$err = "SMTP Error: Can't connect to host $smtphost";
Log3($name, 2, "$name - $err");
$err = encode_base64($err,"");
return "$name|$err|''";
}
if(!$sslfb && !$sslfrominit) {
# Aufbau unverschlüsselt -> switch zu verschlüsselt wenn nicht untersagt
if($smtp->can_ssl() && !$smtpnousessl) {
unless( $smtp->starttls ( SSL_verify_mode => 0,
SSL_version => "TLSv1_2:!TLSv1_1:!SSLv3:!SSLv23:!SSLv2",
) ) {
$err = "SMTP Error while switch to SSL: ".$smtp->message();
Log3($name, 2, "$name - $err");
$err = encode_base64($err,"");
return "$name|$err|''";
}
$sslver = $smtp->get_sslversion();
Log3($name, 3, "$name - SMTP-Host $smtphost switched to encrypted connection with SSL version: $sslver");
} else {
Log3($name, 3, "$name - SMTP-Host $smtphost use unencrypted connection !");
}
} else {
eval { $sslver = $smtp->get_sslversion(); }; ## no critic 'eval not tested' # Forum: https://forum.fhem.de/index.php/topic,45671.msg880602.html#msg880602
$sslver = $sslver ? $sslver : "n.a.";
Log3($name, 3, "$name - SMTP-Host $smtphost use immediately encrypted connection with SSL version: $sslver");
}
unless( $smtp->auth($username, $password) ) {
$err = "SMTP Error authentication: ".$smtp->message();
Log3($name, 2, "$name - $err");
$err = encode_base64($err,"");
return "$name|$err|''";
}
unless( $smtp->mail($from) ) {
$err = "SMTP Error setting sender: ".$smtp->message();
Log3($name, 2, "$name - $err");
$err = encode_base64($err,"");
return "$name|$err|''";
}
my @r = split(",", $to);
unless( $smtp->to(@r) ) {
$err = "SMTP Error setting receiver: ".$smtp->message();
Log3($name, 2, "$name - $err");
$err = encode_base64($err,"");
return "$name|$err|''";
}
if ($cc) {
my @c = split(",", $cc);
unless( $smtp->cc(@c) ) {
$err = "SMTP Error setting carbon-copy $cc: ".$smtp->message();
Log3($name, 2, "$name - $err");
$err = encode_base64($err,"");
return "$name|$err|''";
}
}
unless( $smtp->data() ) {
$err = "SMTP Error setting data: ".$smtp->message();
Log3($name, 2, "$name - $err");
$err = encode_base64($err,"");
return "$name|$err|''";
}
unless( $smtp->datasend(encode('utf8',$mailmsg->as_string)) ) {
$err = "SMTP Error sending email: ".$smtp->message();
Log3($name, 2, "$name - $err");
$err = encode_base64($err,"");
return "$name|$err|''";
}
unless( $smtp->dataend() ) {
$err = "SMTP Error ending transaction: ".$smtp->message();
Log3($name, 2, "$name - $err");
$err = encode_base64($err,"");
return "$name|$err|''";
}
unless( $smtp->quit() ) {
$err = "SMTP Error saying good-bye: ".$smtp->message();
Log3($name, 2, "$name - $err");
$err = encode_base64($err,"");
return "$name|$err|''";
}
my $ret = "Email transaction \"$tac\" successfully sent ".( $sslver?"encoded by $sslver":"" );
Log3($name, 3, "$name - $ret To: $to".(($cc)?", CC: $cc":"") );
# use strict "refs";
# Daten müssen als Einzeiler zurückgegeben werden
$ret = encode_base64($ret,"");
return "$name|''|$ret";
}
####################################################################################################
# Auswertungsroutine nichtblockierendes Send EMail
####################################################################################################
sub sendEmaildone {
my ($string) = @_;
my @a = split("\\|",$string);
my $hash = $defs{$a[0]};
my $err = $a[1]?decode_base64($a[1]):undef;
my $ret = $a[2]?decode_base64($a[2]):undef;
if ($err) {
readingsBeginUpdate($hash);
readingsBulkUpdate($hash,"sendEmailState",$err);
readingsEndUpdate($hash, 1);
delete($hash->{HELPER}{RUNNING_PID});
return;
}
readingsBeginUpdate($hash);
readingsBulkUpdate ($hash,"sendEmailState",$ret);
readingsEndUpdate ($hash, 1);
delete($hash->{HELPER}{RUNNING_PID});
return;
}
####################################################################################################
# Abbruchroutine Send EMail
####################################################################################################
sub sendEmailto {
my ($hash,$cause) = @_;
my $name = $hash->{NAME};
$cause = $cause // "Timeout: process terminated";
Log3 ($name, 1, "$name -> BlockingCall $hash->{HELPER}{RUNNING_PID}{fn} pid:$hash->{HELPER}{RUNNING_PID}{pid} $cause");
readingsBeginUpdate ($hash);
readingsBulkUpdateIfChanged ($hash,"sendEmailState",$cause);
readingsEndUpdate ($hash, 1);
delete($hash->{HELPER}{RUNNING_PID});
return;
}
#################################################################################################
# Modi:
# 1. serial - extrahiere Serial Nummer (der Medien) aus Cache für Versand
# Schnappschüsse / Ausfnahmen + optionalen Vergleich mit laufender Transaktion
# 2. readkeys - liest alle Schlüssel aus gegebenen Cache aus
#
# Muster Schnappschüsse: {SENDSNAPS}{2222}{0}{imageData}
# Muster Aufnahmen: {SENDRECS}{305}{0}{imageData}
# Muster multiple: {SENDSNAPS|RS}{2222|multiple_snapsend}{0|1572995404.125580}{imageData}
#################################################################################################
sub extractTIDfromCache {
my $params = shift;
my $name = $params->{name};
my $tac = $params->{tac};
my $media = $params->{media};
my $mode = $params->{mode};
my $aref = $params->{aref};
if($mode eq "serial") { # Serial Nummern auslesen
for my $ck (cache($name, "c_getkeys")) {
next if $ck !~ /\{$media\}\{.*?\}\{.*?\}\{.*?\}/x;
my ($k1,$k2,$k3) = $ck =~ /\{($media)\}\{(.*?)\}\{(.*?)\}\{.*?\}/x;
if($tac) {
next if "$k2" ne "$tac";
}
push @$aref,$k3 if($k3 =~ /^(\d+|\d+.\d+)$/x); # Serial Nummer in übergebenes Array eintragen
}
}
if($mode eq "readkeys") { # liest alle Schlüssel aus gegebenen Cache aus
for my $ck (cache($name, "c_getkeys")) {
next if $ck !~ /\{$media\}\{\d+?\}\{.*?\}/x;
my ($k1) = $ck =~ /\{$media\}\{(\d+?)\}\{.*?\}/x;
push @$aref,$k1 if($k1 =~ /^\d+$/x);
}
}
return;
}
#############################################################################################
# Token setzen
#############################################################################################
sub setActiveToken {
my ($hash) = @_;
my $name = $hash->{NAME};
$hash->{HELPER}{ACTIVE} = "on";
if (AttrVal($name,"debugactivetoken",0)) {
Log3($name, 1, "$name - Active-Token set by OPMODE: $hash->{OPMODE}");
}
return;
}
#############################################################################################
# Token freigeben
#############################################################################################
sub delActiveToken {
my ($hash) = @_;
my $name = $hash->{NAME};
$hash->{HELPER}{ACTIVE} = "off";
if (AttrVal($name,"debugactivetoken",0)) {
Log3($name, 1, "$name - Active-Token deleted by OPMODE: $hash->{OPMODE}");
}
return;
}
#############################################################################################
# Transaktion starten oder vorhandenen TA Code zurück liefern
#############################################################################################
sub openOrgetTrans {
my $hash = shift;
my $name = $hash->{NAME};
my $tac = "";
if(!$hash->{HELPER}{TRANSACTION}) {
$tac = int(rand(4500)); # Transaktionscode erzeugen und speichern
$hash->{HELPER}{TRANSACTION} = $tac;
if (AttrVal($name,"debugactivetoken",0)) {
Log3($name, 1, "$name - Transaction opened, TA-code: $tac");
}
} else {
$tac = $hash->{HELPER}{TRANSACTION}; # vorhandenen Transaktionscode zurück liefern
}
return $tac;
}
#############################################################################################
# Transaktion freigeben
#############################################################################################
sub closeTrans {
my $hash = shift;
my $name = $hash->{NAME};
my $tac = delete $hash->{HELPER}{TRANSACTION}; # diese Transaktion beenden
$tac = $tac?$tac:"";
cleanData("$name:$tac"); # %data Hash & Cache bereinigen
return if(!$tac);
Log3($name, 1, "$name - Transaction \"$tac\" closed") if(AttrVal($name,"debugactivetoken",0));
return;
}
####################################################################################################
# $data Hash bereinigen
####################################################################################################
sub cleanData {
my ($str) = @_;
my ($name,$tac) = split(":",$str);
my $hash = $defs{$name};
my $del = 0;
RemoveInternalTimer($hash, "FHEM::SSCam::cleanData");
if($data{SSCam}{$name}{SENDCOUNT}{$tac} && $data{SSCam}{$name}{SENDCOUNT}{$tac} > 0) { # Cacheinhalt erst löschen wenn Sendezähler 0
InternalTimer(gettimeofday()+1, "FHEM::SSCam::cleanData", "$name:$tac", 0);
return;
}
if(AttrVal($name,"cacheType","internal") eq "internal") {
# internes Caching
if($tac) {
if($data{SSCam}{RS}{$tac}) {
delete $data{SSCam}{RS}{$tac};
$del = 1;
}
if($data{SSCam}{$name}{SENDRECS}{$tac}) {
delete $data{SSCam}{$name}{SENDRECS}{$tac};
$del = 1;
}
if($data{SSCam}{$name}{SENDSNAPS}{$tac}) {
delete $data{SSCam}{$name}{SENDSNAPS}{$tac};
$del = 1;
}
if($data{SSCam}{$name}{PARAMS}{$tac}) {
delete $data{SSCam}{$name}{PARAMS}{$tac};
$del = 1;
}
if ($del && AttrVal($name,"debugactivetoken",0)) {
Log3($name, 1, "$name - Data of Transaction \"$tac\" deleted");
}
} else {
delete $data{SSCam}{RS};
delete $data{SSCam}{$name}{SENDRECS};
delete $data{SSCam}{$name}{SENDSNAPS};
delete $data{SSCam}{$name}{PARAMS};
if (AttrVal($name,"debugactivetoken",0)) {
Log3($name, 1, "$name - Data of internal Cache removed");
}
}
} else {
# Caching mit CHI
my @as = cache($name, "c_getkeys");
if($tac) {
for my $k (@as) {
if ($k =~ /$tac/x) {
cache($name, "c_remove", $k);
$del = 1;
}
}
if ($del && AttrVal($name,"debugactivetoken",0)) {
Log3($name, 1, "$name - Data of Transaction \"$tac\" removed");
}
} else {
cache($name, "c_clear");
if (AttrVal($name,"debugactivetoken",0)) {
Log3($name, 1, "$name - Data of CHI-Cache removed");
}
}
}
return;
}
#############################################################################################
# {SENDCOUNT} aus BlockingCall heraus um 1 subtrahieren/addieren
# $tac =
#############################################################################################
sub subaddFromBlocking {
my ($name,$op,$tac) = @_;
my $hash = $defs{$name};
if($op eq "-") {
$data{SSCam}{$name}{SENDCOUNT}{$tac}--;
}
if($op eq "+") {
$data{SSCam}{$name}{SENDCOUNT}{$tac}++;
}
Log3($name, 1, "$name - Send Counter transaction \"$tac\": ".$data{SSCam}{$name}{SENDCOUNT}{$tac}) if(AttrVal($name,"debugactivetoken",0));
return;
}
#############################################################################################
# Leerzeichen am Anfang / Ende eines strings entfernen
#############################################################################################
sub trim {
my $str = shift;
$str =~ s/^\s+|\s+$//gx;
return ($str);
}
#############################################################################################
# Check ob "sscam" im iconpath des FHEMWEB Devices enthalten ist
#############################################################################################
sub checkIconpath {
my $name = shift;
my $FW_wname = shift // return;
my $icpa = AttrVal($FW_wname, "iconPath", "");
if ($icpa !~ /sscam/x) {
Log3 ($name, 2, qq{$name - WARNING - add "sscam" to attribute "iconpath" of FHEMWEB device "$FW_wname" to get the SSCam control icons} );
}
return;
}
#############################################################################################
# Cache Handling
# cache ($name, [, , ])
# return 1 = ok , return 0 = nok
#############################################################################################
sub cache {
my ($name,$op,$key,$dat) = @_;
my $hash = $defs{$name};
my $type = AttrVal($name,"cacheType","internal");
my ($server,$port) = split(":",AttrVal($name,"cacheServerParam",""));
my $path = $attr{global}{modpath}."/FHEM/FhemUtils/cacheSSCam"; # Dir für FileCache
my $fuuid = $hash->{FUUID};
my ($cache,$r,$bst,$brt);
$bst = [gettimeofday];
### Cache Initialisierung ###
#############################
if($op eq "c_init") {
if ($type eq "internal") {
Log3($name, 4, "$name - internal Cache mechanism is used ");
return $type;
}
if($SScamMMCHI) {
Log3($name, 1, "$name - Perl cache module ".$SScamMMCHI." is missing. You need to install it with the FHEM Installer for example.");
return 0;
}
if($type eq "redis" && $SScamMMCHIRedis) {
Log3($name, 1, "$name - Perl cache module ".$SScamMMCHIRedis." is missing. You need to install it with the FHEM Installer for example.");
return 0;
}
if($type eq "filecache" && $SScamMMCacheCache) {
Log3($name, 1, "$name - Perl cache module ".$SScamMMCacheCache." is missing. You need to install it with the FHEM Installer for example.");
return 0;
}
if ($hash->{HELPER}{CACHEKEY}) {
Log3($name, 4, "$name - Cache \"$type\" is already initialized ");
return $type;
}
if($type eq "mem") {
# This cache driver stores data on a per-process basis. This is the fastest of the cache implementations,
# but data can not be shared between processes. Data will remain in the cache until cleared, expired,
# or the process dies.
# https://metacpan.org/pod/CHI::Driver::Memory
$cache = CHI->new( driver => 'Memory',
on_set_error => 'warn',
on_get_error => 'warn',
namespace => $fuuid,
global => 0
);
}
if($type eq "rawmem") {
# This is a subclass of CHI::Driver::Memory that stores references to data structures directly instead
# of serializing / deserializing. This makes the cache faster at getting and setting complex data structures,
# but unlike most drivers, modifications to the original data structure will affect the data structure stored
# in the cache.
# https://metacpan.org/pod/CHI::Driver::RawMemory
$cache = CHI->new( driver => 'RawMemory',
on_set_error => 'warn',
on_get_error => 'warn',
namespace => $fuuid,
global => 0
);
}
if($type eq "redis") {
# A CHI driver that uses Redis to store the data. Care has been taken to not have this module fail in fiery
# ways if the cache is unavailable. It is my hope that if it is failing and the cache is not required for your work,
# you can ignore its warnings.
# https://metacpan.org/pod/CHI::Driver::Redis
if(!$server || !$port) {
Log3($name, 1, "$name - ERROR in cache Redis definition. Please provide Redis server parameter in form : ");
return 0;
}
my $cto = 0.5;
my $rto = 2.0;
my $wto = 1.0;
my %Redispars = ( cnx_timeout => $cto,
read_timeout => $rto,
write_timeout => $wto
);
# Redis Construktor for Test Redis server connection (CHI doesn't do it)
delete $hash->{HELPER}{REDISKEY};
$r = eval { Redis->new( server => "$server:$port",
cnx_timeout => $cto,
debug => 0
);
};
if ( my $error = $@ ) {
# Muster: Could not connect to Redis server at 192.168.2.10:6379: Connection refused at ./FHEM/49_SSCam.pm line 9546.
$error = (split("at ./FHEM",$error))[0];
Log3($name, 1, "$name - ERROR - $error");
return 0;
} else {
$hash->{HELPER}{REDISKEY} = $r;
}
# create CHI Redis constructor
$cache = CHI->new( driver => 'Redis',
namespace => $fuuid,
server => "$server:$port",
reconnect => 1,
on_set_error => 'warn',
on_get_error => 'warn',
redis_options => \%Redispars,
debug => 0
);
}
if($type eq "file") {
# This is a filecache using Cache::Cache.
# https://metacpan.org/pod/Cache::Cache
my $pr = (split('/',reverse($path),2))[1];
$pr = reverse($pr);
if(!(-R $pr) || !(-W $pr)) { # root-erzeichnis testen
Log3($name, 1, "$name - ERROR - cannot create \"$type\" Cache in dir \"$pr\": ".$!);
delete $hash->{HELPER}{CACHEKEY};
return 0;
}
if(!(-d $path)) { # Zielverzeichnis anlegen wenn nicht vorhanden
my $success = mkdir($path,0775);
if(!$success) {
Log3($name, 1, "$name - ERROR - cannot create \"$type\" Cache path \"$path\": ".$!);
delete $hash->{HELPER}{CACHEKEY};
return 0;
}
}
$cache = CHI->new( driver => 'CacheCache',
on_set_error => 'warn',
on_get_error => 'warn',
cc_class => 'Cache::FileCache',
cc_options => { cache_root => $path,
namespace => $fuuid
},
);
}
if ($cache && $cache =~ /CHI::Driver::Role::Universal/x) {
Log3($name, 3, "$name - Cache \"$type\" namespace \"$fuuid\" initialized");
$hash->{HELPER}{CACHEKEY} = $cache;
$brt = tv_interval($bst);
Log3($name, 1, "$name - Cache time to create \"$type\": ".$brt) if(AttrVal($name,"debugCachetime",0));
return $type;
} else {
Log3($name, 3, "$name - no cache \"$type\" available.");
}
return 0;
}
### Test Operationen ###
########################
if($hash->{HELPER}{CACHEKEY}) {
$cache = $hash->{HELPER}{CACHEKEY};
} else {
return 0;
}
if($type eq "redis") {
# Test ob Redis Serververbindung möglich
my $rc = $hash->{HELPER}{REDISKEY};
if ($rc) {
eval { $r = $rc->ping }; ## no critic 'eval not tested'
if (!$r || $r ne "PONG") { # Verbindungskeys löschen -> Neugenerierung mit "c_init"
Log3($name, 1, "$name - ERROR - connection to Redis server not possible. May be no route to host or port is wrong.");
delete $hash->{HELPER}{REDISKEY};
delete $hash->{HELPER}{CACHEKEY};
return 0;
}
} else {
Log3($name, 1, "$name - ERROR - no constructor for Redis server is created");
return 0;
}
}
if($type eq "file" && (!(-R $path) || !(-W $path))) {
Log3($name, 1, "$name - ERROR - cannot handle \"$type\" Cache: ".$!);
delete $hash->{HELPER}{CACHEKEY};
return 0;
}
### Cache Operationen ###
#########################
# in Cache schreiben
if($op eq "c_write") {
if (!defined $dat) {
Log3($name, 1, "$name - ERROR - No data for Cache with key: $key ");
}
if($key) {
$cache->set($key,$dat);
$brt = tv_interval($bst);
Log3($name, 1, "$name - Cache time write key \"$key\": ".$brt) if(AttrVal($name,"debugCachetime",0));
return 1;
} else {
Log3($name, 1, "$name - ERROR - no key for \"$type\" cache !");
}
}
# aus Cache lesen
if($op eq "c_read") {
my $g = $cache->get($key);
$brt = tv_interval($bst);
Log3($name, 1, "$name - Cache time read key \"$key\": ".$brt) if(AttrVal($name,"debugCachetime",0));
if(!$g) {
return "";
} else {
return $g;
}
}
# einen Key entfernen
if($op eq "c_remove") {
$cache->remove($key);
$brt = tv_interval($bst);
Log3($name, 1, "$name - Cache time remove key \"$key\": ".$brt) if(AttrVal($name,"debugCachetime",0));
Log3($name, 4, "$name - Cache key \"$key\" removed ");
return 1;
}
# alle Einträge aus Cache (Namespace) entfernen
if($op eq "c_clear") {
$cache->clear();
Log3($name, 4, "$name - All entries removed from \"$type\" cache ");
return 1;
}
# alle Keys aus Cache zurück liefern
if($op eq "c_getkeys") {
return $cache->get_keys;
}
# einen Key im Cache prüfen
if($op eq "c_isvalidkey") {
return $cache->is_valid($key);
}
# Cache entfernen
if($op eq "c_destroy") {
$cache->clear();
delete $hash->{HELPER}{CACHEKEY};
Log3($name, 3, "$name - Cache \"$type\" destroyed ");
return 1;
}
return 0;
}
#############################################################################################
# Versionierungen des Moduls setzen
# Die Verwendung von Meta.pm und Packages wird berücksichtigt
#############################################################################################
sub setVersionInfo {
my ($hash) = @_;
my $name = $hash->{NAME};
my $v = (sortVersion("desc",keys %vNotesIntern))[0];
my $type = $hash->{TYPE};
$hash->{HELPER}{PACKAGE} = __PACKAGE__;
$hash->{HELPER}{VERSION} = $v;
if($modules{$type}{META}{x_prereqs_src} && !$hash->{HELPER}{MODMETAABSENT}) {
# META-Daten sind vorhanden
$modules{$type}{META}{version} = "v".$v; # Version aus META.json überschreiben, Anzeige mit {Dumper $modules{SMAPortal}{META}}
if($modules{$type}{META}{x_version}) { # {x_version} ( nur gesetzt wenn $Id: 49_SSCam.pm 22600 2020-08-14 19:22:36Z DS_Starter $ im Kopf komplett! vorhanden )
$modules{$type}{META}{x_version} =~ s/1\.1\.1/$v/gx;
} else {
$modules{$type}{META}{x_version} = $v;
}
return $@ unless (FHEM::Meta::SetInternals($hash)); # FVERSION wird gesetzt ( nur gesetzt wenn $Id: 49_SSCam.pm 22600 2020-08-14 19:22:36Z DS_Starter $ im Kopf komplett! vorhanden )
if(__PACKAGE__ eq "FHEM::$type" || __PACKAGE__ eq $type) {
# es wird mit Packages gearbeitet -> Perl übliche Modulversion setzen
# mit {->VERSION()} im FHEMWEB kann Modulversion abgefragt werden
use version 0.77; our $VERSION = FHEM::Meta::Get( $hash, 'version' ); ## no critic 'VERSION'
}
} else {
# herkömmliche Modulstruktur
$hash->{VERSION} = $v;
}
return;
}
1;
=pod
=item summary Camera module to control the Synology Surveillance Station
=item summary_DE Kamera-Modul für die Steuerung der Synology Surveillance Station
=begin html
SSCam
Using this Module you are able to operate cameras which are defined in Synology Surveillance Station (SVS) and execute
functions of the SVS. It is based on the SVS API and supports the SVS version 7 and above.
Start a recording and send it optionally by Email and/or Telegram
Stop a recording by command or automatically after an adjustable period
Trigger of snapshots / recordings and optional send them alltogether by Email using the integrated Email client or by Synology Chat / Telegram
Trigger snapshots of all defined cams and optionally send them alltogether by Email using the integrated Email client
Deaktivate a Camera in Synology Surveillance Station
Activate a Camera in Synology Surveillance Station
Control of the exposure modes day, night and automatic
switchover the motion detection by camera, by SVS or deactivate it
control of motion detection parameters sensitivity, threshold, object size and percentage for release
Retrieval of Camera Properties (also by Polling) as well as informations about the installed SVS-package
Move to a predefined Preset-position (at PTZ-cameras)
Start a predefined Patrol (at PTZ-cameras)
Positioning of PTZ-cameras to absolute X/Y-coordinates
continuous moving of PTZ-camera lense
trigger of external events 1-10 (action rules in SVS)
start and stop of camera livestreams incl. audio replay, show the last recording and snapshot
fetch of livestream-Url's with key (login not needed in that case)
playback of last recording and playback the last snapshot
switch the Surveillance Station HomeMode on/off and retrieve the HomeModeState
show the stored credentials of a device
fetch the Surveillance Station Logs, exploit the newest entry as reading
create a gallery of the last 1-10 snapshots (as Popup or in a discrete device)
Start/Stop Object Tracking (only supported PTZ-Cams with this capability)
set/delete a Preset (at PTZ-cameras)
set a Preset or current position as Home Preset (at PTZ-cameras)
provides a panel for camera control (at PTZ-cameras)
create different types of discrete Streaming-Devices (createStreamDev)
Activation / Deactivation of a camera integrated PIR sensor
Creation of a readingsGroup device to display an overview of all defined SSCam devices (createReadingsGroup)
automatized definition of all in SVS available cameras in FHEM (autocreateCams)
save the last recording of camera locally
Selection of several cache types for image data storage (attribute cacheType)
execute Zoom actions (only if PTZ camera supports Zoom)
49_SSCam: Fragen, Hinweise, Neuigkeiten und mehr rund um dieses Modul .
Integration into FHEM TabletUI: FTUI Widget für SSCam Streaming Devices (SSCamSTRM) .
Prerequisites
This module uses the Perl-modules JSON and MIME::Lite which are usually have to be installed in addition. sudo apt-get install libjson-perl sudo apt-get install libmime-lite-perl Credentials .
JSON Data::Dumper MIME::Base64 Time::HiRes Encode POSIX HttpUtils (FHEM-module) Blocking (FHEM-module) Meta (FHEM-module) Net::SMTP (if integrated image data transmission is used) MIME::Lite (if integrated image data transmission is used) CHI (if Cache is used) CHI::Driver::Redis (if Cache is used) Cache::Cache (if Cache is used)
iconPath must be supplemented with sscam in the FHEMWEB device.
Example
Define
camera device is defined by:
define <Name> SSCAM <camera name in SVS> <ServerAddr> [Port] [Protocol]
At first the devices have to be set up and has to be operable in Synology Surveillance Station 7.0 and above. SVS-device to control functions of the Surveillance Station (SVS) is defined by:
define <Name> SSCAM SVS <ServerAddr> [Port] [Protocol]
In that case the term <camera name in SVS> become replaced by SVS only.
Name the name of the new device to use in FHEM Cameraname camera name as defined in Synology Surveillance Station if camera-device, "SVS" if SVS-Device. Spaces are not allowed in camera name. ServerAddr IP-address of Synology Surveillance Station Host. Note: avoid using hostnames because of DNS-Calls are not unblocking in FHEM Port optional - the port of synology disc station. If not set, the default "5000" is used Protocol optional - the protocol (http or https) to access the synology disc station. If not set, the default "http" is used
Examples:
define CamCP SSCAM Carport 192.168.2.20 [5000] [http]
define CamCP SSCAM Carport 192.168.2.20 [5001] [https]
# creates a new camera device CamCP
define DS1 SSCAM SVS 192.168.2.20 [5000] [http]
define DS1 SSCAM SVS 192.168.2.20 [5001] [https]
# creares a new SVS device DS1
When a new Camera is defined, as a start the recordingtime of 15 seconds will be assigned to the device.attribute "rectime" you can adapt the recordingtime for every camera individually.attribute "rectime" would be deleted again, the default-value for recording-time (15s) become active.command "set <name> on [rectime]" a temporary recordingtime is determinded which would overwrite the dafault-value of recordingtime "set <name> on 0" leads also to an endless recording as well.attributes "ptzPanel_.*". command "set <name> createPTZcontrol" in this context.
Credentials
After a camera-device is defined, firstly it is needed to save the credentials. This will be done with command:
set <name> credentials <username> <password>
The password length has a maximum of 20 characters. 2-step verification
activated in DSM, the setup to a session with Surveillance Station is necessary (attribute "session = SurveillanceStation").
DSM-User as member of admin group: unrestricted test of all module functions -> session: DSM
SVS-User as Manager or observer: adjusted privilege profile -> session: SurveillanceStation
Attribute "session" can be selected, if the session should be established to DSM or the
SVS instead. Further informations about user management in SVS are available by execute
"get <name> versionNotes 5".minimum rights that the particular module function needs.
set ... on session: ServeillanceStation - observer with enhanced privilege "manual recording" set ... off session: ServeillanceStation - observer with enhanced privilege "manual recording" set ... snap session: ServeillanceStation - observer set ... delPreset session: ServeillanceStation - observer set ... disable session: ServeillanceStation - manager with edit camera right set ... enable session: ServeillanceStation - manager with edit camera right set ... expmode session: ServeillanceStation - manager set ... extevent session: DSM - user as member of admin-group set ... goPreset session: ServeillanceStation - observer with privilege objective control of camera set ... homeMode ssession: ServeillanceStation - observer with privilege Home Mode switch (valid for SVS-device ! ) set ... motdetsc session: ServeillanceStation - manager set ... runPatrol session: ServeillanceStation - observer with privilege objective control of camera set ... goAbsPTZ session: ServeillanceStation - observer with privilege objective control of camera set ... move session: ServeillanceStation - observer with privilege objective control of camera set ... runView session: ServeillanceStation - observer with privilege liveview of camera set ... setHome session: ServeillanceStation - observer set ... setPreset session: ServeillanceStation - observer set ... snap session: ServeillanceStation - observer set ... snapGallery session: ServeillanceStation - observer set ... stopView - set ... credentials - get ... caminfo[all] session: ServeillanceStation - observer get ... eventlist session: ServeillanceStation - observer get ... listLog session: ServeillanceStation - observer get ... listPresets session: ServeillanceStation - observer get ... scanVirgin session: ServeillanceStation - observer get ... svsinfo session: ServeillanceStation - observer get ... snapfileinfo session: ServeillanceStation - observer get ... snapinfo session: ServeillanceStation - observer get ... stmUrlPath session: ServeillanceStation - observer
HTTP-Timeout Settings
All functions of SSCam use HTTP-calls to SVS Web API. attribute "httptimeout" > 0 to adjust the value as needed in your technical environment.
Set
autocreateCams (valid for SVS)
createStreamDev [generic | hls | lastsnap | mjpeg | switched] (valid for CAM) createStreamDev [master] (valid for SVS)
generic - the streaming device playback a content determined by attribute genericStrmHtmlTag hls - the streaming device playback a permanent HLS video stream lastsnap - the streaming device playback the newest snapshot mjpeg - the streaming device playback a permanent MJPEG video stream (Streamkey method) switched - playback of different streaming types. Buttons for mode control are provided. master - with the master device another defined streaming device can be adopted and its content displayed
htmlattr of the camera device or by
specific attributes of the SSCamSTRM-device itself. Streaming device "hls" attribuet "hlsNetScript" can be specified, whether
the local installed version of hls.js (./www/pgm2/sscam_hls.js) or the newest online library version from the hls.js
project site should be used. This attribute has to be set centrally in a device of type "SVS" ! attribute "hlsStrmObject" must be set in the parent
camera device (see Internal PARENT).
Streaming device "switched hls" Streaming device "generic"
attr <name> genericStrmHtmlTag <video $HTMLATTR controls autoplay>
<source src='http://192.168.2.10:32000/$NAME.m3u8' type='application/x-mpegURL'>
</video>
attr <name> genericStrmHtmlTag <img $HTMLATTR
src="http://192.168.2.10:32774"
onClick="FW_okDialog('<img src=http://192.168.2.10:32774 $PWS>')"
>
The variables $HTMLATTR, $NAME and $PWS are placeholders and absorb the attribute "htmlattr" (if set), the SSCam-Devicename
respectively the value of attribute "popupWindowSize" in streamin-device, which specify the windowsize of a popup window.
Streaming device "lastsnap" "snapGallerySize = Full" has to be set in the associated camera device (compare Internal PARENT).
There also the attribute "pollcaminfoall" should be set to retrieve the newest snapshot regularly.
Streaming Device "master" adopt in the Master Streaming Device.
createPTZcontrol (valid for PTZ-CAM)attributes or respectively the specific attributes of the SSCamSTRM-device
the properties of the control panel can be affected.
createReadingsGroup [<name of readingsGroup>] (valid for CAM/SVS)
createSnapGallery (valid for CAM)attributes respectively the specific attributes of the SSCamSTRM-device
you are able to manipulate the properties of the new snapshot gallery device.
Note
credentials <username> <password> (valid for CAM/SVS)Credentials
delPreset <PresetName> (valid for PTZ-CAM)
disable (gilt für CAM)
enable (gilt für CAM)
expmode [day|night|auto] (valid for CAM) Note:
extevent [ 1-10 ] (valid for SVS)
goAbsPTZ [ X Y | up | down | left | right ] (valid for CAM)
set <name> goAbsPTZ 120 450
In this example the camera lense moves to position X=120 und Y=450.
X = 0 - 640 (0 - 319 moves lense left, 321 - 640 moves lense right, 320 don't move lense)
Y = 0 - 480 (0 - 239 moves lense down, 241 - 480 moves lense up, 240 don't move lense)
The lense can be moved in smallest steps to very large steps into the desired direction.
If necessary the procedure has to be repeated to bring the lense into the desired position.
set <name> goAbsPTZ up [down|left|right]
In this case the lense will be moved with largest possible increment into the given absolute position.
Also in this case the procedure has to be repeated to bring the lense into the desired position if necessary.
goPreset <Preset> (valid for CAM)
define CamFL.Preset.Wandschrank notify MelderTER:on.* set CamFL goPreset Wandschrank, ;; define CamFL.Preset.record at +00:00:10 set CamFL on 5 ;;;; define s3 at +*{3}00:00:05 set CamFL snap ;; define CamFL.Preset.back at +00:00:30 set CamFL goPreset Home
Operating Mode:
2016.02.04 15:02:14 2: CamFL - Camera Flur_Vorderhaus has moved to position "Wandschrank"
2016.02.04 15:02:24 2: CamFL - Camera Flur_Vorderhaus Recording with Recordtime 5s started
2016.02.04 15:02:29 2: CamFL - Snapshot of Camera Flur_Vorderhaus has been done successfully
2016.02.04 15:02:30 2: CamFL - Camera Flur_Vorderhaus Recording stopped
2016.02.04 15:02:34 2: CamFL - Snapshot of Camera Flur_Vorderhaus has been done successfully
2016.02.04 15:02:39 2: CamFL - Snapshot of Camera Flur_Vorderhaus has been done successfully
2016.02.04 15:02:44 2: CamFL - Camera Flur_Vorderhaus has moved to position "Home"
homeMode [on|off] (valid for SVS)Synology Onlinehelp .
motdetsc [camera|SVS|disable] (valid for CAM)
set <name> motdetsc SVS [sensitivity] [threshold] # command pattern set <name> motdetsc SVS 91 30 # set the sensitivity to 91 and threshold to 30 set <name> motdetsc SVS 0 40 # keep the old value of sensitivity, set threshold to 40 set <name> motdetsc SVS 15 # set the sensitivity to 15, threshold keep unchanged
set <name> motdetsc camera [sensitivity] [threshold] [percentage] # command pattern set <name> motdetsc camera 89 0 20 # set the sensitivity to 89, percentage to 20 set <name> motdetsc camera 0 40 10 # keep old value for sensitivity, set threshold to 40, percentage to 10 set <name> motdetsc camera 30 # set the sensitivity to 30, other values keep unchanged
Reading "CamMotDetSc" also will be updated which documents the current setup of motion detection.
Only the parameters and parameter values supported by SVS at present will be shown. The camera itself may offer further options to adjust.
CamMotDetSc SVS, sensitivity: 76, threshold: 55
move [ right | up | down | left | dir_X ] [Sekunden] (valid for CAM up to SVS version 7.1) move [ right | upright | up | upleft | left | downleft | down | downright ] [Sekunden] (valid for CAM and SVS Version 7.2 and above)
set <name> move up 0.5 : moves PTZ 0,5 Sek. (plus processing time) to the top
set <name> move dir_1 1.5 : moves PTZ 1,5 Sek. (plus processing time) to top-right
set <name> move dir_20 0.7 : moves PTZ 1,5 Sek. (plus processing time) to left-bottom ("CapPTZDirections = 32)"
off (valid for CAM)
set <name> on [<rectime>] (valid for CAM)attribute "rectime".
The recording time can be overwritten on-time by "set <name> on <rectime>" for the current recording.
The recording will be stopped after processing time "rectime"automatically.attribute "recextend" as explained as
follows.Attribute "recextend = 0" or not set (default):
if, for example, a recording with rectimeme=22 is started, no other startcommand (for a recording) will be accepted until this started recording is finished.
A hint will be logged in case of verboselevel = 3.
Attribute "recextend = 1" is set:
a before started recording will be extend by the recording time "rectime" if a new start command is received. That means, the timer for the automatic stop-command will be
renewed to "rectime" given bei the command, attribute or default value. This procedure will be repeated every time a new start command for recording is received.
Therefore a running recording will be extended until no start command will be get.
a before started endless-recording will be stopped after recordingtime 2rectime" if a new "set on"-command is received (new set of timer). If it is unwanted make sure you
don't set the attribute "recextend" in case of endless-recordings.
Synology Chat can be activated permanently by setting attribute recChatTxt
Of course, the SSChatBot device which is
used for send data, must be defined and fully functional before. Email shipping of recordings can be activated by setting attribute "recEmailTxt".
Before you have to prepare the Email shipping as described in section Setup Email shipping .
(for further information execute "get <name> versionNotes 7 ") Telegram can be activated permanently by setting attribute
"recTelegramTxt". Of course, the TelegramBot device which is
used, must be defined and fully functional before. Examples: set <name> on 0 set <name> on recEmailTxt:"subject => New recording for $CAM created, body => The last recording of $CAM is atteched." set <name> on recTelegramTxt:"tbot => teleBot, peers => @xxxx , subject => Movement alarm by $CAM. The snapshot $FILE was created at $CTIME" set <name> on recChatTxt:"chatbot => SynChatBot, peers => , subject => Movement alarm by $CAM. The snapshot $FILE was created at $CTIME."
optimizeParams [mirror:<value>] [flip:<value>] [rotate:<value>] [ntp:<value>] (gilt für CAM)
mirror, flip, rotate: true | false
ntp: the name or the IP-address of time server
Examples: set <name> optimizeParams mirror:true flip:true ntp:time.windows.com set <name> optimizeParams ntp:Surveillance%20Station set <name> optimizeParams mirror:true flip:false rotate:true
pirSensor [activate | deactivate] (valid for CAM)
runPatrol <Patrolname> (valid for CAM)
runView [live_fw | live_link | live_open [<room>] | lastrec_fw | lastrec_fw_MJPEG | lastrec_fw_MPEG4/H.264 | lastrec_open [<room>] | lastsnap_fw] (valid for CAM)
live_fw - MJPEG-Livestream. Audio playback is provided if possible. live_fw_hls - HLS-Livestream (currently only Mac Safari Browser and mobile iOS/Android-Devices) live_link - Link of a MJPEG-Livestream live_open [<room>] - opens MJPEG-Livestream in separate Browser window lastrec_fw - playback last recording as iFrame object lastrec_fw_MJPEG - usable if last recording has format MJPEG lastrec_fw_MPEG4/H.264 - usable if last recording has format MPEG4/H.264 lastrec_open [<room>] - playback last recording in a separate Browser window lastsnap_fw - playback last snapshot
"live_fw, live_link" a MJPEG-Livestream will be started, either as an embedded image
or as a generated link. "live_open" starts a new browser window with a MJPEG-Livestream. If the optional "<room>" is set, the
window will only be started if the specified room is currently opened in a FHEMWEB-session. "live_fw_hls" is requested, the camera has to be setup to video format H.264 (not MJPEG) in the
Synology Surveillance Station and the SVS-Version has to support the HLS format.
Therefore this possibility is only present if the Reading "CamStreamFormat" is set to "HLS".
"lastrec_fw.*" respectively "lastrec_open" .
By "lastrec_fw" the recording will be opened in an iFrame. There are some control elements provided if available. "lastrec_open" command can be extended optionally by a room. In this case the new window opens only, if the
room is the same as a FHEMWEB-session has currently opened. "set <name> runView lastsnap_fw" shows the last snapshot of the camera embedded. attribute "htmlattr".
Examples:
attr <name> htmlattr width="500" height="375"
attr <name> htmlattr width="700",height="525",top="200",left="300"
The command "set <name> runView live_open" starts the stream immediately in a new browser window.
A browser window will be initiated to open for every FHEMWEB-session which is active. If you want to change this behavior,
you can use command "set <name> runView live_open <room>" . In this case the new window opens only, if the
room is the same as a FHEMWEB-session has currently opened. attribute "livestreamprefix" overwrite the data for protocol, servername and
port in reading "LiveStreamUrl".
By "livestreamprefix" the LivestreamURL (is shown if attribute "showStmInfoFull" is set) can
be modified and used for distribution and external access to the Livestream. Example:
attr <name> livestreamprefix https://<Servername>:<Port>
The livestream can be stopped again by command "set <name> stopView" .
The "runView" function also switches Streaming-Devices of type "switched" into the appropriate mode.
Start Recording - starts an endless recording Stop Recording - stopps the recording Take Snapshot - take a snapshot Switch off - stops a running playback
Note for HLS (HTTP Live Streaming): Note for MJPEG:
setHome <PresetName> (valid for PTZ-CAM)
setPreset <PresetNumber> [<PresetName>] [<Speed>] (valid for PTZ-CAM)
setZoom < .++ | + | stop | - | --. > (valid for PTZ-CAM)
snap [<number>] [<time difference>] (valid for CAM)snapReadingRotate
can be used.
Synology Chat can be permanently activated by setting attribute snapChatTxt .
Of course, the SSChatBot device which is
used must be defined and fully functional before. videofolderMap has to be set before. It must contain an URL to the
root directory of recordings and snapshots (e.g. http://server.me:8081/surveillance). Email shipping can be activated by setting attribute snapEmailTxt .
Before you have to prepare the Email shipping as described in section Setup Email shipping .
(for further information execute "get <name> versionNotes 7 ") Telegram can be permanently activated by setting attribute snapTelegramTxt .
Of course, the TelegramBot device which is
used must be defined and fully functional before. Examples:
set <name> snap
set <name> snap 4
set <name> snap 3 3 snapEmailTxt:"subject => Movement alarm $CAM, body => A movement was recognised at Carport"
set <name> snap 2 snapTelegramTxt:"tbot => teleBot, peers => , subject => Movement alarm by $CAM. The snapshot $FILE was created at $CTIME"
set <name> snap 2 snapChatTxt:"chatbot => SynChatBot , peers => Frodo Sam, subject => Movement alarm by $CAM. At $CTIME the snapshot $FILE was created. Now it is: $TIME."
snapCams [<number>] [<time difference>] [CAM:"<camera>, <camera>, ..."] (valid for SVS)Email shipping can be activated by setting attribute "snapEmailTxt" in the
SVS device AND in the camera devices whose snapshots should be shipped.
Before you have to prepare the Email shipping as described in section Setup Email shipping .
(for further information execute "get <name> versionNotes 7 ") Examples:
set <name> snapCams 4
set <name> snapCams 3 3 CAM:"CamHE1, CamCarport"
snapGallery [1-10] (valid for CAM)attribute "snapGalleryBoost=1" no popup will be created. The snapshot gallery will be depicted as
an browserpage instead. All further functions and attributes are appropriate the "get <name> snapGallery"
command. "get <name> snapGallery" command instead of "set".
Note
startTracking (valid for CAM with tracking capability)
stopTracking (valid for CAM with tracking capability)
Get
caminfoall (valid for CAM/SVS) caminfo (valid for CAM)
eventlist (valid for CAM)Reading "CamEventNum" and "CamLastRecord" will be refreshed which containes the total number
of in SVS registered camera events and the path/name of the last recording.
This command will be implicit executed when "get <name> caminfoall" is running. attribute "videofolderMap" replaces the content of reading "VideoFolder". You can use it for
example if you have mounted the videofolder of SVS under another name or path and want to access by your local pc.
homeModeState (valid for SVS)
listLog [severity:<Loglevel>] [limit:<Number of lines>] [match:<Searchstring>] (valid for SVS)
<Loglevel> - Information, Warning or Error. Only datasets having this severity are retrieved (default: all)
<Number of lines> - the specified number of lines (newest) of the log are retrieved (default: all)
<Searchstring> - only log entries containing the searchstring are retrieved (Note: no Regex possible, the searchstring will be given into the call to SVS)
Examples
get <name> listLog severity:Error limit:5 get <name> listLog severity:Information match:Carport get <name> listLog severity:Warning
If the polling of SVS is activated by setting the attribute "pollcaminfoall", the reading
"LastLogEntry" will be created. Synology Online-Help .
listPresets (valid for PTZ-CAM)
saveRecording [<path>] (valid for CAM)
Beispiel:
scanVirgin (valid for CAM/SVS)
snapGallery [1-10] (valid for CAM)attribute "snapGalleryBoost" is set,
the last snapshots (default 3) are requested by polling and they will be stored in the FHEM-servers main memory.
This method is helpful to speed up the output especially in case of full size images, but it can be possible
that NOT the newest snapshots are be shown if they have not be initialized by the SSCAm-module itself. attributes :
snapGalleryBoost
snapGalleryColumns
snapGalleryHtmlAttr
snapGalleryNumber
snapGallerySize
Note:
snapfileinfo (valid for CAM)"get <name> snap"
automatically.
snapinfo (valid for CAM)
stmUrlPath (valid for CAM)attribute "showStmInfoFull" is set, additional stream readings like "StmKeyUnicst", "StmKeymjpegHttp" will be shown and can be used to run the
appropriate livestream without session id. Is the attribute "livestreamprefix" (usage: "http(s)://<hostname><port>) used, the servername / port will be replaced if necessary.
The strUrlPath function will be included automatically if polling is used.
http(s)://<hostname><port>/webapi/entry.cgi?api=SYNO.SurveillanceStation.VideoStreaming&version=1&method=Stream&format=mjpeg&cameraId=5&StmKey="31fd87279976d89bb98409728cced890"
cameraId (Internal CAMID) and StmKey has to be replaced by valid values. Note:
storedCredentials (valid for CAM/SVS)
svsinfo (valid for CAM/SVS)
versionNotes [hints | rel | <key>] (valid for CAM/SVS)
Setup Email shipping
Snapshots and recordings can be sent by Email after creation. For this purpose the module contains its
own Email client. Before you can use this function you have to install the Perl-module MIME::Lite . On debian
systems it can be installed with command:
sudo apt-get install libmime-lite-perl
"set <name> smtpcredentials <user> <password>" .
The connection establishment to the server is initially done unencrypted and switches to an encrypted connection if SSL
encryption is available. In that case the transmission of User/Password takes place encrypted too.
If attribute "smtpSSLPort" is defined, the established connection to the Email server will be encrypted immediately.
Attributes which are optional are marked:
snapEmailTxt - Activates the Email shipping of snapshots. This attribute has the format:
subject => <subject text>, body => <message text>
The placeholder $CAM, $DATE and $TIME can be used. recEmailTxt - Activates the Email shipping of recordings. This attribute has the format:
subject => <subject text>, body => <message text>
The placeholder $CAM, $DATE and $TIME can be used. smtpHost - Hostname of outgoing Email server (e.g. securesmtp.t-online.de) smtpFrom - Return address (<name>@<domain>) smtpTo - Receiving address(es) (<name>@<domain>) smtpPort - (optional) Port of outgoing Email server (default: 25) smtpCc - (optional) carbon-copy receiving address(es) (<name>@<domain>) smtpNoUseSSL - (optional) "1" if no SSL encryption should be used for Email shipping (default: 0) smtpSSLPort - (optional) Port for SSL encrypted connection (default: 465) smtpDebug - (optional) switch on the debugging of SMTP connection
attributes .
$CAM - Device alias respectively the name of the camera in SVS if the device alias isn't set $DATE - current date $TIME - current time $FILE - name of the snapshot file $CTIME - creation time of the snapshot
Polling of Camera/SVS-Properties
Retrieval of Camera-Properties can be done automatically if the attribute "pollcaminfoall" will be set to a value > 10.
PollState = Active - automatic polling will be executed with interval correspondig value of attribute "pollcaminfoall" PollState = Inactive - automatic polling won't be executed
here . Notes: Attribut "httptimeout") is set to 4 seconds, the theoretical processing time couldn't be higher than 80 seconds.
Internals
The meaning of used Internals is depicted in following list:
CAMID - the ID of camera defined in SVS, the value will be retrieved automatically on the basis of SVS-cameraname CAMNAME - the name of the camera in SVS COMPATIBILITY - information up to which SVS-version the module version is currently released/tested (see also Reading "compstate") CREDENTIALS - the value is "Set" if Credentials are set NAME - the cameraname in FHEM MODEL - distinction between camera device (CAM) and Surveillance Station device (SVS) OPMODE - the last executed operation of the module SERVERADDR - IP-Address of SVS Host SERVERPORT - SVS-Port
Attributes
hlsNetScript (settable in device model "SVS") hlsStrmObject
Examples:
httptimeout htmlattr
Example:
livestreamprefix
DEF : the protocol, servername and port as specified in device
definition is used http(s)://<servername>:<port> : your own address specification is used
loginRetries noQuotesForSID pollcaminfoall pollnologging ptzNoCapPrePat ptzPanel_Home ptzPanel_iconPath ptzPanel_iconPrefix ptzPanel_row[00-09] <command>:<icon>,<command>:<icon>,... Note:
Example:
ptzPanel_use recChatTxt chatbot => <SSChatBot device>, peers => [<peer1 peer2 ...>], subject => [<subject text>] videofolderMap has to be set. It must contain an URL to the
root directory of your SVS recordings and snapshots ( e.g. http://server.me:8081/surveillance ). SSChatBot device
must be available and work well.
$CAM - Device alias respectively the name of the camera in SVS if the device alias isn't set $DATE - current date $TIME - current time $FILE - Name of recording file $CTIME - recording creation time
Examples: recEmailTxt subject => <subject text>, body => <message text>
$CAM - Device alias respectively the name of the camera in SVS if the device alias isn't set $DATE - current date $TIME - aktuelle time
Example:
recTelegramTxt tbot => <TelegramBot device>, peers => [<peer1 peer2 ...>], subject => [<subject text>] TelegramBot device
must be available and has to be running well.
$CAM - Device alias respectively the name of the camera in SVS if the device alias isn't set $DATE - current date $TIME - current time $FILE - Name of recording file $CTIME - recording creation time
Examples: rectime recextend session simu_SVSversion smtpHost <Hostname> smtpCc <name>@<domain>[, <name>@<domain>][, <name>@<domain>]... smtpDebug smtpFrom <name>@<domain> smtpPort <Port> smtpSSLPort <Port> smtpTo <name>@<domain>[, <name>@<domain>][, <name>@<domain>]... smtpNoUseSSL snapChatTxt chatbot => <SSChatBot-Device>, peers => [<peer1 peer2 ...>], subject => [<subject text>] videofolderMap has to be set. It must contain an URL to the
root directory of your SVS recordings and snapshots ( e.g. http://server.me:8081/surveillance ). SSChatBot device
must be available and work well.
$CAM - Device alias respectively the name of the camera in SVS if the device alias isn't set $DATE - current date $TIME - current time $FILE - Name of snapshot file $CTIME - creation time of the snapshot
Examples: snapEmailTxt subject => <subject text>, body => <message text>
$CAM - Device alias respectively the name of the camera in SVS if the device alias isn't set $DATE - current date $TIME - current time
Example:
snapTelegramTxt tbot => <TelegramBot device>, peers => [<peer1 peer2 ...>], subject => [<subject text>] TelegramBot device
must be available and has to be running well.
$CAM - Device alias respectively the name of the camera in SVS if the device alias isn't set $DATE - current date $TIME - current time $FILE - Name of snapshot file $CTIME - creation time of the snapshot
Examples: snapGalleryBoost snapGalleryColumns snapGalleryHtmlAttr
Example:
snapGalleryNumber snapGallerySize snapReadingRotate 0...10 showStmInfoFull showPassInLog videofolderMap verbose
Different Verbose-Level are supported.
0 - Start/Stop-Event will be logged 1 - Error messages will be logged 2 - messages according to important events were logged 3 - sended commands will be logged 4 - sended and received informations will be logged 5 - all outputs will be logged for error-analyses. Caution: a lot of data could be written into logfile !
readingFnAttributes
Readings
CamAudioType - Indicating audio type Availability - Availability of Camera (disabled, enabled, disconnected, other) CamEventNum - delivers the total number of in SVS registered events of the camera CamExposureControl - indicating type of exposure control CamExposureMode - current exposure mode (Day, Night, Auto, Schedule, Unknown) CamForceEnableMulticast - Is the camera forced to enable multicast. CamIP - IP-Address of Camera CamLastRec - Path / name of last recording CamLastRecId - the ID of last recording CamLastRecTime - date / starttime - endtime of the last recording (format depends of global attribute "language") CamLiveFps - Frames per second of Live-Stream CamLiveMode - Source of Live-View (DS, Camera) camLiveQuality - Live-Stream quality set in SVS camLiveResolution - Live-Stream resolution set in SVS camLiveStreamNo - used Stream-number for Live-Stream CamModel - Model of camera CamMotDetSc - state of motion detection source (disabled, by camera, by SVS) and their parameter CamNTPServer - set time server CamPort - IP-Port of Camera CamPreRecTime - Duration of Pre-Recording (in seconds) adjusted in SVS CamPtSpeed - adjusted value of Pan/Tilt-activities (setup in SVS) CamRecShare - shared folder on disk station for recordings CamRecVolume - Volume on disk station for recordings CamStreamFormat - the current format of video streaming CamVideoType - Indicating video type CamVendor - Identifier of camera producer CamVideoFlip - Is the video flip CamVideoMirror - Is the video mirror CamVideoRotate - Is the video rotate CapAudioOut - Capability to Audio Out over Surveillance Station (false/true) CapChangeSpeed - Capability to various motion speed CapPIR - has the camera a PIR sensor feature CapPTZAbs - Capability to perform absolute PTZ action CapPTZAutoFocus - Capability to perform auto focus action CapPTZDirections - the PTZ directions that camera support CapPTZFocus - mode of support for focus action CapPTZHome - Capability to perform home action CapPTZIris - mode of support for iris action CapPTZObjTracking - Capability to perform objekt-tracking CapPTZPan - Capability to perform pan action CapPTZPresetNumber - The maximum number of preset supported by the model. 0 stands for preset incapability CapPTZTilt - mode of support for tilt action CapPTZZoom - Capability to perform zoom action DeviceType - device type (Camera, Video_Server, PTZ, Fisheye) Error - message text of last error Errorcode - error code of last error HomeModeState - HomeMode-state (SVS-version 8.1.0 and above) LastLogEntry - the neweset entry of Surveillance Station Log (only if SVS-device and if attribute pollcaminfoall is set) LastSnapFilename[x] - the filename of the last snapshot or snapshots LastSnapId[x] - the ID of the last snapshot or snapshots LastSnapTime[x] - timestamp of the last snapshot or snapshots (format depends of global attribute "language") LastUpdateTime - date / time the last update of readings by "caminfoall" (format depends of global attribute "language") LiveStreamUrl - the livestream URL if stream is started (is shown if attribute "showStmInfoFull" is set) Patrols - in Synology Surveillance Station predefined patrols (at PTZ-Cameras) PollState - shows the state of automatic polling PresetHome - Name of Home-position (at PTZ-Cameras) Presets - in Synology Surveillance Station predefined Presets (at PTZ-Cameras) Record - if recording is running = Start, if no recording is running = Stop StmKey - current streamkey. it can be used to open livestreams without session id StmKeyUnicst - Uni-cast stream path of the camera. (attribute "showStmInfoFull" has to be set) StmKeymjpegHttp - Mjpeg stream path(over http) of the camera (attribute "showStmInfoFull" has to be set) SVScustomPortHttp - Customized port of Surveillance Station (HTTP) (to get with "svsinfo") SVScustomPortHttps - Customized port of Surveillance Station (HTTPS) (to get with "svsinfo") SVSlicenseNumber - The total number of installed licenses (to get with "svsinfo") SVSuserPriv - The effective rights of the user used for log in (to get with "svsinfo") SVSversion - package version of the installed Surveillance Station (to get with "svsinfo") UsedSpaceMB - used disk space of recordings by Camera VideoFolder - Path to the recorded video compstate - state of compatibility (compares current/simulated SVS-version with Internal COMPATIBILITY)
=end html
=begin html_DE
SSCam
Mit diesem Modul können Operationen von in der Synology Surveillance Station (SVS) definierten Kameras und Funktionen
der SVS ausgeführt werden. Es basiert auf der SVS API und unterstützt die SVS ab Version 7.
Start einer Aufnahme und optionaler Versand per Email und/oder Telegram
Stop einer Aufnahme per Befehl bzw. automatisch nach Ablauf einer einstellbaren Dauer
Auslösen von Schnappschnüssen / Aufnahmen und optional gemeinsamer Email-Versand mit dem integrierten Email-Client oder Synology Chat / Telegram
Auslösen von Schnappschnüssen aller definierten Kameras und optionaler gemeinsamer Email-Versand mittels integrierten Email-Client
Deaktivieren einer Kamera in Synology Surveillance Station
Aktivieren einer Kamera in Synology Surveillance Station
Steuerung der Belichtungsmodi Tag, Nacht bzw. Automatisch
Umschaltung der Ereigniserkennung durch Kamera, durch SVS oder deaktiviert
steuern der Erkennungsparameterwerte Empfindlichkeit, Schwellwert, Objektgröße und Prozentsatz für Auslösung
Abfrage von Kameraeigenschaften (auch mit Polling) sowie den Eigenschaften des installierten SVS-Paketes
Bewegen an eine vordefinierte Preset-Position (bei PTZ-Kameras)
Start einer vordefinierten Überwachungstour (bei PTZ-Kameras)
Positionieren von PTZ-Kameras zu absoluten X/Y-Koordinaten
kontinuierliche Bewegung von PTZ-Kameras
auslösen externer Ereignisse 1-10 (Aktionsregel SVS)
starten und beenden von Kamera-Livestreams incl. Audiowiedergabe, anzeigen der letzten Aufnahme oder des letzten Schnappschusses
Abruf und Ausgabe der Kamera Streamkeys sowie Stream-Urls (Nutzung von Kamera-Livestreams ohne Session Id)
abspielen der letzten Aufnahme bzw. Anzeige des letzten Schnappschusses
anzeigen der gespeicherten Anmeldeinformationen (Credentials)
Ein- bzw. Ausschalten des Surveillance Station HomeMode und abfragen des HomeMode-Status
abrufen des Surveillance Station Logs, auswerten des neuesten Eintrags als Reading
erzeugen einer Gallerie der letzten 1-10 Schnappschüsse (als Popup oder permanentes Device)
Start bzw. Stop Objekt Tracking (nur unterstützte PTZ-Kameras mit dieser Fähigkeit)
Setzen/Löschen eines Presets (bei PTZ-Kameras)
Setzen der Home-Position (bei PTZ-Kameras)
erstellen eines Paneels zur Kamera-Steuerung. (bei PTZ-Kameras)
erzeugen unterschiedlicher Typen von separaten Streaming-Devices (createStreamDev)
Aktivierung / Deaktivierung eines kamerainternen PIR-Sensors
Erzeugung einer readingsGroup zur Anzeige aller definierten SSCam-Devices (createReadingsGroup)
Automatisiertes Anlegen aller in der SVS vorhandenen Kameras in FHEM (autocreateCams)
lokales Abspeichern der letzten Kamera-Aufnahme
Auswahl unterschiedlicher Cache-Typen zur Bilddatenspeicherung (Attribut cacheType)
ausführen von Zoom-Aktionen (bei PTZ-Kameras die Zoom unterstützen)
49_SSCam: Fragen, Hinweise, Neuigkeiten und mehr rund um dieses Modul .SSCAM - Steuerung von Kameras in Synology Surveillance Station .
Integration in FHEM TabletUI: FTUI Widget für SSCam Streaming Devices (SSCamSTRM) .
Vorbereitung
Dieses Modul nutzt die Perl-Module JSON und MIME::Lite die üblicherweise nachinstalliert werden müssen. sudo apt-get install libjson-perl sudo apt-get install libmime-lite-perl Credentials
JSON Data::Dumper MIME::Base64 Time::HiRes Encode POSIX HttpUtils (FHEM-Modul) Blocking (FHEM-Modul) Meta (FHEM-Modul) Net::SMTP (wenn Bilddaten-Versand verwendet) MIME::Lite (wenn Bilddaten-Versand verwendet) CHI (wenn Cache verwendet wird) CHI::Driver::Redis (wenn Cache verwendet wird) Cache::Cache (wenn Cache verwendet wird)
iconPath um sscam zu ergänzen.
Beispiel
Definition
Kamera wird definiert mit:
define <Name> SSCAM <Kameraname in SVS> <ServerAddr> [Port] [Protocol]
Zunächst muß diese Kamera in der Synology Surveillance Station 7.0 oder höher eingebunden sein und entsprechend
funktionieren. SVS-Device zur Steuerung von Funktionen der Surveillance Station wird definiert mit:
define <Name> SSCAM SVS <ServerAddr> [Port] [Protocol]
In diesem Fall wird statt <Kameraname in SVS> nur SVS angegeben.
Ist das SVS-Device definiert und nach dem Setzen der Credentials einsatzbereit, können alle in der SVS vorhandenen Kameras mit dem Set-Befehl
"autocreateCams" in FHEM automatisiert angelegt werden.
Name der Name des neuen Gerätes in FHEM Kameraname Kameraname wie er in der Synology Surveillance Station angegeben ist für Kamera-Device, "SVS" für SVS-Device. Leerzeichen im Namen sind nicht erlaubt. ServerAddr die IP-Addresse des Synology Surveillance Station Host. Hinweis: Es sollte kein Servername verwendet werden weil DNS-Aufrufe in FHEM blockierend sind. Port optional - der Port der Synology Disc Station. Wenn nicht angegeben, wird der Default-Port "5000" genutzt Protocol optional - das Protokoll (http oder https) zum Funktionsaufruf. Wenn nicht angegeben, wird der Default "http" genutzt
Beispiel:
define CamCP SSCAM Carport 192.168.2.20 [5000] [http]
define CamCP SSCAM Carport 192.168.2.20 [5001] [https]
# erstellt ein neues Kamera-Device CamCP
define DS1 SSCAM SVS 192.168.2.20 [5000] [http]
define DS1 SSCAM SVS 192.168.2.20 [5001] [https]
# erstellt ein neues SVS-Device DS1
Wird eine neue Kamera definiert, wird diesem Device zunächst eine Standardaufnahmedauer von 15 zugewiesen. Attribut "rectime" kann die Aufnahmedauer für jede Kamera individuell angepasst werden. Der Wert "0" für "rectime" führt zu einer Endlosaufnahme, die durch "set <name> off" wieder gestoppt werden muß. Attribut "rectime" gelöscht, greift wieder der Default-Wert (15s) für die Aufnahmedauer. Befehl "set <name> on [rectime]" wird die Aufnahmedauer temporär festgelegt und überschreibt einmalig sowohl den Defaultwert als auch den Wert des gesetzten Attributs "rectime". "set <name> on 0" zu einer Daueraufnahme. Attributen "ptzPanel_.*" beeinflusst werden. Befehl "set <name> createPTZcontrol" .
Credentials
Nach dem Definieren des Gerätes müssen zuerst die Zugangsparameter gespeichert werden. Das geschieht mit dem Befehl:
set <name> credentials <Username> <Passwort>
Die Passwortlänge beträgt maximal 20 Zeichen. 2-Stufen Verifizierung
aktiviert sein, ist die Session mit der Surveillance Station aufzubauen (Attribut "session = SurveillanceStation").
DSM-User als Mitglied der Admin-Gruppe: uneingeschränkter Test aller Modulfunktionen -> session: DSM
SVS-User als Manager oder Betrachter: angepasstes Privilegienprofil -> session: SurveillanceStation
Attribut "session" kann ausgewählt werden, ob die Session mit dem DSM oder der SVS
aufgebaut werden soll. Weitere Informationen zum Usermanagement in der SVS sind verfügbar mit
"get <name> versionNotes 5".Mindestanforderungen der jeweiligen Modulfunktionen an die Nutzerrechte.
set ... credentials - set ... delPreset session: ServeillanceStation - Betrachter set ... disable session: ServeillanceStation - Manager mit dem Kamera bearbeiten Recht set ... enable session: ServeillanceStation - Manager mit dem Kamera bearbeiten Recht set ... expmode session: ServeillanceStation - Manager set ... extevent session: DSM - Nutzer Mitglied von Admin-Gruppe set ... goPreset session: ServeillanceStation - Betrachter mit Privileg Objektivsteuerung der Kamera set ... homeMode session: ServeillanceStation - Betrachter mit Privileg Home-Modus schalten ( gilt für SVS-Device ! ) set ... goAbsPTZ session: ServeillanceStation - Betrachter mit Privileg Objektivsteuerung der Kamera set ... move session: ServeillanceStation - Betrachter mit Privileg Objektivsteuerung der Kamera set ... motdetsc session: ServeillanceStation - Manager set ... on session: ServeillanceStation - Betrachter mit erweiterten Privileg "manuelle Aufnahme" set ... off session: ServeillanceStation - Betrachter mit erweiterten Privileg "manuelle Aufnahme" set ... runView session: ServeillanceStation - Betrachter mit Privileg Liveansicht für Kamera set ... runPatrol session: ServeillanceStation - Betrachter mit Privileg Objektivsteuerung der Kamera set ... setHome session: ServeillanceStation - Betrachter set ... setPreset session: ServeillanceStation - Betrachter set ... snap session: ServeillanceStation - Betrachter set ... snapGallery session: ServeillanceStation - Betrachter set ... stopView - get ... caminfo[all] session: ServeillanceStation - Betrachter get ... eventlist session: ServeillanceStation - Betrachter get ... listLog session: ServeillanceStation - Betrachter get ... listPresets session: ServeillanceStation - Betrachter get ... scanVirgin session: ServeillanceStation - Betrachter get ... svsinfo session: ServeillanceStation - Betrachter get ... snapfileinfo session: ServeillanceStation - Betrachter get ... snapGallery session: ServeillanceStation - Betrachter get ... snapinfo session: ServeillanceStation - Betrachter get ... stmUrlPath session: ServeillanceStation - Betrachter
HTTP-Timeout setzen
Alle Funktionen dieses Moduls verwenden HTTP-Aufrufe gegenüber der SVS Web API. Attributes "httptimeout" > 0 kann dieser Wert bei Bedarf entsprechend den technischen
Gegebenheiten angepasst werden.
Set
autocreateCams (gilt für SVS)
createStreamDev [generic | hls | lastsnap | mjpeg | switched] (gilt für CAM) createStreamDev [master] (gilt für SVS)
generic - das Streaming-Device gibt einen durch das Attribut genericStrmHtmlTag bestimmten Content wieder hls - das Streaming-Device gibt einen permanenten HLS Datenstrom wieder lastsnap - das Streaming-Device zeigt den neuesten Schnappschuß an mjpeg - das Streaming-Device gibt einen permanenten MJPEG Kamerastream wieder (Streamkey Methode) switched - Wiedergabe unterschiedlicher Streamtypen. Drucktasten zur Steuerung werden angeboten. master - mit dem Master Device kann ein anderes definiertes Streaming Device adoptiert und dessen Content angezeigt werden
htmlattr im Kameradevice oder mit den
spezifischen Attributen im Streaming-Device beeinflusst werden. Streaming Device "hls" Attribut "hlsNetScript" kann bestimmt werden, ob
die lokal installierte hls.js (./www/pgm2/sscam_hls.js) oder immer die aktuellste Bibliotheksversion von der hls.js Projektseite
verwendet werden soll. Dieses Attribut ist zentral in einem Device vom Typ "SVS" zu setzen ! Attribut "hlsStrmObject" im verbundenen
Kamera-Device (siehe Internal PARENT) anzugeben.
Streaming Device "switched hls" Streaming Device "generic"
attr <name> genericStrmHtmlTag <video $HTMLATTR controls autoplay>
<source src='http://192.168.2.10:32000/$NAME.m3u8' type='application/x-mpegURL'>
</video>
attr <name> genericStrmHtmlTag <img $HTMLATTR
src="http://192.168.2.10:32774"
onClick="FW_okDialog('<img src=http://192.168.2.10:32774 $PWS >')"
>
Die Variablen $HTMLATTR, $NAME und $PWS sind Platzhalter und übernehmen ein gesetztes Attribut "htmlattr", den SSCam-
Devicenamen bzw. das Attribut "popupWindowSize" im Streaming-Device, welches die Größe eines Popup-Windows festlegt.
Streaming Device "lastsnap" "snapGallerySize = Full" zu setzen.
Dort sollte ebenfalls das Attribut "pollcaminfoall" gesetzt sein, um regelmäßig die neuesten Schnappschußdaten abzurufen.
Streaming Device "master" adopt im Master Streaming Device.
createPTZcontrol (gilt für PTZ-CAM)Attributen bzw. den spezifischen Attributen des erzeugten
SSCamSTRM-Devices können die Eigenschaften des PTZ-Paneels beeinflusst werden.
createReadingsGroup [<Name der readingsGroup>] (gilt für CAM/SVS)
createSnapGallery (gilt für CAM)Attributen bzw. den spezifischen Attributen des erzeugten SSCamSTRM-Devices
können die Eigenschaften der Schnappschußgallerie beeinflusst werden.
Hinweis
credentials <username> <password> (gilt für CAM/SVS)Credentials
delPreset <PresetName> (gilt für PTZ-CAM)
disable (gilt für CAM)
enable (gilt für CAM)
expmode [day|night|auto] (gilt für CAM) Hinweis:
extevent [ 1-10 ] (gilt für SVS)
goAbsPTZ [ X Y | up | down | left | right ] (gilt für CAM)
set <name> goAbsPTZ 120 450
Dieses Beispiel bewegt die Kameralinse in die Position X=120 und Y=450.
X = 0 - 640 (0 - 319 bewegt nach links, 321 - 640 bewegt nach rechts, 320 bewegt die Linse nicht)
Y = 0 - 480 (0 - 239 bewegt nach unten, 241 - 480 bewegt nach oben, 240 bewegt die Linse nicht)
Die Linse kann damit in kleinsten bis sehr großen Schritten in die gewünschte Richtung bewegt werden.
Dieser Vorgang muß ggf. mehrfach wiederholt werden um die Kameralinse in die gewünschte Position zu bringen.
set <name> goAbsPTZ [up|down|left|right]
verwendet werden. Die Optik wird in diesem Fall mit der größt möglichen Schrittweite zur Absolutposition in der angegebenen Richtung bewegt.
Auch in diesem Fall muß der Vorgang ggf. mehrfach wiederholt werden um die Kameralinse in die gewünschte Position zu bringen.
goPreset <Preset> (gilt für CAM)
define CamFL.Preset.Wandschrank notify MelderTER:on.* set CamFL goPreset Wandschrank, ;; define CamFL.Preset.record at +00:00:10 set CamFL on 5 ;;;; define s3 at +*{3}00:00:05 set CamFL snap ;; define CamFL.Preset.back at +00:00:30 set CamFL goPreset Home
Funktionsweise:
2016.02.04 15:02:14 2: CamFL - Camera Flur_Vorderhaus has moved to position "Wandschrank"
2016.02.04 15:02:24 2: CamFL - Camera Flur_Vorderhaus Recording with Recordtime 5s started
2016.02.04 15:02:29 2: CamFL - Snapshot of Camera Flur_Vorderhaus has been done successfully
2016.02.04 15:02:30 2: CamFL - Camera Flur_Vorderhaus Recording stopped
2016.02.04 15:02:34 2: CamFL - Snapshot of Camera Flur_Vorderhaus has been done successfully
2016.02.04 15:02:39 2: CamFL - Snapshot of Camera Flur_Vorderhaus has been done successfully
2016.02.04 15:02:44 2: CamFL - Camera Flur_Vorderhaus has moved to position "Home"
homeMode [on|off] (gilt für SVS)Synology Onlinehilfe
enthalten.
motdetsc [camera|SVS|disable] (gilt für CAM)
set <name> motdetsc SVS [Empfindlichkeit] [Schwellwert] # Befehlsmuster set <name> motdetsc SVS 91 30 # setzt die Empfindlichkeit auf 91 und den Schwellwert auf 30 set <name> motdetsc SVS 0 40 # behält gesetzten Wert für Empfindlichkeit bei, setzt Schwellwert auf 40 set <name> motdetsc SVS 15 # setzt die Empfindlichkeit auf 15, Schwellwert bleibt unverändert
set <name> motdetsc camera [Empfindlichkeit] [Schwellwert] [Prozentsatz] # Befehlsmuster set <name> motdetsc camera 89 0 20 # setzt die Empfindlichkeit auf 89, Prozentsatz auf 20 set <name> motdetsc camera 0 40 10 # behält gesetzten Wert für Empfindlichkeit bei, setzt Schwellwert auf 40, Prozentsatz auf 10 set <name> motdetsc camera 30 # setzt die Empfindlichkeit auf 30, andere Werte bleiben unverändert
Reading "CamMotDetSc" aktualisiert welches die gegenwärtige Einstellung der Bewegungserkennung dokumentiert.
Es werden nur die Parameter und Parameterwerte angezeigt, welche die SVS aktiv unterstützt. Die Kamera selbst kann weiterführende Einstellmöglichkeiten besitzen.
CamMotDetSc SVS, sensitivity: 76, threshold: 55
move [ right | up | down | left | dir_X ] [Sekunden] (gilt für CAM bis SVS Version 7.1) move [ right | upright | up | upleft | left | downleft | down | downright ] [Sekunden] (gilt für CAM ab SVS Version 7.2) Beispiele:
set <name> move up 0.5 : bewegt PTZ 0,5 Sek. (zzgl. Prozesszeit) nach oben
set <name> move dir_1 1.5 : bewegt PTZ 1,5 Sek. (zzgl. Prozesszeit) nach rechts-oben
set <name> move dir_20 0.7 : bewegt PTZ 1,5 Sek. (zzgl. Prozesszeit) nach links-unten ("CapPTZDirections = 32)"
off (gilt für CAM)
on [<rectime>]
(gilt für CAM)Attribut "recextend = 0" bzw. nicht gesetzt (Standard):
Wird eine Aufnahme mit z.B. rectime=22 gestartet, wird kein weiterer Startbefehl für eine Aufnahme akzeptiert bis diese gestartete Aufnahme nach 22 Sekunden
beendet ist. Ein Hinweis wird bei verbose=3 im Logfile protokolliert.
Attribut "recextend = 1" gesetzt:
Eine zuvor gestartete Aufnahme wird bei einem erneuten "set on" -Befehl um die Aufnahmezeit "rectime" verlängert. Das bedeutet, dass der Timer für
den automatischen Stop auf den Wert "rectime" neu gesetzt wird. Dieser Vorgang wiederholt sich mit jedem Start-Befehl. Dadurch verlängert sich eine laufende
Aufnahme bis kein Start-Inpuls mehr registriert wird.
eine zuvor gestartete Endlos-Aufnahme wird mit einem erneuten "set on"-Befehl nach der Aufnahmezeit "rectime" gestoppt (Timerneustart). Ist dies
nicht gewünscht, ist darauf zu achten dass bei der Verwendung einer Endlos-Aufnahme das Attribut "recextend" nicht verwendet wird.
Synology Chat Versand der Aufnahme kann durch Setzen des recChatTxt Attributs permanent aktiviert
werden. Das zu verwendende SSChatBot-Device muss natürlich
funktionstüchtig eingerichtet sein. Email-Versand der letzten Aufnahme kann durch Setzen des Attributs "recEmailTxt"
aktiviert werden. Zuvor ist der Email-Versand, wie im Abschnitt Einstellung Email-Versand beschrieben,
einzustellen. (Für weitere Informationen "get <name> versionNotes 7 " ausführen) Telegram-Versand der letzten Aufnahme kann durch Setzen des Attributs "recTelegramTxt" permanent aktiviert
werden. Das zu verwendende TelegramBot-Device muss natürlich
funktionstüchtig eingerichtet sein. Beispiele : set <name> on [rectime] Attribut "rectime" angegeben) set <name> on 0 set <name> on recEmailTxt:"subject => Neue Aufnahme $CAM, body => Die aktuelle Aufnahme von $CAM ist angehängt." set <name> on recTelegramTxt:"tbot => teleBot, peers => @xxxx , subject => Bewegungsalarm bei $CAM. Es wurde $CTIME die Aufnahme $FILE erstellt" set <name> on recChatTxt:"chatbot => SynChatBot, peers => , subject => Bewegungsalarm bei $CAM. Es wurde $CTIME die Aufnahme $FILE erstellt. Jetzt ist es $TIME."
optimizeParams [mirror:<value>] [flip:<value>] [rotate:<value>] [ntp:<value>] (gilt für CAM)
mirror, flip, rotate: true | false
ntp: der Name oder die IP-Adresse des Zeitservers
Beispiele: set <name> optimizeParams mirror:true flip:true ntp:time.windows.com set <name> optimizeParams ntp:Surveillance%20Station set <name> optimizeParams mirror:true flip:false rotate:true
pirSensor [activate | deactivate] (gilt für CAM)
runPatrol <Patrolname> (gilt für CAM)
runView [live_fw | live_fw_hls | live_link | live_open [<room>] | lastrec_fw | lastrec_fw_MJPEG | lastrec_fw_MPEG4/H.264 | lastrec_open [<room>] | lastsnap_fw] (gilt für CAM)
live_fw - MJPEG-LiveStream. Audiowiedergabe wird mit angeboten wenn verfügbar. live_fw_hls - HLS-LiveStream (aktuell nur Mac Safari und mobile iOS/Android-Geräte) live_link - Link zu einem MJPEG-Livestream live_open [<room>] - öffnet MJPEG-Stream in separatem Browser-Fenster lastrec_fw - letzte Aufnahme als iFrame Objekt lastrec_fw_MJPEG - nutzbar wenn Aufnahme im Format MJPEG vorliegt lastrec_fw_MPEG4/H.264 - nutzbar wenn Aufnahme im Format MPEG4/H.264 vorliegt lastrec_open [<room>] - letzte Aufnahme wird in separatem Browser-Fenster geöffnet lastsnap_fw - letzter Schnappschuss wird dargestellt
"live_fw, live_link, live_open" wird ein MJPEG-Livestream, entweder als eingebettetes Image
oder als generierter Link, gestartet. "live_open" öffnet ein separates Browserfenster mit dem MJPEG-Livestream. Wird dabei optional der Raum mit
angegeben, wird das Browserfenster nur dann gestartet, wenn dieser Raum aktuell im Browser geöffnet ist. "live_fw_hls" ein HLS-Stream verwendet werden, muss die Kamera in der Synology Surveillance Station auf
das Videoformat H.264 (nicht MJPEG) eingestellt und HLS durch die eingesetzte SVS-Version unterstützt sein.
Diese Möglichkeit wird deshalb nur dann angeboten wenn das Reading "CamStreamFormat" den Wert "HLS" hat.
"lastrec_fw.*" bzw. "lastrec_open" erfolgen.
Bei Verwendung von "lastrec_fw.*" wird die letzte Aufnahme als eingebettetes iFrame-Objekt abgespielt. Es werden entsprechende
Steuerungselemente zur Wiedergabegeschwindigkeit usw. angeboten wenn verfügbar. "set <name> runView lastsnap_fw" zeigt den letzten Schnappschuss der Kamera eingebettet an. "lastrec_open" erfolgt die gleiche Einschränkung wie bei "live_open". Attribut "htmlattr" beeinflusst werden.
Beispiel:
attr <name> htmlattr width="500" height="375"
attr <name> htmlattr width="500" height="375" top="200" left="300"
Wird der Stream als live_fw gestartet, ändert sich die Größe entsprechend der Angaben von Width und Hight. "set <name> runView live_open" startet den Livestreamlink sofort in einem neuen
Browserfenster.
Dabei wird für jede aktive FHEMWEB-Session eine Fensteröffnung initiiert. Soll dieses Verhalten geändert werden, kann
"set <name> runView live_open <room>" verwendet werden um das Öffnen des Browserfensters in einem
beliebigen, in einer FHEMWEB-Session aktiven Raum "<room>", zu initiieren.Attribut "livestreamprefix" überschreibt im Reading "LiveStreamUrl"
die Angaben für Protokoll, Servername und Port. Damit kann z.B. die LiveStreamUrl für den Versand und externen Zugriff
auf die SVS modifiziert werden. Beispiel:
attr <name> livestreamprefix https://<Servername>:<Port>
Der Livestream wird über das Kommando "set <name> stopView" wieder beendet.
Start Recording - startet eine Endlosaufnahme Stop Recording - stoppt eine Aufnahme Take Snapshot - löst einen Schnappschuß aus Switch off - stoppt eine laufende Wiedergabe
Hinweis zu HLS (HTTP Live Streaming): Hinweis zu MJPEG:
setHome <PresetName> (gilt für PTZ-CAM)
setPreset <PresetNummer> [<PresetName>] [<Speed>] (gilt für PTZ-CAM)
setZoom < .++ | + | stop | - | --. > (gilt für PTZ-CAM)
smtpcredentials <user> <password> (gilt für CAM)
snap [<Anzahl>] [<Zeitabstand>] (gilt für CAM)Attribut "snapReadingRotate"
verwendet werden.
Synology Chat Versand der Schnappschüsse kann durch Setzen des Attributs snapChatTxt permanent aktiviert
werden. Das zu verwendende SSChatBot-Device muss natürlich
funktionstüchtig eingerichtet sein. videofolderMap zu setzen. Es muß eine URL zum
root-Verzeichnis der Aufnahmen und Schnappschüssen enthalten ( z.B. http://server.mein:8081/surveillance ). Email-Versand der Schnappschüsse kann durch Setzen des Attributs snapEmailTxt permanent aktiviert
werden. Zuvor ist der Email-Versand, wie im Abschnitt Einstellung Email-Versand beschrieben,
einzustellen. (Für weitere Informationen "get <name> versionNotes 7 " ausführen) Telegram-Versand der Schnappschüsse kann durch Setzen des Attributs snapTelegramTxt permanent aktiviert
werden. Das zu verwendende TelegramBot-Device muss natürlich
funktionstüchtig eingerichtet sein. Beispiele:
set <name> snap
set <name> snap 4
set <name> snap 3 3 snapEmailTxt:"subject => Bewegungsalarm $CAM, body => Eine Bewegung wurde am Carport registriert"
set <name> snap 2 snapTelegramTxt:"tbot => teleBot, peers => , subject => Bewegungsalarm bei $CAM. Es wurde $CTIME der Schnappschuss $FILE erstellt"
set <name> snap 2 snapChatTxt:"chatbot => SynChatBot , peers => Frodo Sam, subject => Bewegungsalarm bei $CAM. Es wurde $CTIME der Schnappschuss $FILE erstellt. Jetzt ist es: $TIME."
snapCams [<Anzahl>] [<Zeitabstand>] [CAM:"<Kamera>, <Kamera>, ..."] (gilt für SVS)Email-Versand der Schnappschüsse kann durch Setzen des Attributs "snapEmailTxt" im
SVS-Device UND in den Kamera-Devices, deren Schnappschüsse versendet werden sollen, aktiviert werden.
Bei Kamera-Devices die kein Attribut "snapEmailTxt" gesetzt haben, werden die Schnappschüsse ausgelöst, aber nicht versendet.
Zuvor ist der Email-Versand, wie im Abschnitt Einstellung Email-Versand beschrieben,
einzustellen. (Für weitere Informationen "get <name> versionNotes 7 " ausführen) Beispiele:
set <name> snapCams 4
set <name> snapCams 3 3 CAM:"CamHE1, CamCarport"
snapGallery [1-10] (gilt für CAM)"get <name> snapGallery" . Abweichend von "get" wird mit Attribut
Attribut "snapGalleryBoost=1" kein Popup erzeugt, sondern die Schnappschußgalerie als Browserseite
dargestellt. Alle weiteren Funktionen und Attribute entsprechen dem "get <name> snapGallery" Kommando. "get <name> snapGallery" Kommando anstatt "set" verwendet werden.
Hinweis
startTracking (gilt für CAM mit Tracking Fähigkeit)
stopTracking (gilt für CAM mit Tracking Fähigkeit)
Get
caminfoall (gilt für CAM/SVS) caminfo (gilt für CAM)
eventlist (gilt für CAM)Reading "CamEventNum" und "CamLastRec"
aktualisiert, welches die Gesamtanzahl der registrierten Kameraevents und den Pfad / Namen der letzten Aufnahme enthält.
Dieser Befehl wird implizit mit "get <name> caminfoall" ausgeführt. Attribut "videofolderMap" kann der Inhalt des Readings "VideoFolder" überschrieben werden.
Dies kann von Vortel sein wenn das Surveillance-Verzeichnis der SVS an dem lokalen PC unter anderem Pfadnamen gemountet ist
und darüber der Zugriff auf die Aufnahmen erfolgen soll (z.B. Verwendung bei Email-Versand).
define CamHE1.snap.email DOIF ([CamHE1:"LastSnapFilename"])
({DebianMailnbl ('Recipient@Domain','Bewegungsalarm CamHE1','Eine Bewegung wurde an der Haustür registriert. Aufnahmelink: \
\[CamHE1:VideoFolder]\[CamHE1:CamLastRec]','/media/sf_surveillance/@Snapshot/[CamHE1:LastSnapFilename]')})
homeModeState (gilt für SVS)
listLog [severity:<Loglevel>] [limit:<Zeilenzahl>] [match:<Suchstring>] (gilt für SVS)
<Loglevel> - Information, Warning oder Error. Nur Sätze mit dem Schweregrad werden abgerufen (default: alle)
<Zeilenzahl> - die angegebene Anzahl der Logzeilen (neueste) wird abgerufen (default: alle)
<Suchstring> - nur Logeinträge mit dem angegeben String werden abgerufen (Achtung: kein Regex, der Suchstring wird im Call an die SVS mitgegeben)
Beispiele
get <name> listLog severity:Error limit:5 get <name> listLog severity:Information match:Carport get <name> listLog severity:Warning
Wurde mit dem Attribut "pollcaminfoall" das Polling der SVS aktiviert, wird das Reading
"LastLogEntry" erstellt. Synology Online-Hlfe .
listPresets (gilt für PTZ-CAM)
saveRecording [<Pfad>] (gilt für CAM)
Beispiel:
scanVirgin (gilt für CAM/SVS)
snapGallery [1-10] (gilt für CAM)Attribut "snapGalleryBoost" gesetzt,
werden die letzten Schnappschüsse (default 3) über Polling abgefragt und im Speicher gehalten. Das Verfahren hilft die Ausgabe zu beschleunigen,
kann aber möglicherweise nicht den letzten Schnappschuß anzeigen, falls dieser NICHT über das Modul ausgelöst wurde. Attribute :
snapGalleryBoost
snapGalleryColumns
snapGalleryHtmlAttr
snapGalleryNumber
snapGallerySize
Hinweis:
snapfileinfo (gilt für CAM)"get <name> snap"
ausgeführt.
snapinfo (gilt für CAM)
stmUrlPath (gilt für CAM)Attribut "showStmInfoFull" gesetzt ist, werden zusaätzliche Stream-Informationen wie "StmKeyUnicst", "StmKeymjpegHttp" ausgegeben.
Diese Readings enthalten die gültigen Stream-Pfade zu einem Livestream und können z.B. versendet und von einer entsprechenden Anwendung ohne session Id geöffnet werden.
Wenn das Attribut "livestreamprefix" (Format: "http(s)://<hostname><port>) gesetzt ist, wird der Servername und Port überschrieben soweit es sinnvoll ist.
Wird Polling der Kameraeigenschaften genutzt, wird die stmUrlPath-Funktion automatisch mit ausgeführt.
http(s)://<hostname><port>/webapi/entry.cgi?api=SYNO.SurveillanceStation.VideoStreaming&version=1&method=Stream&format=mjpeg&cameraId=5&StmKey="31fd87279976d89bb98409728cced890"
cameraId (Internal CAMID), StmKey müssen durch gültige Werte ersetzt werden. Hinweis:
storedCredentials (gilt für CAM/SVS)
svsinfo (gilt für CAM/SVS)
versionNotes [hints | rel | <key>] (gilt für CAM/SVS)
Einstellung Email-Versand
Schnappschüsse und Aufnahmen können nach der Erstellung per Email versendet werden. Dazu enthält das
Modul einen eigenen Email-Client.
Zur Verwendung dieser Funktion muss das Perl-Modul MIME::Lite installiert sein. Auf Debian-Systemen kann
es mit
sudo apt-get install libmime-lite-perl
"set <name> smtpcredentials <user> <password>"
hinterlegt werden. Der Verbindungsaufbau zum Postausgangsserver erfolgt initial unverschüsselt und wechselt zu einer verschlüsselten
Verbindung wenn SSL zur Verfügung steht. In diesem Fall erfolgt auch die Übermittlung von User/Password verschlüsselt.
Ist das Attribut smtpSSLPort definiert, erfolgt der Verbindungsaufbau zum Email-Server sofort verschlüsselt.
snapEmailTxt - Aktiviert den Email-Versand von Schnappschüssen .
Das Attribut hat das Format:
subject => <Betreff-Text>, body => <Mitteilung-Text>
Es können die Platzhalter $CAM, $DATE und $TIME verwendet werden. recEmailTxt - Aktiviert den Email-Versand von Aufnahmen .
Das Attribut hat das Format:
subject => <Betreff-Text>, body => <Mitteilung-Text>
Es können die Platzhalter $CAM, $DATE und $TIME verwendet werden. smtpHost - Hostname oder IP-Adresse des Postausgangsservers (z.B. securesmtp.t-online.de) smtpFrom - Absenderadresse (<name>@<domain>) smtpTo - Empfängeradresse(n) (<name>@<domain>) smtpPort - (optional) Port des Postausgangsservers (default: 25) smtpCc - (optional) Carbon-Copy Empfängeradresse(n) (<name>@<domain>) smtpNoUseSSL - (optional) "1" wenn kein SSL beim Email-Versand verwendet werden soll (default: 0) smtpSSLPort - (optional) SSL-Port des Postausgangsservers (default: 465) smtpDebug - (optional) zum Debugging der SMTP-Verbindung setzen
Attribute .
$CAM - Device-Alias bzw. den Namen der Kamera in der SVS ersetzt falls der Device-Alias nicht vorhanden ist $DATE - aktuelles Datum $TIME - aktuelle Zeit $FILE - Filename des Schnappschusses $CTIME - Erstellungszeit des Schnappschusses
Polling der Kamera/SVS-Eigenschaften:
Die Abfrage der Kameraeigenschaften erfolgt automatisch, wenn das Attribut pollcaminfoall mit einem Wert > 10 gesetzt wird. pollcaminfoall nicht gesetzt und das automatische Polling nicht aktiv. pollcaminfoall wird durch einen Watchdog-Timer überwacht. Änderungen des Attributwertes werden alle 90 Sekunden ausgewertet und entsprechend umgesetzt. pollnologging=1 abgeschaltet werden.
PollState = Active - automatisches Polling wird mit Intervall entsprechend "pollcaminfoall" ausgeführt PollState = Inactive - automatisches Polling wird nicht ausgeführt
Readings beschrieben. Hinweise: httptimeout ) von 4 Sekunden kann die theoretische Verarbeitungszeit nicht höher als 80 Sekunden betragen.
Internals
Die Bedeutung der verwendeten Internals stellt die nachfolgende Liste dar:
CAMID - die ID der Kamera in der SVS, der Wert wird automatisch anhand des SVS-Kameranamens ermittelt. CAMNAME - der Name der Kamera in der SVS COMPATIBILITY - Information bis zu welcher SVS-Version das Modul kompatibel bzw. zur Zeit getestet ist (siehe Reading "compstate")CREDENTIALS - der Wert ist "Set" wenn die Credentials gesetzt wurden MODEL - Unterscheidung von Kamera-Device (Hersteller - Kameratyp) und Surveillance Station Device (SVS) NAME - der Kameraname in FHEM OPMODE - die zuletzt ausgeführte Operation des Moduls SERVERADDR - IP-Adresse des SVS Hostes SERVERPORT - der SVS-Port
Attribute
httptimeout hlsNetScript (setzbar in Device Model "SVS") hlsStrmObject
Beispiele:
htmlattr
Beispiel:
livestreamprefix
DEF : es wird Protokoll, Servername und Port aus der Definition
des SSCam-Devices verwendet http(s)://<servername>:<port> : eine eigene Adressenangabe wird verwendet
loginRetries noQuotesForSID pollcaminfoall pollnologging ptzNoCapPrePat ptzPanel_Home ptzPanel_iconPath ptzPanel_iconPrefix ptzPanel_row[00-09] <command>:<icon>,<command>:<icon>,... Hinweis
Beispiel:
ptzPanel_use recChatTxt chatbot => <SSChatBot-Device>, peers => [<peer1 peer2 ...>], subject => [<Betreff-Text>] videofolderMap zu setzen. Es muß eine URL zum
root-Verzeichnis der Aufnahmen und Schnappschüsse enthalten ( z.B. http://server.mein:8081/surveillance ). SSChatBot-Device muss natürlich vorhanden und funktionstüchtig sein.
$CAM - Device-Alias bzw. den Namen der Kamera in der SVS ersetzt falls der Device-Alias nicht vorhanden ist $DATE - aktuelles Datum $TIME - aktuelle Zeit $FILE - Filename $CTIME - Erstellungszeit der Aufnahme
Beispiele: recEmailTxt subject => <Betreff-Text>, body => <Mitteilung-Text>
$CAM - Device-Alias bzw. der Name der Kamera in der SVS falls der Device-Alias nicht vorhanden ist $DATE - aktuelles Datum $TIME - aktuelle Zeit
Beispiel:
recTelegramTxt tbot => <TelegramBot-Device>, peers => [<peer1 peer2 ...>], subject => [<Betreff-Text>] TelegramBot-Device muss natürlich vorhanden und funktionstüchtig sein.
$CAM - Device-Alias bzw. den Namen der Kamera in der SVS ersetzt falls der Device-Alias nicht vorhanden ist $DATE - aktuelles Datum $TIME - aktuelle Zeit $FILE - Filename $CTIME - Erstellungszeit der Aufnahme
Beispiele: rectime recextend session simu_SVSversion smtpHost <Hostname> smtpCc <name>@<domain>[, <name>@<domain>][, <name>@<domain>]... smtpDebug smtpFrom <name>@<domain> smtpPort <Port> smtpSSLPort <Port> smtpTo <name>@<domain>[, <name>@<domain>][, <name>@<domain>]... smtpNoUseSSL snapChatTxt chatbot => <SSChatBot-Device>, peers => [<peer1 peer2 ...>], subject => [<Betreff-Text>] videofolderMap zu setzen. Es muß eine URL zum
root-Verzeichnis der Aufnahmen und Schnappschüsse enthalten ( z.B. http://server.mein:8081/surveillance ). SSChatBot-Device muss natürlich vorhanden und funktionstüchtig sein.
$CAM - Device-Alias bzw. den Namen der Kamera in der SVS ersetzt falls der Device-Alias nicht vorhanden ist $DATE - aktuelles Datum $TIME - aktuelle Zeit $FILE - Filename des Schnappschusses $CTIME - Erstellungszeit des Schnappschusses
Beispiele: snapEmailTxt subject => <Betreff-Text>, body => <Mitteilung-Text>
$CAM - Device-Alias bzw. der Name der Kamera in der SVS falls der Device-Alias nicht vorhanden ist $DATE - aktuelles Datum $TIME - aktuelle Zeit
Beispiel:
snapTelegramTxt tbot => <TelegramBot-Device>, peers => [<peer1 peer2 ...>], subject => [<Betreff-Text>] TelegramBot-Device muss natürlich vorhanden und funktionstüchtig sein.
$CAM - Device-Alias bzw. den Namen der Kamera in der SVS ersetzt falls der Device-Alias nicht vorhanden ist $DATE - aktuelles Datum $TIME - aktuelle Zeit $FILE - Filename des Schnappschusses $CTIME - Erstellungszeit des Schnappschusses
Beispiele: snapGalleryBoost snapGalleryColumns snapGalleryHtmlAttr
Beispiel:
snapGalleryNumber snapGallerySize snapReadingRotate 0...10 showStmInfoFull showPassInLog videofolderMap verbose
Es werden verschiedene Verbose-Level unterstützt.
Dies sind im Einzelnen:
0 - Start/Stop-Ereignisse werden geloggt 1 - Fehlermeldungen werden geloggt 2 - Meldungen über wichtige Ereignisse oder Alarme 3 - gesendete Kommandos werden geloggt 4 - gesendete und empfangene Daten werden geloggt 5 - alle Ausgaben zur Fehleranalyse werden geloggt. ACHTUNG: möglicherweise werden sehr viele Daten in das Logfile geschrieben!
readingFnAttributes
Readings
CamAudioType - listet den eingestellten Audiocodec auf wenn verwendet Availability - Verfügbarkeit der Kamera (disabled, enabled, disconnected, other) CamEventNum - liefert die Gesamtanzahl der in SVS registrierten Events der Kamera CamExposureControl - zeigt den aktuell eingestellten Typ der Belichtungssteuerung CamExposureMode - aktueller Belichtungsmodus (Day, Night, Auto, Schedule, Unknown) CamForceEnableMulticast - sagt aus ob die Kamera verpflichet ist Multicast einzuschalten. CamIP - IP-Adresse der Kamera CamLastRec - Pfad / Name der letzten Aufnahme CamLastRecId - die ID der letzten Aufnahme CamLastRecTime - Datum / Startzeit - Stopzeit der letzten Aufnahme (Format abhängig vom global Attribut "language") CamLiveFps - Frames pro Sekunde des Live-Streams CamLiveMode - Quelle für Live-Ansicht (DS, Camera) camLiveQuality - in SVS eingestellte Live-Stream Qualität camLiveResolution - in SVS eingestellte Live-Stream Auflösung camLiveStreamNo - verwendete Stream-Nummer für Live-Stream CamModel - Kameramodell CamMotDetSc - Status der Bewegungserkennung (disabled, durch Kamera, durch SVS) und deren Parameter CamNTPServer - eingestellter Zeitserver CamPort - IP-Port der Kamera CamPreRecTime - Dauer der der Voraufzeichnung in Sekunden (Einstellung in SVS) CamPtSpeed - eingestellter Wert für Schwenken/Neige-Aktionen (Einstellung in SVS) CamRecShare - gemeinsamer Ordner auf der DS für Aufnahmen CamRecVolume - Volume auf der DS für Aufnahmen CamStreamFormat - aktuelles Format des Videostream CamVideoType - listet den eingestellten Videocodec auf CamVendor - Kamerahersteller Bezeichnung CamVideoFlip - Ist das Video gedreht CamVideoMirror - Ist das Video gespiegelt CamVideoRotate - Ist das Video gedreht CapAudioOut - Fähigkeit der Kamera zur Audioausgabe über Surveillance Station (false/true) CapChangeSpeed - Fähigkeit der Kamera verschiedene Bewegungsgeschwindigkeiten auszuführen CapPIR - besitzt die Kamera einen PIR-Sensor CapPTZAbs - Fähigkeit der Kamera für absolute PTZ-Aktionen CapPTZAutoFocus - Fähigkeit der Kamera für Autofokus Aktionen CapPTZDirections - die verfügbaren PTZ-Richtungen der Kamera CapPTZFocus - Art der Kameraunterstützung für Fokussierung CapPTZHome - Unterstützung der Kamera für Home-Position CapPTZIris - Unterstützung der Kamera für Iris-Aktion CapPTZObjTracking - Unterstützung der Kamera für Objekt-Tracking CapPTZPan - Unterstützung der Kamera für Pan-Aktion CapPTZPresetNumber - die maximale Anzahl unterstützter Presets. 0 steht für keine Preset-Unterstützung CapPTZTilt - Unterstützung der Kamera für Tilt-Aktion CapPTZZoom - Unterstützung der Kamera für Zoom-Aktion DeviceType - Kameratyp (Camera, Video_Server, PTZ, Fisheye) Error - Meldungstext des letzten Fehlers Errorcode - Fehlercode des letzten Fehlers HomeModeState - HomeMode-Status (ab SVS-Version 8.1.0) LastLogEntry - der neueste Eintrag des Surveillance Station Logs (nur SVS-Device und wenn Attribut pollcaminfoall gesetzt) LastSnapFilename[x] - der Filename des/der letzten Schnapschüsse LastSnapId[x] - die ID des/der letzten Schnapschüsse LastSnapTime[x] - Zeitstempel des/der letzten Schnapschüsse (Format abhängig vom global Attribut "language") LastUpdateTime - Datum / Zeit der letzten Aktualisierung durch "caminfoall" (Format abhängig vom global Attribut "language") LiveStreamUrl - die LiveStream-Url wenn der Stream gestartet ist. (Attribut "showStmInfoFull" muss gesetzt sein) Patrols - in Surveillance Station voreingestellte Überwachungstouren (bei PTZ-Kameras) PollState - zeigt den Status des automatischen Pollings an PresetHome - Name der Home-Position (bei PTZ-Kameras) Presets - in Surveillance Station voreingestellte Positionen (bei PTZ-Kameras) Record - Aufnahme läuft = Start, keine Aufnahme = Stop StmKey - aktueller StreamKey. Kann zum öffnen eines Livestreams ohne Session Id genutzt werden. StmKeyUnicst - Uni-cast Stream Pfad der Kamera. (Attribut "showStmInfoFull" muss gesetzt sein) StmKeymjpegHttp - Mjpeg Stream Pfad (über http) der Kamera. (Attribut "showStmInfoFull" muss gesetzt sein) SVScustomPortHttp - benutzerdefinierter Port der Surveillance Station (HTTP) im DSM-Anwendungsportal (get mit "svsinfo") SVScustomPortHttps - benutzerdefinierter Port der Surveillance Station (HTTPS) im DSM-Anwendungsportal (get mit "svsinfo") SVSlicenseNumber - die Anzahl der installierten Kameralizenzen (get mit "svsinfo") SVSuserPriv - die effektiven Rechte des verwendeten Users nach dem Login (get mit "svsinfo") SVSversion - die Paketversion der installierten Surveillance Station (get mit "svsinfo") UsedSpaceMB - durch Aufnahmen der Kamera belegter Plattenplatz auf dem Volume VideoFolder - Pfad zu den aufgenommenen Videos compstate - Kompatibilitätsstatus (Vergleich von eingesetzter/simulierter SVS-Version zum Internal COMPATIBILITY)
"
],
"x_fhem_maintainer": [
"DS_Starter"
],
"x_fhem_maintainer_github": [
"nasseeder1"
],
"prereqs": {
"runtime": {
"requires": {
"FHEM": 5.00918799,
"perl": 5.014,
"POSIX": 0,
"JSON": 0,
"Data::Dumper": 0,
"MIME::Base64": 0,
"Time::HiRes": 0,
"GPUtils": 0,
"HttpUtils": 0,
"Blocking": 0,
"Encode": 0
},
"recommends": {
"FHEM::Meta": 0,
"CHI": 0,
"CHI::Driver::Redis": 0,
"Cache::Cache": 0
},
"suggests": {
}
}
},
"resources": {
"x_wiki": {
"web": "https://wiki.fhem.de/wiki/SSCAM_-_Steuerung_von_Kameras_in_Synology_Surveillance_Station",
"title": "SSCAM - Steuerung von Kameras in Synology Surveillance Station"
},
"repository": {
"x_dev": {
"type": "svn",
"url": "https://svn.fhem.de/trac/browser/trunk/fhem/contrib/DS_Starter",
"web": "https://svn.fhem.de/trac/browser/trunk/fhem/contrib/DS_Starter/49_SSCam.pm",
"x_branch": "dev",
"x_filepath": "fhem/contrib/",
"x_raw": "https://svn.fhem.de/fhem/trunk/fhem/contrib/DS_Starter/49_SSCam.pm"
}
}
}
}
=end :application/json;q=META.json
=cut
![](\"$FW_ME/www/images/sscam/black_btn_CAMBLANK.png\"){kind=spacer}
"; # nicht sichtbare Leertaste
my $cmdstop = "cmd=set $d stopView"; # Stream deaktivieren
my $imgstop = "![](\"$FW_ME/www/images/default/remotecontrol/black_btn_POWEROFF3.png\")
";
my $cmdhlsreact = "cmd=set $d hlsreactivate"; # HLS Stream reaktivieren
my $imghlsreact = "![](\"$FW_ME/www/images/default/remotecontrol/black_btn_BACKDroid.png\")
";
my $cmdmjpegrun = "cmd=set $d runView live_fw"; # MJPEG Stream aktivieren
my $imgmjpegrun = "![](\"$FW_ME/www/images/sscam/black_btn_MJPEG.png\")
";
my $cmdhlsrun = "cmd=set $d runView live_fw_hls"; # HLS Stream aktivieren
my $imghlsrun = "![](\"$FW_ME/www/images/sscam/black_btn_HLS.png\")
";
my $cmdlrirun = "cmd=set $d runView lastrec_fw"; # Last Record IFrame
my $imglrirun = "![](\"$FW_ME/www/images/sscam/black_btn_LASTRECIFRAME.png\")
";
my $cmdlh264run = "cmd=set $d runView lastrec_fw_MPEG4/H.264"; # Last Record H.264
my $imglh264run = "![](\"$FW_ME/www/images/sscam/black_btn_LRECH264.png\")
";
my $cmdlmjpegrun = "cmd=set $d runView lastrec_fw_MJPEG"; # Last Record MJPEG
my $imglmjpegrun = "![](\"$FW_ME/www/images/sscam/black_btn_LRECMJPEG.png\")
";
my $cmdlsnaprun = "cmd=set $d runView lastsnap_fw STRM"; # Last SNAP
my $imglsnaprun = "![](\"$FW_ME/www/images/sscam/black_btn_LSNAP.png\")
";
my $cmdrecendless = "cmd=set $d on 0"; # Endlosaufnahme Start
my $imgrecendless = "![](\"$FW_ME/www/images/sscam/black_btn_RECSTART.png\")
";
my $cmdrecstop = "cmd=set $d off"; # Aufnahme Stop
my $imgrecstop = "![](\"$FW_ME/www/images/sscam/black_btn_RECSTOP.png\")
";
my $cmddosnap = "cmd=set $d snap 1 2 STRM"; # Snapshot auslösen mit Kennzeichnung "by STRM-Device"
my $imgdosnap = "![](\"$FW_ME/www/images/sscam/black_btn_DOSNAP.png\")
";
my $attr = AttrVal($d, "htmlattr", " ");
Log3($name, 4, "$name - FWsummaryFn called - FW_wname: $FW_wname, device: $d, room: $room, attributes: $attr");
# Javascript Bibliothek für Tooltips (http://www.walterzorn.de/tooltip/tooltip.htm#download) und Texte
my $calias = $hash->{CAMNAME}; # Alias der Kamera
my $ttjs = "/fhem/pgm2/sscam_tooltip.js";
my ($ttrefresh, $ttrecstart, $ttrecstop, $ttsnap, $ttcmdstop, $tthlsreact, $ttmjpegrun, $tthlsrun, $ttlrrun, $tth264run, $ttlmjpegrun, $ttlsnaprun);
if(AttrVal("global","language","EN") =~ /EN/x) {
$ttrecstart = $ttips_en{"ttrecstart"}; $ttrecstart =~ s/§NAME§/$calias/gx;
$ttrecstop = $ttips_en{"ttrecstop"}; $ttrecstop =~ s/§NAME§/$calias/gx;
$ttsnap = $ttips_en{"ttsnap"}; $ttsnap =~ s/§NAME§/$calias/gx;
$ttcmdstop = $ttips_en{"ttcmdstop"}; $ttcmdstop =~ s/§NAME§/$calias/gx;
$tthlsreact = $ttips_en{"tthlsreact"}; $tthlsreact =~ s/§NAME§/$calias/gx;
} else {
$ttrecstart = $ttips_de{"ttrecstart"}; $ttrecstart =~ s/§NAME§/$calias/gx;
$ttrecstop = $ttips_de{"ttrecstop"}; $ttrecstop =~ s/§NAME§/$calias/gx;
$ttsnap = $ttips_de{"ttsnap"}; $ttsnap =~ s/§NAME§/$calias/gx;
$ttcmdstop = $ttips_de{"ttcmdstop"}; $ttcmdstop =~ s/§NAME§/$calias/gx;
$tthlsreact = $ttips_de{"tthlsreact"}; $tthlsreact =~ s/§NAME§/$calias/gx;
}
$ret .= "";
if($wltype eq "image") {
if(ReadingsVal($name, "SVSversion", "8.2.3-5828") eq "8.2.3-5828" && ReadingsVal($name, "CamVideoType", "") !~ /MJPEG/x) {
$ret .= "![](\"$FW_ME/www/images/default/Restart.png\")
";
# bei Aufruf durch FTUI Kommandosyntax anpassen
if ($ftui) {
$cmddosnap = "ftui.setFhemStatus('set $camname snap 1 2 STRM:$uuid')";
$cmdstop = "ftui.setFhemStatus('set $camname stopView STRM:$uuid')";
$cmdhlsreact = "ftui.setFhemStatus('set $camname hlsreactivate STRM:$uuid')";
$cmdmjpegrun = "ftui.setFhemStatus('set $camname runView live_fw STRM:$uuid')";
$cmdhlsrun = "ftui.setFhemStatus('set $camname runView live_fw_hls STRM:$uuid')";
$cmdlrirun = "ftui.setFhemStatus('set $camname runView lastrec_fw STRM:$uuid')";
$cmdlh264run = "ftui.setFhemStatus('set $camname runView lastrec_fw_MPEG4/H.264 STRM:$uuid')";
$cmdlmjpegrun = "ftui.setFhemStatus('set $camname runView lastrec_fw_MJPEG STRM:$uuid')";
$cmdlsnaprun = "ftui.setFhemStatus('set $camname runView lastsnap_fw STRM STRM:$uuid')";
$cmdrecendless = "ftui.setFhemStatus('set $camname on 0 STRM:$uuid')";
$cmdrecstop = "ftui.setFhemStatus('set $camname off STRM:$uuid')";
$cmdrefresh = "ftui.setFhemStatus('set $camname refresh STRM:$uuid')";
}
# Javascript Bibliothek für Tooltips (http://www.walterzorn.de/tooltip/tooltip.htm#download) und Texte
my $calias = $hash->{CAMNAME}; # Alias der Kamera
my $ttjs = "/fhem/pgm2/sscam_tooltip.js";
my ($ttrefresh, $ttrecstart, $ttrecstop, $ttsnap, $ttcmdstop, $tthlsreact);
my ($ttmjpegrun, $tthlsrun, $ttlrrun, $tth264run, $ttlmjpegrun, $ttlsnaprun);
# Hinweis Popups
if(AttrVal("global","language","EN") =~ /EN/x) {
$ttrefresh = $ttips_en{"ttrefresh"}; $ttrefresh =~ s/§NAME§/$calias/gx;
$ttrecstart = $ttips_en{"ttrecstart"}; $ttrecstart =~ s/§NAME§/$calias/gx;
$ttrecstop = $ttips_en{"ttrecstop"}; $ttrecstop =~ s/§NAME§/$calias/gx;
$ttsnap = $ttips_en{"ttsnap"}; $ttsnap =~ s/§NAME§/$calias/gx;
$ttcmdstop = $ttips_en{"ttcmdstop"}; $ttcmdstop =~ s/§NAME§/$calias/gx;
$tthlsreact = $ttips_en{"tthlsreact"}; $tthlsreact =~ s/§NAME§/$calias/gx;
$ttmjpegrun = $ttips_en{"ttmjpegrun"}; $ttmjpegrun =~ s/§NAME§/$calias/gx;
$tthlsrun = $ttips_en{"tthlsrun"}; $tthlsrun =~ s/§NAME§/$calias/gx;
$ttlrrun = $ttips_en{"ttlrrun"}; $ttlrrun =~ s/§NAME§/$calias/gx;
$tth264run = $ttips_en{"tth264run"}; $tth264run =~ s/§NAME§/$calias/gx;
$ttlmjpegrun = $ttips_en{"ttlmjpegrun"}; $ttlmjpegrun =~ s/§NAME§/$calias/gx;
$ttlsnaprun = $ttips_en{"ttlsnaprun"}; $ttlsnaprun =~ s/§NAME§/$calias/gx;
} else {
$ttrefresh = $ttips_de{"ttrefresh"}; $ttrefresh =~ s/§NAME§/$calias/gx;
$ttrecstart = $ttips_de{"ttrecstart"}; $ttrecstart =~ s/§NAME§/$calias/gx;
$ttrecstop = $ttips_de{"ttrecstop"}; $ttrecstop =~ s/§NAME§/$calias/gx;
$ttsnap = $ttips_de{"ttsnap"}; $ttsnap =~ s/§NAME§/$calias/gx;
$ttcmdstop = $ttips_de{"ttcmdstop"}; $ttcmdstop =~ s/§NAME§/$calias/gx;
$tthlsreact = $ttips_de{"tthlsreact"}; $tthlsreact =~ s/§NAME§/$calias/gx;
$ttmjpegrun = $ttips_de{"ttmjpegrun"}; $ttmjpegrun =~ s/§NAME§/$calias/gx;
$tthlsrun = $ttips_de{"tthlsrun"}; $tthlsrun =~ s/§NAME§/$calias/gx;
$ttlrrun = $ttips_de{"ttlrrun"}; $ttlrrun =~ s/§NAME§/$calias/gx;
$tth264run = $ttips_de{"tth264run"}; $tth264run =~ s/§NAME§/$calias/gx;
$ttlmjpegrun = $ttips_de{"ttlmjpegrun"}; $ttlmjpegrun =~ s/§NAME§/$calias/gx;
$ttlsnaprun = $ttips_de{"ttlsnaprun"}; $ttlsnaprun =~ s/§NAME§/$calias/gx;
}
my $ha = AttrVal($camname, "htmlattr", 'width="500" height="325"'); # HTML Attribute der Cam
$ha = AttrVal($strmdev, "htmlattr", $ha); # htmlattr mit htmlattr Streaming-Device übersteuern
$ha = AttrVal($strmdev, "htmlattrFTUI", $ha) if($ftui); # wenn aus FTUI aufgerufen divers setzen
my $hb = AttrVal($strmdev, "hideButtons", 0); # Drucktasten im Footer ausblenden ?
my $hau = AttrVal($strmdev, "hideAudio", 0); # Audio Steuerblock im Footer ausblenden ?
my $pws = AttrVal($strmdev, "popupWindowSize", ""); # Größe eines Popups
$pws =~ s/"//gx if($pws);
$show = $defs{$streamHash->{PARENT}}->{HELPER}{ACTSTRM} if($streamHash->{MODEL} =~ /switched/x);
$show = $show ? "($show)" : "";
my $alias = AttrVal($strmdev, "alias", $strmdev); # Linktext als Aliasname oder Devicename setzen
my $dlink = "$alias";
$dlink = $alias if(AttrVal($strmdev, "noLink", 0)); # keine Links im Stream-Dev generieren
my $StmKey = ReadingsVal($camname,"StmKey",undef);
my %params = (
camname => $camname,
strmdev => $strmdev,
ftui => $ftui,
uuid => $uuid,
ha => $ha,
hb => $hb,
hau => $hau,
pws => $pws,
serveraddr => $hash->{SERVERADDR},
serverport => $hash->{SERVERPORT},
apivideostm => $hash->{HELPER}{APIVIDEOSTM},
apivideostmpath => $hash->{HELPER}{APIVIDEOSTMPATH},
apivideostmmaxver => $hash->{HELPER}{APIVIDEOSTMMAXVER},
apiaudiostm => $hash->{HELPER}{APIAUDIOSTM},
apiaudiostmpath => $hash->{HELPER}{APIAUDIOSTMPATH},
apiaudiostmmaxver => $hash->{HELPER}{APIAUDIOSTMMAXVER},
apivideostms => $hash->{HELPER}{APIVIDEOSTMS},
apivideostmspath => $hash->{HELPER}{APIVIDEOSTMSPATH},
apivideostmsmaxver => $hash->{HELPER}{APIVIDEOSTMSMAXVER},
camid => $hash->{CAMID},
sid => $hash->{HELPER}{SID},
proto => $hash->{PROTOCOL},
cmdstop => $cmdstop,
cmdhlsreact => $cmdhlsreact,
cmdmjpegrun => $cmdmjpegrun,
cmdhlsrun => $cmdhlsrun,
cmdlrirun => $cmdlrirun,
cmdlh264run => $cmdlh264run,
cmdlmjpegrun => $cmdlmjpegrun,
cmdlsnaprun => $cmdlsnaprun,
cmdrecendless => $cmdrecendless,
cmdrecstop => $cmdrecstop,
cmddosnap => $cmddosnap,
cmdrefresh => $cmdrefresh,
imgblank => $imgblank,
imgstop => $imgstop,
imghlsreact => $imghlsreact,
imgmjpegrun => $imgmjpegrun,
imghlsrun => $imghlsrun,
imglrirun => $imglrirun,
imglh264run => $imglh264run,
imglmjpegrun => $imglmjpegrun,
imglsnaprun => $imglsnaprun,
imgrecendless => $imgrecendless,
imgrecstop => $imgrecstop,
imgdosnap => $imgdosnap,
imgrefresh => $imgrefresh,
ttrefresh => $ttrefresh,
ttrecstart => $ttrecstart,
ttrecstop => $ttrecstop,
ttsnap => $ttsnap,
ttcmdstop => $ttcmdstop,
tthlsreact => $tthlsreact,
ttmjpegrun => $ttmjpegrun,
tthlsrun => $tthlsrun,
ttlrrun => $ttlrrun,
tth264run => $tth264run,
ttlmjpegrun => $ttlmjpegrun,
ttlsnaprun => $ttlsnaprun,
);
$ret = "";
$ret .= "";
$ret .= '
')\">