>> DAN ARMENDARIZ: Olá, e bem vindo a um seminário sobre a personalização CS50 Cloud 9,
eo IDE CS50.
Então, hoje nós estamos indo para apenas falar um pouco
sobre alguns dos informações técnicas que
vai atrás da arquitetura de Cloud 9, e como
temos implementado alguns dos plug-ins como parte de Cloud 9 para fornecer CS50 IDE.
Então vamos saltar para a direita e começar a falar sobre os plug-ins.
>> Assim, os plug-ins são realmente no núcleo da experiência Cloud 9.
Cloud 9 é a tecnologia subjacente que fornece-nos o IDE,
e também o terminal na janela parte inferior, juntamente com o workspace--
Ubuntu que workspace-- usar para compilar todos os nossos projetos
e realizar os nossos conjuntos de problemas, completar os nossos conjuntos de problemas.
Mas no coração de tudo disso, toda a tecnologia
é realmente apenas um monte de plug-ins.
Tudo é um plug-in que pode ser modificado,
estendido, você pode criar seus próprios plug-ins,
você pode remover outro plug-ins, para realmente alterar
um monte da funcionalidade do Cloud 9 IDE existente.
>> Portanto, este é um existente Cloud 9 ambiente.
Isto é realmente apenas o default Cloud 9 ambiente.
E dar uma olhada em como ele realmente é diferente do IDE CS50.
Então este é o IDE CS50.
Observe que há alguns visuais mudanças entre a Nuvem regulares 9
ambiente e do IDE CS50.
Especificamente, você vai notar algumas mudanças.
Em primeiro lugar, há menos itens de menu para começar.
Há realmente uma maneira que você pode mudar isso.
É chamado de modo simples.
>> Por padrão, o modo simples é habilitado, e que simplifica alguns dos itens do menu.
Ele remove algumas das os mais avançados,
porque, francamente, um monte de estudantes que estão chegando
e não precisa de saber sobre alguns dos recursos mais avançados
não estão sobrecarregados com um monte de opções.
Mas nós fornecemos a capacidade de assumir fora os chamados rodinhas
e remover esse andaimes para que as pessoas
pode tornar-se mais acostumados a os recursos avançados do IDE.
Imediatamente para o direito de que, há
também um botão de debug, o que na nuvem padrão
9 ambiente é simplesmente chamado de execução.
Mas por padrão, nós configuramos o botão de depuração no IDE CS50
para abrir o depurador, compilar automaticamente o código-fonte,
conectar o depurador para o GDB-- subjacente
e uma vez que está sendo executado para executar o debugging-- e alguns outros passos
também.
Além disso, a janela de terminal no very-- ou melhor, o terminal
guia na seção de console no janela na parte inferior da tela,
foi renomeado para simplesmente ser terminal.
Considerando que, no padrão Cloud 9 ambiente,
mostra que realmente o execução da aplicação.
Desta forma, simplifica, de novo, o GUI, apenas um pouco.
>> Nós também adicionamos alguns botões no canto superior direito do IDE
para mostrar algumas informações básicas sobre a instância subjacente.
E também nós removemos um das opções sobre os itens
da extrema direita.
Então, tudo isso não é implementado modificando necessariamente o Cloud 9
código fonte, mas em vez através de um par
de plug-ins que implementamos ao longo do ano passado ou assim.
E Cloud 9 tem acolhido e tem em execução na área de trabalho CS50.
Ou melhor, nos espaços de trabalho que são designados como CS50 IDEs.
>> Então, realmente essa é a principal diferença entre o Cloud 9 eo CS50
espaços de trabalho.
Há também, no subjacente exemplo, a principal alteração é
que instalar algum itens pré-configurados como GDB,
e algumas outras coisas básicas que nós criamos, como atualização de 50,
e um par de outras medidas que fazem toda a experiência um pouco mais
unificado.
Mas no geral, este é apenas um modificação de um sistema existente
Cloud 9 que criou para nós.
O que nós estamos indo para mostrar um pouco mais tarde
é a forma de realmente criar uma plug-in um pouco básicos que
permite-nos inserir algo na sistema de menus, e abrir um diálogo.
E se temos o suficiente vez, vamos realmente
ver como podemos preencher esse diálogo com algumas informações
do exemplo subjacente.
Para que nós para chegar a esse ponto, vamos primeiro falar um pouco
sobre a arquitetura de Cloud 9.
>> Assim, a maneira que estamos acostumados para interagir com Cloud 9
é inteiramente através do cliente.
Nós abrimos um navegador web, digitamos no CS50.io.
Nós finalmente, após a autenticação, são apresentados com o IDE.
Mas perceber que há um par de passos
que realmente nos levar a este ponto.
A primeira coisa é que meu cliente, o navegador da web,
mediante pedido e após a autenticação, carrega o GUI e os plug-ins
de alguns CDN, de algum Content Delivery Network.
Isso pode ser francamente em qualquer lugar.
>> E isso é realmente separado do exemplo subjacente.
É importante perceber que este é na verdade, apenas um monte de arquivos estáticos.
É um monte de JavaScript que é baixado do CDN
no meu navegador web, e toda a GUI que você
aqui-- ver isso é realmente key-- toda a GUI que você vê aqui
é executado no lado do cliente.
Tudo o que você vê no Cloud 9 espaço de trabalho
é realmente executado no navegador.
E qualquer coisa que você envia junto à instância subjacente
é comunicada à instância ao longo desta segunda canal separado,
e é então guardada em essa instância estivador.
>> Portanto, a razão que eu estou dizendo este é um exemplo estivador
é que a tecnologia subjacente não está usando máquinas virtuais,
mas em vez disso utiliza uma tecnologia chamada janela de encaixe,
que basicamente allows-- o mais próximo analogia é uma máquina virtual.
Mas é sutilmente diferente em que há
muitas oportunidades para executar um combinação de janela de encaixe diferente
instâncias em uma única máquina.
E eles pode ser girado para cima em sucessão muito rápida.
Ele não é exatamente a mais diferenciação estrita
entre diferentes instâncias docker como existem em máquinas virtuais,
mas ainda há um monte de diferenciação e separação
entre estes diferentes casos.
ESTÁ BEM.
Assim, os dois passos aqui que são importantes para perceber
é que quando vamos para CS50.io, estamos baixar o GUI e os plug-ins,
que são escritos em JavaScript, em para o navegador ou para o navegador.
E este é talvez um par megabytes de informações.
Nesse ponto, uma vez que tem a GUI carregado e os plug-ins já começaram,
em seguida, ele começa a comunicar com a instância janela de encaixe, o que não faz
têm necessariamente de ser o mesmo servidor.
>> Agora há uma exceção a isso.
Nós podemos realmente ter tanto o mecanismo de entrega para o próprio GUI
ea instância estivador em todos o mesmo servidor, a qual
é realmente algo que nós fazemos para a versão offline do Cloud 9.
Isso não é algo que nós temos divulgado muito esta queda,
mas nós também têm uma versão off-line que
permite que você baixe um embalado versão de todas essas coisas
e permitem que você execute Nuvem 9 num ambiente fora de linha.
>> Movendo esta fora da nuvem e para sua máquina local tem algum impacto.
Em particular, você não já não têm a capacidade
para compartilhar seu espaço de trabalho com os outros.
Você não pode abrir Cloud 9 de, e CS50 o IDE, a partir de qualquer computador
e ver os mesmos arquivos que você estava trabalhando antes.
Mas em vez disso ele funciona totalmente em sua própria máquina local
sem a necessidade de acesso à internet.
Mas, ainda assim, mesmo nesse modelo, mesmo embora tenhamos uma máquina virtual
que é essencialmente executando essas coisas.
>> Nós temos um servidor separado que é entregando essencialmente o Cloud 9
conteúdo, e então nós tenho uma instância de estivador
que é responsável pela comunicação com que IDE para o back-end.
ESTÁ BEM.
Então, toda a GUI é escrito inteiramente em JavaScript
usando Node.js eo Cloud 9 SDK, que nós vamos chegar a em apenas um minuto.
E todos os plug-ins são executados no lado do cliente.
Então, vamos nos concentrar em seguida, um pouco assumindo
que este primeiro passo tem realmente concluída com êxito,
e olhar apenas para essa instância estivador.
>> Portanto, neste caso, este é a maneira padrão
de pensar em fazer Cloud 9 plug-in desenvolvimento é que você está indo
para ser código escrito, que será ser executado no navegador do usuário,
e você tem a oportunidade de usando alguns APIs para se comunicar
com a instância estivador subjacente, executar algum código lá, e fazer qualquer coisa
que você pode querer fazer.
Portanto, esta vai ser o contexto que vamos
estar usando para o resto desta conversa.
E basta manter este modelo em mente.
Isto irá ser muito importante em apenas alguns minutos.
Há um par de links que eu quero te mostrar.
Em primeiro lugar, Nuvem 9 forneceu um monte de documentação
isso é muito bom, que mostra como fazer plug-in de desenvolvimento básico.
Então, se você vai para este URL, cloud9-sdk.readme.io,
você verá a documentação lá.
E um monte de esta informação que você está prestes a ver
também podem ser encontradas lá, além de mais.
Você também pode encontrar o código-fonte aberto versão do Cloud 9 neste URL,
github.com/c9/core, que usamos como parte da versão offline do IDE,
de modo que você será capaz de ter a mesma experiência Cloud 9,
mas de um modo off-line.
Tudo certo.
Então, vamos dar uma olhada em um real Cloud 9 espaço de trabalho aqui.
E novamente, eu quero apontar um par de coisas.
Esta é, aqui, uma IDE CS50 normal.
E eu ter desativado a menos modo confortável sob o menu Exibir
para que eu possa ver tudo das opções do menu.
O que eu quero mostrar-lhe direito agora é um par de coisas.
Primeiro, se eu entrar em Preferências e, em seguida,
clique em Plug-in gerente, e digite CS50 aqui,
podemos ver que há, de fato, um par de CS50 plug-ins que
foram instalados e nossa corrida para permitir que as modificações que temos
visto para o IDE CS50.
>> Agora há, essencialmente, dois plug-ins que estão em execução.
Há um chamado simples, que é o de que modo simplificado
permite reduzir o número de opções de menu na parte superior,
e ter essa chamada modo menos confortável.
E depois há também Stats CS50, que é talvez apenas um pouco misnamed.
Porque é isso que mostra-lhe a informação
sobre o espaço de trabalho subjacente.
Introduz estes botões na parte superior direita.
Ele também injeta um item de menu para o item de janela, no menu Janela
aqui mesmo, CS50 IDE Info.
E é responsável por instanciar este diálogo que temos visto aqui,
com toda a informação que nós somos acostumados a ver em um CS50 IDE
espaço de trabalho.
ESTÁ BEM.
Portanto, há, na verdade, mais um plug-in que temos desenvolvido bem.
E há um par de outros que nós também não divulgou publicamente.
Mas um deles é o global plug-in que permite que o GDB para funcionar.
Assim, um dos aspectos da Cloud 9 é que eles têm já previsto
este GUI para implementar um depurador.
E um dos plug-ins que criamos basicamente
ganchos GDB com este GUI versão com base de um depurador.
E é responsável por mediar tudo dos pedidos que um usuário pode ter,
entre passando por cima ou a criação de pontos de interrupção ou nada
nesse sentido, para que traduzindo para comandos que GDB pode entender,
emitindo os comandos para GDB.
E logo que GDB emite uma resposta, então
nós interpretamos isso e atualizar o GUI, conforme necessário.
>> Isso é provavelmente um dos o mais complicado
dos plug-ins, então ao invés do que somos vai focar hoje é de fato
o plug-in Stats, e vamos falar um pouco sobre simples, também.
Então eu mencionei antes, e eu realmente quero para fazer muito, muito claro, que mais uma vez,
tudo isso que nós somos ver aqui é essencialmente
operando no lado do cliente.
Nós vemos uma janela de terminal a seguir, e que, é claro,
se digitar comandos em que, que será então emitida
à instância de base.
Da mesma forma, se abrirmos um novo arquivo e digite algumas coisas para ele e salvá-lo,
esse arquivo será salvo em o exemplo subjacente.
>> Mas o editor em si, esta própria janela de terminal,
é implementado em toda JavaScript e tudo é um plug-in
que podemos interagir com, e, portanto, modificar.
Há um monte de extensibilidade aqui.
Eu recomendo dar uma olhada em Cloud 9 de conta GitHub
para ver a grande quantidade de plug-ins que estão disponíveis,
e quão bem escrito muito do código é para extensibilidade.
Portanto, há algo que eu quero mencionar
sobre isto, assim, o que é que há um grande número de-- há
uma série de funcionalidades que é fornecida nas preferências
janela, o que temos visto apenas aludido a poucos minutos atrás.
>> Uma das coisas que podemos fazer como IDE desenvolvedores, ou como Cloud 9 desenvolvedores,
é realmente injectar alguma Painéis de preferência de nossa própria.
Assim, o modo simples, ou o modo menos confortável,
e também as informações de IDE, ou plug-in as estatísticas,
cada tem alguma preferência painéis que nos permitem modificar
o comportamento de cada um deles.
Você vai notar que, se eu ir para o Preferências e ir às configurações do usuário,
há um guia CS50, um que diz que a informação IDE.
E eu posso mudar o informações taxa de atualização.
>> Efetivamente, o que está acontecendo nas estatísticas de plug-in
é que cada n-segundos, onde n-segundos é definido por esta preferência
painel, a informação está sendo buscado do exemplo subjacente, sendo enviado
de volta para o lado do cliente, o plug-in é, então,
interpretar a informação da instância subjacente
e atualizar o GUI, conforme necessário.
Podemos ver que agora isso é definido a 30 segundos, e isso é o padrão.
Mas eu posso mudar definitivamente a rapidez com que isso acontece apenas
modificando esse valor.
>> Agora, uma das coisas interessantes é que este painel de preferências, GUI,
é realmente apenas uma versão GUI de um monte de configurações subjacentes
que são apresentadas em JSON.
Então, se eu for, por exemplo, sob a Menu CS50 IDE, ou o menu de Cloud 9,
dependendo de quais versão que você está olhando,
e ir para um desses settings-- neste caso,
o projeto do settings-- configurações do projeto, neste caso,
aplica-se a todas as configurações para este espaço de trabalho.
Considerando as configurações do usuário aplicar para todos os espaços de trabalho
que você pode ter em sua conta.
>> Assim apenas como um aparte aqui, para ser mais claro,
há uma separação entre o dois, porque embora por nós padrão
ter um espaço de trabalho, que é o CS50 IDE, se você
estavam a clicar no seu pouco avatar aqui e ir para o painel de instrumentos,
você vai descobrir que você pode realmente criar espaços de trabalho adicionais.
Você pode ver aqui que eu tenho um IDE de 50 de espaço de trabalho, e também
para os fins da presente seminário, um espaço de trabalho
chamado de espaço de trabalho, que é aqui mesmo.
De qualquer forma, eu tenho preferências diferentes.
Cada um destes pode ter preferências do projeto separados,
mas as preferências do usuário são compartilhado entre todos os meus espaços de trabalho.
By the way, este é também muito útil se você
quer criar um espaço de trabalho com diferentes opções de personalização.
E é muito útil para criar um novo espaço de trabalho.
E escolher aquele que pode ser pré-configurado de alguma outra forma,
talvez para PHP especificamente, ou especificamente Django.
Ou mesmo apenas sob encomenda.
O espaço de trabalho CS50 modelo é o que nós
usar que instala automaticamente Actualização de 50 e todas as configurações
que tem ali, incluindo toda a Os plug-ins que temos para o IDE CS50.
ESTÁ BEM.
Mas vamos voltar a este.
Então, novamente, há projetos configurações, e esses são os que
que estamos vendo aqui.
E note que não há são um bando de configurações,
muitos deles correspondem às preferências painéis, mas não todos eles.
Mas podemos ver que aqui, em isto-- oh não, eu colocá-lo nas configurações do usuário?
Talvez eu colocá-lo nas configurações do usuário.
E isto, aqui vamos nós.
Nas configurações do usuário, nós podemos ver que nós temos uma seção CS50,
e isto está sendo escrito para por estes Nuvem 9 plug-ins
que temos implementado.
Há o simples para corresponder com esse plug-in simples,
e as estatísticas que um corresponde à interface gráfica baseada
versão do painel de preferências.
A taxa de atualização, neste caso, é definido como 20 segundos.
>> Isto é tudo, espero, o começos de alguma informação
que vamos realmente ver em um pouco pouco mais detalhadamente, momentaneamente.
ESTÁ BEM.
Então, vamos dizer que queremos realmente começar a ele.
Entendemos que todas as coisas que está acontecendo no lado do cliente
é feito, na verdade, o navegador, que significa que qualquer plug-ins que eu escrevo
vão ser escrito com o navegador em mente.
E se eu realmente quero fazer nada no espaço de trabalho,
Eu talvez tenha de dar início algum tipo de comunicação
entre o navegador eo o espaço de trabalho para ter certeza
que que é realmente realizado.
Mas vamos dizer que agora Eu quero começar a ele
e realmente criar o meu primeiro plug-in.
Bem, a maneira que você seria capaz de fazer isso é realmente muito fácil.
É dado no Cloud 9 SDK.
Mas é para tomar o seu Nome do espaço de trabalho existente, que
é a URL que você tem na parte superior da seu bar, e adicionar o seguinte a ele.
?
Sdk = 1 & Debub = 2.
Agora, o que é que isto vai permitir é que o SDK = 1 vai realmente definir o SDK
modo a verdade, o que permitirá um par de coisas adicionais.
E debug = 2 irá permitir que mensagens de erro para ser um pouco mais detalhada.
>> E por isso, se você abrir o JavaScript console no seu guia desenvolvedor Chrome,
você vai realmente ser capaz de ver muito mais informações
que você faria de outra forma.
Então, eu recomendo transformando ambos ao mesmo tempo, porque ele realmente
É útil dispor de toda esta informação adicional.
É importante notar, contudo, que ligar de depuração para o valor de 2
significa que é muito detalhado, e ele realmente
vai um pouco visivelmente mais lento o IDE, especialmente quando o carregamento
ou quando fazer fazer tarefas pesadas.
Então, basta manter isso em mente.
É útil para o desenvolvimento, mas você não pode querer tê-lo ligado o tempo todo.
>> Então vamos realmente fazer isso.
Mas, neste caso, eu realmente tenho já criou um espaço de trabalho com este.
Então vamos ver, sdk = 1 & debug = 2.
Com um par de plug-ins espero já instalado.
Tudo certo.
Portanto, agora que eu tenho ligado a depuração SDK modo, repare que estamos em modo de depuração,
para que possamos olhar para as ferramentas dev para ver quaisquer erros, que eu vou fazer fora de campo.
Nós podemos ver que não há um monte de erros aqui.
Agora é realmente muito comum para Cloud 9 para ter um par de erros,
e eu não me preocuparia sobre eles até que você
veja algo que pode ser específico para o plug-in
que acontecer de você estar criando.
>> Então, aqui, por exemplo, obtemos um par de 404s-- não encontrado.
Nós vemos não podemos carregar algum informações fora da instância subjacente
si.
E há um monte de adicional informação, mas a maior parte deste que estamos
realmente indo para ignorar por agora.
Porque isso é muito comum para um espaço de trabalho
ter apenas um par de erros.
ESTÁ BEM.
Eu estou indo para mover esta fora de o caminho e voltar aqui.
E agora o caminho mais fácil, o Nice coisa sobre ter este desenvolvedor
modo ativado é que ele me permite para criar facilmente um novo plug-in.
>> Assim, enquanto que antes eu realmente não fiz ter esta nova opção plug-in está disponível,
que podemos ver se eu voltar para meu modo não desenvolvedor aqui,
não há nenhum novo plug-in.
Ao habilitar o modo SDK, I tem um novo plug-in está disponível
e eu posso facilmente criar uma.
Neste caso, há um casal de diferentes opções, simples,
um plug-in vazio, um plug-in completo, instalador, Cloud 9 bundle.
Vamos apenas escolher um plug-in vazio por enquanto
para que possamos ver um muito versão simples de um.
>> Agora note que ao longo da lado esquerdo que está lá é agora
algo em Favoritos, que está listando um par de plug-ins
que agora estão disponíveis para mim.
Se eu expandir isso, vamos ser capaz de ver aqueles.
Agora eu quero que você observe algo aqui, que
é que este não é, na verdade contida dentro do diretório do espaço de trabalho
no meu exemplo Ubuntu subjacente, mas está contida no disco rígido.
E onde ele está localizado, porque isso é muito útil para saber,
especialmente se você estiver indo para estar fazendo nada com Git,
onde está localizado este é em uma pasta .c9, / plugins.
Então, se eu for lá, podemos ver que agora a lista de plug-ins que está aqui
corresponda à lista de plug-ins que eu viu no lado esquerdo da minha área de trabalho.
>> Agora, por padrão, e este é o tipo de estranho,
por padrão quando eu criar uma novo plug-in em um espaço de trabalho,
ele cria este plug-in que por padrão tem um nome de um sublinhado.
Geralmente que pode causar alguns problemas.
Assim, o próximo passo que eu normalmente realizar
é apenas para remover essa plug-in específico
e deixar apenas o plug-in simples que Foi há inicialmente, plugin.simple.
E isso é o único que está lá.
ESTÁ BEM.
>> Então o que isso realmente se parece?
Bem, isto é, de novo, um pacote JavaScript
que inclui alguns ficheiros, incluindo um arquivo plugin.js, onde
o conteúdo principal do meu plug-in está localizado,
um arquivo package.json, que realmente especifica
alguns metadados sobre este plug-in, tais como quem é o autor,
quaisquer informações adicionais sobre isso, um Descrição do plug-in, e assim por diante.
E também por padrão, ele cria um arquivo README em branco,
e um arquivo de teste vazio para você criar alguma documentação adicional,
e um chicote de fios de teste se você gostaria de fazer isso.
>> Então vamos dar uma olhada na primeira, muito rapidamente, no ficheiro package.json.
É fácil o suficiente para apenas passar por -lo e preencher as áreas deste
que você gostaria de preencher, como fornecer-lhe um nome, uma descrição,
iterar o número da versão de vez em quando, fornecer
um autor para cada pessoa que contribui,
adicioná-los para os contribuintes seção, eo resto deste você
pode muito bem apenas deixar como é para agora.
>> Há uma coisa que é importante notar,
que na seção de plug-ins, existe uma chave chamada plug-in.
E este é comparado com o nome de o arquivo JavaScript chamado plugin.js.
Então é assim Cloud 9 sabe, quando se lê este arquivo package.json, que
dos js arquivos para realmente carregar.
Se eu criar arquivos js adicionais ou quer renomear esse arquivo js do plug-in,
Eu também tenho que mudá-lo no arquivo package.json.
>> Quaisquer perguntas da platéia?
Não.
Que uma pessoa que é a seguir junto comigo até agora.
>> ESTÁ BEM.
Então, eu realmente criaram uma par de plug-ins já,
Eu acho que, neste espaço de trabalho.
Então, vamos nos livrar de alguns deles, adicione sdk = 1 & debug = 2, recarregue esta área de trabalho,
e vamos ver se nós tem esses plug-ins agora.
C9 / plugins.
Aqui vamos nós.
Podemos ver agora em meus C9 / plugins deste um, temos plugin.1 e plugin.2.
Então, nós estamos indo apenas para intensificar as-- apenas aumentar a quantidade de dificuldade
em cada um desses plug-ins.
Mas aqui se eu criar um novo plug-in, I pode adicioná-lo aos favoritos.
E eu vou simplesmente apagar os de o sistema de arquivos subjacente.
>> Vamos remover isso.
Agora, se eu abrir a minha primeira plug-in, e plugin.js abertas,
podemos ver aqui o subjacente versão simples de um plug-in.
Deixe-me realmente voltar Este outro espaço de trabalho
porque você pode, pelo menos, aqui ver, o que um plug-in em branco realmente parece.
Então, debaixo do capô, isso parece muito semelhante à tecnologia chamada,
Eu acho, é RequireJS.
Repare que isso não faz realmente olhar, talvez,
o mesmo que alguma outra JavaScript arquivos que poderíamos ter visto.
Mas em vez disso, há um par de apenas linhas básicas que ele realmente tem.
>> Todo este material é primeiro interpretado pelo IDE,
mas não é, na verdade, executar até que seja especificado.
E eu vou te dizer sobre quando isso significa, na verdade, em apenas um momento.
Mas note que aqui há uma main.consumes linha na linha 2,
e esta lista todos os plug-ins que este plug-in é dependente.
Então, por padrão, nós talvez não ter quaisquer dependências de outros plug-ins,
mas quando nós realmente precisa depender de características fornecidas
por outros plug-ins do IDE, precisamos listar os plug-ins
na linha main.consumes.
E então nós precisamos vinculá-los ao código
abaixo, que eu vou lhe mostrar em apenas um momento sobre como podemos fazer isso.
>> Main.provides dá um nome a este plug-in
que outros plug-ins poderia usar em sua linha consome.
Portanto, neste caso, o meu plug-in é apenas um conjunto lá por padrão,
e devemos mudar isso para ser aplicável ao nosso próprio plug-in,
como veremos em apenas momento.
Agora, aqui na função principal, esta função principal
é realmente executado e interpretados, mas ele realmente não fazer muito.
Ele só fica tudo configurado, mas na verdade não iniciar o plug-in,
apesar do que o nome soa como.
Isso realmente acontece através uma sequência de métodos que
estão contidos ao longo deste plug-in.
>> Então, se eu rolar para baixo, podemos ver que temos um ciclo de vida em que
em algum evento denominado de carga, ou algum evento chamado de descarregamento,
alguns eventos realmente acontecer.
É realmente aqui onde, como o plug-in começa que esses métodos são chamados.
Então, vamos ser um pouco mais concreto sobre isso e olhar um exemplo.
Então aqui para plugin.1, o que estamos basicamente vai fazer
é criar um item de menu CS50 chamado Seminário de Diálogo 1--
porque temos dois eles-- e vamos
para injetá-lo no menu Janela.
E quando clicar sobre ele, nós somos vai abrir um diálogo que
mostra-nos algumas informações muito básico.
>> Neste caso, apenas um Olá mundo.
Portanto, esta é uma forma muito simples Olá diálogo mundo
que pode implementar como um plug-in em Cloud 9.
Então, vamos ver como isso realmente parece.
Nós vamos percorrê-lo, apenas de forma relativamente rápida para que
pode olhar para a próxima plug-in também.
Repare que aqui estamos consumir uma variedade de plug-ins.
Estamos consumindo um diálogo plug-in, comandos, menus, e UI.
Parece que eu realmente estou consumindo diálogo duas vezes, para que eu possa remover isso.
>> E note que o caminho que eu estou conectando-os,
este é o tipo de metadados que está dizendo o sistema plug-in que requisitos
são realmente necessário para este plug-in a ser carregado.
É também importante notar que a fim de que os plug-ins são carregados
não é garantido.
Mas o que é garantido é que se eu especificar alguns plug-in como um requisito,
que plug-in será carregado antes de este é carregado.
>> Então isso significa que se o seu plug-in requer de alguma funcionalidade fornecida
por outra coisa no IDE, você deve ter certeza de que seus plug-in consome
que plug-in, de modo que as dependências estão determinados a criar o seu plug-in,
ou instanciar seu plug-in, única depois existe esse quadro existente.
Então aqui eu ter mencionado a metadados para o gerente de plug-in,
que esses que eu estou indo para consumir.
E na função principal aqui, Eu estou indo em seguida, conecte
meu código para esses plug-ins importados.
>> Então, eu estou indo só para criar algumas variáveis ​​que
coincidir com os nomes de cada um daqueles tão que eu possa muito rapidamente referenciá-los
em todo o meu código.
A razão que eu estou importando diálogo é porque eu quero o meu plug-in
para agir como um plug-in de diálogo.
E a maneira que eu sou capaz para fazer isto é, é claro,
conectar meu código para o diálogo plug-in importando-
e, em seguida, por especificando criando uma nova variável de diálogo
e conectá-lo ao que plug-in importados.
E, em seguida, através da definição de meu plug-in como um novo diálogo.
>> Assim, na inicialização, eu quer definir o meu plug-in.
E essa variável chamada plug-in você verá
é apenas usado comumente todo Cloud 9 plug-ins.
Eu estou indo para instanciar um novo diálogo com alguns atributos,
dar-lhe um nome específico, dizer que é possível para os usuários para a fechar.
Que ele vai mostrar um pouco de x em o canto superior direito,
ou um pequeno botão no canto inferior direito.
Ou não posso selecionar o texto de -lo, o que o título desse diálogo
seria, e assim por diante.
Agora, esta apenas define o diálogo, mas ainda não mostrá-lo.
Na verdade, tenho de definir uma acção para que possa ser demonstrado.
>> E novamente, eu encorajá-lo a Dê uma olhada no Cloud 9 SDK,
porque há uma variedade de diálogos e eles são muito bem documentados.
Você pode ver os diferentes tipos que existem, e usá-los
em qualquer plug-in que você tem em mente.
Agora não vai ser um secção de carga, e esta carga
função como você se lembra é utilizada por ciclo de vida do plug-in
para realmente instanciar tudo e deixar tudo pronto para ir.
Agora, quando este plug-in cargas, eu não quer mostrar imediatamente um diálogo,
porque este plug-in será carregado juntamente com o resto do IDE.
E quando eu carregar o IDE, eu não quero o diálogo para aparecer automaticamente.
Eu só quero isso para mostrar quando eu clico em a opção de menu no meu item de menu Janela
que eu vou adicionar a ele momentaneamente.
>> Portanto, há duas etapas distintas aqui que tem que acontecer.
Eu tenho que criar um comando eo comando
será responsável pela verdade mostrando o diálogo sobre o Cloud 9 IDE.
E então eu tenho que ligar, eu tem que criar um novo menu janela
item, que executa esse comando.
De modo que quando eu clico em que Janela item de menu, o comando é então executado
e, portanto, meu diálogo é mostrada.
E assim esta é realmente uma bonita Nice maneira de pensar sobre isso.
>> Porque primeiro eu posso criar um comando cujo nome é CS50 Seminário de Diálogo 1,
que fornece alguns contexto geral para ele.
E o pouco importante aqui é observe o atributo EXEC, que
enumera uma função que será chamada no meu plug-in quando este comando é executado.
Assim, este comando é uma espécie de um-- é apenas uma nuvem arbitrária 9
comando que está disponível a qualquer Cloud 9 plug-in.
Mas a função real que é vai chamar quando esse comando é executado
é a função show de diálogo no meu arquivo plugin.js.
>> E nós podemos realmente ver estes plug-ins e a lista
de comandos que estão disponíveis para nós em Preferências, percorrer todo o caminho down--
vamos ver, na verdade, é que vamos ver isso agora?
Plug-in gerente, não, eu acho que é i-- definitivamente por aqui em algum lugar.
Bem, há uma lista de comandos em algum lugar, mas eu devo ter,
Esqueci-me onde ele está.
Assim, OK, vamos seguir em frente.
Tudo certo.
Portanto, temos uma lista de comandos que estão disponíveis para nós,
e os comandos são estes apenas arbitrária Cloud 9
comandos que executam código específico.
Então, basta manter isso em mente, que nós estamos indo para executar o programa de diálogo
funcionar momentaneamente.
Agora, quando eu realmente quero adicionar um menu item, posso acrescentar esse item por caminho,
e apenas especificar exatamente onde eu quero que seja, Janela / Seminário CS50 Dialog 1.
E nesse ponto, eu quero para criar um novo item
está indo para executar um comando, CS50 Seminário de Diálogo 1.
Observe que, novamente, esta é a Nuvem 9 comando Eu criei um pouco acima.
>> Agora eu também quero criar um pequeno divisor,
e para que eu possa fazer o mesmo na linha subsequente.
Agora você pode notar que como parte da definição deste item de menu,
há um número associada com ele que
realmente diz onde exatamente Eu quero que esse item de menu para ser
localizado na lista de menus.
Mas você pode notar que eu não sei, na verdade,
ver todos os números com estes menus, por padrão.
Portanto, há uma pequena coisa escondida que o que podemos fazer, uma pequena mudança para a nossa URL.
Assim, além de SDK = 1 & debug = 2, Vou definir menu para 1--
e espero que seja de menu, não menus.
Oh, é menus = 1.
Aguente.
>> E o que vamos ver em cima de recarga que IDE é que eu ainda estou no modo de depuração,
mas agora há números associado com todos os menus.
E isso diz a você exatamente o que o número
é quando você está tentando injetar algo em qualquer lugar neste sistema de menu.
Assim, no menu Janela, eu posso veja o item 45 é colaborar,
e ponto 38, antes que seja instalador.
Então, quando eu quiser injectar um item entre os dois,
Gostaria apenas de seleccionar um número entre esses dois elementos.
Então, eu selecionei 41 e inserido meu Seminário Dialog o item 1 do menu naquele local.
>> E é por isso que este número que aparece aqui é o número 41.
Esta é a localização desse item de menu no menu de Cloud 9.
Agora da mesma forma, eu queria para criar um divisor
e adicioná-lo de modo que há um nice divisão entre cada um deles de menu
itens.
Então eu acrescentou que no local 43.
Tão longe, tão bom, eu espero?
Então agora vamos realmente olhar para o código específico na caixa de diálogo mostra
que é realmente responsável para abrir esta janela de diálogo.
>> Rolagem para baixo, vejo que eu quero para ter este diálogo função show,
e é extremamente simples.
Eu estou indo para executar o show método no variável plug-in.
E lembre-se de que nós definimos esta plug-in variável acima como um diálogo.
Assim, o plug-in de barras, neste caso, é este objeto que nós definimos internamente.
E vai ser um novo diálogo contidos neste plug-in.
E assim nós realmente referenciado este plug-in variável em muitos lugares
em um típico Cloud 9 ambiente de desenvolvimento.
>> Vamos vê-lo aqui.
Observe que à medida que rolar para baixo, há ciclos de vida adicionais.
Então, observe que estes respondem para eventos que são acionados
por este objeto, este objeto do diálogo.
Por padrão, não há carregar e descarregar, que
estão disponíveis para todos Nuvem 9 plug-ins.
Mas em caso de este diálogo, não há
Outro evento que pode fogo também chamado
Draw, que é disparado quando isso está prestes a ser desenhado na tela,
em primeira instância do diálogo mostrando.
>> Assim, quando na verdade é vai ser mostrado,
lá vai nos fornecer algum HTML.
E usando apenas padrão Práticas HTML pode nós
injetar algumas informações muito simples, nosso mundo Olá, em que o diálogo.
Então, se nós, em seguida, vá para cima, nós podemos ver, em seguida, a procissão de coisas
que está ocorrendo.
Primeiro, criamos um comando Cloud 9 que, quando executado por Cloud 9,
vai disparar esta função.
Ele está indo para executar essa função chamado show de diálogo, que eu tenho
escrito no meu código.
>> Eu criei um item de menu e anexado a ele que mesmo comando
que, quando esse item é clicado em o menu, que comando é então executado
e que a função é então executado.
E dentro da função que eu sou só vai chamar as-- eu sou
indo só para executar o show método deste plug-in, que
vai primeira chamada o método de sorteio, e vai
para disparar esse método abaixo, o desenhar manipulador de eventos, em nosso ciclo de vida.
E então ele vai realmente mostrar o diálogo.
>> Há também um método de esconder, de modo que se eu precisar a oportunidade de esconder
meu diálogo, eu posso fazer a mesma coisa.
Então, isso é muito bonito isso para obter tudo isso para trabalhar.
Observe que é se deslocar para baixo ainda há uma API pública congelamento.
Este apenas diz, basicamente, que eu quer estes métodos para efetivamente
ser público, mas não overwriteable fora do contexto deste plug-in.
E abaixo, na parte inferior, é, talvez, a última coisa
que realmente precisa pagar muita atenção aos aqui, que
é que vamos registrar o nosso plug-in com o nome de Seminário C9 1,
e o objeto plug-in.
>> Que, como você deve se lembrar, é que plug-in que plug-in
objeto que temos vindo a definição em toda a totalidade dessa fonte
código.
E Seminário C9 1 é o string que prometemos
fornecer no topo desta definição.
ESTÁ BEM.
Então, vamos rampa-lo um pouco e ver se podemos fazer alguma coisa
um pouco mais interessante.
Agora esta é apenas tão grande.
Quero dizer, isso é, é realmente muito arrefecer que em tão poucas linhas de código,
podemos modificar o IDE existente e adicionar um item de menu existente
ou adicionar um novo item de menu, adicionar uma comando e mostrar um diálogo,
e apenas um bando de funcionalidade que existe.
É realmente muito grande.
>> Mas ele não faz muito, porque ele não pode comunicar com o Ubuntu subjacente
exemplo.
Então, digamos que eu realmente quer descobrir
algumas informações sobre o subjacente instância Ubuntu,
como as estatísticas de plug-in faz.
Então, vamos dar uma olhada em um pouco mais de informação
sobre como as estatísticas de plug-in de obras.
E, de facto, é muito semelhante a este.
Você deve se lembrar que há um diálogo.
Você deve se lembrar que não há alguma informação que é
mostrado apenas ao longo da barra de menu ao longo o topo, que espero que você é agora
obter um sabor de como implementamos isso,
apenas através da inserção de itens de menu em específico pontos e pela instanciação de um diálogo
e exibindo esse diálogo.
>> Mas nós ainda não demonstraram como podemos conectá-lo
a um comando no Ubuntu instância subjacente.
Então, vamos dar uma olhada em seguida, em plugin.2, e que faz precisamente isso.
Nós vamos abrir plugin.js, que é o código para isso.
Mas, sob o menu Janela, se eu clicar na caixa de diálogo 2,
podemos ver que ele diz isso em vez disso, Olá CS50, que
não olhar tudo o que atraente, certo?
Exceto, assistir a isto.
Deixe-me mudar alguma coisa aqui embaixo.
>> Eu estou indo para ir para o meu espaço de trabalho e mudança seminário
para dizer algo mais, como Olá, Dan.
Eu vou fechá-lo e salvá-lo.
E agora eu estou indo para re-run meu item de menu diálogo.
E note que ele tem agora mudou o que ele diz.
Olá, Dan.
Eu pareço ter feito alguma coisa para baixo aqui na instância Ubuntu subjacente
sem ter qualquer manipulado código que está sendo executado novamente unicamente
no lado do cliente.
Portanto, há, obviamente, algum tipo de comunicação que está acontecendo aqui.
>> Agora, este é o lugar onde um monte de poder do Cloud 9 SDK vem,
é que, nesse plugin.2, que pode realmente causar
uma chamada para acontecer com o exemplo subjacente,
e executar alguns comandos arbitrários.
Portanto, neste caso, eu tenho realmente criado um script muito simples
na minha área de trabalho chamado Seminário.
Então deixe-me abrir isso.
E podemos ver que se parece com isso.
É só uma festa muito simples roteiro, cujo único objectivo na vida
vai ser a ecoar este texto, Olá, Dan.
Ou, antes disso, ele disse Olá, CS50.
E isso é tudo o que vai fazer.
>> Porque este é agora um comando que eu posso correr.
Eu posso realmente executá-lo aqui.
Podemos ver que ele realmente é apenas um comando que eu corro naturalmente.
Eu posso pedir ao meu plug-in para executar este comando no espaço de trabalho subjacente
e analisar as informações que foi devolvido a partir dele,
e fazer algo com ele, e modificar meu plug-in eo comportamento que eu
ter na minha plug-in como um resultado. ESTÁ BEM.
Então vamos ver como isso acontece.
Vimos isso muito simples Script em lotes seminário que eu
[Inaudível] que ele pode realmente ser executado.
>> E agora vamos ver as modificações que são necessários para amarrar isso juntos
com a janela de diálogo, e executá-lo.
Então aqui nós vamos fazer muito muito a mesma coisa que vimos antes.
Mas note que entre os coisas que eu consumidos agora--
em adição ao diálogo, que novamente acontecer de eu ter feito duas vezes,
que não é necessary-- além para o diálogo e os comandos
e os menus os plug-ins, que foram necessário, em primeiro um para me
para definir um novo comando e injetar um item nos menus,
Eu também tenho esse proc plug-in.
>> E este proc plug-in permite que nós para manipular processos
no exemplo subjacente.
Eu conectá-lo depois que eu disse que o meu plug-in exige.
Eu, em seguida, conectá-lo ao código, como vimos na função principal.
Mais uma vez, eu vou inicializar meu diálogo.
E se nós nos movemos para baixo agora, pode ver como isso é diferente.
A função de carga é a mesma, então ele só vai para criar um comando
e criar um item de menu e conecte esse item de menu para esse comando.
Mas se agora rolar para baixo para mostrar o diálogo,
podemos começar a ver onde as diferenças surgem.
>> Temos função show de diálogo, que está indo só para mostrar o diálogo.
Mas quando eu mostrar este diálogo, e quando o método show é chamado,
ele aciona a função draw.
E eu vou especificar, em seguida, algum conteúdo dentro do que isso.
Então, eu estou indo só para criar um div, fornecer a ele
algum texto básico, Olá, mundo.
Mas note que aqui eu sou vai anexar a ele uma identificação.
E a linha seguinte eu vou ao descobrir que ID usando JavaScript,
e armazenar esse objeto em outra variável
que eu estou indo só para chamar conteúdo.
>> Então, agora sempre que eu tenho conteúdo, tudo que eu preciso fazer
é apenas modificar HTML interior deste objeto.
E o diálogo vai HTML em seguida, ser modificado, bem.
Assim, quando este plug-in é então mostradas, o que pode acontecer
e este é um novo evento que é novo para este plug-in,
mas acontece em todos os plug-in com o diálogo, quando este é agora mostrado,
Eu vou chamar um função chamada buscar informações.
E esta função é a carne dele aqui.
Vou usar esse plug-in que proc descrevemos antes, que por sinal,
é realmente apenas uma biblioteca Node.js que Cloud 9 está usando aqui.
>> Então você pode realmente olhar para cima sobre como este
funciona se você ir para o Documentação Node.js
e olhar para cima o arquivo exec método para processos de lá.
Eu estou indo para executar este específico comando, casa Ubuntu espaço de trabalho
seminário, que é a mesma, isto mesmo comando que eu criei antes.
Fornecer a ele uma corrente diretório de trabalho, apenas
para ser seguro em termos de ultra-a contexto de onde este está em execução.
E uma vez que tem sido preenchido e devolvido,
Eu estou indo para executar este função chamada de saída de análise.
ESTÁ BEM.
Portanto, este, em seguida, vai para executar um comando no local, ou melhor,
a instância remota Ubuntu.
Quando eu voltar alguns informação, eu sou em seguida,
vai chamar uma função separada chamado de saída de análise, que
tem essa assinatura aqui, err, stdout, stderr,
e realizar alguns cálculos sobre isso.
Então, se eu recebi um erro de algum tipo de todo,
Eu realmente verificar para ver se erro na verdade tem alguns dados.
E se assim for, então eu vou modificar o interior HTML do objeto de conteúdo, que
é você lembrar, nós ligado ao diálogo
no instantiattion desse diálogo, ou no primeiro desenho
de que o diálogo.
Vou apenas dizer que algum erro aconteceu.
>> Agora este é demasiado simplista.
O valor de erro será tipicamente conter algo que fosse útil,
talvez um número de erro e uma erro do próprio script.
Ou se o script escreveu algo para o erro padrão,
que os dados seriam preenchidos em que o parâmetro bem.
E eu poderia ser um pouco mais cuidado com o erro
Na verdade, estou mostrando pessoas.
Mas este exemplo simplista é bom o suficiente para agora
para, pelo menos, ver como tudo isso funciona.
Caso contrário, se houver nenhum erro, então eu sou apenas
vai fornecer a matéria- saída do que a função
no interior do HTML este conteúdo elemento, e, em seguida, atualizar o meu plug-in
e mostrá-lo aqui.
E isso é muito bonito tudo o que é necessária para obter este para ser executado.
E então vamos pensar em seguida, como isso funciona, em geral.
Quando eu carregado pela primeira vez este plug-in, assim como o primeiro plug-in,
Eu estou indo para adicionar um comando que é disponível para qualquer coisa, a qualquer plug-in
em Cloud 9, chamado Seminário CS50 Diálogo 2, cuja responsabilidade
será para executar este show diálogo, que é você se lembra,
vai mostrar realmente o diálogo que eu solicitadas abaixo.
>> Então eu vou acrescentar que comando em um menu de janela
para que eu tenha acesso a isso.
E quando esse diálogo é solicitado para ser mostrado,
Vou buscar algumas informações de a instância do Ubuntu subjacente
usando o comando arquivo exec.
Com licença.
Uma vez que é retornado e eu receber algum informações, em seguida, no lado do cliente
de novo, vou ser capaz de analisar a saída do comando
e atualizar o interior HTML dos elementos
que tinham ligado a anterior.
>> E com isso, então temos esta totalmente funcional plug-in
que me permite buscar informações desse script arbitrário
que criamos em nossa instância subjacente.
Mas, novamente, é realmente importante e realmente chave
de forma a separar cada onde dessas coisas está acontecendo,
que temos tudo isso do lado do cliente código que está sendo executado no navegador,
e que ainda não têm acesso para o sistema de arquivos subjacente
até que nós realmente executar alguns destes comandos que são fornecidos pela nuvem
9 SDK como proc, e alguns outros que nos permitem ler alguns dados,
ou ler alguns arquivos se precisarmos para fazer qualquer coisa do tipo.
>> Agora, este é um exemplo um tanto simples.
Há outras coisas que nós talvez queira fazer também.
Por exemplo, talvez nós realmente deseja salvar algumas informações
com as preferências.
Ou talvez nós queremos adicionar um novo painel de preferências
ou algo nesse sentido.
Então, isso é algo que você pode dar uma olhada no Cloud 9 SDK
para obter mais informações sobre.
Mas isso é realmente o suficiente para começar.
Então, só para ser um pouco mais concreto sobre a maneira que algumas destas coisas
função, eu queria mostrar apenas mais um exemplo, que é apenas alguns
do código do Stats 50 plug-in.
>> E esse código é basicamente Com base nestes exemplos
que você realmente visto, mas tem mais algumas salvaguardas
e tem mais alguma complexidade, a fim para alcançar algumas das coisas adicionais
que queremos alcançar.
Por exemplo, se eu quero ser capaz de salvar algumas configurações,
então eu preciso para ter acesso para as configurações de plug-in,
e cada vez que eu quero para ler algumas configurações,
Posso, por exemplo, anexar a vários eventos nas configurações do plug-in.
Então, toda vez que as definições é vermelho, por exemplo, na minha própria plug-in,
se eu vou ler alguns configurações do armazenamento salvos
preferências do usuário, então eu posso definir padrões para um local específico,
de preferência específica, em que JSON arquivo de opções de estilo que nós temos
salvou anteriormente, que já vimos antes.
>> E se eu vou escrever algumas configurações para ele,
então eu can-- ou assim que detectar que as definições foram escritos
a-- porque, por exemplo, aqueles configurações foram modificadas pelo usuário
quer directamente nas suas definições arquivo, ou no painel de preferências
mudou as configurações arquivo diretamente,
Eu posso realmente atualizar parte do código ou atualizar o comportamento do meu plug-in
com base nesses mudanças que têm ocorreu no arquivo de configurações também.
Mas, realmente, o resto é bastante muito presente que você já viu.
>> Nós adicionamos alguns, talvez algo que é novo.
Por isso, adicionar um arquivo de preferência, ou melhor, um painel de preferências,
para a janela de preferências, o que novamente você pode encontrar mais informações
no Cloud 9 SDK me ler.
Mas tudo o resto é muito bonito, bonito
semelhante ao que vimos antes, apenas com alguma verificação de erros adicional
e algumas proteções adicionais e alguma funcionalidade adicional
para aplicar todas as várias coisas que temos visto.
Se você não tem, na verdade, viu ainda, você pode
estar se perguntando o que o subjacente comando é na janela de Estatísticas 50.
É, na verdade função.
Bem, isso é-- oh, caramba.
Um segundo.
Aguente.
ESTÁ BEM.
Deixe-me passar isso para que possamos realmente ver o que acontece quando digito Stats 50.
Note-se que neste caso, o comando que eu estou fora putting
é realmente novo, só o script que é indo para a saída de um monte de informações
no formato JSON.
E a razão que fazemos desta maneira é que, porque
estão operando, porque nós escrevemos o código do lado do cliente em JavaScript,
nós podemos muito facilmente apenas analisar objetos JavaScript,
e realmente ser capaz de manipular esses objetos apenas como faríamos
qualquer outro objeto JavaScript.
>> E assim, este é um muito conveniente maneira de fornecer algumas informações
da instância Ubuntu subjacente, tais como o número da versão, o anfitrião
nomear, se um servidor está escutando, o que o servidor é, assim por diante e assim por diante,
e analisar que muito facilmente e muito rapidamente
no plug-in que está indo, em seguida, para nos mostrar toda essa informação.
Então, novamente, o insight chave aqui para manter em mente
É esta separação entre o exemplo subjacente,
e também onde o código está sendo carregado.
Que quando eu tenho um cliente, é o primeiro carregamento.
Apenas este arquivo JavaScript estática em algum lugar, talvez CDN de algum tipo.
Nós realmente não precisa se preocupar muito sobre esse primeiro passo.
>> Nós só sabemos que é em execução no lado do cliente
e é aí que eu vou comunicar-se com esta instância estivador.
Isso nós vamos fazê-lo através da Cloud 9 SDK.
Nós realmente não têm a capacidade, usando JavaScript ou Node.js,
para escrever diretamente para ele.
Nós apenas usar aqueles SDK existente APIs para fazer essa ação para nós.
E novamente, um dos coisas realmente importantes
é que, quando eu criei este, quando eu criei este plug-in,
e como eu estou trabalhando nele, em um das coisas importantes a fazer
é trazer o console JavaScript.
>> Porque uma vez que este é tudo operando no JavaScript,
no lado do cliente, se eu usar um console.log method-- então apenas
para mostrar um exemplo aqui.
Vamos tentar modificar este simples plug-in para também registrar alguns dados.
E nós vamos adicionar a norma.
Então vamos mudar isso para estar bem aqui.
Agora, quando eu executar console.log, tenha em mente
desde que este esteja a executar no lado do cliente,
Vou ver isso no meu próprio JavaScript console, que
é como eu, então, ser capaz de tentar solucionar problemas e depurar
alguns dos problemas que eu tenho.
>> Note-se que porque Estou em modo SDK, eu sou
então, capaz de manipular Plug-ins nesta instância.
Então, mesmo que seja salvo no caso em apreço,
este é o único exemplo de que anterior regra a ser violados, onde o Cloud 9
SDK vai realmente puxar plug-ins do subjacente instância e, em seguida, executá-los.
Para que, desta forma, então eu sou capaz de manipular e construir
alguns plug-ins aqui.
Mas para me ver atualizações para este plug-in,
porque é no lado do cliente, Eu preciso salvar o plug-in
e depois recarregar todo o espaço de trabalho, de modo a que o plug-in novo é então
baixado para o meu cliente, para o meu navegador web, e, em seguida, está sendo usado.
>> Então agora quando eu clicar neste Seminário Diálogo 2, ainda vemos isso.
Mas agora espero que na minha JavaScript diálogo, que se ver meu-- esperar,
aguente.
Eu poderia ter de abrir o diálogo fresco.
Devemos ver os meus dados recebidos aqui.
Os dados recebidos, olá, Dan, que é você se lembra,
era uma operação que console.log foi solicitada no plug-in.
Portanto, esta descrição, em seguida, que eu mencionei antes,
este diálogo, ou este diagrama vez, que eu
mencionado antes é o que acontece.
Mas há uma importante exceção apenas para o desenvolvimento,
que é que o plug-in em si pode, na verdade,
ser armazenados na instância janela de encaixe temporariamente, uma vez que presumivelmente Nuvem 9
não querem que sejamos capazes de manipular objetos na sua CDN.
>> E a nuvem 9 clientes, após o carregamento, vai encontrar os plug-ins em que.
Plug-in C9 pasta e carregar esses.
Mas aqueles que ainda estão acontecendo apenas no lado do cliente.
Então, em seguida, esta é apenas a uma excepção de que ocorre apenas
para o desenvolvimento de Cloud 9 plug-ins.
Mas o resto do tempo-- ea razão
que queremos realmente martelar este casa--
é porque a maioria das vezes isso é indo para ser executado a partir do CDN,
e só vai ser executado puramente do lado do cliente.
>> Normalmente, não haverá interacção com o plug-in,
ou não tem sequer a ser qualquer razão que se os plug-ins
são efectivamente armazenados na subjacente instância janela de encaixe,
excepto no caso de este desenvolvimento SDK.
Então, novamente, isso muda apenas ligeiramente devido ao facto
que estamos executando o modo SDK.
Vai então carregar os plug-ins de desenvolvimento,
e o único propósito de modo que é aqui Eu posso usar Cloud 9 para fazer o desenvolvimento
para Cloud 9 plugins.
Mas, mesmo assim, isso não muda novamente como isso funciona.
Ele ainda está sendo executado inteiramente no lado do cliente.
>> Isso apenas significa que sempre que eu quero criar Cloud 9 plug-ins em Cloud 9,
Eu criar esses plug-ins, colocá-los no meu.
Pasta / plugins C9 em minha casa diretório, certifique-se de que eu estou no modo SDK,
recarregar a página toda vez que eu realmente fazer alterações para que plug-in,
e ver o que acontece no meu console JavaScript.
Apenas gerir a minha JavaScript Console para certificar-se de
que qualquer solução de problemas informação que eu coloque para consolar,
ou qualquer outra coisa que possa ocorrer por causa de erros que eu escrevi
no meu código ou semelhantes, aparece lá.
>> E com isso, é realmente o suficiente para começar, eu acho,
com a nuvem 9 plug-ins.
Especialmente tendo um olhar para o SDK documentação que Cloud 9 oferece.
É uma ótima maneira de começar iniciado, e de forma muito fácil
criar alguns plug-ins para Cloud 9.
E com isso, eu quero agradecer a todos muito para se juntar a mim.
Espero que você vai se divertir escrever plug-ins para Cloud 9.
Melhorar Talvez plug-ins que temos agora, ou talvez mesmo
adicionando algumas funcionalidades de seu próprio país.
Estamos ansiosos para vê- o que é que você cria.
Até então, tchau.