Trabalhar com domínios de aplicativo

Flash Player 9 e posterior, Adobe AIR 1.0 e posterior

O objetivo da classe ApplicationDomain é armazenar uma tabela de definições do ActionScript 3.0. Todo código em um arquivo SWF é definido para estar presente em um domínio de aplicativo. Domínios de aplicativo são usados para particionar classes que estão no mesmo domínio de segurança. Eles permitem que haja várias definições da mesma classe e permitem que filhos reutilizem definições de pai.

É possível usar domínios de aplicativo carregando um arquivo SWF externo escrito no ActionScript 3.0 usando a API da classe Loader. (Observe que não é possível usar domínios de aplicativo ao carregar uma imagem ou arquivo SWF no ActionScript 1.0 ou no ActionScript 2.0.) Todas as definições do ActionScript 3.0 contidas na classe carregada são armazenadas no domínio do aplicativo. Ao carregar o arquivo SWF, é possível especificar que o arquivo seja incluído no mesmo domínio do aplicativo que o objeto Loader, definindo o parâmetro applicationDomain do objeto LoaderContext como ApplicationDomain.currentDomain . Colocando o arquivo SWF carregado no mesmo domínio de aplicativo, é possível acessar suas classes diretamente. Isso poderá ser útil se estiver carregando um arquivo SWF contendo mídia incorporada que permita acesso por meio de nomes de classes associadas ou se você desejar acessar os métodos do arquivo SWF carregado.

O exemplo a seguir parte da premissa de que ele tem acesso para separar o arquivo Greeter.swf que define um método público denominado welcome(): 

package 
{ 
    import flash.display.Loader; 
    import flash.display.Sprite; 
    import flash.events.*; 
    import flash.net.URLRequest; 
    import flash.system.ApplicationDomain; 
    import flash.system.LoaderContext; 
 
    public class ApplicationDomainExample extends Sprite 
    { 
        private var ldr:Loader; 
        public function ApplicationDomainExample() 
        { 
            ldr = new Loader(); 
            var req:URLRequest = new URLRequest("Greeter.swf"); 
            var ldrContext:LoaderContext = new LoaderContext(false, ApplicationDomain.currentDomain); 
            ldr.contentLoaderInfo.addEventListener(Event.COMPLETE, completeHandler); 
            ldr.load(req, ldrContext);     
        } 
        private function completeHandler(event:Event):void 
        { 
            var myGreeter:Class = ApplicationDomain.currentDomain.getDefinition("Greeter") as Class; 
            var myGreeter:Greeter = Greeter(event.target.content); 
            var message:String = myGreeter.welcome("Tommy"); 
            trace(message); // Hello, Tommy 
        } 
    } 
}

Consulte também Exemplo de classe ApplicationDomain da Referência do ActionScript® 3.0 para Adobe® Flash® Platform .

Outras coisas que devem ser lembradas ao trabalhar com domínios de aplicativos incluem:

  • Todo código em um arquivo SWF é definido para estar presente em um domínio de aplicativo. O domínio atual é onde seu aplicativo principal é executado. O domínio do sistema contém todos os domínios de aplicativos, incluindo o domínio atual, o que significa que ele contém todas as classes do Flash Player.

  • Todos os domínios de aplicativos, exceto o domínio do sistema, têm um domínio-pai associado. O domínio-pai do domínio do aplicativo principal é o domínio do sistema. As classes carregadas só são definidas quando o pai ainda não as definiu. Você não pode substituir uma definição de classe loaded por uma definição mais recente.

O diagrama a seguir mostra um aplicativo que carrega conteúdo de vários arquivos SWF dentro de um único domínio, domain1.com. Dependendo do conteúdo carregado, diferentes domínios de aplicativos podem ser usados. O texto a seguir descreve a lógica usada para definir o domínio apropriado do aplicativo para cada arquivo SWF no aplicativo.

Exibir gráfico inteiro
A.
Uso A

B.
Uso B

C.
Uso C

O arquivo do aplicativo principal é application1.swf. Ele contém objetos Loader que carregam conteúdo de outros arquivos SWF. Neste cenário, o domínio atual é o Domínio do aplicativo 1. Uso A, uso B e uso C ilustram diferentes técnicas para configurar o domínio do aplicativo apropriado para cada arquivo SWF em um aplicativo.

Uso A
Particionar o arquivo SWF filho criando um filho do domínio do sistema. No diagrama, o Domínio do aplicativo 2 é criado como um filho do domínio do sistema. O arquivo application2.swf é carregado no Domínio do aplicativo 2 e suas definições de classe são portanto particionadas a partir das classes definidas no application1.swf.

Um dos usos dessa técnica é fazer com que um aplicativo antigo carregue uma versão mais nova do mesmo aplicativo sem conflito. Não há conflito porque, embora os mesmos nomes de classes sejam usados, elas são particionadas em diferentes domínios de aplicativo.

O código a seguir cria um domínio de aplicativo que é filho do domínio do sistema, e começa carregando um SWF usando esse domínio de aplicativo: 

var appDomainA:ApplicationDomain = new ApplicationDomain(); 
 
var contextA:LoaderContext = new LoaderContext(false, appDomainA); 
var loaderA:Loader = new Loader(); 
loaderA.load(new URLRequest("application2.swf"), contextA);

Uso B:
Adicione novas definições de classe às definições de classe atuais. O domínio do aplicativo do module1.swf é definido como o domínio atual (Domínio do aplicativo 1). Isso permite adicionar o conjunto atual de aplicativos das definições de classes com novas definições de classes. Isso pode ser usado para uma biblioteca de tempo de execução do aplicativo principal. O SWF carregado é tratado como uma RSL (biblioteca remota compartilhada). Use essa técnica para carregar RSLs por meio de um pré-carregador antes do início do aplicativo.

O código a seguir carrega um SWF definindo seu domínio de aplicativo para o domínio atual: 

var appDomainB:ApplicationDomain = ApplicationDomain.currentDomain; 
 
var contextB:LoaderContext = new LoaderContext(false, appDomainB); 
var loaderB:Loader = new Loader(); 
loaderB.load(new URLRequest("module1.swf"), contextB);

Uso C:
Use as definições de classes pai criando um novo domínio filho do domínio atual. O domínio do aplicativo do module3.swf é filho do domínio atual, e o filho usa as versões de todas as classes do pai. Um uso dessa técnica pode ser um módulo de um RIA (aplicativo de Internet avançado) de várias telas, carregado como um filho do aplicativo principal que usa os tipos do aplicativo principal. Se você puder garantir que todas as classes são sempre atualizadas para serem compatíveis com versões anteriores e que o aplicativo carregado é sempre mais novo do que as coisas que ele carrega, os filhos usarão as versões do pai. Ter um novo domínio de aplicativo também permite descarregar todas as definições de classe para coleta de lixo, se você puder garantir que referências ao SWF filho não continuam a existir.

Essa técnica permite que módulos carregados compartilhem os objetos singleton do carregador e membros da classe estática.

O código a seguir cria um novo domínio filho do domínio atual e inicia o carregamento de um SWF usando aquele domínio de aplicativo: 

var appDomainC:ApplicationDomain = new ApplicationDomain(ApplicationDomain.currentDomain); 
 
var contextC:LoaderContext = new LoaderContext(false, appDomainC); 
var loaderC:Loader = new Loader(); 
loaderC.load(new URLRequest("module3.swf"), contextC);