class= " lineNumbers " do
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
|
class= do
o class= " do id= " codeSnippet686305 do neste caso, tudo que nós precisamos está no pacote de javax.tv.xlet. Para mais complexo
exemplos de // nós igualmente importaríamos classes de org.dvb.* e dos outros APIs de MHP ou de Java.
importação javax.tv.xlet.*;
// a classe principal de cada Xlet deve executar esta relação - se não faz esta,
// a computação distribuída de MHP não pode funcioná-la.
a classe pública FirstXletExample executa javax.tv.xlet. Xlet
{
// cada Xlet tem um contexto de Xlet, apenas como o contexto do applet esse applet em a
o Web page de // é dado. Isto é criado pela computação distribuída de MHP e passado dentro ao
// Xlet como um parâmetro ao método do initXlet ().
contexto confidencial de javax.tv.xlet.XletContext;
Campo confidencial de // A para prender o estado atual. Isto é necessário porque o startXlet ()
o método de // é chamado para começar pela primeira vez o Xlet e para fazer igualmente
Resumo de // Xlet do estado pausado. Isto arquivado deixa-nos manter-se a par se nós somos
// que começa pela primeira vez.
bôoleano confidencial hasBeenStarted;
/**
* Cada Xlet deve ter um construtor do defeito que não tome nenhum argumento.
* Nenhum outro construtor começ chamado.
*
FirstXletExample público ()
{
// o construtor deve não conter nada. Alguma iniciação
// deve ser feito no método do initXlet (), ou no método do startXlet
// se é time- ou recurso-intensivo. Essa maneira, a computação distribuída de MHP
// pode controlar quando a iniciação acontece muito em um mais predizível
maneira de //
}
/**
* Inicializar o Xlet. O contexto para este Xlet começ passado dentro a este
* o método, e uma referência a ele devem ser armazenados caso que tem mais atrasado necessário.
* Este é o lugar onde toda a iniciação deve ser feita, a menos que tomar
* muito tempo ou recursos. Se algo vai mal, então
* XletStateChangeException deve começ jogado para deixar o sistema runtime saber
* que o Xlet não pode ser inicializado.
*
o initXlet vago do público (contexto de javax.tv.xlet.XletContext) joga javax.tv.xlet.XletStateChangeException
{
loja de // uma referência ao contexto de Xlet que o Xlet está executando dentro
this.context = contexto;
// o Xlet não tem sido começado ainda pela primeira vez, assim que jogo
// esta variável a falso.
hasBeenStarted = falso;
// desde que este é um Xlet simples, nós apenas imprimiremos uma mensagem à saída da eliminação de erros
System.out.println (“o método do initXlet () foi chamado. Nosso contexto de Xlet é” + contexto);
}
/**
* Começar o Xlet. Neste momento o Xlet pode indicar-se na tela e
* começar interagir com o usuário, ou fazer todas as tarefas recurso-intensivas. Estes
* os tipos da função devem ser mantidos no startXlet (), e devem *not* ser feitos
* no initXlet ().
*
* Como com initXlet (), se há qualquer problema este método deve jogar
* XletStateChangeException para dizer ao sistema runtime que não pode começar.
*
* Uma das armadilhas comuns é que o método do startXlet () deve retornar ao seu
* chamador. Isto significa que as funções principais do Xlet devem ser feitas dentro
* outros linha. O método do startXlet () deve realmente apenas criar essa linha
* e começá-lo, a seguir retornar.
*
o startXlet vago do público () joga javax.tv.xlet.XletStateChangeException
{
// outra vez, nós imprimimos uma mensagem na saída da eliminação de erros para dizer ao usuário aquele
// algo está acontecendo. Neste caso, o que nós imprimimos depende de
// se o Xlet está começando pela primeira vez, ou se é
// pausado e está recomeçando
// nós fomos começados?
se (hasBeenStarted) {
System.out.println (“o método do startXlet () estêve chamado para recomeçar o Xlet depois que foi pausado. Olá! outra vez, mundo! ");
}
mais {
System.out.println (“o método do startXlet () foi chamado para começar pela primeira vez o Xlet. Olá!, mundo! ");
// ajusta a variável que nos diz que nós estivemos começados realmente
hasBeenStarted = retificar;
}
}
/**
* Pausa o Xlet. Infelizmente, não é desobstruído a qualquer um (including
* povos que escreveram a especificação de MHP) o que esta significa. Geralmente, ele
* significa que o Xlet deve livrar todos os recursos escassos que se está usando,
* parar todas as linhas desnecessárias e remover-se da tela.
*
* Ao contrário dos outros métodos, o pauseXlet () não pode jogar uma exceção para indicar
* um problema com estado em mudança. Quando o Xlet for dito para pausar próprio, ele
* deve fazer isso.
*
pauseXlet vago do público ()
{
// desde que nós não não temos nada pausar, nós diremos ao usuário que nós somos
// que pausa pela impressão uma mensagem na saída da eliminação de erros.
System.out.println (“o método do pauseXlet () foi chamado. Horas de dormir… ");
}
/**
* Parar o Xlet. O parâmetro bôoleano diz o método se o Xlet tem que
* obedecer este pedido. Se o valor do parâmetro é verdadeiro, o Xlet deve terminar
* e o sistema runtime supor que quando o método retorna, o Xlet tem
* terminado. Se o valor f o parâmetro é falso, o Xlet pode pedir que ele
* para não ser matado, jogando um XletStateChangeException. se a computação distribuída de MHP
* ainda quer matar o Xlet, ele deve chamar o destroyXlet () outra vez com
* parâmetro ajustado para retificar.
*
o destroyXlet vago do público (incondicional bôoleano) joga javax.tv.xlet.XletStateChangeException
{
se (incondicional) {
// nós fomos requisitados terminar, assim que nós obedecemos a ordem polidamente e liberamos alguns
recursos de //scarce que nós estamos prendendo.
System.out.println (“o método do destroyXlet () foi chamado dizer o Xlet para parar incondicional. Adeus, mundo cruel! ");
}
mais {
// nós tivemos um pedido polido morrer, assim que nós podemos recusar este pedido se nós queremos.
System.out.println (“o método do destroyXlet () foi chamado pedir que a aplicação para, mas lhe dar a escolha. Assim, eu decidirei não a stop.");
// que joga um XletStateChangeException diz a computação distribuída de MHP que
a aplicação de // gostaria de manter-se funcionar se permitiu a.
lance XletStateChangeException novo (“por favor não me matar! ");
}
}
}
|
