[SKRIPT] Alexa über ioBroker Steuern -> Kommandos an Alexa

Charly4277

vielen Dank für den tollen Script. Kannst Du uns wenn möglich auch den View zu Verfügung stellen? Leider habe ich selber noch nicht viel Ahnung, wie ich das in VIS darstellen soll.

Vielen Dank schon mal im voraus.

ludino

oha ja an der vis steuerung wäre auch sehr intressiert!

Saubere Arbeit!

firephaser

Hier mal meine Lösung für VIS
4781_radio.jpg

firephaser

Hier die Einträge:

BBTown

~~@firephaser:~~

(nicht ganz ernst gemeint, aber ich konnte mich nicht zurückhalten) :lol:

cu, rain or shine !! :twisted:

(hier gehört eigentlich "die Pommesgabel" hin)

[EDIT] PS: Danke fürs Teilen deiner view !!

tempestas

~~@BBTown:~~

\m/

eric hat da eine Signatur ganz nach meinem Geschmack

Charly4277

Hallo firephaser,

erstmal Danke für das Teilen der View. Leider kann ich sie nicht importieren, erhalte lauter parser Fehler. Aber vielleicht mache ich auch einen Fehler. Habe alles kopiert und dann bei "View importieren" alles reinkopiert. Funktioniert leider nicht.

Edit:

Habs doch hinbekommen. Man muss es als Widget importieren, dann funktioniert es auch!!

firephaser

~~@Charly4277:~~

Genau, dass ist nur ein Auszug meiner View und muss als Widget importiert werden.

P.s. Ist müsst natürlich nicht H.Fischer mit Widget starten

sigi234

@Hauke,

bastle gerade auch an der Vis.

Das ist ein sehr sehr gutes Skript!

Charly4277

Wo bekomme ich eigentlich die Radio Stations ID her? Gibt es da irgendeine Liste?

sigi234

Hallo,

mit den Skript von Hauke:

http://forum.iobroker.net/viewtopic.php … 22#p125945

ruhr70

~~@sigi234:~~

Top! Sieht super aus!

firephaser

~~@Charly4277:~~

Ich musste auch etwas suchen und bin dann bei http://www.tunein.com fündig geworden. Dort einfach den gewünschten Radio-Sender auswählen und in der URL steht dann die ID, beginnt mit s…....

Charly4277

Danke Dir, schau ich mal.

Hauke

Moinsen,

hatte die Woche leider keine Zeit zu Hause am PC die Fragen zu beantworten.

~~@Nikoxx:~~

Fehler sollte nun behoben sein.

<u>Hier das neue Script</u>:

liest per https-GET die aktuellen Playlists von Amazon ein und speichert diese in die "Playlists.X" States
*/
function updatePlaylists() {

// zur Abfrage wird der erste Echo mit MusicPlayer verwendet
var echoWithMusicPlayer = getEchoWithMusicPlayerFromDevices();

var path = '/api/cloudplayer/playlists?deviceSerialNumber=' + echoWithMusicPlayer.serialNumber + '&deviceType=' + echoWithMusicPlayer.deviceType + '&mediaOwnerCustomerId=' + mediaOwnerCustomerId;

httpsReqGet(
	path,
	function (result) {	
		tmpListe = JSON.parse(result).playlists;
		var playlistsJSON = [];
		var playlistsTitles = [];
		var playlistsIDs = [];
		for (playlist in tmpListe) {			
			var obj = {  
				"title": tmpListe[playlist][0].title,
				"playlistId": tmpListe[playlist][0].playlistId
			};			
			playlistsJSON.push(obj);				
			playlistsTitles.push(tmpListe[playlist][0].title);				
			playlistsIDs.push(tmpListe[playlist][0].playlistId);				
		}
		setState(pfad + ".Playlists.JSON", JSON.stringify(playlistsJSON));
		setState(pfad + ".Playlists.Titles", playlistsTitles.join(';'));
		setState(pfad + ".Playlists.IDs", playlistsIDs.join(';'));			
	}
);

}

liest per https-GET die letzten 20 Alexa-History-Einträge von Amazon ein und speichert diese in die "Playlists.X" States
*/
function rescanHistory() {

var path = 'https://alexa.amazon.de/api/activities?startTime=&size=20&offset=1';

Updated ein Device per DatenpunktName, sowohl "control", als auch "player" wird
abgerufen und gespeichert befindet sich currentState im Modus "PLAYING", so wird
mit einem Timeout diese Funktion für das Device erneut aufgerufen
@param string deviceDpName
*/
function updateDevice(deviceDpName){

		// deviceObjectPath + clearName(deviceDpName) + ".control.lastState"
		getDeviceStateBySerialAndType(devices[deviceDpName].serialNumber, devices[deviceDpName].deviceType, function(deviceState){

			// nur updaten, wenn unterschiedlich
			if (deviceState.volume != getState(controlPath + ".volume").val) {
				setState(controlPath + ".volume", parseInt(deviceState.volume));
			}

			getDevicePlayerBySerialAndType(devices[deviceDpName].serialNumber, devices[deviceDpName].deviceType, function(devicePlayer){

				// player	
				var playerPath = deviceObjectPath + clearName(deviceDpName) + ".player";
				setState(playerPath + ".contentType", getStringOrEmpty(deviceState.contentType));
				setState(playerPath + ".currentState", getStringOrEmpty(deviceState.currentState));
				setState(playerPath + ".imageURL", getStringOrEmpty(deviceState.imageURL));
				setState(playerPath + ".muted", deviceState.muted);
				setState(playerPath + ".providerId", getStringOrEmpty(deviceState.providerId));
				setState(playerPath + ".radioStationId", getStringOrEmpty(deviceState.radioStationId));
				setState(playerPath + ".service", getStringOrEmpty(deviceState.service));

				var providerName = '';
				if ((devicePlayer !== undefined) && ("provider" in devicePlayer) && (devicePlayer.provider !== null)){
					providerName = getStringOrEmpty(devicePlayer.provider.providerName);
				}
				setState(playerPath + ".providerName", providerName);

			});
		});

	} else {
		logInfo('[updateDevice] Device not controllable: ' + deviceDpName);
	}
}else {
	logInfo('[updateDevice] Device unknown: ' + deviceDpName);
}

}

Inkrementiert "mediaProgress" alle 2 Sekunden um 2. So wird ein permanentes https-get überflüssig
ruft sich nach 2 Sekunden erneut selbst auf, wenn "currentState" noch auf "PLAYING" steht.
ist "mediaProgress" größer als "mediaLength", so ist der Song zu Ende und "updateDevice" wird aufgerufen.
@param string deviceDpName
*/
function updateMediaProgress(deviceDpName) {

if ((currentState == 'PLAYING') ) {	
	mediaProgressNew = mediaProgress + 2;

	// Am Ende des Titels soll neu geladen werden. Ist es Radio (länge = 0) dann alle 200 sekunden
	if ((mediaProgressNew > mediaLength) && ((mediaLength > 0) || (mediaProgressNew % 200 < 2))){		
		setTimeout( function() { updateDevice(deviceDpName); }, 2000 );
	}

	// Nun mediaProgress und mediaProgressPercent neu berechnen
	if (mediaLength > 0) {
		mediaProgressPercent = Math.round((((mediaProgressNew) * 100) / mediaLength));
	} else {
		mediaProgressPercent = 0;
	}
	setState(playerPath + ".mediaProgressPercent", mediaProgressPercent);
	setState(playerPath + ".mediaProgress", mediaProgressNew);
	setState(playerPath + ".mediaProgressStr", sekToHMS(mediaProgressNew));

	setTimeout( function() { updateMediaProgress(deviceDpName); }, 2000 );

}

}

Ruft den aktuellen State eines Devices per Seriennummer und Type von Amazon ab.
Gibt die Antwort an "callback(result)" weiter
@param string serialNumber
@param string deviceType
@param function callback
*/
function getDeviceStateBySerialAndType(serialNumber, deviceType, callback) {
httpsReqGet(
'/api/media/state?deviceSerialNumber=' + serialNumber + '&deviceType=' + deviceType,
function(result) {
// Es kommt vor, dass Geräte nicht antworten, weil sie nicht aktiv sind. Dann greift hier der Dummy-Wert
if (result == '{"message":null}') {
result = JSON.stringify({
"clientId":null,
"contentId":null,
"contentType":null,
"currentState":"IDLE",
"imageURL":null,
"isDisliked":false,
"isLiked":false,
"looping":false,
"mediaOwnerCustomerId":null,
"muted":false,
"programId":null,
"progressSeconds":0,
"providerId":null,
"queue":null,
"queueId":null,
"queueSize":0,
"radioStationId":null,
"radioVariety":0,
"referenceId":null,
"service":null,
"shuffling":false,
"timeLastShuffled":0,
"volume":0
});
}
if(callback !== undefined && typeof callback === 'function') callback(JSON.parse(result));
}
);
}

Ruft den aktuellen State eines Devices per DatenpunktNamen von Amazon ab.
Gibt die Antwort an "callback(result)" weiter
@param string deviceDpName
@param function callback
*/
function getDeviceState(deviceDpName, callback) {
getDeviceStateBySerialAndType(devices[deviceDpName].serialNumber, devices[deviceDpName].deviceType, callback);
}

Ruft die aktuelle PlayerInfo eines Devices per Seriennummer und Type von Amazon ab.
Gibt die Antwort an "callback(result)" weiter
@param string serialNumber
@param string deviceType
@param function callback
*/
function getDevicePlayerBySerialAndType(serialNumber, deviceType, callback) {
httpsReqGet(
'/api/np/player?deviceSerialNumber=' + serialNumber + '&deviceType=' + deviceType,
function(result) {
// Es kommt vor, dass Geräte nicht antworten, weil sie nicht aktiv sind. Dann greift hier der Dummy-Wert
if (result == '{"message":null}') {
result = JSON.stringify({
"playerInfo":{
"hint":null,
"infoText":null,
"isPlayingInLemur":false,
"lemurVolume":null,
"lyrics":null,
"mainArt":null,
"mediaId":null,
"miniArt":null,
"miniInfoText":null,
"playbackSource":null,
"playingInLemurId":null,
"progress":null,
"provider":null,
"queueId":null,
"state":null,
"template":null,
"transport":null,
"volume":null
}
});
}
```
 	if(callback !== undefined && typeof callback === 'function') callback(JSON.parse(result).playerInfo);
 }
```
);
}

Ruft die aktuelle PlayerInfo eines Devices per DatenpunktNamen von Amazon ab.
Gibt die Antwort an "callback(result)" weiter
@param string deviceDpName
@param function callback
*/
function getDevicePlayer(deviceDpName, callback) {
getDevicePlayerBySerialAndType(devices[deviceDpName].serialNumber, devices[deviceDpName].deviceType, callback);
}

liest per https-GET alle Alexa-fähigen Geräte neu ein und updated bei allen
bereits bekannten Geräten die Infos, wie z.B. Onlinestatus, WLAN, etc.
*/
function updateAlexa(){
logInfo('[updateAlexa]');
httpsReqGet('/api/devices/device', function(result) {
// Falls Result leer ist, soll nichts weiter gemacht werden
if(!result) return logWarn("Es konnten keine Daten ermittelt werden! Cookie richtig?");
logDebug(result);
```
 var alexaDeviceObj      = JSON.parse(result);

 var numberOfDevices     = alexaDeviceObj.devices.length;
 logInfo("Anzahl vorhandener Geräte mit Alexa Unterstützung: " + numberOfDevices);
```

	// Devices
	for(var i = 0; i < numberOfDevices; i++) {
		// Nur bekannte Geraete updaten
		if(typeof(devices[clearName(alexaDeviceObj.devices[i].accountName)]) != "undefined") {

			// Pruefen, ob das Geraet noch das selbe ist
			if (devices[clearName(alexaDeviceObj.devices[i].accountName)].serialNumber != alexaDeviceObj.devices[i].serialNumber){
				logError('Das Geraet "' + clearName(alexaDeviceObj.devices[i].accountName) + '" hat nach update eine andere Seriennummer!');
			} else {

				var devicePath = deviceObjectPath + clearName(alexaDeviceObj.devices[i].accountName) + ".device";

				httpsReqGet(
					'/api/device-wifi-details?deviceSerialNumber=' + alexaDeviceObj.devices[i].serialNumber + '&deviceType=' + alexaDeviceObj.devices[i].deviceType,
					function(result) {
						setState(devicePath + ".essid",			getStringOrEmpty(JSON.parse(result).essid));
						setState(devicePath + ".macAddress",	getStringOrEmpty(JSON.parse(result).macAddress));
					}
				);

				setState(devicePath + ".language",			getStringOrEmpty(alexaDeviceObj.devices[i].language));
				setState(devicePath + ".online",			alexaDeviceObj.devices[i].online);
				setState(devicePath + ".parentClusters",	getStringOrEmpty(alexaDeviceObj.devices[i].parentClusters));
				setState(devicePath + ".softwareVersion",	getStringOrEmpty(alexaDeviceObj.devices[i].softwareVersion));

				// Device updaten
				updateDevice(clearName(alexaDeviceObj.devices[i].accountName));
			}

		} 
	}
});

}

liest per https-GET alle Alexa-fähigen Geräte ein und legt die Objekte an
*/
function initAlexa() {
httpsReqGet('/api/devices/device', function(result) {
// Falls Result leer ist, soll nichts weiter gemacht werden
if(!result) return logWarn("Es konnten keine Daten ermittelt werden! Cookie richtig?");
logDebug(result);
```
 var alexaDeviceObj      = JSON.parse(result);

 var numberOfDevices     = alexaDeviceObj.devices.length;
 logInfo("Anzahl vorhandener Geräte mit Alexa Unterstützung: " + numberOfDevices);
```

	// Devices
	for(var i = 0; i < numberOfDevices; i++) {
		if (listNonCotrollable || deviceIsControllable(alexaDeviceObj.devices[i].capabilities)) {		
			devices[clearName(alexaDeviceObj.devices[i].accountName)] = createDevice(alexaDeviceObj.devices[i], forceCreation);
		}
	}

	// Update
	createState(
		pfad + ".update",
		false,
		forceCreation,
		{name:"Update Devices",   type:"boolean",  role:"button"}, 
		null,					
		function () {
			setTimeout(
				function() {
					logInfo("CreateON: " + pfad + ".update");
					on({id: "javascript." + instance + "." + pfad + ".update", change: "any"}, 
					function (obj){
						unsetButtonFirst(obj, function (obj) {updateAlexa();});
					})
				}
				,
				3000
			);
		}
	);

	// Playlists	
	createDeviceState(pfad + ".Playlists.JSON",		null,	forceCreation,  {name:"Playlists als JSON",   					type:"string",  role:"state"});
	createDeviceState(pfad + ".Playlists.Titles",	null,	forceCreation,  {name:"Playlist Titel als Liste fuer Dropdown",	type:"string",  role:"state"});
	createDeviceState(pfad + ".Playlists.IDs",		null,	forceCreation,  {name:"Playlist IDs als Liste fuer Dropdown",	type:"string",  role:"state"});
	createState(
		pfad + ".Playlists.update",
		false,
		forceCreation,
		{name:"Update Playlists",   type:"boolean",  role:"button"}, 
		null,					
		function () {
			setTimeout(
				function() {
					logInfo("CreateON: " + pfad + ".Playlists.update");
					on({id: "javascript." + instance + "." + pfad + ".Playlists.update", change: "any"}, 
					function (obj){
						unsetButtonFirst(obj, function (obj) {updatePlaylists();});
					})
				}
				,
				3000
			);
		}
	);
	// Einmalig die Playlists abfragen
	updatePlaylists();

	// History
	createState(pfad + ".History.creationTime",	null,	forceCreation,  {name:"Timestamp",		type:"number",  role:"state"});
	createState(pfad + ".History.deviceName",	null,	forceCreation,  {name:"deviceName",		type:"string",  role:"state"});
	createState(pfad + ".History.summary",		null,	forceCreation,  {name:"summary",		type:"string",  role:"state"});
	createState(
		pfad + ".History.update",
		false,
		forceCreation,
		{name:"Update History",   type:"boolean",  role:"button"}, 
		null,					
		function () {
			setTimeout(
				function() {
					logInfo("CreateON: " + pfad + ".History.update");
					on({id: "javascript." + instance + "." + pfad + ".History.update", change: "any"}, 
					function (obj){
						unsetButtonFirst(obj, function (obj) {rescanHistory();});
					})
				}
				,
				3000
			);
		}
	);
	// Erstmalig die History abgragen
	rescanHistory();
});

}

Erzeugt alle States zu einem übergebenen Device-Objekt. Anhand der "capabilities"
des Devices, werden, ggf. "control" und "player" States erstellt.
@param object amazonDeviceObject
@param boolean forceCreation
*/
function createDevice(amazonDeviceObject, forceCreation) {
logInfo('createDevice: '+ amazonDeviceObject.accountName);

var devicePath = deviceObjectPath + clearName(amazonDeviceObject.accountName) + ".device";

// device
createDeviceState(devicePath + ".accountName", getStringOrEmpty(amazonDeviceObject.accountName), forceCreation, {name:"Name", type:"string", role:"value"});
createDeviceState(devicePath + ".capabilities", getStringOrEmpty(JSON.stringify(amazonDeviceObject.capabilities)), forceCreation, {name:"Fähigkeiten", type:"string", role:"value"});
createDeviceState(devicePath + ".clusterMembers", getStringOrEmpty(JSON.stringify(amazonDeviceObject.clusterMembers)), forceCreation, {name:"GruppenMitglieder", type:"string", role:"value"});
createDeviceState(devicePath + ".deviceAccountId", getStringOrEmpty(amazonDeviceObject.deviceAccountId), forceCreation, {name:"AccountId", type:"string", role:"value"});
createDeviceState(devicePath + ".deviceFamily", getStringOrEmpty(amazonDeviceObject.deviceFamily), forceCreation, {name:"DeviceFamily", type:"string", role:"value"});
createDeviceState(devicePath + ".deviceOwnerCustomerId", getStringOrEmpty(amazonDeviceObject.deviceOwnerCustomerId), forceCreation, {name:"deviceOwnerCustomerId", type:"string", role:"value"});
createDeviceState(devicePath + ".deviceType", getStringOrEmpty(amazonDeviceObject.deviceType), forceCreation, {name:"deviceType", type:"string", role:"value"});
createDeviceState(devicePath + ".deviceTypeString", getStringOrEmpty(deviceTypeStr(amazonDeviceObject.deviceType)), forceCreation, {name:"deviceType als String", type:"string", role:"value"});
createDeviceState(devicePath + ".deviceTypeFriendlyName", getStringOrEmpty(amazonDeviceObject.deviceTypeFriendlyName), forceCreation, {name:"deviceTypeFriendlyName", type:"string", role:"value"});

createDeviceState(devicePath + ".language",					getStringOrEmpty(amazonDeviceObject.language),				forceCreation,   {name:"language", type:"string", role:"value"});
createDeviceState(devicePath + ".online",					amazonDeviceObject.online,									forceCreation,   {name:"online (Klappt nur bei ECHOs)", type:"boolean", role:"value"});
createDeviceState(devicePath + ".parentClusters",			getStringOrEmpty(amazonDeviceObject.parentClusters),		forceCreation,   {name:"Mitglied in dieser Gruppe", type:"string", role:"value"});
createDeviceState(devicePath + ".serialNumber",				getStringOrEmpty(amazonDeviceObject.serialNumber),			forceCreation,   {name:"serialNumber", type:"string", role:"value"});
createDeviceState(devicePath + ".softwareVersion",			getStringOrEmpty(amazonDeviceObject.softwareVersion),		forceCreation,   {name:"softwareVersion", type:"string", role:"value"});

if (deviceIsControllable(amazonDeviceObject.capabilities)) {
	createDeviceControl(amazonDeviceObject, forceCreation);
}

return { 
	'serialNumber' : amazonDeviceObject.serialNumber,
	'deviceType' : amazonDeviceObject.deviceType,
	'capabilities' : amazonDeviceObject.capabilities
};

}

Erzeugt alle "control" und "player" States zu einem übergebenen Device-Objekt.
Für Initial-Werte wird das Device bei Amazon zunächst abgefragt
@param object amazonDeviceObject
@param boolean forceCreation
*/
function createDeviceControl(amazonDeviceObject, forceCreation) {
logInfo('createDeviceControl: '+ amazonDeviceObject.accountName);

// control		
createDeviceState(controlPath + ".LastStatus",				'INIT',					forceCreation,	{name:"Letzter Status", 			type:"string",	role:"value"});
createDeviceControlState(controlPath + ".updateDevice",		false,					forceCreation,	{name:"Device abfragen",			type:"boolean",	role:"button"});

	createDeviceControlState(controlPath + ".volume",			parseInt(deviceState.volume),	forceCreation,   {name:"Volume in Prozent(0-100)",				type:"number",	role:"level.volume"});
	createDeviceControlState(controlPath + ".pause",			false,							forceCreation,   {name:"Pause",									type:"boolean",	role:"button"});
	createDeviceControlState(controlPath + ".play",				false,							forceCreation,   {name:"Play",									type:"boolean",	role:"button"});

	if(deviceHasTuneIn(amazonDeviceObject.capabilities)){
		createDeviceControlState(controlPath + ".radio",	false,					forceCreation,   {name:"Letzte Radiostation an/aus",	type:"boolean",	role:"switch"});
		createDeviceControlState(controlPath + ".tunein",	defaultRadiostation,	forceCreation,   {name:"tunein Radiosenderkennung",		type:"string",	role:"control.value"});
	}

	getDevicePlayerBySerialAndType(amazonDeviceObject.serialNumber, amazonDeviceObject.deviceType, function(devicePlayer){

		// player	
		var playerPath = deviceObjectPath + clearName(amazonDeviceObject.accountName) + ".player";

		createDeviceState(playerPath + ".contentType",			getStringOrEmpty(deviceState.contentType),		forceCreation,   {name:"contentType", type:"string", role:"value"});	// "LIVE_STATION" | "TRACKS" | "CUSTOM_STATION"
		createDeviceControlState(playerPath + ".currentState",	getStringOrEmpty(deviceState.currentState),		forceCreation,   {name:"currentState", type:"string", role:"value"});	// "PAUSED" | "PLAYING"
		createDeviceState(playerPath + ".imageURL",				getStringOrEmpty(deviceState.imageURL),			forceCreation,   {name:"Grosses Bild", type:"string", role:"value"});
		createDeviceState(playerPath + ".muted",				deviceState.muted,								forceCreation,   {name:"muted", type:"boolean", role:"value"});
		createDeviceState(playerPath + ".providerId",			getStringOrEmpty(deviceState.providerId),		forceCreation,   {name:"providerId", type:"string", role:"value"}); // "TUNE_IN" | "CLOUD_PLAYER" | "ROBIN"
		createDeviceState(playerPath + ".radioStationId",		getStringOrEmpty(deviceState.radioStationId),	forceCreation,   {name:"radioStationId", type:"string", role:"value"}); // "s24885" | null
		createDeviceState(playerPath + ".service",				getStringOrEmpty(deviceState.service),			forceCreation,   {name:"service", type:"string", role:"value"}); // "TUNE_IN" | "CLOUD_PLAYER" | "PRIME_STATION"

		var providerName = null;
		if ((devicePlayer !== undefined) &&("provider" in devicePlayer) && (devicePlayer.provider !== null)){
			providerName = getStringOrEmpty(devicePlayer.provider.providerName);
		}

		createDeviceState(playerPath + ".providerName",			providerName,							forceCreation,	{name:"active providerName",     type:"string",      role:"value"}); // "Amazon Music" | "TuneIn Live-Radio"

		var title = '';
		var interpreter = '';
		var album = '';
		if ((devicePlayer !== undefined) &&("infoText" in devicePlayer) && (devicePlayer.infoText !== null)){
			title = getStringOrEmpty(devicePlayer.infoText.title);
			interpreter = getStringOrEmpty(devicePlayer.infoText.subText1);
			album = getStringOrEmpty(devicePlayer.infoText.subText2);
		}
		createDeviceState(playerPath + ".title",				title,									forceCreation,	{name:"active title",    		 type:"string",      role:"value"});
		createDeviceState(playerPath + ".interpreter",			interpreter,							forceCreation,	{name:"active interpreter",    	 type:"string",      role:"value"});
		createDeviceState(playerPath + ".album",				album,									forceCreation,	{name:"active album",    		 type:"string",      role:"value"});

		var mainArtUrl = '';
		if ((devicePlayer !== undefined) &&("mainArt" in devicePlayer) && (devicePlayer.mainArt !== null)){
			mainArtUrl = getStringOrEmpty(devicePlayer.mainArt.url);
		}			
		createDeviceState(playerPath + ".mainArtUrl",			mainArtUrl,				forceCreation,	{name:"active mainArtUrl",    	 type:"string",      role:"value"});

		var miniArtUrl = '';
		if ((devicePlayer !== undefined) &&("miniArt" in devicePlayer) && (devicePlayer.miniArt !== null)){
			miniArtUrl = getStringOrEmpty(devicePlayer.miniArt.url);
		}			
		createDeviceState(playerPath + ".miniArtUrl",			miniArtUrl,				forceCreation,	{name:"active miniArtUrl",    	 type:"string",      role:"value"});

		var mediaLength = 0;
		var mediaProgress = 0;
		var mediaProgressPercent = 0;
		if ((devicePlayer !== undefined) &&("progress" in devicePlayer) && (devicePlayer.progress !== null)) {
			mediaLength = parseInt(devicePlayer.progress.mediaLength);
			mediaProgress = parseInt(devicePlayer.progress.mediaProgress);
			if (mediaLength > 0) {					
				mediaProgressPercent = Math.round(((mediaProgress * 100) / mediaLength));
			}
		}
		createDeviceState(playerPath + ".mediaLength",			mediaLength,				forceCreation,	{name:"active mediaLength",    			type:"number",      role:"value"});
		createDeviceState(playerPath + ".mediaLengthStr",		sekToHMS(mediaLength),		forceCreation,	{name:"active mediaLength als (HH:)MM:SS",    			type:"string",      role:"value"});
		createDeviceState(playerPath + ".mediaProgress",		mediaProgress,				forceCreation,	{name:"active mediaProgress",    		type:"number",      role:"value"});
		createDeviceState(playerPath + ".mediaProgressStr",		sekToHMS(mediaProgress),	forceCreation,	{name:"active mediaProgress als (HH:)MM:SS",    		type:"string",      role:"value"});
		createDeviceState(playerPath + ".mediaProgressPercent",	mediaProgressPercent,		forceCreation,	{name:"active mediaProgressPercent",    type:"number",      role:"value"});
	});
});

}

Erzeugt einen State und macht danach einen Logeintrag
@param string objectdevicePath
@param mixed initialValue
@param boolean forceCreation
@param object common
*/
function createDeviceState(objectdevicePath, initialValue, forceCreation, common) {
createState(objectdevicePath, initialValue, forceCreation, common, null, function(){logInfo('createState: ' + objectdevicePath)});
}

Erzeugt einen State und macht danach einen Logeintrag
Dann wird für den State eine "on()-Funktion" erzeugt, die die gewünschte Funktion ausfürht
@param string objectdevicePath
@param mixed initialValue
@param boolean forceCreation
@param object common
*/
function createDeviceControlState(objectdevicePath, initialValue, forceCreation, common) {
createState(
objectdevicePath,
initialValue,
forceCreation,
common,
null,
function () {
logInfo('createState: ' + objectdevicePath);
setTimeout(
function() {
logInfo("CreateON: " + objectdevicePath);
on({id: "javascript." + instance + "." + objectdevicePath, change: "any"},
function (obj){
```
 				var   objArr  = obj.id.match(/(^.+)\.(.+)\.(.+)\.(.+)$/, ""); //Aufteilung in devicePath + deviceDpName + CMD
 				var deviceDpName  = objArr[2]; 
 				var cmd     = objArr[4]; 
 				logDebug("Device: " + deviceDpName+", Kommando: " + cmd);
 				parameter = obj.state.val;
```

					switch (cmd) {
						// Buttons, werden immer wieder auf false gesetzt								
						case "updateDevice": 
							unsetButtonFirst(obj, function (obj) {updateDevice(deviceDpName);});
							break;								
						case "pause":
							unsetButtonFirst(obj, function (obj) {setPause(deviceDpName, reloadCallback);});
							break;
						case "play":
							unsetButtonFirst(obj, function (obj) {setPlay(deviceDpName, reloadCallback);});
							break;
						case "next":
							unsetButtonFirst(obj, function (obj) {setNext(deviceDpName, reloadCallback);});
							break;
						case "previous":
							unsetButtonFirst(obj, function (obj) {setPrevious(deviceDpName, reloadCallback);});
							break;
						case "forward":
							unsetButtonFirst(obj, function (obj) {setForward(deviceDpName, reloadCallback);});
							break;
						case "rewind":
							unsetButtonFirst(obj, function (obj) {setRewind(deviceDpName, reloadCallback);});
							break;

						//Switch
						case "shuffle":
							if(parameter === null){
								logWarn("Alexa Shuffle: kein true/false angegeben. Auf true gesetzt.");
								parameter = true;
							}
							setShuffle(deviceDpName, parameter);
							break;

						case "repeat":
							if(parameter === null){
								logWarn("Alexa Repeat: kein true/false angegeben. Auf true gesetzt.");
								parameter = true;
							}
							setRepeat(deviceDpName, parameter);
							break;

						case "radio":
							if(obj.state.val) {
								// Letzte Radiostation einschlaten
								var stationId = getState(deviceObjectPath + deviceDpName + ".control.tunein").val;
								setTuneIn(deviceDpName,stationId, reloadCallback);
							} else {
								// Musik auf Pause.
								setPause(deviceDpName, reloadCallback);
							}
							break;

						case "volume":
							if(!parameter ||parameter === null){
								logWarn("Alexa Volume: keine Lautstärke angegeben. Parameter fehlt.");
								break;
							}
							parameter = parseInt(parameter);
							if(parameter < 0) {
								parameter = 0;
								logWarn("Alexa Volume: ungültige Lautsträke angegeben (<0). Auf 0 gesetzt.");
							}
							if(parameter > 100) {
								parameter = 100;
								logWarn("Alexa Volume: ungültige Lautsträke angegeben (>100). Auf 100 gesetzt.");
							}
							setVolume(deviceDpName, parameter);
							break;

						case "playlistId":
							setPlaylistId(deviceDpName, parameter, reloadCallback);
							break;

						case "tunein":
							setTuneIn(deviceDpName,parameter, reloadCallback);
							break;

						case "currentState":	
							// den aktuellen "mediaProgress" berechnen, statt ihn immer neu runterzuladen
							if ((obj.oldState.val == 'PAUSED') && (obj.state.val == 'PLAYING')) {
								// Wechsel von Pause zu Playing
								updateMediaProgress(deviceDpName);
							} else if (obj.state.val == 'PLAYING') {
								// war vorher nicht Pause, nun aber Playing, dann überprüfen, ob sich "mediaProgress" 
								// innerhalb einer gewissen Zeit verändert (dann wurde die Funktion bereits ausgeführt)
								var playerPath = deviceObjectPath + deviceDpName + ".player";
								setTimeout( function() {
									var mediaProgress = getState(playerPath + ".mediaProgress").val;
									setTimeout( function() {									
										var mediaProgressNew = getState(playerPath + ".mediaProgress").val;
										// Wurde mediaProgress in der Zeit trotz PLAYING nicht verändert, dann trotzdem ausführen
										if (mediaProgressNew == mediaProgress){
											setState(playerPath + ".mediaProgress", mediaProgressNew + 7);
											updateMediaProgress(deviceDpName);
										}									
									}, 5000 );
								}, 3000 );
							}
							break;

						default:
							logWarn("Kommando << "+cmd+" >> im Skript nicht behandelt");
							break;
					}
				})								
			}
			,
			3000
		);
	}
);

}

Setzt die Options für den https Request
@param string path
@param string method - Should be GET oder POST
*/
function setOptions(path,method) {
var options = {
"host": 'layla.amazon.de',
"path": path,
"method": method,
"timeout":10000,
"headers": {
'User-Agent' : 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/57.0.2987.133 Safari/537.36',
'Content-Type': 'text/plain',
'csrf' : csrf,
'Cookie' : cookie
}
};
return options;
}

Erzeugt eine GET Anfrage
@param string path
@param function callback
*/
function httpsReqGet(path,callback) {
logDebug("Abfrage " + path + " an Alexa gesendet");
var options = setOptions(path,"GET");
var req = https.get(options, function getDevices(res) {
logDebug('STATUS: ' + res.statusCode) + ": " + statusCode(res.statusCode); // Statuscode
logDebug('HEADERS: ' + JSON.stringify(res.headers)); // Header (Rückmeldung vom Webserver)
// Buffer the body entirely for processing as a whole.
var bodyChunks = [];
var chunkLine = 0;

Setzt das Device auf die Lautstärke
@param string deviceDpName
@param integer volumeLevel
@param function callback
*/
function setVolume(deviceDpName, volumeLevel, callback) {httpsPostCmd(deviceDpName, '{"type":"VolumeLevelCommand","volumeLevel":' + volumeLevel + '}' , callback);}

Setzt das Device auf PLAY
@param string deviceDpName
@param function callback
*/
function setPlay(deviceDpName, callback) {httpsPostCmd(deviceDpName, '{"type":"PlayCommand"}', callback);}

Setzt das Device auf PAUSE
@param string deviceDpName
@param function callback
*/
function setPause(deviceDpName, callback) {httpsPostCmd(deviceDpName, '{"type":"PauseCommand"}', callback);}

Setzt das Device auf NEXT
@param string deviceDpName
@param function callback
*/
function setNext(deviceDpName, callback) {httpsPostCmd(deviceDpName, '{"type":"NextCommand"}', callback);}

Setzt das Device auf PREVIOUS
@param string deviceDpName
@param function callback
*/
function setPrevious(deviceDpName, callback) {httpsPostCmd(deviceDpName, '{"type":"PreviousCommand"}', callback);}

Setzt das Device auf FORWARD
@param string deviceDpName
@param function callback
*/
function setForward(deviceDpName, callback) {httpsPostCmd(deviceDpName, '{"type":"ForwardCommand"}', callback);}

Setzt das Device auf REWIND
@param string deviceDpName
@param function callback
*/
function setRewind(deviceDpName, callback) {httpsPostCmd(deviceDpName, '{"type":"RewindCommand"}', callback);}

Setzt für das Device SHUFFLE auf den gewünschten zustand
@param string deviceDpName
@param boolean state
@param function callback
*/
function setShuffle(deviceDpName, state, callback) {httpsPostCmd(deviceDpName, '{"type":"ShuffleCommand","shuffle":' + state + '}', callback);}

Setzt für das Device REPEAT auf den gewünschten zustand
@param string deviceDpName
@param boolean state
@param function callback
*/
function setRepeat(deviceDpName, state, callback) {httpsPostCmd(deviceDpName, '{"type":"RepeatCommand","repeat":' + state + '}', callback);}

Schickt ein Kommando an Alexa
@param string deviceDpName
@param string postData
@param function callback
*/
function httpsPostCmd(deviceDpName, postData, callback) {

var path	= '/api/np/command?' 
	+ 'deviceSerialNumber=' + devices[deviceDpName].serialNumber 
	+ '&deviceType=' + devices[deviceDpName].deviceType ;

httpsPost(deviceDpName, path, postData, callback);

}

Startet auf dem Device den Radiosender
@param string deviceDpName
@param string stationId
@param function callback
*/
function setTuneIn(deviceDpName,stationId, callback) {

var path	= '/api/tunein/queue-and-play?' 
	+ 'deviceSerialNumber=' + devices[deviceDpName].serialNumber 
	+ '&deviceType=' + devices[deviceDpName].deviceType 
	+ '&guideId=' + stationId 
	+ '&contentType=station&callSign=&mediaOwnerCustomerId=' + mediaOwnerCustomerId;

Startet auf dem Device die Playlist
@param string deviceDpName
@param string playlistId
@param function callback
*/
function setPlaylistId(deviceDpName, playlistId, callback) {

var path	= '/api/cloudplayer/queue-and-play?' 
	+ 'deviceSerialNumber=' + devices[deviceDpName].serialNumber 
	+ '&deviceType=' + devices[deviceDpName].deviceType 
	+ '&shuffle=false'
	+ '&contentType=station&callSign=&mediaOwnerCustomerId=' + mediaOwnerCustomerId;

Erzeugt eine POST Anfrage und setzt den Status-Code
der Anfrage in das 'control.LastStatus' Feld
@param string deviceDpName
@param string path
@param string postData
@param function callback
*/
function httpsPost(deviceDpName, path, postData, callback) {

var options = setOptions(path,"POST");

// request object
var req = https.request(options, function (res) {
	var result = '';
	res.on('data', function (chunk) {
		result += chunk;
	});
	res.on('end', function () {
		logDebug(result);

		setState(deviceObjectPath + deviceDpName +".control.LastStatus",res.statusCode.toString()+" " + statusCode(res.statusCode));
		if(res.statusCode != 200) {
			logWarn("Negative Rückmeldung von Alexa: " + res.statusCode + ": " + statusCode(res.statusCode));
			logWarn("Gesendetes Kommando: " + postData);
		} else {
			logDebug('STATUS: ' + res.statusCode + ": " + statusCode(res.statusCode)); // Statuscode
		}
		if(res.statusCode != 200){
			logWarn('HEADERS: ' + JSON.stringify(res.headers)); // Header (Rückmeldung vom Webserver)
		}

        if(callback !== undefined && typeof callback === 'function') callback(result);
	});

	res.on('error', function (err) {
		logWarn('ERROR: ' + err.message);
	})
});

// req error
req.on('error', function (err) {
	logWarn('ERROR: ' + err.message);
});

//send request witht the postData form
req.write(postData);
req.end();

}

Setzt das gewünschte Loglevel
@param string level
*/
function setLoglevel(level) {
switch(level.toLowerCase()) {
case 'debug':
logLevelInt = 0;
break;
case 'info':
logLevelInt = 1;
break;
case 'warn':
logLevelInt = 2;
break;
case 'error':
logLevelInt = 3;
break;
case 'none':
logLevelInt = 4;
break;
default:
logLevelInt = 2;
break;
}
}

Logt eine DEBUG Message
(wird als info geloggt, da Debug nicht angezeigt wird)
@param string msg
*/
function logDebug(msg) {
if (logLevelInt <= 0) {
log(msg, "info");
}
}

Logt eine INFO Message
@param string msg
*/
function logInfo(msg) {
if (logLevelInt <= 1) {
log(msg, "info");
}
}

Logt eine WARN Message
@param string msg
*/
function logWarn(msg) {
if (logLevelInt <= 2) {
log(msg, "warn");
}
}

Logt eine ERROR Message
@param string msg
*/
function logError(msg) {
if (logLevelInt <= 3) {
log(msg, "error");
}
}

Durchsucht ein Array nach needle und
liefert bei Erfolg TRUE
@param string needle
@param array haystack
@return boolean
*/
function inArray(needle, haystack) {
var length = haystack.length;
for(var i = 0; i < length; i++) {
if(haystack[i] == needle) return true;
}
return false;
}

Gibt zurück, ob die capabilities ein Steuern zulassen
@param array capabilities
@return boolean
*/
function deviceIsControllable(capabilities) {
return (inArray('AUDIO_PLAYER', capabilities)
|| inArray('AMAZON_MUSIC', capabilities)
|| inArray('TUNE_IN', capabilities));
}

Gibt zurück, ob die capabilities eine Audiowiedergabe zulassen
@param array capabilities
@return boolean
*/
function deviceHasMusicPlayer(capabilities) {
return (inArray('AUDIO_PLAYER', capabilities)
|| inArray('AMAZON_MUSIC', capabilities));
}

Gibt zurück, ob die capabilities TuneIn und somit Radio zulassen
@param array capabilities
@return boolean
*/
function deviceHasTuneIn(capabilities) {
return (inArray('TUNE_IN', capabilities));
}

Button wieder auf false zurücksetzen, wenn er true war, danach callback
@param object obj
@param function callback
*/
function unsetButtonFirst(obj, callback) {
if(getState(obj.id).val) {
setState(obj.id,false);
if(callback !== undefined && typeof callback === 'function') callback(obj);
}
}

Liefert str als String zurück, '' anstelle von null, false, ...
@param mixed str
@return string
*/
function getStringOrEmpty(str){
return (String(str) !== 'undefined') ? String(str) : '';
}

Liefert das Device anhand der seriennummer
@param string serialNumber
@param object
*/
function getDeviceNameBySerialNumber(serialNumber) {

return null;
}

Liefert das erste Device das einen MusicPlayer hat,
oder null, wenn es keines gibt
@return object|null
*/
function getEchoWithMusicPlayerFromDevices() {
for (device in devices) {
if (deviceHasMusicPlayer(devices[device].capabilities)) {
return devices[device];
}
}
return null;
}

Liefert einen bereinigten Namen um daraus einen State-Pfad zu erzeugen
@param string name
@return string
*/
function clearName(name){
name = umlaut(name);
name = name.replace(/\W/g,"_");
return name;
}

Ersetzt Umlaufe/Sonderzeichen
@param string str
@return string
*/
function umlaut(str) {
return str
.replace(/Â|À|Å|Ã/g, "A")
.replace(/â|à|å|ã/g, "a")
.replace(/Ä/g, "AE")
.replace(/ä/g, "ae")
.replace(/Ç/g, "C")
.replace(/ç/g, "c")
.replace(/É|Ê|È|Ë/g, "E")
.replace(/é|ê|è|ë/g, "e")
.replace(/Ó|Ô|Ò|Õ|Ø/g, "O")
.replace(/ó|ô|ò|õ/g, "o")
.replace(/Ö/g, "OE")
.replace(/ö/g, "oe")
.replace(/Š/g, "S")
.replace(/š/g, "s")
.replace(/ß/g, "ss")
.replace(/Ú|Û|Ù/g, "U")
.replace(/ú|û|ù/g, "u")
.replace(/Ü/g, "UE")
.replace(/ü/g, "ue")
.replace(/Ý|Ÿ/g, "Y")
.replace(/ý|ÿ/g, "y")
.replace(/Ž/g, "Z")
.replace(/ž/, "z");
}

Liefert einen String zum http-Status
@param integer status
@return string
/
function statusCode(status) {
if(status === 0) return "* Daten unvollständig ** (csrf fehlt/falsch? Cookie falsch?)";
if(status == 200) return "** OK ";
if(status == 302) return " Found (Moved Temporarily) ** (Cookie abgelaufen?)";
if(status == 401) return "** Unauthorized ** (Cookie nicht richtig gesetzt?)";
if(status == 403) return "** Forbidden ** (Kombination Cookie, deviceType, Seriennummer richtig?)";
if(status == 404) return "** Not Found ** (Kommando im Kontext des Geräts sinnvoll?)";
if(status == 500) return "** Internal Server Error** (ggf. Kommando im falschen Kontext verwendet?)";
return "Fehler";
}

Liefert einen String zum deviceType
@param integer deviceType
@return string
*/
function deviceTypeStr(deviceType){
if(!knownDeviceType[deviceType] || knownDeviceType[deviceType] === undefined) return "Gerät unbekannt";
return knownDeviceType[deviceType];
}

Konvertiert eine Sekundenzahl in einen String im Format (HH:)MM:SS
@param integer sek
@return string
*/
function sekToHMS(sek) {

if (sek === 0) {
return '0';
}

var sec_num = parseInt(sek, 10);
var hours = Math.floor(sec_num / 3600);
var minutes = Math.floor((sec_num - (hours * 3600)) / 60);
var seconds = sec_num - (hours * 3600) - (minutes * 60);

if (hours  === 0) {
    return minutes+':'+seconds;
}

if (hours   < 10) {hours   = "0"+hours;}
return hours+':'+minutes+':'+seconds;

}`[/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i]

Hauke

Da in einem Beitrag sonst zu viele Zeichen wären, hier mein Widget-Export:

Ich habe "ioBroker.icons-ultimate-png" installiert - die anderen Icons zusammengesammelt. Hauptsächlich bei TuneIn.

Edit:Falsches Widget, durch aktuelles ersetzt

Nikoxx

Fettes Dankeschön :mrgreen: … läuft jetzt !

Arnulf

~~@Hauke:~~

csamaggi

Sehr cooles Skript woher bekomme ich denn die Radiostation ID damit ich die Default von Eins Live ändern kann?

MFG Maggi

RooftopBBQ

Die findest du auf der Seite von TuneIn.

Steht als letzte Zahl dann oben im Adressfeld deines Browsers.

Gruß

Marcel

NEWS

[SKRIPT] Alexa über ioBroker Steuern -> Kommandos an Alexa

Support us

879
Online

31.8k
Users

79.9k
Topics

1.3m
Posts

NEWS

[SKRIPT] Alexa über ioBroker Steuern -> Kommandos an Alexa

Support us

879Online

31.8kUsers

79.9kTopics

1.3mPosts

879
Online

31.8k
Users

79.9k
Topics

1.3m
Posts