Soquetes

O arquivo TelnetSocket.mxml principal é responsável por criar a interface do usuário (UI) para o aplicativo inteiro.

Além da UI, esse arquivo também define dois métodos, login() e sendCommand(), para conectar o usuário ao servidor especificado.

O código a seguir lista o ActionScript no arquivo principal do aplicativo:

import com.example.programmingas3.socket.Telnet; 
 
private var telnetClient:Telnet; 
private function connect():void 
{ 
    telnetClient = new Telnet(serverName.text, int(portNumber.text), output); 
    console.title = "Connecting to " + serverName.text + ":" + portNumber.text; 
    console.enabled = true; 
} 
private function sendCommand():void 
{ 
    var ba:ByteArray = new ByteArray(); 
    ba.writeMultiByte(command.text + "\n", "UTF-8"); 
    telnetClient.writeBytesToSocket(ba); 
    command.text = ""; 
}

A primeira linha de código importa a classe Telnet do pacote com.example.programmingas.socket personalizado. A segunda linha de código declara uma instância da classe Telnet, telnetClient, que é inicializada posteriormente pelo método connect(). Em seguida, o método connect() é declarado e inicializa a variável telnetClient declarada anteriormente. Esse método transmite o nome do servidor telnet especificado pelo usuário, a porta do servidor telnet e uma referência a um componente TextArea na lista de exibição que é usada para exibir as respostas de texto do servidor de soquete. As duas linhas finais do método connect() definem a propriedade title do Painel e ativam o componente Painel, o que permite que o usuário envie dados ao servidor remoto. O método final no arquivo principal do aplicativo, sendCommand(), é usado para enviar os comandos do usuário ao servidor remoto como um objeto ByteArray.

A classe Telnet é responsável por conectar-se ao servidor Telnet remoto e enviar/receber dados.

A classe Telnet declara as seguintes variáveis particulares:

private var serverURL:String; 
private var portNumber:int; 
private var socket:Socket; 
private var ta:TextArea; 
private var state:int = 0;

A primeira variável, serverURL, contém o endereço do servidor especificado pelo usuário ao qual conectar-se.

A segunda variável, portNumber, é o número da porta na qual o servidor Telnet está em execução atualmente. Por padrão, o serviço Telnet é executado na porta 23.

A terceira variável, socket, é uma instância de Socket que tentará conectar-se ao servidor definido pelas variáveis serverURL e portNumber.

A quarta variável, ta, é uma referência a uma ocorrência do componente TextArea no Palco. Esse componente é usado para exibir respostas do servidor Telnet remoto ou qualquer mensagem de erro possível.

A variável final, state, é um valor numérico usado para determinar quais opções são suportadas pelo cliente Telnet.

Conforme visto anteriormente, a função do construtor da classe Telnet é chamada pelo método connect() no arquivo principal do aplicativo.

O construtor Telnet utiliza três parâmetros: server, port e output. Os parâmetros server e port especificam o nome do servidor e o número da porta em que o servidor Telnet está executando. O parâmetro final, output, é uma referência a uma instância do componente TextArea no Palco onde a saída do servidor é exibida aos usuários.

public function Telnet(server:String, port:int, output:TextArea) 
{ 
    serverURL = server; 
    portNumber = port; 
    ta = output; 
    socket = new Socket(); 
    socket.addEventListener(Event.CONNECT, connectHandler); 
    socket.addEventListener(Event.CLOSE, closeHandler); 
    socket.addEventListener(ErrorEvent.ERROR, errorHandler); 
    socket.addEventListener(IOErrorEvent.IO_ERROR, ioErrorHandler); 
    socket.addEventListener(ProgressEvent.SOCKET_DATA, dataHandler); 
    Security.loadPolicyFile("http://" + serverURL + "/crossdomain.xml"); 
    try 
    { 
        msg("Trying to connect to " + serverURL + ":" + portNumber + "\n"); 
        socket.connect(serverURL, portNumber); 
    } 
    catch (error:Error) 
    { 
        msg(error.message + "\n"); 
        socket.close(); 
    } 
}

Para gravar dados em uma conexão de soquete, você pode chamar qualquer um dos métodos de gravação da classe Socket. Entre esses métodos de gravação estão os seguintes: writeBoolean(), writeByte(), writeBytes(), writeDouble() e outros. Então, esvazie os dados do buffer de saída usando o método flush(). No servidor Telnet, os dados são gravados na conexão de soquete usando o método writeBytes() que utiliza a matriz de bytes como um parâmetro e envia-a ao buffer de saída. O método writeBytesToSocket() é o seguinte:

public function writeBytesToSocket(ba:ByteArray):void 
{ 
    socket.writeBytes(ba); 
    socket.flush(); 
}

Esse método é chamado pelo método sendCommand() do arquivo principal do aplicativo.

Sempre que uma mensagem é recebida do servidor de soquete, ou ocorre um evento, o método msg() personalizado é chamado. Esse método anexa uma sequência de caracteres ao TextArea no Palco e chama um método setScroll() personalizado, o que faz com que o componente TextArea role para a parte inferior. O método msg() é o seguinte:

private function msg(value:String):void 
{ 
    ta.text += value; 
    setScroll(); 
}

Se você não rolou automaticamente o conteúdo do componente TextArea, os usuários precisarão arrastar manualmente as barras de rolagem na área de texto para ver a resposta mais recente do servidor.

O método setScroll() contém uma única linha do ActionScript que rola o conteúdo do componente TextArea verticalmente de forma que o usuário possa ver a última linha do texto retornado. O seguinte snippet mostra o método setScroll():

public function setScroll():void 
{ 
    ta.verticalScrollPosition = ta.maxVerticalScrollPosition; 
}

Esse método define a propriedade verticalScrollPosition, que é o número da linha superior de caracteres exibida atualmente, e define-a como o valor da propriedade maxVerticalScrollPosition.

O código a seguir demonstra um servidor XMLSocket simples criado em Java que aceita conexões de entrada e exibe as mensagens recebidas na janela do prompt de comando. Por padrão, um novo servidor é criado na porta 8080 da máquina local, embora você possa especificar um número de porta diferente quando iniciar o servidor a partir da linha de comando.

Crie um novo documento de texto e adicione o seguinte código:

import java.io.*; 
import java.net.*; 
 
class SimpleServer 
{ 
    private static SimpleServer server; 
    ServerSocket socket; 
    Socket incoming; 
    BufferedReader readerIn; 
    PrintStream printOut; 
 
    public static void main(String[] args) 
    { 
        int port = 8080; 
 
        try 
        { 
            port = Integer.parseInt(args[0]); 
        } 
        catch (ArrayIndexOutOfBoundsException e) 
        { 
            // Catch exception and keep going. 
        } 
 
        server = new SimpleServer(port); 
    } 
 
    private SimpleServer(int port) 
    { 
        System.out.println(">> Starting SimpleServer"); 
        try 
        { 
            socket = new ServerSocket(port); 
            incoming = socket.accept(); 
            readerIn = new BufferedReader(new InputStreamReader(incoming.getInputStream())); 
            printOut = new PrintStream(incoming.getOutputStream()); 
            printOut.println("Enter EXIT to exit.\r"); 
            out("Enter EXIT to exit.\r"); 
            boolean done = false; 
            while (!done) 
            { 
                String str = readerIn.readLine(); 
                if (str == null) 
                { 
                    done = true; 
                } 
                else 
                { 
                    out("Echo: " + str + "\r"); 
                    if(str.trim().equals("EXIT")) 
                    { 
                        done = true; 
                    } 
                } 
                incoming.close(); 
            } 
        } 
        catch (Exception e) 
        { 
            System.out.println(e); 
        } 
    } 
 
    private void out(String str) 
    { 
        printOut.println(str); 
        System.out.println(str); 
    } 
}

Salve o documento no disco rígido como SimpleServer.java e o compile usando um compilador Java, que cria um arquivo de classe Java chamado SimpleServer.class.

Você pode iniciar o servidor XMLSocket abrindo um prompt de comando e digitando java SimpleServer. O arquivo SimpleServer.class pode ser colocado em qualquer lugar do computador local ou da rede; não é necessário colocá-lo no diretório raiz do servidor Web.

Se você não puder iniciar o servidor porque os arquivos não estão localizados dentro do caminho de classe Java, tente iniciar o servidor com java -classpath. SimpleServer.

Para se conectar ao XMLSocket do aplicativo , é necessário criar uma nova ocorrência da classe XMLSocket, e chamar o método XMLSocket.connect() ao transmitir um nome do host e um número de porta, da seguinte maneira:

var xmlsock:XMLSocket = new XMLSocket(); 
xmlsock.connect("127.0.0.1", 8080);

Sempre que você receber dados do servidor, o evento data (flash.events.DataEvent.DATA) é despachado:

xmlsock.addEventListener(DataEvent.DATA, onData); 
private function onData(event:DataEvent):void 
{ 
    trace("[" + event.type + "] " + event.data); 
}

Para enviar dados ao servidor XMLSocket, use o método XMLSocket.send() e transmita um objeto ou string XML. O Flash Player converte o parâmetro fornecido em um objeto String e envia o conteúdo ao servidor XMLSocket seguido de um byte zero (0):

xmlsock.send(xmlFormattedData);

O método XMLSocket.send() não retorna um valor que indica se os dados foram transmitidos com êxito. Se houve um erro durante a tentativa de enviar dados, é gerado um erro IOError.

Cada mensagem enviada ao servidor de soquete XML deve ser terminada por uma nova linha (caractere \n).

Para obter mais informações, consulte XMLSocket.