O Contexto Global é uma variável que pode assumir como valor qualquer tipo de variável, como um mapa definindo um conjunto de pares chave/valor ou objetos JSONs complexos que definem árvores de objetos.
Ele funciona exatamente como o Contexto, no entanto, com um escopo global, ou seja, ele existirá enquanto a aplicação estiver rodando (mesmo em background), o que o permite ser acessado a partir de qualquer ponto da aplicação, seja esse ponto um componente ou ação vinculada a um componente ou mesmo programaticamente.
Ele pode ser acessado a partir de uma expressão em uma página declarativa, como por exemplo "@{global.user}"
ou programaticamente, a partir de um objeto GlobalContext.get().
Para utilizar o Contexto Global é importante ressaltar algumas informações importantes:
Objeto
do tipo ContextData
.Singleton
.O Contexto Global é criado juntamente com a aplicação. É definido internamente no Beagle como um objeto do tipo ContextData que armazenará qualquer informação definida no contexto global.
Um contexto que seja global pode ser definido de duas formas:
SetContext
) ouset()
a partir do objeto GlobalContext
É possível definir ou modificar um contexto global a partir da Ação SetContext
Para tal, basta identificar o contexto global utilizando a ID = "global"
na propriedade contextId
, como mostrado no exemplo abaixo:
Container(
children = listOf(
Text(text = "@{global.myValue}"),
Button(text = "Open Modal",
onPress = listOf(
SetContext(
contextId = "global",
path = "myValue",
value = "Context has changed"
)
)
)
)
)
path
, o valor será definido na raiz desse objeto, ou seja, qualquer outra atribuição que seja feita ao contexto vai sobrescrever qualquer informação sem um path
na raiz do objeto.No exemplo acima, o objeto JSON criado na raiz do contexto seria:
{"myValue" : "Context has changed"}
O Contexto Global também pode ser definido através de um método set
que pode ser chamado a partir do objeto GlobalContext
.
Para isso é usado:
GlobalContext.set(value, path)
Parâmetro | Tipo | Obrigatório | Definição |
---|---|---|---|
value | Any | ✓ | Representa a informação em si, que pode ser de qualquer tipo, como por exemplo, outros objetos JSONs, um array ou outro objeto qualquer. |
path | String | Representa o caminho designado que conterá essa informação, no exemplo acima, o path utilizado foi "myValue". O parâmetro path não é obrigatório, e quando for omitido, definirá o valor informado na raiz do objeto, sobrescrevendo qualquer outra informação. |
Para definir um contexto global como o do exemplo dessa seção, utilize o comando abaixo:
GlobalContext.set("Context has changed", "myValue");
Na web, o contexto global é um dos atributos do BeagleService, que a lib do beagle-angular e beagle-react disponibilizam.
Angular:
Para utilizar o contexto global em qualquer componente da sua aplicação você precisará injetar o BeagleProvider no construtor do seu componente, utilizar a função getBeagleUIService
para ter acesso ao objeto do beagleService
, acessar o globalContext
e a função do globalContext desejada. Abaixo o código exemplificando como utilizar a função de set
.
import { BeagleProvider } from '@zup-it/beagle-angular';
constructor(private beagleProvider: BeagleProvider)
...
const beagleService = this.beagleProvider.getBeagleUIService()
beagleService?.globalContext.set(value, path)
React:
Para utilizar o contexto global em uma aplicação React, utilize o context
disponibilizado pelo beagle-react através do useContext
do próprio react para ter acesso ao beagleService e através desse beagleService
, acesse o globalContext
e a função desejada, no exemplo abaixo, a função de set
é utilizada.
import context from '@zup-it/beagle-react/provider'
...
const beagleService = useContext(context)
beagleService?.globalContext.set(value, path)
No iOS o Contexto Global é um dos atributos do Beagle Dependencies .
Para utilizar o contexto global em qualquer componente da sua aplicação você precisará chamar o BeagleDependencies
do seu projeto como no exemplo abaixo:
Beagle.dependencies.globalContext.set(
value: "Context has changed",
path: "myValue"
)
O valor do contexto é um DynamicObject
, portanto ele pode assumir qualquer tipo de valor.
No Flutter o Contexto Global é chamado por meio da função getInstance()
, ela provê uma única instância (Singleton) do GlobalContext
, veja abaixo um exemplo de como utilizar:
import 'package:beagle/beagle.dart';
GlobalContext.getInstance().then((value) => value.set(value, path));
O contexto global pode ser recuperado de duas formas:
expressões
(assim como qualquer contexto) ouget
chamada a partir do Objeto GlobalContext
.Para recuperar o valor atribuído a um contexto global basta utilizar a expressão “@{global}”.
No exemplo utilizado nessa seção, atribuímos um valor ao contexto global utilizando o path "myValue" ,
dessa forma, para recuperá-lo basta usar a expressão "@{global.myValue}" o que retornará a string “Context has changed”.
O Contexto Global também pode ser recuperado através de um método get
que pode ser chamado a partir do objeto GlobalContext
.
Para isso é usado:
GlobalContext.get(path)
Parâmetro | Tipo | Obrigatório | Definição |
---|---|---|---|
path | String | Representa o caminho designado que conterá essa informação, no exemplo acima, o path utilizada foi "myValue". O parâmetro path é opcional e caso não seja passado todo o valor do contexto global será retornado. |
Considerando o exemplo anterior, para recuperar o valor do Contexto Global que está no path “myValue”, utilize o comando:
GlobalContext.get("myValue");
Acima foram mostradas todas as configs para utilização do set. A config para o get é a mesma, porém mudando apenas o método do globalContext que será acessado:
beagleService?.globalContext.get("myValue");
Assim como no método set será necessário chamar as dependências do Beagle para utilizar o contexto global como no exemplo abaixo:
Beagle.dependencies.globalContext.get(path: "myValue")
Assim como no método set é necessário chamar a função getInstance()
do GlobalContext
, você precisa utilizar o get
do contexto global, veja o exemplo abaixo:
import 'package:beagle/beagle.dart';
GlobalContext.getInstance().then((value) => value.get("myValue"));
GlobalContext.get()
sem nenhum parâmetro como path
, esse método retornará o objeto JSON inteiro -> {"myValue" : "Context has changed"}
O contexto global só é destruído com o encerramento da aplicação, e mesmo se estiver vazio, pode ser chamado de qualquer lugar da aplicação, pois “existe” enquanto a aplicação “existir”.
No entanto, ele pode ser apagado (reset) ou ter partes de sua estrutura (Objetos dentro do objeto JSON que representa o contexto global) removidas, modificando a estrutura do objeto.
O Contexto Global pode ser apagado através do método clear
que pode ser chamado a partir do objeto GlobalContext
.
Para isso é usado:
GlobalContext.clear(path)
Parâmetro | Tipo | Obrigatório | Definição |
---|---|---|---|
path | String | Opcional. Representa o caminho que se deseja remover. |
Para remover os valores de um Contexto Global por completo, “limpando-o”, devemos utilizar o comando clear sem informar um path. Veja abaixo:
GlobalContext.clear();
Lembre-se que na web o acesso ao contexto global sempre é feito atráves do beagleService:
beagleService?.globalContext.clear();
Lembre-se que no iOS o acesso ao contexto global é feito através do BeagleDependencies
Beagle.dependencies.globalContext.clear()
Lembre-se que no Flutter o acesso ao contexto global é feito por meio do getInstance()
:
import 'package:beagle/beagle.dart';
GlobalContext.getInstance().then((value) => value.clear());
Dessa forma, o VALUE
do Contexto Global será apagado totalmente e terá um valor vazio ("") caso chamado a partir de sua função GlobalContext.get()
Por exemplo, imagine um contexto global que tenha duas propriedades definidas a seguir
GlobalContext.set(path = "myValue1", value = "My Context Value1")
GlobalContext.set(path = "myValue2", value = "My Context Value2")
beagleService?.globalContext.set("My Context Value1", "myValue1");
beagleService?.globalContext.set("My Context Value2", "myValue1");
Esse Contexto Global é construído pelo Beagle como o objeto JSON a seguir:
{
"myValue1":"My Context Value1",
"myValue2":"My Context Value2"
}
Ao utilizar o comando:
GlobalContext.clear("myValue1")
beagleService?.globalContext.clear("myValue1");
Beagle.dependencies.globalContext.clear(path: "myValue1")
import 'package:beagle/beagle.dart';
GlobalContext.getInstance().then((value) => value.clear("myValue1"));
A propriedade representada pelo path
“myValue1” será completamente removida contexto global, que será:
{
"myValue2":"My Context Value2"
}
Was this page helpful?
Glad to hear it! Please tell us how we can improve.
Sorry to hear that. Please tell us how we can improve.