[Port]";
}
my $camname = $a[2];
my $serveraddr = $a[3];
my $serverport = $a[4] ? $a[4] : 5000;
my $proto = $a[5] ? lc($a[5]) : "http";
$hash->{SERVERADDR} = $serveraddr;
$hash->{SERVERPORT} = $serverport;
$hash->{CAMNAME} = $camname;
$hash->{MODEL} = ($camname =~ m/^SVS$/xi) ? "SVS" : "CAM"; # initial, CAM wird später ersetzt durch CamModel
$hash->{PROTOCOL} = $proto;
$hash->{COMPATIBILITY} = $compstat; # getestete SVS-version Kompatibilität
$hash->{HELPER}{MODMETAABSENT} = 1 if($modMetaAbsent); # Modul Meta.pm nicht vorhanden
# Startwerte setzen
if(IsModelCam($hash)) { # initiale Webkommandos setzen
$attr{$name}{webCmd} = "on:off:snap:enable:disable:runView:stopView";
}
else {
$attr{$name}{webCmd} = "homeMode";
$attr{$name}{webCmdLabel} = "HomeMode";
}
$hash->{HELPER}{ACTIVE} = "off"; # Funktionstoken "off", Funktionen können sofort starten
$hash->{HELPER}{OLDVALPOLLNOLOGGING} = "0"; # Loggingfunktion für Polling ist an
$hash->{HELPER}{OLDVALPOLL} = "0";
$hash->{HELPER}{RECTIME_DEF} = "15"; # Standard für rectime setzen, überschreibbar durch Attribut "rectime" bzw. beim "set .. on-for-time"
$hash->{HELPER}{OLDPTZHOME} = "";
$hash->{".ptzhtml"} = ""; # initial -> es wird ptzpanel neu eingelesen
$hash->{HELPER}{HLSSTREAM} = "inactive"; # Aktivitätsstatus HLS-Streaming
$hash->{HELPER}{SNAPLIMIT} = 0; # abgerufene Anzahl Snaps
$hash->{HELPER}{TOTALCNT} = 0; # totale Anzahl Snaps
my $params = {
hash => $hash,
notes => \%vNotesIntern,
useAPI => 1,
useSMUtils => 1,
useErrCodes => 1
};
use version 0.77; our $VERSION = moduleVersion ($params); # Versionsinformationen setzen
readingsBeginUpdate ($hash );
readingsBulkUpdate ($hash, "PollState", "Inactive"); # es ist keine Gerätepolling aktiv
if(IsModelCam($hash)) {
readingsBulkUpdate ($hash, "Availability", "???"); # Verfügbarkeit ist unbekannt
readingsBulkUpdate ($hash, "state", "off"); # Init für "state" , Problemlösung für setstate, Forum #308
}
else {
readingsBulkUpdate ($hash, "state", "Initialized"); # Init für "state" wenn SVS
}
readingsEndUpdate ($hash,1);
getCredentials ($hash,1, "credentials" ); # Credentials lesen und in RAM laden ($boot=1)
getCredentials ($hash,1, "SMTPcredentials");
# initiale Routinen zufällig verzögert nach Restart ausführen
RemoveInternalTimer ($hash, "FHEM::SSCam::initOnBoot" );
InternalTimer (gettimeofday()+int(rand(30)), "FHEM::SSCam::initOnBoot", $hash, 0);
return;
}
################################################################
# Die Undef-Funktion wird aufgerufen wenn ein Gerät mit delete
# gelöscht wird oder bei der Abarbeitung des Befehls rereadcfg,
# der ebenfalls alle Geräte löscht und danach das
# Konfigurationsfile neu einliest.
# Funktion: typische Aufräumarbeiten wie das
# saubere Schließen von Verbindungen oder das Entfernen von
# internen Timern, sofern diese im Modul zum Pollen verwendet
# wurden.
################################################################
sub Undef {
my $hash = shift;
my $arg = shift;
my $name = $hash->{NAME};
RemoveInternalTimer($hash);
return;
}
#######################################################################################################
# Mit der X_DelayedShutdown Funktion kann eine Definition das Stoppen von FHEM verzögern um asynchron
# hinter sich aufzuräumen.
# Je nach Rückgabewert $delay_needed wird der Stopp von FHEM verzögert (0|1).
# Sobald alle nötigen Maßnahmen erledigt sind, muss der Abschluss mit CancelDelayedShutdown($name) an
# FHEM zurückgemeldet werden.
#######################################################################################################
sub delayedShutdown {
my $hash = shift;
my $name = $hash->{NAME};
$shutdownInProcess = 1; # Statusbit shutdown setzen -> asynchrone Funktionen nicht mehr ausgeführen
Log3($name, 2, "$name - Quit session due to shutdown ...");
__sessionOff($hash);
if($hash->{HELPER}{CACHEKEY}) {
cache($name, "c_destroy");
}
return 1;
}
#################################################################
# Wenn ein Gerät in FHEM gelöscht wird, wird zuerst die Funktion
# X_Undef aufgerufen um offene Verbindungen zu schließen,
# anschließend wird die Funktion X_Delete aufgerufen.
# Funktion: Aufräumen von dauerhaften Daten, welche durch das
# Modul evtl. für dieses Gerät spezifisch erstellt worden sind.
# Es geht hier also eher darum, alle Spuren sowohl im laufenden
# FHEM-Prozess, als auch dauerhafte Daten bspw. im physikalischen
# Gerät zu löschen die mit dieser Gerätedefinition zu tun haben.
#################################################################
sub Delete {
my $hash = shift;
my $arg = shift;
my $index = $hash->{TYPE}."_".$hash->{NAME}."_credentials";
my $name = $hash->{NAME};
setKeyValue ($index, undef); # gespeicherte Credentials löschen
my $sgdev = "SSCam.$hash->{NAME}.snapgallery"; # löschen snapGallerie-Device falls vorhanden
CommandDelete($hash->{CL},"$sgdev");
CommandDelete($hash->{CL},"TYPE=SSCamSTRM:FILTER=PARENT=$name"); # alle zugeordneten Streaming-Devices löschen falls vorhanden
delete $data{SSCam}{$name}; # internen Cache löschen
return;
}
######################################################################################
# Kamera Liveview Anzeige in FHEMWEB
######################################################################################
# wird von FW aufgerufen. $FW_wname = aufrufende Webinstanz, $d = aufrufendes
# Device (z.B. CamCP1)
sub FWsummaryFn {
my ($FW_wname, $d, $room, $pageHash) = @_; # pageHash is set for summaryFn in FHEMWEB
my $hash = $defs{$d};
my $name = $hash->{NAME};
my $link = $hash->{HELPER}{LINK};
my $wltype = $hash->{HELPER}{WLTYPE};
my $ret = "";
my $alias;
return if(!$hash->{HELPER}{LINK} || ReadingsVal($d, "state", "") =~ /^dis/x || IsDisabled($name));
# Definition Tasten
my $imgblank = " 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 $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;
}
else {
$cexpl = $ttips_en{confcam}; $cexpl =~ s/§NAME§/$alias/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;
}
else {
$cexpl = $ttips_en{confsvs}; $cexpl =~ s/§NAME§/$alias/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);
$ret .= "";
$ret .= "";
$ret .= '';
$ret .= "";
$ret .= " $cicon ";
$ret .= " ";
$ret .= " $hicon ";
$ret .= " ";
$ret .= "";
$ret .= ' ';
$ret .= "
";
$ret .= ":";
}
}
if($aVal eq "file") {
if($SScamMMCacheCache) {
return "Perl cache module ".$SScamMMCacheCache." is missing. You need to install it with the FHEM Installer for example.";
}
}
}
if ($aVal ne $type) {
if($hash->{HELPER}{CACHEKEY}) {
cache($name, "c_destroy"); # CHI-Cache löschen/entfernen
}
else {
delete $data{SSCam}{$name}; # internen Cache löschen
}
}
}
else {
if($hash->{HELPER}{CACHEKEY}) {
cache($name, "c_destroy"); # CHI-Cache löschen/entfernen
}
}
}
if ($aName eq "showStmInfoFull") {
if($cmd eq "set") {
$do = ($aVal) ? 1 : 0;
}
$do = 0 if($cmd eq "del");
if ($do == 0) {
delete($defs{$name}{READINGS}{StmKeymjpegHttp});
delete($defs{$name}{READINGS}{LiveStreamUrl});
delete($defs{$name}{READINGS}{StmKeyUnicst});
delete($defs{$name}{READINGS}{StmKeyUnicstOverHttp});
delete($defs{$name}{READINGS}{StmKeymxpegHttp});
}
}
if ($aName eq "snapGallerySize") {
if($cmd eq "set") {
$do = ($aVal eq "Icon")?1:2;
}
$do = 0 if($cmd eq "del");
if ($do == 0) {
delete($hash->{HELPER}{".SNAPHASH"}) if(AttrVal($name,"snapGalleryBoost",0)); # Snaphash nur löschen wenn Snaps gepollt werden
Log3($name, 4, "$name - Snapshot hash deleted");
}
elsif (AttrVal($name,"snapGalleryBoost",0) && $init_done == 1) { # snap-Infos abhängig ermitteln wenn gepollt werden soll
$hash->{HELPER}{GETSNAPGALLERY} = 1;
my $slim = AttrVal($name,"snapGalleryNumber",$defSlim); # Anzahl der abzurufenden Snaps
my $ssize = $do;
RemoveInternalTimer($hash, "FHEM::SSCam::__getSnapInfo" );
InternalTimer (gettimeofday()+0.7, "FHEM::SSCam::__getSnapInfo", "$name:$slim:$ssize", 0);
}
}
if ($aName eq "snapGalleryBoost") {
if($cmd eq "set") {
$do = ($aVal == 1) ? 1 : 0;
}
$do = 0 if($cmd eq "del");
if($do == 0) {
delete($hash->{HELPER}{".SNAPHASH"}); # Snaphash löschen
Log3($name, 4, "$name - Snapshot hash deleted");
}
elsif ($init_done == 1) { # snapgallery regelmäßig neu einlesen wenn Polling ein
return qq{When you want activate "snapGalleryBoost", you have to set the attribute "pollcaminfoall" first because of the functionality depends on retrieving snapshots periodical.}
if(!AttrVal($name,"pollcaminfoall",0));
$hash->{HELPER}{GETSNAPGALLERY} = 1;
my $slim = AttrVal($name, "snapGalleryNumber", $defSlim); # Anzahl der abzurufenden Snaps
my $sg = AttrVal($name, "snapGallerySize", "Icon" ); # Auflösung Image
my $ssize = ($sg eq "Icon") ? 1 : 2;
RemoveInternalTimer ($hash, "FHEM::SSCam::__getSnapInfo" );
InternalTimer (gettimeofday()+0.7, "FHEM::SSCam::__getSnapInfo", "$name:$slim:$ssize", 0);
}
}
if ($aName eq "snapGalleryNumber" && AttrVal($name,"snapGalleryBoost",0)) {
my ($slim,$ssize);
if($cmd eq "set") {
$do = ($aVal != 0) ? 1 : 0;
}
$do = 0 if($cmd eq "del");
if ($do == 0) {
$slim = 3;
}
else {
$slim = $aVal;
}
if($init_done == 1) {
delete($hash->{HELPER}{".SNAPHASH"}); # bestehenden Snaphash löschen
$hash->{HELPER}{GETSNAPGALLERY} = 1;
my $sg = AttrVal($name,"snapGallerySize","Icon"); # Auflösung Image
$ssize = $sg eq "Icon" ? 1 : 2;
RemoveInternalTimer ($hash, "FHEM::SSCam::__getSnapInfo" );
InternalTimer (gettimeofday()+0.7, "FHEM::SSCam::__getSnapInfo", "$name:$slim:$ssize", 0);
}
}
if ($aName eq "snapReadingRotate") {
if($cmd eq "set") {
$do = ($aVal) ? 1 : 0;
}
$do = 0 if($cmd eq "del");
if(!$do) {$aVal = 0}
for my $i (1..10) {
if($i>$aVal) {
readingsDelete($hash, "LastSnapFilename$i" );
readingsDelete($hash, "LastSnapId$i" );
readingsDelete($hash, "LastSnapTime$i" );
}
}
}
if ($aName eq "simu_SVSversion") {
delete $hash->{HELPER}{API}{PARSET};
delete $hash->{HELPER}{SID};
delete $hash->{CAMID};
RemoveInternalTimer ($hash, "FHEM::SSCam::__getCaminfoAll" );
InternalTimer (gettimeofday()+0.5, "FHEM::SSCam::__getCaminfoAll", $hash, 0);
}
if($aName =~ m/pollcaminfoall/ && $init_done == 1) {
RemoveInternalTimer ($hash, "FHEM::SSCam::__getCaminfoAll" );
InternalTimer (gettimeofday()+1.0, "FHEM::SSCam::__getCaminfoAll", $hash, 0);
RemoveInternalTimer ($hash, "FHEM::SSCam::wdpollcaminfo" );
InternalTimer (gettimeofday()+1.5, "FHEM::SSCam::wdpollcaminfo", $hash, 0);
}
if($aName =~ m/pollnologging/ && $init_done == 1) {
RemoveInternalTimer ($hash, "FHEM::SSCam::wdpollcaminfo" );
InternalTimer (gettimeofday()+1.0, "FHEM::SSCam::wdpollcaminfo", $hash, 0);
}
if ($cmd eq "set") {
if ($aName =~ m/httptimeout|snapGalleryColumns|rectime|pollcaminfoall/x) {
unless ($aVal =~ /^\d+$/x) { return " The Value for $aName is not valid. Use only figures 1-9 !";}
}
if($aName =~ m/pollcaminfoall/x) {
return "The value of \"$aName\" has to be greater than 10 seconds." if($aVal <= 10);
}
if($aName =~ m/cacheServerParam/x) {
return "Please provide the Redis server parameters in form: : or unix:" if($aVal !~ /:\d+$|unix:.+$/x);
my $type = AttrVal($name, "cacheType", "internal");
if($hash->{HELPER}{CACHEKEY} && $type eq "redis") {
cache($name, "c_destroy");
}
}
if($aName =~ m/snapChatTxt|recChatTxt/x) {
return "When you want activate \"$aName\", you have to set first the attribute \"videofolderMap\" to the root folder ".
"of recordings and snapshots provided by an URL.\n".
"Example: http://server.domain:8081/surveillance "
if(!AttrVal($name, "videofolderMap", "") && $init_done == 1);
}
}
if ($cmd eq "del") {
if ($aName =~ m/pollcaminfoall/x) {
# Polling nicht ausschalten wenn snapGalleryBoost ein (regelmäßig neu einlesen)
return "Please switch off \"snapGalleryBoost\" first if you want to deactivate \"pollcaminfoall\" because the functionality of \"snapGalleryBoost\" depends on retrieving snapshots periodical."
if(AttrVal($name,"snapGalleryBoost",0));
}
}
return;
}
################################################################
# Set
################################################################
sub Set {
my ($hash, @a) = @_;
return "\"set X\" needs at least an argument" if ( @a < 2 );
my $name = $a[0];
my $opt = $a[1];
my $prop = $a[2];
my $prop1 = $a[3];
my $prop2 = $a[4];
my $prop3 = $a[5];
my $success;
my $setlist;
return if(IsDisabled($name));
if(!$hash->{CREDENTIALS}) {
# initiale setlist für neue Devices
$setlist = "Unknown argument $opt, choose one of ".
"credentials "
;
} elsif(IsModelCam($hash)) {
# selist für Cams
my $hlslfw = IsCapHLS($hash) ? ",live_fw_hls," : ",";
$setlist = "Unknown argument $opt, choose one of ".
"createSnapGallery:noArg ".
"createStreamDev:generic,hls,lastsnap,mjpeg,switched ".
"createReadingsGroup ".
"credentials ".
"disable:noArg ".
"enable:noArg ".
"expmode:auto,day,night ".
"motdetsc:disable,camera,SVS ".
"snap ".
(AttrVal($name, "snapGalleryBoost",0) ? (AttrVal($name,"snapGalleryNumber",undef) || AttrVal($name,"snapGalleryBoost",0)) ? "snapGallery:noArg " : "snapGallery:$defSnum " : " ").
"on ".
"off:noArg ".
"optimizeParams ".
"runView:#,live_fw".$hlslfw."live_link,live_open,lastrec_fw,lastrec_fw_MJPEG,lastrec_fw_MPEG4/H.264,lastrec_open,lastsnap_fw ".
"stopView:noArg ".
"smtpcredentials ".
(IsCapPTZObjTrack($hash) ? "startTracking:noArg " : "").
(IsCapPTZObjTrack($hash) ? "stopTracking:noArg " : "").
(IsCapPTZPan($hash) ? "setPreset ": "").
(IsCapPTZPan($hash) ? "setHome:---currentPosition---,".ReadingsVal("$name","Presets","")." " : "").
(IsCapPTZPan($hash) ? "delPreset:".ReadingsVal("$name","Presets","")." " : "").
(IsCapPTZPan($hash) ? "runPatrol:#,".ReadingsVal("$name", "Patrols", "")." " : "").
(IsCapPTZPan($hash) ? "goPreset:#,".ReadingsVal("$name", "Presets", "")." " : "").
(IsCapPTZ($hash) ? "createPTZcontrol:noArg " : "").
(IsCapPTZAbs($hash) ? "goAbsPTZ"." " : "").
(IsCapPTZDir($hash) ? "move"." " : "").
(IsCapPIR($hash) ? "pirSensor:activate,deactivate " : "").
(IsCapZoom($hash) ? "setZoom:$valZoom " : "").
"";
}
else {
# setlist für SVS Devices
$setlist = "Unknown argument $opt, choose one of ".
"autocreateCams:noArg ".
"credentials ".
"createStreamDev:master ".
"smtpcredentials ".
"createReadingsGroup ".
"extevent:1,2,3,4,5,6,7,8,9,10 ".
($hash->{HELPER}{API}{HMODE}{VER} ? "homeMode:on,off " : "").
"snapCams ";
}
my $params = {
hash => $hash,
name => $name,
opt => $opt,
prop => $prop,
prop1 => $prop1,
prop2 => $prop2,
prop3 => $prop3,
aref => \@a,
};
no strict "refs"; ## no critic 'NoStrict'
if($hset{$opt} && defined &{$hset{$opt}{fn}}) {
my $ret = q{};
if (!$hash->{CREDENTIALS} && $hset{$opt}{needcred}) {
return qq{Credentials of $name are not set. Make sure they are set with "set $name credentials "};
}
$ret = &{$hset{$opt}{fn}} ($params);
return $ret;
}
use strict "refs";
return $setlist;
}
################################################################
# Setter credentials
################################################################
sub _setcredentials { ## no critic "not used"
my $paref = shift;
my $hash = $paref->{hash};
my $prop = $paref->{prop};
my $prop1 = $paref->{prop1};
return "Credentials are incomplete, use username password" if(!$prop || !$prop1);
return "Password is too long. It is limited up to and including 20 characters." if(length $prop1 > 20);
delete $hash->{HELPER}{SID};
my ($success) = setCredentials($hash,"credentials",$prop,$prop1);
$hash->{HELPER}{ACTIVE} = "off";
if($success) {
__getCaminfoAll($hash,0);
versionCheck ($hash);
return "Username and Password saved successfully";
}
else {
return "Error while saving Username / Password - see logfile for details";
}
return;
}
################################################################
# Setter smtpcredentials
################################################################
sub _setsmtpcredentials { ## no critic "not used"
my $paref = shift;
my $hash = $paref->{hash};
my $prop = $paref->{prop};
my $prop1 = $paref->{prop1};
return "Credentials are incomplete, use username password" if (!$prop || !$prop1);
my ($success) = setCredentials($hash,"SMTPcredentials",$prop,$prop1);
if($success) {
return "SMTP-Username and SMTP-Password saved successfully";
}
else {
return "Error while saving SMTP-Username / SMTP-Password - see logfile for details";
}
return;
}
################################################################
# Setter on
################################################################
sub _seton { ## no critic "not used"
my $paref = shift;
my $hash = $paref->{hash};
my $name = $paref->{name};
my $prop = $paref->{prop};
my $aref = $paref->{aref};
return if(!IsModelCam($hash));
if (defined($prop) && $prop =~ /^\d+$/x) {
$hash->{HELPER}{RECTIME_TEMP} = $prop;
}
my $spec = join(" ",@$aref);
my ($inf) = $spec =~ m/STRM:(.*)/ix; # Aufnahme durch SSCamSTRM-Device
$hash->{HELPER}{INFORM} = $inf if($inf);
my $emtxt = AttrVal($name, "recEmailTxt", "");
if($spec =~ /recEmailTxt:/x) {
($emtxt) = $spec =~ m/recEmailTxt:"(.*)"/xi;
}
if($emtxt) { # Recording soll per Email versendet werden, recEmailTxt muss sein: subject => , body =>
if (!$hash->{SMTPCREDENTIALS}) {return "Due to \"recEmailTxt\" is set, you want to send recordings by email but SMTP credentials are not set - make sure you've set credentials with \"set $name smtpcredentials username password\"";}
$hash->{HELPER}{SMTPRECMSG} = $emtxt;
}
my $teletxt = AttrVal($name, "recTelegramTxt", "");
if($spec =~ /recTelegramTxt:/x) {
($teletxt) = $spec =~ m/recTelegramTxt:"(.*)"/xi;
}
if ($teletxt) { # Recording soll per Telegram versendet werden, Format teletxt muss sein: recTelegramTxt:"tbot => , peers => , subject => "
$hash->{HELPER}{TELERECMSG} = $teletxt;
}
my $chattxt = AttrVal($name, "recChatTxt", "");
if($spec =~ /recChatTxt:/x) {
($chattxt) = $spec =~ m/recChatTxt:"(.*)"/xi;
}
if ($chattxt) { # Recording soll per SSChatBot versendet werden, Format $chattxt muss sein: recChatTxt:"chatbot => , peers => , subject => "
$hash->{HELPER}{CHATRECMSG} = $chattxt;
}
__camStartRec("$name!_!$emtxt!_!$teletxt!_!$chattxt");
return;
}
################################################################
# Setter off
################################################################
sub _setoff { ## no critic "not used"
my $paref = shift;
my $hash = $paref->{hash};
my $name = $paref->{name};
my $aref = $paref->{aref};
return if(!IsModelCam($hash));
my $spec = join(" ",@$aref);
my ($inf) = $spec =~ m/STRM:(.*)/ix; # Aufnahmestop durch SSCamSTRM-Device
$hash->{HELPER}{INFORM} = $inf if($inf);
__camStopRec($hash);
return;
}
################################################################
# Setter snap
################################################################
sub _setsnap { ## no critic "not used"
my $paref = shift;
my $hash = $paref->{hash};
my $name = $paref->{name};
my $prop = $paref->{prop} // q{};
my $prop1 = $paref->{prop1} // q{};
my $aref = $paref->{aref};
return if(!IsModelCam($hash));
my ($num,$lag,$ncount) = (1,2,1);
if($prop =~ /^\d+$/x) { # Anzahl der Schnappschüsse zu triggern (default: 1)
$num = $prop;
$ncount = $prop;
}
if($prop1 =~ /^\d+$/x) { # Zeit zwischen zwei Schnappschüssen (default: 2 Sekunden)
$lag = $prop1;
}
Log3($name, 4, "$name - Trigger snapshots - Number: $num, Lag: $lag");
my $spec = join " ",@$aref;
if($spec =~ /STRM:/x) {
($hash->{HELPER}{INFORM}) = $spec =~ m/STRM:(.*)/xi; # Snap by SSCamSTRM-Device
}
my $emtxt = AttrVal ($name, "snapEmailTxt", "");
if($spec =~ /snapEmailTxt:/x) {
($emtxt) = $spec =~ m/snapEmailTxt:"(.*)"/xi;
}
if ($emtxt) { # Snap soll per Email versendet werden, Format $emtxt muss sein: snapEmailTxt:"subject => , body => "
if (!$hash->{SMTPCREDENTIALS}) {
return "It seems you want to send snapshots by email but SMTP credentials are not set. Make sure set credentials with \"set $name smtpcredentials username password\"";
}
$hash->{HELPER}{SMTPMSG} = $emtxt;
}
my $teletxt = AttrVal ($name, "snapTelegramTxt", "");
if($spec =~ /snapTelegramTxt:/x) {
($teletxt) = $spec =~ m/snapTelegramTxt:"(.*)"/xi;
}
if ($teletxt) { # Snap soll per TelegramBot versendet werden, Format $teletxt muss sein: snapTelegramTxt:"tbot => , peers => , subject => "
$hash->{HELPER}{TELEMSG} = $teletxt;
}
my $chattxt = AttrVal ($name, "snapChatTxt", "");
if($spec =~ /snapChatTxt:/x) {
($chattxt) = $spec =~ m/snapChatTxt:"(.*)"/xi;
}
if ($chattxt) { # Snap soll per SSChatBot versendet werden, Format $chattxt muss sein: snapChatTxt:"chatbot => , peers => , subject => "
$hash->{HELPER}{CHATMSG} = $chattxt;
}
__camSnap("$name!_!$num!_!$lag!_!$ncount!_!$emtxt!_!$teletxt!_!$chattxt");
return;
}
################################################################
# Setter snapCams
################################################################
sub _setsnapCams { ## no critic "not used"
my $paref = shift;
my $hash = $paref->{hash};
my $name = $paref->{name};
my $prop = $paref->{prop} // q{};
my $prop1 = $paref->{prop1} // q{};
my $aref = $paref->{aref};
return if(IsModelCam($hash));
my ($num,$lag,$ncount) = (1,2,1);
my $cams = "all";
if($prop =~ /^\d+$/x) { # Anzahl der Schnappschüsse zu triggern (default: 1)
$num = $prop;
$ncount = $prop;
}
if($prop1 =~ /^\d+$/x) { # Zeit zwischen zwei Schnappschüssen (default: 2 Sekunden)
$lag = $prop1;
}
my $at = join " ",@$aref;
if($at =~ /CAM:/xi) {
($cams) = $at =~ m/CAM:"(.*)"/xi;
$cams =~ s/\s//gx;
}
my @camdvs;
if($cams eq "all") { # alle nicht disabled Kameras auslösen, sonst nur die gewählten
@camdvs = devspec2array("TYPE=SSCam:FILTER=MODEL!=SVS");
for (@camdvs) {
if($defs{$_} && !IsDisabled($_)) {
$hash->{HELPER}{ALLSNAPREF}{$_} = ""; # Schnappschuss Hash für alle Cams -> Schnappschußdaten sollen hinein
}
}
}
else {
@camdvs = split(",",$cams);
for (@camdvs) {
if($defs{$_} && !IsDisabled($_)) {
$hash->{HELPER}{ALLSNAPREF}{$_} = "";
}
}
}
return "No valid camera devices are specified for trigger snapshots" if(!$hash->{HELPER}{ALLSNAPREF});
my $emtxt;
my $teletxt = "";
my $rawet = AttrVal ($name, "snapEmailTxt", "");
my $bt = join " ", @$aref;
if($bt =~ /snapEmailTxt:/x) {
($rawet) = $bt =~ m/snapEmailTxt:"(.*)"/xi;
}
if($rawet) {
$hash->{HELPER}{CANSENDSNAP} = 1; # zentraler Schnappschußversand wird aktiviert
$hash->{HELPER}{SMTPMSG} = $rawet;
}
my ($csnap,$cmail) = ("","");
for my $key (keys%{$hash->{HELPER}{ALLSNAPREF}}) {
if(!AttrVal ($key, "snapEmailTxt", "")) {
delete $hash->{HELPER}{ALLSNAPREF}->{$key}; # Snap dieser Kamera auslösen aber nicht senden
$csnap .= $csnap ? ", $key" : $key;
$emtxt = "";
}
else {
$cmail .= $cmail ? ", $key" : $key;
$emtxt = $rawet;
}
__camSnap("$key!_!$num!_!$lag!_!$ncount!_!$emtxt!_!$teletxt");
}
Log3($name, 4, "$name - Trigger snapshots by SVS - Number: $num, Lag: $lag, Snap only: \"$csnap\", Snap and send: \"$cmail\" ");
return;
}
################################################################
# Setter startTracking
################################################################
sub _setstartTracking { ## no critic "not used"
my $paref = shift;
my $hash = $paref->{hash};
my $name = $paref->{name};
my $opt = $paref->{opt};
return if(!IsModelCam($hash));
if ($hash->{HELPER}{API}{PTZ}{VER} < 5) {
return qq{Function "$opt" needs a higher version of Surveillance Station};
}
__startTrack($hash);
return;
}
################################################################
# Setter stopTracking
################################################################
sub _setstopTracking { ## no critic "not used"
my $paref = shift;
my $hash = $paref->{hash};
my $name = $paref->{name};
my $opt = $paref->{opt};
return if(!IsModelCam($hash));
if ($hash->{HELPER}{API}{PTZ}{VER} < 5) {
return qq{Function "$opt" needs a higher version of Surveillance Station};
}
__stopTrack($hash);
return;
}
################################################################
# Setter setZoom
################################################################
sub _setsetZoom { ## no critic "not used"
my $paref = shift;
my $hash = $paref->{hash};
my $name = $paref->{name};
my $prop = $paref->{prop};
return if(!IsModelCam($hash));
$prop = $prop // "+"; # Korrektur -> "+" in Taste wird als undef geliefert
$prop = ".++" if($prop eq "."); # Korrektur -> ".++" in Taste wird als "." geliefert
__setZoom ("$name!_!$prop");
return;
}
################################################################
# Setter snapGallery
################################################################
sub _setsnapGallery { ## no critic "not used"
my $paref = shift;
my $hash = $paref->{hash};
my $name = $paref->{name};
my $prop = $paref->{prop};
return if(!IsModelCam($hash));
my $ret = getClHash($hash);
return $ret if($ret);
if(!AttrVal($name, "snapGalleryBoost",0)) { # Snaphash ist nicht vorhanden und wird neu abgerufen und ausgegeben
$hash->{HELPER}{GETSNAPGALLERY} = 1;
my $slim = $prop // AttrVal($name,"snapGalleryNumber",$defSlim); # Anzahl der abzurufenden Snapshots
my $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 (Polling ist aktiv)
$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;
}
}
delClHash ($name);
}
return;
}
################################################################
# Setter createSnapGallery
################################################################
sub _setcreateSnapGallery { ## no critic "not used"
my $paref = shift;
my $hash = $paref->{hash};
my $name = $paref->{name};
my $opt = $paref->{opt};
return if(!IsModelCam($hash));
if(!AttrVal($name,"snapGalleryBoost",0)) {
return qq{Before you can use "$opt", you must first set the "snapGalleryBoost" attribute, since automatic snapshot retrieval is required.};
}
my $sgdev = "SSCamSTRM.$name.snapgallery";
my $ret = CommandDefine($hash->{CL},"$sgdev SSCamSTRM {FHEM::SSCam::composeGallery('$name','$sgdev','snapgallery')}");
return $ret if($ret);
my $room = "SSCam";
$attr{$sgdev}{room} = $room;
return qq{Snapgallery device "$sgdev" created and assigned to room "$room".};
}
################################################################
# Setter createPTZcontrol
################################################################
sub _setcreatePTZcontrol { ## no critic "not used"
my $paref = shift;
my $hash = $paref->{hash};
my $name = $paref->{name};
return if(!IsModelCam($hash));
my $ptzcdev = "SSCamSTRM.$name.PTZcontrol";
my $ret = CommandDefine($hash->{CL},"$ptzcdev SSCamSTRM {FHEM::SSCam::ptzPanel('$name','$ptzcdev','ptzcontrol')}");
return $ret if($ret);
my $room = AttrVal($name,"room","SSCam");
$attr{$ptzcdev}{room} = $room;
$attr{$ptzcdev}{group} = $name."_PTZcontrol";
return qq{PTZ control device "$ptzcdev" created and assigned to room "$room".};
}
################################################################
# Setter createStreamDev
################################################################
sub _setcreateStreamDev { ## no critic "not used"
my $paref = shift;
my $hash = $paref->{hash};
my $name = $paref->{name};
my $prop = $paref->{prop};
my ($livedev,$ret);
if($prop =~ /mjpeg/x) {
$livedev = "SSCamSTRM.$name.mjpeg";
$ret = CommandDefine($hash->{CL},"$livedev SSCamSTRM {FHEM::SSCam::streamDev('$name','$livedev','mjpeg')}");
return $ret if($ret);
}
if($prop =~ /generic/x) {
$livedev = "SSCamSTRM.$name.generic";
$ret = CommandDefine($hash->{CL},"$livedev SSCamSTRM {FHEM::SSCam::streamDev('$name','$livedev','generic')}");
return $ret if($ret);
}
if($prop =~ /hls/x) {
$livedev = "SSCamSTRM.$name.hls";
$ret = CommandDefine($hash->{CL},"$livedev SSCamSTRM {FHEM::SSCam::streamDev('$name','$livedev','hls')}");
return $ret if($ret);
my $c = qq{The device needs to set attribute "hlsStrmObject" in camera device "$name" to a valid HLS videostream};
CommandAttr($hash->{CL},"$livedev comment $c");
}
if($prop =~ /lastsnap/x) {
$livedev = "SSCamSTRM.$name.lastsnap";
$ret = CommandDefine($hash->{CL},"$livedev SSCamSTRM {FHEM::SSCam::streamDev('$name','$livedev','lastsnap')}");
return $ret if($ret);
my $c = qq{The device shows the last snapshot of camera device "$name". \n}.
qq{If you always want to see the newest snapshot, please set attribute "pollcaminfoall" in camera device "$name".\n}.
qq{Set also attribute "snapGallerySize = Full" in camera device "$name" to retrieve snapshots in original resolution.};
CommandAttr($hash->{CL},"$livedev comment $c");
}
if($prop =~ /switched/x) {
$livedev = "SSCamSTRM.$name.switched";
$ret = CommandDefine($hash->{CL},"$livedev SSCamSTRM {FHEM::SSCam::streamDev('$name','$livedev','switched')}");
return $ret if($ret);
}
if($prop =~ /master/x) {
$livedev = "SSCamSTRM.$name.master";
$ret = CommandDefine($hash->{CL},"$livedev SSCamSTRM {FHEM::SSCam::streamDev('$name','$livedev','master')}");
return $ret if($ret);
}
my $room = AttrVal($name,"room","SSCam");
$attr{$livedev}{room} = $room;
return qq{Livestream device "$livedev" created and assigned to room "$room".};
}
################################################################
# Setter createReadingsGroup
################################################################
sub _setcreateReadingsGroup { ## no critic "not used"
my $paref = shift;
my $hash = $paref->{hash};
my $name = $paref->{name};
my $prop = $paref->{prop};
my $rgdev = $prop // "RG.SSCam";
my $rgdef = '<%it_camera>,On/Offline>,< >,,< >,erkennung>,< >,,< >,(MB)>,< >,,< >,Modul>,< >,'."\n".
'TYPE=SSCam:FILTER=MODEL!=SVS:Availability,< >,state,< >,!CamMotDetSc,< >,!CamLastRecTime,< >,!UsedSpaceMB,< >,!LastUpdateTime,< >,?!disable,< >,?!LSnap,?!LRec,?!Start,?!Stop'."\n".
'< >,< >,< >,< >,< >,< >,< >,< >,< >,< >,< >,< >,< >,< >,< >,< >,< >,< >,< >'."\n".
'< >,< >,< >,< >,< >,< >,< >,< >,< >,< >,< >,< >,< >,< >,< >,< >,< >,< >,< >'."\n".
'< >,< >,< >,< >,< >,< >,< >,< >,< >,< >,< >,< >,< >,< >,< >,< >,< >,< >,< >'."\n".
'<%it_server>,On/Off>,< >,,< >, >,< >,< >,< >,< >, >,< >,< >,< >,< >,< >,< >,< >,< >,< >,< >'."\n".
'TYPE=SSCam:FILTER=MODEL=SVS:!HomeModeState,< >,state,< >,< >,< >,< >,< >,< >, >,< >,< >,< >,?!disable,< >,< >,< >,< >,< >'."\n".
'';
my $ret = CommandDefine($hash->{CL},"$rgdev readingsGroup $rgdef");
return $ret if($ret);
my $room = AttrVal($name,"room","SSCam");
CommandAttr($hash->{CL},"$rgdev room $room");
CommandAttr($hash->{CL},"$rgdev alias Überblick Kameras");
my $cellStyle = '{'."\n".
' "c:0" => \'style="text-align:left;font-weight:normal"\','."\n".
' "c:1" => \'style="text-align:left;font-weight:normal"\','."\n".
' "c:4" => \'style="text-align:center;font-weight:bold"\','."\n".
' "c:5" => \'style="text-align:center;color:green;font-weight:normal"\','."\n".
' "c:9" => \'style="text-align:center;font-weight:normal"\''."\n".
'}';
CommandAttr($hash->{CL},"$rgdev cellStyle $cellStyle");
my $commands = '{'."\n".
' "Availability.enabled" => "set $DEVICE disable",'."\n".
' "Availability.disabled" => "set $DEVICE enable",'."\n".
' "HomeModeState.on" => "set $DEVICE homeMode off",'."\n".
' "HomeModeState.off" => "set $DEVICE homeMode on",'."\n".
' "'.$rgdev.'.Start" => "set %DEVICE runView live_fw",'."\n".
' "Start" => "set %DEVICE runView live_fw",'."\n".
' "LRec" => "set %DEVICE runView lastrec_fw",'."\n".
' "LSnap" => "set %DEVICE runView lastsnap_fw",'."\n".
' "Stop" => "set %DEVICE stopView",'."\n".
' "Record" => "runView:",'."\n".
' "disable" => "disable:"'."\n".
'}';
CommandAttr($hash->{CL},"$rgdev commands $commands");
my $nameStyle = 'style = "color:black;font-weight:bold;text-align:center"';
CommandAttr($hash->{CL},"$rgdev nameStyle $nameStyle");
my $valueColumns = '{'."\n".
' \'Wiedergabe\' => \'colspan="4"\''."\n".
'}';
CommandAttr($hash->{CL},"$rgdev valueColumns $valueColumns");
my $valueFormat = '{'."\n".
' ($READING eq "CamMotDetSc" && $VALUE eq "disabled") ? "external" : $VALUE'."\n".
'}';
CommandAttr($hash->{CL},"$rgdev valueFormat $valueFormat");
my $valueIcon = '{'."\n".
' "Availability.enabled" => "remotecontrol/black_btn_GREEN",'."\n".
' "Availability.disabled" => "remotecontrol/black_btn_RED",'."\n".
' "HomeModeState.on" => "status_available",'."\n".
' "HomeModeState.off" => "status_away_1\@orange",'."\n".
' "Start" => "black_btn_MJPEG",'."\n".
' "LRec" => "black_btn_LASTRECIFRAME",'."\n".
' "LSnap" => "black_btn_LSNAP",'."\n".
' "Stop" => "remotecontrol/black_btn_POWEROFF3",'."\n".
' "state.initialized" => "remotecontrol/black_btn_STOP",'."\n".
' "state" => "%devStateIcon"'."\n".
'}';
CommandAttr($hash->{CL},"$rgdev valueIcon $valueIcon");
my $valueStyle = '{'."\n".
' if($READING eq "Availability" && $VALUE eq "enabled"){ \' style="color:green" \' }'."\n".
' elsif( $READING eq "Availability" && $VALUE eq "disabled"){ \' style="color:red" \' }'."\n".
' elsif( $READING eq "CamMotDetSc" && $VALUE =~ /SVS.*/ ){ \' style="color:orange" \' }'."\n".
' elsif( $READING eq "CamMotDetSc" && $VALUE eq "disabled"){ \' style="color:LimeGreen" \' }'."\n".
' elsif( $READING eq "CamMotDetSc" && $VALUE =~ /Cam.*/ ){ \' style="color:SandyBrown" \' }'."\n".
'}';
CommandAttr($hash->{CL},"$rgdev valueStyle $valueStyle");
return qq{readingsGroup device "$rgdev" created and assigned to room "$room".};
}
################################################################
# Setter enable
################################################################
sub _setenable { ## no critic "not used"
my $paref = shift;
my $hash = $paref->{hash};
return if(!IsModelCam($hash));
__camEnable($hash);
return;
}
################################################################
# Setter disable
################################################################
sub _setdisable { ## no critic "not used"
my $paref = shift;
my $hash = $paref->{hash};
return if(!IsModelCam($hash));
__camDisable($hash);
return;
}
################################################################
# Setter motdetsc
################################################################
sub _setmotdetsc { ## no critic "not used"
my $paref = shift;
my $hash = $paref->{hash};
my $opt = $paref->{opt};
my $prop = $paref->{prop};
my $prop1 = $paref->{prop1};
my $prop2 = $paref->{prop2};
my $prop3 = $paref->{prop3};
return if(!IsModelCam($hash));
if (!$prop || $prop !~ /disable|camera|SVS/x) {
return qq{Command "$opt" needs one of those arguments: disable, camera, SVS !};
}
$hash->{HELPER}{MOTDETSC} = $prop;
if ($prop1) {
if ($prop1 !~ /^[1-9][0-9]?$/x) {
return "Invalid value for sensitivity (SVS or camera). Use numbers between 1 - 99";
}
$hash->{HELPER}{MOTDETSC_PROP1} = $prop1;
}
if ($prop2) {
if ($prop2 !~ /^[1-9][0-9]?$/x) {
return "Invalid value for threshold (SVS) / object size (camera). Use numbers between 1 - 99";
}
$hash->{HELPER}{MOTDETSC_PROP2} = $prop2;
}
if ($prop3) {
if ($prop3 !~ /^[1-9][0-9]?$/x) {
return "Invalid value for threshold (SVS) / object size (camera). Use numbers between 1 - 99";
}
$hash->{HELPER}{MOTDETSC_PROP3} = $prop3;
}
__camMotDetSc($hash);
return;
}
################################################################
# Setter expmode
################################################################
sub _setexpmode { ## no critic "not used"
my $paref = shift;
my $hash = $paref->{hash};
my $opt = $paref->{opt};
my $prop = $paref->{prop};
return if(!IsModelCam($hash));
if(!$prop) {
return qq{Command "$opt" needs one of those arguments: auto, day, night};
}
$hash->{HELPER}{EXPMODE} = $prop;
__camExpmode($hash);
return;
}
################################################################
# Setter homeMode
################################################################
sub _sethomeMode { ## no critic "not used"
my $paref = shift;
my $hash = $paref->{hash};
my $opt = $paref->{opt};
my $prop = $paref->{prop};
return if(IsModelCam($hash));
if(!$prop) {
return qq{Command "$opt" needs one of those arguments: on, off};
}
$hash->{HELPER}{HOMEMODE} = $prop;
__setHomeMode($hash);
return;
}
################################################################
# Setter autocreateCams
################################################################
sub _setautocreateCams { ## no critic "not used"
my $paref = shift;
my $hash = $paref->{hash};
return if(IsModelCam($hash));
__camAutocreate($hash);
return;
}
################################################################
# Setter goPreset
################################################################
sub _setgoPreset { ## no critic "not used"
my $paref = shift;
my $hash = $paref->{hash};
my $opt = $paref->{opt};
my $prop = $paref->{prop};
return if(!IsModelCam($hash));
if (!$prop) {
return qq{Command "$opt" needs a as an argument};
}
$hash->{HELPER}{GOPRESETNAME} = $prop;
$hash->{HELPER}{PTZACTION} = "gopreset";
__doPtzAaction($hash);
return;
}
################################################################
# Setter optimizeParams
################################################################
sub _setoptimizeParams { ## no critic "not used"
my $paref = shift;
my $hash = $paref->{hash};
my $aref = $paref->{aref};
return if(!IsModelCam($hash));
my %cpcl = (ntp => 1, mirror => 2, flip => 4, rotate => 8);
for my $part (@$aref) {
$hash->{HELPER}{MIRROR} = (split "mirror:", $part)[1] if(lc($part) =~ m/^mirror:/x);
$hash->{HELPER}{FLIP} = (split "flip:", $part)[1] if(lc($part) =~ m/^flip:/x);
$hash->{HELPER}{ROTATE} = (split "rotate:", $part)[1] if(lc($part) =~ m/^rotate:/x);
$hash->{HELPER}{NTPSERV} = (split "ntp:", $part)[1] if(lc($part) =~ 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);
__setOptParams($hash);
return;
}
################################################################
# Setter pirSensor
################################################################
sub _setpirSensor { ## no critic "not used"
my $paref = shift;
my $hash = $paref->{hash};
my $name = $paref->{name};
my $opt = $paref->{opt};
my $prop = $paref->{prop};
return if(!IsModelCam($hash));
if(ReadingsVal($name, "CapPIR", "false") eq "false") {
return qq{Command "$opt" not possible. Camera "$name" don't provide a PIR sensor.};
}
if(!$prop) {
return qq{Command "$opt" needs an argument};
}
$hash->{HELPER}{PIRACT} = ($prop eq "activate") ? 0 : ($prop eq "deactivate") ? -1 : 5;
if($hash->{HELPER}{PIRACT} == 5) {
return qq{Illegal argument for "$opt" detected. Use "activate" or "activate".};
}
__managePir($hash);
return;
}
################################################################
# Setter runPatrol
################################################################
sub _setrunPatrol { ## no critic "not used"
my $paref = shift;
my $hash = $paref->{hash};
my $opt = $paref->{opt};
my $prop = $paref->{prop};
return if(!IsModelCam($hash));
if (!$prop) {
return qq{Command "$opt" needs a as an argument};
}
$hash->{HELPER}{GOPATROLNAME} = $prop;
$hash->{HELPER}{PTZACTION} = "runpatrol";
__doPtzAaction($hash);
return;
}
################################################################
# Setter goAbsPTZ
################################################################
sub _setgoAbsPTZ { ## no critic "not used"
my $paref = shift;
my $hash = $paref->{hash};
my $opt = $paref->{opt};
my $prop = $paref->{prop};
my $prop1 = $paref->{prop1};
return if(!IsModelCam($hash));
if ($prop eq "up" || $prop eq "down" || $prop eq "left" || $prop eq "right") {
if ($prop eq "up") {$hash->{HELPER}{GOPTZPOSX} = 320; $hash->{HELPER}{GOPTZPOSY} = 480;}
if ($prop eq "down") {$hash->{HELPER}{GOPTZPOSX} = 320; $hash->{HELPER}{GOPTZPOSY} = 0; }
if ($prop eq "left") {$hash->{HELPER}{GOPTZPOSX} = 0; $hash->{HELPER}{GOPTZPOSY} = 240;}
if ($prop eq "right") {$hash->{HELPER}{GOPTZPOSX} = 640; $hash->{HELPER}{GOPTZPOSY} = 240;}
$hash->{HELPER}{PTZACTION} = "goabsptz";
__doPtzAaction($hash);
return;
}
else {
if ($prop !~ /\d+/x || $prop1 !~ /\d+/x || abs($prop) > 640 || abs($prop1) > 480) {
return qq{Command "$opt" needs two coordinates within limits posX=0-640 and posY=0-480 as arguments or use up, down, left, right instead};
}
$hash->{HELPER}{GOPTZPOSX} = abs($prop);
$hash->{HELPER}{GOPTZPOSY} = abs($prop1);
$hash->{HELPER}{PTZACTION} = "goabsptz";
__doPtzAaction($hash);
return;
}
return qq{Command "$opt" needs two coordinates, posX=0-640 and posY=0-480, as arguments or use up, down, left, right instead};
}
################################################################
# Setter move
################################################################
sub _setmove { ## no critic "not used"
my $paref = shift;
my $hash = $paref->{hash};
my $name = $paref->{name};
my $opt = $paref->{opt};
my $prop = $paref->{prop};
my $prop1 = $paref->{prop1};
return if(!IsModelCam($hash));
if(!$hash->{HELPER}{API}{PTZ}{VER}) {
return qq{PTZ version of Synology API isn't set. Use "get $name scanVirgin" first.}
};
if($hash->{HELPER}{API}{PTZ}{VER} <= 4) {
if (!defined($prop) || ($prop !~ /^up$|^down$|^left$|^right$|^dir_\d$/x)) {
return qq{Command "$opt" needs an argument like up, down, left, right or dir_X (X = 0 to CapPTZDirections-1)};
}
$hash->{HELPER}{GOMOVEDIR} = $prop;
} elsif ($hash->{HELPER}{API}{PTZ}{VER} >= 5) {
if (!defined($prop) || ($prop !~ /^right$|^upright$|^up$|^upleft$|^left$|^downleft$|^down$|^downright$/x)) {
return qq{Command "$opt" needs an argument like right, upright, up, upleft, left, downleft, down, downright};
}
my %dirs = (
right => 0,
upright => 4,
up => 8,
upleft => 12,
left => 16,
downleft => 20,
down => 24,
downright => 28,
);
$hash->{HELPER}{GOMOVEDIR} = $dirs{$prop};
}
$hash->{HELPER}{GOMOVETIME} = $prop1 // 1;
$hash->{HELPER}{PTZACTION} = "movestart";
__doPtzAaction($hash);
return;
}
################################################################
# Setter runView
################################################################
sub _setrunView { ## no critic "not used"
my $paref = shift;
my $hash = $paref->{hash};
my $aref = $paref->{aref};
my $prop = $paref->{prop};
my $prop1 = $paref->{prop1};
return if(!IsModelCam($hash) || !$prop);
my $spec = join " ", @$aref;
if($spec =~ /STRM:/x) {
($hash->{HELPER}{INFORM}) = $spec =~ m/STRM:(.*)/xi; # Call by SSCamSTRM-Device
}
if ($prop eq "live_open") {
if ($prop1) {
$hash->{HELPER}{VIEWOPENROOM} = $prop1;
}
else {
delete $hash->{HELPER}{VIEWOPENROOM};
}
$hash->{HELPER}{OPENWINDOW} = 1;
$hash->{HELPER}{WLTYPE} = "link";
$hash->{HELPER}{ALIAS} = "LiveView";
$hash->{HELPER}{RUNVIEW} = "live_open";
$hash->{HELPER}{ACTSTRM} = ""; # sprechender Name des laufenden Streamtyps für SSCamSTRM
}
elsif ($prop eq "live_link") {
$hash->{HELPER}{OPENWINDOW} = 0;
$hash->{HELPER}{WLTYPE} = "link";
$hash->{HELPER}{ALIAS} = "LiveView";
$hash->{HELPER}{RUNVIEW} = "live_link";
$hash->{HELPER}{ACTSTRM} = ""; # sprechender Name des laufenden Streamtyps für SSCamSTRM
}
elsif ($prop eq "lastrec_open") {
if ($prop1) {
$hash->{HELPER}{VIEWOPENROOM} = $prop1;
}
else {
delete $hash->{HELPER}{VIEWOPENROOM};
}
$hash->{HELPER}{OPENWINDOW} = 1;
$hash->{HELPER}{WLTYPE} = "link";
$hash->{HELPER}{ALIAS} = "LastRecording";
$hash->{HELPER}{RUNVIEW} = "lastrec_open";
$hash->{HELPER}{ACTSTRM} = ""; # sprechender Name des laufenden Streamtyps für SSCamSTRM
}
elsif ($prop eq "lastrec_fw") { # Video in iFrame eingebettet
$hash->{HELPER}{OPENWINDOW} = 0;
$hash->{HELPER}{WLTYPE} = "iframe";
$hash->{HELPER}{ALIAS} = " ";
$hash->{HELPER}{RUNVIEW} = "lastrec";
$hash->{HELPER}{ACTSTRM} = "last Recording"; # sprechender Name des laufenden Streamtyps für SSCamSTRM
}
elsif ($prop eq "lastrec_fw_MJPEG") { # “video/avi” – MJPEG format event
$hash->{HELPER}{OPENWINDOW} = 0;
$hash->{HELPER}{WLTYPE} = "image";
$hash->{HELPER}{ALIAS} = " ";
$hash->{HELPER}{RUNVIEW} = "lastrec";
$hash->{HELPER}{ACTSTRM} = "last Recording"; # sprechender Name des laufenden Streamtyps für SSCamSTRM
}
elsif ($prop eq "lastrec_fw_MPEG4/H.264") { # “video/mp4” – MPEG4/H.264 format event
$hash->{HELPER}{OPENWINDOW} = 0;
$hash->{HELPER}{WLTYPE} = "video";
$hash->{HELPER}{ALIAS} = " ";
$hash->{HELPER}{RUNVIEW} = "lastrec";
$hash->{HELPER}{ACTSTRM} = "last Recording"; # sprechender Name des laufenden Streamtyps für SSCamSTRM
}
elsif ($prop eq "live_fw") {
$hash->{HELPER}{OPENWINDOW} = 0;
$hash->{HELPER}{WLTYPE} = "image";
$hash->{HELPER}{ALIAS} = " ";
$hash->{HELPER}{RUNVIEW} = "live_fw";
$hash->{HELPER}{ACTSTRM} = "MJPEG Livestream"; # sprechender Name des laufenden Streamtyps für SSCamSTRM
}
elsif ($prop eq "live_fw_hls") {
if(!IsCapHLS($hash)) {
return qq{API "SYNO.SurveillanceStation.VideoStream" is not available or Reading "CamStreamFormat" is not "HLS". May be your API version is 2.8 or lower.};
}
$hash->{HELPER}{OPENWINDOW} = 0;
$hash->{HELPER}{WLTYPE} = "hls";
$hash->{HELPER}{ALIAS} = "View only on compatible browsers";
$hash->{HELPER}{RUNVIEW} = "live_fw_hls";
$hash->{HELPER}{ACTSTRM} = "HLS Livestream"; # sprechender Name des laufenden Streamtyps für SSCamSTRM
}
elsif ($prop eq "lastsnap_fw") {
$hash->{HELPER}{LSNAPBYSTRMDEV} = 1 if($prop1); # Anzeige durch SSCamSTRM-Device ausgelöst
$hash->{HELPER}{LSNAPBYDEV} = 1 if(!$prop1); # Anzeige durch SSCam ausgelöst
$hash->{HELPER}{OPENWINDOW} = 0;
$hash->{HELPER}{WLTYPE} = "base64img";
$hash->{HELPER}{ALIAS} = " ";
$hash->{HELPER}{RUNVIEW} = "lastsnap_fw";
$hash->{HELPER}{ACTSTRM} = "last Snapshot"; # sprechender Name des laufenden Streamtyps für SSCamSTRM
}
else {
return qq{"$prop" isn't a valid option of runview, use one of live_fw, live_link, live_open, lastrec_fw, lastrec_open, lastsnap_fw};
}
__runLiveview($hash);
return;
}
################################################################
# Setter hlsreactivate
# ohne SET-Menüeintrag
################################################################
sub _sethlsreactivate { ## no critic "not used"
my $paref = shift;
my $hash = $paref->{hash};
return if(!IsModelCam($hash));
__reactivateHls($hash);
return;
}
################################################################
# Setter hlsactivate
# ohne SET-Menüeintrag
################################################################
sub _sethlsactivate { ## no critic "not used"
my $paref = shift;
my $hash = $paref->{hash};
my $aref = $paref->{aref};
return if(!IsModelCam($hash));
my $spec = join " ", @$aref;
if($spec =~ /STRM:/x) {
($hash->{HELPER}{INFORM}) = $spec =~ m/STRM:(.*)/xi; # Call by SSCamSTRM-Device
}
__activateHls($hash);
return;
}
################################################################
# Setter refresh
# ohne SET-Menüeintrag
################################################################
sub _setrefresh { ## no critic "not used"
my $paref = shift;
my $hash = $paref->{hash};
my $aref = $paref->{aref};
return if(!IsModelCam($hash));
my $spec = join " ", @$aref;
if($spec =~ /STRM:/x) {
($hash->{HELPER}{INFORM}) = $spec =~ m/STRM:(.*)/xi; # Refresh by SSCamSTRM-Device
roomRefresh($hash,0,0,1); # kein Room-Refresh, kein SSCam-state-Event, SSCamSTRM-Event
}
return;
}
################################################################
# Setter extevent
################################################################
sub _setextevent { ## no critic "not used"
my $paref = shift;
my $hash = $paref->{hash};
my $prop = $paref->{prop};
return if(IsModelCam($hash));
$hash->{HELPER}{EVENTID} = $prop;
__extEvent($hash);
return;
}
################################################################
# Setter stopView
################################################################
sub _setstopView { ## no critic "not used"
my $paref = shift;
my $hash = $paref->{hash};
my $aref = $paref->{aref};
return if(!IsModelCam($hash));
my $spec = join " ", @$aref;
if($spec =~ /STRM:/x) {
($hash->{HELPER}{INFORM}) = $spec =~ m/STRM:(.*)/xi; # Stop by SSCamSTRM-Device
}
__stopLiveview($hash);
return;
}
################################################################
# Setter setPreset
################################################################
sub _setsetPreset { ## no critic "not used"
my $paref = shift;
my $hash = $paref->{hash};
my $name = $paref->{name};
my $opt = $paref->{opt};
my $prop = $paref->{prop};
my $prop1 = $paref->{prop1};
my $prop2 = $paref->{prop2};
return if(!IsModelCam($hash));
if (!$prop) {
return qq{Syntax of Command "$opt" was wrong. Please use "set $name setPreset []"};
}
$hash->{HELPER}{PNUMBER} = $prop;
$hash->{HELPER}{PNAME} = $prop1 // $prop; # wenn keine Presetname angegeben -> Presetnummer als Name verwenden
$hash->{HELPER}{PSPEED} = $prop2 if($prop2);
__setPreset($hash);
return;
}
################################################################
# Setter setHome
################################################################
sub _setsetHome { ## no critic "not used"
my $paref = shift;
my $hash = $paref->{hash};
my $opt = $paref->{opt};
my $prop = $paref->{prop};
return if(!IsModelCam($hash));
if (!$prop) {
return qq{Command "$opt" needs a as argument};
}
$hash->{HELPER}{SETHOME} = $prop;
__setHome($hash);
return;
}
################################################################
# Setter delPreset
################################################################
sub _setdelPreset { ## no critic "not used"
my $paref = shift;
my $hash = $paref->{hash};
my $opt = $paref->{opt};
my $prop = $paref->{prop};
return if(!IsModelCam($hash));
if (!$prop) {
return qq{Function "$opt" needs a as argument};
}
$hash->{HELPER}{DELPRESETNAME} = $prop;
__delPreset($hash);
return;
}
###############################################################################
# Kamera Aufnahme starten
###############################################################################
sub __camStartRec {
my $str = shift;
my ($name,$emtxt,$teletxt,$chattxt) = split("!_!",$str);
my $hash = $defs{$name};
my $camname = $hash->{CAMNAME};
my $caller = (caller(0))[3];
RemoveInternalTimer($hash, $caller);
return if(IsDisabled($name));
return if(exitOnDis ($name, "Start Recording of Camera $camname can't be executed"));
if (ReadingsVal("$name", "Record", "") eq "Start" && !AttrVal($name, "recextend", "")) {
Log3($name, 3, "$name - another recording is already running - new start-command will be ignored");
return;
}
if ($hash->{HELPER}{ACTIVE} eq "off") {
$hash->{OPMODE} = "Start";
return if(startOrShut($name));
$hash->{HELPER}{LOGINRETRIES} = 0;
if (!$hash->{HELPER}{API}{PARSET}) {
getApiSites ($hash, $caller, $str);
return;
}
$hash->{HELPER}{CALL}{VKEY} = "EXTREC";
$hash->{HELPER}{CALL}{PART} = qq{api=_NAME_&version=_VER_&method=Record&cameraId=_CID_&action=start&_sid="_SID_"};
if($hash->{HELPER}{API}{EXTREC}{VER} >= 3) {
$hash->{HELPER}{CALL}{PART} = qq{api=_NAME_&version=_VER_&method=Record&cameraIds=_CID_&action=start&_sid="_SID_"};
}
if($emtxt || $teletxt || $chattxt) {
$hash->{HELPER}{CANSENDREC} = 1 if($emtxt); # Versand Aufnahme soll per Email erfolgen
$hash->{HELPER}{CANTELEREC} = 1 if($teletxt); # Versand Aufnahme soll per TelegramBot erfolgen
$hash->{HELPER}{CANCHATREC} = 1 if($chattxt); # Versand Aufnahme soll per SSChatBot erfolgen
$hash->{HELPER}{SMTPRECMSG} = $emtxt if($emtxt); # Text für Email-Versand
$hash->{HELPER}{TELERECMSG} = $teletxt if($teletxt); # Text für Telegram-Versand
$hash->{HELPER}{CHATRECMSG} = $chattxt if($chattxt); # Text für Synology Chat-Versand
}
setActiveToken($hash);
checkSid ($hash);
}
else {
schedule ($name, $str);
}
return;
}
###############################################################################
# Kamera Aufnahme stoppen
###############################################################################
sub __camStopRec {
my $hash = shift;
my $camname = $hash->{CAMNAME};
my $name = $hash->{NAME};
my $caller = (caller(0))[3];
RemoveInternalTimer($hash, $caller);
return if(IsDisabled($name));
return if(exitOnDis ($name, "Stop Recording of Camera $camname can't be executed"));
if (ReadingsVal("$name", "Record", undef) eq "Stop") {
Log3($name, 3, "$name - recording is already stopped - new stop-command will be ignored");
return;
}
if ($hash->{HELPER}{ACTIVE} eq "off") {
$hash->{OPMODE} = "Stop";
return if(startOrShut($name));
$hash->{HELPER}{LOGINRETRIES} = 0;
if (!$hash->{HELPER}{API}{PARSET}) {
getApiSites ($hash, $caller, $hash);
return;
}
$hash->{HELPER}{CALL}{VKEY} = "EXTREC";
$hash->{HELPER}{CALL}{PART} = qq{api=_NAME_&version=_VER_&method=Record&cameraId=_CID_&action=stop&_sid="_SID_"};
if($hash->{HELPER}{API}{EXTREC}{VER} >= 3) {
$hash->{HELPER}{CALL}{PART} = qq{api=_NAME_&version=_VER_&method=Record&cameraIds=_CID_&action=stop&_sid="_SID_"};
}
setActiveToken($hash);
checkSid ($hash);
}
else {
schedule ($name, $hash);
}
return;
}
###############################################################################
# Kamera Auto / Day / Nightmode setzen
###############################################################################
sub __camExpmode {
my $hash = shift;
my $camname = $hash->{CAMNAME};
my $name = $hash->{NAME};
my $caller = (caller(0))[3];
RemoveInternalTimer($hash, $caller);
return if(IsDisabled($name));
return if(exitOnDis ($name, "Setting exposure mode of Camera $camname can't be executed"));
if ($hash->{HELPER}{ACTIVE} eq "off") {
$hash->{OPMODE} = "ExpMode";
return if(startOrShut($name));
$hash->{HELPER}{LOGINRETRIES} = 0;
if (!$hash->{HELPER}{API}{PARSET}) {
getApiSites ($hash, $caller, $hash);
return;
}
my $expmode = $hexmo{$hash->{HELPER}{EXPMODE}};
$hash->{HELPER}{CALL}{VKEY} = "CAM";
my $ver = ($hash->{HELPER}{API}{CAM}{VER} >= 9) ? 8 : $hash->{HELPER}{API}{CAM}{VER};
$hash->{HELPER}{CALL}{PART} = qq{api="_NAME_"&version="$ver"&method="SaveOptimizeParam"&cameraIds="_CID_"&expMode="$expmode"&camParamChkList=32&_sid="_SID_"};
setActiveToken($hash);
checkSid ($hash);
}
else {
schedule ($name, $hash);
}
return;
}
###############################################################################
# Art der Bewegungserkennung setzen
###############################################################################
sub __camMotDetSc {
my $hash = shift;
my $camname = $hash->{CAMNAME};
my $name = $hash->{NAME};
my $caller = (caller(0))[3];
RemoveInternalTimer($hash, $caller);
return if(IsDisabled($name));
return if(exitOnDis ($name, "Setting of motion detection source of Camera $camname can't be executed"));
if ($hash->{HELPER}{ACTIVE} eq "off") {
$hash->{OPMODE} = "MotDetSc";
return if(startOrShut($name));
$hash->{HELPER}{LOGINRETRIES} = 0;
if (!$hash->{HELPER}{API}{PARSET}) {
getApiSites ($hash, $caller, $hash);
return;
}
$hash->{HELPER}{CALL}{VKEY} = "CAMEVENT";
my %motdetoptions = (); # Hash für Optionswerte sichern für Logausgabe in Befehlsauswertung
my $motdetsc;
if ($hash->{HELPER}{MOTDETSC} eq "disable") {
$motdetsc = "-1";
$hash->{HELPER}{CALL}{PART} = qq{api="_NAME_"&version="_VER_"&method="MDParamSave"&camId="_CID_"&source=$motdetsc&keep=true};
} elsif ($hash->{HELPER}{MOTDETSC} eq "camera") {
$motdetsc = "0";
$motdetoptions{SENSITIVITY} = $hash->{HELPER}{MOTDETSC_PROP1} if ($hash->{HELPER}{MOTDETSC_PROP1});
$motdetoptions{OBJECTSIZE} = $hash->{HELPER}{MOTDETSC_PROP2} if ($hash->{HELPER}{MOTDETSC_PROP2});
$motdetoptions{PERCENTAGE} = $hash->{HELPER}{MOTDETSC_PROP3} if ($hash->{HELPER}{MOTDETSC_PROP3});
$hash->{HELPER}{CALL}{PART} = qq{api="_NAME_"&version="_VER_"&method="MDParamSave"&camId="_CID_"&source=$motdetsc};
if ($hash->{HELPER}{MOTDETSC_PROP1} || $hash->{HELPER}{MOTDETSC_PROP2} || $hash->{HELPER}{MOTDETSC_PROP3}) {
$hash->{HELPER}{CALL}{PART} .= qq{&mode=1}; # umschalten und neue Werte setzen
}
else { # nur Umschaltung, alte Werte beibehalten
$hash->{HELPER}{CALL}{PART} .= qq{&mode=0};
}
if ($hash->{HELPER}{MOTDETSC_PROP1}) { # der Wert für Bewegungserkennung Kamera -> Empfindlichkeit ist gesetzt
my $sensitivity = delete $hash->{HELPER}{MOTDETSC_PROP1};
$hash->{HELPER}{CALL}{PART} .= qq{&sensitivity="$sensitivity"};
}
if ($hash->{HELPER}{MOTDETSC_PROP2}) { # der Wert für Bewegungserkennung Kamera -> Objektgröße ist gesetzt
my $objectsize = delete $hash->{HELPER}{MOTDETSC_PROP2};
$hash->{HELPER}{CALL}{PART} .= qq{&objectSize="$objectsize"};
}
if ($hash->{HELPER}{MOTDETSC_PROP3}) { # der Wert für Bewegungserkennung Kamera -> Prozentsatz für Auslösung ist gesetzt
my $percentage = delete $hash->{HELPER}{MOTDETSC_PROP3};
$hash->{HELPER}{CALL}{PART} .= qq{&percentage="$percentage"};
}
} elsif ($hash->{HELPER}{MOTDETSC} eq "SVS") {
$motdetsc = "1";
$motdetoptions{SENSITIVITY} = $hash->{HELPER}{MOTDETSC_PROP1} if ($hash->{HELPER}{MOTDETSC_PROP1});
$motdetoptions{THRESHOLD} = $hash->{HELPER}{MOTDETSC_PROP2} if ($hash->{HELPER}{MOTDETSC_PROP2});
$hash->{HELPER}{CALL}{PART} = qq{api="_NAME_"&version="_VER_"&method="MDParamSave"&camId="_CID_"&source=$motdetsc};
if ($hash->{HELPER}{MOTDETSC_PROP1} || $hash->{HELPER}{MOTDETSC_PROP2}) {
$hash->{HELPER}{CALL}{PART} .= qq{&mode=1}; # umschalten und neue Werte setzen
}
else { # nur Umschaltung, alte Werte beibehalten
$hash->{HELPER}{CALL}{PART} .= qq{&mode=0};
}
if ($hash->{HELPER}{MOTDETSC_PROP1}) { # der Wert für Bewegungserkennung SVS -> Empfindlichkeit ist gesetzt
my $sensitivity = delete $hash->{HELPER}{MOTDETSC_PROP1};
$hash->{HELPER}{CALL}{PART} .= qq{&sensitivity="$sensitivity"};
}
if ($hash->{HELPER}{MOTDETSC_PROP2}) { # der Wert für Bewegungserkennung SVS -> Schwellwert ist gesetzt
my $threshold = delete $hash->{HELPER}{MOTDETSC_PROP2};
$hash->{HELPER}{CALL}{PART} .= qq{&threshold="$threshold"};
}
}
$hash->{HELPER}{CALL}{PART} .= qq{&_sid="_SID_"};
$hash->{HELPER}{MOTDETOPTIONS} = \%motdetoptions; # Optionswerte in Hash sichern für Logausgabe in Befehlsauswertung
setActiveToken($hash);
checkSid ($hash);
} else {
schedule ($name, $hash);
}
return;
}
###############################################################################
# Kamera Schappschuß aufnehmen
# $num = Anzahl der Schnappschüsse
# $lag = Zeit zwischen zwei Schnappschüssen
# $ncount = Anzahl der Schnappschüsse zum rnterzählen
###############################################################################
sub __camSnap {
my $str = shift;
my ($name,$num,$lag,$ncount,$emtxt,$teletxt,$chattxt,$tac) = split("!_!",$str);
my $hash = $defs{$name};
my $camname = $hash->{CAMNAME};
$tac = $tac // 5000;
my $ta = $hash->{HELPER}{TRANSACTION};
my $caller = (caller(0))[3];
RemoveInternalTimer($hash, $caller);
return if(IsDisabled($name));
return if(exitOnDis ($name, "Snapshot of Camera $camname can't be executed"));
if ($hash->{HELPER}{ACTIVE} eq "off" || (defined $ta && $ta == $tac)) {
$hash->{OPMODE} = "Snap";
return if(startOrShut($name));
$hash->{HELPER}{LOGINRETRIES} = 0;
if (!$hash->{HELPER}{API}{PARSET}) {
getApiSites ($hash, $caller, $str);
return;
}
$hash->{HELPER}{CANSENDSNAP} = 1 if($emtxt); # Versand Schnappschüsse soll per Email erfolgen
$hash->{HELPER}{CANTELESNAP} = 1 if($teletxt); # Versand Schnappschüsse soll per TelegramBot erfolgen
$hash->{HELPER}{CANCHATSNAP} = 1 if($chattxt); # Versand Schnappschüsse soll per SSChatBot erfolgen
$hash->{HELPER}{SNAPNUM} = $num if($num); # Gesamtzahl der auszulösenden Schnappschüsse
$hash->{HELPER}{SNAPLAG} = $lag if($lag); # Zeitverzögerung zwischen zwei Schnappschüssen
$hash->{HELPER}{SNAPNUMCOUNT} = $ncount if($ncount); # Restzahl der auszulösenden Schnappschüsse (wird runtergezählt)
$hash->{HELPER}{SMTPMSG} = $emtxt if($emtxt); # Text für Email-Versand
$hash->{HELPER}{CALL}{VKEY} = "SNAPSHOT";
$hash->{HELPER}{CALL}{PART} = qq{api="_NAME_"&version="_VER_"&dsId="0"&method="TakeSnapshot"&blSave="true"&camId="_CID_"&_sid="_SID_"};
readingsSingleUpdate($hash,"state", "snap", 1);
setActiveToken($hash);
checkSid ($hash);
}
else {
$tac = $tac // "";
schedule ($name, $str);
}
return;
}
###############################################################################
# Kamera gemachte Aufnahme abrufen
###############################################################################
sub __getRec {
my $hash = shift;
my $camname = $hash->{CAMNAME};
my $name = $hash->{NAME};
my $caller = (caller(0))[3];
RemoveInternalTimer($hash, $caller);
return if(IsDisabled($name));
return if(exitOnDis ($name, "Save Recording of Camera $camname in local file can't be executed"));
if ($hash->{HELPER}{ACTIVE} eq "off") {
$hash->{OPMODE} = "GetRec";
return if(startOrShut($name));
$hash->{HELPER}{LOGINRETRIES} = 0;
if (!$hash->{HELPER}{API}{PARSET}) {
getApiSites ($hash, $caller, $hash);
return;
}
$hash->{HELPER}{CALL}{VKEY} = "REC";
my $recid = ReadingsVal("$name", "CamLastRecId", 0);
if($recid) {
$hash->{HELPER}{CALL}{PART} = qq{api="_NAME_"&version="_VER_"&id=$recid&mountId=0&method="Download"&_sid="_SID_"};
}
else {
Log3($name, 2, "$name - WARNING - Can't fetch recording due to no recording available.");
return;
}
setActiveToken($hash);
checkSid ($hash);
}
else {
schedule ($name, $hash);
}
return;
}
###############################################################################
# Kamera gemachte Aufnahme lokal speichern
###############################################################################
sub __getRecAndSave {
my $hash = shift;
my $camname = $hash->{CAMNAME};
my $name = $hash->{NAME};
my $caller = (caller(0))[3];
RemoveInternalTimer($hash, $caller);
return if(IsDisabled($name));
return if(exitOnDis ($name, "Save Recording of Camera $camname in local file can't be executed"));
if ($hash->{HELPER}{ACTIVE} eq "off") {
$hash->{OPMODE} = "SaveRec";
return if(startOrShut($name));
$hash->{HELPER}{LOGINRETRIES} = 0;
if (!$hash->{HELPER}{API}{PARSET}) {
getApiSites ($hash, $caller, $hash);
return;
}
$hash->{HELPER}{CALL}{VKEY} = "REC";
my $recid = ReadingsVal("$name", "CamLastRecId", 0);
if($recid) {
$hash->{HELPER}{CALL}{PART} = qq{api="_NAME_"&version="_VER_"&id=$recid&mountId=0&method="Download"&_sid="_SID_"};
}
else {
Log3($name, 2, "$name - WARNING - Can't fetch recording due to no recording available.");
return;
}
setActiveToken($hash);
checkSid ($hash);
}
else {
schedule ($name, $hash);
}
return;
}
###############################################################################
# Start Object Tracking
###############################################################################
sub __startTrack {
my $hash = shift;
my $camname = $hash->{CAMNAME};
my $name = $hash->{NAME};
my $caller = (caller(0))[3];
RemoveInternalTimer($hash, $caller);
return if(IsDisabled($name));
return if(exitOnDis ($name, "Object Tracking of Camera $camname can't switched on"));
if ($hash->{HELPER}{ACTIVE} eq "off") {
$hash->{OPMODE} = "startTrack";
return if(startOrShut($name));
$hash->{HELPER}{LOGINRETRIES} = 0;
if (!$hash->{HELPER}{API}{PARSET}) {
getApiSites ($hash, $caller, $hash);
return;
}
$hash->{HELPER}{CALL}{VKEY} = "PTZ";
$hash->{HELPER}{CALL}{PART} = qq{api="_NAME_"&version="_VER_"&method="ObjTracking"&cameraId="_CID_"&_sid="_SID_"};
setActiveToken($hash);
checkSid ($hash);
}
else {
schedule ($name, $hash);
}
return;
}
###############################################################################
# Stopp Object Tracking
###############################################################################
sub __stopTrack {
my $hash = shift;
my $camname = $hash->{CAMNAME};
my $name = $hash->{NAME};
my $caller = (caller(0))[3];
RemoveInternalTimer($hash, $caller);
return if(IsDisabled($name));
return if(exitOnDis ($name, "Object Tracking of Camera $camname can't switched off"));
if ($hash->{HELPER}{ACTIVE} eq "off") {
$hash->{OPMODE} = "stopTrack";
return if(startOrShut($name));
$hash->{HELPER}{LOGINRETRIES} = 0;
if (!$hash->{HELPER}{API}{PARSET}) {
getApiSites ($hash, $caller, $hash);
return;
}
$hash->{HELPER}{CALL}{VKEY} = "PTZ";
$hash->{HELPER}{CALL}{PART} = qq{api="_NAME_"&version="_VER_"&method="ObjTracking"&moveType="Stop"&cameraId="_CID_"&_sid="_SID_"};
setActiveToken($hash);
checkSid ($hash);
}
else {
schedule ($name, $hash);
}
return;
}
###############################################################################
# Zoom in / stop / out starten bzw. stoppen
# $op = + / stop / -
###############################################################################
sub __setZoom {
my $str = shift;
my ($name,$op) = split("!_!",$str);
my $hash = $defs{$name};
my $camname = $hash->{CAMNAME};
my $caller = (caller(0))[3];
RemoveInternalTimer($hash, $caller);
return if(IsDisabled($name));
return if(exitOnDis ($name, "Zoom $op of Camera $camname can't be started"));
if ($hash->{HELPER}{ACTIVE} eq "off") {
$hash->{OPMODE} = "setZoom";
return if(startOrShut($name));
$hash->{HELPER}{LOGINRETRIES} = 0;
if (!$hash->{HELPER}{API}{PARSET}) {
getApiSites ($hash, $caller, $str);
return;
}
$hash->{HELPER}{ZOOM}{DIR} = $zd{$op}{dir} // $hash->{HELPER}{ZOOM}{DIR}; # Richtung (in / out)
$hash->{HELPER}{ZOOM}{MOVETYPE} = $zd{$op}{moveType}; # Start / Stop
return if(!$hash->{HELPER}{ZOOM}{DIR}); # es muss ! eine Richtung gesetzt sein
my $dir = $hash->{HELPER}{ZOOM}{DIR};
my $moveType = $hash->{HELPER}{ZOOM}{MOVETYPE};
$hash->{HELPER}{CALL}{VKEY} = "PTZ";
$hash->{HELPER}{CALL}{PART} = qq{api="_NAME_"&version="_VER_"&method="Zoom"&cameraId="_CID_"&control="$dir"&moveType="$moveType"&_sid="_SID_"};
if($hash->{HELPER}{ZOOM}{MOVETYPE} ne "Stop") {
InternalTimer(gettimeofday()+$zd{$op}{sttime}, "FHEM::SSCam::__setZoom", "$name!_!stop", 0);
}
setActiveToken($hash);
checkSid ($hash);
}
else {
schedule ($name, $str);
}
return;
}
###############################################################################
# einen Preset setzen
###############################################################################
sub __setPreset {
my $hash = shift;
my $camname = $hash->{CAMNAME};
my $name = $hash->{NAME};
my $caller = (caller(0))[3];
RemoveInternalTimer($hash, $caller);
return if(IsDisabled($name));
return if(exitOnDis ($name, "Preset of Camera $camname can't be set"));
if ($hash->{HELPER}{ACTIVE} eq "off") {
$hash->{OPMODE} = "setPreset";
return if(startOrShut($name));
$hash->{HELPER}{LOGINRETRIES} = 0;
if (!$hash->{HELPER}{API}{PARSET}) {
getApiSites ($hash, $caller, $hash);
return;
}
$hash->{HELPER}{CALL}{VKEY} = "PRESET";
my $pnumber = $hash->{HELPER}{PNUMBER};
my $pname = $hash->{HELPER}{PNAME};
my $pspeed = $hash->{HELPER}{PSPEED};
if ($pspeed) {
$hash->{HELPER}{CALL}{PART} = qq{api="_NAME_"&version="_VER_"&method="SetPreset"&position=$pnumber&name="$pname"&speed="$pspeed"&cameraId="_CID_"&_sid="_SID_"};
}
else {
$hash->{HELPER}{CALL}{PART} = qq{api="_NAME_"&version="_VER_"&method="SetPreset"&position=$pnumber&name="$pname"&cameraId="_CID_"&_sid="_SID_"};
}
setActiveToken($hash);
checkSid ($hash);
}
else {
schedule ($name, $hash);
}
return;
}
###############################################################################
# einen Preset löschen
###############################################################################
sub __delPreset {
my $hash = shift;
my $camname = $hash->{CAMNAME};
my $name = $hash->{NAME};
my $caller = (caller(0))[3];
RemoveInternalTimer($hash, $caller);
return if(IsDisabled($name));
return if(exitOnDis ($name, "Preset of Camera $camname can't be deleted"));
if ($hash->{HELPER}{ACTIVE} eq "off") {
$hash->{OPMODE} = "delPreset";
return if(startOrShut($name));
$hash->{HELPER}{LOGINRETRIES} = 0;
if (!$hash->{HELPER}{API}{PARSET}) {
getApiSites ($hash, $caller, $hash);
return;
}
my $delp = $hash->{HELPER}{ALLPRESETS}{$hash->{HELPER}{DELPRESETNAME}};
$hash->{HELPER}{CALL}{VKEY} = "PRESET";
$hash->{HELPER}{CALL}{PART} = qq{api="_NAME_"&version="_VER_"&method="DelPreset"&position="$delp"&cameraId="_CID_"&_sid="_SID_"};
setActiveToken($hash);
checkSid ($hash);
}
else {
schedule ($name, $hash);
}
return;
}
###############################################################################
# Preset Home setzen
###############################################################################
sub __setHome {
my $hash = shift;
my $camname = $hash->{CAMNAME};
my $name = $hash->{NAME};
my $caller = (caller(0))[3];
RemoveInternalTimer($hash, $caller);
return if(IsDisabled($name));
return if(exitOnDis ($name, "Home preset of Camera $camname can't be set"));
if ($hash->{HELPER}{ACTIVE} eq "off") {
$hash->{OPMODE} = "setHome";
return if(startOrShut($name));
$hash->{HELPER}{LOGINRETRIES} = 0;
if (!$hash->{HELPER}{API}{PARSET}) {
getApiSites ($hash, $caller, $hash);
return;
}
$hash->{HELPER}{CALL}{VKEY} = "PRESET";
if($hash->{HELPER}{SETHOME} eq "---currentPosition---") {
$hash->{HELPER}{CALL}{PART} = qq{api="_NAME_"&version="_VER_"&method="SetHome"&cameraId="_CID_"&_sid="_SID_"};
}
else {
my $bindpos = $hash->{HELPER}{ALLPRESETS}{$hash->{HELPER}{SETHOME}};
$hash->{HELPER}{CALL}{PART} = qq{api="_NAME_"&version="_VER_"&method="SetHome"&bindPosition="$bindpos"&cameraId="_CID_"&_sid="_SID_"};
}
setActiveToken($hash);
checkSid ($hash);
}
else {
schedule ($name, $hash);
}
return;
}
###########################################################################
# HomeMode setzen
###########################################################################
sub __setHomeMode {
my $hash = shift;
my $camname = $hash->{CAMNAME};
my $name = $hash->{NAME};
my $caller = (caller(0))[3];
RemoveInternalTimer($hash, $caller);
return if(IsDisabled($name) || !defined($hash->{HELPER}{API}{HMODE}{VER}));
if ($hash->{HELPER}{ACTIVE} eq "off") {
$hash->{OPMODE} = "sethomemode";
return if(startOrShut($name));
$hash->{HELPER}{LOGINRETRIES} = 0;
if (!$hash->{HELPER}{API}{PARSET}) {
getApiSites ($hash, $caller, $hash);
return;
}
my $sw = $hash->{HELPER}{HOMEMODE}; # HomeMode on,off
$sw = ($sw eq "on") ? "true" : "false";
$hash->{HELPER}{CALL}{VKEY} = "HMODE";
$hash->{HELPER}{CALL}{PART} = qq{api="_NAME_"&version="_VER_"&method=Switch&on=$sw&_sid="_SID_"};
setActiveToken($hash);
checkSid ($hash);
}
else {
schedule ($name, $hash);
}
return;
}
###########################################################################
# Optimierparameter setzen
###########################################################################
sub __setOptParams {
my $hash = shift;
my $camname = $hash->{CAMNAME};
my $name = $hash->{NAME};
my $caller = (caller(0))[3];
RemoveInternalTimer($hash, $caller);
return if(IsDisabled($name));
if ($hash->{HELPER}{ACTIVE} eq "off") {
$hash->{OPMODE} = "setoptpar";
return if(startOrShut($name));
$hash->{HELPER}{LOGINRETRIES} = 0;
if (!$hash->{HELPER}{API}{PARSET}) {
getApiSites ($hash, $caller, $hash);
return;
}
my $mirr = $hash->{HELPER}{MIRROR} // ReadingsVal($name, "CamVideoMirror", "");
my $flip = $hash->{HELPER}{FLIP} // ReadingsVal($name, "CamVideoFlip", "");
my $rot = $hash->{HELPER}{ROTATE} // ReadingsVal($name, "CamVideoRotate", "");
my $ntp = $hash->{HELPER}{NTPSERV} // ReadingsVal($name, "CamNTPServer", "");
$ntp = q{} if($ntp eq "none");
my $clst = $hash->{HELPER}{CHKLIST} // "";
my $ver = $hash->{HELPER}{API}{CAM}{VER} >= 9 ? 8 : $hash->{HELPER}{API}{CAM}{VER};
$hash->{HELPER}{CALL}{VKEY} = "CAM";
$hash->{HELPER}{CALL}{PART} = qq{api="_NAME_"&version="$ver"&method="SaveOptimizeParam"&vdoMirror=$mirr&vdoRotation=$rot&vdoFlip=$flip&timeServer="$ntp"&camParamChkList=$clst&cameraIds="_CID_"&_sid="_SID_"};
$hash->{HELPER}{CALL}{TO} = 90; # setzen Optimierungsparameter dauert lange !
setActiveToken($hash);
checkSid ($hash);
}
else {
schedule ($name, $hash);
}
return;
}
###############################################################################
# PIR Sensor aktivieren/deaktivieren
###############################################################################
sub __managePir {
my $hash = shift;
my $camname = $hash->{CAMNAME};
my $name = $hash->{NAME};
my $caller = (caller(0))[3];
RemoveInternalTimer($hash, $caller);
return if(IsDisabled($name));
return if(exitOnDis ($name, "PIR of camera $camname cannot be managed"));
if ($hash->{HELPER}{ACTIVE} eq "off") {
$hash->{OPMODE} = "piract";
return if(startOrShut($name));
$hash->{HELPER}{LOGINRETRIES} = 0;
if (!$hash->{HELPER}{API}{PARSET}) {
getApiSites ($hash, $caller, $hash);
return;
}
$hash->{HELPER}{CALL}{VKEY} = "CAMEVENT";
my $piract = $hash->{HELPER}{PIRACT};
$hash->{HELPER}{CALL}{PART} = qq{api="_NAME_"&version="_VER_"&method="PDParamSave"&keep=true&source=$piract&camId="_CID_"&_sid="_SID_"};
setActiveToken($hash);
checkSid ($hash);
}
else {
schedule ($name, $hash);
}
return;
}
###############################################################################
# Kamera Liveview starten
###############################################################################
sub __runLiveview {
my $hash = shift;
my $camname = $hash->{CAMNAME};
my $name = $hash->{NAME};
my $caller = (caller(0))[3];
RemoveInternalTimer($hash, $caller);
return if(IsDisabled($name));
return if(exitOnDis ($name, "Liveview of Camera $camname can't be started"));
if ($hash->{HELPER}{ACTIVE} eq "off") {
$hash->{OPMODE} = "runliveview";
return if(startOrShut($name));
$hash->{HELPER}{LOGINRETRIES} = 0;
if (!$hash->{HELPER}{API}{PARSET}) {
getApiSites ($hash, $caller, $hash);
return;
}
delete $hash->{CAMID}; # erzwingen die Camid zu ermitteln und bei login-Fehler neue SID zu holen
readingsSingleUpdate($hash,"state","runView ".$hash->{HELPER}{RUNVIEW},1);
if ($hash->{HELPER}{RUNVIEW} =~ /snap/x) { # den letzten Schnappschuß live anzeigen
my $limit = 1; # nur 1 Snap laden, für lastsnap_fw
my $imgsize = 2; # full size image, für lastsnap_fw
my $keyword = $hash->{CAMNAME}; # nur Snaps von $camname selektieren, für lastsnap_fw
$hash->{HELPER}{CALL}{VKEY} = "SNAPSHOT";
$hash->{HELPER}{CALL}{PART} = qq{api="_NAME_"&version="_VER_"&method="List"&keyword="$keyword"&imgSize="$imgsize"&limit="$limit"&_sid="_SID_"};
}
if ($hash->{HELPER}{RUNVIEW} =~ m/^live_.*?hls$/x) { # HLS Livestreaming aktivieren
$hash->{HELPER}{CALL}{VKEY} = "VIDEOSTMS";
$hash->{HELPER}{CALL}{TO} = 90; # aktivieren HLS dauert lange !
$hash->{HELPER}{CALL}{PART} = qq{api=_NAME_&version=_VER_&method=Open&cameraId=_CID_&format=hls&_sid=_SID_};
}
if ($hash->{HELPER}{RUNVIEW} !~ m/snap|^live_.*hls$/x) {
if ($hash->{HELPER}{RUNVIEW} =~ m/live/x) {
if(ApiVal ($hash, $hash->{HELPER}{API}{AUDIOSTM}, 'VER', '')) { # Audio aktivieren
$hash->{HELPER}{ACALL}{AKEY} = "AUDIOSTM";
$hash->{HELPER}{ACALL}{APART} = qq{api=_ANAME_&version=_AVER_&method=Stream&cameraId=_CID_&_sid=_SID_};
}
else {
delete $hash->{HELPER}{AUDIOLINK};
}
if(ApiVal ($hash, $hash->{HELPER}{API}{VIDEOSTMS}, 'VER', '')) { # API "SYNO.SurveillanceStation.VideoStream" vorhanden ? (removed ab API v2.8)
$hash->{HELPER}{CALL}{VKEY} = "VIDEOSTMS";
$hash->{HELPER}{CALL}{PART} = qq{api=_NAME_&version=_VER_&method=Stream&cameraId=_CID_&format=mjpeg&_sid=_SID_};
}
}
else {
my $lrecid = ReadingsVal("$name", "CamLastRecId", 0);
$hash->{HELPER}{CALL}{VKEY} = "STM";
$hash->{HELPER}{CALL}{PART} = qq{api=_NAME_&version=_VER_&method=EventStream&eventId=$lrecid×tamp=1&_sid=_SID_};
}
}
setActiveToken($hash);
checkSid ($hash);
}
else {
schedule ($name, $hash);
}
return;
}
###############################################################################
# Kamera HLS-Stream aktivieren
###############################################################################
sub __activateHls {
my $hash = shift;
my $camname = $hash->{CAMNAME};
my $name = $hash->{NAME};
my $caller = (caller(0))[3];
RemoveInternalTimer($hash, $caller);
return if(IsDisabled($name));
return if(exitOnDis ($name, "HLS-Stream of Camera $camname can't be activated"));
if ($hash->{HELPER}{ACTIVE} eq "off") {
$hash->{OPMODE} = "activate_hls";
return if(startOrShut($name));
$hash->{HELPER}{LOGINRETRIES} = 0;
if (!$hash->{HELPER}{API}{PARSET}) {
getApiSites ($hash, $caller, $hash);
return;
}
$hash->{HELPER}{CALL}{VKEY} = "VIDEOSTMS";
$hash->{HELPER}{CALL}{TO} = 90; # aktivieren HLS dauert lange !
$hash->{HELPER}{CALL}{PART} = qq{api=_NAME_&version=_VER_&method=Open&cameraId=_CID_&format=hls&_sid=_SID_};
setActiveToken($hash);
checkSid ($hash);
}
else {
schedule ($name, $hash);
}
return;
}
###############################################################################
# HLS-Stream reaktivieren (stoppen & starten)
###############################################################################
sub __reactivateHls {
my $hash = shift;
my $camname = $hash->{CAMNAME};
my $name = $hash->{NAME};
my $caller = (caller(0))[3];
RemoveInternalTimer($hash, $caller);
return if(IsDisabled($name));
return if(exitOnDis ($name, "HLS-Stream of Camera $camname can't be reactivated"));
if ($hash->{HELPER}{ACTIVE} eq "off") {
$hash->{OPMODE} = "reactivate_hls";
return if(startOrShut($name));
$hash->{HELPER}{LOGINRETRIES} = 0;
if (!$hash->{HELPER}{API}{PARSET}) {
getApiSites ($hash, $caller, $hash);
return;
}
$hash->{HELPER}{CALL}{VKEY} = "VIDEOSTMS";
$hash->{HELPER}{CALL}{PART} = qq{api=_NAME_&version=_VER_&method=Close&cameraId=_CID_&format=hls&_sid=_SID_};
setActiveToken($hash);
checkSid ($hash);
}
else {
schedule ($name, $hash);
}
return;
}
###############################################################################
# Kameras mit Autocreate erstellen
###############################################################################
sub __camAutocreate {
my $hash = shift;
my $name = $hash->{NAME};
my $caller = (caller(0))[3];
RemoveInternalTimer($hash, $caller);
return if(IsDisabled($name));
return if(exitOnDis ($name, "autocreate cameras not possible"));
if ($hash->{HELPER}{ACTIVE} eq "off") {
$hash->{OPMODE} = "Autocreate";
return if(startOrShut($name));
$hash->{HELPER}{LOGINRETRIES} = 0;
if (!$hash->{HELPER}{API}{PARSET}) {
getApiSites ($hash, $caller, $hash);
return;
}
setActiveToken($hash);
checkSid ($hash);
}
else {
schedule ($name, $hash);
}
return;
}
###############################################################################
# Kamera Liveview stoppen
###############################################################################
sub __stopLiveview {
my $hash = shift;
my $name = $hash->{NAME};
my $caller = (caller(0))[3];
RemoveInternalTimer($hash, $caller);
return if(IsDisabled($name));
if ($hash->{HELPER}{ACTIVE} eq "off") {
$hash->{OPMODE} = "stopliveview";
$hash->{HELPER}{LOGINRETRIES} = 0;
if (!$hash->{HELPER}{API}{PARSET}) {
getApiSites ($hash, $caller, $hash);
return;
}
setActiveToken($hash);
delete $hash->{HELPER}{LINK}; # Link aus Helper-hash löschen
delete $hash->{HELPER}{AUDIOLINK};
delete $hash->{HELPER}{ACTSTRM}; # sprechender Name des laufenden Streamtyps für SSCamSTRM
delete($defs{$name}{READINGS}{LiveStreamUrl}) if ($defs{$name}{READINGS}{LiveStreamUrl}); # Reading LiveStreamUrl löschen
readingsSingleUpdate($hash,"state","stopview",1);
if($hash->{HELPER}{WLTYPE} eq "hls") { # HLS Stream war aktiv, Streaming beenden
$hash->{OPMODE} = "stopliveview_hls";
$hash->{HELPER}{CALL}{VKEY} = "VIDEOSTMS";
$hash->{HELPER}{CALL}{PART} = qq{api=_NAME_&version=_VER_&method=Close&cameraId=_CID_&format=hls&_sid=_SID_};
return if(startOrShut($name));
checkSid ($hash);
}
else { # kein HLS Stream
roomRefresh ($hash,0,1,1); # kein Room-Refresh, SSCam-state-Event, SSCamSTRM-Event
delActiveToken($hash);
}
}
else {
schedule ($name, $hash);
}
return;
}
###############################################################################
# external Event 1-10 auslösen
###############################################################################
sub __extEvent {
my $hash = shift;
my $name = $hash->{NAME};
my $caller = (caller(0))[3];
RemoveInternalTimer($hash, $caller);
return if(IsDisabled($name));
if ($hash->{HELPER}{ACTIVE} eq "off") {
$hash->{OPMODE} = "extevent";
return if(startOrShut($name));
$hash->{HELPER}{LOGINRETRIES} = 0;
if (!$hash->{HELPER}{API}{PARSET}) {
getApiSites ($hash, $caller, $hash);
return;
}
my $evtid = $hash->{HELPER}{EVENTID};
$hash->{HELPER}{CALL}{VKEY} = "EXTEVT";
$hash->{HELPER}{CALL}{PART} = qq{api=_NAME_&version=_VER_&method=Trigger&eventId=$evtid&eventName=$evtid&_sid="_SID_"};
Log3($name, 4, "$name - trigger external event \"$evtid\"");
setActiveToken($hash);
checkSid ($hash);
}
else {
schedule ($name, $hash);
}
return;
}
###############################################################################
# PTZ-Kamera Aktion ausführen
###############################################################################
sub __doPtzAaction {
my $hash = shift;
my $camname = $hash->{CAMNAME};
my $name = $hash->{NAME};
my ($errorcode,$error);
my $caller = (caller(0))[3];
RemoveInternalTimer($hash, $caller);
return if(IsDisabled($name));
if (!IsCapPTZ($hash)) {
Log3($name, 2, "$name - ERROR - Operation \"$hash->{HELPER}{PTZACTION}\" is only possible for cameras of DeviceType \"PTZ\" - please compare with device Readings");
return;
}
if ($hash->{HELPER}{PTZACTION} eq "goabsptz" && !IsCapPTZAbs($hash)) {
Log3($name, 2, "$name - ERROR - Operation \"$hash->{HELPER}{PTZACTION}\" is only possible if camera supports absolute PTZ action - please compare with Reading \"CapPTZAbs\"");
return;
}
if ($hash->{HELPER}{PTZACTION} eq "movestart" && !IsCapPTZDir($hash)) {
Log3($name, 2, "$name - ERROR - Operation \"$hash->{HELPER}{PTZACTION}\" is only possible if camera supports \"Tilt\" and \"Pan\" operations - please compare with device Reading \"CapPTZDirections\"");
return;
}
return if(exitOnDis ($name, "$hash->{HELPER}{PTZACTION} of Camera $camname can't be executed"));
if ($hash->{HELPER}{ACTIVE} eq "off") {
if ($hash->{HELPER}{PTZACTION} eq "gopreset") {
if (!defined($hash->{HELPER}{ALLPRESETS}{$hash->{HELPER}{GOPRESETNAME}})) {
$errorcode = "600";
$error = expErrors($hash,$errorcode); # Fehlertext zum Errorcode ermitteln
readingsBeginUpdate ($hash);
readingsBulkUpdate ($hash, "Errorcode", $errorcode);
readingsBulkUpdate ($hash, "Error", $error );
readingsEndUpdate ($hash, 1);
Log3($name, 2, "$name - ERROR - goPreset to position \"$hash->{HELPER}{GOPRESETNAME}\" of Camera $camname can't be executed - $error");
return;
}
}
if ($hash->{HELPER}{PTZACTION} eq "runpatrol") {
my $patid = $hash->{HELPER}{ALLPATROLS}{$hash->{HELPER}{GOPATROLNAME}};
if (!defined $patid) {
$errorcode = "600";
$error = expErrors($hash,$errorcode); # Fehlertext zum Errorcode ermitteln
readingsBeginUpdate ($hash);
readingsBulkUpdate ($hash, "Errorcode", $errorcode);
readingsBulkUpdate ($hash, "Error", $error );
readingsEndUpdate ($hash, 1);
Log3($name, 2, "$name - ERROR - runPatrol to patrol \"$hash->{HELPER}{GOPATROLNAME}\" of Camera $camname can't be executed - $error");
return;
}
$hash->{HELPER}{CALL}{VKEY} = "PTZ";
$hash->{HELPER}{CALL}{PART} = qq{api="_NAME_"&version="_VER_"&method="RunPatrol"&patrolId="$patid"&cameraId="_CID_"&_sid="_SID_"};
Log3($name, 4, "$name - Start patrol \"$hash->{HELPER}{GOPATROLNAME}\" with ID \"$hash->{HELPER}{ALLPATROLS}{$hash->{HELPER}{GOPATROLNAME}}\" of Camera $camname now");
}
if ($hash->{HELPER}{PTZACTION} eq "gopreset") {
$hash->{HELPER}{CALL}{VKEY} = "PTZ";
my $ver = ($hash->{HELPER}{API}{PTZ}{VER} >= 5) ? 4 : $hash->{HELPER}{API}{PTZ}{VER};
my $posid = $hash->{HELPER}{ALLPRESETS}{$hash->{HELPER}{GOPRESETNAME}};
$hash->{HELPER}{CALL}{PART} = qq{api="_NAME_"&version="$ver"&method="GoPreset"&position="$posid"&cameraId="_CID_"&_sid="_SID_"};
Log3($name, 4, "$name - Move Camera $camname to position \"$hash->{HELPER}{GOPRESETNAME}\" with ID \"$posid\" now");
}
if ($hash->{HELPER}{PTZACTION} eq "goabsptz") {
my $posx = $hash->{HELPER}{GOPTZPOSX};
my $posy = $hash->{HELPER}{GOPTZPOSY};
$hash->{HELPER}{CALL}{VKEY} = "PTZ";
$hash->{HELPER}{CALL}{PART} = qq{api="_NAME_"&version="_VER_"&method="AbsPtz"&cameraId="_CID_"&posX="$posx"&posY="$posy"&_sid="_SID_"};
Log3($name, 4, "$name - Start move Camera $camname to position posX=\"$hash->{HELPER}{GOPTZPOSX}\" and posY=\"$hash->{HELPER}{GOPTZPOSY}\" now");
}
if ($hash->{HELPER}{PTZACTION} eq "movestart") {
my $mdir = $hash->{HELPER}{GOMOVEDIR};
$hash->{HELPER}{CALL}{VKEY} = "PTZ";
$hash->{HELPER}{CALL}{PART} = qq{api="_NAME_"&version="_VER_"&method="Move"&cameraId="_CID_"&direction="$mdir"&speed="3"&moveType="Start"&_sid="_SID_"};
Log3($name, 4, "$name - Start move Camera $camname to direction \"$hash->{HELPER}{GOMOVEDIR}\" with duration of $hash->{HELPER}{GOMOVETIME} s");
}
$hash->{OPMODE} = $hash->{HELPER}{PTZACTION};
return if(startOrShut($name));
$hash->{HELPER}{LOGINRETRIES} = 0;
if (!$hash->{HELPER}{API}{PARSET}) {
getApiSites ($hash, $caller, $hash);
return;
}
setActiveToken($hash);
checkSid ($hash);
}
else {
schedule ($name, $hash);
}
return;
}
###############################################################################
# stoppen continued move
###############################################################################
sub __moveStop { ## no critic "not used"
my $hash = shift;
my $name = $hash->{NAME};
my $caller = (caller(0))[3];
RemoveInternalTimer($hash, $caller);
return if(IsDisabled($name));
if ($hash->{HELPER}{ACTIVE} eq "off") {
$hash->{OPMODE} = "movestop";
return if(startOrShut($name));
$hash->{HELPER}{LOGINRETRIES} = 0;
if (!$hash->{HELPER}{API}{PARSET}) {
getApiSites ($hash, $caller, $hash);
return;
}
my $mdir = $hash->{HELPER}{GOMOVEDIR};
$hash->{HELPER}{CALL}{VKEY} = "PTZ";
$hash->{HELPER}{CALL}{PART} = qq{api="_NAME_"&version="_VER_"&method="Move"&cameraId="_CID_"&direction="$mdir"&moveType="Stop"&_sid="_SID_"};
Log3($name, 4, "$name - Stop Camera $hash->{CAMNAME} moving to direction \"$hash->{HELPER}{GOMOVEDIR}\" now");
setActiveToken($hash);
checkSid ($hash);
}
else {
schedule ($name, $hash);
}
return;
}
###############################################################################
# Kamera aktivieren
###############################################################################
sub __camEnable {
my $hash = shift;
my $camname = $hash->{CAMNAME};
my $name = $hash->{NAME};
my $caller = (caller(0))[3];
RemoveInternalTimer($hash, $caller);
return if(IsDisabled($name));
if ($hash->{HELPER}{ACTIVE} eq "off") {
$hash->{OPMODE} = "Enable";
return if(startOrShut($name));
$hash->{HELPER}{LOGINRETRIES} = 0;
if (!$hash->{HELPER}{API}{PARSET}) {
getApiSites ($hash, $caller, $hash);
return;
}
$hash->{HELPER}{CALL}{VKEY} = "CAM";
$hash->{HELPER}{CALL}{PART} = qq{api=_NAME_&version=_VER_&method=Enable&cameraIds=_CID_&_sid="_SID_"};
if($hash->{HELPER}{API}{CAM}{VER} >= 9) {
$hash->{HELPER}{CALL}{PART} = qq{api="_NAME_"&version=_VER_&method="Enable"&idList="_CID_"&_sid="_SID_"};
}
Log3($name, 4, "$name - Enable Camera $camname");
setActiveToken($hash);
checkSid ($hash);
}
else {
schedule ($name, $hash);
}
return;
}
###############################################################################
# Kamera deaktivieren
###############################################################################
sub __camDisable {
my $hash = shift;
my $camname = $hash->{CAMNAME};
my $name = $hash->{NAME};
my $caller = (caller(0))[3];
RemoveInternalTimer($hash, $caller);
return if(IsDisabled($name));
if ($hash->{HELPER}{ACTIVE} eq "off" and ReadingsVal("$name", "Record", "Start") ne "Start") {
$hash->{OPMODE} = "Disable";
return if(startOrShut($name));
$hash->{HELPER}{LOGINRETRIES} = 0;
if (!$hash->{HELPER}{API}{PARSET}) {
getApiSites ($hash, $caller, $hash);
return;
}
$hash->{HELPER}{CALL}{VKEY} = "CAM";
$hash->{HELPER}{CALL}{TO} = 90; # Disable dauert lange !
$hash->{HELPER}{CALL}{PART} = qq{api=_NAME_&version=_VER_&method=Disable&cameraIds=_CID_&_sid="_SID_"};
if($hash->{HELPER}{API}{CAM}{VER} >= 9) {
$hash->{HELPER}{CALL}{PART} = qq{api="_NAME_"&version=_VER_&method="Disable"&idList="_CID_"&_sid="_SID_"};
}
Log3($name, 4, "$name - Disable Camera $camname");
setActiveToken($hash);
checkSid ($hash);
}
else {
schedule ($name, $hash);
}
return;
}
################################################################
# Get
################################################################
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 $getlist = "Unknown argument $opt, choose one of ";
if(!$hash->{CREDENTIALS}) {
return;
}
elsif(IsModelCam($hash)) { # getlist für Cams
$getlist .= "caminfo:noArg ".
((AttrVal($name,"snapGalleryNumber",undef) || AttrVal($name,"snapGalleryBoost",0))
? "snapGallery:noArg " : "snapGallery:$defSnum ").
(IsCapPTZPan($hash) ? "listPresets:noArg " : "").
"snapinfo:noArg ".
"saveRecording ".
"saveLastSnap ".
"snapfileinfo:noArg ".
"eventlist:noArg ".
"stmUrlPath:noArg "
;
}
else { # getlist für SVS Devices
$getlist .= ($hash->{HELPER}{API}{HMODE}{VER} ? "homeModeState:noArg " : "").
"listLog "
;
}
$getlist .= "caminfoall:noArg ". # Ergänzend für beiden Device Typen
"svsinfo:noArg ".
"scanVirgin:noArg ".
"storedCredentials:noArg ".
"versionNotes ".
"apiInfo:noArg "
;
return if(IsDisabled($name));
my $params = {
hash => $hash,
name => $name,
opt => $opt,
arg => $arg,
arg1 => $arg1,
arg2 => $arg2,
};
no strict "refs"; ## no critic 'NoStrict'
if($hget{$opt} && defined &{$hget{$opt}{fn}}) {
my $ret = q{};
if (!$hash->{CREDENTIALS} && $hget{$opt}{needcred}) {
return qq{Credentials of $name are not set. Make sure they are set with "set $name credentials "};
}
$ret = &{$hget{$opt}{fn}} ($params);
return $ret;
}
use strict "refs";
return $getlist;
}
################################################################
# Getter apiInfo - Anzeige die API Infos in Popup
################################################################
sub _getapiInfo { ## no critic "not used"
my $paref = shift;
my $hash = $paref->{hash};
getClHash ($hash,1);
__getApiInfo($hash);
return;
}
################################################################
# Getter caminfo
################################################################
sub _getcaminfo { ## no critic "not used"
my $paref = shift;
my $hash = $paref->{hash};
__getCamInfo($hash);
return;
}
################################################################
# Getter caminfoall
################################################################
sub _getcaminfoall { ## no critic "not used"
my $paref = shift;
my $hash = $paref->{hash};
__getCaminfoAll($hash,1); # "1" ist Statusbit für manuelle Abfrage, kein Einstieg in Pollingroutine
return;
}
################################################################
# Getter homeModeState
################################################################
sub _gethomeModeState { ## no critic "not used"
my $paref = shift;
my $hash = $paref->{hash};
return if(IsModelCam($hash));
__getHomeModeState($hash);
return;
}
################################################################
# Getter listLog
################################################################
sub _getlistLog { ## no critic "not used"
my $paref = shift;
my $hash = $paref->{hash};
my $arg = $paref->{arg};
my $arg1 = $paref->{arg1};
my $arg2 = $paref->{arg2};
return if(IsModelCam($hash));
getClHash($hash,1); # übergebenen CL-Hash (FHEMWEB) in Helper eintragen
extlogargs($hash, $arg) if($arg);
extlogargs($hash, $arg1) if($arg1);
extlogargs($hash, $arg2) if($arg2);
__getSvsLog ($hash);
return;
}
################################################################
# Getter listPresets
################################################################
sub _getlistPresets { ## no critic "not used"
my $paref = shift;
my $hash = $paref->{hash};
return if(!IsModelCam($hash));
getClHash ($hash,1); # übergebenen CL-Hash (FHEMWEB) in Helper eintragen
__getPresets($hash);
return;
}
################################################################
# Getter saveRecording
################################################################
sub _getsaveRecording { ## no critic "not used"
my $paref = shift;
my $hash = $paref->{hash};
my $arg = $paref->{arg};
return if(!IsModelCam($hash));
$hash->{HELPER}{RECSAVEPATH} = $arg if($arg);
__getRecAndSave($hash);
return;
}
################################################################
# Getter saveLastSnap
# Letzten Snap in File speichern
################################################################
sub _getsaveLastSnap { ## no critic 'not used'
my $paref = shift;
my $hash = $paref->{hash};
my $name = $paref->{name};
my $path = $paref->{arg} // $attr{global}{modpath};
return if(!IsModelCam($hash));
my ($imgdata,$err);
my $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" ) {
$imgdata = $data{SSCam}{$name}{LASTSNAP};
}
else {
$imgdata = cache($name, "c_read", "{LASTSNAP}");
}
if(!$imgdata) {
Log3($name, 2, "$name - No image data available to save locally")
}
my $fname = ReadingsVal($name, "LastSnapFilename", "");
my $file = $path."/$fname";
open my $fh, '>', $file or do { $err = qq{Can't open file "$file": $!};
Log3($name, 2, "$name - $err");
};
if(!$err) {
$err = "none";
binmode $fh;
print $fh MIME::Base64::decode_base64($imgdata);
close($fh);
Log3($name, 3, qq{$name - Last Snapshot was saved to local file "$file"});
}
readingsBeginUpdate ($hash);
readingsBulkUpdate ($hash, "Errorcode", "none");
readingsBulkUpdate ($hash, "Error", $err );
readingsEndUpdate ($hash, 1);
return;
}
################################################################
# Getter svsinfo
################################################################
sub _getsvsinfo { ## no critic "not used"
my $paref = shift;
my $hash = $paref->{hash};
__getSvsInfo($hash);
return;
}
################################################################
# Getter storedCredentials
################################################################
sub _getstoredCredentials { ## no critic "not used"
my $paref = shift;
my $hash = $paref->{hash};
my $out = showStoredCredentials ($hash, 3);
return $out;
}
################################################################
# Getter snapGallery
################################################################
sub _getsnapGallery { ## no critic "not used"
my $paref = shift;
my $hash = $paref->{hash};
my $name = $paref->{name};
my $arg = $paref->{arg};
return if(!IsModelCam($hash));
my $ret = getClHash($hash);
return $ret if($ret);
if(!AttrVal($name, "snapGalleryBoost",0)) { # Snaphash ist nicht vorhanden und wird abgerufen
$hash->{HELPER}{GETSNAPGALLERY} = 1;
my $slim = $arg // AttrVal($name,"snapGalleryNumber",$defSlim); # Anzahl der abzurufenden Snapshots
my $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;
}
}
delClHash ($name);
}
return;
}
################################################################
# Getter snapinfo
# Schnappschußgalerie abrufen oder nur Info des letzten Snaps
################################################################
sub _getsnapinfo { ## no critic "not used"
my $paref = shift;
my $hash = $paref->{hash};
my $name = $paref->{name};
return if(!IsModelCam($hash));
my ($slim,$ssize) = snapLimSize($hash,1); # Force-Bit, es wird $hash->{HELPER}{GETSNAPGALLERY} gesetzt !
__getSnapInfo("$name:$slim:$ssize");
return;
}
################################################################
# Getter snapfileinfo
################################################################
sub _getsnapfileinfo { ## no critic "not used"
my $paref = shift;
my $hash = $paref->{hash};
my $name = $paref->{name};
return if(!IsModelCam($hash));
if (!ReadingsVal($name, "LastSnapId", undef)) {
return "Reading LastSnapId is empty - please take a snapshot before !"
}
__getSnapFilename($hash);
return;
}
################################################################
# Getter eventlist
################################################################
sub _geteventlist { ## no critic "not used"
my $paref = shift;
my $hash = $paref->{hash};
return if(!IsModelCam($hash));
__getEventList($hash);
return;
}
################################################################
# Getter stmUrlPath
################################################################
sub _getstmUrlPath { ## no critic "not used"
my $paref = shift;
my $hash = $paref->{hash};
return if(!IsModelCam($hash));
__getStmUrlPath($hash);
return;
}
################################################################
# Getter scanVirgin
################################################################
sub _getscanVirgin { ## no critic "not used"
my $paref = shift;
my $hash = $paref->{hash};
my $name = $paref->{name};
__sessionOff($hash);
delete $hash->{HELPER}{API}{PARSET};
delete $hash->{CAMID};
my @allrds = keys%{$defs{$name}{READINGS}};
for my $key(@allrds) { # vorhandene Readings außer "state" löschen
delete($defs{$name}{READINGS}{$key}) if($key ne "state");
}
__getCaminfoAll($hash,1); # "1" ist Statusbit für manuelle Abfrage, kein Einstieg in Pollingroutine
return;
}
################################################################
# Getter versionNotes
################################################################
sub _getversionNotes { ## no critic "not used"
my $paref = shift;
$paref->{hintextde} = \%vHintsExt_de;
$paref->{hintexten} = \%vHintsExt_en;
$paref->{notesext} = \%vNotesExtern;
my $ret = showModuleInfo ($paref);
return $ret;
}
###########################################################################
# API Infos abfragen und in einem Popup anzeigen
###########################################################################
sub __getApiInfo {
my $hash = shift;
my $name = $hash->{NAME};
my $caller = (caller(0))[3];
RemoveInternalTimer($hash, $caller);
return if(IsDisabled($name));
if ($hash->{HELPER}{ACTIVE} eq "off") {
$hash->{OPMODE} = "apiInfo";
return if(startOrShut($name));
$hash->{HELPER}{API}{PARSET} = 0; # Abruf API Infos erzwingen
setActiveToken ($hash);
getApiSites ($hash, "", $hash);
}
else {
schedule ($name, $hash);
}
return;
}
###########################################################################
# Kamera allgemeine Informationen abrufen (Get)
###########################################################################
sub __getCamInfo {
my $hash = shift;
my $camname = $hash->{CAMNAME};
my $name = $hash->{NAME};
my $caller = (caller(0))[3];
RemoveInternalTimer($hash, $caller);
return if(IsDisabled($name));
if ($hash->{HELPER}{ACTIVE} eq "off") {
$hash->{OPMODE} = "Getcaminfo";
return if(startOrShut($name));
$hash->{HELPER}{LOGINRETRIES} = 0;
if (!$hash->{HELPER}{API}{PARSET}) {
getApiSites ($hash, $caller, $hash);
return;
}
$hash->{HELPER}{CALL}{VKEY} = "CAM";
my $ver = ($hash->{HELPER}{API}{CAM}{VER} >= 9) ? 8 : $hash->{HELPER}{API}{CAM}{VER};
$hash->{HELPER}{CALL}{PART} = qq{api="_NAME_"&version="$ver"&method="GetInfo"&cameraIds="_CID_"&deviceOutCap="true"&streamInfo="true"&ptz="true"&basic="true"&camAppInfo="true"&optimize="true"&fisheye="true"&eventDetection="true"&_sid="_SID_"};
setActiveToken($hash);
checkSid ($hash);
}
else {
schedule ($name, $hash);
}
return;
}
###############################################################################
# Kamera alle Informationen abrufen (Get) bzw. Einstieg Polling
###############################################################################
sub __getCaminfoAll {
my $hash = shift;
my $mode = shift;
my $camname = $hash->{CAMNAME};
my $name = $hash->{NAME};
my $caller = (caller(0))[3];
RemoveInternalTimer($hash, $caller);
return if(IsDisabled($name));
if(IsModelCam($hash)) { # Model ist CAM
__getCapabilities ($hash);
__getEventList ($hash);
__getMotionEnum ($hash);
__getCamInfo ($hash);
__getStreamFormat ($hash);
__getStmUrlPath ($hash);
my ($slim,$ssize) = snapLimSize($hash,1);
__getSnapInfo ("$name:$slim:$ssize"); # Schnappschußgalerie abrufen (snapGalleryBoost) oder nur Info des letzten Snaps, Force-Bit -> es wird $hash->{HELPER}{GETSNAPGALLERY} erzwungen !
}
else { # Model ist SVS
__getHomeModeState ($hash);
__getSvsLog ($hash);
}
__getSvsInfo ($hash);
my $pcia = AttrVal($name,"pollcaminfoall", 0);
my $pnl = AttrVal($name,"pollnologging", 0);
if ($pcia) {
my $new = gettimeofday()+$pcia;
InternalTimer($new, $caller, $hash, 0);
my $now = FmtTime(gettimeofday());
$new = FmtTime(gettimeofday()+$pcia);
readingsSingleUpdate($hash, "state", "polling", 1) if(!IsModelCam($hash)); # state für SVS-Device setzen
readingsSingleUpdate($hash, "PollState", "Active - next time: $new", 1);
if (!$pnl) {
Log3($name, 3, "$name - Polling now: $now , next Polling: $new");
}
}
else { # Beenden Polling aller Caminfos
readingsSingleUpdate($hash, "PollState", "Inactive", 1);
readingsSingleUpdate($hash, "state", "initialized",1) if(!IsModelCam($hash)); # state für SVS-Device setzen
Log3($name, 3, "$name - Polling of $camname is deactivated");
}
return;
}
###########################################################################
# HomeMode Status abfragen
###########################################################################
sub __getHomeModeState {
my $hash = shift;
my $camname = $hash->{CAMNAME};
my $name = $hash->{NAME};
my $caller = (caller(0))[3];
RemoveInternalTimer($hash, $caller);
return if(IsDisabled($name) || !defined($hash->{HELPER}{API}{HMODE}{VER}));
if ($hash->{HELPER}{ACTIVE} eq "off") {
$hash->{OPMODE} = "gethomemodestate";
return if(startOrShut($name));
$hash->{HELPER}{LOGINRETRIES} = 0;
if (!$hash->{HELPER}{API}{PARSET}) {
getApiSites ($hash, $caller, $hash);
return;
}
$hash->{HELPER}{CALL}{VKEY} = "HMODE";
$hash->{HELPER}{CALL}{PART} = qq{api="_NAME_"&version="_VER_"&method=GetInfo&_sid="_SID_"};
setActiveToken($hash);
checkSid ($hash);
}
else {
schedule ($name, $hash);
}
return;
}
###########################################################################
# SVS Log abrufen
###########################################################################
sub __getSvsLog {
my $hash = shift;
my $camname = $hash->{CAMNAME};
my $name = $hash->{NAME};
my $caller = (caller(0))[3];
RemoveInternalTimer($hash, $caller);
return if(IsDisabled($name));
if ($hash->{HELPER}{ACTIVE} eq "off") {
$hash->{OPMODE} = "getsvslog";
return if(startOrShut($name));
$hash->{HELPER}{LOGINRETRIES} = 0;
if (!$hash->{HELPER}{API}{PARSET}) {
getApiSites ($hash, $caller, $hash);
return;
}
my $sev = delete $hash->{HELPER}{LISTLOGSEVERITY} // "";
my $lim = delete $hash->{HELPER}{LISTLOGLIMIT} // 0;
my $mco = delete $hash->{HELPER}{LISTLOGMATCH} // "";
$lim = 1 if(!$hash->{HELPER}{CL}{1}); # Datenabruf im Hintergrund
$mco = IsModelCam($hash) ? $hash->{CAMNAME} : $mco;
$sev = (lc($sev) =~ /error/x) ? 3 :(lc($sev) =~ /warning/x) ? 2 :(lc($sev) =~ /info/x) ? 1 : "";
$hash->{HELPER}{CALL}{VKEY} = "LOG";
$hash->{HELPER}{CALL}{PART} = qq{api=_NAME_&version="2"&method="List"&time2String="no"&level="$sev"&limit="$lim"&keyword="$mco"&_sid="_SID_"};
Log3($name,4, "$name - get logList with params: severity => $sev, limit => $lim, matchcode => $mco");
setActiveToken($hash);
checkSid ($hash);
}
else {
schedule ($name, $hash);
}
return;
}
###########################################################################
# allgemeine Infos über Synology Surveillance Station
###########################################################################
sub __getSvsInfo {
my $hash = shift;
my $camname = $hash->{CAMNAME};
my $name = $hash->{NAME};
my $caller = (caller(0))[3];
RemoveInternalTimer($hash, $caller);
return if(IsDisabled($name));
if ($hash->{HELPER}{ACTIVE} eq "off") {
$hash->{OPMODE} = "getsvsinfo";
return if(startOrShut($name));
$hash->{HELPER}{LOGINRETRIES} = 0;
if (!$hash->{HELPER}{API}{PARSET}) {
getApiSites ($hash, $caller, $hash);
return;
}
$hash->{HELPER}{CALL}{VKEY} = "SVSINFO";
$hash->{HELPER}{CALL}{PART} = qq{api="_NAME_"&version="_VER_"&method="GetInfo"&_sid="_SID_"};
setActiveToken($hash);
checkSid ($hash);
}
else {
schedule ($name, $hash);
}
return;
}
###########################################################################
# Infos zu Snaps abfragen (z.B. weil nicht über SSCam ausgelöst)
#
# $slim = Anzahl der abzurufenden Snapinfos (snaps)
# $ssize = Snapgröße
# $tac = Transaktionscode (für gemeinsamen Versand)
###########################################################################
sub __getSnapInfo {
my $str = shift;
my ($name,$slim,$ssize,$tac) = split(":",$str);
my $hash = $defs{$name};
my $camname = $hash->{CAMNAME};
$tac = $tac // 5000;
my $ta = $hash->{HELPER}{TRANSACTION};
my $caller = (caller(0))[3];
RemoveInternalTimer($hash, $caller);
return if(IsDisabled($name));
if ($hash->{HELPER}{ACTIVE} eq "off" || ((defined $ta) && $ta == $tac)) {
$hash->{OPMODE} = "getsnapinfo";
$hash->{OPMODE} = "getsnapgallery" if(exists($hash->{HELPER}{GETSNAPGALLERY}));
return if(startOrShut($name));
$hash->{HELPER}{LOGINRETRIES} = 0;
if (!$hash->{HELPER}{API}{PARSET}) {
getApiSites ($hash, $caller, $str);
return;
}
my $limit = $slim; # 0-alle Snapshots werden abgerufen und ausgewertet, sonst $slim
$hash->{HELPER}{SNAPLIMIT} = $slim;
my $imgsize = $ssize; # 0-Do not append image, 1-Icon size, 2-Full size
my $keyword = $camname;
my $snapid = ReadingsVal("$name", "LastSnapId", " ");
$hash->{HELPER}{CALL}{VKEY} = "SNAPSHOT";
if($hash->{OPMODE} eq "getsnapinfo" && $snapid =~/\d+/x) { # getsnapinfo UND Reading LastSnapId gesetzt
Log3($name,4, "$name - Call getsnapinfo with params: Image numbers => $limit, Image size => $imgsize, Id => $snapid");
$hash->{HELPER}{CALL}{PART} = qq{api="_NAME_"&version="_VER_"&method="List"&idList="$snapid"&imgSize="$imgsize"&limit="$limit"&_sid="_SID_"};
}
else { # snapgallery oder kein Reading LastSnapId gesetzt
Log3($name,4, "$name - Call getsnapinfo with params: Image numbers => $limit, Image size => $imgsize, Keyword => $keyword");
$hash->{HELPER}{CALL}{PART} = qq{api="_NAME_"&version="_VER_"&method="List"&keyword="$keyword"&imgSize="$imgsize"&limit="$limit"&_sid="_SID_"};
}
setActiveToken($hash);
checkSid ($hash);
}
else {
schedule ($name, $str);
}
return;
}
###############################################################################
# Liste der Presets abrufen
###############################################################################
sub __getPresets {
my $hash = shift;
my $camname = $hash->{CAMNAME};
my $name = $hash->{NAME};
my $caller = (caller(0))[3];
RemoveInternalTimer($hash, $caller);
return if(IsDisabled($name));
return if(exitOnDis ($name, "Preset list of Camera $camname can't be get"));
if ($hash->{HELPER}{ACTIVE} eq "off") {
$hash->{OPMODE} = "getPresets";
return if(startOrShut($name));
$hash->{HELPER}{LOGINRETRIES} = 0;
if (!$hash->{HELPER}{API}{PARSET}) {
getApiSites ($hash, $caller, $hash);
return;
}
$hash->{HELPER}{CALL}{VKEY} = "PRESET";
$hash->{HELPER}{CALL}{PART} = qq{api="_NAME_"&version="_VER_"&method="Enum"&cameraId="_CID_"&_sid="_SID_"};
setActiveToken($hash);
checkSid ($hash);
}
else {
schedule ($name, $hash);
}
return;
}
###############################################################################
# der Filename der aktuellen Schnappschuß-ID wird ermittelt
###############################################################################
sub __getSnapFilename {
my $hash = shift;
my $name = $hash->{NAME};
my $caller = (caller(0))[3];
RemoveInternalTimer($hash, $caller);
return if(IsDisabled($name));
if ($hash->{HELPER}{ACTIVE} eq "off") {
$hash->{OPMODE} = "getsnapfilename";
return if(startOrShut($name));
$hash->{HELPER}{LOGINRETRIES} = 0;
if (!$hash->{HELPER}{API}{PARSET}) {
getApiSites ($hash, $caller, $hash);
return;
}
my $snapid = ReadingsVal("$name", "LastSnapId", "");
Log3($name, 4, "$name - Get filename of present Snap-ID $snapid");
$hash->{HELPER}{CALL}{VKEY} = "SNAPSHOT";
$hash->{HELPER}{CALL}{PART} = qq{api="_NAME_"&version="_VER_"&method="List"&imgSize="0"&idList="$snapid"&_sid="_SID_"};
setActiveToken($hash);
checkSid ($hash);
}
else {
schedule ($name, $hash);
}
return;
}
################################################################################
# Kamera Stream Urls abrufen (Get)
################################################################################
sub __getStmUrlPath {
my $hash = shift;
my $camname = $hash->{CAMNAME};
my $name = $hash->{NAME};
my $caller = (caller(0))[3];
RemoveInternalTimer($hash, $caller);
return if(IsDisabled($name));
if ($hash->{HELPER}{ACTIVE} eq "off") {
$hash->{OPMODE} = "getStmUrlPath";
return if(startOrShut($name));
$hash->{HELPER}{LOGINRETRIES} = 0;
if (!$hash->{HELPER}{API}{PARSET}) {
getApiSites ($hash, $caller, $hash);
return;
}
$hash->{HELPER}{CALL}{VKEY} = "CAM";
$hash->{HELPER}{CALL}{PART} = qq{api="_NAME_"&version="_VER_"&method="GetStmUrlPath"&cameraIds="_CID_"&_sid="_SID_"};
if($hash->{HELPER}{API}{CAM}{VER} >= 9) {
$hash->{HELPER}{CALL}{PART} = qq{api="_NAME_"&version=_VER_&method="GetLiveViewPath"&idList="_CID_"&_sid="_SID_"};
}
setActiveToken($hash);
checkSid ($hash);
}
else {
schedule ($name, $hash);
}
return;
}
###########################################################################
# query SVS-Event information
# Abruf der Events einer Kamera
###########################################################################
sub __getEventList {
my $hash = shift;
my $camname = $hash->{CAMNAME};
my $name = $hash->{NAME};
my $caller = (caller(0))[3];
RemoveInternalTimer($hash, $caller);
return if(IsDisabled($name));
if ($hash->{HELPER}{ACTIVE} eq "off") {
$hash->{OPMODE} = "geteventlist";
return if(startOrShut($name));
$hash->{HELPER}{LOGINRETRIES} = 0;
if (!$hash->{HELPER}{API}{PARSET}) {
getApiSites ($hash, $caller, $hash);
return;
}
$hash->{HELPER}{CALL}{VKEY} = "EVENT";
$hash->{HELPER}{CALL}{PART} = qq{api="_NAME_"&version="_VER_"&method="List"&cameraIds="_CID_"&locked="0"&blIncludeSnapshot="false"&reason=""&limit="2"&includeAllCam="false"&_sid="_SID_"};
setActiveToken($hash);
checkSid ($hash);
}
else {
schedule ($name, $hash);
}
return;
}
##########################################################################
# Capabilities von Kamera abrufen (Get)
##########################################################################
sub __getCapabilities {
my $hash = shift;
my $camname = $hash->{CAMNAME};
my $name = $hash->{NAME};
my $caller = (caller(0))[3];
RemoveInternalTimer($hash, $caller);
return if(IsDisabled($name));
if ($hash->{HELPER}{ACTIVE} eq "off") {
$hash->{OPMODE} = "Getcapabilities";
return if(startOrShut($name));
$hash->{HELPER}{LOGINRETRIES} = 0;
if (!$hash->{HELPER}{API}{PARSET}) {
getApiSites ($hash, $caller, $hash);
return;
}
$hash->{HELPER}{CALL}{VKEY} = "CAM";
my $ver = ($hash->{HELPER}{API}{CAM}{VER} >= 9) ? 8 : $hash->{HELPER}{API}{CAM}{VER};
$hash->{HELPER}{CALL}{PART} = qq{api=_NAME_&version=$ver&method="GetCapabilityByCamId"&cameraId=_CID_&_sid="_SID_"};
setActiveToken($hash);
checkSid ($hash);
}
else {
schedule ($name, $hash);
}
return;
}
###########################################################################
# SYNO.SurveillanceStation.VideoStream query aktuelles Streamformat
###########################################################################
sub __getStreamFormat {
my $hash = shift;
my $camname = $hash->{CAMNAME};
my $name = $hash->{NAME};
my $caller = (caller(0))[3];
RemoveInternalTimer($hash, $caller);
return if(IsDisabled($name) || !ApiVal ($hash, $hash->{HELPER}{API}{VIDEOSTMS}, 'VER', ''));
if ($hash->{HELPER}{ACTIVE} eq "off") {
$hash->{OPMODE} = "getstreamformat";
return if(startOrShut($name));
$hash->{HELPER}{LOGINRETRIES} = 0;
if (!$hash->{HELPER}{API}{PARSET}) {
getApiSites ($hash, $caller, $hash);
return;
}
$hash->{HELPER}{CALL}{VKEY} = "VIDEOSTMS";
$hash->{HELPER}{CALL}{PART} = qq{api=_NAME_&version=_VER_&method=Query&cameraId=_CID_&_sid=_SID_};
setActiveToken($hash);
checkSid ($hash);
}
else {
schedule ($name, $hash);
}
return;
}
###########################################################################
# Enumerate motion detection parameters
###########################################################################
sub __getMotionEnum {
my $hash = shift;
my $camname = $hash->{CAMNAME};
my $name = $hash->{NAME};
my $caller = (caller(0))[3];
RemoveInternalTimer($hash, $caller);
return if(IsDisabled($name));
if ($hash->{HELPER}{ACTIVE} eq "off") {
$hash->{OPMODE} = "getmotionenum";
return if(startOrShut($name));
$hash->{HELPER}{LOGINRETRIES} = 0;
if (!$hash->{HELPER}{API}{PARSET}) {
getApiSites ($hash, $caller, $hash);
return;
}
$hash->{HELPER}{CALL}{VKEY} = "CAMEVENT";
$hash->{HELPER}{CALL}{PART} = qq{api="_NAME_"&version="_VER_"&method="MotionEnum"&camId="_CID_"&_sid="_SID_"};
setActiveToken($hash);
checkSid ($hash);
}
else {
schedule ($name, $hash);
}
return;
}
##########################################################################
# PTZ Presets abrufen (Get)
##########################################################################
sub __getPtzPresetList {
my $hash = shift;
my $camname = $hash->{CAMNAME};
my $name = $hash->{NAME};
my $caller = (caller(0))[3];
RemoveInternalTimer($hash, $caller);
return if(IsDisabled($name));
if(!IsCapPTZ($hash)) {
Log3($name, 4, "$name - Retrieval of Presets for $camname can't be executed - $camname is not a PTZ-Camera");
return;
}
if(!IsCapPTZTilt($hash) | !IsCapPTZPan($hash)) {
Log3($name, 4, "$name - Retrieval of Presets for $camname can't be executed - $camname has no capability to tilt/pan");
return;
}
if($hash->{HELPER}{ACTIVE} eq "off") {
$hash->{OPMODE} = "Getptzlistpreset";
return if(startOrShut($name));
$hash->{HELPER}{LOGINRETRIES} = 0;
if (!$hash->{HELPER}{API}{PARSET}) {
getApiSites ($hash, $caller, $hash);
return;
}
$hash->{HELPER}{CALL}{VKEY} = "PTZ";
$hash->{HELPER}{CALL}{PART} = qq{api="_NAME_"&version="_VER_"&method=ListPreset&cameraId=_CID_&_sid="_SID_"};
setActiveToken($hash);
checkSid ($hash);
}
else {
schedule ($name, $hash);
}
return;
}
##########################################################################
# PTZ Patrols abrufen (Get)
##########################################################################
sub __getPtzPatrolList {
my $hash = shift;
my $camname = $hash->{CAMNAME};
my $name = $hash->{NAME};
my $caller = (caller(0))[3];
RemoveInternalTimer($hash, $caller);
return if(IsDisabled($name));
if(!IsCapPTZ($hash)) {
Log3($name, 4, "$name - Retrieval of Patrols for $camname can't be executed - $camname is not a PTZ-Camera");
return;
}
if(!IsCapPTZTilt($hash) | !IsCapPTZPan($hash)) {
Log3($name, 4, "$name - Retrieval of Patrols for $camname can't be executed - $camname has no capability to tilt/pan");
return;
}
if($hash->{HELPER}{ACTIVE} ne "on") {
$hash->{OPMODE} = "Getptzlistpatrol";
return if(startOrShut($name));
$hash->{HELPER}{LOGINRETRIES} = 0;
if (!$hash->{HELPER}{API}{PARSET}) {
getApiSites ($hash, $caller, $hash);
return;
}
$hash->{HELPER}{CALL}{VKEY} = "PTZ";
$hash->{HELPER}{CALL}{PART} = qq{api=_NAME_&version=_VER_&method=ListPatrol&cameraId=_CID_&_sid="_SID_"};
setActiveToken($hash);
checkSid ($hash);
}
else {
schedule ($name, $hash);
}
return;
}
###########################################################################
# Session logout
###########################################################################
sub __sessionOff {
my $hash = shift;
my $camname = $hash->{CAMNAME};
my $name = $hash->{NAME};
my $caller = (caller(0))[3];
RemoveInternalTimer($hash, $caller);
return if(IsDisabled($name));
if ($hash->{HELPER}{ACTIVE} eq "off") {
$hash->{OPMODE} = "logout";
setActiveToken($hash);
logout ($hash, $hash->{HELPER}{API});
}
else {
schedule ($name, $hash);
}
return;
}
##################################################################################
# API-Pfade und Versionen ermitteln
##################################################################################
sub getApiSites {
my $hash = shift;
my $fret = shift // "";
my $arg = shift // "";
my $serveraddr = $hash->{SERVERADDR};
my $serverport = $hash->{SERVERPORT};
my $name = $hash->{NAME};
my $proto = $hash->{PROTOCOL};
my ($url,$param);
if($fret) { # Activetoken setzen wenn Caller angegeben
setActiveToken($hash);
}
Log3($name, 4, "$name - --- Start getApiSites ---");
if ($hash->{HELPER}{API}{PARSET}) { # API-Hashwerte sind bereits gesetzt -> Abruf überspringen
Log3($name, 4, "$name - API hashvalues already set - ignore get apisites");
checkSid($hash);
return;
}
my $httptimeout = AttrVal($name, "httptimeout", $todef);
Log3($name, 5, "$name - HTTP-Call will be done with httptimeout-Value: $httptimeout s");
# API initialisieren und abrufen
####################################
$hash->{HELPER}{API} = apistatic ("surveillance"); # API Template im HELPER instanziieren
Log3 ($name, 4, "$name - API imported:\n".Dumper $hash->{HELPER}{API});
my @ak;
for my $key (keys %{$hash->{HELPER}{API}}) {
next if($key =~ /^PARSET$/x);
push @ak, $hash->{HELPER}{API}{$key}{NAME};
}
my $apis = join ",", @ak;
$url = "$proto://$serveraddr:$serverport/webapi/$hash->{HELPER}{API}{INFO}{PATH}?".
"api=$hash->{HELPER}{API}{INFO}{NAME}".
"&method=Query".
"&version=$hash->{HELPER}{API}{INFO}{VER}".
"&query=$apis";
Log3($name, 4, "$name - Call-Out now: $url");
$param = {
url => $url,
timeout => $httptimeout,
hash => $hash,
fret => $fret,
arg => $arg,
method => "GET",
header => "Accept: application/json",
callback => \&getApiSites_Parse
};
HttpUtils_NonblockingGet ($param);
return;
}
####################################################################################
# Auswertung Abruf apisites
####################################################################################
sub getApiSites_Parse {
my $param = shift;
my $err = shift;
my $myjson = shift;
my $hash = $param->{hash};
my $fret = $param->{fret};
my $arg = $param->{arg};
my $name = $hash->{NAME};
my $opmode = $hash->{OPMODE};
my ($error,$errorcode,$success);
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);
delActiveToken($hash); # ausgeführte Funktion ist abgebrochen, Freigabe Funktionstoken
return;
}
elsif ($myjson ne "") { # Evaluiere ob Daten im JSON-Format empfangen wurden
($success) = evaljson($hash,$myjson);
if(!$success) {
delActiveToken($hash);
return;
}
my $jdata = decode_json($myjson);
$success = $jdata->{success};
Log3($name, 5, "$name - JSON returned: ". Dumper $jdata); # Logausgabe decodierte JSON Daten
if ($success) {
my $completed = completeAPI ($jdata, $hash->{HELPER}{API}); # übergibt Referenz zum instanziierten API-Hash
if(!$completed) {
$errorcode = "9001";
$error = expErrors($hash,$errorcode); # Fehlertext zum Errorcode ermitteln
readingsBeginUpdate($hash);
readingsBulkUpdate ($hash, "Errorcode", $errorcode);
readingsBulkUpdate ($hash, "Error", $error );
readingsEndUpdate ($hash, 1);
Log3($name, 2, "$name - ERROR - $error");
delActiveToken($hash); # ausgeführte Funktion ist abgebrochen, Freigabe Funktionstoken
return;
}
# aktuelle oder simulierte SVS-Version für Fallentscheidung setzen
my $major = $hash->{HELPER}{SVSVERSION}{MAJOR} // "";
my $minor = $hash->{HELPER}{SVSVERSION}{MINOR} // "";
my $small = $hash->{HELPER}{SVSVERSION}{SMALL} // "";
my $build = $hash->{HELPER}{SVSVERSION}{BUILD} // "";
my $actvs = $major.$minor.$small.$build;
Log3($name, 4, "$name - installed SVS version is: $actvs");
if (AttrVal($name,"simu_SVSversion",0)) {
my @vl = split (/\.|-/x,AttrVal($name, "simu_SVSversion", ""));
$actvs = $vl[0];
$actvs .= $vl[1];
$actvs .= ($vl[2] =~ /\d/x) ? $vl[2]."xxxx" : $vl[2];
$actvs .= "-simu";
}
### Downgrades für nicht kompatible API-Versionen. Hier nur nutzen wenn API zentral downgraded werden soll
###########################################################################################################
Log3($name, 4, "$name - ------- Begin of adaption section -------");
my $adavs = "a01"; # adaptierte Version
if($adavs) {
for my $av (sort keys %{$hvada{$adavs}}) {
$hash->{HELPER}{API}{$av}{VER} = $hvada{$adavs}{$av};
$hash->{HELPER}{API}{$av}{MOD} = "yes";
Log3($name, 4, "$name - Version of $hash->{HELPER}{API}{$av}{NAME} adapted to: $hash->{HELPER}{API}{$av}{VER}");
}
}
Log3($name, 4, "$name - ------- End of adaption section -------");
### Simulation älterer SVS-Versionen
#####################################
Log3($name, 4, "$name - ------- Begin of simulation section -------");
if (AttrVal($name, "simu_SVSversion", undef)) {
Log3($name, 4, "$name - SVS version $actvs will be simulated");
for my $ak (sort keys %{$hash->{HELPER}{API}} ) {
next if($ak =~ /^PARSET$/x);
if(!exists $hsimu{$actvs}{$ak}) {
Log3($name, 4, "$name - delete $hash->{HELPER}{API}{$ak}{NAME} due to version setting");
delete $hash->{HELPER}{API}{$ak};
}
}
for my $k (sort keys %{$hsimu{$actvs}} ) {
next if(!ApiVal ($hash, $hash->{HELPER}{API}{$k}, 'NAME', ''));
$hash->{HELPER}{API}{$k}{VER} = $hsimu{$actvs}{$k};
$hash->{HELPER}{API}{$k}{MOD} = "yes";
Log3($name, 4, "$name - Version of $hash->{HELPER}{API}{$k}{NAME} adapted to: $hash->{HELPER}{API}{$k}{VER}");
}
}
Log3($name, 4, "$name - ------- End of simulation section -------");
setReadingErrorNone( $hash, 1 );
Log3 ($name, 4, "$name - API completed after retrieval and adaption:\n".Dumper $hash->{HELPER}{API});
if ($opmode eq "apiInfo") { # API Infos in Popup anzeigen
showAPIinfo ($hash, $hash->{HELPER}{API}); # übergibt Referenz zum instanziierten API-Hash)
delActiveToken($hash); # Freigabe Funktionstoken
return;
}
}
else {
$errorcode = "806";
$error = expErrors($hash,$errorcode); # Fehlertext zum Errorcode ermitteln
readingsBeginUpdate($hash);
readingsBulkUpdate ($hash, "Errorcode", $errorcode);
readingsBulkUpdate ($hash, "Error", $error );
readingsEndUpdate ($hash, 1);
Log3($name, 2, "$name - ERROR - $error");
delActiveToken($hash); # ausgeführte Funktion ist abgebrochen, Freigabe Funktionstoken
return;
}
}
if($fret) { # Caller aufrufen wenn angegeben
no strict "refs"; ## no critic 'NoStrict'
delActiveToken($hash); # Freigabe Funktionstoken vor Neudurchlauf der aufrufenden Funktion
&$fret($arg);
use strict "refs";
return;
}
return checkSid($hash);
}
#############################################################################################
# Check ob Session ID gesetzt ist - ggf. login
#############################################################################################
sub checkSid {
my $hash = shift;
my $name = $hash->{NAME};
my $subref;
if(IsModelCam($hash)) { # Folgefunktion wenn Cam-Device
$subref = \&getCamId;
}
else { # Folgefunktion wenn SVS-Device
$subref = \&camOp;
}
my $sid = $hash->{HELPER}{SID}; # SID holen bzw. login
if(!$sid) {
Log3($name, 3, "$name - no session ID found - get new one");
login($hash, $hash->{HELPER}{API}, $subref);
return;
}
if(IsModelCam($hash) || $hash->{OPMODE} eq "Autocreate") { # Normalverarbeitung für Cams oder Autocreate Cams
return getCamId($hash);
}
else { # Sprung zu camOp wenn SVS Device
return camOp($hash);
}
return;
}
#############################################################################################
# Abruf der installierten Cams
# die Kamera-Id wird aus dem Kameranamen (Surveillance Station) ermittelt
#############################################################################################
sub getCamId {
my ($hash) = @_;
my $name = $hash->{NAME};
my $serveraddr = $hash->{SERVERADDR};
my $serverport = $hash->{SERVERPORT};
my $apicam = $hash->{HELPER}{API}{CAM}{NAME};
my $apicampath = $hash->{HELPER}{API}{CAM}{PATH};
my $apicamver = $hash->{HELPER}{API}{CAM}{VER};
my $sid = $hash->{HELPER}{SID};
my $proto = $hash->{PROTOCOL};
my $url;
Log3($name, 4, "$name - --- Start getCamId ---");
if ($hash->{CAMID}) { # Camid ist bereits ermittelt -> Abruf überspringen
Log3($name, 4, "$name - CAMID already set - ignore get camid");
return camOp($hash);
}
my $httptimeout = AttrVal($name, "httptimeout", $todef);
Log3($name, 5, "$name - HTTP-Call will be done with httptimeout-Value: $httptimeout s");
$url = "$proto://$serveraddr:$serverport/webapi/$apicampath?api=$apicam&version=$apicamver&method=List&basic=true&streamInfo=true&camStm=true&_sid=\"$sid\"";
if ($apicamver >= 9) {
$url = "$proto://$serveraddr:$serverport/webapi/$apicampath?api=$apicam&version=$apicamver&method=\"List\"&basic=true&streamInfo=true&camStm=0&_sid=\"$sid\"";
}
Log3($name, 4, "$name - Call-Out now: $url");
my $param = {
url => $url,
timeout => $httptimeout,
hash => $hash,
method => "GET",
header => "Accept: application/json",
callback => \&getCamId_Parse
};
HttpUtils_NonblockingGet($param);
return;
}
#############################################################################################
# Auswertung installierte Cams, Selektion Cam , Ausführung Operation
#############################################################################################
sub getCamId_Parse {
my ($param, $err, $myjson) = @_;
my $hash = $param->{hash};
my $name = $hash->{NAME};
my $camname = $hash->{CAMNAME};
my $apicamver = $hash->{HELPER}{API}{CAM}{VER};
my $OpMode = $hash->{OPMODE};
my ($data,$success,$error,$errorcode,$camid);
my ($i,$n,$id,$errstate,$camdef,$nrcreated);
my $cdall = "";
my %allcams;
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);
return login($hash, $hash->{HELPER}{API}, \&getCamId);
} elsif ($myjson ne "") { # Datenabruf erfolgreich
($success) = evaljson($hash,$myjson);
if (!$success) {
Log3($name, 4, "$name - Data returned: ".$myjson);
delActiveToken($hash);
return;
}
$data = decode_json($myjson);
Log3($name, 5, "$name - JSON returned: ". Dumper $data);
$success = $data->{'success'};
if ($success) { # die Liste aller Kameras konnte ausgelesen werden
($i,$nrcreated) = (0,0);
%allcams = (); # Namen aller installierten Kameras mit Id's in Hash einlesen
while ($data->{'data'}->{'cameras'}->[$i]) {
if ($apicamver <= 8) {
$n = $data->{'data'}->{'cameras'}->[$i]->{'name'};
}
else {
$n = $data->{'data'}->{'cameras'}->[$i]->{'newName'}; # Änderung ab SVS 8.0.0
}
$id = $data->{'data'}->{'cameras'}->[$i]->{'id'};
$allcams{"$n"} = "$id";
$i += 1;
if ($OpMode eq "Autocreate") { # Cam autocreate
($err,$camdef) = doAutocreate($hash,$n);
if ($camdef) {
$cdall = $cdall.($cdall ? ", " : "").$camdef;
$nrcreated++;
}
$errstate = $err if($err);
}
}
if ($OpMode eq "Autocreate") { # Cam autocreate
Log3($name, 3, "$name - Cameras defined by autocreate: $cdall") if($cdall);
$errstate = $errstate // "none";
readingsBeginUpdate ($hash);
readingsBulkUpdate ($hash, "NumberAutocreatedCams", $nrcreated );
readingsBulkUpdate ($hash, "Errorcode", "none" );
readingsBulkUpdate ($hash, "Error", $errstate );
readingsBulkUpdate ($hash, "state", "autocreate finished");
readingsEndUpdate ($hash, 1);
CommandSave(undef, undef) if($errstate eq "none" && $nrcreated && AttrVal("global","autosave", 1));
delActiveToken($hash); # Freigabe Funktionstoken
return;
}
if (exists($allcams{$camname})) { # Ist der gesuchte Kameraname im Hash enhalten (in SVS eingerichtet ?)
$camid = $allcams{$camname};
$hash->{CAMID} = $camid;
Log3($name, 4, "$name - Detection Camid successful - $camname ID: $camid");
}
else { # Kameraname nicht gefunden, id = ""
readingsBeginUpdate ($hash);
readingsBulkUpdate ($hash, "Errorcode", "none" );
readingsBulkUpdate ($hash, "Error", "Camera(ID) not found in Surveillance Station");
readingsEndUpdate ($hash, 1);
Log3($name, 2, "$name - ERROR - Cameraname $camname wasn't found in Surveillance Station. Check Userrights, Cameraname and Spelling");
delActiveToken($hash);
return;
}
}
else {
$errorcode = $data->{'error'}->{'code'}; # Errorcode aus JSON ermitteln
$error = expErrors($hash,$errorcode); # Fehlertext zum Errorcode ermitteln
readingsBeginUpdate ($hash);
readingsBulkUpdate ($hash, "Errorcode", $errorcode);
readingsBulkUpdate ($hash, "Error", $error );
readingsEndUpdate ($hash, 1);
if ($errorcode =~ /(105|401)/x) { # neue Login-Versuche
Log3($name, 2, "$name - ERROR - $errorcode - $error -> try new login");
return login($hash, $hash->{HELPER}{API}, \&getCamId);
}
else { # ausgeführte Funktion ist abgebrochen, Freigabe Funktionstoken
delActiveToken($hash);
Log3($name, 2, "$name - ERROR - ID of Camera $camname couldn't be selected. Errorcode: $errorcode - $error");
return;
}
}
}
return camOp($hash);
}
#############################################################################################
# Ausführung Operation
#############################################################################################
sub camOp {
my $hash = shift;
my $name = $hash->{NAME};
my $OpMode = $hash->{OPMODE};
my $proto = $hash->{PROTOCOL};
my $serveraddr = $hash->{SERVERADDR};
my $serverport = $hash->{SERVERPORT};
my ($url,$part,$vkey);
Log3($name, 4, "$name - --- Start $OpMode ---");
my $httptimeout = AttrVal($name, "httptimeout", $todef);
if($hash->{HELPER}{CALL}) { # neue camOp Videosteuerung Ausführungsvariante
$vkey = $hash->{HELPER}{CALL}{VKEY}; # API Key Video Parts
my $head = $hash->{HELPER}{CALL}{HEAD}; # vom Standard abweichende Serveradresse / Port (z.B. bei external)
$part = $hash->{HELPER}{CALL}{PART}; # URL-Teilstring ohne Startsequenz (Server, Port, ...)
my $to = $hash->{HELPER}{CALL}{TO} // 0; # evtl. zuätzlicher Timeout Add-On
$httptimeout += $to;
$part =~ s/_NAME_/$hash->{HELPER}{API}{$vkey}{NAME}/x;
$part =~ s/_VER_/$hash->{HELPER}{API}{$vkey}{VER}/x;
$part =~ s/_CID_/$hash->{CAMID}/x;
$part =~ s/_SID_/$hash->{HELPER}{SID}/x;
if($head) {
$url = $head.qq{/webapi/$hash->{HELPER}{API}{$vkey}{PATH}?}.$part;
}
else {
$url = qq{$proto://$serveraddr:$serverport/webapi/$hash->{HELPER}{API}{$vkey}{PATH}?}.$part;
}
}
if($hash->{HELPER}{ACALL}) { # neue camOp Audiosteuerung Ausführungsvariante
my $akey = $hash->{HELPER}{ACALL}{AKEY}; # API Key Audio Parts
my $apart = $hash->{HELPER}{ACALL}{APART}; # URL-Teilstring Audio
$apart =~ s/_ANAME_/$hash->{HELPER}{API}{$akey}{NAME}/x;
$apart =~ s/_AVER_/$hash->{HELPER}{API}{$akey}{VER}/x;
$apart =~ s/_CID_/$hash->{CAMID}/x;
$apart =~ s/_SID_/$hash->{HELPER}{SID}/x;
$hash->{HELPER}{AUDIOLINK} = qq{$proto://$serveraddr:$serverport/webapi/$hash->{HELPER}{API}{$akey}{PATH}?}.$apart;
}
if ($OpMode eq "runliveview" && $hash->{HELPER}{RUNVIEW} !~ m/snap|^live_.*hls$/x) {
_Oprunliveview ($hash, $part, $vkey);
return;
}
Log3($name, 5, "$name - HTTP-Call will be done with httptimeout-Value: $httptimeout s");
Log3($name, 4, "$name - Call-Out now: $url");
my $param = {
url => $url,
timeout => $httptimeout,
hash => $hash,
method => "GET",
header => "Accept: application/json",
callback => \&camOp_Parse
};
HttpUtils_NonblockingGet ($param);
return;
}
################################################################
# camOp runliveview
# wird bei runliveview aufgerufen wenn nicht Anzeige Snaps
# oder kein HLS-Stream aktiviert werden soll
################################################################
sub _Oprunliveview {
my $hash = shift // return;
my $part = shift // delCallParts($hash) && return;
my $vkey = shift // delCallParts($hash) && return;
my $name = $hash->{NAME};
my $proto = $hash->{PROTOCOL};
my $serveraddr = $hash->{SERVERADDR};
my $serverport = $hash->{SERVERPORT};
my $url;
my $exturl = AttrVal($name, "livestreamprefix", "$proto://$serveraddr:$serverport"); # externe URL
$exturl = ($exturl eq "DEF") ? "$proto://$serveraddr:$serverport" : $exturl;
if ($hash->{HELPER}{RUNVIEW} =~ m/live/x) {
if($part) { # API "SYNO.SurveillanceStation.VideoStream" vorhanden ? (removed ab API v2.8)
$exturl .= qq{/webapi/$hash->{HELPER}{API}{$vkey}{PATH}?}.$part;
$url = qq{$proto://$serveraddr:$serverport/webapi/$hash->{HELPER}{API}{$vkey}{PATH}?}.$part; # interne URL
}
elsif ($hash->{HELPER}{STMKEYMJPEGHTTP}) {
$url = $hash->{HELPER}{STMKEYMJPEGHTTP};
}
}
else { # Abspielen der letzten Aufnahme (EventId)
$exturl .= qq{/webapi/$hash->{HELPER}{API}{$vkey}{PATH}?}.$part;
$url = qq{$proto://$serveraddr:$serverport/webapi/$hash->{HELPER}{API}{$vkey}{PATH}?}.$part; # interne URL
}
readingsSingleUpdate($hash,"LiveStreamUrl", $exturl, 1) if(AttrVal($name, "showStmInfoFull", 0));
$hash->{HELPER}{LINK} = $url; # Liveview-Link in Hash speichern
Log3($name, 4, "$name - Set Streaming-URL: $url");
if ($hash->{HELPER}{OPENWINDOW}) { # livestream sofort in neuem Browsertab öffnen
my $winname = $name."_view";
my $attr = AttrVal($name, "htmlattr", "");
if ($hash->{HELPER}{VIEWOPENROOM}) { # öffnen streamwindow für die Instanz die "VIEWOPENROOM" oder Attr "room" aktuell geöffnet hat
my $room = $hash->{HELPER}{VIEWOPENROOM};
map {FW_directNotify("FILTER=room=$room", "#FHEMWEB:$_", "window.open ('$url','$winname','$attr')", "")} devspec2array("TYPE=FHEMWEB"); ## no critic 'void context'
}
else {
map {FW_directNotify("#FHEMWEB:$_", "window.open ('$url','$winname','$attr')", "")} devspec2array("TYPE=FHEMWEB"); ## no critic 'void context'
}
}
roomRefresh($hash,0,1,1); # kein Room-Refresh, SSCam-state-Event, SSCamSTRM-Event
delActiveToken ($hash);
return;
}
###################################################################################
# Check ob Kameraoperation erfolgreich wie in "OpMOde" definiert
###################################################################################
sub camOp_Parse {
my $param = shift;
my $err = shift;
my $myjson = shift;
my $hash = $param->{hash};
my $name = $hash->{NAME};
my $camname = $hash->{CAMNAME};
my $OpMode = $hash->{OPMODE};
my ($data,$success);
# Einstellung für Logausgabe Pollinginfos
# wenn "pollnologging" = 1 -> logging nur bei Verbose=4, sonst 3
my $verbose = 3;
if (AttrVal($name, "pollnologging", 0)) {
$verbose = 4;
}
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);
delActiveToken ($hash); # ausgeführte Funktion ist abgebrochen, Freigabe Funktionstoken
return;
}
elsif ($myjson ne "") { # wenn die Abfrage erfolgreich war
if($OpMode !~ /SaveRec|GetRec/x) { # "SaveRec/GetRec" liefern MP4-Daten und kein JSON
($success,$myjson) = evaljson($hash,$myjson);
if (!$success) {
Log3($name, 4, "$name - Data returned: ".$myjson);
delActiveToken ($hash);
return;
}
$data = decode_json($myjson);
Log3($name, 5, "$name - JSON returned: ". Dumper $data); # Logausgabe decodierte JSON Daten
$success = $data->{'success'};
}
else {
$success = 1;
}
if ($success) { # Kameraoperation entsprechend "OpMode" war erfolgreich
my $params = {
hash => $hash,
name => $name,
camname => $camname,
OpMode => $OpMode,
myjson => $myjson,
data => $data,
verbose => $verbose,
};
no strict "refs"; ## no critic 'NoStrict'
if($hparse{$OpMode} && defined &{$hparse{$OpMode}{fn}}) {
my $ret = q{};
$ret = &{$hparse{$OpMode}{fn}} ($params);
return if($ret);
}
use strict "refs";
if ($OpMode eq "ExpMode") {
Log3 ($name, 3, qq{$name - Camera $camname exposure mode is set to "$hash->{HELPER}{EXPMODE}"} );
setReadingErrorNone($hash, 1 );
__getCamInfo ($hash);
}
elsif ($OpMode eq "setZoom") {
Log3 ($name, 3, qq{$name - Zoom operation "$hash->{HELPER}{ZOOM}{DIR}:$hash->{HELPER}{ZOOM}{MOVETYPE}" of Camera $camname successfully done} );
setReadingErrorNone($hash, 1 );
}
elsif ($OpMode eq "extevent") {
Log3 ($name, 3, qq{$name - External Event "$hash->{HELPER}{EVENTID}" successfully triggered} );
setReadingErrorNone($hash, 1 );
}
elsif ($OpMode eq "sethomemode") {
Log3 ($name, 3, qq{$name - HomeMode was set to "$hash->{HELPER}{HOMEMODE}"} );
setReadingErrorNone($hash, 1 );
delActiveToken ($hash); # Token freigeben vor nächstem Kommando
__getHomeModeState ($hash); # neuen HomeModeState abrufen
}
elsif ($OpMode eq "setPreset") {
my $pnumber = delete($hash->{HELPER}{PNUMBER});
my $pname = delete($hash->{HELPER}{PNAME});
my $pspeed = delete($hash->{HELPER}{PSPEED});
$pspeed = $pspeed?$pspeed:"not set";
Log3 ($name, 3, "$name - Camera $camname preset \"$pname\" was saved to number $pnumber with speed $pspeed");
setReadingErrorNone($hash, 1);
__getPtzPresetList ($hash);
}
elsif ($OpMode eq "delPreset") {
my $dp = $hash->{HELPER}{DELPRESETNAME};
delete $hash->{HELPER}{ALLPRESETS}{$dp};
Log3 ($name, 3, "$name - Preset \"$dp\" of camera \"$camname\" has been deleted");
setReadingErrorNone($hash, 1);
__getPtzPresetList ($hash);
}
elsif ($OpMode eq "piract") {
my $piract = ($hash->{HELPER}{PIRACT} == 0)?"activated":"deactivated";
Log3 ($name, 3, "$name - PIR sensor $piract");
setReadingErrorNone($hash, 1);
}
elsif ($OpMode eq "setHome") {
my $sh = $hash->{HELPER}{SETHOME};
Log3 ($name, 3, "$name - Preset \"$sh\" of camera \"$camname\" was set as Home position");
setReadingErrorNone($hash, 1);
__getPtzPresetList ($hash);
}
elsif ($OpMode eq "setoptpar") {
my $rid = $data->{'data'}{'id'}; # Cam ID return wenn i.O.
my $ropt = $rid == $hash->{CAMID} ? "none" : "error in operation";
delete($hash->{HELPER}{NTPSERV});
delete($hash->{HELPER}{MIRROR});
delete($hash->{HELPER}{FLIP});
delete($hash->{HELPER}{ROTATE});
delete($hash->{HELPER}{CHKLIST});
readingsBeginUpdate ($hash);
readingsBulkUpdate ($hash,"Errorcode","none");
readingsBulkUpdate ($hash,"Error",$ropt);
readingsEndUpdate ($hash, 1);
delActiveToken ($hash); # Token freigeben vor Abruf caminfo
__getCamInfo ($hash);
}
elsif ($OpMode eq "stopliveview_hls") { # HLS Streaming wurde deaktiviert, Aktivitätsstatus speichern
$hash->{HELPER}{HLSSTREAM} = "inactive";
Log3($name, 3, "$name - HLS Streaming of camera \"$name\" deactivated");
roomRefresh($hash,0,1,1); # kein Room-Refresh, SSCam-state-Event, SSCamSTRM-Event
}
elsif ($OpMode eq "reactivate_hls") { # HLS Streaming wurde deaktiviert, Aktivitätsstatus speichern
$hash->{HELPER}{HLSSTREAM} = "inactive";
Log3($name, 3, "$name - HLS Streaming of camera \"$name\" deactivated for reactivation");
delActiveToken ($hash); # Token freigeben vor hlsactivate
__activateHls ($hash);
return;
}
elsif ($OpMode eq "activate_hls") { # HLS Streaming wurde aktiviert, Aktivitätsstatus speichern
$hash->{HELPER}{HLSSTREAM} = "active";
Log3($name, 3, "$name - HLS Streaming of camera \"$name\" activated");
roomRefresh($hash,0,1,1); # kein Room-Refresh, SSCam-state-Event, SSCamSTRM-Event
}
elsif ($OpMode eq "getsnapfilename") { # den Filenamen eines Schnapschusses ermitteln
my $snapid = ReadingsVal("$name", "LastSnapId", "");
if(!$snapid) {
Log3($name, 2, "$name - Snap-ID \"LastSnapId\" isn't set. Filename can't be retrieved");
delActiveToken ($hash); # Token freigeben vor hlsactivate
return;
}
Log3($name, 4, "$name - Filename of Snap-ID $snapid is \"$data->{'data'}{'data'}[0]{'fileName'}\"") if($data->{'data'}{'data'}[0]{'fileName'});
readingsSingleUpdate($hash, "LastSnapFilename", $data->{'data'}{'data'}[0]{'fileName'}, 1);
setReadingErrorNone ($hash, 1);
}
elsif ($OpMode eq "getstreamformat") { # aktuelles Streamformat abgefragt
my $sformat = jboolmap($data->{'data'}->{'format'});
$sformat = $sformat ? uc($sformat) : "no API";
readingsSingleUpdate($hash, "CamStreamFormat", $sformat, 1);
setReadingErrorNone ($hash, 1);
}
elsif ($OpMode eq "runpatrol") { # eine Tour wurde gestartet
my $st = (ReadingsVal("$name", "Record", "Stop") eq "Start") ? "on" : "off"; # falls Aufnahme noch läuft -> state = on setzen
DoTrigger($name,"patrol started");
Log3 ($name, 3, qq{$name - Patrol "$hash->{HELPER}{GOPATROLNAME}" of camera $camname has been started successfully} );
readingsSingleUpdate($hash,"state", $st, 0);
setReadingErrorNone ($hash, 1);
}
elsif ($OpMode eq "goabsptz") { # eine absolute PTZ-Position wurde angefahren
my $st = (ReadingsVal("$name", "Record", "Stop") eq "Start") ? "on" : "off"; # falls Aufnahme noch läuft -> state = on setzen
DoTrigger($name,"move stop");
Log3 ($name, 3, qq{$name - Camera $camname has been moved to absolute position "posX=$hash->{HELPER}{GOPTZPOSX}" and "posY=$hash->{HELPER}{GOPTZPOSY}"} );
readingsSingleUpdate($hash,"state", $st, 0);
setReadingErrorNone ($hash, 1);
}
elsif ($OpMode eq "startTrack") { # Object Tracking wurde eingeschaltet
Log3 ($name, 3, qq{$name - Object tracking of Camera $camname has been switched on} );
setReadingErrorNone($hash, 1 );
}
elsif ($OpMode eq "stopTrack") { # Object Tracking wurde eingeschaltet
Log3 ($name, 3, qq{$name - Object tracking of Camera $camname has been stopped} );
setReadingErrorNone($hash, 1);
}
elsif ($OpMode eq "movestart") { # ein "Move" in eine bestimmte Richtung wird durchgeführt
Log3 ($name, 3, qq{$name - Camera $camname started move to direction "$hash->{HELPER}{GOMOVEDIR}" with duration of $hash->{HELPER}{GOMOVETIME} s} );
setReadingErrorNone($hash, 1);
RemoveInternalTimer($hash, "FHEM::SSCam::__moveStop" );
InternalTimer (gettimeofday()+($hash->{HELPER}{GOMOVETIME}), "FHEM::SSCam::__moveStop", $hash );
}
elsif ($OpMode eq "movestop") { # ein "Move" in eine bestimmte Richtung wurde durchgeführt
my $st = (ReadingsVal("$name", "Record", "Stop") eq "Start") ? "on" : "off"; # falls Aufnahme noch läuft -> state = on setzen
DoTrigger($name,"move stop");
Log3 ($name, 3, qq{$name - Camera $camname stopped move to direction "$hash->{HELPER}{GOMOVEDIR}"} );
readingsSingleUpdate($hash,"state", $st, 0);
setReadingErrorNone ($hash, 1);
}
elsif ($OpMode eq "Enable") { # Kamera wurde aktiviert, sonst kann nichts laufen -> "off"
Log3($name, 3, "$name - Camera $camname has been enabled successfully");
readingsBeginUpdate($hash);
readingsBulkUpdate ($hash, "Availability", "enabled");
readingsBulkUpdate ($hash, "state", "off" );
readingsEndUpdate ($hash, 1);
setReadingErrorNone ($hash, 1);
}
elsif ($OpMode eq "Disable") { # Kamera wurde deaktiviert
Log3($name, 3, "$name - Camera $camname has been disabled successfully");
readingsBeginUpdate($hash);
readingsBulkUpdate ($hash, "Availability", "disabled");
readingsBulkUpdate ($hash, "state", "disabled");
readingsEndUpdate ($hash, 1);
setReadingErrorNone ($hash, 1);
}
}
else { # die API-Operation war fehlerhaft
my $errorcode = $data->{'error'}->{'code'}; # Errorcode aus JSON ermitteln
my $error = expErrors($hash,$errorcode); # Fehlertext zum Errorcode ermitteln
readingsBeginUpdate($hash);
readingsBulkUpdate ($hash, "Errorcode", $errorcode);
readingsBulkUpdate ($hash, "Error", $error );
readingsEndUpdate ($hash, 1);
if ($errorcode =~ /105/x) {
Log3($name, 2, "$name - ERROR - $errorcode - $error in operation $OpMode -> try new login");
undef $data;
undef $myjson;
return login($hash, $hash->{HELPER}{API}, \&camOp);
}
Log3($name, 2, "$name - ERROR - Operation $OpMode not successful. Cause: $errorcode - $error");
}
undef $data;
undef $myjson;
}
delActiveToken ($hash); # Token freigeben
return;
}
###############################################################################
# Parse OpMode Start
# Die Aufnahmezeit setzen
# wird "set on [rectime]" verwendet -> dann [rectime] nutzen,
# sonst Attribut "rectime" wenn es gesetzt ist, falls nicht -> "RECTIME_DEF"
###############################################################################
sub _parseStart { ## no critic "not used"
my $paref = shift;
my $hash = $paref->{hash};
my $name = $paref->{name};
my $camname = $paref->{camname};
my $rectime;
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} // "";
my $teletxt = $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
return;
}
###############################################################################
# Parse OpMode Stop
###############################################################################
sub _parseStop { ## no critic "not used"
my $paref = shift;
my $hash = $paref->{hash};
my $name = $paref->{name};
my $camname = $paref->{camname};
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);
return;
}
###############################################################################
# Parse OpMode GetRec
###############################################################################
sub _parseGetRec { ## no critic "not used"
my $paref = shift;
my $hash = $paref->{hash};
my $name = $paref->{name};
my $camname = $paref->{camname};
my $OpMode = $paref->{OpMode};
my $myjson = $paref->{myjson};
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
setReadingErrorNone( $hash, 1 );
return;
}
###############################################################################
# Parse OpMode MotDetSc
###############################################################################
sub _parseMotDetSc { ## no critic "not used"
my $paref = shift;
my $hash = $paref->{hash};
my $name = $paref->{name};
my $camname = $paref->{camname};
my $sensitivity;
if ($hash->{HELPER}{MOTDETSC} eq "SVS" && keys %{$hash->{HELPER}{MOTDETOPTIONS}}) { # Optionen für "SVS" sind gesetzt
$sensitivity = ($hash->{HELPER}{MOTDETOPTIONS}{SENSITIVITY}) ? ($hash->{HELPER}{MOTDETOPTIONS}{SENSITIVITY}) : "-";
my $threshold = ($hash->{HELPER}{MOTDETOPTIONS}{THRESHOLD}) ? ($hash->{HELPER}{MOTDETOPTIONS}{THRESHOLD}) : "-";
Log3($name, 3, "$name - Camera $camname motion detection source set to \"$hash->{HELPER}{MOTDETSC}\" with options sensitivity: $sensitivity, threshold: $threshold");
} elsif ($hash->{HELPER}{MOTDETSC} eq "camera" && keys %{$hash->{HELPER}{MOTDETOPTIONS}}) { # Optionen für "camera" sind gesetzt
$sensitivity = ($hash->{HELPER}{MOTDETOPTIONS}{SENSITIVITY}) ? ($hash->{HELPER}{MOTDETOPTIONS}{SENSITIVITY}) : "-";
my $objectSize = ($hash->{HELPER}{MOTDETOPTIONS}{OBJECTSIZE}) ? ($hash->{HELPER}{MOTDETOPTIONS}{OBJECTSIZE}) : "-";
my $percentage = ($hash->{HELPER}{MOTDETOPTIONS}{PERCENTAGE}) ? ($hash->{HELPER}{MOTDETOPTIONS}{PERCENTAGE}) : "-";
Log3($name, 3, "$name - Camera $camname motion detection source set to \"$hash->{HELPER}{MOTDETSC}\" with options sensitivity: $sensitivity, objectSize: $objectSize, percentage: $percentage");
}
else { # keine Optionen Bewegungserkennung wurden gesetzt
Log3($name, 3, "$name - Camera $camname motion detection source set to \"$hash->{HELPER}{MOTDETSC}\" ");
}
setReadingErrorNone( $hash, 1 );
__getMotionEnum ($hash); # neu gesetzte Parameter abrufen
return;
}
###############################################################################
# Parse OpMode getsvslog
###############################################################################
sub _parsegetsvslog { ## no critic "not used"
my $paref = shift;
my $hash = $paref->{hash};
my $name = $paref->{name};
my $data = $paref->{data};
my $lec = $data->{'data'}{'total'}; # abgerufene Anzahl von Log-Einträgen
my $log = q{};
my $log0 = q{};
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 = FmtDateTime($data->{'data'}->{'log'}->[$i]{'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: ...) $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 => ApiVal ($hash, $hash->{HELPER}{API}{VIDEOSTM}, 'NAME', ''),
apivideostmpath => ApiVal ($hash, $hash->{HELPER}{API}{VIDEOSTM}, 'PATH', ''),
apivideostmver => ApiVal ($hash, $hash->{HELPER}{API}{VIDEOSTM}, 'VER', ''),
apiaudiostm => ApiVal ($hash, $hash->{HELPER}{API}{AUDIOSTM}, 'NAME', ''),
apiaudiostmpath => ApiVal ($hash, $hash->{HELPER}{API}{AUDIOSTM}, 'PATH', ''),
apiaudiostmver => ApiVal ($hash, $hash->{HELPER}{API}{AUDIOSTM}, 'VER', ''),
apivideostms => ApiVal ($hash, $hash->{HELPER}{API}{VIDEOSTMS}, 'NAME', ''),
apivideostmspath => ApiVal ($hash, $hash->{HELPER}{API}{VIDEOSTMS}, 'PATH', ''),
apivideostmsver => ApiVal ($hash, $hash->{HELPER}{API}{VIDEOSTMS}, 'VER', ''),
camid => $hash->{CAMID},
sid => $hash->{HELPER}{SID},
proto => $hash->{PROTOCOL},
noQuotesForSID => AttrVal($camname, "noQuotesForSID",0),
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 .= '';
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 $noQuotesForSID = $params->{noQuotesForSID};
my $serveraddr = $params->{serveraddr};
my $serverport = $params->{serverport};
my $apivideostms = $params->{apivideostms};
my $apivideostmspath = $params->{apivideostmspath};
my $apivideostmsver = $params->{apivideostmsver};
my $apiaudiostm = $params->{apiaudiostm};
my $apiaudiostmpath = $params->{apiaudiostmpath};
my $apiaudiostmver = $params->{apiaudiostmver};
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 $quote = $noQuotesForSID ? qq{"} : qq{};
my $ret = "";
if(ReadingsVal($camname, "SVSversion", "") 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 ";
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+?$/xs;
$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 = qq{You have to specify attribute "hlsStrmObject" in Camera $cam !};
$ret .= " $cause ";
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;
}
#############################################################################################
# Autocreate für Kameras
# $sn = Name der Kamera in SVS
#############################################################################################
sub doAutocreate {
my ($hash,$sn) = @_;
my $name = $hash->{NAME};
my $type = $hash->{TYPE};
my ($camhash, $err, $camname);
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};
my $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,"credentials");
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);
}
######################################################################################################
# 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;
}
#############################################################################################
# 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 - The gallery is not updated automatically. Please set the attribute \"snapGalleryBoost=1\" in device $name ";
$sgbnote = "ACHTUNG - Die Galerie wird nicht automatisch aktualisiert. Dazu bitte das Attribut \"snapGalleryBoost=1\" im Device $name setzen." if ($lang eq "DE");
}
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 = "";
# Bildaten aus Cache abrufen
############################
my $count;
$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" ) {
$count = scalar keys %{$data{SSCam}{$name}{SNAPHASH}} // 0; # Anzahl Bilddaten im Cache
$htmlCode =~ s{_LIMIT_}{$count}xms; # Platzhalter Snapanzahl im Header mit realem Wert ersetzen
my $i = 1;
for my $key (sort{$a<=>$b}keys %{$data{SSCam}{$name}{SNAPHASH}}) {
if($i > $limit) {
$count = $limit;
last;
}
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 = "";
$i++;
}
}
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
$count = scalar @unique // 0; # Anzahl Bilddaten im Cache
$htmlCode =~ s{_LIMIT_}{$count}xms; # Platzhalter Snapanzahl im Header mit realem Wert ersetzen
my $i = 1;
for my $key (@unique) {
if($i > $limit) {
$count = $limit;
last;
}
$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 = "";
$i++;
}
}
if ( $cell == 2 ) {
$htmlCode .= " ";
}
$htmlCode .= " ";
if(!$hb) {
$htmlCode .= "";
$htmlCode .= "";
$htmlCode .= "$imgdosnap " if($strmdev);
$htmlCode .= " ";
$htmlCode .= " ";
}
$htmlCode .= " ";
$htmlCode .= "
";
$htmlCode .= "
';
$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 " ", AttrVal($name, "userattr", "");
for my $part (@ua) {
push(@h,$part) if($part !~ 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 eingelesen
return;
}
##############################################################################
# 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 my $svs (@allsvs) {
my $svshash;
$svshash = $defs{$svs} if($defs{$svs});
next if(!$svshash ||
!AttrVal($svs, "snapEmailTxt", "") ||
!$svshash->{HELPER}{ALLSNAPREF} ||
!$svshash->{HELPER}{CANSENDSNAP}); # Sammel-Schnappschüsse nur senden wenn CANSENDSNAP und Attribut gesetzt ist
$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($svs, 4, "$svs - 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($svs, 4, "$svs - 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 ($date, $time) = timestampToDateTime ();
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};
my $param = {
hash => $hash,
calias => $calias,
mt => $mt,
date => $date,
time => $time,
};
my $smtpmsg = _prepSendMail ($param);
$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};
my $param = {
hash => $hash,
calias => $calias,
mt => $mt,
date => $date,
time => $time,
};
my $smtpmsg = _prepSendMail ($param);
$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
# snapTelegramTxt aus $hash->{HELPER}{TELEMSG}
#
# Format in $hash->{HELPER}{TELEMSG} muss sein:
# tbot => , peers => , subject =>
################################################################################################
if($OpMode =~ /^getsnap/x && $hash->{HELPER}{CANTELESNAP}) {
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};
my $param = {
hash => $hash,
calias => $calias,
mt => $mt,
date => $date,
time => $time,
};
my $telemsg = _prepSendTelegram ($param);
$ret = _sendTelegram($hash, {
'subject' => $telemsg->{subject},
'part2type' => 'image/jpeg',
'sdat' => $dat,
'opmode' => $OpMode,
'tac' => $tac,
'telebot' => $telemsg->{tbot},
'peers' => $telemsg->{peers},
'option' => $telemsg->{option}, # Versandoptionen
'MediaStream' => '-1', # Code für MediaStream im TelegramBot (png/jpg = -1)
}
);
readingsSingleUpdate($hash, "sendTeleState", $ret, 1) if ($ret);
}
### Aufnahmen mit Telegram versenden
# recTelegramTxt aus $hash->{HELPER}{TELERECMSG}
#
# Format in $hash->{HELPER}{TELEMSG} muss sein:
# tbot => , peers => , subject =>
#################################################################################################
if($OpMode =~ /^GetRec/x && $hash->{HELPER}{CANTELEREC}) {
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};
my $param = {
hash => $hash,
calias => $calias,
mt => $mt,
date => $date,
time => $time,
};
my $telemsg = _prepSendTelegram ($param);
$vdat = $dat;
$ret = _sendTelegram($hash, {
'subject' => $telemsg->{subject},
'vdat' => $vdat,
'opmode' => $OpMode,
'telebot' => $telemsg->{tbot},
'peers' => $telemsg->{peers},
'option' => $telemsg->{option}, # Versandoptionen
'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
# snapChatTxt aus $hash->{HELPER}{CHATMSG}
# Format in $hash->{HELPER}{CHATMSG} muss sein: snapChatTxt:"chatbot => ,
# peers => , subject => "
#############################################################################################
if($OpMode =~ /^getsnap/x && $hash->{HELPER}{CANCHATSNAP}) {
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};
my $param = {
hash => $hash,
calias => $calias,
mt => $mt,
date => $date,
time => $time,
};
my $chatmsg = _prepSendChat ($param);
$ret = _sendChat($hash, {
'subject' => $chatmsg->{subject},
'opmode' => $OpMode,
'tac' => $tac,
'sdat' => $dat,
'chatbot' => $chatmsg->{chatbot},
'peers' => $chatmsg->{peers},
}
);
readingsSingleUpdate($hash, "sendChatState", $ret, 1) if ($ret);
}
### Aufnahmen mit Synology Chat versenden
# recChatTxt aus $hash->{HELPER}{CHATRECMSG}
# Format in $hash->{HELPER}{CHATRECMSG} muss sein: chatbot => ,
# peers => , subject =>
###################################################################################
if($OpMode =~ /^GetRec/x && $hash->{HELPER}{CANCHATREC}) {
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};
my $param = {
hash => $hash,
calias => $calias,
mt => $mt,
date => $date,
time => $time,
};
my $chatmsg = _prepSendChat ($param);
$ret = _sendChat($hash, {
'subject' => $chatmsg->{subject},
'opmode' => $OpMode,
'tac' => $tac,
'vdat' => $dat,
'chatbot' => $chatmsg->{chatbot},
'peers' => $chatmsg->{peers},
}
);
readingsSingleUpdate($hash, "sendChatState", $ret, 1) if ($ret);
}
closeTrans($hash) if($hash->{HELPER}{TRANSACTION} eq "multiple_snapsend"); # Transaction Sammelversand (SVS) schließen, Daten bereinigen
return;
}
###############################################################################
# Vorbereitung Versand Chatnachrichten
###############################################################################
sub _prepSendChat {
my $paref = shift;
my $hash = $paref->{hash};
my $calias = $paref->{calias};
my $mt = $paref->{mt};
my $date = $paref->{date};
my $time = $paref->{time};
my $name = $hash->{NAME};
my ($cbott,$peert,$subjt);
$mt =~ s/['"]//gx;
my ($chatbot,$peers,$subj) = split(",", $mt, 3 );
$cbott = (split("=>", $chatbot))[1] if($chatbot);
$peert = (split("=>", $peers ))[1] if($peers);
$subjt = (split("=>", $subj ))[1] if($subj);
$cbott = trim($cbott) if($cbott);
$peert = trim($peert) if($peert);
if($subjt) {
$subjt = trim($subjt);
$subjt =~ s/[\$#]CAM/$calias/gx;
$subjt =~ s/[\$#]DATE/$date/gx;
$subjt =~ s/[\$#]TIME/$time/gx;
}
my %chatmsg = ();
$chatmsg{chatbot} = "$cbott" if($cbott);
$chatmsg{peers} = "$peert" if($peert);
$chatmsg{subject} = "$subjt" if($subjt);
return \%chatmsg;
}
#############################################################################################
# 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;
}
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});
my @ua = split(",", $peers); # User aufsplitten und zu jedem die ID ermitteln
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::addSendqueue ($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});
my @ua = split(/,/x, $peers); # User aufsplitten und zu jedem die ID ermitteln
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::addSendqueue ($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 = shift;
my $key = shift;
my $paref = shift;
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 = $paref->{sdat}{$key}{createdTm};
$fname = trim ($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 = $paref->{vdat}{$key}{createdTm};
$fname = trim ($paref->{vdat}{$key}{fileName});
$tdir = trim ($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);
}
###############################################################################
# Vorbereitung Versand Telegramnachrichten
###############################################################################
sub _prepSendTelegram {
my $paref = shift;
my $hash = $paref->{hash};
my $calias = $paref->{calias};
my $mt = $paref->{mt};
my $date = $paref->{date};
my $time = $paref->{time};
my $name = $hash->{NAME};
my ($tbott,$peert,$subjt,$optt);
$mt =~ s/['"]//gx;
my ($telebot, $peers, $subj, $opt) = split ",", $mt, 4;
$tbott = (split "=>", $telebot)[1] if($telebot);
$peert = (split "=>", $peers )[1] if($peers);
$subjt = (split "=>", $subj )[1] if($subj);
$optt = (split "=>", $opt )[1] if($opt);
$tbott = trim ($tbott) if($tbott);
$peert = trim ($peert) if($peert);
if($subjt) {
$subjt = trim($subjt);
$subjt =~ s/[\$#]CAM/$calias/gx;
$subjt =~ s/[\$#]DATE/$date/gx;
$subjt =~ s/[\$#]TIME/$time/gx;
}
my %telemsg = ();
$telemsg{tbot} = "$tbott" if($tbott);
$telemsg{peers} = "$peert" if($peert);
$telemsg{subject} = "$subjt" if($subjt);
$telemsg{option} = "$optt" if($optt);
return \%telemsg;
}
#############################################################################################
# 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' => {'attr'=>'', 'default'=>'', 'required'=>0, 'set'=>1},
'part1type' => {'attr'=>'', 'default'=>'text/html; charset=UTF-8', 'required'=>1, 'set'=>1},
'part1txt' => {'attr'=>'', 'default'=>'', 'required'=>0, 'set'=>1},
'part2type' => {'attr'=>'', 'default'=>'', 'required'=>0, 'set'=>1},
'sdat' => {'attr'=>'', 'default'=>'', 'required'=>0, 'set'=>1}, # Hashref der Bilddaten (Bilddaten base64 codiert), wenn gesetzt muss 'part2type' auf 'image/jpeg' gesetzt sein
'image' => {'attr'=>'', 'default'=>'', 'required'=>0, 'set'=>1}, # Daten als File, wenn gesetzt muss 'part2type' auf 'image/jpeg' gesetzt sein
'fname' => {'attr'=>'', 'default'=>'', 'required'=>0, 'set'=>1}, # Filename für "image"
'lsnaptime' => {'attr'=>'', 'default'=>'', 'required'=>0, 'set'=>1}, # Zeitstempel der Bilddaten
'opmode' => {'attr'=>'', 'default'=>'', 'required'=>1, 'set'=>1}, # OpMode muss gesetzt sein
'tac' => {'attr'=>'', 'default'=>'', 'required'=>0, 'set'=>1}, # übermittelter Transaktionscode der ausgewerteten Transaktion
'vdat' => {'attr'=>'', 'default'=>'', 'required'=>0, 'set'=>1}, # Hashref der Videodaten
'telebot' => {'attr'=>'', 'default'=>'', 'required'=>1, 'set'=>1}, # TelegramBot-Device welches zum Senden verwendet werden soll
'peers' => {'attr'=>'', 'default'=>'', 'required'=>0, 'set'=>1}, # TelegramBot Peers
'option' => {'attr'=>'', 'default'=>'', 'required'=>0, 'set'=>1}, # TelegramBot Sendeoptionen
'MediaStream' => {'attr'=>'', '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($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($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};
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;
}
my $peers = $data{SSCam}{$name}{PARAMS}{$tac}{peers};
if ($peers =~ /^r:/xs) { # Reading mit Empfängern ist hinterlegt
my $pr = (split ':', $peers)[1];
$peers = ReadingsVal ($name, $pr, '');
Log3 ($name, 4, "$name - peers was fetched from reading >$pr<: $peers");
}
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 $options = '';
my @opta = split ' ', $data{SSCam}{$name}{PARAMS}{$tac}{option};
if (@opta) {
for my $o (@opta) {
$options .= " -$o-"
}
$options .= ' ';
}
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, $options);
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, $options);
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 = $paref->{sdat}{$key}{createdTm};
$img = $paref->{sdat}{$key}{imageData};
$fname = trim ($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 = $paref->{vdat}{$key}{createdTm};
$data = $paref->{vdat}{$key}{imageData};
$fname = trim ($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);
}
###############################################################################
# Vorbereitung Versand Mail Nachrichten
###############################################################################
sub _prepSendMail {
my $paref = shift;
my $hash = $paref->{hash};
my $calias = $paref->{calias};
my $mt = $paref->{mt};
my $date = $paref->{date};
my $time = $paref->{time};
my $name = $hash->{NAME};
$mt =~ s/['"]//gx;
my ($subj,$body) = split ",", $mt, 2;
my $subjt = (split "=>", $subj)[1];
my $bodyt = (split "=>", $body)[1];
$subjt = trim($subjt);
$subjt =~ s/[\$#]CAM/$calias/gx;
$subjt =~ s/[\$#]DATE/$date/gx;
$subjt =~ s/[\$#]TIME/$time/gx;
$bodyt = trim($bodyt);
$bodyt =~ s/[\$#]CAM/$calias/gx;
$bodyt =~ s/[\$#]DATE/$date/gx;
$bodyt =~ s/[\$#]TIME/$time/gx;
my %smtpmsg = ();
$smtpmsg{subject} = "$subjt";
$smtpmsg{body} = "$bodyt";
return \%smtpmsg;
}
#############################################################################################
# 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/html; 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 { ## no critic 'not used'
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,"SMTPcredentials");
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'
);
$part1txt = decode_utf8($part1txt);
### Add image, Das Image liegt bereits als File vor
####################################################
if($image) {
$mailmsg->attach(
Type => $part2type,
Path => $image,
Filename => $fname,
Disposition => 'attachment',
);
}
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',
);
my $params = {
hash => $hash,
name => $name,
txt => $part1txt,
fname => $fname,
ct => $ct
};
$part1txt = __extractForEmail ($params);
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
for my $key (@unique) { # attach mail
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',
);
my $params = {
hash => $hash,
name => $name,
txt => $part1txt,
fname => $fname,
ct => $ct
};
$part1txt = __extractForEmail ($params);
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',
);
my $params = {
hash => $hash,
name => $name,
txt => $part1txt,
fname => $fname,
ct => $ct
};
$part1txt = __extractForEmail ($params);
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',
);
my $params = {
hash => $hash,
name => $name,
txt => $part1txt,
fname => $fname,
ct => $ct
};
$part1txt = __extractForEmail ($params);
Log3($name, 4, "$name - Video data sequence [$key] decoded from CHI-Cache for Email attachment");
}
BlockingInformParent("FHEM::SSCam::subaddFromBlocking", [$name, "-", $tac], 0);
}
}
### Add the text message part (Note that "attach" has same arguments as "new")
###############################################################################
$mailmsg->attach(
Type => $part1type,
Data => $part1txt,
);
$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":"") );
# Daten müssen als Einzeiler zurückgegeben werden
$ret = encode_base64($ret,"");
return "$name|''|$ret";
}
####################################################################################################
# Daten extrahieren für Email Versand
####################################################################################################
sub __extractForEmail {
my $paref = shift;
my $txt = $paref->{txt} // qq{};
my $fname = $paref->{fname} // qq{};
my $ct = $paref->{ct} // qq{};
$txt =~ s/[\$#]FILE/$fname/gx;
$txt =~ s/[\$#]CTIME/$ct/gx;
return $txt;
}
####################################################################################################
# Auswertungsroutine nichtblockierendes Send EMail
####################################################################################################
sub __sendEmaildone { ## no critic 'not used'
my $string = shift;
my @a = split("\\|",$string);
my $hash = $defs{$a[0]};
my $err = $a[1] ? trim(decode_base64($a[1])) : undef;
my $ret = $a[2] ? trim(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 { ## no critic 'not used'
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;
}
#############################################################################################
# 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 // q{};
return if(!$tac);
cleanData("$name:$tac"); # %data Hash & Cache bereinigen
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;
}
#############################################################################################
# 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;
}
######################################################################################
# initiale Startroutinen nach Restart FHEM
######################################################################################
sub initOnBoot {
my $hash = shift;
my $name = $hash->{NAME};
RemoveInternalTimer($hash, "FHEM::SSCam::initOnBoot");
if($init_done == 1) {
RemoveInternalTimer($hash); # alle Timer löschen
delete($defs{$name}{READINGS}{LiveStreamUrl}) if($defs{$name}{READINGS}{LiveStreamUrl}); # LiveStream URL zurücksetzen
if (ReadingsVal($hash->{NAME}, "Record", "Stop") eq "Start") { # check ob alle Recordings = "Stop" nach Reboot -> sonst stoppen
Log3($name, 2, "$name - Recording of $hash->{CAMNAME} seems to be still active after FHEM restart - try to stop it now");
__camStopRec($hash);
}
if (!$hash->{CREDENTIALS}) { # Konfiguration der Synology Surveillance Station abrufen
Log3($name, 2, qq{$name - Credentials of $name are not set - make sure you've set it with "set $name credentials "});
}
else {
readingsSingleUpdate($hash, "compstate", "true", 0); # Anfangswert f. versionCheck setzen
__getCaminfoAll($hash,1); # "1" ist Statusbit für manuelle Abfrage, kein Einstieg in Pollingroutine
versionCheck($hash); # Einstieg in regelmäßigen Check Kompatibilität
}
# Subroutine Watchdog-Timer starten (sollen Cam-Infos regelmäßig abgerufen werden ?), verzögerter zufälliger Start 0-30s
RemoveInternalTimer($hash, "FHEM::SSCam::wdpollcaminfo");
InternalTimer (gettimeofday()+int(rand(30)), "FHEM::SSCam::wdpollcaminfo", $hash, 0);
}
else {
InternalTimer(gettimeofday()+3, "FHEM::SSCam::initOnBoot", $hash, 0);
}
return;
}
###############################################################################
# Dauerschleife Kompatibilitätscheck SSCam <-> SVS
###############################################################################
sub versionCheck {
my $hash = shift;
my $name = $hash->{NAME};
my $rc = 21600;
RemoveInternalTimer($hash, "FHEM::SSCam::versionCheck");
return if(IsDisabled($name));
my $cs = ReadingsVal($name, "compstate", "true");
if($cs eq "false") {
Log3($name, 2, "$name - WARNING - The current/simulated SVS-version ".ReadingsVal($name, "SVSversion", "").
" may be incompatible with SSCam version $hash->{HELPER}{VERSION}. ".
"For further information execute \"get $name versionNotes 4\".");
}
InternalTimer(gettimeofday()+$rc, "FHEM::SSCam::versionCheck", $hash, 0);
return;
}
################################################################
# return 0 - Startmeldung OpMode im Log
# return 1 - wenn Shutdown läuft
################################################################
sub startOrShut {
my $name = shift;
my $hash = $defs{$name};
if ($shutdownInProcess) { # shutdown in Proces -> keine weiteren Aktionen
Log3($name, 3, "$name - Shutdown in process. No more activities allowed.");
return 1;
}
Log3($name, 4, "$name - ####################################################");
Log3($name, 4, "$name - ### start cam operation $hash->{OPMODE} ");
Log3($name, 4, "$name - ####################################################");
return 0;
}
###############################################################################
# Err-Status / Log setzen wenn Device Verfügbarkeit disabled oder disconnected
###############################################################################
sub exitOnDis {
my $name = shift;
my $log = shift;
my $hash = $defs{$name};
my $exit = 0;
my $errorcode = "000";
my $avail = ReadingsVal($name, "Availability", "");
if ($avail eq "disabled") {
$errorcode = "402";
$exit = 1;
}
elsif ($avail eq "disconnected") {
$errorcode = "502";
$exit = 1;
}
if($exit) {
my $error = expErrors($hash,$errorcode); # Fehlertext zum Errorcode ermitteln
readingsBeginUpdate ($hash);
readingsBulkUpdate ($hash, "Errorcode", $errorcode);
readingsBulkUpdate ($hash, "Error", $error );
readingsEndUpdate ($hash, 1);
Log3($name, 2, "$name - ERROR - $log - $error");
}
return $exit;
}
###########################################################################
# plant die aufrufende Funktion mit einem Delta Time aus dem Hash %hdt
# neu mit InternalTimer ein
# $arg = Argument für InternalTimer
###########################################################################
sub schedule {
my $name = shift;
my $arg = shift;
my $pack = __PACKAGE__;
my $caller = (caller(1))[3];
my $sub = (split /${pack}::/x, $caller)[1];
my $dt = $hdt{$sub};
if(!$dt) {
$dt = 1;
Debug (qq{$pack - no delta time found for function "$sub", use default of $dt seconds instead})
}
InternalTimer(gettimeofday()+$dt, $caller, $arg, 0);
if (AttrVal($name,"debugactivetoken",0)) {
Log3($name, 1, "$name - Function $caller scheduled again with delta time $dt seconds");
}
return;
}
###############################################################################
# Liefert die bereinigte SVS-Version dreistellig xxx
###############################################################################
sub myVersion {
my $hash = shift;
my $name = $hash->{NAME};
my $actvs = 0;
my @vl = split (/-/x,ReadingsVal($name, "SVSversion", ""),2);
if(@vl) {
$actvs = $vl[0];
$actvs =~ s/\.//gx;
}
return $actvs;
}
######################################################################################
# Polling Überwachung
# Überwacht die Wert von Attribut "pollcaminfoall" und Reading "PollState"
# wenn Attribut "pollcaminfoall" > 10 und "PollState"=Inactive -> start Polling
######################################################################################
sub wdpollcaminfo {
my ($hash) = @_;
my $name = $hash->{NAME};
my $camname = $hash->{CAMNAME};
my $pcia = AttrVal($name,"pollcaminfoall",0);
my $pnl = AttrVal($name,"pollnologging",0);
my $watchdogtimer = 60+rand(30);
my $lang = AttrVal("global","language","EN");
RemoveInternalTimer($hash, "FHEM::SSCam::wdpollcaminfo");
if ($hash->{HELPER}{OLDVALPOLLNOLOGGING} != $pnl) { # Poll-Logging prüfen
$hash->{HELPER}{OLDVALPOLLNOLOGGING} = $pnl; # aktuellen pollnologging-Wert in $hash eintragen für späteren Vergleich
if ($pnl) {
Log3($name, 3, "$name - Polling-Log of $camname is deactivated");
}
else {
Log3($name, 3, "$name - Polling-Log of $camname is activated");
}
}
if ($pcia && !IsDisabled($name)) { # Polling prüfen
if(ReadingsVal($name, "PollState", "Active") eq "Inactive") {
readingsSingleUpdate($hash,"PollState","Active",1); # Polling ist jetzt aktiv
readingsSingleUpdate($hash,"state","polling",1) if(!IsModelCam($hash)); # Polling-state bei einem SVS-Device setzten
Log3($name, 3, "$name - Polling of $camname is activated - Pollinginterval: $pcia s");
$hash->{HELPER}{OLDVALPOLL} = $pcia; # in $hash eintragen für späteren Vergleich (Changes von pollcaminfoall)
__getCaminfoAll($hash,0);
}
my $lupd = ReadingsVal($name, "LastUpdateTime", "1970-01-01 / 01:00:00");
my ($year,$month,$mday,$hour,$min,$sec);
if ($lupd =~ /(\d+)\.(\d+)\.(\d+)/x) {
($mday, $month, $year, $hour, $min, $sec) = ($lupd =~ /(\d+)\.(\d+)\.(\d+)\s\/\s(\d+):(\d+):(\d+)/x);
}
else {
($year, $month, $mday, $hour, $min, $sec) = ($lupd =~ /(\d+)-(\d+)-(\d+)\s\/\s(\d+):(\d+):(\d+)/x);
}
$lupd = fhemTimeLocal($sec, $min, $hour, $mday, $month-=1, $year-=1900);
if( gettimeofday() > ($lupd + $pcia + 20) ) {
__getCaminfoAll($hash,0);
}
}
if (defined($hash->{HELPER}{OLDVALPOLL}) && $pcia) {
if ($hash->{HELPER}{OLDVALPOLL} != $pcia) {
Log3($name, 3, "$name - Pollinginterval of $camname has been changed to: $pcia s");
$hash->{HELPER}{OLDVALPOLL} = $pcia;
}
}
InternalTimer(gettimeofday()+$watchdogtimer, "FHEM::SSCam::wdpollcaminfo", $hash, 0);
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 or the last snapshot 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. 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] [object size] [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)
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, option => silent" 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, option => silent"
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
apiInfo
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)
saveLastSnap [<Pfad>] (gilt für CAM)
Example:
saveRecording [<path>] (valid for CAM)
Example:
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: 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 (#CAM) - Device alias respectively the name of the camera in SVS if the device alias isn't set $DATE (#DATE) - current date $TIME (#TIME) - current time $FILE (#FILE) - Name of recording file $CTIME (#CTIME) - recording creation time
Examples: recEmailTxt subject => <subject text>, body => <message text>
$CAM (#CAM) - Device alias respectively the name of the camera in SVS if the device alias isn't set $DATE (#DATE) - current date $TIME (#TIME) - aktuelle time $FILE (#FILE) - Filename of the (last) recording (only usable in body) $CTIME (#CTIME) - Creation time of the (last) recording (only usable in body)
Example:
recTelegramTxt tbot => <TelegramBot-Device>, peers => [<peer1 peer2 ...>], subject => [<Text>], option => [silent]
tbot Name of the TelegramBot-Device peers List of recipients separated by spaces (optional). It can be specified r:<Reading> to read the recipients from the <Reading>. If peers is not specified, the default peer of the TelegramBot device is used. subject the text to be transmitted (optional) option possible TelegramBot sending options described below (optional) silent : the signaling at the receiver is suppressed
$CAM (#CAM) - Device alias respectively the name of the camera in SVS if the device alias isn't set $DATE (#DATE) - current date $TIME (#TIME) - current time $FILE (#FILE) - Name of recording file $CTIME (#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 (#CAM) - Device alias respectively the name of the camera in SVS if the device alias isn't set $DATE (#DATE) - current date $TIME (#TIME) - current time $FILE (#FILE) - Name of snapshot file $CTIME (#CTIME) - creation time of the snapshot
Examples: snapEmailTxt subject => <subject text>, body => <message text>
$CAM (#CAM) - Device alias respectively the name of the camera in SVS if the device alias isn't set $DATE (#DATE) - current date $TIME (#TIME) - current time $FILE (#FILE) - Filename of the (last) snapshot (only usable in body) $CTIME (#CTIME) - Creation time of the (last) snapshot (only usable in body)
Example:
snapTelegramTxt tbot => <TelegramBot device>, peers => [<peer1 peer2 ...>], subject => [<subject text>], option => [silent]
tbot Name of the TelegramBot-Device peers List of recipients separated by spaces (optional). It can be specified r:<Reading> to read the recipients from the <Reading>. If peers is not specified, the default peer of the TelegramBot device is used. subject the text to be transmitted (optional) option possible TelegramBot sending options described below (optional) silent : the signaling at the receiver is suppressed
$CAM (#CAM) - Device alias respectively the name of the camera in SVS if the device alias isn't set $DATE (#DATE) - current date $TIME (#TIME) - current time $FILE (#FILE) - Name of snapshot file $CTIME (#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 bzw. des letzten Schnappschusses
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. 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 [<options>] | SVS [<options>] | disable] (gilt für CAM)
set <name> motdetsc SVS [Empfindlichkeit] [Schwellenwert] # 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, Schwellenwert bleibt unverändert
set <name> motdetsc camera [Empfindlichkeit] [Objektgröße] [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. Beipiel:
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>] 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, option => silent" 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, option => silent"
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
apiInfo
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)
saveLastSnap [<Pfad>] (gilt für CAM)
Beispiel:
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 (#CAM) - Device-Alias bzw. den Namen der Kamera in der SVS ersetzt falls der Device-Alias nicht vorhanden ist $DATE (#DATE) - aktuelles Datum $TIME (#TIME) - aktuelle Zeit $FILE (#FILE) - Filename $CTIME (#CTIME) - Erstellungszeit der Aufnahme
Beispiele: recEmailTxt subject => <Betreff-Text>, body => <Mitteilung-Text>
$CAM (#CAM) - Device-Alias bzw. der Name der Kamera in der SVS falls der Device-Alias nicht vorhanden ist $DATE (#DATE) - aktuelles Datum $TIME (#TIME) - aktuelle Zeit $FILE (#FILE) - Filename der (letzten) Aufnahme (nur in body verwendbar) $CTIME (#CTIME) - Erstellungszeit des (letzten) Aufnahme (nur in body verwendbar)
Beispiel:
recTelegramTxt tbot => <TelegramBot-Device>, peers => [<peer1 peer2 ...>], subject => [<Text>], option => [silent]
tbot Name des TelegramBot-Device peers Durch Leerzeichen getrennte Liste der Empfänger (optional). Es kann r:<Reading> angegeben werden um die Empfänger aus dem <Reading> zu lesen. Ist peers nicht angegeben, wird der Default-Peer des TelegramBot-Device verwendet. subject der zu übermittelnde Text (optional) option mögliche nachfolgend beschriebene TelegramBot Sendeoptionen (optional) silent : die Signalisierung beim Empfänger wird unterdrückt
$CAM (#CAM) - Device-Alias bzw. den Namen der Kamera in der SVS ersetzt falls der Device-Alias nicht vorhanden ist $DATE (#DATE) - aktuelles Datum $TIME (#TIME) - aktuelle Zeit $FILE (#FILE) - Filename $CTIME (#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 (#CAM) - Device-Alias bzw. den Namen der Kamera in der SVS ersetzt falls der Device-Alias nicht vorhanden ist $DATE (#DATE) - aktuelles Datum $TIME (#TIME) - aktuelle Zeit $FILE (#FILE) - Filename des Schnappschusses $CTIME (#CTIME) - Erstellungszeit des Schnappschusses
Beispiele: snapEmailTxt subject => <Betreff-Text>, body => <Mitteilung-Text>
$CAM (#CAM) - Device-Alias bzw. der Name der Kamera in der SVS falls der Device-Alias nicht vorhanden ist $DATE (#DATE) - aktuelles Datum $TIME (#TIME) - aktuelle Zeit $FILE (#FILE) - Filename des (letzten) Schnappschusses (nur in body verwendbar) $CTIME (#CTIME) - Erstellungszeit des (letzten) Schnappschusses (nur in body verwendbar)
Beispiel:
snapTelegramTxt tbot => <TelegramBot-Device>, peers => [<peer1 peer2 ...>], subject => [<Betreff-Text>], option => [silent]
tbot Name des TelegramBot-Device peers Durch Leerzeichen getrennte Liste der Empfänger (optional). Es kann r:<Reading> angegeben werden um die Empfänger aus dem <Reading> zu lesen. Ist peers nicht angegeben, wird der Default-Peer des TelegramBot-Device verwendet. subject der zu übermittelnde Text (optional) option mögliche nachfolgend beschriebene TelegramBot Sendeoptionen (optional) silent : die Signalisierung beim Empfänger wird unterdrückt
$CAM (#CAM) - Device-Alias bzw. den Namen der Kamera in der SVS ersetzt falls der Device-Alias nicht vorhanden ist $DATE (#DATE) - aktuelles Datum $TIME (#TIME) - aktuelle Zeit $FILE (#FILE) - Filename des Schnappschusses $CTIME (#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,
"FHEM::SynoModules::API": 0,
"FHEM::SynoModules::SMUtils": 0,
"FHEM::SynoModules::ErrCodes": 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");
my $calias = $hash->{CAMNAME}; # Alias der Kamera
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;
}
if($wltype eq "image") {
if(ReadingsVal($name, "SVSversion", "") eq "8.2.3-5828" && ReadingsVal($name, "CamVideoType", "") !~ /MJPEG/x) {
$ret .= "