In den letzten Jahren gab es diverse BLINK Adapter für die Amazon Kameras, die jedoch nicht weiterentwickelt wurden und alle, mehr oder weniger, auf blinkpy basierten. Als Alternative funktionierten temporär python scripte mit blinkpy oder die Option über IFTTT.

Zuletzt sind die meisten sicherlich am HAM Adapter oder Homeassistant hängen geblieben, um die Kameras zu steuern. Da Amazon jedoch wieder einmal an den API herumbastelt, funktioniert das tlw. nur noch suboptimal.
Die Idee mit blinkpy zu arbeiten habe ich auf anraten des Forums verworfen und einen Adapter (unter Zuhilfenahme von KI) erstellt, um die gesamte Login - Logik im Adapter nachzubauen.

Funktionen:
• Kameras und Sync-Modul werden ausgelesen und die entsprechenden States etc. angezeigt
• Temperaturanzeige über die Kamera in Grad Celsius und Fahrenheit
• Batterienanzeige der Kamera, umgerechnet in Volt
• bei geringem Batteriestand wird / kann eine pushover oder telegram Info gesendet werden
• Snapshot von Bildern über commands in einen state bzw. auch lokal in den Ordner /opt/iobroker/iobroker-data/blink
• Snapshot als image_base64 mit Zeitstempel
• automatische Erzeugung von Snapshots nach Zeit über admin Bereich
• motion detect
• aktuell, von Blink gespeicherte Videos werden in die entsprechenden Datenpunkte geschrieben oder per fetch geholt
• Speicherort kann im Admin Bereich festgelegt werden

Was funktioniert (noch) nicht:
• kein Echtzeit Video (in Arbeit)
• Video Doorbell (in Arbeit) sollte mit 0.0.4 unterstützt werden, jedoch keine Temperaturanzeige, da diese offensichtlich bei der Doorbell nicht verbaut ist

VIS-Widget
Zusätzlich habe ich ein VIS-Widget Generator erstellt, bei dem ihr lediglich die Kamera ID´s eingeben müsst und es wird daraus ein json erstellt, welches als widget in Vis importiert werden kann

Bild

blink-vis-raster-widget-generator.html

1.) Widgetgenerator für Cameras ohne letzte Videodarstellung:

• blink-vis-raster-widget-generator.html

2.) Widgetgenerator mit Anzeige der zuletzt gespeicherten Videos. Dazu muss ein javascript in den Scripten erstellt werden mit dem Inhalt unter Code, im Code bitte die Kamera ID´s anpassen !:

• blink-vis-raster-widget-generator-video-2.html
• Code

// ioBroker JavaScript Adapter Script
// Blink-Videos aus blink.0.cameras.<ID>.video.file lesen,
// per ffmpeg konvertieren und direkt als Data-URL-States bereitstellen.
//
// Ergebnis:
// javascript.0.blinkVideos.<ID>.data_url       = MP4 / H.264 + AAC, gut für Safari
// javascript.0.blinkVideos.<ID>.data_url_webm  = WebM / VP8 + Opus, gut für Chrome/Edge
//
// Voraussetzung auf dem ioBroker-Server:
// sudo apt install ffmpeg

const fs = require('fs');
const path = require('path');
const { execFile } = require('child_process');

const BLINK_INSTANCE = 'blink.0';

// HIER deine Kamera-IDs eintragen/anpassen:
const CAMERA_IDS = [
  '548730',
  '1136145',
  '1136121',
  '1723473'
];

const OUT_PREFIX = 'blinkVideos';

const FFMPEG = '/usr/bin/ffmpeg';
const FFPROBE = '/usr/bin/ffprobe';

const CACHE_DIR = '/opt/iobroker/iobroker-data/blink-vis-cache';

// Limit pro fertiger Datei, bevor sie als Base64 in einen State geschrieben wird
const MAX_MB_MP4 = 50;
const MAX_MB_WEBM = 50;

// Warten, damit Blink/ioBroker die Datei sicher fertig geschrieben hat
const READ_DELAY_MS = 5000;

const timers = {};
const running = {};
const rerun = {};

function localId(camera, name) {
  return `${OUT_PREFIX}.${camera}.${name}`;
}

function ensureState(id, def, common) {
  try {
    createState(id, def, Object.assign({
      read: true,
      write: false
    }, common));
  } catch (e) {
    log(`createState ${id}: ${e.message || e}`, 'warn');
  }
}

function setLocal(camera, name, value) {
  try {
    setState(localId(camera, name), value, true);
  } catch (e) {
    log(`setState ${localId(camera, name)}: ${e.message || e}`, 'warn');
  }
}

function ensureCameraStates(camera) {
  ensureState(localId(camera, 'data_url'), '', {
    name: `Blink ${camera} MP4 Data URL`,
    type: 'string',
    role: 'text'
  });

  ensureState(localId(camera, 'data_url_webm'), '', {
    name: `Blink ${camera} WebM Data URL`,
    type: 'string',
    role: 'text'
  });

  ensureState(localId(camera, 'source_file'), '', {
    name: `Blink ${camera} Original video.file`,
    type: 'string',
    role: 'text'
  });

  ensureState(localId(camera, 'converted_file'), '', {
    name: `Blink ${camera} konvertierte MP4-Datei`,
    type: 'string',
    role: 'text'
  });

  ensureState(localId(camera, 'converted_file_webm'), '', {
    name: `Blink ${camera} konvertierte WebM-Datei`,
    type: 'string',
    role: 'text'
  });

  ensureState(localId(camera, 'original_size'), 0, {
    name: `Blink ${camera} Originalgröße`,
    type: 'number',
    role: 'value',
    unit: 'Bytes'
  });

  ensureState(localId(camera, 'converted_size'), 0, {
    name: `Blink ${camera} MP4 Größe`,
    type: 'number',
    role: 'value',
    unit: 'Bytes'
  });

  ensureState(localId(camera, 'converted_size_webm'), 0, {
    name: `Blink ${camera} WebM Größe`,
    type: 'number',
    role: 'value',
    unit: 'Bytes'
  });

  ensureState(localId(camera, 'data_url_length'), 0, {
    name: `Blink ${camera} MP4 Data URL Länge`,
    type: 'number',
    role: 'value'
  });

  ensureState(localId(camera, 'data_url_webm_length'), 0, {
    name: `Blink ${camera} WebM Data URL Länge`,
    type: 'number',
    role: 'value'
  });

  ensureState(localId(camera, 'updated'), 0, {
    name: `Blink ${camera} aktualisiert`,
    type: 'number',
    role: 'date'
  });

  ensureState(localId(camera, 'ffprobe'), '', {
    name: `Blink ${camera} ffprobe MP4`,
    type: 'string',
    role: 'text'
  });

  ensureState(localId(camera, 'ffprobe_webm'), '', {
    name: `Blink ${camera} ffprobe WebM`,
    type: 'string',
    role: 'text'
  });

  ensureState(localId(camera, 'status'), '', {
    name: `Blink ${camera} Status`,
    type: 'string',
    role: 'text'
  });

  ensureState(localId(camera, 'error'), '', {
    name: `Blink ${camera} Fehler`,
    type: 'string',
    role: 'text'
  });
}

function readStateValue(id) {
  const s = getState(id);
  return s && s.val !== null && s.val !== undefined ? String(s.val).trim() : '';
}

function finish(camera) {
  running[camera] = false;

  if (rerun[camera]) {
    rerun[camera] = false;
    scheduleConvert(camera, 3000);
  }
}

function fail(camera, message) {
  setLocal(camera, 'status', 'Fehler');
  setLocal(camera, 'error', message);
  log(`Blink ${camera}: ${message}`, 'warn');
  finish(camera);
}

function waitForStableFile(filePath, callback) {
  let lastSize = -1;
  let stableCount = 0;
  let tries = 0;

  const timer = setInterval(() => {
    tries++;

    fs.stat(filePath, (err, stat) => {
      if (err) {
        clearInterval(timer);
        callback(err);
        return;
      }

      if (stat.size > 0 && stat.size === lastSize) {
        stableCount++;
      } else {
        stableCount = 0;
        lastSize = stat.size;
      }

      if (stableCount >= 2) {
        clearInterval(timer);
        callback(null, stat);
        return;
      }

      if (tries >= 25) {
        clearInterval(timer);
        callback(new Error(`Dateigröße wurde nicht stabil: ${filePath}`));
      }
    });
  }, 1000);
}

function probeFile(camera, filePath, stateName, callback) {
  const args = [
    '-v', 'error',
    '-show_streams',
    '-show_format',
    filePath
  ];

  execFile(FFPROBE, args, { timeout: 30000 }, (err, stdout, stderr) => {
    const output = String(stdout || stderr || (err && err.message) || '').slice(0, 12000);
    setLocal(camera, stateName, output);
    callback();
  });
}

function removeIfExists(filePath) {
  try {
    if (fs.existsSync(filePath)) {
      fs.unlinkSync(filePath);
    }
  } catch (e) {
    // ignorieren
  }
}

function transcodeToMp4(inputFile, outputFile, callback) {
  const tmpFile = `${outputFile}.tmp.mp4`;

  removeIfExists(tmpFile);

  const args = [
    '-hide_banner',
    '-nostdin',
    '-y',

    '-fflags', '+genpts',
    '-err_detect', 'ignore_err',

    '-i', inputFile,

    '-map', '0:v:0',
    '-map', '0:a:0?',

    '-c:v', 'libx264',
    '-preset', 'veryfast',
    '-crf', '23',
    '-pix_fmt', 'yuv420p',
    '-profile:v', 'baseline',
    '-level', '3.1',
    '-tag:v', 'avc1',
    '-vf', 'scale=trunc(iw/2)*2:trunc(ih/2)*2',

    '-c:a', 'aac',
    '-b:a', '128k',
    '-ac', '2',
    '-ar', '44100',

    '-movflags', '+faststart',
    '-f', 'mp4',

    tmpFile
  ];

  execFile(FFMPEG, args, { timeout: 120000 }, (err, stdout, stderr) => {
    if (err) {
      callback(new Error(`ffmpeg MP4 Fehler: ${stderr || err.message}`));
      return;
    }

    try {
      removeIfExists(outputFile);
      fs.renameSync(tmpFile, outputFile);
    } catch (e) {
      callback(new Error(`MP4 konnte nicht übernommen werden: ${e.message}`));
      return;
    }

    callback(null);
  });
}

function transcodeToWebm(inputFile, outputFile, callback) {
  const tmpFile = `${outputFile}.tmp.webm`;

  removeIfExists(tmpFile);

  const args = [
    '-hide_banner',
    '-nostdin',
    '-y',

    '-fflags', '+genpts',
    '-err_detect', 'ignore_err',

    '-i', inputFile,

    '-map', '0:v:0',
    '-map', '0:a:0?',

    // Chrome/Edge-kompatibles WebM
    '-c:v', 'libvpx',
    '-deadline', 'realtime',
    '-cpu-used', '5',
    '-b:v', '0',
    '-crf', '32',
    '-pix_fmt', 'yuv420p',
    '-vf', 'scale=trunc(iw/2)*2:trunc(ih/2)*2',

    // Audio behalten und nach Opus wandeln
    '-c:a', 'libopus',
    '-b:a', '96k',
    '-ac', '2',
    '-ar', '48000',

    '-f', 'webm',

    tmpFile
  ];

  execFile(FFMPEG, args, { timeout: 180000 }, (err, stdout, stderr) => {
    if (err) {
      callback(new Error(`ffmpeg WebM Fehler: ${stderr || err.message}`));
      return;
    }

    try {
      removeIfExists(outputFile);
      fs.renameSync(tmpFile, outputFile);
    } catch (e) {
      callback(new Error(`WebM konnte nicht übernommen werden: ${e.message}`));
      return;
    }

    callback(null);
  });
}

function writeDataUrl(camera, filePath, mimeType, dataState, lengthState, sizeState, maxMb, callback) {
  fs.stat(filePath, (statErr, stat) => {
    if (statErr) {
      callback(new Error(`Datei nicht lesbar: ${statErr.message}`));
      return;
    }

    const maxBytes = maxMb * 1024 * 1024;

    if (stat.size > maxBytes) {
      callback(new Error(`Video zu groß für State: ${stat.size} Bytes, Limit ${maxBytes} Bytes`));
      return;
    }

    fs.readFile(filePath, (readErr, buf) => {
      if (readErr) {
        callback(new Error(`Video konnte nicht gelesen werden: ${readErr.message}`));
        return;
      }

      const dataUrl = `data:${mimeType};base64,${buf.toString('base64')}`;

      setLocal(camera, dataState, dataUrl);
      setLocal(camera, lengthState, dataUrl.length);
      setLocal(camera, sizeState, stat.size);

      callback(null);
    });
  });
}

function convertVideo(camera) {
  if (running[camera]) {
    rerun[camera] = true;
    return;
  }

  running[camera] = true;

  const sourceState = `${BLINK_INSTANCE}.cameras.${camera}.video.file`;
  const sourceFile = readStateValue(sourceState);

  if (!sourceFile) {
    fail(camera, `${sourceState} ist leer`);
    return;
  }

  setLocal(camera, 'source_file', sourceFile);
  setLocal(camera, 'data_url', '');
  setLocal(camera, 'data_url_webm', '');
  setLocal(camera, 'data_url_length', 0);
  setLocal(camera, 'data_url_webm_length', 0);
  setLocal(camera, 'error', '');
  setLocal(camera, 'status', 'Warte auf stabile Videodatei ...');

  setTimeout(() => {
    waitForStableFile(sourceFile, (stableErr, originalStat) => {
      if (stableErr) {
        fail(camera, stableErr.message);
        return;
      }

      setLocal(camera, 'original_size', originalStat.size);

      try {
        if (!fs.existsSync(CACHE_DIR)) {
          fs.mkdirSync(CACHE_DIR, { recursive: true });
        }
      } catch (e) {
        fail(camera, `Cache-Verzeichnis konnte nicht erstellt werden: ${e.message}`);
        return;
      }

      const mp4File = path.join(CACHE_DIR, `${camera}_browser.mp4`);
      const webmFile = path.join(CACHE_DIR, `${camera}_browser.webm`);

      setLocal(camera, 'converted_file', mp4File);
      setLocal(camera, 'converted_file_webm', webmFile);

      setLocal(camera, 'status', 'Konvertiere MP4 für Safari ...');

      transcodeToMp4(sourceFile, mp4File, (mp4Err) => {
        if (mp4Err) {
          fail(camera, mp4Err.message);
          return;
        }

        setLocal(camera, 'status', 'Prüfe MP4 ...');

        probeFile(camera, mp4File, 'ffprobe', () => {
          setLocal(camera, 'status', 'Schreibe MP4 Data URL ...');

          writeDataUrl(
            camera,
            mp4File,
            'video/mp4',
            'data_url',
            'data_url_length',
            'converted_size',
            MAX_MB_MP4,
            (mp4WriteErr) => {
              if (mp4WriteErr) {
                fail(camera, mp4WriteErr.message);
                return;
              }

              setLocal(camera, 'status', 'Konvertiere WebM für Chrome/Edge ...');

              transcodeToWebm(sourceFile, webmFile, (webmErr) => {
                if (webmErr) {
                  fail(camera, webmErr.message);
                  return;
                }

                setLocal(camera, 'status', 'Prüfe WebM ...');

                probeFile(camera, webmFile, 'ffprobe_webm', () => {
                  setLocal(camera, 'status', 'Schreibe WebM Data URL ...');

                  writeDataUrl(
                    camera,
                    webmFile,
                    'video/webm',
                    'data_url_webm',
                    'data_url_webm_length',
                    'converted_size_webm',
                    MAX_MB_WEBM,
                    (webmWriteErr) => {
                      if (webmWriteErr) {
                        fail(camera, webmWriteErr.message);
                        return;
                      }

                      setLocal(camera, 'updated', Date.now());
                      setLocal(camera, 'status', 'Fertig');
                      setLocal(camera, 'error', '');

                      log(`Blink ${camera}: MP4 + WebM Data-URLs aktualisiert`, 'info');
                      finish(camera);
                    }
                  );
                });
              });
            }
          );
        });
      });
    });
  }, READ_DELAY_MS);
}

function scheduleConvert(camera, delayMs) {
  if (timers[camera]) {
    clearTimeout(timers[camera]);
  }

  timers[camera] = setTimeout(() => {
    convertVideo(camera);
  }, delayMs || 3000);
}

CAMERA_IDS.forEach((camera) => {
  ensureCameraStates(camera);

  on({ id: `${BLINK_INSTANCE}.cameras.${camera}.video.file`, change: 'any' }, () => scheduleConvert(camera, 3000));
  on({ id: `${BLINK_INSTANCE}.cameras.${camera}.video.timestamp`, change: 'any' }, () => scheduleConvert(camera, 3000));
  on({ id: `${BLINK_INSTANCE}.cameras.${camera}.video.ready`, change: 'any' }, () => scheduleConvert(camera, 3000));

  // Einmal beim Scriptstart ausführen
  scheduleConvert(camera, 5000);
});
[/s]