Grundläggande om nätverk och kommunikation

Flash Player 9 och senare, Adobe AIR 1.0 och senare

När du skapar program i Flash Player eller AIR behöver du ofta ha tillgång till resurser utanför programmet. Du kanske till exempel vill skicka en begäran för en bild på en webbserver på Internet och få tillbaka bildens data. Eller så kanske du vill skicka serialiserade objekt fram och tillbaka via en socketanslutning med en programserver. API:erna i Flash Player och AIR innehåller klasser som gör det möjligt för dina program att delta i den här överföringen. Dessa API:er stöder IP-baserade nätverk för protokoll som UDP, TCP, HTTP, RTMP och RTMFP.

Följande klasser kan användas för att skicka och ta emot data över ett nätverk:

Klass

Dataformat som stöds

Protokoll

Beskrivning

Loader

SWF, PNG, JPEG, GIF

HTTP, HTTPS

Läser in datatyper som stöds och konverterar dessa data till ett visningsobjekt.

Se Dynamisk inläsning av visningsinnehåll.

URLLoader

Alla (text, XML, binära filer o.s.v.)

HTTP, HTTPS

Läser in arbiträra dataformat. Programmet ansvarar för tolkningen av data.

Se Använda klassen URLLoader

FileReference

Alla

HTTP

Överföra och hämta filer.

Se Använda klassen FileReference

NetConnection

Video, ljud, ActionScript Message Format (AMF)

HTTP, HTTPS, RTMP, RTMFP

Ansluter till video-, ljud- och fjärrobjektströmmar.

Se Arbeta med video.

Sound

Ljud

HTTP

Läser in och spelar upp ljudformat som stöds.

Se Läsa in externa ljudfiler.

XMLSocket

XML

TCP

Överför XML-meddelanden med en XMLSocket-server.

Se XML-socketar.

Socket

Alla

TCP

Ansluter till en TCP-socketserver.

Se Binära klientsocketar.

SecureSocket (AIR)

Alla

TCP med SSLv3 eller TLSv1

Ansluter till en TCP-socketserver som kräver SSL- eller TLS-säkerhet.

Se Säkra klientsocketar (AIR).

ServerSocket (AIR)

Alla

TCP

Fungerar som en server för inkommande TCP-socketanslutningar.

Se Serversocketar.

DatagramSocket (AIR)

Alla

UDP

Skickar och tar emot UDP-paket.

Se UDP-socketar (AIR)

När du skapar ett webbprogram kan det ofta vara användbart att kontinuerligt lagra information om användarens programläge. HTML-sidor och program använder vanligtvis cookies för det. I Flash Player kan klassen SharedObject användas för detta. Se Delade objekt. (Klassen SharedObject kan användas i AIR-program, men det är färre begränsningar när data helt enkelt sparas till en vanlig fil.)

När ditt Flash Player- eller AIR-program behöver kommunicera med ett annat Flash Player- eller AIR-program på samma dator kan du använda klassen LocalConnection. Till exempel kan två (eller flera) SWF-filer på samma webbsida kommunicera sinsemellan. På samma sätt kan en SWF-fil som körs på en webbsida kommunicera med ett AIR-program. Se Kommunicera med andra Flash Player- och AIR-instanser.

Om du behöver kommunicera med annat än SWF-filer på den lokala datorn kan du använda klassen NativeProcess i AIR 2. Med hjälp av klassen NativeProcess kan ditt AIR-program starta och kommunicera med andra program. Se Kommunicera med interna processer i AIR.

Om du behöver information om nätverksmiljön för den dator på vilken ett AIR-program körs kan du använda följande klasser:

  • NetworkInfo – Ger information om de tillgängliga nätverksgränssnitten, till exempel datorns IP-adress. Se Nätverksgränssnitt.

  • DNSResolver – Gör att du kan söka efter DNS-poster. Se DNS-poster (Domain Name System).

  • ServiceMonitor – Låter dig övervaka tillgängligheten för en server. Se Tjänstövervakning.

  • URLMonitor – Låter dig övervaka tillgängligheten för en resurs på en viss URL. Se HTTP-övervakning.

  • SocketMonitor och SecureSocketMonitor – Låter dig övervaka tillgängligheten för en resurs vid en socket. Se Socketövervakning.

Viktiga termer och begrepp

Följande referenslista innehåller viktiga termer som du kommer att stöta på när du programmerar nätverks- och kommunikationskod:

Externa data
Data som lagras i någon form utanför programmet och som läses in till programmet vid behov. Dessa data kan lagras i en fil som läses in direkt, eller också kan de lagras i en databas eller i någon annan form som hämtas genom att anropa skript eller program som körs på en server.

URL-kodade variabler
Med det URL-kodade formatet kan flera variabler (par av variabelnamn och -värden) representeras i en enskild textsträng. De enskilda variablerna skrivs i formatet namn=värde. Varje variabel (d.v.s. varje par av namn–värde) avgränsas med et-tecken på följande sätt: variabel1=värde1&variabel2=värde2. På så sätt kan ett oändligt antal variabler skickas som ett enda meddelande.

MIME-typ
En standardkod som används för att identifiera typen för en viss fil vid Internet-kommunikation. Varje filtyp har en särskild kod som används för att identifiera den. När en fil eller ett meddelande skickas, kommer en dator (som en webbserver eller en användares Flash Player- eller AIR-instans) att ange vilken typ av fil som skickas.

HTTP
Hypertext Transfer Protocol är ett standardformat för att skicka webbsidor och andra typer av innehåll på Internet.

Metod för begärande
När ett program (till exempel ett AIR-program eller en webbläsare) skickar ett meddelande (som kallas för HTTP-begäran) till en webbserver, kan de data som skickas vara inbäddade i begäran på ett av två olika sätt. Dessa båda sätt är de två förfrågningsmetoderna GET och POST. På servern kommer det program som tar emot begäran att behöva undersöka lämplig del av begäran för att hitta data. Därför måste den förfrågningsmetod som används för att skicka data från programmet överensstämma med den förfrågningsmetod som används för att läsa data på servern.

Socketanslutning
En beständig anslutning för kommunikation mellan två datorer.

Skicka
Skicka en fil till en annan dator.

Hämta
Hämta en fil från en annan dator.

Nätverksgränssnitt

Du kan använda NetworkInfo-objektet för att identifiera de nätverksgränssnitt för hårdvara och mjukvara som finns tillgängliga för programmet. NetworkInfo-objektet är ett singleton-objekt, du behöver inte skapa något. Använd i stället den statiska klassegenskapen networkInfo om du vill komma åt det enskilda NetworkInfo-objektet. NetworkInfo-objektet skickar också en networkChange-händelse när något av de tillgängliga gränssnitten ändras.

Anropa metoden findInterfaces() för att hämta en lista med NetworkInterface-objekt. Varje NetworkInterface-objekt i listan beskriver ett av de tillgängliga gränssnitten. NetworkInterface-objektet tillhandahåller sådan information som IP-adress, maskinvaruadress, största överföringsenhet och om gränssnittet är aktivt eller inte.

I följande kodexempel spåras NetworkInterface-egenskaper för alla gränssnitt på klientdatorn:

package { 
import flash.display.Sprite; 
import flash.net.InterfaceAddress; 
import flash.net.NetworkInfo; 
import flash.net.NetworkInterface; 
 
public class NetworkInformationExample extends Sprite 
{ 
    public function NetworkInformationExample() 
    { 
        var networkInfo:NetworkInfo = NetworkInfo.networkInfo; 
        var interfaces:Vector.<NetworkInterface> = networkInfo.findInterfaces(); 
         
        if( interfaces != null ) 
        { 
            trace( "Interface count: " + interfaces.length ); 
            for each ( var interfaceObj:NetworkInterface in interfaces ) 
            { 
                trace( "\nname: "             + interfaceObj.name ); 
                trace( "display name: "     + interfaceObj.displayName ); 
                trace( "mtu: "                 + interfaceObj.mtu ); 
                trace( "active?: "             + interfaceObj.active ); 
                trace( "parent interface: " + interfaceObj.parent ); 
                trace( "hardware address: " + interfaceObj.hardwareAddress ); 
                if( interfaceObj.subInterfaces != null ) 
                { 
                    trace( "# subinterfaces: " + interfaceObj.subInterfaces.length ); 
                } 
                trace("# addresses: "     + interfaceObj.addresses.length ); 
                for each ( var address:InterfaceAddress in interfaceObj.addresses ) 
                { 
                    trace( "  type: "           + address.ipVersion ); 
                    trace( "  address: "         + address.address ); 
                    trace( "  broadcast: "         + address.broadcast ); 
                    trace( "  prefix length: "     + address.prefixLength ); 
                } 
            }             
        } 
    }     
} 
}

Mer information finns i:

Ändringar i nätverksanslutning

AIR-programmet kan köras i miljöer där nätverksanslutningen är osäker och ändras. Om en nätverksanslutning blir tillgänglig eller inte längre kan användas, skickar Adobe AIR en nätverksändringshändelse. Det blir då lättare för ett program att hantera anslutningarna till olika onlineresurser. Både NetworkInfo-objektet och programmets NativeApplication-objekt skickar händelsen networkChange. Om programmet ska reagera på den här händelsen lägger du till en lyssnare:

NetworkInfo.networkInfo.addEventListener(Event.NETWORK_CHANGE, onNetworkChange); 

Ange också en händelsehanterarfunktion:

function onNetworkChange(event:Event) 
{ 
    //Check resource availability 
} 

Händelsen networkChange indikerar inte någon ändring i all nätverksaktivitet, utan bara att en enskild nätverksanslutning har ändrats. AIR försöker inte tolka innebörden av den här nätverksändringen. En nätverksansluten dator kan ha många verkliga och virtuella anslutningar. Att en anslutning försvinner behöver alltså inte innebära att en resurs går förlorad. Nya anslutningar garanterar inte heller förbättrad resurstillgänglighet. Ibland kan en ny anslutning till och med blockera åtkomst till resurser som varit tillgängliga tidigare (till exempel vid anslutning till VPN).

Vanligtvis kan ett program bara avgöra om det kan ansluta till en fjärresurs genom att prova. I ramverket för tjänstövervakning tillhandahålls en händelsebaserad metod att svara på ändringar i nätverksanslutning till en angiven värd.

Obs! Ramverket för tjänstövervakning upptäcker om en server svarar godkännande på en begäran. Att kontrollen slutförs garanterar inte fullständig anslutning. Skalbara webbtjänster använder ofta program för cachelagring och belastningsutjämning för att dirigera om trafik till ett kluster med webbservrar. I en sådan situation kan tjänsteleverantörerna bara tillhandahålla en ofullständig diagnos för nätverksanslutningen.

Tjänstövervakning

Tjänstövervakningens ramverk, som är skilt från AIR-ramverket, finns i filen aircore.swc. Om det här ramverket ska kunna användas måste filen aircore.swc tas med i ditt programbygge.

I Adobe® Flash® Builder inkluderas det här biblioteket automatiskt.

Klassen ServiceMonitor implementerar ramverket för övervakning av nätverkstjänster och ger en basfunktion för tjänstövervakning. Som standard skickar en instans av klassen ServiceMonitor händelser avseende nätverksanslutning. ServiceMonitor-objektet skickar dessa händelser när instansen skapas och när körningstiden upptäcker en nätverksändring. Du kan dessutom ställa in egenskapen pollInterval i en ServiceMonitor-instans så att anslutningen kontrolleras vid ett angivet intervall i millisekunder, oavsett vanliga nätverksanslutningshändelser. Ett ServiceMonitor-objekt kontrollerar inte nätverksanslutningen förrän metoden start() anropas.

Klassen URLMonitor, en underklass till klassen ServiceMonitor, upptäcker ändringar i HTTP-anslutningen för en angiven URLRequest.

Klassen SocketMonitor, som också är en underklass till klassen ServiceMonitor, upptäcker ändringar i anslutningen till en särskild värd vid en särskild port.

Obs! Före AIR 2 publicerades tjänstövervakningens ramverk i servicemonitor.swc-biblioteket. Detta bibliotek är nu inaktuellt. Du ska använda aircore.swc-biblioteket i stället.

Flash CS4 och CS5 Professional

Så här använder du dessa klasser i Adobe® Flash® CS4 eller CS5 Professional:

  1. Välj kommandot Arkiv > Publiceringsinställningar.

  2. Klicka på knappen Inställningar för ActionScript 3.0. Välj Bibliotekssökväg.

  3. Klicka på knappen Bläddra efter SWC-fil och bläddra till AIK-mappen i installationsmappen för Flash Professional.

  4. I den här mappen ska du leta reda på filen /frameworks/libs/air/aircore.swc (för AIR 2) eller filen /frameworks/libs/air/servicemonitor.swc (för AIR 1.5).

  5. Klicka på OK.

  6. Lägg till följande importsats till ActionScript 3.0-koden:
    import air.net.*;

Flash CS3 Professional

Om du vill använda dessa klasser i Adobe® Flash® CS3 Professional drar du komponenten ServiceMonitorShim från komponentpanelen till biblioteket och lägger sedan till följande import-sats till ActionScript 3.0-koden:

import air.net.*;

HTTP-övervakning

Klassen URLMonitor bestämmer om HTTP-begäran ska göras till en angiven adress vid port 80 (den vanliga porten för HTTP-kommunikation). Följande kod använder en instans av klassen URLMonitor för att identifiera anslutningsändringar för Adobes webbplats:

import air.net.URLMonitor; 
import flash.net.URLRequest; 
import flash.events.StatusEvent; 
var monitor:URLMonitor; 
monitor = new URLMonitor(new URLRequest('http://www.example.com')); 
monitor.addEventListener(StatusEvent.STATUS, announceStatus); 
monitor.start(); 
function announceStatus(e:StatusEvent):void { 
    trace("Status change. Current status: " + monitor.available); 
}

Socketövervakning

AIR-program kan också använda socketanslutningar för anslutning av push model-typ. Nätverkskommunikation via otillåtna portar begränsas vanligtvis av brandväggar och nätverksroutrar av säkerhetsskäl. Utvecklarna måste därför tänka på att användarna kanske inte alltid har möjlighet att skapa socketanslutningar.

Följande kod använder en instans av klassen SocketMonitor för att identifiera anslutningsändringar för en socketanslutning. Porten som övervakas är 6667, en gemensam port för IRC:

import air.net.ServiceMonitor; 
import flash.events.StatusEvent; 
 
socketMonitor = new SocketMonitor('www.example.com',6667); 
socketMonitor.addEventListener(StatusEvent.STATUS, socketStatusChange); 
socketMonitor.start(); 
 
function announceStatus(e:StatusEvent):void { 
    trace("Status change. Current status: " + socketMonitor.available); 
} 

Om socketservern kräver en säker anslutning kan du använda klassen SecureSocketMonitor istället för SocketMonitor.

DNS-poster (Domain Name System)

Du kan leta upp DNS-resursposter med hjälp av klassen DNSResolver. I DNS-resursposter tillhandahålls information som IP-adressen för ett domännamn och domännamnet för en IP-adress. Du kan leta upp följande typer av DNS-resursposter:

  • ARecord – IPv4-adress för en värd.

  • AAAARecord – IPv6-adress för en värd.

  • MXRecord – post för utbyte av e-post för en värd.

  • PTRRecord – värdnamn för en IP-adress.

  • SRVRecord – tjänstpost för en tjänst.

Om du vill leta upp en post skickar du en frågesträng och det klassobjekt som representerar posttypen till lookup()-metoden för DNSResolver-objektet. Vilken frågesträng som ska användas beror på posttypen:

Postklass

Frågesträng

Exempel på frågesträng

ARecord

värdnamn

"example.com"

AAAARecord

värdnamn

"example.com"

MXRecord

värdnamn

"example.com"

PTRRecord

IP-adress

"208.77.188.166"

SRVRecord

Tjänstidentifierare: _service._protocol.host

"_sip._tcp.example.com"

I följande kodexempel letas IP-adressen för värden "example.com" upp.

package 
{ 
    import flash.display.Sprite; 
    import flash.events.DNSResolverEvent; 
    import flash.events.ErrorEvent; 
    import flash.net.dns.ARecord; 
    import flash.net.dns.DNSResolver; 
 
    public class DNSResolverExample extends Sprite 
    { 
         
        public function DNSResolverExample() 
        { 
            var resolver:DNSResolver = new DNSResolver(); 
            resolver.addEventListener( DNSResolverEvent.LOOKUP, lookupComplete ); 
            resolver.addEventListener( ErrorEvent.ERROR, lookupError ); 
 
            resolver.lookup( "example.com.", ARecord ); 
        } 
         
        private function lookupComplete( event:DNSResolverEvent ):void 
        { 
            trace( "Query string: " + event.host ); 
            trace( "Record count: " + event.resourceRecords.length ); 
            for each( var record:* in event.resourceRecords ) 
            { 
                if( record is ARecord ) trace( record.address ); 
            } 
             
        } 
 
        private function lookupError( error:ErrorEvent ):void 
        { 
            trace("Error: " + error.text ); 
        } 
    } 
}

Mer information finns i: