Livello di automazione

Indice dei contenuti

Ottimizzare la produzione con il livello di automazione di mimoLive

Stai visualizzando un contenuto segnato da YouTube. Per accedere al contenuto effettivo, clicchi sul pulsante sottostante. Si prega di notare che in questo modo si condividono i dati con provider di terze parti.

Ulteriori informazioni

Il livello di automazione mimoLive è stato originariamente sviluppato come proof of concept, ma da allora si è rivelato uno strumento incredibilmente utile per gli utenti. Questo livello può essere utilizzato per automatizzare l'accensione e lo spegnimento dei livelli in una sequenza specifica o in momenti predeterminati, per recuperare dati da fonti remote via HTTP e inviare le informazioni elaborate ai campi di input del livello, per avviare e interrompere destinazioni di uscita, e molto altro ancora!

Gli script di automazione in mimoLive non vengono eseguiti in tempo reale

Tenga presente che la tempistica degli script di automazione in mimoLive potrebbe non essere accurata a causa della natura asincrona delle richieste HTTP richiamate dal motore di rendering video. Alcuni comandi di script inviano richieste HTTP all'API di mimoLive e la durata di queste richieste non può essere determinata con precisione, con conseguenti potenziali discrepanze nella tempistica. Lo tenga presente quando utilizza gli script di automazione nel suo flusso di lavoro di produzione.

Prerequisito

Per far funzionare questo livello, deve attivare il server HTTP in mimoLive per abilitare l'API di controllo remoto. Vada su mimoLive > Preferenze > Controlli remoti: Selezioni l'opzione "Allow Remote Control Access". (Attualmente il livello di automazione in mimoLive funziona solo senza password).

6102d04e 4eb3 4600 b410 0d2b2aef0767

Impostare il livello di automazione

Esistono due opzioni su come il livello deve comportarsi dopo essere stato attivato:

OpzioneComportamento
Spegnimento automatico del livelloQuesta opzione è singola in quanto applicata una volta che lo script ha terminato l'esecuzione, il livello si spegnerà automaticamente. Utilizzi questa opzione quando uno script deve essere eseguito una sola volta.
Spegnimento manuale del livello (ad esempio, da parte dell'operatore)In questa modalità, sono disponibili tre script:

- In diretta - Viene eseguito una volta quando il livello viene attivato.
- Mentre in diretta - Esegue continuamente un ciclo infinito dopo il termine dello script On Live.
- Spento - Funziona una volta quando il livello è spento.

Quando il livello viene spento, lo script While Live viene terminato prima che venga eseguito lo script Turned Off.
Se il livello viene riacceso, può rivivere lo stato precedente.

Codice sorgente Commenti

Per ricordare lo scopo e la funzionalità del suo script, le consigliamo di aggiungere commenti all'interno del codice. Inizi ogni riga di commento con //.

// First sleep for 5 seconds...
sleep(5)

// ...then start the Stop Watch layer:
layerOn("7C4665C4-0E17-4F63-BCFF-B59D68D75956")

Comandi di scripting

Il linguaggio di scripting è proprietario e comprende diversi comandi. Questi comandi sono elencati in una scheda informativa nell'anteprima del livello sulla destra. Se questo elenco è difficile da leggere, può espandere l'anteprima cliccando sul pulsante situato sopra e a destra dell'area di anteprima.

layerOn()

Attiva un livello o una variante di livello in base al suo ID o all'URL dell'endpoint API, oppure in base alla variabile.

// switching on a layer by its id
layerOn("4E38A868-DCB5-4E9C-AC75-231764229BFA")

// switching on a layer variant by its id
layerOn("4E38A868-DCB5-4E9C-AC75-231764229BFA/variants/5F18C566-F59F-45B4-8D40-27EF289D47B1")

// switching on a layer by its long API Endpoint URL
layerOn("/api/v1/documents/863743527/layers/4E38A868-DCB5-4E9C-AC75-231764229BFA")

// switching on a layer with a defined variable
setVariable($myLayerID, "4E38A868-DCB5-4E9C-AC75-231764229BFA")
layerOn($myLayerID)

layerOff(<API ID del livello come Espressione stringa>.)

Disattiva un livello o una variante di livello in base al suo ID o all'URL dell'endpoint API, oppure in base alla variabile.

// switching off a layer by its id
layerOff("4E38A868-DCB5-4E9C-AC75-231764229BFA")

// switching off a layer variant by its id
layerOff("4E38A868-DCB5-4E9C-AC75-231764229BFA/variants/5F18C566-F59F-45B4-8D40-27EF289D47B1")

// switching off a layer by its long API Endpoint URL
layerOff("/api/v1/documents/863743527/layers/4E38A868-DCB5-4E9C-AC75-231764229BFA")

// switching off a layer with a defined variable
setVariable($myLayerID, "4E38A868-DCB5-4E9C-AC75-231764229BFA")
layerOff($myLayerID)

layerSetRecall(<Livello API Imposta ID come espressione stringa>)

Attiva il richiamo per un determinato Set di livelli.

// recall a Layer Set by its id
layerSetRecall("E6950B7A-7457-44C5-81F7-972D9B04DBC3")

// recall a Layer Set by its long API Endpoint URL
layerSetRecall("/api/v1/documents/863743527/layer-sets/E6950B7A-7457-44C5-81F7-972D9B04DBC3")

// recall a Layer Set with a defined variable
setVariable($myLayerSetID, "E6950B7A-7457-44C5-81F7-972D9B04DBC3")
layerSetRecall($myLayerSetID)

outputOn(<API Output ID di destinazione come espressione di stringa>)

Attiva una destinazione di uscita.

// avvia una destinazione di output in base al suo id
outputOn("1953186E-4176-4849-A8ED-5B47EE1627BD")

// avvia una destinazione di output tramite il suo URL API Endpoint lungo
outputOn("/api/v1/documents/1677022440/output-destinations/1953186E-4176-4849-A8ED-5B47EE1627BD")

// avvia una destinazione di uscita con una variabile definita
setVariable($myOutputDestinationtID, "1953186E-4176-4849-A8ED-5B47EE1627BD")
outputOn($myOutputDestinationtID)

outputOff(<API Output ID di destinazione come espressione di stringa>)

Disattiva una destinazione di uscita.

// ferma una destinazione di uscita in base al suo id
outputOff("1953186E-4176-4849-A8ED-5B47EE1627BD")

// ferma una destinazione di output tramite il suo URL API Endpoint lungo
outputOff("/api/v1/documents/1677022440/output-destinations/1953186E-4176-4849-A8ED-5B47EE1627BD")

// interrompe una destinazione di uscita con una variabile definita
setVariable($myOutputDestinationtID, "1953186E-4176-4849-A8ED-5B47EE1627BD")
outputOff($myOutputDestinationtID)

getLayerData(1TP11NomeVariabileRisultato, ).

Recupera i dati del livello in base al percorso della chiave.

Questo comando combina più comandi in un'unica fase di script: Recupera le informazioni sul livello dal server HTTP e memorizza un campo dati specifico dalla risposta JSON in una variabile. È necessario il percorso esatto del valore che desidera leggere. Per il parametro di input dei livelli, questo percorso inizia solitamente con 'data.attributes.input-values'.

// set up useful variables
setVariable($myScoreboardLayerID, "36FA76B4-11FE-4879-8DE1-307222512712")
setVariable($pathToHomeScore, "data.attributes.input-values.tvGroup_Control__Score_Home")

// read the score for the home team from the Basketball layer
getLayerData($currentHomeScore, $myScoreboardLayerID, $pathToHomeScore)

// The variable $currentHomeScore now contains the Home Score input value of the Basketball Score layer

getObjectIDByName(1TP11NomeVariabileRisultato, ).

Recupera l'endpoint API per un oggetto mimoLive specificato in base al suo nome di visualizzazione.

Tenga presente che il nome visualizzato può essere modificato in qualsiasi momento dall'operatore nell'interfaccia utente di mimoLive. Se il nome cambia, lo script di automazione potrebbe fallire perché non riesce più a trovare l'oggetto specificato. D'altra parte, questo comando è utile per scoprire in modo programmatico gli endpoint API senza dover codificare i loro ID nello script.

Funziona per "sorgente", "livello", "livello-variante", "set di livelli", "uscita-destinazione".

// Get the API Endpoint for the Basketball Score layer
getObjectIDByName($myBasketballScoreLayerID, "layer", "My Basketball Score Keeper")

// switch this layer on
layerOn($myBasketballScoreLayerID)
Schermata 2024 06 11 alle 15.20.42

dormire(<Secondi> come numero)

Mette in pausa l'esecuzione dello script per un certo numero di secondi.

// pause the script execution for 12 seconds
sleep(12)

// pause the script execution for 35.6 seconds
sleep(35.6)

// pause the script execution for a time interval specified by a variable
setVariable($mySleepInterval, 17)
sleep($mySleepInterval)

sleepUntil(<Tempo come espressione di stringa>)

Mette in pausa fino a un determinato orario (HH:MM o HH:MM:SS).

// sleep until 5:15pm
sleepUntil("17:15:00")

// sleep until 9:12am
sleepUntil("9:12")

// sleep until a time specified by a variable
setVariable($myWakeUpTime, "9:41")
sleepUntil($myWakeUpTime)

sleepOnTheMinute()

Mette in pausa lo script fino al raggiungimento della prossima frazione di ora 'al minuto'.

// go on every 20 minutes: on the hour, 20 and 40 minutes past the hour:
sleepOnTheMinute(20)

// go on "on the hour"
sleepOnTheMinute(60)

// go on every 10 minutes past the hour (specified by a variable)
setVariable($myWakeUpMinute, 10)
sleepOnTheMinute($myWakeUpMinute)

setVariabile($variableName, <valore>)

Crea o modifica una variabile locale (inizia con $). Il valore può essere una stringa, un numero o un booleano.

setVariable($myText, "This is a text")
setVariable($myNumber, 15.73)
setVariable($myBoolValue, false)

setGlobal($variableName, <valore>)

Crea o modifica una variabile globale condivisa tra i livelli di automazione.

Tenga presente che le variabili globali sono accessibili ad altri livelli di automazione finché il livello di origine è attivo. Questa disposizione consente di cambiare le variabili globali attivando un livello diverso con definizioni di variabili globali distinte. La prassi migliore in questo scenario è impostare l'opzione 'Switch Layer Off' del livello di automazione su 'Manualmente' e definire le variabili globali nello script 'On Live'.

setGlobal($myGlobalText, "This is a text")
setGlobal($myGlobalNumber, 15.73)
setGlobal($myGlobalBoolValue, false)

concat($resultVariableName, )

Concatena le espressioni di stringa.

// define some variables
setVariable($myVariableA, "This is")
setVariable($myVariableB, "text.")

// concatenate those variables and store the result into a new one
concat($myResultVariable, $myVariableA + " a " + $myVariableB)

// The variable $myResultVariable contains "This is a text.".

replace(, , , )

Questo comando crea una nuova stringa sostituendo tutte le occorrenze di una stringa di ricerca all'interno di una stringa sorgente. Il risultato viene memorizzato nella variabile result specificata.

// define a source string
setVariable($source, "Hello mimoLive, hello automation!")

// replace “hello” (lowercase) with “Hi”
replace($result, $source, "hello", "Hi")

// $result = "Hello mimoLive, Hi automation!"

math(1TP11NomeVariabile Risultato, )

Questo comando esegue semplici calcoli matematici, tra cui addizione (+), sottrazione (-), moltiplicazione (*) e divisione (/). Tenga presente che i calcoli vengono eseguiti nell'ordine in cui appaiono e NON seguono la regola PEMDAS/BODMAS.

// define some variables
setVariable($myVariableA, 3)
setVariable($myVariableB, 5)

// perform the calculation
math($myResult, $myVariableA + 2 * $myVariableB)

// The result in $myResult is 25 (!) and not 13

list($resultVariableName, [, , ...])

Il comando list crea un elenco e lo inserisce nella variabile result. Può utilizzare la variabile list nel comando getListItem per iterare questo elenco.

// create a list and put it into a variable
list($myList, "A", "B", "C", "D")

appendToList($listVariableName, )

Questo comando aggiungerà un determinato valore ad un elenco esistente.

// create a list and put it into a variable
list($myList, "A", "B", "C", "D")

// append an item to the list
appendToList($myList, "E")

// The result is a list with 5 items "A", "B", "C", "D" and "E"

getListItem($resultVariableName, $listVariableName, )

Con questo comando può recuperare un determinato elemento da un elenco specificato dal comando list. Tenga presente che il numero dell'elemento inizia con 1, a differenza di molti altri linguaggi di programmazione in cui gli array iniziano spesso con l'indice 0.

// create a list and put it into a variable
list($myList, "A", "B", "C", "D")

// get a specific list item
getListItem($myCharacter, $myList, 2)

// The result "B" is stored in variable $myCharacter


// The following is a more complex example on how to iterate through the list with a loop command

// define a list of layer IDs that should be turned on
list($myLayerIDs, "4ECB8ACC-DEF5", "9852-60E2C81", "DFD87A4D-9FC9", "4324-9B7C", "7B1C13-2CD28")

setvariable($iteration,1)
loop(5)

  getListItem($myLayerID,$myLayerIDs,$iteration)
  setLayerOn($myLayerID)
  math($iteration,$iteration+1)

endloop()

getListCount($resultingListCountVariableName, $listVariableName)

Con questo comando può ottenere il conteggio degli elementi in una variabile elenco creata con list().

// create a list and put it into a variable
list($myList, "A", "B", "C", "D")

// get a specific list item
getListCount($myListCount, $myList)

// The result 4 is stored in variable $myListCount

if(, , ) [else] endif

Questa istruzione if confronta due espressioni numeriche utilizzando un comparatore specificato. Se il confronto è vero, vengono eseguiti i comandi successivi. Altrimenti, i comandi successivi vengono saltati fino a quando non viene raggiunto un else o un endif.

I comparatori validi sono:

“==”uguale
“!=”non uguale
">"maggiore di
"<"meno di
">="maggiore o uguale a
"<="inferiore o uguale a
// define a variable
setVariable($myVariable, 3)

// test if the variable is bigger than 10
if($myVariable, ">", 10)
   setVariable($text, "is bigger than 10")
else
   setVariable($text, "is less or equal 10")
endif

// The result in $text is "is less or equal 10"

ifString(, , ) [else] endif

Questa istruzione ifString confronta due espressioni di stringa utilizzando un comparatore specificato. Il confronto si basa sul codice dei caratteri ASCII di ciascuna lettera delle stringhe. Se il confronto è vero, vengono eseguiti i comandi successivi. Altrimenti, i comandi successivi vengono saltati fino a quando non viene raggiunto un else o endif.

Per i comparatori validi, veda il comando if.

// define a variable
setVariable($myVariable, "mimoLive")

// test if the variable is "mimoLive"
if($myVariable, "==", "mimoLive")
   setVariable($text, "yes")
else
   setVariable($text, "no")
endif

// The result in $text is "yes"

ifLayerIsOn(<API ID del livello come Espressione stringa>.) - ifLayerIsOff(<API ID del livello come Espressione stringa>.) [else] endif

Queste dichiarazioni if verificano se un determinato livello è attualmente attivo o meno. Se la condizione specificata è soddisfatta (il livello è acceso o spento), vengono elaborati i comandi successivi. Altrimenti, i comandi successivi vengono saltati fino a quando non viene raggiunto un else o endif.

setVariable($myLayerA, "D6A326CA-72E6-45E5-836D-9795F8F534F4")
setVariable($myLayerB, "8C58DEA7-CCBE-44CB-A60F-97C5BD456C68")

ifLayerIsOn($myLayerA)
   // the layer is live, switch it off
   layerOff($myLayerA)
else
   // the layer is currently off, switch it on
   layerOn($myLayerA)
endif

ifLayerIsOff($myLayerB)
   // the layer is currently off, switch it on
   layerOn($myLayerB)
endif

ifLayerSetIsActive(<API ID del livello come Espressione stringa>.) - ifLayerSetIsInactive(<API ID del livello come Espressione stringa>.) [else] endif

Queste dichiarazioni if verificano se un determinato Layer Set è attualmente attivo o meno. In caso affermativo, vengono elaborati i comandi successivi. Altrimenti, i comandi successivi vengono saltati fino a quando non viene raggiunto un else o endif.

setVariable($myLayerSetA, "CEF07AFA-B552-40F8-821C-CF424EB93500")
setVariable($myLayerSetB, "E4B15B8B-EE34-4CCE-BDE7-58120A65E83A")
setVariable($myLayer, "8C58DEA7-CCBE-44CB-A60F-97C5BD456C68")


ifLayerSetIsActive($myLayerSetA)
   // the layer set A is active, switch layer on
   layerOn($myLayer)
else
   // the layer set A is currently inactive, switch the layer off
   layerOff($myLayer)
endif

ifLayerSetIsInactive($myLayerSetB)
   // the layer set B is currently inactive, switch the layer off
   layerOn($myLayer)
endif

ifLayerData(, , , ) [else] endif

Questo comando complesso le permette di testare qualsiasi parametro di un livello che il programma HTTP API fornisce. Deve specificare un livello tramite il suo ID API, il percorso della chiave all'interno dei dati JSON restituiti dall'API HTTP, un comparatore (come una stringa tra virgolette, ad esempio, "=="), e un valore.

I valori validi del comparatore sono:

“==”uguale
“!=”non uguale
">"maggiore di
"<"meno di
">="maggiore o uguale a
"<="inferiore o uguale a
// Example: Testing if the audio volume is turned up on a layer

setVariable($myLayerA, "D6A326CA-72E6-45E5-836D-9795F8F534F4")
setVariable($myLayerB, "8C58DEA7-CCBE-44CB-A60F-97C5BD456C68")

ifLayerData($myLayerA,"data.attributes.volume",">",0.5)
   // The audio volume is bigger than 0.5 so turn layer B on
   layerOn($myLayerB)
else
   // The volume is lower than 0.5, lets turn layer B off
   layerOff($myLayerB)
endif

loop([]) [break] endloop

Il comando loop le permette di eseguire il codice più volte. Se non specifica il numero di iterazioni, il ciclo verrà eseguito all'infinito. Il comando break le permette di uscire dal ciclo in qualsiasi momento. endloop è necessario per contrassegnare la fine del blocco di comando che deve essere eseguito in loop.

setVariable($myLayerA, "D6A326CA-72E6-45E5-836D-9795F8F534F4")

// blink layer A 4 times
loop(4)
   layerOn(setVariable(myLayerA)
   sleep(1)
   layerOff(setVariable(myLayerA)
   sleep(1)
endloop

// wait for volume of layer A will be bigger than 0.5
loop()
   ifLayerData($myLayerA,"data.attributes.volume",">",0.5)
      // The audio volume is bigger than 0.5 exit the loop now
      break
   endif
   sleep(1)
endloop

httpRequest()

Il httpRichiesta() attiva l'URL indicato. Ciò offre una grande flessibilità nel modo in cui può utilizzare questo comando di script. In mimoLivePuò anche attivare azioni in altri documenti o script remoti. Per maggiori dettagli su mimoLiveComandi API HTTP, consulti la sezione HTTP API per esplorare tutte le possibili chiamate API.

// accendere un livello
httpRequest("http://127.0.0.1:8989/api/v1/documents/188462841/layers/BA868701-8131-49CB-8EDD-8C7E6E7CD60B/setLive")

httpRequestJSON($resultVariableName, )

Questo comando legge la risposta della chiamata HTTP come JSON e memorizza i dati nella variabile di risultato specificata. Successivamente, potrà accedere ai dati tramite il comando getJSONData().

getJSONData($resultVariableName, $jsonDataVariable, )

Questo comando recupera un valore di dati specifico da una struttura JSON memorizzata in una variabile. Deve specificare la variabile che contiene i dati JSON ($jsonDataVariabile), il percorso dei dati all'interno della struttura JSON () e la variabile in cui deve essere memorizzato il risultato (1TP18NomeVariabileRisultato). Ciò consente un'estrazione precisa dei dati per un'ulteriore elaborazione o per l'utilizzo nel suo script. Il percorso chiave può contenere riferimenti a elementi di un array, ad esempio "myarray.[12].myvalue" produrrà l'elemento valore di myvalue di un array chiamato myarray all'elemento 12. (il conteggio degli elementi inizia da 1). (il conteggio degli elementi inizia da 1).

// ottenere tutti i dati di un livello
httpRequestJSON($myLayerData, "http://127.0.0.1:8989/api/v1/documents/188462841/layers/BA868701-8131-49CB-8EDD-8C7E6E7CD60B")

// ottenere il valore del quadrante del volume
getJSONData($volumenDial, $myLayerData, "data.attributes.volume")

// Ora, la variabile $volumenDial conterrà un valore tra 0 e 1.

setJSONData(, , )

Scrive un valore in una variabile JSON nel percorso chiave fornito. Lo utilizzi per modificare il JSON che ha costruito o recuperato con httpRequestJSON. I percorsi delle chiavi sono separati da punti.

// set fields
setJSONData($json, "data.attributes.input-values.title", "My Headline")
setJSONData($json, "data.attributes.volume", 0.75)

JSONToString(, )

Serializza una variabile oggetto JSON in una stringa compatta (utile per la registrazione, l'invio o la memorizzazione).

// assume $json already contains data
JSONToString($jsonString, $json)
// $jsonString now holds the serialized JSON text

urlEncode(, )

URL-encodifica una stringa in modo che possa essere utilizzata in modo sicuro nei parametri di query o nei percorsi delle richieste http.

// build a query value and encode it
setVariable($q, "mimoLive tips & tricks")
urlEncode($qEncoded, $q)

// $qEncoded -> "mimoLive%20tips%20%26%20tricks"

urlDecode(, )

Decodifica l'URL di una stringa codificata in percentuale in testo leggibile.

// decode an encoded query value
setVariable($raw, "mimoLive%20tips%20%26%20tricks")
urlDecode($decoded, $raw)

// $decoded -> "mimoLive tips & tricks"

fermarsi

Arresta immediatamente lo script in esecuzione. Utile per l'uscita anticipata dopo il verificarsi di una condizione.

// wait for a condition, then stop the script
ifLayerData("D6A326CA-72E6-45E5-836D-9795F8F534F4", "data.attributes.volume", ">", 0.5)
  // do one action then stop
  layerOn("8C58DEA7-CCBE-44CB-A60F-97C5BD456C68")
  stop
else
  // keep waiting
  sleep(1)
endif

> (Punto di interruzione per il debugger)

Quando il debugger di script è abilitato e la modalità di debug è impostata su 'Continuamente', l'esecuzione dello script si fermerà in corrispondenza di questo marcatore e attenderà fino a quando l'operatore mimoLive farà clic sul pulsante 'Passo successivo'. Per ulteriori informazioni sulle possibilità di debug, consulti la sezione 'Best Practices - Debug degli script'.

// do something
layerOn("D6A326CA-72E6-45E5-836D-9795F8F534F4")

// breakpoint: script pauses here in debugger
>

// continue after stepping
sleep(1)
layerOff("D6A326CA-72E6-45E5-836D-9795F8F534F4")

Costante: $DOCUMENT_ID

Mantiene l'ID del documento API per il documento mimoLive corrente. Utile per la costruzione di endpoint senza hardcoding.

// build a layer endpoint using the document ID
setVariable($layerId, "BA868701-8131-49CB-8EDD-8C7E6E7CD60B")
concat($endpoint, "/api/v1/documents/" + $DOCUMENT_ID + "/layers/" + $layerId + "/setLive")

// switch the layer on using the constructed URL
httpRequest($endpoint)

Tipi di dati

API Punti finali

Il parametro deve essere un endpoint API per un livello, una variante di livello, un set di livelli, una sorgente o una destinazione di output. Può ottenere questi Endpoint API facendo clic con il pulsante destro del mouse sull'oggetto nel documento mimoLive. Dovrebbe apparire un menu contestuale con una voce di menu 'Copia Endpoint API negli Appunti'.

Questa azione copierà il punto finale API di questo oggetto negli appunti. Se lo incolla altrove, avrà un aspetto simile a questo:

/api/v1/documents/863743527/layers/D6A326CA-72E6-45E5-836D-9795F8F534F4

/api/v1/documents/863743527/layers/68F63C8F-2376-4CA3-9764-CC17CBFC5F8D/variants/3FF72CC3-AF80-4252-A879-F8AFD68DB922

/api/v1/documents/863743527/layer-sets/E6950B7A-7457-44C5-81F7-972D9B04DBC3

Per i comandi relativi ai livelli, può ridurre il API I punti finali alla parte importante solo rimuovendo il prefisso "/api/v1/documents//layers/" . Questo renderà il suo script più breve, come mostrato qui:

// switching on a layer:
layerOn("/api/v1/documents/863743527/layers/D6A326CA-72E6-45E5-836D-9795F8F534F4")
// OR
layerOn("D6A326CA-72E6-45E5-836D-9795F8F534F4")

// switching on a variant:
layerOn("/api/v1/documents/863743527/layers/68F63C8F-2376-4CA3-9764-CC17CBFC5F8D/variants/3FF72CC3-AF80-4252-A879-F8AFD68DB922")
// OR
layerOn("68F63C8F-2376-4CA3-9764-CC17CBFC5F8D/variants/3FF72CC3-AF80-4252-A879-F8AFD68DB922")

 

Le migliori pratiche

Endpoint API

Come ottenere gli endpoint API

  • Cliccando con il tasto destro del mouse sul livello e selezionando "Copia endpoint API".
  • utilizzando il comando getAPIEndpoint() (vedere la documentazione).

Indirizzare gli endpoint API

Può utilizzare l'endpoint API completo o rimuovere la parte "/api/v1/documents//" per assicurarsi che il suo script funzioni anche quando viene copiato in un altro documento. Tuttavia, l'ID del documento è importante se desidera indirizzare un punto API in un altro documento mimoLive.

Script di debug

C'è un debugger di script incorporato nel livello Automazione. Può passare il livello in modalità di debug impostando il parametro del livello 'Debug' su on.

TBD.

Idee di scripting

Pubblicare un annuncio ogni 10 minuti

In combinazione con un'opzione "PIP Il livello "Finestra" e una "sorgente Playlist multimediale" contenente più brevi filmati pubblicitari consentono di riprodurre una pubblicità ogni 10 minuti. Assicurarsi di deselezionare l'opzione "Non-Stop" nella sorgente Media Playlist. In questo modo ogni volta che la PIP Se la finestra è impostata su "live", riproduce un annuncio dalla sorgente Playlist e si spegne. Dopo 10 minuti verrà riprodotto l'annuncio successivo.

Eseguire un pungiglione prima di passare a un determinato livello.

È necessario preparare un breve video stinger che avrà una transizione interna fino a coprire tutto lo schermo (ad esempio, dopo 1 secondo). Dopo 1 secondo si passa in diretta al livello che si desidera rivelare. Posizionare questo livello sotto il livello che riproduce il video stinger. Ora che il video stinger copre lo schermo, la commutazione del livello sottostante non può essere vista. Il video stinger dovrebbe continuare a rivelare il livello sottostante. Assicurarsi che il video stinger sia renderizzato con il codec video ProRes4444, in modo da avere la trasparenza necessaria per la transizione.

Creare un'apertura di spettacolo complessa

Poiché è possibile attivare e disattivare i livelli uno dopo l'altro per un periodo di tempo più lungo, è possibile avere più livelli di testo o di annotazione, livelli di piazzamento che mostrano la grafica o persino terzi inferiori che riempiono lo schermo per creare il proprio spettacolo animato. Siate creativi!

Attivare un telecomando HTTP URL con un tocco sulla superficie del telecomando

Se è necessario attivare un HTTP Richiesta tramite un pulsante sul vostro Superficie di controllo remoto è possibile aggiungere un livello di automazione alla pila di livelli e impostare l'opzione "Switch Layer Off" di tale livello su "Automatically". Ora è possibile inserire un singolo comando httpRequest() nel campo di script "On Live". Sulla superficie di controllo remoto aggiungere il pulsante Live di questo livello al layout. Una volta premuto questo pulsante sulla superficie di controllo remoto, il HTTP sarà eseguita la richiesta.

Il vostro feedback

Come valuta la sua esperienza con questa funzione di mimoLive?

Manuale d'uso: Aggiornamenti recenti