>> DAN ARMENDARIZ: Ciao, e benvenuto un seminario CS50 sulla personalizzazione Cloud 9,
e l'IDE CS50.
Così oggi stiamo andando a solo parlare un po '
su alcune delle informazioni tecniche
va dietro l'architettura di Cloud 9, e in che modo
abbiamo implementato alcuni dei plug-in come parte di Cloud 9 per fornire CS50 IDE.
Così facciamo solo saltare a destra e cominciare a parlare di plug-in.
>> Così plug-in sono davvero al cuore dell'esperienza Cloud 9.
Cloud 9 è la tecnologia di base che fornisce a noi l'IDE,
e anche la finestra del terminale al fondo, insieme alla workspace--
Ubuntu workspace-- che abbiamo utilizzare per compilare tutti i nostri progetti
ed eseguire i nostri insiemi di problemi, completare i nostri insiemi di problemi.
Ma al centro di tutto di esso, tutta la tecnologia
è in realtà solo un mucchio di plug-in.
Tutto è un plug-in che possono essere modificate,
estesa, è possibile creare i propri plug-in,
è possibile rimuovere altri plug-in, di modificare davvero
un sacco di funzionalità dell'esistente Cloud 9 IDE.
>> Quindi questo è un esistente Cloud 9 ambiente.
Questo è in realtà solo la predefinito Cloud 9 ambiente.
E dare un'occhiata a come è realmente è diverso da quello IDE CS50.
Quindi questo è l'IDE CS50.
Si noti che ci sono alcuni visiva modifiche tra il regolare Cloud 9
ambiente e l'IDE CS50.
In particolare, ti notare un paio di modifiche.
Prima di tutto, c'è meno le voci di menu per cominciare.
C'è in realtà un modo che si può cambiare la situazione.
Si chiama Simple Mode.
>> Per impostazione predefinita, la modalità semplice è abilitato, e che semplifica alcune delle voci di menu.
Si rimuove alcune delle quelle più avanzate,
perché, francamente, un sacco di gli studenti che stanno arrivando
e non hanno bisogno di conoscere alcuni delle caratteristiche più avanzate
Non sono sopraffatti con una serie di opzioni.
Ma noi fornire la capacità di prendere fuori quei cosiddetti rotelle
e rimuovere tale impalcature modo che le persone
può diventare più abituati a le funzionalità avanzate di IDE.
Subito a a destra di questo, non c'è
anche un pulsante di debug, che nello standard Copertura
9 ambiente si chiama semplicemente correre.
Ma per impostazione predefinita, abbiamo configurato il pulsante di debug nel CS50 IDE
per far apparire il debugger, compila automaticamente il codice sorgente,
collegare il debugger al GDB-- sottostante
e dal momento che è in esecuzione per eseguire il debugging-- e alcune altre misure
anche.
Anche la finestra del terminale al very-- o meglio il terminale
linguetta sezione alla console finestra nella parte inferiore dello schermo,
è stato rinominato per essere semplicemente terminale.
Considerando che la norma Cloud 9 ambiente,
in realtà mostra il in esecuzione l'applicazione.
In questo modo, si semplifica, di nuovo, l'interfaccia grafica, solo un po '.
>> Abbiamo anche aggiunto alcuni pulsanti in alto a destra dell'IDE
per visualizzare alcune informazioni di base sull'istanza sottostante.
E anche noi abbiamo rimosso uno delle opzioni sulle voci
dall'estrema destra.
Quindi, tutto questo è non implementato modificando necessariamente il Cloud 9
il codice sorgente, ma invece attraverso un paio
di plug-in che abbiamo implementato durante tutto l'anno scorso o giù di lì.
E Cloud 9 ha ospitato e ha in esecuzione nell'area di lavoro CS50.
O meglio nelle aree di lavoro sono designate come CS50 IDE.
>> Quindi, in realtà questa è la differenza principale tra il Cloud 9 e il CS50
spazi di lavoro.
C'è anche, nel sottostante esempio, il cambiamento principale è
che installiamo qualche oggetti preconfigurati come GDB,
e alcune altre cose di base che abbiamo creato, come aggiornamento 50,
e un paio di altri passi che fanno l'intera esperienza un po 'di più
unificato.
Ma nel complesso, questo è solo un modifica di un sistema esistente
che Cloud 9 ha creato per noi.
Quello che stiamo andando a mostrare un po 'più tardi
è come creare effettivamente un plug-in che po 'di base
ci permette di inserire qualcosa nel sistema di menu, e aprire un dialogo.
E se abbiamo abbastanza tempo, faremo in realtà
vedere come possiamo popolare che dialogo con alcune informazioni
dall'istanza sottostante.
In modo per noi per arrivare a quel punto, facciamo prima parliamo un po '
sull'architettura di Cloud 9.
>> Quindi il modo che siamo abituati di interagire con Cloud 9
è interamente attraverso il client.
Apriamo un browser web, digitiamo nella CS50.io.
Abbiamo finalmente, dopo l'autenticazione, sono presentati con l'IDE.
Ma si rendono conto che non c'è un paio di passi
che in realtà noi arrivare a questo punto.
La prima cosa è che il mio cliente, il browser web,
su richiesta e dopo l'autenticazione, carica l'interfaccia grafica e il plug-in
da qualche CDN, da parte di alcuni Content Delivery Network.
Questo può essere francamente ovunque.
>> E questo è in realtà separata dall'istanza sottostante.
E 'importante rendersi conto che questo è in realtà solo un mucchio di file statici.
E 'un po' di JavaScript che viene scaricato dalla CDN
al mio web browser, e tutto il GUI che
vedi qui-- questo è davvero key-- tutta la GUI che vedete qui
viene eseguito sul lato client.
Tutto ciò che si vede nel Cloud 9 di lavoro
è in realtà eseguito nel browser.
E tutto ciò che si invia lungo all'istanza sottostante
si comunica con l'istanza lungo questo secondo canale separato,
e viene poi salvato su tale istanza finestra mobile.
>> Quindi la ragione che sto dicendo questo è un'istanza finestra mobile
è che la tecnologia sottostante non utilizza le macchine virtuali,
ma invece utilizza un tecnologia chiamata finestra mobile,
che sostanzialmente allows-- più vicino analogia è una macchina virtuale.
Ma è sottilmente diverso in quanto ci sono
un sacco di opportunità per eseguire una combinazione di diversi finestra mobile
istanze su una singola macchina.
E possono essere filata up in molto rapida successione.
Non è molto più differenziazione rigorosa
tra le diverse istanze docker come ci sono in macchine virtuali,
ma ancora ci sono un sacco di differenziazione e separazione
tra queste diverse istanze.
OK.
Così i due passaggi qui che sono importanti per realizzare
è che quando andiamo a CS50.io, siamo il download del GUI e dei plug-in,
che sono scritte in JavaScript, il al browser o al browser.
E questa è forse una coppia megabyte vale la pena di informazioni.
A quel punto, una volta che il GUI ha caricati e il plug-in è già incominciata
poi inizia a comunicare con l'istanza di finestra mobile, che non lo fa
necessariamente essere lo stesso server.
>> Ora c'è un'eccezione a questa.
In realtà possiamo avere sia la meccanismo di attuazione per la GUI sé
e l'istanza di finestra mobile tutti dello stesso server, che
è in realtà qualcosa che facciamo per la versione offline di Cloud 9.
Questo non è qualcosa che abbiamo pubblicizzato molto questo autunno,
ma noi abbiamo anche un versione offline che
permette di scaricare un confezionato versione di tutte queste cose
e consentono di eseguire Nube 9 in un ambiente in linea.
>> Spostando questo fuori dalla nuvola e sulla vostra macchina locale ha un certo impatto.
In particolare, non si è hanno più la capacità
per condividere il vostro spazio di lavoro con gli altri.
Non è più possibile aprire Cloud 9 da, e il CS50 IDE, da qualsiasi computer
e vedere gli stessi file che si stava lavorando prima.
Ma invece funziona tutto sulla propria macchina locale
senza bisogno di accesso a Internet.
Ma ancora, anche in quel modello, anche se abbiamo una macchina virtuale
che è essenzialmente l'esecuzione di queste cose.
>> Abbiamo un server separato che è offrendo essenzialmente il Cloud 9
contenuti, e poi noi avere un'istanza finestra mobile
che è responsabile per la comunicazione con che IDE per il back-end.
OK.
Così l'intera interfaccia grafica è scritto interamente in JavaScript
utilizzando Node.js e il Cloud 9 SDK, che ci arriveremo in appena un minuto.
E tutti i plug-in vengono eseguiti sul lato client.
Quindi concentriamoci quindi una poco assumendo
che questo primo passo ha in realtà completato con successo,
e guardare solo a questa istanza finestra mobile.
>> Quindi, in questo caso, questo è il modo standard
di pensare di fare Cloud 9 plug-in sviluppo è che si sta andando
da scrivere codice che verrà essere eseguito nel browser dell'utente,
e avete la possibilità di utilizzando alcune API per comunicare
con l'istanza finestra mobile sottostante, eseguire del codice là, e fare qualsiasi cosa
che si potrebbe desiderare di fare.
Quindi questo sarà il contesto che faremo
prevede di utilizzare per il resto di questo discorso.
E solo a mantenere questo modello in mente.
Questo sarà molto importante in pochi minuti.
Ci sono un paio di collegamenti voglio mostrarvi.
Prima di tutto, Cloud 9 ha fornito un bel po 'di documentazione
che è abbastanza buono, che mostra come a fare lo sviluppo di plug-in di base.
Quindi, se si va a questo URL, cloud9-sdk.readme.io,
vedrete la documentazione lì.
E un sacco di queste informazioni che state per vedere
si possono trovare anche lì, e molto di più.
È anche possibile trovare il open source versione di Cloud 9 di questo URL,
github.com/c9/core, che usiamo come parte della versione offline dell'IDE,
in modo che si sarà in grado di avere la stessa esperienza Cloud 9,
ma in modo offline.
Tutto ok.
Quindi, diamo un'occhiata a un attuale Cloud 9 di lavoro qui.
E ancora, voglio segnalare un paio di cose.
Si tratta, qui, di un normale IDE CS50.
E ho disattivato un meno Modalità confortevole sotto il menu Visualizza
in modo che io possa vedere tutto delle opzioni del menu.
Quello che voglio mostrarvi destra ora è un paio di cose.
Prima di tutto, se vado in Preferenze e poi
cliccare su Plug-in Manager, e digitare CS50 qui,
possiamo vedere che ci sono, infatti, un paio di CS50 plug-in che
sono stati installati e la nostra corsa per attivare le modifiche che abbiamo
visto per l'IDE CS50.
>> In questo momento ci sono essenzialmente due plug-in che sono in esecuzione.
C'è uno chiamato Simple, che è la modalità semplificata che
consente di ridurre il numero di opzioni di menu lungo la parte superiore,
e hanno questo cosiddetto modalità meno confortevole.
E poi c'è anche CS50 Stats, che è forse solo leggermente misnamed.
Perché questo è ciò che vi mostra le informazioni
sull'area di lavoro sottostante.
Inserisce questi pulsanti lungo la destra.
Si inietta anche una voce di menu nel elemento della finestra, nel menu Finestra
proprio qui, CS50 Informazioni IDE.
Ed è responsabile per istanziare questo dialogo che abbiamo visto qui,
con tutte le informazioni che siamo abituato a vedere in un IDE CS50
area di lavoro.
OK.
Quindi c'è in realtà un altro plug-in che abbiamo sviluppato pure.
E ci sono un paio di altri che anche noi non abbiamo rilasciato pubblicamente.
Ma uno di questi è complessiva plug-in che permette GDB di funzionare.
Così uno degli aspetti di Cloud 9 è che essi hanno fornito già
questa GUI per implementare un debugger.
E uno dei plug-in che abbiamo creato praticamente
ganci GDB con questa interfaccia grafica versione basata su di un debugger.
Ed è responsabile di mediare tutto delle richieste che un utente può avere,
tra scavalcando o la creazione di punti di interruzione o niente
in questo senso, a tradurre che ai comandi che GDB può capire,
l'emissione di quei comandi per GDB.
E non appena GDB fornisce una risposta, allora
interpretiamo questo e aggiornare la GUI come necessario.
>> Questo è probabilmente uno dei la più complicata
dei plug-in, così invece ciò che siamo andando a concentrarsi su oggi è di fatto
Stats plug-in, e ne parliamo un po 'di semplice, pure.
Così ho detto prima, e ci tengo per fare molto, molto chiaro, che ancora una volta,
tutto ciò che siamo vedendo qui è essenzialmente
operando sul lato client.
Facciamo vedere una finestra di terminale sotto, e che, naturalmente,
se si digita nei comandi in che, che verrà quindi emesso
all'istanza sottostante.
Allo stesso modo, se apriamo un nuovo file e digitare alcune cose in esso e salvarlo,
il file verrà salvato su l'istanza sottostante.
>> Ma l'editor stesso, questo finestra del terminale stesso,
è tutto implementato in JavaScript ed è tutto un plug-in
che siamo in grado di interagire con, e quindi modificare.
C'è un sacco di estensibilità qui.
Vi consiglio di dare un'occhiata a Cloud 9 di conto GitHub
per vedere la grande quantità di i plug-in che sono disponibili,
e quanto ben scritto un sacco del codice è per l'estensibilità.
Quindi c'è qualcosa che voglio citare
su questo pure, che è che ci sono un sacco di-- c'è
un sacco di funzionalità che è disponibile nelle preferenze
finestra, che abbiamo visto solo alluso solo pochi minuti fa.
>> Una delle cose che possiamo fare come IDE gli sviluppatori, o come Cloud 9 sviluppatori,
è di iniettare realtà alcune Pannelli delle preferenze della nostra.
Quindi il modo semplice, o la modalità meno confortevole,
e anche le informazioni IDE, o le statistiche plug-in,
ha ogni qualche preferenza pannelli che ci permettono di modificare
il comportamento di ciascuno di questi.
Noterete che se vado al Preferenze e andare alle impostazioni utente,
c'è una scheda CS50, uno che dice informazioni IDE.
E posso cambiare il informazioni frequenza di aggiornamento.
>> In effetti, quello che sta succedendo nelle statistiche plug-in
è che ogni n secondi, dove n-secondi è definita da questa preferenza
pannello informazioni è essere recuperato dall'istanza sottostante, di essere inviato
indietro al lato client, il plug-in è quindi
interpretare le informazioni dall'istanza sottostante
e aggiornare la GUI come necessario.
Possiamo vedere che in questo momento è impostata a 30 secondi, e questo è il default.
Ma posso sicuramente cambiare quanto velocemente questo accade solo
modificando questo valore.
>> Ora, una delle cose interessanti è che questo pannello delle preferenze, GUI,
è in realtà solo una versione GUI di un sacco di impostazioni sottostanti
che sono presentati in JSON.
Quindi, se io vado, per esempio, sotto il Menu CS50 IDE, o il menu Cloud 9,
a seconda di quale versione che si sta guardando,
e andare in uno di questi settings-- in questo caso,
il progetto settings-- la impostazioni di progetto in questo caso
si applica a tutte le impostazioni per questo uno spazio di lavoro.
Considerando che si applicano le impostazioni utente a tutte le aree di lavoro
che si potrebbe avere nel tuo account.
>> Quindi, solo come una digressione qui, per essere extra chiaro,
c'è una separazione tra la due, perché anche se per difetto noi
avere uno spazio di lavoro, che è il CS50 IDE, se
dovevano fare clic sul tuo piccolo avatar qui e andare al cruscotto,
troverete che si può effettivamente creare spazi di lavoro aggiuntivi.
Potete vedere qui che Io ho un IDE 50 di lavoro, e anche
ai fini della presente seminari, uno spazio di lavoro
chiamato spazio di lavoro, che è proprio qui.
Comunque, non ho preferenze diverse.
Ognuno di questi può avere preferenze del progetto separati,
ma le preferenze dell'utente sono condiviso tra tutti i miei spazi di lavoro.
Tra l'altro, questo è anche molto utile se si
vuole creare uno spazio di lavoro con diverse opzioni di personalizzazione.
Ed è molto utile per creare una nuova area di lavoro.
E scegliere quello che potrebbe essere pre-configurato in qualche altro modo,
forse per PHP in particolare, o Django specifico.
O anche solo su ordinazione.
L'area di lavoro CS50 template è quella che abbiamo
uso che installa automaticamente Aggiornamento 50 e tutte le impostazioni
che abbiamo, compresa tutta la plug-in che abbiamo per l'IDE CS50.
OK.
Ma torniamo a questo.
Quindi, di nuovo, ci sono progetti impostazioni, e questi sono quelli
che stiamo guardando qui.
E notare che ci sono un gruppo di impostazioni,
molti dei quali corrisponde alla preferenza pannelli, ma non tutti di loro.
Ma possiamo vedere che qui, in questo-- oh no, ho messo nelle impostazioni utente?
Forse ho messo nelle impostazioni utente.
E questo, qui andiamo.
Nelle impostazioni utente, possiamo vedere che abbiamo una sezione CS50,
e questo è stato scritto a da questi Cloud 9 plug-in
che abbiamo implementato.
C'è il semplice per corrispondere con quella semplice plug-in,
e le statistiche che uno corrisponde a quello GUI basata
versione del pannello di preferenza.
La frequenza di aggiornamento, in questa caso, è impostato a 20 secondi.
>> Questo è tutto, si spera, il inizio di alcune informazioni
che saremo in realtà vediamo in un po ' po 'più in dettaglio, momentaneamente.
OK.
Quindi diciamo che vogliamo effettivamente arrivare al dunque.
Sappiamo che tutte le cose quello che sta succedendo sul lato client
è fatto in realtà sul browser, che significa che tutti i plug-in che scrivo
stanno per essere scritti con il browser in mente.
E se io in realtà voglio fare nulla sul lavoro,
Io forse dovuto avviare una sorta di comunicazione
tra il browser e l'area di lavoro per essere sicuri
che ciò che è realmente compiuto.
Ma diciamo che ora Voglio arrivare al dunque
ed effettivamente creare il mio primo plug-in.
Beh, il modo in cui si sarebbe in grado per farlo è in realtà abbastanza semplice.
E 'dato in Cloud 9 SDK.
Ma è di prendere la Nome lavoro esistente, che
è l'URL che si ha nella parte superiore la barra, e aggiungere il seguente ad esso.
?
Sdk = 1 & Debub = 2.
Ora, ciò che questo sta per attivare è che l'sdk = 1 sarà effettivamente impostare l'SDK
modalità di vero, che consentirà un paio di cose aggiuntive.
E debug = 2 consentirà messaggi di errore per essere un po 'più dettagliato.
>> E così, se si mettono il JavaScript console nella scheda sviluppatore di Chrome,
si sarà effettivamente in grado di vedere molto di più informazioni
di quanto sarebbe altrimenti.
Quindi vi consiglio di girare entrambi questi sopra allo stesso tempo, perché in realtà
È utile avere tutto questo Informazioni aggiuntive.
E 'importante notare, tuttavia, che accendere debug per il valore di 2
significa che è molto verbose, e in realtà
sarà un po 'notevolmente rallentare il vostro IDE, soprattutto durante il caricamento
o quando fare fare i compiti pesanti.
Quindi, solo tenere a mente.
E 'utile per lo sviluppo, ma si Non può decidere di avere tutto il tempo.
>> Quindi cerchiamo di realmente farlo.
Ma in questo caso, io in realtà sono già istituito uno spazio di lavoro con questo.
Vediamo quindi, sdk = 1 & debug = 2.
Con un paio di plug-in si spera già installato.
Tutto ok.
Quindi, ora che ho acceso il SDK di debug modalità, si accorge che siamo in modalità di debug,
in modo che possiamo guardare gli strumenti dev per vedere eventuali errori, che mi faranno fuori campo.
Possiamo vedere che non c'è un mucchio di errori qui.
Ora è in realtà abbastanza comune per i Cloud 9 per avere un paio di errori,
e io non mi preoccuperei su di loro fino a quando non
vedere qualcosa che potrebbe essere specifico per il plug-in
che vi capita di essere la creazione.
>> Ecco, per esempio, si ottiene un paio di 404s-- non trovato.
Vediamo siamo in grado di caricare un po ' informazioni fuori l'istanza sottostante
si.
E c'è un sacco di supplementari informazioni, ma la maggior parte di questo siamo
in realtà intenzione di ignorare per ora.
Perché questo è abbastanza comune per uno spazio di lavoro
di avere solo un paio di errori.
OK.
Io vado a spostare questo fuori la strada e tornare qui.
E ora la via più facile, il bello cosa di avere questo sviluppatore
modalità attivata è che mi permette di creare facilmente un nuovo plug-in.
>> Così mentre prima io in realtà non ha fatto avere questa nuova opzione plug-in disponibili,
che possiamo vedere se dovessi tornare a il mio modo non sviluppatore qui,
non c'è nuovo plug-in.
Attivando la modalità SDK, io hanno un nuovo plug-in disponibile
e posso creare facilmente uno.
In questo caso, c'è una coppia delle diverse opzioni, semplici,
un plug-in vuoto, un plug-in pieno, installer, Cloud 9 bundle.
Diciamo solo scegliere un vuoto plug-in per ora
in modo che possiamo vedere molto semplice versione di uno.
>> Ora notare che lungo la lato sinistro che è vi è ora
qualcosa sotto Preferiti, che viene messa in vendita di un paio di plug-in
che sono ora disponibili per me.
Se espando che, ci sarà essere in grado di vedere quelli.
Ora voglio farvi notare qualcosa qui, che
è che questo non è in realtà contenuta all'interno della directory di lavoro
sul mio sottostante esempio di Ubuntu, ma è contenuto sul disco rigido.
E dove questo si trova, perché questo è molto utile sapere,
soprattutto se avete intenzione di essere fare qualsiasi cosa con Git,
dove questo si trova è in una cartella .c9, / plugins.
Quindi, se ci vado, possiamo vedere che ora l'elenco dei plug-in che sono qui
corrisponde l'elenco dei plug-in che io mentre sul lato sinistro del mio lavoro.
>> Ora per impostazione predefinita, e questo è una specie di strano,
Per impostazione predefinita, quando creo un nuovo plug-in in uno spazio di lavoro,
crea questo plug-in che di default ha un nome di una sottolineatura.
In generale, che potrebbe causare alcuni problemi.
Quindi il passo successivo che io di solito eseguo
è solo per rimuovere la particolare plug-in
e lasciare solo il semplice plug-in che c'era inizialmente, plugin.simple.
E questo è l'unico che c'è.
OK.
>> Che cosa significa questo in realtà assomiglia?
Ebbene, questo è, ancora una volta, un pacchetto di JavaScript
che include alcuni file, tra cui un file plugin.js, dove
il contenuto principale di il mio plug-in si trova,
un file package.json, che in realtà specifica
alcuni metadati su questo plug-in, come ad esempio chi è l'autore,
tutte le ulteriori informazioni su di esso, un descrizione del plug-in, e così via.
E anche per impostazione predefinita, crea un file README vuoto,
e un file di test vuoto per voi creare qualche documentazione aggiuntiva,
e una cintura di prova se ti piacerebbe farlo.
>> Così facciamo solo dare un'occhiata prima a, molto rapidamente, il file package.json.
E 'abbastanza facile andare solo attraverso e riempire le aree di questo
che si vorrebbe inserire, come fornire un nome, dare una descrizione,
iterare il numero di versione ogni tanto, fornire
un autore per ogni persona che contribuisce,
aggiungerli ai contribuenti sezione, e il resto di questo si
può praticamente solo lasciare come lo è per ora.
>> C'è una cosa che è importante notare,
che sotto la sezione plug-in, vi è una chiave denominata plug-in.
E questo è abbinato al nome il file JavaScript denominato plugin.js.
Quindi questo è il modo in Cloud 9 sa, quando si legge il file package.json, che
dei js file da caricare in realtà.
Se creo altri file js o vogliono rinominare il file js da plug-in,
Ho anche cambiarlo nel file package.json.
>> Tutte le domande da parte del pubblico?
No.
Che una persona che è in seguito insieme a me finora.
>> OK.
Così ho effettivamente creato un paio di plug-in già,
Credo che, in questa area di lavoro.
Quindi cerchiamo di sbarazzarsi di alcuni di essi, aggiungere sdk = 1 & debug = 2, ricaricare questa area di lavoro,
e vediamo se siamo avere quei plug-in ora.
C9 / plugins.
Eccoci qui.
Ora possiamo vedere nei miei C9 / plugins di questo uno, abbiamo plugin.1 e plugin.2.
Quindi stiamo andando a solo intensificare the-- basta aumentare la quantità di difficoltà
in ciascuno di questi plug-in.
Ma qui se creo un nuovo plug-in, Posso aggiungere ai miei preferiti.
E mi limiterò a eliminare quelli da il file system sottostante.
>> Rimuoviamo che.
Ora, se apro il mio primo plug-in, e plugin.js aperti,
possiamo vedere qui il sottostante semplice versione di un plug-in.
Lasciatemi in realtà tornare a questo altro lavoro
perché si può almeno, qui vedi, cosa un plug-in in bianco si presenta come.
Quindi, sotto il cofano, questo sembra molto simile alla tecnologia chiamata,
Penso, che sia RequireJS.
Si noti che ciò non davvero guardare, forse,
la stessa come qualche altro JavaScript file che avremmo visto.
Invece, ci sono un paio di soli linee di base che in realtà ha.
>> Tutto questo materiale è il primo interpretato dalla IDE,
ma in realtà non è aperta fino al specificato.
E ti dirò di quando che significa in realtà in un attimo.
Ma notare che qui ci sia una Linea main.consumes in linea 2,
e questo elenca tutti i plug-in che questo plug-in è dipendente.
Così per difetto, noi forse fare di non avere eventuali dipendenze da altri plug-in,
ma quando abbiamo effettivamente bisogno di dipendere da caratteristiche in dotazione
da altri plug-in IDE, abbiamo bisogno di elencare i plug-in
nella linea main.consumes.
E poi abbiamo bisogno di collegarli al codice
qui sotto, che vi faccio vedere in un solo un attimo su come possiamo farlo.
>> Main.provides dà un nome di questo plug-in
che gli altri plug-in potrebbe utilizzare nella loro linea consumi.
Quindi, in questo caso, il plug-in è sufficiente impostare lì per impostazione predefinita,
e dovremmo cambiare che, per essere applicabile al nostro plug-in,
come vedremo in un solo momento.
Ora qui in funzione principale, questa funzione principale
è effettivamente eseguito e interpretato, ma in realtà non fa molto.
E 'appena viene impostato tutto, ma esso non inizia il plug-in,
nonostante quello che il nome suona come.
Che in realtà avviene attraverso una sequenza di metodi che
sono contenuti in questo plug-in.
>> Quindi, se ho scorrere verso il basso, si può vedere che abbiamo un ciclo di vita in cui
su qualche evento chiamato carico, o qualche evento chiamato scarico,
alcuni eventi realmente accadere.
E 'davvero in qui dove, come il plug-in inizia che questi metodi sono chiamati.
Quindi cerchiamo di essere un po 'più concreto su questo e guardare un esempio.
Quindi, ecco per plugin.1, cosa ci accingiamo a fare praticamente
è quello di creare una voce di menu chiamato CS50 Seminario Dialog 1--
perché abbiamo due them-- e stiamo andando
per iniettarlo nel menu Finestra.
E quando si clicca su di esso, siamo andando ad aprire un dialogo che
ci mostra alcune informazioni di base.
>> In questo caso, solo un mondo ciao.
Quindi questo è un molto semplice ciao dialogo mondo
che possiamo implementare come plug-in in Cloud 9.
Quindi cerchiamo di vedere come questo in realtà sembra.
Ti passo attraverso di essa, semplicemente in tempi relativamente brevi in ​​modo da
può guardare al prossimo plug-in come bene.
Si noti che qui siamo consumare una varietà di plug-in.
Stiamo consumando un dialogo plug-in, comandi, menu e interfaccia utente.
Sembra che in realtà sto consumando dialogo due volte, quindi posso rimuovere quel.
>> E notare che il modo che li sto collegamento,
questo è una sorta di metadati che sta dicendo il sistema plug-in quali requisiti
sono in realtà necessari per questo plug-in per caricare.
E 'anche importante notare che l'ordine in cui i plug-in vengono caricati
non è garantita.
Ma ciò che è garantito è che se io specificare alcuni plug-in come requisito,
che il plug-in sarà caricato prima del caricamento questa.
>> Quindi questo significa che, se il plug-in richiede su qualche funzionalità fornita
da qualcos'altro nell'IDE, si dovrebbe essere sicuri che i vostri consuma di plug-in
che inserita, in modo che le dipendenze sono certi di creare plug-in,
o un'istanza il plug-in, solo dopo che esista quadro esistente.
Così qui ho citato il metadati al gestore plug-in,
quali ho intenzione di consumare.
E nella funzione principale qui, Ho intenzione di collegare
il mio codice di tali plug-in di importazione.
>> Così sto solo andando a creare alcune variabili che
corrispondono ai nomi di ciascuno di questi così che posso riferimento molto rapidamente
tutto il mio codice.
La ragione per cui sto importando dialogo è perché voglio il mio plug-in
agire come un plug-in dialogo.
E il modo in cui sono in grado per farlo è, naturalmente,
collegare il codice al dialogo plug-in per l'importazione
e quindi specificando by creare una nuova variabile dialogo
e collegandolo quello importato plug-in.
E poi definendo mia plug-in in un nuovo dialogo.
>> Così nell'inizializzazione, I voler definire il mio plug-in.
E questa variabile chiamata plug-in si vedrà
è appena usato comunemente tutta Cloud 9 plug-in.
Io vado a un'istanza di un nuovo il dialogo con alcuni attributi,
dare un nome specifico, dire che è possibile per gli utenti di chiuderlo.
Che faccio vedere un po 'x in nell'angolo in alto a destra,
o un piccolo pulsante nella in basso a destra.
O se non riesco a selezionare il testo da esso, ciò che il titolo di questo dialogo
sarebbe, e così via.
Ora, questo definisce solo il dialogo, ma ancora non vederlo.
Mi hanno fatto di definire un azione per essere mostrato.
>> E ancora, vi incoraggio a date un'occhiata al Cloud 9 SDK,
perché ci sono una varietà dialoghi e sono molto ben documentati.
Potete vedere i diversi tipi di che ci sono, e li usano
in qualunque plug-in che avete in mente.
Ora ci sara 'un parte del carico, e questo carico
funzione di come si ricorderà è utilizzato dal ciclo di vita plug-in
per istanziare realtà tutto e ottenere tutto pronto per andare.
Ora, quando questo carichi di plug-in, io no vuole per mostrare immediatamente un dialogo,
perché questo plug-in verrà caricato insieme al resto del IDE.
E quando carico che IDE, non voglio il dialogo di mostrare automaticamente.
Voglio soltanto per mostrare quando clicco su l'opzione di menu nella mia voce di menu Finestra
che mi aggiungere ad essa momentaneamente.
>> Quindi ci sono due fasi distinte qui che deve accadere.
Devo creare un comando e il comando
avrà il compito di realtà mostra il dialogo sulla Cloud 9 IDE.
E poi devo collegare, io necessario creare una nuova menu della finestra
voce, che esegue quel comando.
In modo che quando clicco su quella finestra voce di menu, il comando è quindi corsa
e quindi viene quindi visualizzato il mio dialogo.
E così questo è in realtà una bella bel modo di pensarci.
>> Perché prima che posso creare un comando il cui nome è CS50 Seminario Dialog 1,
che fornisce un po ' contesto generale per esso.
E il bit importante qui è notare l'attributo EXEC, che
elenca una funzione che verrà chiamata nel mio plug-in quando viene eseguito questo comando.
Quindi questo comando è un po 'come a-- è solo un arbitrario Cloud 9
comando che è disponibile a qualsiasi Cloud 9 plug-in.
Ma la funzione reale che è chiamerà quando viene eseguito questo comando
è la funzione spettacolo dialogo nel mio file plugin.js.
>> E possiamo realmente vedere questi plug-in e la lista
di comandi che sono a nostra disposizione in Preferenze, scorrere fino down--
vediamo, in realtà vediamo adesso?
Plug-in Manager, no, penso che sia I-- sicuramente qui da qualche parte.
Beh, c'è un elenco di comandi da qualche parte, ma devo avere,
Ho dimenticato dove si trova.
Così male, ci sposteremo.
Tutto ok.
Quindi abbiamo un elenco di comandi che sono a nostra disposizione,
e questi comandi sono questi solo arbitraria Cloud 9
i comandi che eseguono codice specifico.
Quindi, solo tenere a mente, che stiamo andando a correre la finestra di spettacolo
funzionare momentaneamente.
Ora, quando ho voglia di aggiungere un menu voce, posso aggiungere l'elemento in base al percorso,
e basta specificare esattamente dove voglio che sia, Finestra / CS50 Seminario Dialog 1.
E a quel punto, voglio per creare un nuovo elemento
sta per eseguire un comando, CS50 Seminario Dialog 1.
Si noti ancora che, questa è la Copertura 9 comando Ho creato appena sopra.
>> Ora voglio anche a creare un piccolo divisorio,
e così posso fare lo stesso nella riga successiva.
Ora si potrebbe notare che come parte di definire questa voce di menu,
c'è un numero di ad esso associati che
in realtà dice esattamente dove Voglio che voce di menu è
situata nella lista dei menu.
Ma si potrebbe notare che io in realtà non
vedere tutti i numeri con questi menu, per impostazione predefinita.
Quindi c'è una piccola cosa nascosta che possiamo fare, un piccolo cambiamento per il nostro URL.
Quindi, oltre a SDK = 1 & debug = 2, Mi misi menu per 1--
e speriamo che sia il menu, non i menu.
Oh, è menu = 1.
Resisti.
>> E quello che vedremo su ricarico che IDE è che io sono ancora in modalità di debug,
ma ora ci sono i numeri associato a tutti i menu.
E questo vi dice esattamente quello che il numero
è quando si sta cercando di iniettare qualcosa ovunque in questo sistema di menu.
Così nel menu Finestra, posso vedere l'elemento 45 è collaborare,
e articolo 38 prima che sia installatore.
Così, quando ho voglia di iniettare un elemento tra quei due,
Vorrei solo selezionare un numero tra questi due elementi.
Così ho scelto 41 e inserito il mio Seminario Voce 1 menu della finestra in quella posizione.
>> Ed è per questo che questo numero che appare qui è il numero 41.
Questa è la posizione di tale voce di menu nel menu di Cloud 9.
Ora allo stesso modo, ho voluto per creare un divisore
e aggiungere in modo che ci sia un bel divisione tra ciascuno di questi menù
elementi.
Così ho aggiunto che in posizione 43.
Fin qui, tutto bene, spero?
Quindi, ora diamo un'occhiata a realtà il codice specifico di dialogo spettacolo
che in realtà è responsabile per l'apertura di questa finestra di dialogo.
>> Scorrendo, vedo che voglio di avere questa funzione di finestra spettacolo,
ed è estremamente semplice.
Ho intenzione di eseguire lo spettacolo metodo sulla variabile plug-in.
E ricordate che abbiamo definito questo plug-in variabili di cui sopra come un dialogo.
Così bar plug-in, in questo caso, è questo oggetto che abbiamo definito internamente.
E sarà un nuovo dialogo contenute in questo plug-in.
E così abbiamo referenziato questo plug-in variabile in molti luoghi
in una tipica Cloud 9 sviluppo dell'ambiente.
>> Staremo a vedere qui.
Si noti che come noi scorriamo, c'è cicli di vita aggiuntivi.
Così notare che questi rispondono agli eventi che vengono sparati
da questo oggetto, l'oggetto del dialogo.
Per impostazione predefinita, non c'è caricare e scaricare, che
sono a disposizione di tutti i Cloud 9 plug-in.
Ma in caso di questo dialogo, non c'è
un altro evento che possa fuoco così chiamato
Draw, che viene generato quando che sta per essere disegnato sullo schermo,
in primo grado del dialogo che mostra.
>> Così, quando in realtà sta per essere mostrato,
ci sta andando fornire a noi un po 'di HTML.
E usando solo normale Pratiche HTML POSSIAMO
iniettare alcune informazioni molto semplici, il nostro mondo ciao, in quel dialogo.
Quindi, se poi scorrere verso l'alto, possiamo vedere poi la processione delle cose
che è che si verificano.
In primo luogo abbiamo creato un comando Cloud 9 che quando eseguiti da Cloud 9,
sta andando a fuoco questa funzione.
E 'intenzione di eseguire questa funzione Chiamai spettacolo dialogo, che ho
scritto nel mio codice.
>> Ho creato una voce di menu e collegato ad esso che stesso comando
che quando tale voce si fa clic su il menu, che comando è quindi eseguire
e che la funzione viene eseguita.
E all'interno della funzione sono solo andando a chiamare the-- Sono
solo andando per eseguire lo spettacolo metodo di questo plug-in, che
sta per prima chiamata il metodo draw, e andando
al fuoco questo metodo basso, la disegnare gestore di eventi, nel nostro ciclo di vita.
E allora sarà davvero mostrano il dialogo.
>> C'è anche un metodo nascondere, in modo che se ho bisogno la possibilità di nascondersi
il mio dialogo, posso fare la stessa cosa.
Ecco, questo è più o meno lo per ottenere tutto questo a lavorare.
Si noti che è: se ci spostiamo verso il basso inoltre c'è un congelamento API pubblica.
Questo dice in sostanza solo che ho vogliono questi metodi in modo efficace
pubblica, ma non overwriteable al di fuori del contesto di questo plug-in.
E sotto, in fondo, è forse l'ultima cosa
che abbiamo davvero bisogno di pagare molta attenzione a qui, che
è che ci accingiamo a registrare il nostro plug-in con il nome C9 Seminario 1,
e il plug-in oggetto.
>> Che, come ricorderete, è che plug-in che il plug-in
oggetto che abbiamo definendo durante l'interezza di questa fonte
codice.
E C9 Seminario 1 è il stringa che abbiamo promesso
fornire al top di questa definizione.
OK.
Quindi cerchiamo di rampa è un po ' e vedere se possiamo fare qualcosa
un po 'più interessante.
Ora, questo è solo così grande.
Voglio dire, questo è, è in realtà piuttosto raffreddare in modo che poche linee di codice,
possiamo modificare l'IDE esistente e aggiungere una voce di menu esistente
o aggiungere una nuova voce di menu, aggiungere un il comando, e mostrano un dialogo,
e solo un mucchio di funzionalità che esiste.
E 'davvero abbastanza grande.
>> Ma non fare molto perché non può comunicare con l'Ubuntu sottostante
esempio.
Quindi diciamo che ho in realtà vuole scoprire
alcune informazioni sul sottostante esempio Ubuntu,
come le statistiche plug-in fa.
Quindi, diamo un'occhiata a un po 'più di informazioni
di come le statistiche plug-in opere.
Ed in effetti, è molto simile a questo.
Si potrebbe ricordare che c'è un dialogo.
Si potrebbe ricordare che non c'è alcune informazioni che sono
mostrato proprio lungo la barra del menu lungo la parte superiore, che si spera si è ora
ottenere un sapore di come abbiamo implementato questo,
semplicemente inserendo le voci di menu a specifica punti e istanziando un dialogo
e la visualizzazione che il dialogo.
>> Ma non abbiamo ancora mostrato come possiamo collegarlo
di un comando nel sottostante esempio Ubuntu.
Quindi, diamo uno sguardo poi a plugin.2, che fa appunto questa cosa.
Stiamo andando ad aprire plugin.js, che è il codice per questo.
Ma sotto il menu Finestra, se clicco su finestra 2,
possiamo vedere che si dice invece, ciao CS50, che
non sembra che tutto allettante, giusto?
Tranne, guarda questo.
Vorrei cambiare qualcosa qui.
>> Ho intenzione di andare al mio spazio di lavoro e il cambiamento seminario
per dire qualcos'altro, come Ciao, Dan.
Ho intenzione di chiuderlo e salvarlo.
E ora ho intenzione di re-run la mia voce di menu dialogo.
E notare che ha ora ha cambiato quello che dice.
Ciao, Dan.
Mi sembra di aver fatto qualcosa giù qui nel sottostante istanza Ubuntu
senza aver manipolato alcuna codice che ancora una volta è in esecuzione solo
sul lato client.
Quindi c'è ovviamente una sorta di comunicazione che sta succedendo qui.
>> Ora, questo è dove un sacco di potenza del Cloud 9 SDK è disponibile in,
è che in questo plugin.2, possiamo effettivamente causare
una chiamata per accadere al esempio di fondo,
ed eseguire un comando arbitrario.
Quindi, in questo caso, ho fatto creato un semplice script bash
nel mio lavoro chiamato Seminario.
Permettetemi quindi di aprire che fino.
E possiamo vedere che assomiglia a questo.
E 'solo un semplice bash sceneggiatura il cui unico scopo nella vita
sta per essere echeggiare questo testo, Ciao, Dan.
O prima, ha detto Ciao, CS50.
E questo è tutto quello che sta per fare.
>> Perché questo è ormai un comando che posso correre.
Posso effettivamente correre qui.
Possiamo vedere che in realtà è solo un comando che ho eseguito in modo naturale.
Posso chiedere al mio plug-in per eseguire questo comando sul lavoro sottostante
e analizzare le informazioni che è stato restituito da esso,
e fare qualcosa con esso, e modificare Plug-in e il comportamento che ho
avere nel mio plug-in di conseguenza. OK.
Quindi cerchiamo di vedere come questo accade.
Abbiamo visto questo molto semplice Script batch Seminario che ho
[Incomprensibile] che può effettivamente eseguito.
>> E ora vediamo le modifiche che sono necessari per legare questo insieme
con la finestra di dialogo, ed eseguirlo.
Quindi qui stiamo andando a fare abbastanza più o meno la stessa cosa, come abbiamo visto prima.
Meno di notare che tra il cose che ho consumato now--
oltre al dialogo, che ancora una volta mi è capitato di aver fatto due volte,
che non è necessary-- oltre al dialogo e comandi
ei menu plug-in, che erano necessaria nel primo per me
definire un nuovo comando e iniettare un elemento in menu,
Ho anche questo plug-in proc.
>> E questo plug-in permette proc di manipolare i processi
l'istanza sottostante.
Ho collegato dopo ho ha detto che il mio plug-in richiede.
Ho poi collegato al codice, come abbiamo visto nella funzione principale.
Ancora una volta, ho intenzione di inizializzare il mio dialogo.
E se ci spostiamo in giù ora, abbiamo può vedere come questo è diverso.
La funzione di carico è lo stesso, così è solo andando a creare un comando
e creare una voce di menu e collegare che voce di menu per quel comando.
Ma se ora scorriamo in modo da mostrare il dialogo,
possiamo iniziare a vedere dove le differenze si presentano.
>> Abbiamo spettacolo dialogo funzione, che sta solo andando a mostrare il dialogo.
Ma quando mostro questo dialogo, e quando il metodo spettacolo si chiama,
spara la funzione di disegno.
E ho intenzione di specificare alcuni contenuti all'interno di tale.
Così sto solo andando a creare un div, fornire ad essa
un testo base, Ciao, mondo.
Meno di notare che qui sono andando a collegare ad essa un ID.
E la linea molto prossimo vado per scoprire che ID utilizzando JavaScript,
e memorizzare l'oggetto in un'altra variabile
che sto solo andando a chiamare il contenuto.
>> Così ora ogni volta che ho contenuti, tutto quello che ho bisogno di fare
è sufficiente modificare HTML interno di questo oggetto.
E il codice HTML dialogo quindi essere modificato pure.
Così, quando questo plug-in è poi dimostrato, che può accadere
e questo è un nuovo evento che è nuovo a questo plug-in,
ma accade in ogni plug-in con il dialogo, quando questo viene ora mostrata,
Vado a chiamare un funzione di chiamata fetch informazioni.
E questa funzione è la carne di qui.
Ho intenzione di utilizzare tale plug-in proc che abbiamo descritto prima, che tra l'altro,
è in realtà solo una libreria Node.js che Cloud 9 sta usando qui.
>> Così si può effettivamente cercare su come questo
funziona se si va in Documentazione Node.js
e cercare il file exec metodo per i processi di lì.
Ho intenzione di eseguire questo specifico comando, casa Ubuntu lavoro
seminario, che è quella stessa, che stesso comando che ho creato prima.
Fornire ad esso una corrente directory di lavoro, solo
per essere sicuri ultra in termini di contesto in cui questo è in esecuzione.
E una volta che è stato completato e restituito,
Ho intenzione di eseguire questo funzione chiamata uscita di analisi.
OK.
Quindi questo poi sta andando ad eseguire un comando a livello locale, o meglio,
l'istanza di Ubuntu remota.
Quando torno un po ' informazioni, sono quindi
intenzione di chiamare una funzione separata chiamato uscita parse, che
ha questa firma qui, err, stdout, stderr,
ed eseguire alcuni calcoli su questo.
Quindi, se ho ricevuto un errore di qualche tipo affatto,
Io in realtà controllare per vedere se errore in realtà ha alcuni dati.
E se è così, allora io modificherà il interno HTML di tale oggetto contenuto, che
è ricorderete, abbiamo collegata al dialogo
al instantiattion di tale dialogo, o il primo disegno
di quel dialogo.
Io vado a dire proprio questo qualche errore è accaduto.
>> Ora, questo è troppo semplicistico.
Il valore di errore in genere contenere qualcosa che fosse utile,
forse un numero di errore e errore dello script stesso.
Oppure, se lo script scritto qualcosa di errore standard,
che i dati sarebbe popolata in tale parametro.
E potrei essere un po ' più attenti a ciò che errore
In realtà sto mostrando persone.
Ma questo esempio semplicistico è abbastanza buono per ora
almeno vedere come tutto questo funzioni.
Altrimenti se c'è nessun errore, allora io sono solo
andando a fornire grezzo uscita di tale funzione
in HTML interno di questo contenuto elemento, e quindi aggiornare il mio plug-in
e mostra qui.
E questo è più o meno tutto ciò che è necessario per ottenere questo per funzionare.
E così pensiamo poi come questo funziona, nel complesso.
Quando ho caricato questo plug-in, proprio come il primo plug-in,
Ho intenzione di aggiungere un comando che è disponibile per qualsiasi cosa, a qualsiasi plug-in
in Cloud 9, chiamato Seminario CS50 Dialog 2, la cui responsabilità
sarà quello di eseguire questo spettacolo il dialogo, che è si ricorderà,
realmente mostrerà il dialogo che ho richiesto qui di seguito.
>> Poi vorrei aggiungere che comando in un menu della finestra
in modo da avere accesso a questo.
E quando questo dialogo è chiesto di essere mostrato,
Io andrò a prendere alcune informazioni da il sottostante istanza di Ubuntu
utilizzando il comando exec file.
Mi scusi.
Una volta che viene restituito e ricevo un po ' informazioni, poi sul lato client
ancora una volta, sarò in grado di analizzare l'uscita di tale comando
e aggiornare l'interno HTML degli elementi
che avevamo collegato al precedente.
>> E con questo, abbiamo poi questo completamente funzionale plug-in
che mi permette di recuperare informazioni da questo script arbitrari
che abbiamo creato sulla nostra istanza sottostante.
Ma ancora una volta, è davvero importante e davvero fondamentale
separare dove ciascun di queste cose sta accadendo,
che abbiamo tutto questo lato client codice che viene eseguito nel browser,
e ancora non ha accesso per il file system sottostante
fino a quando abbiamo effettivamente eseguire alcuni di questi comandi che vengono forniti dal Copertura
9 SDK come proc, e alcuni altri che ci permettono di leggere alcuni dati,
o leggere alcuni file se abbiamo bisogno per fare una cosa del genere.
>> Ora, questo è un po 'semplice esempio.
Ci sono altre cose che abbiamo avrebbe forse voglia di fare pure.
Per esempio, forse abbiamo effettivamente desidera salvare alcune informazioni
alle preferenze.
O forse vogliamo aggiungere un nuovo pannello di preferenze
o qualcosa del genere.
Allora questo è qualcosa che si può dare un'occhiata al Cloud 9 SDK
per avere maggiori informazioni su.
Ma questo è davvero abbastanza per iniziare.
Quindi, solo per essere un po 'più concreto nel modo in cui alcune di queste cose
Funzione, volevo mostrare solo un altro esempio, che è solo alcuni
del codice dal plug-in Statistiche 50.
>> E questo codice è fondamentalmente sulla base di questi esempi
che hai effettivamente visto, ma ha alcune altre misure di salvaguardia
e ha un po 'di complessità, al fine per raggiungere alcune delle cose aggiuntive
che vogliamo raggiungere.
Ad esempio, se voglio essere in grado di salvare alcune impostazioni,
quindi ho bisogno di avere accesso le impostazioni dei plug-in,
e ogni volta che voglio leggere alcune impostazioni,
Posso, per esempio, collegare a vari eventi nelle impostazioni dei plug-in.
Così ogni volta le impostazioni è di colore rosso, per esempio, nel mio plug-in,
se ho intenzione di leggere alcuni le impostazioni dalla memoria salvato
le preferenze degli utenti, allora posso impostare i valori predefiniti per una località specifica,
per particolari richieste, in quanto JSON file di opzioni di stile che abbiamo
salvato in precedenza, che abbiamo visto in precedenza.
>> E se ho intenzione di scrivere alcune impostazioni ad esso,
poi ho can-- o non appena rileviamo che le impostazioni sono stati scritti
a-- perché per esempio, quelli le impostazioni sono state modificate dall'utente
o direttamente nelle impostazioni file o il pannello di preferenze
ha cambiato le impostazioni presentare direttamente, quindi
Posso realmente aggiornare parte del codice o aggiornare il comportamento del mio plug-in
sulla base di quei cambiamenti che hanno si è verificato sul file di impostazioni come bene.
Ma in realtà, il resto è piuttosto tanto questo che hai già visto.
>> Aggiungiamo un po ', forse qualcosa di nuovo.
Così aggiungiamo un file di preferenze, o meglio un pannello di preferenze,
la finestra delle preferenze, che ancora una volta è possibile trovare ulteriori informazioni
nel Cloud 9 SDK mi legge.
Ma tutto il resto è più o meno, piuttosto
simile a quello che abbiamo visto prima, solo con un po 'di controllo degli errori supplementari
e alcune protezioni aggiuntive e alcune funzionalità aggiuntive
per caratterizzare tutte le varie cose che abbiamo visto.
Se non avete in realtà ancora visto, si potrebbe
essere chiedendo cosa il sottostante il comando si trova nella finestra Statistiche 50.
In realtà è la funzione.
Beh, è-- oh, dannazione.
Un secondo.
Resisti.
OK.
Fammi spostare questo in modo che possiamo in realtà vedere cosa succede quando digito Statistiche 50.
Si noti che in questo caso, la comando che sono fuori mettendo
è davvero nuovo, solo lo script che è andando a produrre un mucchio di informazioni
in formato JSON.
E la ragione per cui lo facciamo in questo modo è che perché
sono operativi, perché abbiamo scritto il codice lato client in JavaScript,
possiamo molto facilmente solo analizzare oggetti JavaScript,
e realmente in grado di manipolare questi oggetti proprio come faremmo
qualsiasi altro oggetto JavaScript.
>> E quindi questo è un molto conveniente modo di fornire alcune informazioni
dal sottostante istanza di Ubuntu, quali il numero di versione, l'host
nome, se un server è in ascolto, ciò che il server è, chi più ne ha più ne metta,
e analizzare che molto facilmente e molto rapidamente
nel plug-in che viene poi andando per mostrarci tutte queste informazioni.
Così ancora una volta, l'intuizione chiave qui da tenere a mente
è questa separazione tra l'istanza di base,
e anche dove si carica il codice.
Che quando ho un cliente, è primo caricamento.
Proprio questo file JavaScript statico dal da qualche parte, forse CDN di qualche tipo.
Noi in realtà non hanno di cura troppo di questo primo passo.
>> Sappiamo solo che si tratta di esecuzione sul lato client
e che quando ho intenzione di comunicare con questa istanza finestra mobile.
Che stiamo andando a farlo attraverso il Cloud 9 SDK.
Noi in realtà non abbiamo la capacità, utilizzando JavaScript o Node.js,
di scrivere direttamente ad esso.
Usiamo quelli esistenti SDK API per fare che l'azione per noi.
E ancora, una delle cose veramente importanti
è che quando ho creato questo, quando ho creato questo plug-in,
e mentre sto lavorando su di esso, un delle cose importanti da fare
è quello di far apparire la console JavaScript.
>> Poiché poiché questo è tutto operanti sul JavaScript,
sul lato client, se uso un console.log method-- quindi basta
per mostrare un esempio qui.
Proviamo modificare questo semplice plug-in per registrare anche alcuni dati.
E noi aggiungeremo fuori standard.
Quindi cerchiamo di cambiare che, per essere proprio qui.
Ora, quando eseguo console.log, tenere a mente
che dal momento che questo è in esecuzione sul lato client,
Vedrò questo nel mio Console JavaScript, che
è come sarò quindi in grado di cercare di risolvere i problemi ed eseguire il debug
alcuni dei problemi che ho.
>> Si noti che, a causa Sono in modalità SDK, sono
quindi in grado di manipolare plug-in di questa istanza.
Quindi, anche se è salvato in questo esempio,
questo è quello del precedente esempio regola violata, dove il Cloud 9
SDK sarà effettivamente tirare plug-in dal sottostante istanza e quindi eseguirli.
Così che in questo modo, sono poi in grado di manipolare e costruire
alcuni plug-in qui.
Ma per per me vedere aggiornamenti su questo plug-in,
perché è sul lato client, Ho bisogno di salvare quel plug-in
e poi ricaricare l'intera area di lavoro, in modo che il nuovo plug-in è quindi
scaricato sul mio cliente, sul mio browser web, e quindi è in uso.
>> Così ora quando faccio clic su questo Seminario Dialog 2, vediamo ancora questo.
Ma ora si spera in mia JavaScript dialogo, dovrebbe vediamo my-- aspettare,
resisti.
Avrei potuto aprire il dialogo fresco.
Dovremmo vedere i miei dati ricevuti qui.
I dati ricevuti, Ciao, Dan, che è si ricorderà,
era un'operazione che console.log abbiamo richiesto nel plug-in.
Quindi questa descrizione allora che ho detto prima,
questo dialogo, o questo schema piuttosto, che mi
accennato prima è ciò che accade.
Ma c'è un importante eccezione solo per lo sviluppo,
che è che il plug-in si potrebbe effettivamente
essere memorizzati nell'istanza finestra mobile temporaneamente, dal momento che presumibilmente Cloud 9
non ci vuole essere in grado di manipolare oggetti sul loro CDN.
>> E i Cloud 9 clienti, al momento del caricamento, troveranno i plug-in che.
Plug-in C9 cartella e caricare quelli.
Ma quelli sono ancora accadendo solo sul lato client.
Allora questo è solo l'una eccezione che si verifica solo
per lo sviluppo di Cloud 9 plug-in.
Ma il resto della tempo-- e la ragione
che vogliamo davvero martello questo home--
è perché la maggior parte del tempo questo è andando ad essere in esecuzione dalla CDN,
e solo andando a essere eseguito puramente dal lato client.
>> Normalmente non ci sarà interazione con il plug-in,
o non ci hanno nemmeno bisogno di essere qualsiasi ragione che si il plug-ins
sono effettivamente memorizzati sulla sottostante istanza finestra mobile,
tranne nel caso di questo sviluppo SDK.
Quindi, di nuovo, questo cambia solo leggermente a causa del fatto
che stiamo correndo modalità SDK.
Sta andando a caricare quelli plug-in di sviluppo,
e l'unico scopo qui è così che Posso usare Cloud 9 per fare lo sviluppo
per Cloud 9 plugin.
Ma anche così, questo non cambia ancora una volta come tutto questo funziona.
E 'ancora in fase di esecuzione interamente sul lato client.
>> Significa solo che ogni volta che voglio creare Cloud 9 plug-in Cloud 9,
Creo quei plug-in, metterli nel mio.
Cartella / plugins C9 nella mia casa directory, assicurarsi che io sono in modalità di SDK,
ricaricare la pagina ogni volta che in realtà apportare modifiche a tale plug-in,
e vedere cosa succede in mia console JavaScript.
Basta gestire la mia JavaScript consolare per assicurarsi
che la risoluzione dei problemi informazioni che ho posto a consolare,
o qualsiasi altra cosa che potrebbe accadere a causa di errori che ho scritto
nel mio codice o simile, vi appare.
>> E con questo, è davvero abbastanza per iniziare, credo,
con i Cloud 9 plug-in.
Soprattutto dare un'occhiata a l'SDK documentazione Cloud 9 fornisce.
E 'un ottimo modo per ottenere iniziato, e molto facilmente
creare alcuni plug-in per Cloud 9.
E con questo, voglio ringraziare tutti molto per me l'adesione.
Spero che vi divertirete scrivere plug-in per Cloud 9.
Forse migliorando plug-in che abbiamo ora, o forse anche
l'aggiunta di alcune funzionalità di tua scelta.
Non vediamo l'ora di vedere che cosa è che si crea.
Fino ad allora, ciao.