From 074785cea106179cb3305637055ab0a009ca74f2 Mon Sep 17 00:00:00 2001 From: Peter Bengtsson Date: Tue, 8 Dec 2020 14:42:52 -0500 Subject: initial commit --- files/pt-br/webapi/battery_status/index.html | 58 +++ files/pt-br/webapi/device_storage/index.html | 224 ++++++++++++ files/pt-br/webapi/idle/index.html | 70 ++++ files/pt-br/webapi/index.html | 133 +++++++ files/pt-br/webapi/mobile_connection/index.html | 148 ++++++++ files/pt-br/webapi/network_information/index.html | 56 +++ files/pt-br/webapi/network_stats/index.html | 86 +++++ files/pt-br/webapi/tcp_socket/index.html | 75 ++++ files/pt-br/webapi/web_activities/index.html | 421 ++++++++++++++++++++++ files/pt-br/webapi/websms/index.html | 136 +++++++ 10 files changed, 1407 insertions(+) create mode 100644 files/pt-br/webapi/battery_status/index.html create mode 100644 files/pt-br/webapi/device_storage/index.html create mode 100644 files/pt-br/webapi/idle/index.html create mode 100644 files/pt-br/webapi/index.html create mode 100644 files/pt-br/webapi/mobile_connection/index.html create mode 100644 files/pt-br/webapi/network_information/index.html create mode 100644 files/pt-br/webapi/network_stats/index.html create mode 100644 files/pt-br/webapi/tcp_socket/index.html create mode 100644 files/pt-br/webapi/web_activities/index.html create mode 100644 files/pt-br/webapi/websms/index.html (limited to 'files/pt-br/webapi') diff --git a/files/pt-br/webapi/battery_status/index.html b/files/pt-br/webapi/battery_status/index.html new file mode 100644 index 0000000000..603750f72c --- /dev/null +++ b/files/pt-br/webapi/battery_status/index.html @@ -0,0 +1,58 @@ +--- +title: Battery Status API +slug: WebAPI/Battery_Status +tags: + - API + - Apps + - Batería + - Firefox OS + - Guia(2) + - Guía + - Mobile + - Obsoleto +translation_of: Web/API/Battery_Status_API +--- +
{{obsolete_header}}
+ +
{{DefaultAPISidebar("Battery API")}}
+ +

A API Battery Status, mais conhecida como Battery API, fornece informações sobre o nível de carga da bateria presente no sistema e permite que você seja notificado por eventos que são enviados quando os níveis sofrem alterações. Isto pode ser usado para ajustar a utilização de recursos do seu aplicativo, reduzindo a quantidade de energia drenada por ele quando a bateria estiver em nível baixo, ou ainda para salvar mudanças antes da bateria acabar, prevenindo a perda de dados.

+ +

A API Battery Status API estende {{domxref("Window.navigator")}} com uma propriedade {{domxref("Navigator.battery")}} que é um objeto {{domxref("BatteryManager")}},  e adiciona alguns novos eventos que você pode receber para monitorar o status da bateria.

+ +

Exemplo

+ +

Neste exemplo, nós observamos as mudanças em ambos os status de carregamento (se estamos ou não conectados e carregando) e para mudanças no nível da bateria. Isto é feito escutando pelos eventos {{event("chargingchange")}} e {{event("levelchange")}}, respectivamente.

+ +
var battery = navigator.battery || navigator.mozBattery || navigator.webkitBattery;
+
+function updateBatteryStatus() {
+  console.log("Status da bateria: " + battery.level * 100 + " %");
+
+  if (battery.charging) {
+    console.log("A bateria está carregando");
+  }
+}
+
+battery.addEventListener("chargingchange", updateBatteryStatus);
+battery.addEventListener("levelchange", updateBatteryStatus);
+updateBatteryStatus();
+
+ +

Veja também o exemplo na especificação.

+ +

Especificações

+ +

{{page("/pt-BR/docs/Web/API/BatteryManager","Specifications")}}

+ +

Compatibilidade entre navegadores

+ +

{{page("/pt-BR/docs/Web/API/BatteryManager","Browser_compatibility")}}

+ +

Veja também

+ + diff --git a/files/pt-br/webapi/device_storage/index.html b/files/pt-br/webapi/device_storage/index.html new file mode 100644 index 0000000000..a50851ed77 --- /dev/null +++ b/files/pt-br/webapi/device_storage/index.html @@ -0,0 +1,224 @@ +--- +title: Device Storage API +slug: WebAPI/Device_Storage +translation_of: Archive/B2G_OS/API/Device_Storage_API +--- +

{{ non-standard_header() }}

+

{{ B2GOnlyHeader2('privileged') }}

+

Sumário

+

O Device Storage API é utilizado para acessar o sistema via Web app. Como acessar arquivos do sistema é algo sensível, e por está razão que API só libera o acesso a leitura.

+
+

Nota: Acessar o storage do device é um pouco lento devido a limitação do nível físico. Em muitos casos pode ser mais rápido usar uma base de dados IndexedDB em vez de armazenar os arquivos no storage do device.

+
+

Acessando um storage

+

Ponto de entrada

+

É possível ter acesso a uma área de storage utilizando o método, {{domxref("window.navigator.getDeviceStorage()","navigator.getDeviceStorage()")}}. Este método aceita uma string como parâmetro que representa o nome do storage que você quer acessar. O método retorna um objeto {{domxref("DeviceStorage")}} que é utilizaod para ter acesso a leitura da área do storage.

+

Firefox OS fornece as seguintes áreas de storage:

+ +
var pics = navigator.getDeviceStorage('pictures');
+

Para ser capaz de utilizar cada uma dessas áreas de storage, a app precisa solicitar no seu manifesto a permissão. Como examplo, se app precisa ter acesso a área de storage  sdcard, é necessário declarar a seguinte linha "device-storage:sdcard" para slolicitar a permissão, detro do arquivo de manifesto, conforme exemplo abaixo.

+
"permissions": {
+  "device-storage:videos":{ "access": "readonly" },
+  "device-storage:pictures":{ "access": "readwrite" }
+}
+

Utilizando um storage

+

Depois que uma app tem acesso a uma área de storage, ela pode adicionar, pegar e remover arquivos desta área.

+

Adicionar um arquivo

+

Para adicionar um arquivo utilizamos os seguintes métodos {{domxref("DeviceStorage.addNamed()","addNamed")}} ou {{domxref("DeviceStorage.add()","add")}}. O primeiro método permite definir o nome do arquivo que está sendo adicionado e o segundo método gera o nome de forma automatica. Ambos os métodos são assíncronos e retorna um objeto {{domxref("DOMRequest")}} para controlar o success ou error da operação. Isto é muito importânte para acompanhar o processo de leitura e escrita de arquivos.

+

Aqueles dois métodos espera um {{domxref("Blob")}} como o seu primeiro parametro. Este objeto será transformado em um arquivo e armazenado em background. Quando criar o objeto {{domxref("Blob")}}, é obrigado dar um type. Este type, que é o type mime, é importânte porque algumas áreas storage tem base restrição o type:

+ +
var sdcard = navigator.getDeviceStorage("sdcard");
+var file   = new Blob(["This is a text file."], {type: "text/plain"});
+
+var request = sdcard.addNamed(file, "my-file.txt");
+
+request.onsuccess = function () {
+  var name = this.result;
+  console.log('File "' + name + '" successfully wrote on the sdcard storage area');
+}
+
+// An error typically occur if a file with the same name already exist
+request.onerror = function () {
+  console.warn('Unable to write the file: ' + this.error);
+}
+
+
+

Nota: Repositória em uma área de storage são implícitos. Repository in a storage area are implicit. Não é possível criar explicidamente um repositório vazio.  Se você  Se você precisar de uma estrutura de repositório é necessário ter um arquivo armazenado. Então se você precisa armazenar um arquivo bar dentro do repositório foo, você tem que usar o método {{domxref("DeviceStorage.addNamed()","addNamed")}}  com o caminho compreto para o arquivo addNamed(blob, "foo/bar"). Isto também é utilzado quando você precisa recuperar um arquivo utilizando seu nome (veja abaixo).

+

Como os arquivos são adicionados dentro de uma área de storage retrita, por razões de securança, o caminho do arquivo não pode começar com "/" ou "../" (e "./" é inútil).

+
+

Download de um arquivo

+

Download de um arquivo pode ser feito de duas maneira: usando seu nome ou por interação em uma lista inteira.

+

A maneira mais fácil de recuperar um arquivo é utiliznado o nome do arquivo nos métodos {{domxref("DeviceStorage.get()","get")}} e {{domxref("DeviceStorage.getEditable","getEditable")}}. O primeiro método retorna um objeto {{domxref("File")}} (que age só como uma leitura de arquivo) e o segundo retorna o objeto {{domxref("FileHandle")}} object (que permite alterar o arquivo base). Os dois métodos são assíncronos e returna um objeto {{domxref("DOMRequest")}} para manipular caso tenha success ou error.

+
var sdcard = navigator.getDeviceStorage('sdcard');
+
+var request = sdcard.get("my-file.txt");
+
+request.onsuccess = function () {
+  var file = this.result;
+  console.log("Get the file: " + file.name);
+}
+
+request.onerror = function () {
+  console.warn("Unable to get the file: " + this.error);
+}
+
+

A outra maneira de recuperar arquivos é navegando pelo conteúdo da área de storage. Temos dois métodos {{domxref("DeviceStorage.enumerate()","enumerate")}} e{{domxref("DeviceStorage.enumerateEditable()","enumerateEditable")}}. O retorno do primeiro método é os objetos {{domxref("File")}} o segunto método retorna os objetos {{domxref("FileHandle")}} . Ambos métodos são assíncrono e retorna um objeto {{domxref("DOMCursor")}} para iterar ao longo da lista de arquivos. Um {{domxref("DOMCursor")}} é nada menos que um {{domxref("DOMRequest")}} com uma função a mais para interar de forma assíncrona ao longo de uma lista de coisas (arquivos nesse caso).

+
var pics = navigator.getDeviceStorage('pictures');
+
+// Let's browse all the images available
+var cursor = pics.enumerate();
+
+cursor.onsuccess = function () {
+  var file = this.result;
+  console.log("File found: " + file.name);
+
+  // Once we found a file we check if there is other results
+  if (!this.done) {
+    // Then we move to the next result, which call the cursor
+    // success with the next file as result.
+    this.continue();
+  }
+}
+
+cursor.onerror = function () {
+  console.warn("No file found: " + this.error);
+}
+
+

É possível para limitar o número de resultados, passando dois parâmetros opcionais para os métodos {{domxref("DeviceStorage.enumerate()","enumerate")}} e {{domxref("DeviceStorage.enumerateEditable()","enumerateEditable")}}.

+

O primeiro parâmetro pode ser uma string, que representa uma sub pasta para uma busca interna.

+

O segundo parâmetro pode ser um objeto com uma propriedade since, que permite liberar a pesquisa por um determinado período de tempo.

+
var pics = navigator.getDeviceStorage('pictures');
+
+// Lets retrieve picture from the last week.
+var param = {
+  since: new Date((+new Date()) - 7*24*60*60*1000)
+}
+
+var cursor = pics.enumerate(param);
+
+cursor.onsuccess = function () {
+  var file = this.result;
+  console.log("Picture taken on: " + file.lastModifiedDate);
+
+  if (!this.done) {
+    this.continue();
+  }
+}
+
+

Deletar um arquivo

+

Um arquivo pode ser removido a partir da sua área de storage, simplismente utilizando o método {{domxref("DeviceStorage.delete()","delete")}}. Este método só precisa do nome para deletar o arquivo. Como todos os outros métodos da interface {{domxref("DeviceStorage")}}, este também é assíncrono e retorna um objeto {{domxref("DOMRequest")}} para manipular os status de success ou error.

+
var sdcard = navigator.getDeviceStorage('sdcard');
+
+var request = sdcard.delete("my-file.txt");
+
+request.onsuccess = function () {
+  console.log("File deleted");
+}
+
+request.onerror = function () {
+  console.log("Unable to delete the file: " + this.error);
+}
+
+

Informação do Storage

+

Além de acessar os arquivos, a área de storage fornece alguns métodos para ler facilmente algumas informações importantes.

+

Estaço Livre

+

Uma das mais umportantes informações para saber sobre o storage, é a quantidade de espaço livre para armazenamento. A interface {{domxref("DeviceStorage")}} fornece duas funções úteis dedicada ao espaço de armazenamento:

+ +

Como os dois métodos são assíncronos, eles retornam um objeto {{domxref("DOMRequest")}} para tratar os status de success ou error.

+
var videos = navigator.getDeviceStorage('videos');
+
+var request = videos.usedSpace();
+
+request.onsuccess = function () {
+  // The result is express in bytes, lets turn it into megabytes
+  var size = this.result / 1048576;
+  console.log("The videos on your device use a total of " + size.toFixed(2) + "Mo of space.");
+}
+
+request.onerror = function () {
+  console.warn("Unable to get the space used by videos: " + this.error);
+}
+
+

Ouvindo alterações

+

Como muitas aplicações pode usar uma mesma área de storage ao mesmo tempo, por este motivo é muito útil para aplicação estar ciente de uma alteração em uma área de storage. É também útil para uma aplição que deseja executar uma ação assíncrona sem a dependência do objeto de retorno {{domxref("DOMRequest")}} por cada método da interface  {{domxref("DeviceStorage")}}.

+

Para esse fim, um evento {{event("change")}} é acionado cada vez que um arquivo é criado, modificado ou deletado. Este evento pode ser capturado utilizando a propriedade  {{domxref("DeviceStorage.onchange","onchange")}} ou o método {{domxref("EventTarget.addEventListener()","addEventListener()")}}. O evento pega um objeto {{domxref("DeviceStorageChangeEvent")}} que um objeto regular {{domxref("Event")}} que tem duas própriedades não obrigatórias:

+ +
var sdcard = navigator.getDeviceStorage('sdcard');
+
+sdcard.onchange = function (change) {
+  var reason = change.reason;
+  var path   = change.path;
+
+  console.log('The file "' + path + '" has been ' + reason);
+}
+
+

Especificação

+

Não faz parte de qualquer especificação.

+

Compatibilidade com Browser

+

{{ CompatibilityTable() }}

+
+ + + + + + + + + + + + + + + + + + + +
FeatureChromeFirefox (Gecko)Internet ExplorerOperaSafari
Basic support{{ CompatUnknown() }}{{ CompatUnknown() }}{{ CompatNo() }}{{ CompatNo() }}{{ CompatNo() }}
+
+
+ + + + + + + + + + + + + + + + + + + +
FeatureAndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Basic support{{ CompatUnknown() }}{{ CompatUnknown() }}{{ CompatNo() }}{{ CompatNo() }}{{ CompatNo() }}
+
+

Veja também

+ diff --git a/files/pt-br/webapi/idle/index.html b/files/pt-br/webapi/idle/index.html new file mode 100644 index 0000000000..65f71e1b2c --- /dev/null +++ b/files/pt-br/webapi/idle/index.html @@ -0,0 +1,70 @@ +--- +title: Idle API +slug: WebAPI/Idle +tags: + - API + - inatividade + - observadores +translation_of: Archive/B2G_OS/API/Idle_API +--- +
+ {{non-standard_header}} {{B2GOnlyHeader2('certified')}}
+

Resumo

+

A Idle API é utilizada para enviar notificações ao usuário mesmo quando um aplicativo está em segundo plano (inativo). Ela possibilita que o usuário continue recebendo notificaçòes do aplicativo mesmo quando não estiver com ele em primeiro plano (ativo). O caso de uso mais comum é para economizar bateria; nesse caso é utilizado em conjunto com a Power Management API, api de gerenciamento de energia.

+

Monitorando uma aplicação inativa

+

Para que uma aplicação em segundo plano envie notificações ao usuário, é necessário registrar um observador (idle observer).O observador é um objeto que possui três propriedades:

+ +

Exemplo: escurecendo a tela to celular quando o app estiver inativo

+

In this example, an idle observer is set up that dims the screen's brightness to 50% when the user is idle for 10 seconds, and restores it back to 100% when the user is active again. A second observer is set up that turns off the screen when the user is idle for at least 15 seconds.

+

Nesse exemplo, o observador está configurado para reduzir o brilho da tela em 50%, 10 segundos após o aplicativo entrar em segundo plano, e restaura o brilho para 100% quando ele voltar a ficar em primeiro plano. Um segundo observador é configurado, e 15 segundos após o aplicativo entrar em segundo plano, ele apaga a tela do usuário.

+
// NOTE: mozPower is part of the Power Management API
+
+var fadeLight = {
+  time: 10, // Ten seconds
+
+  onidle: function () {
+    // The user does not seem active, let's dim the screen down
+    navigator.mozPower.screenBrightness = 0.5;
+  },
+
+  onactive: function () {
+    // Ok, the user is back, let's brighten the screen up
+    navigator.mozPower.screenBrightness = 1;
+  }
+}
+
+var screenOff = {
+  time: 15, // fifteen seconds
+
+  onidle: function () {
+    // Ok, the user had his chance but he's really idle, let's turn the screen off
+    navigator.mozPower.screenEnabled = false;
+  },
+
+  onactive: function () {
+    // Ok, the user is back, let's turn the screen on
+    navigator.mozPower.screenEnabled = true;
+  }
+}
+
+// Register the idle observers
+
+navigator.addIdleObserver(fadeLight);
+navigator.addIdleObserver(screenOff);
+
+

O código acima define 2 observadores: fadeLight e screenOff, que chamam {{domxref("window.navigator.addIdleObserver","navigator.addIdleObserver()")}} uma vez para cada um deles, de modo que eles sejam registrados. Podem ser registrados quantos observadores forem necessários para uma aplicação.

+

Se não for necessário observar o momento em que o aplicativo entra em segundo plano, os observadores ociosos podem ser removidos chamando o método {{domxref("window.navigator.removeIdleObserver","navigator.removeIdleObserver()")}} , como mostrado a seguir:

+
navigator.removeIdleObserver(fadeLight);
+navigator.removeIdleObserver(screenOff);
+
+

Especificação

+

Essa API não faz parte das especificações do W3C, mas será discutida como parte do System Applications Working Group.

+

Veja também

+ diff --git a/files/pt-br/webapi/index.html b/files/pt-br/webapi/index.html new file mode 100644 index 0000000000..f28a579474 --- /dev/null +++ b/files/pt-br/webapi/index.html @@ -0,0 +1,133 @@ +--- +title: WebAPI +slug: WebAPI +tags: + - Apps + - DOM + - Firefox OS + - Mobile +translation_of: Web/API +--- +

WebAPI é um termo usado para se referir a um conjunto de compatibilidade de dispositivos e acessar APIs que permitem que aplicativos Web e conteúdos para acessar o hardware do dispositivo (como o estado da bateria ou o hardware de vibração do dispositivo), bem como o acesso aos dados armazenados no dispositivo (como como o calendário ou lista de contatos). Ao acrescentar estas APIs, esperamos expandir o que a Web pode fazer hoje e apenas plataformas proprietárias foram capazes de fazer no passado.

+ +
+

Nota: Esta documentação é maior do que parece, os links ainda não estão todos adicionados aqui. Estamos trabalhando ativamente para melhorar isso e esperamos ver as coisas muito melhor nas próximas semanas. Veja a página de status da documentação da WebAPI, onde estamos acompanhando o trabalho em documentos WebAPI.

+
+ +
+

Nota: para uma breve explicação de cada distintivo, consulte a documentação do pacote de aplicativos.

+
+ +
+
+

APIs de Comunicação

+ +
+
Network Information API (API de Informação de Rede)
+
Fornece informações básicas sobre a conexão de rede atual, como a velocidade de conexão.
+
Bluetooth {{NonStandardBadge}}
+
A API WebBluetooth fornece acesso de baixo nível ao hardware Bluetooth do dispositivo.
+
Mobile Connection API (API de Conexão Móvel) {{NonStandardBadge}}
+
Expões informações sobre a conectividade do celular, como a força do sinal, informação da operadora, assim por diante.
+
Network Stats API (API de Estatísticas de Rede) {{NonStandardBadge}}
+
Monitora a utilização de dados e expõe esses dados para aplicações privilegiadas.
+
Telephony (Telefonia) {{NonStandardBadge}}
+
Permite aplicações efectuar e atender chamadas telefônicas e usar a interface de usuário de telefonia embutida.
+
WebSMS {{NonStandardBadge}}
+
Permite que aplicações enviem e recebam mensagens de texto SMS, bem como para acessar e gerenciar as mensagens armazenadas no dispositivo.
+
WiFi Information API (API de Informações WiFi) {{NonStandardBadge}}
+
+
+
Uma API privilegiada que fornece informações sobre a força do sinal, o nome da rede atual, as redes Wi-Fi disponíveis, e assim por diante.
+
+
+
+ +

APIs de Acesso ao Hardware

+ +
+
Ambiente Light Sensor API (API do Sensor de Luz Ambiente)
+
Fornece acesso ao sensor de luz ambiente, que permite que seu aplicativo detecte o nível de luz ao redor do dispositivo.
+
Battery Status API (API de Estado da Bateria)
+
Fornece informações sobre nível de carregamento da bateria e quando ou não o dispositivo está plugado e carregando.
+
Geolocation API (API de Geolocalização)
+
Provê informação sobre a localização física do dispositivo.
+
Pointer Lock API (API de Bloqueio do mouse)
+
Permitir aplicativos bloquearem o acesso ao mouse e ter acesso a deltas de movimento ao invés de coordenadas absolutas, o que é ótimo para jogos.
+
Proximity API (API de Proximidade)
+
Permite dectar a proximidade do dispositivo a objetos próximos, como o rosto do usuário.
+
Device Orientation API (API de Orientação do Dispositivo)
+
Fornece notificações quando a orientação do dispositivo muda.
+
Screen Orientation API (API de Orientação de Tela)
+
Fornece notificações quando a tela do dispositivo muda. Você também uasr a API para permitir seu aplicativo indicar qual orientação é preferida.
+
Vibration API (API de Vibração)
+
Permite aplicativos controlarem o hardware de vibração do dispositivo para coisas como feedback tátil em jogos. Não é a intenção para utilização como vibrações de notificação. Veja a API de Alarme para isso.
+
Camera API (API de Camera) {{NonStandardBadge}}
+
Permite aplicativos tirarem fotograficas e/ou gravar vídeos usando a camera do dispositivo.
+
Power Management API (API Gerenciamento de Energia) {{NonStandardBadge}}
+
Permite aplicativos ligar ou desligar a tela, CPU e energia do dispositivo, assim por diante. Também fornece suporte para verificar a inspecionar recursos em eventos de bloqueio.Ver todos...
+
+
+ +
+

APIs de Gerenciamento de Dados

+ +
+
FileHandle API
+
Fornece suporte para escrever arquivos com suporte a bloqueio.
+
IndexedDB
+
Armazenamento do lado do cliente de dados estruturados, com suporte para pesquisas de alto desempenho.
+
Settings API (API de Configurações) {{NonStandardBadge}}
+
Permite apps examinarem e alterar todas opções de configuração do sistema que são permanentemente armazenadas no dispositivo.
+
+ +

Outras APIs

+ +
+
Alarm API (API de Alarme)
+
Permite apps agendarem notificações. Também fornece suporte para automaticamente abrir um app em um tempo específico.
+
Simple Push API
+
Permite a plataforma enviar mensagens de notificação para aplicações específicas.
+
Notificações Web
+
Permites aplicações enviarem notificacões mostradas no nível do sistema.
+
Apps API {{NonStandardBadge}}
+
As WebApps APIs abertas fornecem suporte para instalar e gerenciar WebApps. Em complemento, suporte é dado para permitir apps determinem informações de pagamento.
+
Web Activities (Atividades Web) {{NonStandardBadge}}
+
Permite um app delegar uma atividade para outro app; por exemplo, um app pode perguntar outro app para selecionar (ou criar) e retornar uma foto. Tipicamente o usuário é capaz de configurar que apps são usados para cada atividade.
+
WebPayment API (API Pagamento Web) {{NonStandardBadge}}
+
Permite conteúdos web iniciar pagamentos e restituição para bens virtuais.
+
Browser API {{NonStandardBadge}}
+
Fornece suporte para a construção de um navegador Web completamente utilizando tecnologias da Web (em essência, um navegador em um navegador).
+
+ +
+
Idle API(Notificações em Segundo Plano)
+
Permite apps receberem notificações quando o usuário não estiver ativamente utilizando o dispositivo.
+
Permissions API(API de Permissões) {{NonStandardBadge}}
+
Gerencia permissão de apps em localização centralizada. Utilizado pelo app de Configurações.
+
Time/Clock API (API de Tempo/Relógio)  {{NonStandardBadge}}
+
Fornece suporte para configuração do tempo atual. O fuso horário é definido utilizando a Settings API (API de Configurações).
+
+ +

Comunidade WebAPI

+ +

Se você precisa de ajuda com alguma dessas APIs, aqui estão várias maneiras que você pode conversar com outros desenvolvedores que as estão utilizando.

+ +
    +
  • Consultar forum de WebAPI {{DiscussionList("dev-webapi", "mozilla.dev.webapi")}}
    • +
  • Visite o canal no IRC WebAPI: #webapi
    • +
+ +

Don't forget about the netiquette...

+ + + + +
+
+ +

 

diff --git a/files/pt-br/webapi/mobile_connection/index.html b/files/pt-br/webapi/mobile_connection/index.html new file mode 100644 index 0000000000..cccbb5cd05 --- /dev/null +++ b/files/pt-br/webapi/mobile_connection/index.html @@ -0,0 +1,148 @@ +--- +title: Mobile Connection +slug: WebAPI/Mobile_Connection +translation_of: Archive/B2G_OS/API/Mobile_Connection_API +--- +

{{ non-standard_header() }}

+

{{ B2GOnlyHeader2('certified') }}

+

Sumário

+

Essa API tem 2 propósitos:

+ +

Como essa API pode acessar funcionalidades que podem ter um impacto no plano móvel assinado pelo usuário (algumas funcionalidades pode ter custo para utilizar ou causar danos ao ICC), é restrita para aplicações certificadas apenas.

+

O ponto inicial principal dessa API é a propriedade {{domxref("window.navigator.mozMobileConnection","navigator.mozMobileConnection")}} que é uma instância da interface {{domxref("MozMobileConnection")}}.

+

Estado da conexão móvel

+

O estado da conexão móvel é dividida em dois: de um lado a conexão voice, do outro conexão  data. O dado relacionado a cada tipo de conexão é acessível através pelas propriedades {{domxref("MozMobileConnection.voice")}} e {{domxref("MozMobileConnection.data")}} que ambas retornarão o objeto {{domxref("MozMobileConnectionInfo")}}.

+

Esses objetos permitem acesso a todas as informações relacionadas a qualidade da rede (signal strength, quality of the signal, posição das network's cells, restricted usage, roaming, etc.), e relacionado à  the carrier operating the network.

+
var cnx = navigator.mozMobileConnection;
+
+console.log("The voice operator is " + cnx.voice.network.longName);
+
+if (cnx.voice.connected) {
+  console.log("The signal has a strength of " + (+cnx.voice.relSignalStrength) + "%");
+} else {
+  console.log("The state of the connection is: " + cnx.voice.state);
+}
+
+

Funcionalidades ICC

+

As funcionalidades disponíveis para o ICC pode ser dividida dentro de duas categorias: o gerenciamento do próprio ICC e a utilização do comando integrado disponível dentro do STK (SIM Application Toolkit).

+

Ações Básicas

+

O {{domxref("MozMobileConnection")}} fornece métodos para lidar com comportamentos comuns no ICCs.

+
+

Nota: All original methods from the MozMobileConnection interface are fully asynchronous. They all return a {{domxref("DOMRequest")}} object which has an onsuccess and onerror event handler to handle the success or failure of the method call.

+
+

Bloqueio do Cartão

+

Enquanto o cartão estiver bloqueado, o usuário é incapaz de utilizar uma rede móvel. É possível gerenciar o bloqueio do cartão com os métodos {{domxref("MozMobileConnection.getCardLock","getCardLock()")}}, {{domxref("MozMobileConnection.setCardLock","setCardLock()")}}, e {{domxref("MozMobileConnection.unlockCardLock","unlockCardLock()")}}.

+

Se {{domxref("MozMobileConnection.getCardLock","getCardLock()")}} permite pegar algumas informações detalhadas sobre o bloqueio, também possível ter informação rápida sobre o bloqueio através {{domxref("MozMobileConnection.cardState")}} que retorna uma string representando o estado atual do bloqueio.

+
+

Nota: Even if the state change requests are successfully handled, it does not mean that the operations are necessarily successful. For that reason, any change in the card state is tracked independently through events:

+ +
+
var cnx = navigator.mozMobileConnection;
+
+function unlockCard() {
+  var unlockOptions = {
+    lockType: "pin",
+    pin     : prompt("Please, enter your PIN")
+  }
+
+  var unlock = cnx.unlockCardLock(unlockOptions);
+
+  unlock.onsuccess = function () {
+    console.log("The card has successfully handled the PIN number.");
+
+    if (this.result.success === false) {
+      if (this.result.retryCount > 0) {
+        console.log("But you mistyped your PIN, you have " + this.result.retryCount + " tries left.");
+      } else {
+        console.log("But your card is hard locked, you need to contact your carrier to get a special unlocking code.");
+      }
+    }
+  }
+
+  unlock.onerror = function () {
+    console.log("Hu! Something goes very wrong!")
+  }
+}
+
+cnx.addEventListener('icccardlockerror', function () {
+  // In case of error, ask the user for his PIN again
+  unlockCard();
+});
+
+cnx.addEventListener('cardsatechange', function () {
+  // In case the card state change and required to be unlocked
+  if (cnx.cardState === 'pinRequired') {
+    unlockCard();
+  }
+}
+
+// First call to unlockCard if required
+if (cnx.cardState === 'pinRequired') {
+  unlockCard();
+}
+
+

Mensagens MMI

+

Mensagens MMI são códigos legíveis para humanos que, uma vez digitado no teclado do aparelho, permite disparo de ações específicas do RIL ou pegar resposta da rede pela requisição USSD. Um exemplo comum é digitar um código curto para receber número IMEI do aparelho.

+

Essas mensagens são enviadas utilizando o método {{domxref("MozMobileConnection.sendMMI()")}} (e pode ser cancelado com {{domxref("MozMobileConnection.cancelMMI","cancelMMI()")}}). Mesmo com isso irá retornar um objeto {{domxref("DOMRequest")}}, a resposta para este tipo de mensagem é manuseada de duas maneiras:

+ +
var cnx = navigator.mozMobileConnection;
+
+cnx.addEventHandler('ussdreceived', function (evt) {
+  console.log('Network message: ' + evt.data.message);
+});
+
+var MMIRequest = cnx.sendMMI(prompt('Provide a valid MMI'));
+
+MMIRequest.onerror = function() {
+  console.log("Mmmh... Something goes wrong.");
+}
+
+

Opções encaminhamento de chamada

+

Opções de encaminhamento permite definir como uma ligação pode ou não ser encaminhada para outro número de telefone.

+

Essas opções são manuseadas com os métodos {{domxref("MozMobileConnection.getCallForwardingOption","getCallForwardingOption()")}} e {{domxref("MozMobileConnection.setCallForwardingOption","setCallForwardingOption()")}}.

+
var options = {
+  action      : MozMobileCFInfo.CALL_FORWARD_ACTION_ENABLE,
+  reason      : MozMobileCFInfo.CALL_FORWARD_REASON_UNCONDITIONAL,
+  serviceClass: MozMobileConnectionInfo.ICC_SERVICE_CLASS_VOICE,
+  number      : prompt('To which phone number would you wish to forward the calls?'),
+  timeSeconds : 5
+};
+
+var setOption = navigator.mozMobileConnection.setCallForwardingOption(options);
+
+setOption.onsuccess = function () {
+  console.log('Options successfully set');
+}
+
+setOption.onerror = function () {
+  console.log('Unable to set options: ' + this.error.name);
+}
+
+

Comandos STK

+

Os comandos STK dependem em vários fatores (operadoras, modelos de chips, etc.) mas podem sempre ser acessados pela propriedade {{domxref("MozMobileConnection.icc")}} que retorna um objeto {{domxref("MozIccManager")}}.

+
+

Atenção: É recomendado utilizando comando STK apenas se você já sabe exatamente o que você está fazendo, porque a utilização errada pode danificar o chip e torná-lo inutilizável.

+
+

Especificações

+

Não faz parte de nenhuma especificação.

+

Veja também

+ diff --git a/files/pt-br/webapi/network_information/index.html b/files/pt-br/webapi/network_information/index.html new file mode 100644 index 0000000000..032fc54169 --- /dev/null +++ b/files/pt-br/webapi/network_information/index.html @@ -0,0 +1,56 @@ +--- +title: Network Information API +slug: WebAPI/Network_Information +translation_of: Web/API/Network_Information_API +--- +

{{ SeeCompatTable() }}

+ +

A API de Informações de Rede fornece informação sobre a conexão do sistema, assim como a banda atual do dispositivo do usuário ou qualquer conexão que seja medida. Essa pode também ser usada para selecionar conteúdo de alta ou baixa definição baseado na conexão do usuário. Toda a API consiste na adição da interface domxref("Connection") e uma única propriedade a interface {{domxref("Navigator")}}: {{domxref("Navigator.connection")}}.

+ +

Detectando mudanças de conexão

+ +

Este é um exemplo vê mudança na conexão do usuário. Essa é similar a como uma app pode alertar quando o usuário move de uma conexão de alto para baixo custo por exemplo, a fim de reduzir a demanda da banda para previnir que o usuário seja submetido a cargos substanciais.

+ +
var connection = navigator.connection || navigator.mozConnection || navigator.webkitConnection;
+
+function updateConnectionStatus() {
+  alert("Connection bandwidth: " + connection.bandwidth + " MB/s");
+  if (connection.metered) {
+    alert("The connection is metered!");
+  }
+}
+
+connection.addEventListener("change", updateConnectionStatus);
+updateConnectionStatus();
+
+ +

Especificações

+ + + + + + + + + + + + + + + + +
SpecificationStatusComment
{{ SpecName('Network Information', '', 'Network Information API') }}{{ Spec2('Network Information') }}Initial specification
+ +

Compatibilidade com Navegadores

+ +

{{Page('/en-US/docs/Web/API/window.navigator.connection','Browser compatibility')}}

+ +

Veja também

+ + diff --git a/files/pt-br/webapi/network_stats/index.html b/files/pt-br/webapi/network_stats/index.html new file mode 100644 index 0000000000..9276841db3 --- /dev/null +++ b/files/pt-br/webapi/network_stats/index.html @@ -0,0 +1,86 @@ +--- +title: Network Stats +slug: WebAPI/Network_Stats +translation_of: Archive/B2G_OS/API/Network_Stats_API +--- +

{{ non-standard_header() }}

+

{{ B2GOnlyHeader2('certified') }}

+

Sumário

+

A API do Estado de Rede permite monitorar utilização de dados e expor esses dados para aplicações certificadas.

+

Os dados podem ser acessados através de {{domxref("window.navigator.mozNetworkStats","navigator.mozNetworkStats")}} que é uma instância da interface {{domxref("MozNetworkStatsManager")}}.

+

Acessando os dados

+

Informações sobre o volume de dados recebidos e enviados é automaticamente guardado no sistema.  É possível acessá-los utilizando o método {{domxref("MozNetworkStatsManager.getNetworkStats()")}}. Este método espera um objeto de configuração como seu primeiro parâmetro, que deve conter as seguintes propriedades:

+ +

Quando chamada, este método retorna um {{domxref("DOMRequest")}} para lidar com o sucesso ou falha das informações requisitadas. Em caso de sucesso o result requisitado é um objeto {{domxref("MozNetworkStats")}}.

+
var manageWifi   = navigator.mozNetworkStats.connectionTypes.indexOf('wifi')   > -1;
+var manageMobile = navigator.mozNetworkStats.connectionTypes.indexOf('mobile') > -1;
+
+var config = {
+  start: new Date(),
+  end  : new Date(),
+  connectionType: manageWifi ? 'wifi' : null
+};
+
+var request = navigator.mozNetworkStats.getNetworkStats(config);
+
+request.onsuccess = function () {
+  console.log("Data received: " + request.result.data[0].rxBytes + " bytes");
+  console.log("Data sent: " + request.result.data[0].txBytes + " bytes")
+}
+
+request.onerror = function () {
+  console.log("Something goes wrong: ", request.error);
+}
+
+

Amostragem ao longo do tempo

+

Para ter uma visão dos dados utilizados ao longo do tempo, as informações sobre a quantidade de dados é armazenada em blocos. Cada bloco é um valor representando a quantidade de dados trocados desde que o último bloco foi armazenado.

+

Quando requisitar os estados, o resultado do objeto {{domxref("MozNetworkStats")}} contém quantos o maior número de dados possíveis para um intervalo definido entre as datas de start e end. O número total de blocos depende de dois parâmetros (note que os parâmetros são apenas para leitura):

+ +

Cada bloco é um objeto {{domxref("MozNetworkStatsData")}}, e todos os blocos de dados para um determinado período de tempo estão disponíveis através da propriedade {{domxref("MozNetworkStats.data")}}, que são um Array de objetos {{domxref("MozNetworkStatsData")}}.

+
var rate = navigator.mozNetworkStats.sampleRate;
+var max  = navigator.mozNetworkStats.maxStorageSample;
+
+var config = {
+  start: new Date() - (rate * max), // This allows to get all the available data chunks.
+  end  : new Date(),
+  connectionType: 'mobile'
+};
+
+var request = navigator.mozNetworkStats.getNetworkStats(config);
+
+request.onsuccess = function () {
+  var total = {
+    receive: 0,
+    send   : 0
+  };
+
+  this.result.forEach(function (chunk) {
+    total.receive += chunk.rxBytes;
+    total.send    += chunk.txBytes;
+  });
+
+  console.log("Since: " + config.start.toString());
+  console.log("Data received: " + (total.receive * 1000).toFixed(2) + "Ko");
+  console.log("Data sent: " + (total.send * 1000).toFixed(2) + "Ko")
+}
+
+request.onerror = function () {
+  console.log("Something goes wrong: ", request.error);
+}
+

Especificações

+

Não faz parte de uma especificação

+

Veja também

+ diff --git a/files/pt-br/webapi/tcp_socket/index.html b/files/pt-br/webapi/tcp_socket/index.html new file mode 100644 index 0000000000..48b49f4132 --- /dev/null +++ b/files/pt-br/webapi/tcp_socket/index.html @@ -0,0 +1,75 @@ +--- +title: TCP Socket +slug: WebAPI/TCP_Socket +translation_of: Archive/B2G_OS/API/TPC_Socket_API +--- +

{{ non-standard_header() }}

+

{{ B2GOnlyHeader2('privileged') }}

+

Sumário

+

A API TCPSocket oferece

+

The TCPSocket API offers a whole API to open and use a TCP connection. This allows app makers to implement any protocol available on top of TCP such as IMAP, IRC, POP, HTTP, etc., or even build their own to sustain any specific needs they could have.

+

Permissões

+

Para utilizar essa API, como todas as API privilegiadas, é necessário que tenha permissão para utilizar dentro do app manifest.

+
"permissions" : {
+  "tcp-socket" : {
+    "description" : "Create TCP sockets and communicate over them."
+  }
+}
+

Overview

+

A API está disponível através da propriedade {{domxref("window.navigator.mozTCPSocket","navigator.mozTCPSocket")}} que por si é um objeto {{domxref("TCPSocket")}}.

+

Abrindo um socket.

+

Opening a socket is done with the {{domxref("TCPSocket.open()")}} method. This method expects up to three parameters:

+
    +
  1. A string representing the hostname of the server to connect to (it can also be its raw IP address).
    2. +
  2. A number representing the TCP port to be used by the socket (some protocols have a standard port, for example 80 for HTTP, 447 for SSL, 25 for SMTP, etc. Port numbers beyond 1024 are not assigned to any specific protocol and can be used for any purpose.)
    3. +
  3. A optional object containing up to two options: a boolean named useSSL is the socket needed to use SSL, false by default; and a string named binaryType allows to state the type of data retrieved by the application through the {{event("data")}} event, with the expected values string or arraybuffer. By default, it is string.
    4. +
+
var socket = navigator.mozTCPSocket.open('localhost', 80);
+
+

Nota: Apenas aplicações certificadas podem utilizar portas abaixo de 1024.

+
+

Enviando dado

+

Sending data is done using the {{domxref("TCPSocket.send()")}} method. The data sent can be either a string or a Uint8Array object; however, remember that a TCP socket always deals with binary data. For that reason, it's a lot safer to use Uint8Array instead of a string when sending data.

+

As per the TCP protocol, it's a good optimization to send a maximum of 64kb of data at the same time. As long as less than 64kb has been buffered, a call to the {{domxref("TCPSocket.send()","send")}} method returns true. Once the buffer is full, the method will return false which indicates the application should make a pause to flush the buffer. Each time the buffer is flushed, a {{event("drain")}} event is fired and the application can use it to resume data sending.

+

It's possible to know exactly the current amount of data buffered with the {{domxref("TCPSocket.bufferedAmount")}} property.

+
function getData() {
+  var data;
+
+  // do stuff that will retrieve data
+
+  return data;
+}
+
+function pushData() {
+  var data;
+
+  do {
+    data = getData();
+  } while (data != null && socket.send(data));
+}
+
+// Each time the buffer is flushed
+// we try to send data again.
+socket.ondrain = pushData;
+
+// Start sending data.
+pushData();
+
+

Pegando dado

+

Each time the socket gets some data from the host, it fires a {{event("data")}} event. This event will give access to the data from the socket. The type of the data depends on the option set when the socket was opened (see above).

+
socket.ondata = function (event) {
+  if (typeof event.data === 'string') {
+    console.log('Get a string: ' + event.data);
+  } else {
+    console.log('Get a Uint8Array');
+  }
+}
+

As the {{event("data")}} event is fired as much as needed, it can sometimes be necessary to pause the flow of incoming data. To that end, calling the {{domxref("TCPSocket.suspend()")}} method will pause reading incoming data and stop firing the {{event("data")}}. It's possible to start reading data and firing events again by calling the {{domxref("TCPSocket.resume()")}} method.

+

Fechando um socket

+

Closing a socket is simply done using {{domxref("TCPSocket.close()")}}.

+

Padrão

+

Not part of any specification yet; however, this API is discussed at W3C as part of the System Applications Working Group under the Raw Sockets proposal.

+

Veja também

+ diff --git a/files/pt-br/webapi/web_activities/index.html b/files/pt-br/webapi/web_activities/index.html new file mode 100644 index 0000000000..0eae803549 --- /dev/null +++ b/files/pt-br/webapi/web_activities/index.html @@ -0,0 +1,421 @@ +--- +title: Web Activities +slug: WebAPI/Web_Activities +translation_of: Archive/B2G_OS/API/Web_Activities +--- +

{{ non-standard_header() }}

+

{{B2GOnlyHeader2('installed')}}

+

Sumário

+

Atividades Web define um modo para as aplicações delegarem uma atividade para a outra (geralmente escolhida pelo usuário) aplicação.

+

Atividades Web estão atualmente habilitadas no Firefox OS apenas, e toda a especificação está disponível no WikiMo.

+

Atividades

+

An activity is something a user wants to do: pick an image, send an e-mail, etc. App authors may want to define an app that can handle an activity or that can delegate to an activity.

+

Registering an App as an activity handler

+

App authors can build an app that will handle one or more activities. That means that the app will be callable by another app to perform some specific actions defined by the activity. For example, let's pretend we want to build a photo manager. It could be used by another application to pick a photo. As an activity handler our app will become part of the other application's workflow.

+

Registrar uma atividade

+

There is currently only one way to register an app as an activity handler: declaring it in the app manifest.

+
+

Note: Any application can register itself as an activity handler for any existing activity or create its own activity. In both cases it's done the same way within the app manifest. However, when creating a new activity, it is considered best practice to avoid activities' name collisions by prefixing the name of the new activity with a URL (e.g., + + example.org/myActivity + or + + org.example.myActivity + ).

+
+

App manifest (a.k.a. declaration registration)

+

We have to use the app manifest to express that our app is expected to handle an activity as in this example:

+
{
+  // Other App Manifest related stuff
+
+  // Activity registration
+  "activities": {
+
+    // The name of the activity to handle (here "pick")
+    "pick": {
+      "href": "./pick.html",
+      "disposition": "inline",
+      "filters": {
+        "type": ["image/*","image/jpeg","image/png"]
+      },
+      "returnValue": true
+    }
+  }
+}
+
+

Dynamic registration

+

There are plans to let an app register itself dynamically by using the {{domxref("window.navigator","navigator")}} object. However, this API is not available yet. See {{bug("775181")}} to follow the work about that specific API.

+

Activity handler description

+
+
+ href
+
+ When another app or Web page initiates an activity that is supported by this app, if this app is chosen to perform the activity, this specifies the page that will be opened. It will be opened in the manner specified by the disposition property. +
+ Note: The URL of this page is restricted by the rules of the same origin policy.
+
+
+
+
+ disposition {{optional_inline()}}
+
+
+
+ Specifies how the page specified in href is presented when an activity is invoked. The value, if specified, must be one of the following (if omitted, defaults to window): +
    +
  • window - The page handling the activity is opened in a new "window" (on a mobile device this view will replace the original app that requested the activity). The page must call {{domxref("window.navigator.mozSetMessageHandler()","navigator.mozSetMessageHandler()")}} for each activity it supports and subsequently execute the activity for which it receives a message.
    • +
  • inline - The page that handles the activity will open in an overlay (on a mobile device this will be rendered in a popup over the original app that requested the activity). Subsequent behavior is exactly the same as if disposition were window.
    • +
+
+
+
+
+ returnValue {{optional_inline()}}
+
+ States if the activity will return a value or not. If an application doesn't plan to return a value, the UA may send a + + success + event as soon as an application has been picked. If a value is expected, the activity handler must call {{domxref("MozActivityRequestHandler.postResult()")}} if the activity is successful or {{domxref("MozActivityRequestHandler.postError()")}} if the activity fails (where {{domxref("MozActivityRequestHandler")}} is the type of the first argument provided to the function specified within {{domxref("window.navigator.mozSetMessageHandler()","mozSetMessageHandler")}} by the activity handler). The success or error event will be respectively fired after {{domxref("MozActivityRequestHandler.postResult()","postResult")}} or {{domxref("MozActivityRequestHandler.postError()","postError")}} has been called by the activity handler.
+
+
+
+ filters {{optional_inline()}}
+
+ A dictionary where each property of which specifies a filter. These filters will be applied while determining apps suitable for handling a given activity. Filter names are free-form text and should mirror {{domxref("MozActivityOptions.data","data")}} properties' names from {{domxref("MozActivityOptions")}}. Filters' values are either a basic value (string or number), an array of basic values, or a filter definition object. An activity will be considered as able to handle an activity only if the filters are all satisfied.
+
+

The way filters are handled depend on each filter value:

+ +

Handle an activity

+

Once our application is declared as an activity handler, we have to make it concrete by performing some actions when receiving an activity request from another app.

+

To handle the activity, we have to register a function that will perform all the necessary actions. To do so, we need to set a message handler with {{domxref("window.navigator.mozSetMessageHandler()","navigator.mozSetMessageHandler()")}}, specifically assigned to the 'activity' message (and not the name of the activity). A {{domxref("MozActivityRequestHandler")}} object is passed as an argument of the activity handler function.

+
navigator.mozSetMessageHandler('activity', function(activityRequest) {
+  // Do something to handle the activity
+});
+

As the activity handler function is performing an action, it will use the activity request to retrieve information about the activity and to send back an answer if necessary.

+

The app that calls the activity has to provide some data (see below). This data can be reached through the request's {{domxref("MozActivityRequestHandler.source","source")}} properties which is a {{domxref("MozActivityOptions")}} object. This object provides the {{domxref("MozActivityOptions.name","name")}} of the activity call and the associated {{domxref("MozActivityOptions.data","data")}}.

+
navigator.mozSetMessageHandler('activity', function(activityRequest) {
+  var option = activityRequest.source;
+
+  if (option.name === "pick") {
+    // Do something to handle the activity
+  }
+});
+

Once we have performed all the actions to handle the activity, we can call the request's {{domxref("MozActivityRequestHandler.postResult()","postResult()")}} method to send the result back to the app that delegated the activity.

+

If something goes wrong we can call the request's {{domxref("MozActivityRequestHandler.postError()","postError()")}} method to send back an error message about the activity.

+
navigator.mozSetMessageHandler('activity', function(activityRequest) {
+  var option = activityRequest.source;
+
+  if (option.name === "pick") {
+    // Do something to handle the activity
+    ...
+
+    // Send back the result
+    if (picture) {
+      activityRequest.postResult(picture);
+    } else {
+      activityRequest.postError("Unable to provide a picture");
+    }
+  }
+});
+
+

Note: UA is expected to send an error anyway at some point if neither {{domxref("MozActivityRequestHandler.postError()","postError")}} nor {{domxref("MozActivityRequestHandler.postResult()","postResult()")}} are called--for example, if the user leaves the application (closes the tab on desktop or goes back to the home screen on a mobile device).

+
+

Starting an activity

+

On the other side of Web Activities, there are apps that want to delegate an activity to our app. To perform such delegation, the apps have to call an activity by instantiating a {{domxref("MozActivity")}} object. Such objects are nothing less than {{domxref("DOMRequest")}} objects that allow to wait for any response from the activity handler. As soon as the object is constructed, the activity is started, and the UI is shown to the user as soon as possible.

+
var activity = new MozActivity({
+  // Ask for the "pick" activity
+  name: "pick",
+
+  // Provide the data required by the filters of the activity
+  data: {
+    type: "image/jpeg"
+  }
+});
+
+activity.onsuccess = function() {
+  var picture = this.result;
+  console.log("A picture has been retrieved");
+};
+
+activity.onerror = function() {
+  console.log(this.error);
+};
+
+

Firefox OS activities

+

Gaia, the native interface for Firefox OS, provides many built-in applications that define basic activities. Those activities are the following:

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
NameApplicationExpected Data (filters)Comments
browseGallery + 
+type: "photos"
+ 		 
configureSettings + 
+target: "device"
+ 		 
costcontrol/balanceCostcontrolNone 
costcontrol/data_usageCostcontrolNone 
costcontrol/telephonyCostcontrolNone 
dialCommunication + 
+type: "webtelephony/number",
+number: {
+  regexp:/^[\\d\\s+#*().-]{0,50}$/
+}
+ 		Used when an app wants to pass a phone call.
newCommunication + 
+type: "webcontacts/contact"
+ 		Used when an app wants to create a new contact entry.
Email + 
+type: "mail"
+ 		 
SMS + 
+type: "websms/sms",
+number: {
+  regexp:/^[\\w\\s+#*().-]{0,50}$/
+}
+ 		Used when an app wants to send an SMS.
openCommunication + 
+type: "webcontacts/contact"
+ 		 
Gallery + 
+type: [
+  "image/jpeg",
+  "image/png",
+  "image/gif",
+  "image/bmp"
+]
+ 		 
Music + 
+type: [
+  "audio/mpeg",
+  "audio/ogg",
+  "audio/mp4"
+]
+ 		 
Video + 
+type: [
+  "video/webm",
+  "video/mp4",
+  "video/3gpp",
+  "video/youtube"
+]
+

Also expect a blob property which is a {{domxref("Blob")}} object.

+ 		Used when an app wants to display a video (the view activity allows to do the same).
pickCamera, Gallery, Wallpaper + 
+type: ["image/*", "image/jpeg"]
+ 		Used when an app wants to get a picture.
Communication + 
+type: [
+  "webcontacts/contact",
+  "webcontacts/email"
+]
+ 		Used when an app wants to retrieve some contact information or an e-mail.
recordCamera + 
+type: ["photos", "videos"]
+ 		Used when an app wants to record some video.
save-bookmarkHomescreen + 
+type: "url",
+url: {
+  required:true,
+  regexp:/^https?:/
+}
+ 		 
shareBluetooth + 
+number: 1
+
+ 		 
Email, Wallpaper + 
+type: "image/*"
+ 		Used when an app wants to share an image.
viewBrowser + 
+type: "url"
+url: {
+  required: true,
+  regexp: /^https?:.{1,16384}$/
+}
+ 		Used when an app wants to open a URL.
Email + 
+type: "url",
+url: {
+  required:true,
+  regexp:/^mailto:/
+}
+ 		 
PDFs + 
+type: "application/pdf"
+ 		Used when an app wants to display the content of a PDF document.
Video + 
+type: [
+  "video/webm",
+  "video/mp4",
+  "video/3gpp",
+  "video/youtube"
+]
+

Also expect a url property which is a string.

+ 		Used when an app wants to display a video (the open activity allows to do the same).
updateCommunication + 
+type: "webcontacts/contact"
+ 		Used when an app wants to update a contact.
+

Specification

+

Web Activities is not part of any specification. However, it has some overlap with the proposed Web Intents specification. Mozilla actually proposed Web Activities as a counter proposal to Web Intents. For more information about this, see discussion on the Web Intents Task Force ML.

+

See also

+ diff --git a/files/pt-br/webapi/websms/index.html b/files/pt-br/webapi/websms/index.html new file mode 100644 index 0000000000..db11b891c0 --- /dev/null +++ b/files/pt-br/webapi/websms/index.html @@ -0,0 +1,136 @@ +--- +title: WebSMS +slug: WebAPI/WebSMS +tags: + - MMS + - SMS + - WebSMS +translation_of: Archive/B2G_OS/API/Mobile_Messaging_API +--- +

{{ non-standard_header() }}

+ +

{{ B2GOnlyHeader2('certified') }}

+ +

Resumo

+ +

WebSMS é uma API que possibilita a criação, envio e recebimento de SMS (Short Message Service) ou MMS (Multimedia Messaging Service).

+ +

A API está disponível usando {{ domxref("window.navigator.mozSms") }} que retorna um objeto {{ domxref("MozSmsManager") }} ou {{ domxref("window.navigator.mozMobileMessage") }} que retorna {{ domxref("MozMobileMessageManager") }}. Veja abaixo uma lista completa com o métodos:

+ +

Interfaces do DOM

+ +

SMS

+ + + +

MMS e SMS

+ + + +

Código de exemplo e introdução

+ + + +

Especificações

+ +

Essa especificação ainda não é padrão, mas já está em discussão no W3C como parte do System Application Working Group.

+ + + + + + + + + + + + + + + + +
EspecificaçãoStatusComentário
{{SpecName('Messaging')}}{{Spec2('Messaging')}}projeto de edição (WIP).
+ +

Compatibilidade dos browsers

+ +

Pro razões óbvias, o suprote é esperado primeiramente em browser para dispositivos móveis.

+ +

{{ CompatibilityTable() }}

+ +
+ + + + + + + + + + + + + + + + + + + +
FeatureChromeFirefox (Gecko)Internet ExplorerOperaSafari
Suporte Básico{{ CompatNo() }}{{ CompatNo() }}{{ CompatNo() }}{{ CompatNo() }}{{ CompatNo() }}
+
+ +
+ + + + + + + + + + + + + + + + + + + +
FeatureAndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Suporte Básico{{ CompatNo() }}{{ CompatGeckoMobile("12.0") }}{{ CompatNo() }}{{ CompatNo() }}{{ CompatNo() }}
+
+ +

 

+ +

Preferências e disponibilidade

+ + + +

Veja também

+ + -- cgit v1.2.3-54-g00ecf