From a065e04d529da1d847b5062a12c46d916408bf32 Mon Sep 17 00:00:00 2001 From: Peter Bengtsson Date: Tue, 8 Dec 2020 21:46:22 -0500 Subject: update based on https://github.com/mdn/yari/issues/2028 --- files/es/archive/b2g_os/api/callevent/index.html | 117 ---- .../b2g_os/api/cameramanager/getcamera/index.html | 126 ---- .../es/archive/b2g_os/api/cameramanager/index.html | 62 -- files/es/archive/b2g_os/api/index.html | 120 ---- files/es/archive/b2g_os/api/mozactivity/index.html | 69 -- .../b2g_os/api/mozvoicemailstatus/index.html | 67 -- files/es/archive/b2g_os/api/navigator/index.html | 12 - .../b2g_os/api/navigator/mozalarms/index.html | 116 ---- .../b2g_os/api/navigator/mozapps/index.html | 96 --- .../b2g_os/api/navigator/moztelephony/index.html | 83 --- files/es/archive/b2g_os/api/telephony/index.html | 141 ---- .../b2g_os/api/telephonycall/hangup/index.html | 118 ---- .../es/archive/b2g_os/api/telephonycall/index.html | 185 ----- .../b2g_os/api/telephonycall/number/index.html | 125 ---- .../b2g_os/api/telephonycall/onincoming/index.html | 120 ---- files/es/archive/b2g_os/api/window/index.html | 27 - .../b2g_os/application_development/index.html | 11 - .../index.html | 29 - files/es/archive/b2g_os/apps/index.html | 62 -- files/es/archive/b2g_os/architecture/index.html | 759 --------------------- .../dispositivos_compatibles/index.html | 360 ---------- .../firefox_os_build_process_summary/index.html | 109 --- .../index.html | 82 --- .../building_b2g_for_qemu_emulator/index.html | 37 - .../b2g_os/compilar_boot_to_gecko/index.html | 123 ---- files/es/archive/b2g_os/complementos/index.html | 58 -- .../b2g_os/consejos_uso_firefox_os/index.html | 21 - .../debugging/depurar_b2g_usando_gdb/index.html | 79 --- .../b2g_os/debugging/developer_settings/index.html | 194 ------ files/es/archive/b2g_os/debugging/index.html | 74 -- .../personalizando_el_script_b2g.sh/index.html | 42 -- .../archive/b2g_os/debugging/setting_up/index.html | 37 - .../entendiendo_el_codigo_base_de_gaia/index.html | 104 --- files/es/archive/b2g_os/developing_gaia/index.html | 61 -- .../running_the_gaia_codebase/index.html | 47 -- .../elegir_como_ejecutar_gaia_o_b2g/index.html | 61 -- .../firefox_os_apps/building_blocks/index.html | 195 ------ files/es/archive/b2g_os/firefox_os_apps/index.html | 85 --- .../firefox_os_build_prerequisites/index.html | 204 ------ .../archive/b2g_os/gaia_hacking_guide/index.html | 6 - files/es/archive/b2g_os/gonk/index.html | 23 - files/es/archive/b2g_os/index.html | 94 --- .../installing_on_a_mobile_device/index.html | 79 --- files/es/archive/b2g_os/introduction/index.html | 27 - .../b2g_os/phone_guide/fairphone/index.html | 186 ----- .../flame/configuracion_inicial/index.html | 122 ---- .../es/archive/b2g_os/phone_guide/flame/index.html | 78 --- .../flame/updating_your_flame/index.html | 301 -------- files/es/archive/b2g_os/phone_guide/fx0/index.html | 51 -- .../b2g_os/phone_guide/geeksphone/index.html | 124 ---- files/es/archive/b2g_os/phone_guide/index.html | 43 -- .../phone_guide/lista_dispositivos/index.html | 712 ------------------- .../archive/b2g_os/phone_guide/zte_open/index.html | 287 -------- .../b2g_os/phone_guide/zte_open_c/index.html | 226 ------ .../b2g_os/platform/gaia/hacking/index.html | 226 ------ files/es/archive/b2g_os/platform/gaia/index.html | 61 -- .../platform/gaia/introduction_to_gaia/index.html | 13 - files/es/archive/b2g_os/platform/index.html | 94 --- .../b2g_os/platform/settings_list/index.html | 709 ------------------- files/es/archive/b2g_os/portando/index.html | 369 ---------- .../archive/b2g_os/porting_firefox_os/index.html | 71 -- .../portando_de_cyanogenmod/index.html | 239 ------- .../preparing_for_your_first_b2g_build/index.html | 151 ---- .../archive/b2g_os/probando_firefox_os/index.html | 81 --- .../archive/b2g_os/quickstart/app_tools/index.html | 16 - files/es/archive/b2g_os/quickstart/index.html | 49 -- .../quickstart/intro_to_manifests/index.html | 90 --- .../introduccion_a_las_open_web_apps/index.html | 108 --- .../quickstart/tu_primera_aplicacion/index.html | 257 ------- files/es/archive/b2g_os/releases/2.0/index.html | 116 ---- files/es/archive/b2g_os/releases/2.1/index.html | 40 -- files/es/archive/b2g_os/releases/index.html | 24 - .../index.html | 228 ------- .../security/application_security/index.html | 118 ---- files/es/archive/b2g_os/security/index.html | 72 -- .../b2g_os/security/modelo_seguridad/index.html | 255 ------- files/es/archive/b2g_os/simulator/index.html | 258 ------- .../usando_el_b2g_escritorio_cliente/index.html | 134 ---- .../b2g_os/using_firefox_os_simulator/index.html | 57 -- .../b2g_os/using_the_app_manager/index.html | 179 ----- .../building_blocks/action_menu/coding/index.html | 80 --- .../ux/building_blocks/action_menu/index.html | 46 -- .../b2g_os/ux/building_blocks/button/index.html | 231 ------- .../archive/b2g_os/ux/building_blocks/index.html | 268 -------- files/es/archive/b2g_os/ux/guia_estilo/index.html | 62 -- .../es/archive/b2g_os/web_telephony_api/index.html | 28 - .../introduccion_a_la_webtelephony/index.html | 64 -- 87 files changed, 11571 deletions(-) delete mode 100644 files/es/archive/b2g_os/api/callevent/index.html delete mode 100644 files/es/archive/b2g_os/api/cameramanager/getcamera/index.html delete mode 100644 files/es/archive/b2g_os/api/cameramanager/index.html delete mode 100644 files/es/archive/b2g_os/api/index.html delete mode 100644 files/es/archive/b2g_os/api/mozactivity/index.html delete mode 100644 files/es/archive/b2g_os/api/mozvoicemailstatus/index.html delete mode 100644 files/es/archive/b2g_os/api/navigator/index.html delete mode 100644 files/es/archive/b2g_os/api/navigator/mozalarms/index.html delete mode 100644 files/es/archive/b2g_os/api/navigator/mozapps/index.html delete mode 100644 files/es/archive/b2g_os/api/navigator/moztelephony/index.html delete mode 100644 files/es/archive/b2g_os/api/telephony/index.html delete mode 100644 files/es/archive/b2g_os/api/telephonycall/hangup/index.html delete mode 100644 files/es/archive/b2g_os/api/telephonycall/index.html delete mode 100644 files/es/archive/b2g_os/api/telephonycall/number/index.html delete mode 100644 files/es/archive/b2g_os/api/telephonycall/onincoming/index.html delete mode 100644 files/es/archive/b2g_os/api/window/index.html delete mode 100644 files/es/archive/b2g_os/application_development/index.html delete mode 100644 files/es/archive/b2g_os/apps/escribiendo_una_aplicacion_web_para_b2g/index.html delete mode 100644 files/es/archive/b2g_os/apps/index.html delete mode 100644 files/es/archive/b2g_os/architecture/index.html delete mode 100644 files/es/archive/b2g_os/building_and_installing_boot_to_gecko/dispositivos_compatibles/index.html delete mode 100644 files/es/archive/b2g_os/building_and_installing_boot_to_gecko/firefox_os_build_process_summary/index.html delete mode 100644 files/es/archive/b2g_os/building_and_installing_boot_to_gecko/index.html delete mode 100644 files/es/archive/b2g_os/building_b2g_for_qemu_emulator/index.html delete mode 100644 files/es/archive/b2g_os/compilar_boot_to_gecko/index.html delete mode 100644 files/es/archive/b2g_os/complementos/index.html delete mode 100644 files/es/archive/b2g_os/consejos_uso_firefox_os/index.html delete mode 100644 files/es/archive/b2g_os/debugging/depurar_b2g_usando_gdb/index.html delete mode 100644 files/es/archive/b2g_os/debugging/developer_settings/index.html delete mode 100644 files/es/archive/b2g_os/debugging/index.html delete mode 100644 files/es/archive/b2g_os/debugging/personalizando_el_script_b2g.sh/index.html delete mode 100644 files/es/archive/b2g_os/debugging/setting_up/index.html delete mode 100644 files/es/archive/b2g_os/developing_gaia/entendiendo_el_codigo_base_de_gaia/index.html delete mode 100644 files/es/archive/b2g_os/developing_gaia/index.html delete mode 100644 files/es/archive/b2g_os/developing_gaia/running_the_gaia_codebase/index.html delete mode 100644 files/es/archive/b2g_os/elegir_como_ejecutar_gaia_o_b2g/index.html delete mode 100644 files/es/archive/b2g_os/firefox_os_apps/building_blocks/index.html delete mode 100644 files/es/archive/b2g_os/firefox_os_apps/index.html delete mode 100644 files/es/archive/b2g_os/firefox_os_build_prerequisites/index.html delete mode 100644 files/es/archive/b2g_os/gaia_hacking_guide/index.html delete mode 100644 files/es/archive/b2g_os/gonk/index.html delete mode 100644 files/es/archive/b2g_os/index.html delete mode 100644 files/es/archive/b2g_os/installing_on_a_mobile_device/index.html delete mode 100644 files/es/archive/b2g_os/introduction/index.html delete mode 100644 files/es/archive/b2g_os/phone_guide/fairphone/index.html delete mode 100644 files/es/archive/b2g_os/phone_guide/flame/configuracion_inicial/index.html delete mode 100644 files/es/archive/b2g_os/phone_guide/flame/index.html delete mode 100644 files/es/archive/b2g_os/phone_guide/flame/updating_your_flame/index.html delete mode 100644 files/es/archive/b2g_os/phone_guide/fx0/index.html delete mode 100644 files/es/archive/b2g_os/phone_guide/geeksphone/index.html delete mode 100644 files/es/archive/b2g_os/phone_guide/index.html delete mode 100644 files/es/archive/b2g_os/phone_guide/lista_dispositivos/index.html delete mode 100644 files/es/archive/b2g_os/phone_guide/zte_open/index.html delete mode 100644 files/es/archive/b2g_os/phone_guide/zte_open_c/index.html delete mode 100644 files/es/archive/b2g_os/platform/gaia/hacking/index.html delete mode 100644 files/es/archive/b2g_os/platform/gaia/index.html delete mode 100644 files/es/archive/b2g_os/platform/gaia/introduction_to_gaia/index.html delete mode 100644 files/es/archive/b2g_os/platform/index.html delete mode 100644 files/es/archive/b2g_os/platform/settings_list/index.html delete mode 100644 files/es/archive/b2g_os/portando/index.html delete mode 100644 files/es/archive/b2g_os/porting_firefox_os/index.html delete mode 100644 files/es/archive/b2g_os/porting_firefox_os/portando_de_cyanogenmod/index.html delete mode 100644 files/es/archive/b2g_os/preparing_for_your_first_b2g_build/index.html delete mode 100644 files/es/archive/b2g_os/probando_firefox_os/index.html delete mode 100644 files/es/archive/b2g_os/quickstart/app_tools/index.html delete mode 100644 files/es/archive/b2g_os/quickstart/index.html delete mode 100644 files/es/archive/b2g_os/quickstart/intro_to_manifests/index.html delete mode 100644 files/es/archive/b2g_os/quickstart/introduccion_a_las_open_web_apps/index.html delete mode 100644 files/es/archive/b2g_os/quickstart/tu_primera_aplicacion/index.html delete mode 100644 files/es/archive/b2g_os/releases/2.0/index.html delete mode 100644 files/es/archive/b2g_os/releases/2.1/index.html delete mode 100644 files/es/archive/b2g_os/releases/index.html delete mode 100644 files/es/archive/b2g_os/screencast_series_colon__app_basics_for_firefox_os/index.html delete mode 100644 files/es/archive/b2g_os/security/application_security/index.html delete mode 100644 files/es/archive/b2g_os/security/index.html delete mode 100644 files/es/archive/b2g_os/security/modelo_seguridad/index.html delete mode 100644 files/es/archive/b2g_os/simulator/index.html delete mode 100644 files/es/archive/b2g_os/usando_el_b2g_escritorio_cliente/index.html delete mode 100644 files/es/archive/b2g_os/using_firefox_os_simulator/index.html delete mode 100644 files/es/archive/b2g_os/using_the_app_manager/index.html delete mode 100644 files/es/archive/b2g_os/ux/building_blocks/action_menu/coding/index.html delete mode 100644 files/es/archive/b2g_os/ux/building_blocks/action_menu/index.html delete mode 100644 files/es/archive/b2g_os/ux/building_blocks/button/index.html delete mode 100644 files/es/archive/b2g_os/ux/building_blocks/index.html delete mode 100644 files/es/archive/b2g_os/ux/guia_estilo/index.html delete mode 100644 files/es/archive/b2g_os/web_telephony_api/index.html delete mode 100644 files/es/archive/b2g_os/web_telephony_api/introduccion_a_la_webtelephony/index.html (limited to 'files/es/archive/b2g_os') diff --git a/files/es/archive/b2g_os/api/callevent/index.html b/files/es/archive/b2g_os/api/callevent/index.html deleted file mode 100644 index ceb6219d5a..0000000000 --- a/files/es/archive/b2g_os/api/callevent/index.html +++ /dev/null @@ -1,117 +0,0 @@ ---- -title: CallEvent -slug: Archive/B2G_OS/API/CallEvent -translation_of: Archive/B2G_OS/API/CallEvent ---- -

-

No estándar
- This feature is non-standard and is not on a standards track. Do not use it on production sites facing the Web: it will not work for every user. There may also be large incompatibilities between implementations and the behavior may change in the future.

-

- -

-

This API is available on Firefox OS for internal applications only.

-

- -

Resumen

- -

El DOM CallEvent representa eventos relacionados con las llamadas telefonicas.

- -

Propiedades

- -
-
CallEvent.call Read only
-
Un objeto TelephonyCall representa la llamada de la que se originó el evento.
-
- -

Especificaciones

- -

No es una implementacion estandar, pero se dicote en el W3C como parte del Grupo de trabajo de aplicaciones del sistema.

- - - - - - - - - - - - - - - - -
EspecificacionEstatusComentario
Web TelephonyDraftEditor Draft (WIP).
- -

Compatibilidad de navegador

- -

Por razones obvias, el apoyo se espera principalmente en los navegadores móviles.

- -

We're converting our compatibility data into a machine-readable JSON format. - This compatibility table still uses the old format, - because we haven't yet converted the data it contains. - Find out how you can help!

- -
- - -

- -
- - - - - - - - - - - - - - - - - - - -
CaracteristicaChromeFirefox (Gecko)Internet ExplorerOperaSafari
Soporte basicoSin soporteSin soporteSin soporteSin soporteSin soporte
-
- -
- - - - - - - - - - - - - - - - - - - -
CaracteristicaAndroidFirefox Mobil (Gecko)IE MobilOpera MobilSafari Mobil
Soporte basicoSin soporte12.0 (12.0)Sin soporteSin soporteSin soporte
-
- -

Ver también

- - diff --git a/files/es/archive/b2g_os/api/cameramanager/getcamera/index.html b/files/es/archive/b2g_os/api/cameramanager/getcamera/index.html deleted file mode 100644 index 605e8229b7..0000000000 --- a/files/es/archive/b2g_os/api/cameramanager/getcamera/index.html +++ /dev/null @@ -1,126 +0,0 @@ ---- -title: CameraManager.getCamera() -slug: Archive/B2G_OS/API/CameraManager/getCamera -translation_of: Archive/B2G_OS/API/CameraManager/getCamera ---- -
-

This API is available on Firefox OS for privileged or certified applications only.

-
- -

Resumen

- -

Este método es usado para acceder a una de las camaras validas en el dispositivo basado en el identificador. Puedes obtener una lista de las camaras validas para ser llamadas por el método CameraManager.getListOfCameras() .

- -

Sintaxis (pre Firefox OS 2.2)

- -
CameraManager.getCamera(camera, cameraConfiguration, onsuccess[, onerror]);
- -

Parametros

- -
-
camera
-
Especifica la camara que desea usarse (el dispositivo puede tener mas de una camara).
-
cameraConfiguration
-
Un objeto permite al conjunto de opciones de la camara por esta camara: mode, previewSize y recorderProfile
-
onsuccess
-
una función de llamada que toma un objeto CameraControl como parametro.
-
onerror
-
Una opcional función de llamada que acepta una cadena de error como un parametro.
-
- -

Ejemplo

- -
var options = {
-  mode: 'picture',
-  recorderProfile: 'jpg',
-  previewSize: {
-    width: 352,
-    height: 288
-  }
-};
-
-var camera = navigator.mozCameras.getListOfCameras()[0];
-
-function onSuccess(camera) {
-  // Do stuff with the camera
-};
-
-function onError(error) {
-  console.warn(error);
-};
-
-navigator.mozCameras.getCamera(camera, options, onSuccess, onError);
-
- -

Sintaxis (Firefox OS 2.2+)

- -
Promise CameraManager.getCamera(camera, cameraConfiguration);
- -

Parametros

- -
-
camera
-
Especifica la camara que deseas usar (El dispositivo puede tener mas de una camara).
-
cameraConfiguration
-
Un objeto permite al conjunto de opciones de la camara por esta camara: mode, previewSize y recorderProfile
-
- -

Valor de retorno

- -

retorna un Promise.  La función Promise's .then() acepta dos argumentos en la función:

- -
-
onsuccess
-
Una función de llamada que toma un objeto como parametro. Este objeto tiene la propiedad camara como objeto CameraControl y la configuracion de la propiedad como actual cameraConfiguration del dispositivo.
-
onerror
-
Una opcional función de llamada que acepta una cadena de error como un parametro.
-
- -

Ejemplo

- -
var options = {
-  mode: 'picture',
-  recorderProfile: 'jpg',
-  previewSize: {
-    width: 352,
-    height: 288
-  }
-};
-
-var camera = navigator.mozCameras.getListOfCameras()[0];
-
-function onSuccess(cameraObj) {
-  var cameraControl = cameraObj.camera;
-  // Do stuff with the cameraControl
-};
-
-function onError(error) {
-  console.warn(error);
-};
-
-navigator.mozCameras.getCamera(camera, options).then(onSuccess, onError);
-
- -

Especificaciones

- -

no forma parte de cualquier especificación aun; este propablemente será reemplazado por  WebRTC cuando este gane mas soporte generalizado en dispositivos moviles .

- -

Permisos

- -

Hasta Firefox OS 1.4, la api de la camara es una api certificada, pero no es accesible para aplicaciones  de tercera partes. Para Firefox OS 2.0 en adelante, el nivel de permisos han sido degradado a privilegiado, pero este es ahora valido para desarrolladores  que usen en sus aplicaciones.

- -
"type": "privileged"
- -
"permissions": {
-  "camera": {
-    "description": "Required for accessing cameras on the device."
-  }
-}
- -

Ver también

- - diff --git a/files/es/archive/b2g_os/api/cameramanager/index.html b/files/es/archive/b2g_os/api/cameramanager/index.html deleted file mode 100644 index 492feb0803..0000000000 --- a/files/es/archive/b2g_os/api/cameramanager/index.html +++ /dev/null @@ -1,62 +0,0 @@ ---- -title: CameraManager -slug: Archive/B2G_OS/API/CameraManager -tags: - - API - - B2G - - Certified Only - - DOM - - DOM Reference - - Firefox OS - - Graphics - - JavaScript - - NeedsTranslation - - Non-standard - - Reference - - Référence(2) - - TopicStub - - WebAPI - - camera -translation_of: Archive/B2G_OS/API/CameraManager ---- -

- -

-

This API is available on Firefox OS for privileged or certified applications only.

-

- -

The CameraManager interface provides access to any cameras available on the device being used.

- -

Properties

- -

This interface doesn't implements, nor inherits any property.

- -

Methods

- -
-
CameraManager.getCamera()
-
Gets a camera instance based on its identifier.
-
CameraManager.getListOfCameras()
-
Returns an Array of all camera identifiers available on the device.
-
- -

Specification

- -

Not part of any specification as yet; this will probably be replaced by WebRTC when it gains more widespread support on mobile devices.

- -

Permissions

- -

Up until Firefox OS 1.4, The Camera API was a certified API, so not accessible to third party apps. From Firefox OS 2.0 onwards, the permission level has been downgraded to privileged, so it is now available for developers to use in their apps.

- -
"permissions": {
-  "camera": {
-    "description": "Required for accessing cameras on the device."
-  }
-}

- -

See also

- - diff --git a/files/es/archive/b2g_os/api/index.html b/files/es/archive/b2g_os/api/index.html deleted file mode 100644 index 8826729643..0000000000 --- a/files/es/archive/b2g_os/api/index.html +++ /dev/null @@ -1,120 +0,0 @@ ---- -title: Firefox OS APIs -slug: Archive/B2G_OS/API -tags: - - NeedsTranslation - - TopicStub -translation_of: Archive/B2G_OS/API ---- -

- -

This page lists all Firefox OS-specific APIs.

- -

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

diff --git a/files/es/archive/b2g_os/api/mozactivity/index.html b/files/es/archive/b2g_os/api/mozactivity/index.html deleted file mode 100644 index d3fb6a28fe..0000000000 --- a/files/es/archive/b2g_os/api/mozactivity/index.html +++ /dev/null @@ -1,69 +0,0 @@ ---- -title: MozActivity -slug: Archive/B2G_OS/API/MozActivity -translation_of: Archive/B2G_OS/API/MozActivity ---- -

-

-

No estándar
- This feature is non-standard and is not on a standards track. Do not use it on production sites facing the Web: it will not work for every user. There may also be large incompatibilities between implementations and the behavior may change in the future.

-

-

-

This API is available on Firefox or Firefox OS for installed or higher privileged applications.

-

-

Summary

-

The MozActivity interface allows apps to delegate an activity to another app.

-

This interface fully inherits from the DOMRequest interface excepts that it has a constructor that it takes a MozActivityOptions as a parameter.

-
-

Note: As soon as a MozActivity is instentiated, the system will prompt the user to choose an activity handler. It's not possible to instentiate an activity and wait to use it.

-
-

Properties

-

Inherited from DOMRequest:

-

-
DOMRequest.onsuccess
-
A callback handler called when the operation represented by the DOMRequest is completed.
-
DOMRequest.onerror
-
A callback handler that gets called when an error occurs while processing the operation.
-
DOMRequest.readyState
-
A string indicating whether or not the operation is finished running. Its value is either "done" or "pending".
-
DOMRequest.result
-
The operation's result.
-
DOMRequest.error
-
Error information, if any.
-

-
-
-

Methods

-

None.

-

Example

-
var activity = new MozActivity({
-  // The name of the activity the app wants to delegate the action
-  name: "pick",
-
-  // Data requierd by the activity. Each application acting as an activity handler
-  // can have it's own requirement for the activity. If the data does not fulfill
-  // all the requirement of any activity handler, the error event will be sent
-  // otherwise, the event sent depend on the activity handler itself.
-  data: {
-    type: "image/jpeg"
-  }
-});
-
-activity.onsuccess = function() {
-  console.log("Activity successfuly handled");
-
-  var imgSrc = this.result.blob;
-}
-
-activity.onerror = function() {
-  console.log("The activity encouter en error: " + this.error);
-}
-
-

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/es/archive/b2g_os/api/mozvoicemailstatus/index.html b/files/es/archive/b2g_os/api/mozvoicemailstatus/index.html deleted file mode 100644 index b00c181193..0000000000 --- a/files/es/archive/b2g_os/api/mozvoicemailstatus/index.html +++ /dev/null @@ -1,67 +0,0 @@ ---- -title: MozVoicemailStatus -slug: Archive/B2G_OS/API/MozVoicemailStatus -translation_of: Archive/B2G_OS/API/MozVoicemailStatus ---- - - -
-

This API is available on Firefox OS for internal applications only.

-
- - - -

Summary

- -

The MozVoicemailStatus API provides access to a voicemail status.

- -

Interface overview

- -
interface MozVoicemailStatus
-{
-  readonly attribute unsigned long serviceId;
-  readonly attribute boolean hasMessage;
-  readonly attribute long messageCount;
-  readonly attribute DOMString returnNumber;
-  readonly attribute DOMString returnMessage;
-};
- -

Properties

- -
-
MozVoicemailStatus.serviceId Read only
-
A number indicating the voicemail service ID.
-
MozVoicemailStatus.hasMessage Read only
-
A boolean indicating if there are messages available within the voicemail box.
-
MozVoicemailStatus.messageCount Read only
-
A number indicating the total message count.
-
MozVoicemailStatus.returnNumber Read only
-
A string representing the return call number for the voicemail status.
-
MozVoicemailStatus.returnMessage Read only
-
A string representing a displayable return call message for the voicemail status.
-
- -

Methods

- -

None.

- -

Specification

- -

Not part of any specification yet.

- -

See also

- - diff --git a/files/es/archive/b2g_os/api/navigator/index.html b/files/es/archive/b2g_os/api/navigator/index.html deleted file mode 100644 index 1760c18acd..0000000000 --- a/files/es/archive/b2g_os/api/navigator/index.html +++ /dev/null @@ -1,12 +0,0 @@ ---- -title: Navigator (Firefox OS extensions) -slug: Archive/B2G_OS/API/Navigator -translation_of: Archive/B2G_OS/API/Navigator ---- -

(es translation)

- -

The Navigator interface represents the state and the identity of the user agent. It allows scripts to query it and to register themselves to carry on some activities. This page represents the list of properties and methods added to Navigator on Firefox OS devices. For the list of properties and methods available to any Web sites, consult Navigator.

- -

A Navigator object can be retrieved using the read-only Window.navigator property.

- -

Navigator.mozApps
Retorna un objecto Apps que puedes usar para instalar, manejar y controlar Open Web Apps en el navegador.
Navigator.mozTelephony
Devuelve un objeto  Telephony que se puede utilizar para iniciar y controlar las llamadas telefónicas del navegador.
window.navigator.mozAlarms
Retorna un objeto MozAlarmsManager que puede usar para programar notificaciones o aplicaciones que se inicien en un momento determinado.

diff --git a/files/es/archive/b2g_os/api/navigator/mozalarms/index.html b/files/es/archive/b2g_os/api/navigator/mozalarms/index.html deleted file mode 100644 index d83b3dc520..0000000000 --- a/files/es/archive/b2g_os/api/navigator/mozalarms/index.html +++ /dev/null @@ -1,116 +0,0 @@ ---- -title: window.navigator.mozAlarms -slug: Archive/B2G_OS/API/Navigator/mozAlarms -translation_of: Archive/B2G_OS/API/Navigator/mozAlarms ---- -

-

No estándar
- This feature is non-standard and is not on a standards track. Do not use it on production sites facing the Web: it will not work for every user. There may also be large incompatibilities between implementations and the behavior may change in the future.

-

- -

-

This API is available on Firefox or Firefox OS for installed or higher privileged applications.

-

- -

Resumen

- -

Retorna un objeto MozAlarmsManager que puede usar para programar notificaciones o aplicaciones que se inicien en un momento determinado.

- -

Sintaxis

- -
var alarms = window.navigator.mozAlarms;
-
- -

Valor

- -

navigator.mozAlarms es un objeto MozAlarmsManager.

- -

Especificación

- - - - - - - - - - - - - - -
EspecificaciónEstadoComentario
Web Alarms APIObsoleteDefine la extensión para el objeto navigator .
- -

Compatibilidad de navegadores

- -

We're converting our compatibility data into a machine-readable JSON format. - This compatibility table still uses the old format, - because we haven't yet converted the data it contains. - Find out how you can help!

- -
- - -

- -
- - - - - - - - - - - - - - - - - - - -
FeatureChromeFirefox (Gecko)Internet ExplorerOperaSafari (WebKit)
Basic supportSin soporteSin soporteSin soporteSin soporteSin soporte
-
- -
- - - - - - - - - - - - - - - - - - - - - -
FeatureAndroidFirefox OSFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Basic supportSin soporte1.0Sin soporteSin soporteSin soporteSin soporte
-
- -

Nota de implementación en Gecko

- -

Esta API es disponible actualmente solo en Firefox OS para cualquier aplicación instalada. La especificación actual para esta API no es considerada lo suficientemente estable como para utilizar sin prefijo actualmente.

- -

Ver también

- - diff --git a/files/es/archive/b2g_os/api/navigator/mozapps/index.html b/files/es/archive/b2g_os/api/navigator/mozapps/index.html deleted file mode 100644 index a0df89d37c..0000000000 --- a/files/es/archive/b2g_os/api/navigator/mozapps/index.html +++ /dev/null @@ -1,96 +0,0 @@ ---- -title: Navigator.mozApps -slug: Archive/B2G_OS/API/Navigator/mozApps -tags: - - API - - API de aplicaciones - - No estandar - - aplicaciones -translation_of: Archive/B2G_OS/API/Navigator/mozApps ---- -

- -

-

No estándar
- This feature is non-standard and is not on a standards track. Do not use it on production sites facing the Web: it will not work for every user. There may also be large incompatibilities between implementations and the behavior may change in the future.

-

- -

Descripción

- -

Retorna un objecto Apps que puedes usar para instalar, manejar y controlar Open Web Apps en el navegador.

- -

Sintaxis

- -
var apps = window.navigator.mozApps;
-
- -

Valor

- -

navigator.mozApps es un objecto Apps que puedes usar para instalar, manejar y controlar Open Web Apps en el navegador.

- -

Especificación

- -

No es parte de ninguna especificación; implementado en Gecko en la base del error 697383.

- -

Compatibilidad de navegadores

- -

We're converting our compatibility data into a machine-readable JSON format. - This compatibility table still uses the old format, - because we haven't yet converted the data it contains. - Find out how you can help!

- -
- - -

- -
- - - - - - - - - - - - - - - - - - - -
FeatureChromeFirefox (Gecko)Internet ExplorerOperaSafari
Soporte basico---11.0 (11.0)---------
-
- -
- - - - - - - - - - - - - - - - - - - -
FeatureAndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Soporte basico---11.0 (11.0)---------
-
- -

 

diff --git a/files/es/archive/b2g_os/api/navigator/moztelephony/index.html b/files/es/archive/b2g_os/api/navigator/moztelephony/index.html deleted file mode 100644 index 9a67f43f5c..0000000000 --- a/files/es/archive/b2g_os/api/navigator/moztelephony/index.html +++ /dev/null @@ -1,83 +0,0 @@ ---- -title: Navigator.mozTelephony -slug: Archive/B2G_OS/API/Navigator/MozTelephony -translation_of: Archive/B2G_OS/API/Navigator/MozTelephony ---- -

-

No estándar
- This feature is non-standard and is not on a standards track. Do not use it on production sites facing the Web: it will not work for every user. There may also be large incompatibilities between implementations and the behavior may change in the future.

-

- -

-

This API is available on Firefox OS for internal applications only.

-

- -

Resumen

- -

Devuelve un objeto  Telephony que se puede utilizar para iniciar y controlar las llamadas telefónicas del navegador.

- -

Sintaxis

- -
var phone = window.navigator.mozTelephony;
-
- -

Valor

- -

navigator.mozTelephony es un objeto de Telephony que se puede utilizar para controlar las funciones de teléfono del dispositivo en el que se está ejecutando el navegador.

- -

Especificaciones

- -

Esta es una implementación no estándar, pero se discute en el W3C como parte del Grupo de trabajo de aplicaciones del sistema.

- - - - - - - - - - - - - - - - -
EspecificaciónEstatusComentario
Web TelephonyDraftEditor Draft (WIP).
- -

Compatibilidad del navegador

- -

Por razones obvias, el apoyo se espera principalmente en los navegadores móviles.

- -
- - - - - - - - - - - - - - - - - - - -
CaracteristicaAndroidFirefox Mobil (Gecko)IE MobilOpera MobilSafari Mobil
Soporte básicoSin soporte12.0 (12.0)Sin soporteSin soporteSin soporte
-
- -

Ver también

- - diff --git a/files/es/archive/b2g_os/api/telephony/index.html b/files/es/archive/b2g_os/api/telephony/index.html deleted file mode 100644 index 840ff8fbe0..0000000000 --- a/files/es/archive/b2g_os/api/telephony/index.html +++ /dev/null @@ -1,141 +0,0 @@ ---- -title: Telephony -slug: Archive/B2G_OS/API/Telephony -translation_of: Archive/B2G_OS/API/Telephony ---- -
-

No estándar
- This feature is non-standard and is not on a standards track. Do not use it on production sites facing the Web: it will not work for every user. There may also be large incompatibilities between implementations and the behavior may change in the future.

-
-

This API is available on Firefox OS for internal applications only.

-
- -

Resumen

- -

Proporciona soporte para marcar, contestar y manejar llamadas de teléfono en un dispositivo con soporte de telefonía.

- -

Propiedades

- -
-
Telephony.active
-
Un objeto TelephonyCall indicanda la llamada que está activa en ese momento. La llamada activa es la que recibe la entrada del micrófono y cualquier tono generado utilizando el metodo Telephony.startTone().
-
Telephony.calls
-
Matriz de objetos TelephonyCall, uno para cada llamada que está conectado en ese momento.
-
Telephony.muted
-
Se establece en true para silenciar el micrófono o false para activar el micrófono.
-
Telephony.speakerEnabled
-
Se establece en true para habilitar la funcionalidad de altavoz o false para desactivarla.
-
- -

Manejo de eventos

- -
-
Telephony.oncallschanged
-
Un controlador para el evento callschanged; este evento CallEvent se envía cada vez que la lista de llamadas presenta cambios.
-
Telephony.onincoming
-
Un controlador para el evento de entrada, lo que CallEvent envía cada vez que hay una nueva llamada entrante.
-
- -

Metodos

- -
-
Telephony.dial()
-
Marca el número de teléfono especificado, que se especifica como una cadena.
-
Telephony.startTone()
-
Comienza la generación del tono DTMF especificado.
-
Telephony.stopTone()
-
Detiene la generación del tono DTMF actualmente sonando.
-
- -

Especificaciones

- -

Esta es una implementación no estándar, pero se discute en el W3C como parte del Grupo de trabajo de aplicaciones del sistema.

- - - - - - - - - - - - - - - - -
EspecificaciónEstatusComentario
Web TelephonyDraftEditor Draft (WIP).
- -

Browser compatibility

- -

Por razones obvias, el apoyo se espera principalmente en los navegadores móviles.

- -

We're converting our compatibility data into a machine-readable JSON format. - This compatibility table still uses the old format, - because we haven't yet converted the data it contains. - Find out how you can help!

- -
- - -

- -
- - - - - - - - - - - - - - - - - - - -
CaracteristicaChromeFirefox (Gecko)Internet ExplorerOperaSafari
Soporte básicoSin soporteSin soporteSin soporteSin soporteSin soporte
-
- -
- - - - - - - - - - - - - - - - - - - -
CaracteristicaAndroidFirefox Mobil (Gecko)IE MobilOpera MobilSafari Mobil
Soporte básicoSin soporte12.0 (12.0)Sin soporteSin soporteSin soporte
-
- -

Ver también

- - diff --git a/files/es/archive/b2g_os/api/telephonycall/hangup/index.html b/files/es/archive/b2g_os/api/telephonycall/hangup/index.html deleted file mode 100644 index 1afab7cee9..0000000000 --- a/files/es/archive/b2g_os/api/telephonycall/hangup/index.html +++ /dev/null @@ -1,118 +0,0 @@ ---- -title: TelephonyCall.hangUp -slug: Archive/B2G_OS/API/TelephonyCall/hangUp -translation_of: Archive/B2G_OS/API/TelephonyCall/hangUp ---- -

- -

-

No estándar
- This feature is non-standard and is not on a standards track. Do not use it on production sites facing the Web: it will not work for every user. There may also be large incompatibilities between implementations and the behavior may change in the future.

-

- -

-

This API is available on Firefox OS for internal applications only.

-

- -

Resumen

- -

Este método cuelga una llamada en curso.

- -

Sintaxis

- -
instanceOfTelephonyCall.hangUp();
-
- -

Especificaciones

- -

Esta es una implementación no estándar, pero se discute en el W3C como parte del Grupo de trabajo de aplicaciones del sistema.

- - - - - - - - - - - - - - - - -
EspecificaciónEstatusComentario
Web TelephonyDraftEditor Draft (WIP).
- -

Compatibilidad del navegador

- -

Por razones obvias, el apoyo se espera principalmente en los navegadores móviles.

- -

We're converting our compatibility data into a machine-readable JSON format. - This compatibility table still uses the old format, - because we haven't yet converted the data it contains. - Find out how you can help!

- -
- - -

- -
- - - - - - - - - - - - - - - - - - - -
CaracteristicaChromeFirefox (Gecko)Internet ExplorerOperaSafari
Soporte basicoSin soporteSin soporteSin soporteSin soporteSin soporte
-
- -
- - - - - - - - - - - - - - - - - - - -
CaracteristicaAndroidFirefox Mobil (Gecko)IE MobilOpera MobilSafari Mobil
Soporte basicoSin soporte12.0 (12.0)Sin soporteSin soporteSin soporte
-
- -

See also

- - diff --git a/files/es/archive/b2g_os/api/telephonycall/index.html b/files/es/archive/b2g_os/api/telephonycall/index.html deleted file mode 100644 index 118b5126fc..0000000000 --- a/files/es/archive/b2g_os/api/telephonycall/index.html +++ /dev/null @@ -1,185 +0,0 @@ ---- -title: TelephonyCall -slug: Archive/B2G_OS/API/TelephonyCall -translation_of: Archive/B2G_OS/API/TelephonyCall ---- -

-

-

No estándar
- This feature is non-standard and is not on a standards track. Do not use it on production sites facing the Web: it will not work for every user. There may also be large incompatibilities between implementations and the behavior may change in the future.

-

-

-

This API is available on Firefox OS for internal applications only.

-

-

Resumen

-

Representa una llamada telefonica, proporciona información sobre la llamada y ofreciendo mecanismos para controlar y detectar los cambios en su estado.

-

Propiedades

-
-
- TelephonyCall.number Read only
-
- Cadena que indica el número de teléfono correspondiente a la llamada.
-
- TelephonyCall.state Read only
-
- Una cadena que indica el estado de la llamada.
-
-

Controladores de eventos

-
-
- TelephonyCall.onalerting
-
- A function to be called when the call alerts. What does this mean?
-
- TelephonyCall.onbusy
-
- Una función que se llamará cuando se recibe una señal de ocupado al intentar marcar.
-
- TelephonyCall.onconnected
-
- Una función que se llamará una vez que se conecte la llamada.
-
- TelephonyCall.onconnecting
-
- Una función que se llamará después de marcar, a la espera de una conexión.
-
- TelephonyCall.ondialing
-
- Una función que se llamará cuando la llamada comienza a marcar el number.
-
- TelephonyCall.ondisconnected
-
- Una función que se llamará después de que la llamada haya terminado de desconectar.
-
- TelephonyCall.ondisconnecting
-
- Una función que se llamará cuando la llamada comienza a desconectar.
-
- TelephonyCall.onincoming
-
- Una función a llamar cuando se detecta una llamada entrante.
-
- TelephonyCall.onstatechange
-
- A function to be called when the state of the call changes.
-
-

Metodos

-
-
- TelephonyCall.answer()
-
- Responde a una llamada entrante
-
- TelephonyCall.hangUp()
-
- Cuelga la llamada
-
- TelephonyCall.hold()
-
- Permite poner una llamada en espera.
-
- TelephonyCall.resume()
-
- Permite recuperar una llamada en espera.
-
-

TelephonyCall también hereda métodos de EventTarget:

-

-
EventTarget.addEventListener()
-
Register an event handler of a specific event type on the EventTarget.
-
EventTarget.removeEventListener()
-
Removes an event listener from the EventTarget.
-
EventTarget.dispatchEvent()
-
Dispatch an event to this EventTarget.
-
- -

Additional methods for Mozilla chrome code

- -

Mozilla extensions for use by JS-implemented event targets to implement on* properties. See also WebIDL bindings.

- -

-

Especificaciones

-

Se trata de una implementación no estándar, pero se está discutiendo en el W3C, como parte del Grupo de trabajo de aplicación del sistea.

- - - - - - - - - - - - - - - -
EspecificaciónEstatusComentario
Web TelephonyDraftEditor Draft (WIP).
-

Compatibilidad de navegador

-

Por razones obvias, el apoyo se espera principalmente en los navegadores móviles.

-

We're converting our compatibility data into a machine-readable JSON format. - This compatibility table still uses the old format, - because we haven't yet converted the data it contains. - Find out how you can help!

- -
- - -

-
- - - - - - - - - - - - - - - - - - - -
CaracteristicaChromeFirefox (Gecko)Internet ExplorerOperaSafari
Soporte basicoSin soporteSin soporteSin soporteSin soporteSin soporte
-
-
- - - - - - - - - - - - - - - - - - - -
CaracteristicaAndroidFirefox Mobil (Gecko)IE MobilOpera MobilSafari Mobil
Soporte basicoSin soporte12.0 (12.0)Sin soporteSin soporteSin soporte
-
-

Ver también

- diff --git a/files/es/archive/b2g_os/api/telephonycall/number/index.html b/files/es/archive/b2g_os/api/telephonycall/number/index.html deleted file mode 100644 index 7ac9efa096..0000000000 --- a/files/es/archive/b2g_os/api/telephonycall/number/index.html +++ /dev/null @@ -1,125 +0,0 @@ ---- -title: TelephonyCall.number -slug: Archive/B2G_OS/API/TelephonyCall/number -translation_of: Archive/B2G_OS/API/TelephonyCall/number ---- -

- -

-

No estándar
- This feature is non-standard and is not on a standards track. Do not use it on production sites facing the Web: it will not work for every user. There may also be large incompatibilities between implementations and the behavior may change in the future.

-

- -

-

This API is available on Firefox OS for internal applications only.

-

- -

Resumen

- -

El número de teléfono asociado con una llamada telefónica. Solo lectura.

- -

Sintaxis

- -
var phoneNum = window.navigator.mozTelephony.number;
-
- -

Valor

- -


- Una cadena (String) que indica el número asociado a la llamada. Esto puede ser o bien el número marcado durante una llamada saliente, o el número de teléfono informado por ID de llamada entrante.

- -
Nota: El valor devuelto es probablemente "" para llamadas de personas con identificador de llamadas bloqueadas. ¡Esto es solo una conjetura! Por favor actualice esto cuando lo sepa a ciencia cierta.
- -

Especificaciones

- -

No es una implementacion estandar, pero se dicute en el W3C como parte del Grupo de trabajo de aplicaciones del sistema.

- - - - - - - - - - - - - - - - -
EspecificaciónEstatusComentario
Web TelephonyDraftEditor Draft (WIP).
- -

Compatibilidad de navegador

- -

Por razones obvias, el apoyo se espera principalmente en los navegadores móviles.

- -

We're converting our compatibility data into a machine-readable JSON format. - This compatibility table still uses the old format, - because we haven't yet converted the data it contains. - Find out how you can help!

- -
- - -

- -
- - - - - - - - - - - - - - - - - - - -
CaracteristicaChromeFirefox (Gecko)Internet ExplorerOperaSafari
Soporte basicoSin soporteSin soporteSin soporteSin soporteSin soporte
-
- -
- - - - - - - - - - - - - - - - - - - -
CaracteristicaAndroidFirefox Mobil (Gecko)IE MobilOpera MobilSafari Mobil
Soporte basicoSin soporte12.0 (12.0)Sin soporteSin soporteSin soporte
-
- -

See also

- - diff --git a/files/es/archive/b2g_os/api/telephonycall/onincoming/index.html b/files/es/archive/b2g_os/api/telephonycall/onincoming/index.html deleted file mode 100644 index 38514ab777..0000000000 --- a/files/es/archive/b2g_os/api/telephonycall/onincoming/index.html +++ /dev/null @@ -1,120 +0,0 @@ ---- -title: TelephonyCall.onincoming -slug: Archive/B2G_OS/API/TelephonyCall/onincoming -translation_of: Archive/B2G_OS/API/TelephonyCall/onincoming ---- -

- -

-

No estándar
- This feature is non-standard and is not on a standards track. Do not use it on production sites facing the Web: it will not work for every user. There may also be large incompatibilities between implementations and the behavior may change in the future.

-

- -

-

This API is available on Firefox OS for internal applications only.

-

- -

Resumen

- -

Una referencia a una función que se llamará para manejar evento de incoming de la API de telefonía. Este evento se produce cuando se detecta una llamada entrante. El controlador de eventos se llama con un CallEvent como único parámetro.

- -

Sintaxis

- -
instanceOfTelephonyCall.onincoming = funcRef;
-
- -

Donde funcRef es una función que se llamara cuando se resiva una llamda entrante incoming. Estos eventos son de tipo CallEvent.

- -

Especificaciones

- -

No es una implementacion estandar, pero se discute en el W3C como parte del Grupo de trabajo de aplicaciones del sistema.

- - - - - - - - - - - - - - - - -
EspecificaciónEstatusComentario
Web TelephonyDraftEditor Draft (WIP).
- -

Compatibilidad de navegador

- -

Por razones obvias, el apoyo se espera principalmente en los navegadores móviles.

- -

We're converting our compatibility data into a machine-readable JSON format. - This compatibility table still uses the old format, - because we haven't yet converted the data it contains. - Find out how you can help!

- -
- - -

- -
- - - - - - - - - - - - - - - - - - - -
CaracteristicaChromeFirefox (Gecko)Internet ExplorerOperaSafari
Soporte basicoSin soporteSin soporteSin soporteSin soporteSin soporte
-
- -
- - - - - - - - - - - - - - - - - - - -
CaracteristicaAndroidFirefox Mobil (Gecko)IE MobilOpera MobilSafari Mobil
Soporte basicoSin soporte12.0 (12.0)Sin soporteSin soporteSin soporte
-
- -

See also

- - diff --git a/files/es/archive/b2g_os/api/window/index.html b/files/es/archive/b2g_os/api/window/index.html deleted file mode 100644 index b5e3bcf899..0000000000 --- a/files/es/archive/b2g_os/api/window/index.html +++ /dev/null @@ -1,27 +0,0 @@ ---- -title: Window (Firefox OS extensions) -slug: Archive/B2G_OS/API/Window -tags: - - Navegado -translation_of: Archive/B2G_OS/API/Window ---- - - - - -

The Window interface represents a window containing a DOM document. This page represents the list of properties and methods added to Window on Firefox OS devices. For the list of properties and methods available to any Web sites, consult Window.

- -

Properties

- -
-
Window.onmoztimechange
-
Contains the event handler to be called whent the event moztimechange is sent.
-
- -

Methods

- -

There is no Firefox OS-specific method on the Window interface.

diff --git a/files/es/archive/b2g_os/application_development/index.html b/files/es/archive/b2g_os/application_development/index.html deleted file mode 100644 index 95eb0170fd..0000000000 --- a/files/es/archive/b2g_os/application_development/index.html +++ /dev/null @@ -1,11 +0,0 @@ ---- -title: Desarrollo de aplicaciones en Firefox OS -slug: Archive/B2G_OS/Application_development -translation_of: Archive/B2G_OS/Firefox_OS_apps/Building_apps_for_Firefox_OS ---- -

Las aplicaciones de Firefox OS no son mas que Open Web apps, esto es Aplicaciones HTML5, que estan instaladas en un dispositivo que ejecuta Firefox OS. Esto significa que puedes usar tus conocimientos que tienes actualmente sobre desarrollo front-end para crear aplicaciones que corran en los teléfonos Firefox OS.

-

Para más información sobre cómo desarrollar aplicaciones para Firefox OS en vez de sitios web puedes ver el tutorial Comenzando a construir aplicaciones. Desarrollar una aplicación para un sistema específico tiene algunas advertencias. Puedes obtener informaciton relevante sobre ellas en la guía: Escribiendo una aplicación web para B2G.

-

Una vez familiarizado con los puntos básicos, quizá puedas necesitar consultar la información sobre la API de Desarrollo de Aplicaciones. Para información básica sobre el desarrollo de apps en Firefox OS, puedes ver el Firefox Marketplace Developer Hub.

-

 

-
- Nota: Actualmente Firefox OS se identifica usando la misma cadena UA que Firefox para los sistemas Android, excepto sin la clausula Android. Por ejemplo: Mozilla/5.0 (Mobile; rv:15.0) Gecko/15.0 Firefox/15.0a1.
diff --git a/files/es/archive/b2g_os/apps/escribiendo_una_aplicacion_web_para_b2g/index.html b/files/es/archive/b2g_os/apps/escribiendo_una_aplicacion_web_para_b2g/index.html deleted file mode 100644 index e3ca09ccb8..0000000000 --- a/files/es/archive/b2g_os/apps/escribiendo_una_aplicacion_web_para_b2g/index.html +++ /dev/null @@ -1,29 +0,0 @@ ---- -title: Escribiendo una aplicación web para B2G -slug: Archive/B2G_OS/Apps/Escribiendo_una_aplicacion_web_para_B2G -tags: - - Firefox OS - - aplicaciones - - aplicación -translation_of: Web/Apps/Fundamentals/Quickstart ---- -

Las aplicaciones de B2G son solo aplicaciones Web escritas con HTML, CSS y JavaScript. Las puedes publicar en la Web tal como publicarías cualquier otro sitio Web. Con el fin de hacer instalable el sitio Web como una aplicación Web en el dispositivo, solo tienes que adornarlo con un manifiesto y conectar un botón de instalación tal como se explica a continuación.

-

Los siguientes temas son puntos de partida recomendados:

- -

Por supuesto, ¡no dudes en profundizar aún más en Open Web Apps!

-

Instalando la aplicación Web

-

Con la aplicación y el manifiesto publicados en la Web, necesitas hacer que Gecko sea conciente de ello. Al momento de la instalación, Gecko busca el manifiesto y agrega las entradas necesarias para la pantalla de inicio, etc.

-

Para instalar una aplicación, llamar a la  API navigator.mozApps.install. Aquí un ejemplo de un botón de instalación que podrías incluir en tu aplicación cuando la estas organizando:

-
<script>
-var manifest_url = "http://my.webapp.com/manifest.json";
-</script>
-
-<button onclick="navigator.mozApps.install(manifest_url); return false;">
-  ¡Instala esta impresionante aplicación en tu pantalla de inicio!
-</button>
-
-

Nota: El botón de instalación podría estar también en el app market, tal como el Firefox Marketplace, pero a menudo es muy importante tener un un botón "Instalar como una apliación web" en la página principal de tu sitio.

-

Ahora visita tu sitio web en el navegador de B2G y pulsa el botón de instalación.

diff --git a/files/es/archive/b2g_os/apps/index.html b/files/es/archive/b2g_os/apps/index.html deleted file mode 100644 index 83e26c0f3f..0000000000 --- a/files/es/archive/b2g_os/apps/index.html +++ /dev/null @@ -1,62 +0,0 @@ ---- -title: Creando Aplicaciones para Firefox OS -slug: Archive/B2G_OS/Apps -translation_of: Web/Apps/Fundamentals ---- -

Las aplicaciones para dispositivos Firefox OS son simplemente aplicaciones Web; ellas consisten enteramente de tecnologías Web abiertas como JavaScript, HTML, y CSS. Mientras nuestra documentación primaria para aplicaciones cubre casi todo lo que necesitas saber, aquí hay algunos documentos específicos para desarrollar y probar Firefox OS.

-
-
-

DOCUMENTACIón y tutoriales

-
-
- Escribiendo una aplicación web para Firefox OS
-
- Un tutorial para crear tu primera aplicación para Firefox OS.
-
- Experiencia de usuario
-
- Guías para ayudarte a desarrollar aplicaciones con experiencia de usuario consistente y atractiva, incluyendo ejemplos de código y plantillas.
-
- Tips y técnicas
-
- Una surtida variedad de tips y trucos (tanto como soluciones a los problemas) que nuestros desarrolladores sugieren para ti.
-
-

Ver más...

-
-
-

recibiendo ayuda de la comunidad

-

¿Necesitas ayuda en un problema relacionado con tu aplicación y no encuentras la solución en la documentación?

- -

No olvides la etiqueta de la red...

-

Herramientas

- -

Ver más...

- - -
-
-

 

diff --git a/files/es/archive/b2g_os/architecture/index.html b/files/es/archive/b2g_os/architecture/index.html deleted file mode 100644 index 875eac916d..0000000000 --- a/files/es/archive/b2g_os/architecture/index.html +++ /dev/null @@ -1,759 +0,0 @@ ---- -title: Arquitectura del Sistema Operativo Firefox OS -slug: Archive/B2G_OS/Architecture -translation_of: Archive/B2G_OS/Architecture ---- -
-

Este artículo es un panorama de alto nivel de la arquitectura de la plataforma Firefox OS, que introduce conceptos fundamentales y explica cómo sus componentes interactúan a un nivel básico.

-
- -
-

Nota: recuerda que Firefox OS todavía se encuentra en estado de pre-lanzamiento. La arquitectura descrita aquí no necesariamente es la final y que otros elementos todavía pueden estar sujetos a cambios.

-
- -

Terminología de Firefox OS

- -

Existen algunos términos que debes entender antes de continuar leyendo nuestra documentación sobre Firefox OS.

- -
-
B2G
-
Sigla de Boot to Gecko.
-
Boot to Gecko
-
El nombre código de ingeniería para el sistema operativo Firefox OS.
-
Firefox OS
-
Es básicamente la marca y servicios de soporte de Mozilla (y sus socios de OEM) aplicados sobre Boot to Gecko para crear el producto final de lanzamiento.
-
Gaia
-
La interfaz de usuario de la plataforma Firefox OS. Cualquier cosa dibujada en la pantalla una vez que Firefox OS ha sido iniciado es un producto de la capa Gaia. La misma implementa la pantalla de seguridad (lock screen), pantalla principal (home screen) y todas las aplicaciones estándares de cualquier teléfono inteligente moderno. Gaia se implementa en su totalidad empleando HTML, CSS y JavaScript. Las interfaces subyacentes al sistema operativo son Web APIs de código abierto, que se implementan por medio de la capa Gecko. Las aplicaciones de terceros se pueden instalar en paralelo con la capa Gaia.
-
Gecko
-
Este es el runtime de aplicaciones de Firefox OS, es decir, la capa que provee todo el soporte para el trío de estándares de código abierto: HTML, CSS y JavaScript. Es responsable de que esas APIs funcionen bien en cualquier sistema operativo soportado por Gecko. Esto implica que Gecko incluya, además de otras cosas, paquetes de redes y de gráficos, un motor de diagramación, una máquina virtual de JavaScript y capas de adaptación (porting).
-
Gonk
-
Gonk es el sistema operativo de bajo nivel de la plataforma Firefox OS que consiste un núcleo/kernel Linux (basado sobre el Android Open Source Project (AOSP)) y una capa de abstracción de hardware de espacio de usuario (HAL por su sigla en inglés). El kernel y varias de las librerías de espacio de usuario son proyectos comunes de código abierto: Linux, libusb, bluez, y sucesivos. Algunas de las otras partes de la HAL se comparten con la AOSP: GPS, cámara y otros. Se podría decir que Gonk es una distribución de Linux muy sencilla. Gonk es una capa de adaptación (port) de dispositivos: un adaptador entre el hardware y Gecko. Gonk es una distribución de Linux bastante sencilla que puede ser tratada como un adaptador Gecko empardado con capas de adaptación Gecko —entonces Gonk es un objetivo para adaptar Gecko a Firefox OS así como también hay adaptadores de Gecko para OS X, Windows y Android. Como el Proyecto Firefox OS goza de control total sobre Gonk, podemos exponer interfaces a Gecko que no podrían ser expuestas en otros sistemas operativos. Por ejemplo, Gecko posee a través de Gonk acceso directo al conjunto completo de telefonía y al buffer de pantalla pero no tiene este acceso en otros sistemas operativos.
-
Jank
-
Este término, generalmente empleado en el área de las aplicaciones móviles, se refiere al efecto causado por código lento o ineficiente en una aplicación, que podría bloquear la actualización de la interfaz de usuario y provocar su lentitud o que no responda. Nuestros ingenieros de Gaia se valen de numerosas técnicas de optimización para evitar esto lo mejor posible.
-
- -

Diagrama estructural

- -

Firefox OS Architecture

- -

Procedimiento de arranque de Firefox OS

- -

Esta sección describe el proceso por el que los dipositivos con Firefox OS arrancan (butean), cuáles partes están involucradas en el proceso y dónde. A modo de referencia rápida, el flujo del arranque general del sistema va desde los cargadores de arranque (bootloaders) en el espacio del núcleo/kernel al init en el código nativo, a B2G y después a Geko en el espacio de usuario y después finalmente a la aplicación de sistema, gestor de ventanas y posteriormente a la pantalla de inicio de la aplicación en Gecko. Sobre ese conjunto se ejecutan todas las otras aplicaciones.

- -

- -

El proceso de arranque encadenado (bootstrapping)

- -

Cuando un dispositivo con FirefoxOS se enciende, la ejecución se inicia en el cargador del arranque primario (bootloader). Desde allí, el proceso de la carga del SO principal procede normalmene; una sucesión de arranques de jerarquías crecientes inicia el siguiennte arranque en la cadena. Al final del proceso, se delega la ejecución al núcleo/kernel Linux.

- -

Hay algunos puntos destcables sobre el proceso de arranque:

- - - -

El kernel Linux

- -

El núcleo Linux empleado por Gonk es muy similar a la versión de Linux difundida (upstreamed) de la que deriva (basada sobre el Android Open Source Project). Existen cambios hehos por el AOSP que todavía no han sido difundidos. Además, los fabricantes y vendedores a veces modifican el núcleo y cargan esos cambios a la versión de difusión de acuerdo con su intinerario. En términos generales, el núcleo Linux es muy parecido al original.

- -

El proceso de arranque de Linux se encuentra bien documentado en la internet por lo tanto este artículo no lo cubrirá.

- -

El núcleo Linux activará dispositivos y ejecutará procesos esenciales definidos en init.rc y su sucesor init.b2g.rc para arrancar procesos esenciales como b2g [procesos básicos de Firefox OS, contenedores de Gecko] y rild [un proceso relacionado con la telefonía que puede ser específico de cada chip] —vaya más abajo para ver más detalles. Al final del proceso, un proceso init de espacio de usuario (userspace) se lanza, como ocurre en la mayoría de los sistemas operativos del tipo UNIX.

- -

Una vez que el proceso init se ha lanzado, el núcleo Linux administra las llamadas del sistema desde el espacio de usuario, las interrupciones y semejantes desde los dispositivos de hardware. Algunas de las características de hardware se exponen al espacio de usuario a través de sysfs. Por ejemplo, aquí hay un fragmento de código que lee el estado de la batería en Gecko:

- -
FILE *capacityFile = fopen("/sys/class/power_supply/battery/capacity", "r");
-double capacity = dom::battery::kDefaultLevel * 100;
-if (capacityFile) {
-  fscanf(capacityFile, "%lf", &capacity);
-  fclose(capacityFile);
-}
- -

Más sobre el proceso init

- -

El proceso init en Gonk gestiona el montaje de los archivos de sistema requeridos y activa los procesos de systema. Después de eso, se mantiene activo como gestor de procesos. Esto es muy similar al init en otros sistemas operativos similares a UNIX. Interpreta scripts [los archivos init.rc] que consisten de comandos que describen lo que debería ser hecho para iniciar servicios varios. El init.rc de FirefoxOS suele ser el init.rc original de Android para ese dispositivo, parchado para incluir los requisitos de arranque de FirefoxOS, y varía de dispositivo a dispositivo.

- -

Una de las tareas fundamentales que maneja el proceso init es el inicio del proceso b2g; éste es el núcleo del sistema operativo FirefoxOS.

- -

El código para tal init.rc es el siguiente:

- -
service b2g /system/bin/b2g.sh
-    class main
-    onrestart restart media
- -
-

Nota: las variaciones de init.rc dependerán de dispositivo a dispositivo; a veces init.b2g.rc sólo es anexadoo, y a veces los parches son más significativos.

-
- -

Arquitectura de los procesos del espacio de usuario (userspace)

- -

Resulta muy útil echar un vistazo de alto nivel a cómo varios componentes del Firefox OS se articulan e interactúan entre sí. Este diagrama muestra los procesos primarios de espacio de usuario en Firefox OS.

- -

Userspace diagram

- -
-

Nota: recuerda que como Firefox OS se encuentra en desarrollo activo, este diagrama puede estar sujeto a cambios y puede ser impreciso parcialmente.

-
- -

El proceso b2g es el proceso primario de sistema. Se ejecuta con privilegios altos; tiene acceso a la mayoría del hardware. b2g se comunica con el módem, almacena en el buffer de pantalla e interactúa con el GPS, cámaras y otros dispositivos. Internamemte, se ejecuta con una capa de Gecko (implementada por libxul.so). Ver Gecko para más detalles sobre cómo funciona la capa Gecko y cómo b2g se comunica con ella.

- -

b2g

- -

El proceso b2g puede dar lugar a un número de procesos de contenido de privilegios limitados. Estos procesos albergan la carga de aplicaciones web y otros contenidos. Estos procesos se comunican con el proceso principal del servidor Gecko a través de IPDL, un sistema de envio de mensajes.

- -

El proceso b2g ejecuta lixbul, el cual referencia a b2g/app/b2g.js para obtener las preferencias de fábrica. De las preferencias se abrirá el archivo HTML descriptor b2g/chrome/content/shell.html, que es compilado en un archivo omni.ja. El shell.html incluye el archivo b2g/chrome/content/shell.js , que dispara la aplicación system de Gaia.

- -

rild

- -

El proceso rild es la interfaz del proceso del módem. rild es el daemon que implementa La capa de Interfaz de la Radio [Radio Interface Layer (RIL)]. Es un componente de codigo cerrado implementado por el fabricante/vendedor de hardware para comunicarse con el hardware del módem. rild hace posible que el código cliente se comunique con un empalme de dominio-UNIX al que se enlaza. Se inicia con un código como este en el init script:

- -
service ril-daemon /system/bin/rild
-    socket rild stream 660 root radio
- -

rilproxy

- -

En Firefox OS, el cliente rild client es el proceso rilproxy. Este actúa como un proxy de reenvio mudo (dumb proxy) entre rild y b2g. Este proxy es necesario como un detalle de implementación; es de hecho necesario. El código de rilproxy se encuentra en GitHub.

- -

mediaserver

- -

El proceso mediaserver controla la reproducción de audio y video. Gecko se comunica con él a través de un mecanismo de Llamada de Procedimiento Remota de Android [Android Remote Procedure Call (RPC)]. Algunos de los contenidos multimedia que Gecko puede reproducir (OGG Vorbis audio, OGG Theora video, y WebM video) son decodificados por Gecko y enviados directamente al proceso mediaserver. Otros archivos multimedia son decodificados por libstagefright, que puede acceder códecs del fabricante y codificadores del hardware.

- -
-

Nota: El proceso mediaserver es un componente "provisional" de Firefox OS; existe sólo para ayudar en el trabajo de desarrollo inicial pero se espera que se descarte con el tiempo; lo que seguramente no ocurrirá antes de la version 2.0 de Firefox OS.

-
- -

netd

- -

El proceso netd se usa para configurar interfaces de red.

- -

wpa_supplicant

- -

El proceso wpa_supplicant process es el daemon estándar tipo UNIX que maneja la conectividad con los puntos de acceso WiFi.

- -

dbus-daemon

- -

El dbus-daemon implementa el D-Bus, un sistema de mensajes de bus que Firefox OS emplea para las comunicaciones por Bluetooth.

- -

Gecko

- -

Gecko, como se lo mencionó previamente, es la implementación de estándares web (HTML, CSS, y JavaScript) que se usa para implementar todos lo que el usuario ve en Firefox OS, y controlar las interacciones con el hardware del telefono.

- -

Las aplicaciones Web conectan HTML5 con el hardware de forma controlada a traves de API's web seguras, implementadas en Gecko. Las API's Web proveen de acceso programado a las caracteristicas implicitas en el hardware del dispositivo (como la bateria, o la vibracion), a medida que los datos son guardados, o estan disponibles, en el dispositivo. El contenido web invoca a las API's web accesibles con HTML5.

- -

Una app consiste en una coleccion de codigos web HTML5 relacionados. Para construir aplicaciones web que funcionen en dispositivos Firefox OS, los desarrolladores simplemento ensamblan, empaquetan y distribuyen este contenido web. En tiempo de ejecucion, este contenido web es interpretado, compilado y renderizado en una navegador web. Para mas informacion sobre Apps, puedes consultar el App Center

- -
-

Note: Para buscar en la base de código de Gecko, se puede usar http://dxr.mozilla.org. Es más elegante y ofrece buenas características de referemcias. pero con repositorios limitados. También podría usar el tradicional http://mxr.mozilla.org, que contiene más proyectos de Mozilla.

-
- -

Diagrama de arquitectura de Gecko

- -

- -

 

- - - -

 

- -

Archivos de Gecko relacionados con Firefox OS

- -

b2g/

- -

La carpeta b2g contiene es su mayoría funciones relacionadas con Firefox OS.

- -
b2g/chrome/content
- -

Contiene archivos de Javascript ejecutados sobre la aplicación de sistema.

- -
b2g/chrome/content/shell.html
- -

El punto de entrada a Gaia — el HTML para la aplicación de sistema. shell.html toma de settings.js and shell.js:

- -
 
- -

settings.js contiene parámetros de configuración básicos (default) de sistema.

- -
b2g/chrome/content/shell.js
- -

shell.js es el primer script que se carga en la aplicación de sistema de Gaia.

- -

shell.js importa todos los módulos requeridos, registra los detectores de clave (key listeners), define sendCustomEvent y sendChromeEvent para que se cominiquen con Gaia, y provee ayudantes de instalación de aplicaciones web: indexedDB quota, RemoteDebugger, ayudante de teclado, y la herramienta para captura de pantalla.

- -

Pero la función más importante de shell.js es lanzar la aplicación de sistema de Gaia, después entregarle todo el trabajo general de administración del sistema.

- -
let systemAppFrame =
-  document.createElementNS('http://www.w3.org/1999/xhtml', 'html:iframe');
-    ...
-  container.appendChild(systemAppFrame);
- -
b2g/app/b2g.js
- -

Este script contiene configuraciones predefinidas, como about:config en el navegador, y la misma que Gaia's pref.js. Estas configuraciones se pueden cambiar desde la aplicación de congifuraciones y se pueden sobreescribir con user.js en el script de construcción Gaia.

- -

dom/{API}

- -

Nuevas implementaciones de la API (post-b2g) se localizarán en dom/. Las APIs anteiores se localizarán en dom/base, for example Navigator.cpp.

- -
dom/apps
- -

.jsm se cargarán implementaciones de API — .js API tales como webapp.js install, getSelf, etc.

- -
dom/apps/PermissionsTable.jsm
- -

Se definen todos los permisos en PermissionsTable.jsm

- -

dom/webidl

- -

WebIDL es el lenguaje empleado para definir web APIs. La información sobre los atributos soportados se encuentra en WebIDL_bindings.

- -

hal/gonk

- -

Este directorio contiene archivos sobre la capa de adaptación gonk..

- -

Archivos generados

- -
module/libpref/src/init/all.js
- -

Contiene todos los archivos de configuración.

- -
/system/b2g/ omni.ja and omni.js
- -

Contiene el paquete de estilos para los recursos en el dispositivo.

- -

Proceso de eventos de ingreso

- -

La mayor parte de las acciones en Gecko se activan por acciones de usuario. Estas acciones son representadas por eventos de emtrada (tales como presionar botones, tocar la pantalla y similar). Estos eventos entran a Gecko a través de Gonk implementation perteneciente a nsIAppShell, que es una interfaz de Gecko empleada para representar los puntos de entrada primaria de una aplicación de Gecko, es decir, el controlador del dispositivo de ingreso llama métodos en el objeto nsAppShell que representa el subsistema de Gecko para así enviar eventos a la interfaz de usuario.

- -

 

- -

Por ejemplo:

- -

 

- -
void GeckoInputDispatcher::notifyKey(nsecs_t eventTime,
-                                     int32_t deviceId,
-                                     int32_t source,
-                                     uint32_t policyFlags,
-                                     int32_t action,
-                                     int32_t flags,
-                                     int32_t keyCode,
-                                     int32_t scanCode,
-                                     int32_t metaState,
-                                     nsecs_t downTime) {
-  UserInputData data;
-  data.timeMs = nanosecsToMillisecs(eventTime);
-  data.type = UserInputData::KEY_DATA;
-  data.action = action;
-  data.flags = flags;
-  data.metaState = metaState;
-  data.key.keyCode = keyCode;
-  data.key.scanCode = scanCode;
-  {
-    MutexAutoLock lock(mQueueLock);
-    mEventQueue.push(data);
-  }
-  gAppShell->NotifyNativeEvent();
-}
- -

Estos eventos provienen del sistema estándar Linux input_event. Firefox OS emplea light abstraction layer sobre eso; lo que provee algunas características útiles como filtrar los eventos. Se puede ver el código que crea eventos de ingreso en el método EventHub::getEvents() que se encuentra en widget/gonk/libui/EventHub.cpp.

- -

Un vez que Gecko recivió los eventos, se envían a DOM por nsAppShell:

- -
static nsEventStatus sendKeyEventWithMsg(uint32_t keyCode,
-                                         uint32_t msg,
-                                         uint64_t timeMs,
-                                         uint32_t flags) {
-    nsKeyEvent event(true, msg, NULL);
-    event.keyCode = keyCode;
-    event.location = nsIDOMKeyEvent::DOM_KEY_LOCATION_MOBILE;
-    event.time = timeMs;
-    event.flags |= flags;
-    return nsWindow::DispatchInputEvent(event);
-}
-
- -

Después de lo anterior, los eventos son consumidos por el propio Gecko o despachados a aplicaciones web como Eventos DOM para ser procesados posteriormente.

- -

Graficos

- -

En si nivel más inferior, Gecko emplea OpenGL ES 2.0 para establecer un contexto GL que envuelva los buffers del hardware. Esto es realizado en la implementación de Gonk en nsWindow por medio de un código similar a este:

- -
gNativeWindow = new android::FramebufferNativeWindow();
-sGLContext = GLContextProvider::CreateForWindow(this);
- -

La clase FramebufferNativeWindow es obtenida directamente desde Android; ver FramebufferNativeWindow.cpp. Este emplea la API de gralloc para acceder al controlador de gráficos con el fin de mapear los buffers del dispositivo framebuffer a la memoria del dispositivo.

- -

Gecko emplea su sistema (de) Layers para componer contenido dibujado en la pantalla. En resumen, ocurre lo siguiente:

- -
    -
  1. Gecko dibuja regiones distintas de las páginas en los buffers de memoria, A veces, estos buffers están en la memoria del sistema; otras veces, son texturas mapeadas en el espacio de direcciones de Gecko, lo que siginifica que Gecko está dibujando directamente en la memoria de video. Esto se realiza generalmente en el método BasicThebesLayer::PaintThebes().
    2. -
  2. Entonces, Gecko, compone todas estas texturas en la pantalla empleando comandos OpenGL. Esta composición tiene lugar en ThebesLayerOGL::RenderTo().
    3. -
- -

Los detalles de cómo Gecko maneja el muestreo (rendenring) de contenido web se encuentra fuera del alcance de este documento.

- -

Capa de Abstracción de Hardware (HAL)

- -


- La capa de abstracción de hardware de Gecko es una de sus capas de adaptación (porting). Gestiona los accesos de bajo nivel a las interfaces del sistema a lo largo de múltiples plataformas usando una API de C++ accesible desde los niveles superiores de Gecko. Estas APIs son implementadas plataforma a plataforma dentro de la HAL de Gecko. Esta capa de abstracción de hardware no es expuesta directamente a código JavaScript dentro de Gecko.

- -

Cómo funciona HAL

- -

Vamos a considerar la API Vibration como ejemplo. la HAL para esta API se define en hal/Hal.h. Resumiendo (simplificando el método de firma para hacerlo más claro), tienes esta función:

- -
void Vibrate(const nsTArray &pattern);
- -

Esta es la función que el código de Gecko llama par activar la vibración del dispositivo de acuerdo con un patrón específico; una función correspondiente existe para cancelar la vibración activa. La implementación de GONK para este método está en hal/gonk/GonkHal.cpp:

- -
void Vibrate(const nsTArray &pattern) {
-  EnsureVibratorThreadInitialized();
-  sVibratorRunnable->Vibrate(pattern);
-}
-
- -

Este código envía la petición para el inicio de la vibración a otro conjunto de procesos, que se implementa en VibratorRunnable::Run(). El bucle principal de este hilo seria parecido a esto:

- -
while (!mShuttingDown) {
-  if (mIndex < mPattern.Length()) {
-    uint32_t duration = mPattern[mIndex];
-    if (mIndex % 2 == 0) {
-      vibrator_on(duration);
-    }
-    mIndex++;
-    mMonitor.Wait(PR_MillisecondsToInterval(duration));
-  }
-  else {
-    mMonitor.Wait();
-  }
-}
-
- -

vibrator_on() es la API HAL de GONK que enciende el motor de vibración. Internamente, este método envía un mensaje al controlador de núcleo (kernel driver) al escribir un valor en un objeto de kernel empleando sysfs.

- -

Implementaciones de la Fallback HAL API

- -


- Las APIs HAL de Gecko tienen soporte en todas las plataformas. Cuando se construye Gecko para una plataforma que no expone una interfaz a los motores de vibración (como una computadora de escritorio) entonces se vale de una implemenación de fallback de la API de HAL. Para la vibración, este esta implementado en hal/fallback/FallbackVibration.cpp.

- -
void Vibrate(const nsTArray &pattern) {
-}
- -

Implementaciones de Sandbox (entorno cerrado)

- -

Debido a que la mayoría del contenido de la red se ejecuta en procesos de contenido con privilegios bajos, no podemos suponer que esos procesos tienen los privilegios necesarios para poder (por ejemplo) activar o desactivar el motor de vibración. Además, queremos tener una ubicación central para controlar las posibles condiciones de carrera (race conditions). En la HAL de Gecko, esto es realizado por medio de la implementación de una sandbox de la HAL. Esta sandbox simplemente funciona como un proxy para la peticiones realizadas por los procesos de contenido y las reenvía al proceso del "servidor Gecko". Las peticiones de proxy se envían empleando IPDL.

- -

Para la vibración, la función Vibrate() se encarga de la gestión y se la implementa en hal/sandbox/SandboxHal.cpp:

- -
void Vibrate(const nsTArray& pattern, const WindowIdentifier &id) {
-  AutoInfallibleTArray p(pattern);
-
-  WindowIdentifier newID(id);
-  newID.AppendProcessID();
-  Hal()->SendVibrate(p, newID.AsArray(), GetTabChildFrom(newID.GetWindow()));
-}
- -

Esto envía un mensaje definido por la interfaz PHal, descrita por IPDL en hal/sandbox/PHal.ipdl. El método se describe aproximadamente de la siguiente manera:

- -
Vibrate(uint32_t[] pattern);
- -

El receptor de este mensaje es la HalParent::RecvVibrate() method in hal/sandbox/SandboxHal.cpp, el cual seria algo parecido a esto:

- -
virtual bool RecvVibrate(const InfallibleTArray& pattern,
-            const InfallibleTArray &id,
-            PBrowserParent *browserParent) MOZ_OVERRIDE {
-
-  hal::Vibrate(pattern, newID);
-  return true;
-}
- -

Este omite algunos detalles que no son relevantes a este punto pero, en cualquier caso, demuestra cómo el mensaje progresa desde un proceso de contenido a través de Gecko hasta Gonk, luego a la implementación de la HAL de Gonk Vibrate(), y finalmente al controlador de vibración.

- -

APIs DOM

- -

Las interfaces DOM son, esencialmente, la forma en la que el contenido web se comunica con Gecko. Hay más información al respecto y, si estás interesado en detalles extras, puedes leer sobre el DOM. Las interfaces DOM se definen empleando IDL, que compone una interfaz de función foránea (foreign function interface, FFI) y un objeto modelo (OM) entre JavaScript y C++.

- -

La API de vibración se expone al contenido web por medio de una interfaz IDL, que se la provee en nsIDOMNavigator.idl:

- -
[implicit_jscontext] void mozVibrate(in jsval aPattern);
- -

El argumento jsval indica que mozVibrate() (que es nuestra implementación vendedor-prefijada de esta especificación no finalazida de vibración) acepta como ingreso cualquier valor de JavaScript. El compilador IDL, xpidl, genera una interfaz C++ que entonces se implementa por la clase Navigator en Navigator.cpp.

- -
NS_IMETHODIMP Navigator::MozVibrate(const jsval& aPattern, JSContext* cx) {
-  // ...
-  hal::Vibrate(pattern);
-  return NS_OK;
-}
- -

Hay mucho más código en este método de lo que ves aquí, pero no es importante para el proposito que estamos tratando. El hecho es que la llamada a hal::Vibrate() transfiere el control de DOM a la HAL Gecko. Desde allí, entramos a la implementación de HAL tratada en la sección previa y continuamos hacia el controlador. Además, la implementación DOM no se preocupa por la plataforma en la que está corriendo (Gonk, Windows, OS X, o cualquier otra). Tampoco le interesa si el código está corriendo en un proceso de contenido o en un proceso del servidor Gecko. Esos detalles se dejan de lado para que los gestionen los procesos de nivel bajo del sistema.

- -

La API de vibración es muy simple, lo que la convierte un ejemplo excelente. La API de SMS es más compleja porque emplea su propia capa de envío remoto que conecta los procesos de contenido con el servidor.

- -

Capa de Interfaz de Radio (CIR/RIL)

- -

La RIL (Radio Interface Lyer) ya se mencionó en la sección The userspace process architecture. Esta sección examinará con más detalle cómo las diferentes partes de esta capa interactúan.

- -

Los componentes principales involucrados en la RIL son los siguientes:

- -
-
rild
-
El daemon que habla al firmware del módem de fábrica.
-
rilproxy
-
El daemon que referencia mensajes (proxy) entre rild y Gecko (que está implementado en el proceso b2g). Esto soluciona el problema de permisos que surje cuando se trata de comunicar con rild directamente ya que sólo se puede comunicar con rild desde el grupo radio.
-
b2g
-
Este proceso, también conocido como el proceso chrome, implementa Gecko. Las partes de el que se relacionan con la Capa de Interfaz de Radio son dom/system/gonk/ril_worker.js, las cuales implementan una cadena de procesos de trabajo (worker thread) que se comunica con rild a través de rilproxy es implementa el estadio radial (radio state machine) y la interfaz nsIRadioInterfaceLayer, que es el servicio XPCOM de la cadena de procesos principal, que actúa principalmente como un intercambio de mensajes entre la cadena ril_worker.js y otros numerosos componentes de Gecko, incluidos el proceso de contenido de Gecko.
-
Proceso de contenido de Gecko (Gecko's content process)
-
Dentro del proceso de contenido de Gecko, la interfaz nsIRILContentHelper provee un servicio XPCOM que permite a algunas partes de código implementado de DOM, tales como las APIs Telephony y SMS, comunicarse con la interfaz de radio, la cual es un proceso chrome.
-
- -

Ejemplo: comunicación desde rild a DOM

- -

Echemos una mirada al ejemplo de cómo las partes del nivel inferior del sistema se comunican con código DOM. Cuando el módem recibe una llamada entrante, la notifica a rild empleando un mecanismo de fábrica. entonces rild prepara un mensaje para su cliente de acuerdo con el protocolo "open", que se describe en ril.h. En el caso de una llamada entrante, se genera un mensaje RIL_UNSOL_RESPONSE_CALL_STATE_CHANGED y lo envía rild a rilproxy.

- -

rilproxy, implementada en rilproxy.c, recibe este mensaje en bucle principal, que envía (poll) la conexión a rild utilizando código como éste:

- -
ret = read(rilproxy_rw, data, 1024);
-
-if(ret > 0) {
-  writeToSocket(rild_rw, data, ret);
-}
- -

Una vez que el mensaje es recibido por rild, se lo reenvía a Gecko en el empalme que conecta rilproxy con Gecko. Gecko recibe el mensaje enviado en su IPC thread:

- -
int ret = read(fd, mIncoming->Data, 1024);
-// ... handle errors ...
-mIncoming->mSize = ret;
-sConsumer->MessageReceived(mIncoming.forget());
-
- -

El consumidor de estos mensajes es SystemWorkerManager, que reempaqueta los mensajer y los envía a la cadena ril_worker.js que implementa la máquina de estado RIL; que se realia en the RILReceiver::MessageReceived() method:

- -
virtual void MessageReceived(RilRawData *aMessage) {
-  nsRefPtr dre(new DispatchRILEvent(aMessage));
-  mDispatcher->PostTask(dre);
-}
- -

La tarea postada en esa cadena a su vez llama la función onRILMessage(), que se implemente en JavaScript. Esto se realiza empleando la función JS_CallFunctionName() de la API de JavaScript:

- -
return JS_CallFunctionName(aCx, obj, "onRILMessage", NS_ARRAY_LENGTH(argv),
-                           argv, argv);
- -

onRILMessage() está implementada en dom/system/gonk/ril_worker.js, que procesa los bytes del mensaje y los corta en fragmentos. Cada fragmento completo se envía a métodos de gestión (handler) individuales apropiadamente:

- -
handleParcel: function handleParcel(request_type, length) {
-  let method = this[request_type];
-  if (typeof method == "function") {
-    if (DEBUG) debug("Handling parcel as " + method.name);
-    method.call(this, length);
-  }
-}
-
- -

Este código trabaja por medio del tipo de petición (request) del objeto, asegurándose de que sea definido como una función en código de JavaScript, para después llamar al método. Ya que ril_worker.js implementa cada tipo de petición (request type) en un método con el mismo nombre que el tipo de petición, es muy sencillo.

- -

En nuestro ejemplo RIL_UNSOL_RESPONSE_CALL_STATE_CHANGED, se llama al siguiente handler:

- -
RIL[UNSOLICITED_RESPONSE_CALL_STATE_CHANGED] = function UNSOLICITED_RESPONSE_CALL_STATE_CHANGED() {
-  this.getCurrentCalls();
-};
- -

Como puedes ver en el código de más arriba, cuando se recibe la notificación que el estado de la llamada ha cambiado, la máquina de estado (state machine) simplemente trae para sí el estado actual de la llamafa invocando el método getCurrentCall():

- -
getCurrentCalls: function getCurrentCalls() {
-  Buf.simpleRequest(REQUEST_GET_CURRENT_CALLS);
-}
- -

Esto envía una petición de vuelta a rild para solicitar el estado de todas las llamadas actuales. La petición regresa por un camino similar al que siguió el mensaje RIL_UNSOL_RESPONSE_CALL_STATE_CHANGED message pero en la dirección opuesta (es decir, desde ril_worker.js a SystemWorkerManager a Ril.cpp, después a rilproxy y finalmente al rild socket). rild responde por el camino inverso y la respuesta llega al handler de ril_worker.js's handler para el mensaje REQUEST_GET_CURRENT_CALLS. Así es como se da lugar la comunicación bidireccional.

- -

El estado de la llamda se procesay compara con el estado previo; si hay un cambio de estado, ril_worker.js notifica al servicio nsIRadioInterfaceLayer de la cadena principal:

- -
_handleChangedCallState: function _handleChangedCallState(changedCall) {
-  let message = {type: "callStateChange",
-                 call: changedCall};
-  this.sendDOMMessage(message);
-}
- -

Se implementa nsIRadioInterfaceLayer en dom/system/gonk/RadioInterfaceLayer.js; se recibe el mensaje por su método onmessage():

- -
 onmessage: function onmessage(event) {
-   let message = event.data;
-   debug("Received message from worker: " + JSON.stringify(message));
-   switch (message.type) {
-     case "callStateChange":
-       // This one will handle its own notifications.
-       this.handleCallStateChange(message.call);
-       break;
-   ...
-
- -

Lo que todo esto realmente hace es enviar el mensaje al proceso de contenidos empleando el Administrador de Mensajes de Procesos Principales [Parent Process Message Manager (PPMM)]:

- -
handleCallStateChange: function handleCallStateChange(call) {
-  [some internal state updating]
-  ppmm.sendAsyncMessage("RIL:CallStateChanged", call);
-}
- -

En el proceso de contenidos, el mensaje es recibido por el método receiveMessage() en el servicio nsIRILContentHelper, del Administrador de Mensajes de Procesos Secundarios [Child Process Message Manager (CPMM)]:

- -
receiveMessage: function receiveMessage(msg) {
-  let request;
-  debug("Received message '" + msg.name + "': " + JSON.stringify(msg.json));
-  switch (msg.name) {
-    case "RIL:CallStateChanged":
-      this._deliverTelephonyCallback("callStateChanged",
-                                     [msg.json.callIndex, msg.json.state,
-                                     msg.json.number, msg.json.isActive]);
-      break;
- -

Esto, a su vez, llama a los métodos nsIRILTelephonyCallback.callStateChanged() de cada uno de los objetos registrados de las respuesta de telefonía (registered telephony callback object). Cada aplicación web que accede la API window.navigator.mozTelephony API ha registrado uno de ese tipo de objeto que envía los eventos al código JavaScript code en la aplicación web, así sea como un cambio de estado de un objeto de llamada existente o un nuevo evento de llamada incoming.

- -
NS_IMETHODIMP Telephony::CallStateChanged(PRUint32 aCallIndex, PRUint16 aCallState,
-                                          const nsAString& aNumber, bool aIsActive) {
-  [...]
-
-  if (modifiedCall) {
-    // Change state.
-    modifiedCall->ChangeState(aCallState);
-
-    // See if this should replace our current active call.
-    if (aIsActive) {
-      mActiveCall = modifiedCall;
-    }
-
-    return NS_OK;
-  }
-
-  nsRefPtr call =
-          TelephonyCall::Create(this, aNumber, aCallState, aCallIndex);
-  nsRefPtr event = CallEvent::Create(call);
-  nsresult rv = event->Dispatch(ToIDOMEventTarget(), NS_LITERAL_STRING("incoming"));
-  NS_ENSURE_SUCCESS(rv, rv);
-  return NS_OK;
-}
- -

Las aplicaciones pueden recibir estos eventos y actualizar su interfaz de usuario:

- -
handleEvent: function fm_handleEvent(evt) {
-  switch (evt.call.state) {
-    case 'connected':
-      this.connected();
-      break;
-    case 'disconnected':
-      this.disconnected();
-      break;
-    default:
-      break;
-  }
-}
- -

Echa una mirada a la implementación de handleEvent() in the Dialer application como un ejemplo más.

- -

Datos 3G

- -

Hay un mensaje RIL que inicia una "petición de datos" al servicio móvil; este activa el modo de transferencia de datos en el modem. Esta petición de datos termina creando y activando una interfaz Point-to-Point Protocol (PPP) en el kernel Linux que pueden ser configuradas usando las interfaces comunes.

- -
-

Nota: Esta sección necesita ser redactada

-
- -

APIs relacionadas con DOM

- -

Esta sección lista las APIs de DOM que estan relacionadas con comunicaciones RIL.

- - - -

WiFi

- -

El backend de WiFi para Firefox OS simplemente usa wpa_supplicant para hacer la mayor parte del trabajo.
- Esto significa que el principal trabajo del backend es simplemente gestionar el supplicant, y hacer algunas tareas auxiliares como cargar el driver del WiFI y activar o desactivar la interfaz de red.
- En resumen, esto significa que el backend es una maquina de estados, con los estados que indican el estado del supplicant.

- -
-

Note: Muchas cosas interesantes que suceden en WiFi dependen profundamente de posibles cambios de estado en el proceso wpa_supplicant.

-
- -

La implementación del componente WiFi esta dividida en dos archivos.

- -
-
dom/wifi/DOMWifiManager.js
-
Implementa lo que la API muestra al contenido web, tal como esta definido en nsIWifi.idl.
-
dom/wifi/WifiWorker.js
-
Implementa la máquina de estados y el código que controla el supplicant.
-
- -

Estos dos archivos se comunican con otro usando el gestor de mensajes.
- El backend escucha los mensajes que requieran una determinada acción, como "asociar" y responde con una mensaje cuando la acción requerida ha sido completada.

- -

El lado del DOM escucha los métodos de respuesta, asi como muchos mensajes de eventos que indican cambios de estado y actualización de información.

- -
-

Note: Algunas API's síncronas de DOM son implementadas leyendo datos en el otro extremo de la tubería. Los mensajes síncronos son evitados siempre que es posible

-
- -

WifiWorker.js

- -

Este archivo implementa la logica principal detras de la interfaz WiFi. Se ejecuta en el proceso chrome (en construcciones multiproceso) y es instanciado por el SystemWorkerManager. El fichero es generalmente dividido en dos secciones: una gigantesca funcion anonima y WifiWorker (y su prototipo). La funcion anonima termina siendo el WifiManager proveyendo una API local, incluyendo notificaciones para eventos como una conexion al supplicant y escaneando los resultados cuando estan disponibles. En general. este contiene la logica simple y manda a su control exclusivo de consumidor sus acciones mientras estas simplemente responden a la informacion requerida y controla los detalles de la conexion con el supplicant.

- -

El objeto WifiWorker se situa entre el WifiManager y el DOM. Este reacciona a eventos y los sigue al DOM; a su vez, este recibe las peticiones del DOM y realiza las acciones apropiadas en el supplicant. Este tambien mantiene informacion sobre el supplicant y lo siguiente que necesita hacer.

- -

DOMWifiManager.js

- -

Este implementa la API de DOM, transmitiendo mensajes hacia atras y llamadas de regreso y el actual WiFi worker. Hay muy poca logica envuelta aqui.

- -
-

Nota: Para poder permitir mensajes sincronos al proceso chrome, el WiFi Manager necesita cachear el estado basado en el envio recibido.

-
- -

Hay un solo mensaje sincrono, el cual es enviado en cuanto la API DOM se instancia, para poder obtener el estado actual del supplicant.

- -

DHCP

- -

DHCP y DND van de la mano con dhcpcd, el cliente DHCP estandar en Linux.
- Sin embargo, este no permite reaccionar cuando la conexion de red se pierde.
- Por eso, Firefox OS mata y reinicia dhcpcd cada vez que se conecta a una red inalambrica dada.

- -

dhcpcd es tambien responsable de ajustar la ruta por defecto; nosotros llamamos al gestor de redes para informar al kernel sobre los servidores DNS.

- -

Gestor de Redes

- -

El Gestor de Redes configura las interfaces de red abiertas por los datos 3G y los componentes WiFi

- -
-

Nota: Esto necesita ser redactado.

-
- -

Procesos e hilos

- -

Firefox OS usa los hilos de POSIX para implementar todos los hilos de las aplicaciones - esto incluye los hilos principales de cada aplicación asi como los trabajadores web y los hilos de ayuda. Los grupos de control son usados para priorizar procesos e hilos de ejecución que dependen del planificador completamente justo del kernel Linux. Dependiendo del estado del proceso le asignaremos un grupo de control distinto. Actualmente tenemos 6 niveles de prioridad correspondientes a 5 grupos de control

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Process priority levels
PriorityNiceUsed for
MASTER0proceso principal de b2g
FOREGROUND_HIGH0aplicaciones criticas que sostienen la cpu y el wakelock de alta prioridad.
- Este es actualmente reservado para el reloj y las aplicaciones de comunicacion
FOREGROUND1aplicaciones en primer plano
FOREGROUND_KEYBOARD1aplicacion de teclado
BACKGROUND_PERCEIVABLE7aplicaciones en segundo plano que ejecuten audio o sostengan la CPU o el wakelock de alta prioridad y tengan al menos un controlador de mensajes de sistema registrado
BACKGROUND_HOMESCREEN18aplicacion de pantalla principal
BACKGROUND18resto de aplicaciones que se ejecuten en segundo plano
   
- -

Algunos niveles comparten el mismo grupo de control, esto es asi porque dichos niveles actualmente difieren en la manera que son tratados por el liberador de memoria. Todas las prioridades pueden ser ajustadas en tiempo de ejecucion mediante preferencias; las entradas relativas a esto se pueden encontrar en el b2g/app/b2g.js file.

- -

Actualmente se usan los siguientes grupos de control:

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Grupos de Control
RutaOcupación de la CPUDescripción
 50% del tiempo total de CPUGrupo de control de Root reservado para el proceso principal de b2g y los servicios del sistema
apps50% del tiempo total de CPUAplicaciones comunes
apps/critical95% de las appsAplicaciones criticas
apps/bg_perceivable10% de las appsAplicaciones perceptibles en segundo plano
apps/bg_non_interactive5% de las appsAplicaciones en segundo plano
- -
-

Nota: para mas informacion sobre el liberador de memoria, y como Firefox OS gestiona las situaciones de memoria baja, lease Out of memory management on Firefox OS

-
- -

Sin un proceso, el hilo principal hereda el "valor seguro" del proceso, mientras que los procesos web en curso toman un "valor seguro" que es un punto mas alto que el hilo principal, que corre la prioridad mas baja.
- Esto esta hecho para prevenir que los ciclos intensivos en curso de la CPU ralenticen excesivamente el hilo principal. Todos los hilos de una aplicación son actualmente asignados al mismo grupo de control. Las prioridades de los procesos son cambiadas cuando un evento importante sucede, como cuando una aplicación cambia de segundo plano al primer plano, o una nueva aplicación inicia, o una aplicación acapara la CPU.

- -
-

Nota: los cgroups soportados en dispositivos ICS estan actualmente rotos debido a un bug del kernel.

-
- -

 

diff --git a/files/es/archive/b2g_os/building_and_installing_boot_to_gecko/dispositivos_compatibles/index.html b/files/es/archive/b2g_os/building_and_installing_boot_to_gecko/dispositivos_compatibles/index.html deleted file mode 100644 index 009e1c5ab5..0000000000 --- a/files/es/archive/b2g_os/building_and_installing_boot_to_gecko/dispositivos_compatibles/index.html +++ /dev/null @@ -1,360 +0,0 @@ ---- -title: Dispositivos compatibles -slug: Archive/B2G_OS/Building_and_installing_Boot_to_Gecko/Dispositivos_compatibles -translation_of: Archive/B2G_OS/Building_and_installing_B2G_OS/Compatible_Devices ---- -
-

Instalar B2G OS en tu dispositivo es fácil con el instalador de B2G (Add-on de Firefox)

-
- -
-

Nota: Todos los dispositivos tienen debajo de su nombre (ver el nombre). Por ejemplo para construir la imagen para Nexus 6 haz ./build.sh nexus-6-1. Los nombres en código de los dispositivos es proporcionado por los fabricantes. Puedes encontrar el archivo build.prop en una ROM stock.

-
- -

Dispositivos de Desarrollo

- -

Estos dispositivos son de referencia oficial para el desarrollo de B2G

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Imagen
Nombre
- (Versión android)		Z3 Compact (Kitkat)
- Sony Shinano platform		Z3 (Kitkat)
- Sony Shinano platform		Flame (Kitkat)
Nombre en códigoaries-kkleo-kkflame-kk
Información de construcción e instalaciónhttps://discourse.mozilla-community.org/t/building-b2g-os-for-aries-z3c/8082 https://discourse.mozilla-community.org/t/flame-builds/8548
Disponible en B2G InstallerSíNoSí
- -

Dispositivos Soportados por la Comunidad

- -

Estos dispositivos son mantenidos por los esfurzos de la comunidad. ¡Siéntete libre de ayudar!

- -
-

La frecuencia de la distribución de las builds depende del número de voluntarios y del tiempo disponible.

-
- -

Dispositivos disponibles

- -

Estos dispositivos tienen builds disponible para ejecutar B2G:

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
ImageN
Nombre
- (Versión de Android)		ZTE Open CNexus 5WileyFox SwiftFairphone 2
Nombre en códigoopenc-fr / openc-ebay                         
Información de construcción e instalaciónhttps://discourse.mozilla-community.org/t/zte-open-c/8402/ -

https://discourse.mozilla-community.org/t/test-b2gos-on-nexus-5/9405/1

- 		  -

https://discourse.mozilla-community.org/t/fairphone-2-build/8641/
- https://discourse.mozilla-community.org/t/fairphone-2-support-for-b2g-installer-landed/8334

-
Disponible en B2G Installer -

No

- -

(but a buildbot is available)

- 		SíSí -

Dentro de poco.

- -

Blobfull build working.

-
- -

En progeso

- -

Trabajando en soporte para estos dispositivos.

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Imagen 
Nombre
- (Versión de Android)		E3
- Sony Yukon platform		Z1 Compact (Lollipop)
- Sony Rhine platform		Xiaomi Redmi 1S
Nombre en códigoflamingo-lamami-larmani
Información de construcción e instalaciónhttps://discourse.mozilla-community.org/t/b2g-os-flamingo-sony-xperia-e3-builds/8361https://discourse.mozilla-community.org/t/support-for-amami-xperia-z1c-building-debugging-providing-builds/8348https://discourse.mozilla-community.org/t/wip-xiaomi-redmi-1s-hongmi-1s/10273
Estado de soporteBloqueado, hay problemas con las herramientas de flasheo.Versiones previas de pruebas.Versiones previas de pruebas
- -

Dispositivos con posibilidad de portar el SO

- -

Esto es una lista de dispositivos con potencial para portar B2G, gracias a las versiones de AOSP y Cyanogen Mod disponibles, o porque soportaban versiones anteriores de Firefox OS hasta la versión 2.6

- -
-

Nota: No hay ports para estos dispositivos, pero es posible construir B2G. Mira la sección de cómo construir para más información. Eres bienvenido para ayudar al mantenimiento de estas builds.

-
- -

Dispositivos Nexus

- -

Estos dispositivos son (en parte) soportados por B2G porque son dispositivos de referencia de Google para AOSP

- - - - - - - - - - - - - - - - -
Nexus 6Nexus 4
  
- -

Dispositivos de Sony

- -

Estos dispositivos pertenecen a la iniciativa Sony Mobile´s Open Devices, que tiene como objetivo el soporte de los móviles Xperia en AOSP

- -

Estos dispositivos están construidos en base a AOSP Lollipop.

- -
-

Ahora mismo la mayoría de los dispositivos Sony no tienen soporte para cámara. Esto depende del avance del trabajo de los desarrolladores de Sony. Además, nosotros contribuimos con el mantenimiento de estos ports.

-
- -

Los dispositivos que está en curso el soporte para B2G no están listados aquí.

- -

Sony Shinano Platform

- - - - - - - - - - - - - - - - - - - - - - -
 
Z3 Z3 Tablet CompactZ2
leo-l scorpion-lsirius-l
- -
-
- -

Sony Rhine Platform

- -
-

Los dispositivos Rhine utilizan un chip NFC Legacy, así que esta función no está disponible. Mira el bug 1226720. Necesitamos contribuidores para el mantenimiento de estos ports.

-
- - - - - - - - - - - - - -
Z1
honami-l
- -

Sony Yukon Platform

- - - - - - - - - - - - - - - - - - - -
T2 UltraT3M2
tianchi-lseagull-leagle-l
- -

Dispositivos Soportados CyanogenMod

- -

Hay que completar.

- -

Dispositivos Legacy

- -

Muchos dispositivos antiguos no son mantenidos por la comunidad, pero es posible que voluntarios puedan mantenerlos vivos. El estado actual de estos dispositivos es desconocido, así que es probable que no se pueda instalar B2G.

- -

No hay dispositivos aquí actualmente.

- -

Obsolete Devices

- -
-

Olvídate del soporte para estos dispositivos si tenes uno.

-
- -

Varios dispositivos antiguos ya no son soportados por B2G OS, y no tenemos voluntarios para mantenerlos vivos. El estado actual de estos dispositivos es desconocido, lo que probablemente significa que no se puede actualizar B2G.

- - - - - - - - - - - - - - - - - - - - - - -
Geeksphone PeakGeeksphone KeonZTE OpenTCL Fire
peakkeoninarihamachi
- - - - - - - - - - - - - - - - - - - - - - -
Samsung Galaxy S2Galaxy NexusNexus SNexus S 4G
galaxy-s2galaxy-nexusnexus-snexus-s-4g
- - - - - - - - - - - - - - - - - - - - - - -
Foxconn InFocusVia VixenPandaboardRaspberry Pi
flatfishvixenpandaboardrpi
diff --git a/files/es/archive/b2g_os/building_and_installing_boot_to_gecko/firefox_os_build_process_summary/index.html b/files/es/archive/b2g_os/building_and_installing_boot_to_gecko/firefox_os_build_process_summary/index.html deleted file mode 100644 index 2ba4b7b7b6..0000000000 --- a/files/es/archive/b2g_os/building_and_installing_boot_to_gecko/firefox_os_build_process_summary/index.html +++ /dev/null @@ -1,109 +0,0 @@ ---- -title: Resumen del proceso de compilación de Firefox OS -slug: >- - Archive/B2G_OS/Building_and_installing_Boot_to_Gecko/Firefox_OS_build_process_summary -tags: - - Firefox OS - - compilar - - instalación - - instalar -translation_of: Archive/B2G_OS/Building_and_installing_B2G_OS/B2G_OS_build_process_summary ---- -
-

Compilar e Instalar Firefox OS requiere una significante cantidad de tiempo, ancho de banda de red, y poder computacional. Desafortunadamente, a lo largo del camino, las cosas son susceptibles de salir mal. Esta página describe los objetivos del proceso de compilación y  los pasos de este proceso con el fin de ayudar a los usuarios a lo largo del camino. Los detalles de cada paso son mostrados en los enlaces de su respectiva página.

-
-
-

Nota: El proceso de compilación de Firefox OS está lleno de referencias a 'B2G' o 'Boot2Gecko'. 'Boot2Gecko' fué el nombre clave original del proyecto Firefox OS.

-
-

El objetivo de la compilación: cuatro archivos 'image'

-

El objetivo general del proceso de compilación es la compilacióno de cuatro archivos que puedan ser copiados a un dispositivo Firefox OS.

- - - - - - - - - - - - - - - - - - - -
boot.imgEl Kernel Linux y un root filesystem image, este último provee un útil conjunto de herramientas básicas de Unix.
system.imgEl núcleo de Firefox OS incluye partes de Gonk, el puerto de Gecko, y el ejecutable b2g.
userdata.imgEl perfil Gecko del usuario y la aplicación web Gaia para el dispositivo.
recovery.imgUn kernel Linux y una imagen del sistema de ficheros raíz, junto con una herramienta sencilla para que los usuarios puedan arreglar una mala instalación.
-

Una vez que se han creado las cuatro imágenes, estas pueden ser transferidas al dispositivo.

-

Firefox OS está compilado sobre la base de Android Open Source Project (AOSP). Las herramientas AOSP, adb y fastboot, proveen una potente vía para acceder y manipular un dispositivo. Notablemente, el comando adb reboot-bootloader puede ocasionar que un dispositivo conectado se reinicie (reboot) y se detenga en la fase inicial del  bootloader donde el comando fastboot flash $partition $image puede ser usado para copiar una imágen al dispositivo.

-

La imagen de arranque

-

La imagen de arranque (boot.img) es una combinación del Kernel Linux y una partición inicial del root proveyendo el software núcleo de utilidad y el script de inicialización. Este último será copiado en la memoria del dispositivo para uso eficiente por el dispositivo y por consiguiente es llamado "ramdisk". La imagen de arranque será copiada en la partición 'boot' en el dispositivo y el contenido del  ramdisk es visible iniciando en el directorio raíz (root) cuando el  filesystem del dispositivo es accedido en tiempo de ejecución (runtime), tal como cuando se usa adb shell.

-

La imágen de arranque también establece los permisos de los usuarios root en el archivo default.prop  en el directorio raíz.

-

También es posible modificar una imágen de arranque existente mediante la inspección de archivo, dividiendo el archivo en el Kernel y ramdisk image, extrayendo los contenidos de la imagen ramdisk, modificando esos contenidos, reensamblando la imagen ramdisk, entonces recompilando una boot.img funcional. Ver, por ejemplo, la página de Alcatel One Touch Fire Hacking (Mini) Guide.

-

La imagen de arranque puede ser probada antes de ser instalada por  'sideloading'; el dispositivo puede ser inicializado y pausado en el  bootloader y luego un  fastboot puede ser usado para arrancar desde la imagen de arranque sin instalarla usando el comando fastboot boot /some/path/to/boot.img.

-

La imagen del sistema

-

La imagen del sistema (system.img) provee el núcleo de  Firefox OS:

- -
-

Vea la guía la pataforma Firefox OS para más información acerca de la arquitectura de la plataforma.

-
-

La imagen del sistema será copiada a la partición system  en el dispositivo y será visible en el directorio /system/ cuando el  filesystem del dispositivo sea accedido en tiempo de ejecución.

-
-

Nota: La Imagen del Sistema también provee las manchas binarias (blobs) que pueden ser usadas por el dispositivo, notablemente el RIL (Radio Interface Layer) controla la radio celular en el dispositivo.

-
-

La imagen de los datos de usuario

-

La imagen de los datos de usuario (userdata.img) provee las aplicaciones Gaia cargadas en tiempo de ejecución.

-

La imagen de los datos de usuario será copiada a la partición userdata en el dispositivo y los contenidos serán visibles en el directorio /data/ cuando el filesystem del dispositivo sea accedido en tiempo de ejecución. Notablemente el directorio /data/b2g/  contiene el   profile  de Mozilla Gecko del dispositivo del usuario mientras el directorio /data/local/webapps/ contiene la aplicación web actual disponible para el usuario.

-

La imagen de recuperación

-

La imagen de recuperación (recovery.img) contiene lo mismo que el Kernel y un similar ramdisk que están presentes en la partición de la imagen de arranque. La imagen de recuperación sin embargo utiliza un script de inicialización diferente, lo que lleva al usuario a un conjunto de recuperación de comandos de acceso utilizando los botones de hardware en el dispositivo.

-

La Imagen de recuperación será copiada a la partición recovery en el dispositivo,  que no es montada en el filesystem en tiempo de ejecución normal.

-

El proceso de compilación:  ajustar, configurar,  compilar, instalar

-

El proceso general de construcción e instalación de Firefox OS consta de cuatro pasos:

- - - - - - - - - - - - - - - - - - - -
AjustarObtener copias de todos los programas usados por el proceso de construcción, tales como los compiladores y librerías.
ConfigurarDescargar el código fuente que será utilizado en la creación y construcción del archivo .configure que define las variables del entorno especificando las direcciones y otros valores utilizados en la construcción.
CompilarCompilar el perfil Gecko del usuario y la aplicación web Gaia para el dispositivo.
InstalarInstalar los archivos en el dispositivo.
-

 

-

Ajustar

-

El ajuste inicial debe ser hecho para asegurar el equipo que corre la compilación tenga todos el software requerido durante la compilación, tal como compiladores y herramientas de construcción.

-

Esta paso puede ser hecho a mano o usando un script. Los detalles los podemos ver en la página Prerrequisitos para compilar Firefox OS.

-
-

Nota: En UNIX y máquinas UNIX, la presencia de los software requeridos pueden ser comprobados usando el comando unix which con el nombre del programa requerido como parámetro.

-
-

Configuración

-

El actual proceso de compilación inicia obteniendo una copia del software Firefox OS (o B2G), por lo general mediante la creación de un clon Git del proyecto B2G. La configuración de compilación obtendrá copias de todo el código fuente que es compilado y crea el archivo .config que especifica las variables para la compilación.

-

Esto se ejecuta con el script config.sh. Más detalles podemos encontrar en la página Preparandote para tu primer binario B2G .

-

Es script necesario de configuración y parámetros especificando el tipo de dispositivo a compilar. Los nombre de compilación son códigos nombre enlazados a la arquitectura del CPU en lugar de un dispositivo específico, y actualmente no hay manera de establecer qué compilación trabaja para qué dispositivo físico. Una lista de códigos nombres  disponibles puede encontrarse aquí.

-

El paso de configuración también utilizará la herramienta Android Open Source Project repo para descargar (o actualizar) una copia de todo el código utilizado en la compilación. Estas copias serán almacenadas en el directorio .repo/projects. Debido a esta actividad, el paso de configuración puede tardar bastante tiempo y descargará una gran cantidad de datos.

-

Compilar

-

El paso de compilación lo qe hace es compilar todo el código fuente y produce como resultado las imagenes.

-

Esto se ejecuta con el script  build.sh. Para más detalles podemos encontrar en la página Compilando Firefox OS .

-

Por defecto, el paso de compilación es monolítico, intentando compilar todo a la vez desde las herramientas Android Open Source Project para el  kernel Linux a la aplicación web Gaia. Cuando la compilación falla,  puede a veces no ser claro en que paso ha fallado.

-

Es posible compilar solo ciertas partes de toda la pila Firefox. Por ejemplo, el sistema Gecko solo puede ser compilado mediante una llamada al script de compilación con el parámetro gecko. De igual manera, Gaia puede ser compilado de forma independiente utilizando el parámetro gaia. Estas partes pueden ser instaladas de forma separada en el dispositivo como se explica a mas adelante.

-

También se pueden compilar las imágenes mostradas en la primera parte de esta página. Por ejemplo, el sistema de imagen puede ser compilado utilizando./build.sh out/platform/$target/system.img, donde el parámetro $target es el mismo que el dado en el paso de configuración.

-

Instalar

-

El paso de instalación colocará nuevamente el código compilado en el dispositivo. Esto es ejecutado con el script flash.sh .

-

Partes individuales de la compilación pueden ser instaladas agregando un parámetro al script flash. Por ejemplo, es posible instalar sólo la aplicación web gaia especificando ./flash.sh gaia.

diff --git a/files/es/archive/b2g_os/building_and_installing_boot_to_gecko/index.html b/files/es/archive/b2g_os/building_and_installing_boot_to_gecko/index.html deleted file mode 100644 index 0e2cc7d35d..0000000000 --- a/files/es/archive/b2g_os/building_and_installing_boot_to_gecko/index.html +++ /dev/null @@ -1,82 +0,0 @@ ---- -title: Construyendo e instalando Firefox OS -slug: Archive/B2G_OS/Building_and_installing_Boot_to_Gecko -tags: - - B2G - - Documentación de construcción - - Firefox OS -translation_of: Archive/B2G_OS/Building_and_installing_B2G_OS ---- -
-

Debido a que Firefox OS está actualmente en un desarrollo activo, y se encuentra en estado preliminar, la mejor manera de asegurarse de que tienes una copia actualizada e instalada, es compilarla e instalarla tú mismo. Los artículos comprendidos en esta página te guiarán a través de la compilación y la instalación de Firefox OS en un emulador, dispositivo compatible, o en la interfaz de usuario de Gaia en el navegador Firefox.

-
- - - - - - - -
-

Cómo obtener y compilar Firefox OS

-
-
- Firefox OS visión general de la compilación
-
- La compilación e instalación de Firefox OS requiere de una cantidad significativa de tiempo, ancho de banda y una computadora potente. Esta página describe los objetivos del proceso de compilación y de los pasos de este proceso con el fin de ayudar a los usuarios a lo largo del camino.
-
- Firefox OS requisitos previos de compilación
-
- Pasos a seguir antes de compilar Firefox OS por primera vez.
-
- Preparándose para su primera compilación de Firefox OS
-
- Antes de poder compilar Firefox OS, es necesario clonar el repositorio y configurar su construcción. En este artículo se explica cómo hacerlo.
-
- Compilando Firefox OS
-
- Cómo compilar Firefox OS.
-
-
-
- Compilando la llama de Firefox OS en OSX
-
- Cómo realizar la compilación de la llama de Firefox OS en OSX.
-
-
-
- Portando a Firefox OS
-
- Información sobre cómo portar Firefox OS a nuevos dispositivos.
-
-

Ver todo...

- 		-

Instalación de Firefox OS y/o Gaia

-
-
- Eligiendo cómo iniciar Gaia o Firefox OS
-
- Puedes usar Gaia dentro de Firefox, o puedes ejecutar Firefox OS en un dispositivo móvil o en un simulador en el escritorio. Esta guía te ayudará a decidir cuál es mejor para tus necesidades.
-
- Usando Gaia en Firefox
-
- Cómo utilizar Gaia dentro de un navegador Firefox de escritorio.
-
- Usando el cliente B2G de escritorio
-
- Una guía para ejecutar y utilizar el cliente de escritorio de Firefox OS; esto simula el entorno Gaia en una aplicación de escritorio. Es más preciso que ejecutar Gaia en Firefox, pero no es tan preciso como los emuladores.
-
- Usando los emuladores de Firefox OS
-
- Una guía para compilar y usar los emuladores de Firefox OS y cuándo usar cada uno.
-
- Instalando Firefox OS en un dispositivo móvil
-
- Cómo instalar Firefox OS en un dispositivo móvil real.
-
- Booteo doble de Firefox OS y Android en SGS2
-
- Cómo configurar un entorno de booteo doble Firefox OS/Android en un Samsung Galaxy S2.
-
-
-

 

diff --git a/files/es/archive/b2g_os/building_b2g_for_qemu_emulator/index.html b/files/es/archive/b2g_os/building_b2g_for_qemu_emulator/index.html deleted file mode 100644 index af77d73b5f..0000000000 --- a/files/es/archive/b2g_os/building_b2g_for_qemu_emulator/index.html +++ /dev/null @@ -1,37 +0,0 @@ ---- -title: Compilando B2G para el emulador QEMU -slug: Archive/B2G_OS/Building_B2G_for_QEMU_Emulator -translation_of: Archive/B2G_OS/Building_and_installing_B2G_OS ---- -

Obsoleto
Esta funcionalidad es obsoleta. Aunque puede aún funcionar en algunos navegadores, se desalienta su uso ya que puede ser removida en cualquier momento. Evite usarla.

- -

Éste artículo está obsoleto. Ver Compilando e instalando Boot to Gecko, una guía completa para compilar Firefox OS.

- -

Suponemos que ya has configurado tu entorno de compilación y clonado los repositorios.

- -

Los siguientes pasos  te permitirán compilar - y ejecutar - B2G en tu emulador.  NO ejecutar como root.

- -

$ cd B2G
- $ make sync

- -

- -

Compilar con la configuración para QEMU:
- $ make config-qemu

- -

Lo siguiente, construir el backend gonk y luego el propio sistema:
- $ make gonk
- $ make
-
- NOTA:   si ./emu.sh - tu emulador - no se inicia a la primera, tendrás que hacerlo ejecutable:
- $ chmod +x emu.sh
-
- Después, ejecuta el emulador:
- $ ./emu.sh

- -

NOTA:  Después de clonar los repositorios o al crear tu compilación por primera vez, puedes "limpiar" them - e.g. put them into the state so that the latest pull is the same as a fresh clone.

- -

To do this, from your repo root:
- $ make sync; git clean -xfd; git submodule foreach "git clean -xfd"
- Alternately, you can try:
- $ make mrproper

diff --git a/files/es/archive/b2g_os/compilar_boot_to_gecko/index.html b/files/es/archive/b2g_os/compilar_boot_to_gecko/index.html deleted file mode 100644 index 255f1a3db0..0000000000 --- a/files/es/archive/b2g_os/compilar_boot_to_gecko/index.html +++ /dev/null @@ -1,123 +0,0 @@ ---- -title: Compilando Firefox OS -slug: Archive/B2G_OS/Compilar_Boot_to_Gecko -translation_of: Archive/B2G_OS/Building ---- -
-
-

Una vez que hayas preparado tu sistema para compilar y hayas realizado la clonación inicial y configurado el código, podrás compilar Boot to Gecko.

-

Actualizar tu código

-

Si no es la primera vez que compilas B2G, deberías actualizar el código antes de empezar a compilar. Para hacerlo, debes actualizar tanto las herramientas de B2G como las dependencias, usando los siguientes dos comandos:

-
git pull
-./repo sync
-
-

Puedes actualizar partes específicas del repositorio aclarando su nombre:

-
./repo sync gaia
-
-

El comando repo tiene otras opciones disponibles que pueden ser interesantes; repo help te dará mucha información.

-

Compilar

-
-

Nota: Antes de compilar, conviene que prepares un archivo .userconfig para personalizar la compilación. Mira Personalizar el archivo .userconfig para aprender cómo hacerlo.

-
-

Para compilar Boot to Gecko, debes usar simplemente la herramienta build.sh:

-
cd B2G
-./build.sh
-
-

Es hora de otra pausa para un café, o posiblemente una siesta (especialmente si es tu primera compilación). Así como en el paso de configuración de la página anterior, si usas un directorio de archivos de sistema de Android previamente extraídos, deberás establecer ANDROIDFS_DIR antes de ejecutar build.sh.

-

Compilar sólo ciertos módulos

-

Si sólo quieres compilar un módulo en particular, por ejemplo Gecko, puedes hacerlo incluyendo el nombre:

-
./build.sh gecko
-
-

Si sólo quieres actualizar una de las aplicaciones, puedes hacerlo compilando el módulo gaia y usando la variable de entorno BUILD_APP_NAME:

-
BUILD_APP_NAME=calendar ./build.sh gaia
-

Para ver una lista de los módulos que puedes compilar, haz:

-
./build.sh modules
-
-

Especificar cuántos núcleos de procesador usar

-

Por defecto, el compilador de B2G utiliza el número de procesadores que existan en tu ordenador, y establece dos como el número de tareas a ejecutar en paralelo. Puedes cambiar estos números especificando el parámetro -j cuando ejecutes build.sh. Esto es útil si estás usando el ordenador para otras cosas mientras compilas, y necesitas reducir el uso de CPU. También viene bien cuando tienes problemas con la compilación, ya que ejecutar tareas de una en una facilita la lectura de mensajes y registros.

-

Por ejemplo, para compilar ejecutando 2 tareas en paralelo, usa:

-
./build.sh -j2
-
-

El uso más común de esta opción es configurar la compilación para no ejecutar tareas en paralelo, lo cual facilita la lectura de mensajes y la resolución de errores. Para ello, usa:

-
./build.sh -j1
-
-

Construir para múltiples configuraciones regionales

-

Para crear un sistema que incluya varias configuraciones regionales, haz lo siguiente:

-

Gaia

-
    -
  1. Escoge el archivo de idioma que quieres usar. Ahora mismo hay dos en Gaia shared/resources/languages-dev.json y shared/resources/languages-all.json
    2. -
  2. Clona las configuraciones regionales que necesitas desde http://hg.mozilla.org/gaia-l10n a un directorio; nosotros usamos gaia-l10n/ . Tendrás que clonar un repositorio para cada uno de las configuraciones regionales incluidas en el archivo de idiomas.
    3. -
  3. En tu sistema, configura LOCALE_BASEDIR como la ruta absoluta al directorio que creaste en el paso 2. Configura LOCALES_FILE como la ruta absoluta al archivo que escogiste en el paso 1.
    4. -
-

Por ejemplo:

-
export LOCALE_BASEDIR=$PWD/gaia-l10n
-export LOCALES_FILE=$PWD/gecko/gaia/shared/resources/languages-dev.json
-
-

Gecko

-
    -
  1. Escoge el archivo de idioma que quieres usar. En Gecko, ahora mismo utilizamos b2g/locales/all-locales
    2. -
  2. Clona las configuraciones regionales que necesitas a un directorio; por ejemplo gecko-l10n/ . - -
    3. -
  3. Clona compare-locales.
    4. -
  4. -

    En tu sistema, configura L10NBASEDIR como la ruta absoluta al directorio que creaste en el paso 2. Configura MOZ_CHROME_MULTILOCALE como una lista de las configuraciones regionales que clonaste, separadas con espacios.

    -

    Añade el directorio compare-locales/scripts a tu PATH, y compare-locales/lib a tu PYTHONPATH.

    - Por ejemplo, - 
    export L10NBASEDIR=$PWD/gecko-l10n
-export MOZ_CHROME_MULTILOCALE="ja zh-TW"
-export PATH="$PATH:$PWD/compare-locales/scripts"
-export PYTHONPATH="$PWD/compare-locales/lib"
-
    -

    Una vez hayas completado estos pasos, puedes ejecutar build.sh .

    -

    Al parecer, también es posible usar .userconfig.

    -

    Es posible que estas instrucciones cambien a medida de que avanza el proyecto.

    -

    Errores conocidos

    -
      -
    • -

      KeyedVector.h:193:31: error: indexOfKey was not declared in this scope

      -
      • -
    -

    Este error aparece cuando tu versión de gcc es demasiado reciente. Instala una versión 4.6.x de gcc/g++/g++-multilib.

    -

    Visita Prerrequisitos para compilar Firefox OS para más información.

    -
    -

    Aviso de la comunidad: Es posible utilizar gcc 4.7.x si modificas ligeramente el código de B2G (gcc te proporcionará instrucciones), pero no te podemos ayudar, ni a modificar el código ni con los errores que te puedas encontrar.

    -
    -
      -
    • -

      arm-linux-androideabi-g++: Internal error: Killed (program cc1plus)

      -
      • -
    -

    Si ves este mensaje, lo más probable es que no tengas suficiente memoria libre. Asegúrate de tener suficiente memoria libre antes de ejecutar./build.sh. Normalmente, 4GB de ram son suficientes para compilar sin problemas.

    -
      -
    • -

      Si encuentras errores mientras el compilador está haciendo tests

      -
      • -
    -

    A veces (especialmente después de actualizar el compilador o el sistema operativo) puedes encontrarte con errores extraños mientras el compilador está haciendo test tras acabar de compilar. Algo como esto:

    - 
    Generating permissions.sqlite...
-test -d profile || mkdir -p profile
-run-js-command  permissions
-WARNING: permission unknown:offline-app
-WARNING: permission unknown:indexedDB-unlimited
-build/permissions.js:122: NS_ERROR_UNEXPECTED: Component returned failure code: 0x8000ffff (NS_ERROR_UNEXPECTED) [nsIPermissionManager.add]
-make[1]: *** [permissions] Error 3
-make: *** [gaia/profile.tar.gz] Error 2
    -

    En estos casos, prueba a eliminar el directorio gaia/xulrunner-sdk y haz "pull" para bajarte el código de nuevo:

    - 
    rm -r gaia/xulrunner-sdk
-
    -

    Este comando elimina la copia precompilada de XULRunner que el compilador se baja automáticamente. Cuando compiles de nuevo, el compilador obtendrá una nueva copia de XULRunner automáticamente.

    -

    Próximos pasos

    -

    Tras compilar, los pasos siguientes dependen de si has compilado Boot to Gecko para el emulador o para un teléfono móvil; lee los artículos siguientes para más información:

    - -
    5. -
diff --git a/files/es/archive/b2g_os/complementos/index.html b/files/es/archive/b2g_os/complementos/index.html deleted file mode 100644 index c6f9d4dca8..0000000000 --- a/files/es/archive/b2g_os/complementos/index.html +++ /dev/null @@ -1,58 +0,0 @@ ---- -title: Complementos para Firefox OS -slug: Archive/B2G_OS/Complementos -translation_of: Archive/B2G_OS/Add-ons ---- -

Firefox OS 2.5 introduce el soporte para complementos, una característica que los usuarios de equipos de sobremesa han conocido y amado desde el principio de Firefox. Los complementos en Firefox OS son incluso aún más poderosos y pueden personalizar no solo el navegador, dando una experiencia completa con el teléfono, incluyendo modificaciones en la pantalla de inicio y aplicaciones del sistema como por ejemplo la aplicación de Correo o la de Mensajes. Esta página dice todo lo que necesitas saber para empezar con la creación de complementos para Firefox OS e involucrarse con la comunidad de desarrolladores de complementos.

- -
-

Nota: Los complementos de Firefox OS se basan en la WebExtensions API, que tambien es compatible con Firefox para escritorio a partir de la versión 42 y es basado en la API de extensiones usada por Chrome y Opera.

-
- -

Requisitos previos

- -

Usted deberá seguir los pasos que se indican a continuación para empezar con el desarrollo de las extensiones.

- -

1. Actualizar su teléfono a la versión Firefox OS 2.5

- -

Los complementos en Firefox OS solo son compatibles con Firefox OS 2.5 y versiones posteriores. A continuación se muestra una lista con los dispositivos compatibles y cómo actualizarlos (esta lista está incompleta y se modificará en el futuro).

- - - -

2. Habilitar la depuración USB

- -

Ir a la aplicación de Ajustes del dispositivo, seleccione Desarrollador > Depurar vía USB > ADB y DevTools. Ahora debería ser capaz de depurar las apps instaladas mediante WebIDE, ya sea a través de un cable USB y por Wifi (no necesita cable USB.)

- -

3. Configurar WebIDE

- -

El herramienta de WebIDE es parte de Firefox y puede utilizarse para instalar complementos en el teléfono durante el desarrollo.

- -

Véase también

- -

Desarrollo

- - - -

Distribución

- - - -

Participar

- - diff --git a/files/es/archive/b2g_os/consejos_uso_firefox_os/index.html b/files/es/archive/b2g_os/consejos_uso_firefox_os/index.html deleted file mode 100644 index 057a2d39a9..0000000000 --- a/files/es/archive/b2g_os/consejos_uso_firefox_os/index.html +++ /dev/null @@ -1,21 +0,0 @@ ---- -title: Consejos de uso de Firefox OS -slug: Archive/B2G_OS/Consejos_uso_Firefox_OS -translation_of: Archive/B2G_OS/Firefox_OS_usage_tips ---- -
-
- Depuración remota
-
- Como poner tu teléfono para la depuración remota.
-
- Desbloqueando tu teléfono
-
- Instrucciones básicas para desbloquear tu teléfono.
-
-  Hacer capturas de pantalla
-
- Como hacer capturas de pantalla en tu teléfono con Firefox OS.
-
-  
-
diff --git a/files/es/archive/b2g_os/debugging/depurar_b2g_usando_gdb/index.html b/files/es/archive/b2g_os/debugging/depurar_b2g_usando_gdb/index.html deleted file mode 100644 index ff30152895..0000000000 --- a/files/es/archive/b2g_os/debugging/depurar_b2g_usando_gdb/index.html +++ /dev/null @@ -1,79 +0,0 @@ ---- -title: Depurar B2G usando gdb -slug: Archive/B2G_OS/Debugging/Depurar_B2G_usando_gdb -translation_of: Archive/B2G_OS/Debugging/Debugging_B2G_using_gdb ---- -

-

Borrador
- Esta página no está completa.

- -

-

Depurar Firefox OS usando gdb es fácil. Este artículo lo ayudará a hacerlo aún más fácil.

-

Iniciar el depurador en modo proceso único

-
-

Nota: Antes de ejecutar el depurador, podría configurar un archivo .userconfig para personalizar ciertas cosas. Vea Personalización con el archivo .userconfig para más detalles.

-
-

Para reiniciar Firefox OS y ejecutarlo bajo el control de gdb, simplemente use el script run-gdb.sh:

-
./run-gdb.sh
-
-
-

Nota: Si desea depurar en el emulador, asegúrese de no tener teléfonos conectados; esto puede causar conflctos con la habilidad de gdb de conectarse al emulador.

-
-

Si ya se está ejecutando Firefox OS y desea adjuntarlo sin reiniciarlo, puede hacer algo como:

-
./run-gdb.sh attach
-
-

Depurar tareas fuera del proceso

-

Because of the threaded nature of Firefox OS, you often need to be able to debug tasks other than the main B2G task. To do this, the simplest way is to use the b2g-ps command to find out the PID of the process that you need to debug:

-
$ adb shell b2g-ps
-b2g              root      106   1     189828 56956 ffffffff 40101330 S /system/b2g/b2g
-Browser          app_0     4308  106   52688  16188 ffffffff 400db330 S /system/b2g/plugin-container
-
-

Aquí, Browser es el proceso hijo usado como el "proceso contenido" para la aplicación navegador. Así que si quiere depurar el proceso contenido, en este ejemplo, debería hacer:

-
$ ./run-gdb attach 4308
-

A veces es útil ser notificado inmediatamente de la creación de cualquier proceso hijo. Esto puede lograrse iniiando run-gdb.sh con la variable de entorno MOZ_DEBUG_CHILD_PROCESS:

-
MOZ_DEBUG_CHILD_PROCESS=1 ./run-gdb.sh
-

Habiendo hecho esto, lanzar una aplicación OOP en Firefox OS mostrará el PID de plugin-container para la nueva tarea y esperará 30 segundos, tiempo suficiente para hacer

-
$ ./run-gdb attach <pid>
-

como se mencionaba anteriormente.

-

Si está tratando de depurar algo que ocurre durante el booteo, deberá lanzar la instancia del depurador para la nueva aplicación con bastante rapidez. Una vez que el nuevo depurador fue lanzado, debería presionar inmediatamente "c" para continuar ejecutando la nueva tarea.

-

Soporte

-

Que nivel de funcionalidad se espera

-

Al menos las siguientes caracterísiticas de depuración deberían funcionar definitivamente. Si no lo hacen, lo más probable es que un simple ajuste a la configuración las haga funcionar:

- -

Las siguientes características de depuración not están soportadas. No intente usarlas.

- -

Solución de problemas

-

Hay unas pocas cosas que intentar cuando GDB no está funcionando como se describe anteriormente.

-

Asegúrese que el clon de B2G está actualizado

-

Siempre tenga en mente que para actualizar su clon de B2G debe ejecutar estos dos comandos:

-
git pull
-./repo sync
-

Olvidarse de git pull aquí es una típica razón por la que se terminará con un run-gdb.sh viejo y no se beneficiará de las mejoras recientes.

-

Asegúrese de adjuntarse al proceso correcto

-

Adjuntarse al proceso equivocado (ej. proceso principal de B2G en lugar del proceso Browser) podría explicar por que los breakpoints no se alcanzan.

-

Asegúrese que los símbolos se leyeron correctamente

-

En gdb, use info shared para verificar que los símbolos se leyeron correctamente:

-
(gdb) info shared
-From        To          Syms Read   Shared Object Library
-0xb0001000  0xb0006928  Yes         out/target/product/otoro/symbols/system/bin/linker
-0x40051100  0x4007ed74  Yes         /hack/b2g/B2G/out/target/product/otoro/symbols/system/lib/libc.so
-0x401ab934  0x401aba2c  Yes         /hack/b2g/B2G/out/target/product/otoro/symbols/system/lib/libstdc++.so
-...
-

La columna Syms Read debería decir Yes en todas partes. Quizás en algún teléfono android podría ver Yes (*) para algunas librerías del sistema o drivers; eso debería estar bien. No se debería ver ningún No.

-

Si se ve un No, ese es el primer problema y debe resolverlo antes de buscar otra cosa.

-

Busque cualquer mensaje de error en la salida de terminal justo después de tipear el comando run-gdb.sh.

-

También verifique en esa salida de terminal output que el comando GDB esté correcto. En particular, el último argumento de la línea de comando debería ser la ruta al ejecutable de b2g. Aquí hay un ejemplo correcto:

-
prebuilt/linux-x86/toolchain/arm-linux-androideabi-4.4.x/bin/arm-linux-androideabi-gdb -x /tmp/b2g.gdbinit.bjacob /hack/b2g/B2G/objdir-gecko/dist/bin/b2g
-

Verifique el valor de estas variables de GDB: solib-search-path y solib-absolute-prefix:

-
(gdb) show solib-search-path
-The search path for loading non-absolute shared library symbol files is /hack/b2g/B2G/objdir-gecko/dist/bin:out/target/product/otoro/symbols/system/lib:out/target/product/otoro/symbols/system/lib/hw:out/target/product/otoro/symbols/system/lib/egl:out/target/product/otoro/symbols/system/bin:out/target/product/otoro/system/lib:out/target/product/otoro/system/lib/egl:out/target/product/otoro/system/lib/hw:out/target/product/otoro/system/vendor/lib:out/target/product/otoro/system/vendor/lib/hw:out/target/product/otoro/system/vendor/lib/egl.
-(gdb) show solib-absolute-prefix
-The current system root is "out/target/product/otoro/symbols".
-

Si necesita ayuda, intente el canal de IRC #b2g. Si piensa que encontró un error, infórmelo en B2G issue tracker.

diff --git a/files/es/archive/b2g_os/debugging/developer_settings/index.html b/files/es/archive/b2g_os/debugging/developer_settings/index.html deleted file mode 100644 index 3146b7c96d..0000000000 --- a/files/es/archive/b2g_os/debugging/developer_settings/index.html +++ /dev/null @@ -1,194 +0,0 @@ ---- -title: Developer settings for Firefox OS -slug: Archive/B2G_OS/Debugging/Developer_settings -translation_of: Archive/B2G_OS/Debugging/Developer_settings ---- -
-

Contained in the Firefox OS Settings app is the Developer panel. This panel offers a number of options that can make debugging your open web app on Firefox OS easier. This article covers the options available and how to make use of them.

-
-

The settings panel for developer options is intentionally buried deep to avoid having end users who have no need for these options inadvertently turning on options that make their device run more slowly or add strange visual effects to their displays. The panel looks something like this (the following is from a Geeksphone Keon running an April 2014 build of Firefox OS 2.0; yours may differ if you are running a different version):

-

-

The developer panel is reached as follows:

- -

The following sections cover each of the options in the Developer panel, explaining what they do and why they're useful.

-
-

Importante: Estas herramientas pueden ocasionar fallos durante el uso normal del teléfono. Algunas características vienen desactivadas por defecto debido a los fallos que han sido reportados.

-
-

Ajustes para Desarrolladores

-

Depuración via USB

-

La opción "depuración remota" permite utilizar la depuración remota en tu dispositivo. Esto también activa los comandos ADB. En las versiones anteriores a Firefox 1.4 solo existe una casilla para activar estas funciones; en Firefox 1.4 y superior existen tres opciones diferentes:

- -

HUD Desarrolladores

-

En versiones superiores a Firefox OS 1.4, seleccionando este menú entrarás a las opciones del HUD Desarrolladores.

-

-

Existen varias opciones que son explicadas a continuacion:

- -

Cuadros por Segundo

-

Al activar esta opción se mostrarán tres números en la esquina izquierda de la pantalla, si bien estos numeros son "instantáneos" son sólo suposiciones y pueden no ser acertivos. A continuación se explica qué significa cada número:

- -

A screenshot of Firefox OS, showing three numbers in the top left hand corner that are measurements of app framerate.

-

Time to load

-

Firefox OS also has a tool that can help measure startup time, specifically the "first paint" time. The value shown by the tool — in the top right of the Firefox OS display — is the elapsed time between when the most recent application was launched, and an estimate of the first time that application painted its UI, in milliseconds. This number only approximates the real "first paint" time, and in particular underestimates it. However, lowering this number almost always correlates to improvements in real startup time, so it can be useful to quickly measure optimization ideas.

-

A screenshot of Firefox OS, showing a number in the top right hand corner that is a measurement of the current app startup time, in milliseconds.

-

App memory

-

Displays information on how much memory the app is using, and allows you to enable or disable the different items that use memory to show much each one is using in the current app. For example, the screen shot below only has App memory and JS objects checked, and the indicator on the bottom right is showing that the Settings app is using 414.77KB for JS objects.

-

-

Pseudo-localization

-

When enabled, pseudo-languages like Accented English and Mirrored English are available for selection in Settings > Languages.  With pseudo-localizations, you can test the localizability of your code in regular Gaia builds without having to add real language resources nor having to speak a foreign language.  For instance, you can make sure the layout scales well with longer strings, you can preview the app in a fake RTL language, or spot HTML elements wihout the data-l10n-id attribute (they will be displayed in regular English).

-

Screenshot of pseudolocales

-

You can turn pseudo-localizations on by default when you build Gaia by adding the following line into gaia/build/config/common-settings.json:

-
 "devtools.qps.enabled": true
-

Note: Pseudo-localizations are generated completely dynamically, each time an app is launched.  The performance and memory characteristics may be different than those of regular localizations.  If you specifically want to test performance of non-English languages, build multilocale Gaia with real locales.

-

Graphics settings

-

Flash repainted area

-

In this mode, every time a region of the screen is painted by Gecko, Gecko blits a random translucent color over the painted region. Ideally, only parts of the screen that visually change between frames will "flash" with a new color. But sometimes more area than is needed is repainted, causing large areas to "flash". This symptom may indicate that application code is forcing too much of its scene to update. It may also indicate bugs in Gecko itself.

-

A screenshot of Firefox OS with a number of transparent overlays, showing the parts of the screen repainted with each new animation frame.

-

Enable APZ for all content (Async Pan/Zoom)

-

When enabled, the Async Pan/Zoom module allows panning and zooming to be performed on asynchronously, on another thread, with some noticeable differences to rendering behaviour. To find out more, read the MozillaWiki APZ article.

-

Overscrolling

-

This enables and disables the behaviour in Firefox 2.1+ where the display stretches in an elastic manner when you scroll past the end of a page, then shrinks back again when you stop dragging the display. The behaviour's full name is elastic overscroll.

-

Tiling (was Layers: Enable tiles)

-

Introduced in Firefox OS 1.4, this feature enables the painting of content to the screen in smaller chunks ("tiles") rather than painting the whole screen at once. This is mainly useful for platform QA work involving reducing checkerboarding and finding regression windows.

-

Simple tiling (was Layers: Simple tiles)

-

This flips between the two different content painting implementations described in the section above.

-

Low-precision painting

-

Enabling this option makes Gecko paint a low-precision (blurry) version of the content when scrolling really fast. This is useful because it's quicker to paint, and so helps us avoid displaying blank areas (i.e. checkerboarding) while scrolling quickly. It should only be visible to the user temporarily; once the user stops scrolling we fill in the low-precision areas with high-precision content.

-

Low-precision transparency

-

This is an additional flag for low-precision painting, which makes the low-precision content half transparent. This makes it a little more subtle and less jarring for the user.

-

Hardware composer (was Enable hardware compositing)

-

When enabled, this setting causes the device to use its Hardware Composer to composite visual elements (surfaces) to the screen.

-

Draw tile borders (was Layers: Draw tile borders)

-

This is very similar to the Draw layer borders option, the difference being that it also draws the borders for individual tiles as well as the borders around layers.

-

Draw layer borders

-

When this setting is enabled, a brightly colored border is added around all the different layers painted to the display — great for diagnosing layout issues.

-

A screenshot from Firefox OS showing an opened select form with the draw layers borders option enabled, resulting in colored borders being drawn on all the different rendered layers.

-

Dump layers tree

-

This option enables layers.dump, which causes a copy of the compositor's layer tree to be dumped to logcat on every frame composited to the screen; this is mainly useful for platform graphics performance work, rather than regular web development.

-

Cards View: Screenshots

-

When enabled, this specifies that app screenshots will be taken when the open apps are displayed in card view. If disabled, app icons are shown in the center of blank cards for the card view instead.

-

Window management settings

-

Software home button

-

Enabling this option creates a software home button that can provide the same functionality as the equivalent hardware button if it is not available. This is intended for future use on devices that are likely to not have hardware home buttons, like tablets.

-

Home gesture

-

Enabling this option allows you to swipe upwards towards the center from outside the screen to bring up the homescreen. Again, this can provide the same functionality as the equivalent hardware button if it is not available, and is intended for future use on devices that are likely to not have hardware home buttons, like tablets.

-

Continuous transition

-

This setting allows you to decide whether app keyboards open immediately or continuously (with a  transition). Disabling such transition effects are useful on low end devices, when they cause performance to suffer.

-

App transition

-

Turn this on and then off again and you will disable all app closing/opening transitions: all apps will now just show immediately, without the smooth animation, and keyboards will also open/close without animation. Like "Continuous transition enabled", this is meant for improving performance on low end devices, but it has more of an effect.

-

App suspending

-

If enabled, this specifies that when an app is killed in the background, it will be kept in history and reopened when you open it from homescreen/card view. If disabled, such apps are not kept in history/card view.

-

Debug settings

-

Log slow animations

-

This tool tries to help developers understand why animations are not offloaded to the compositor to be run efficiently as possible. It reports "bugs" like trying to animate elements that are too large, or trying to animate CSS properties that can't be offloaded. The messages you'll get on the device will look like the following:

-
I/Gecko   ( 5644): Performance warning: Async animation disabled because frame size (1280, 410) is bigger than the viewport (360, 518) [div with id 'views']
-
-

Geolocation output in ADB

-

Enables logging of geolocation data to adb logcat. This helps with debugging both the GPS stack (namely we get NMEA callback) and MLS use.

-

Wi-Fi output in adb

-

Enabling this option adds information about Wi-Fi to the adb logs (error logs from the console can be accessed using adb logcat | grep "Error" in the Terminal.)

-

Bluetooth output in adb

-

Enabling this option adds information about Bluetooth to the adb logs (error logs from the console can be accessed using adb logcat | grep "Error" in the Terminal.)

-

Console enabled

-

When enabled, this option lets you use the Web Console in Firefox to remotely access the console output on the device; without this option enabled, the console.log() function does nothing.

-

Gaia debug traces

-

Enabling this directly enables DEBUG traces in Gaia; see error 881672 for more details.

-
-

Note: Unfortunately, not every app supports this mechanism to print their debug log. Instead, they control a "DEBUG" flag in code directly, so enabling this flag does NOT ensure that you'll see all debug logs.

-
-

Show accessibility settings

-

This enables the accessibility settings menu, subsequently found at Settings > Accessibility. The options contained within the accessibility settings are as follows:

-

Screen reader

-

Enabling this option turns on Firefox OS's screen reader. This is technology that allows a blind person to use a Firefox OS device. Currently at a very early stage, it changes the way the standard touch events work. When the screen reader is on, you must interact with the screen as follows:

- -
-

Note: If you have turned the screen reader on and wish to disable it again, you must navigate back to the setting via these new gestures and double-tap the checkbox once it is highlighted to turn it off again. That will restore the touch screen functionality to its default behaviour.

-
-

Note: In Firefox 1.4 and above, there is a quick toggle for the screen reader. Press volume up, then down, three times (up, down, up, down, up, down). The screen reader will instruct you to perform this same action again (volume up, down, up, down, up, down) to turn it on if it is not running, or to turn it off if it is already running. If you do not want to change the current toggle state, simply do something else. That way, you can turn it on and off at will to test your web application for accessibility without having to navigate the accessibility settings menu each time.

-

Speech volume

-

A slider that controls how loud the speech is delivered.

-

Speech rate

-

A slider that controls how fast the speech is delivered.

-

Use Marketplace reviewer certs

-

TBD

-

Shake to save system log

-

TBD

-

Verbose app permissions

-
-

Note: Introduced with Firefox 2.1

-
-

When this is enabled, developers (and privacy enthusiasts) may modify all permissions granted to installed privileged apps, using The "App Permission" pane in the Settings app. The app sub-pages under here are updated upon enabling the setting to provide a list of each API permission is requested for in the app's manifest file, along with choices to set that permission to. For example, "Schedule Alarms" appears with choices of Ask, Deny and Grant. Note that some apps may be unable to deal with changed permissions. If you experience any odd behavior, consider resetting the permission or re-installing the app.

-

Launch first time use

-

The "Launch first time use" button runs the "First-Time Use" (FTU) program; this lets you go through the initial setup and tutorial process, and is useful when trying to debug that process, or if you want to re-configure your device from scratch.

-

Software updates

-

Update channel

-

Enables you to specify different update channels to get software updates from when your device receives OTA updates. Options are nightly, aurora ... (others?)

-

Update URL

-

Enables you to specify different URLs from which to receive your updates.

-

Obsolete settings

-

This section lists settings that are no longer provided, or no longer exist in the same state, but might still be interesting if you are running an older version of Firefox OS.

-

Accessibility

-

In versions of Firefox earlier than newer 1.4 versions, this controls the accessibility settings, as explained in the Show_accessibility_settings section above.

-

Grid

-

The "Grid" option, when enabled, causes the Firefox OS display to be overlaid with a grid pattern to help you gauge positioning and alignment of items. For example, below we see the Browser app running with the Grid option enabled:

-

-

The grid's heavier lines are 32 pixels apart, both horizontally and vertically.

-

Show frames per second

-

In Firefox OS versions older than newer 1.4, enabling this displays frames per second, as explained in the Frames_per_second section above.

-

Show time to load

-

In Firefox OS versions older than newer 1.4, enabling this displays time to load information, as explained in the Time_to_load section above.

-

Rocketbar enabled

-

In Firefox OS versions older than newer 1.4, this option enables the new Firefox Rocketbar on your device, which provides a useful new way to switch between apps, search, and more. When enabled, you'll find a search icon at the top left of the device, and the RocketBar can be brought up by swiping from the top left of the device towards the bottom left.

-
-

Note: In newer versions of Firefox OS, Rocketbar is enabled automatically and cannot be turned off.

-
-

Contacts debugging output in adb

-

Enabling this option adds debugging information about contacts to the adb logs (error logs from the console can be accessed using adb logcat | grep "Error" in the Terminal.)

-

Progressive paint (was Layers: Progressive paint)

-

This was introduced to help with debugging of the Async Panning/Zoom module (APZ) during its implementation. Now APZ implementation is complete, this option is deprecated, and will be removed from future versions (see error 1003228).

-

Displayport Heuristics

- -

These options were introduced to help with debugging of the Async Panning/Zoom module (APZ) during its implementation, specifically to allow QA to experiment with different repainting heuristics to see which resulted in the least amount of checkboarding.. Now APZ implementation is complete, these options are deprecated, and will be removed from future versions (see error 1003228).

-

Edges gesture

-

Enabling this option allows you to swipe left and right from outside the screen towards the center, to navigate to the next and previous sheets (either web pages in the browser, or views inside another app.) This basically works like the browser navigator bar in Firefox, but is enabled by default in Firefox 2.1+.

-

Keyboard layouts

-

In addition to the developer-specific options listed above, Firefox OS < 1.4's developer settings featured keyboard layout options. These let you toggle on and off the then-experimental Chinese input methods:

-

-

As of Firefox 1.4, these options have been removed. This is because the Chinese keyboard layout implementations (zhuyin and pinyin) have now been completed.

-
-

Note: For other keyboard layouts still under development, such as Japanese, we now have a build-time config to opt them in.

-
-

 

diff --git a/files/es/archive/b2g_os/debugging/index.html b/files/es/archive/b2g_os/debugging/index.html deleted file mode 100644 index a06052613e..0000000000 --- a/files/es/archive/b2g_os/debugging/index.html +++ /dev/null @@ -1,74 +0,0 @@ ---- -title: Depuración en Firefox OS -slug: Archive/B2G_OS/Debugging -translation_of: Archive/B2G_OS/Debugging ---- -

Hay tres tipos de depuración que puedes realizar con Firefox OS. Puedes hacer un nivel más elevado de depuración ejecutando Gaia (y por lo tanto muchas aplicaciones web compatibles con B2G) en Firefox 15 o posteriores en el escritorio, lo cual te permitirá utilizar las excelentes herramientas de desarrollador disponibles en Firefox que te ayudarán a depurar la IU de Gaia a la vez que tu aplicación web. Por otro lado puedes usar la aplicación de escritorio dedicada a B2G; o ejecutar Firefox OS en tu dispositivo móvil o en el emulador bajo el control de gdb debugger. Y hay herramientas disponibles para ti mientras ejecutes el cliente de escritorio B2G. Este artículo proporciona enlaces a información útil para todos estos métodos varios de depurar tu código de Firefox OS.

- - - - - - - -
-

documentacion de depuracion Firefox OS

-
-
- Depuración de aplicaciones de Firefox OS en Firefox para escritorio
-
- Puedes utilizar Firefox de escritorio para depurar muchas aplicaciones web. Este artículo  te ofrece una guía de características de Firefox que te pueden venir muy bien mientras lo haces.
-
- Preparándose para depurar código de Firefox OS
-
- Antes de ponerte a usar la mayoría de herramientas integradas en Firefox para depurar código funcionando bajo Firefox OS, necesitarás realizar un poquito de trabajo de configuración previo. Este artículo te explica qué.
-
- Utilizando el depurador
-
- Puedes emplear el Depurador remoto integrado de Firefox para depurar código ejecutado bajo Firefox OS en un dispositivo usando una conexión compartida (tethering) o en el simulador de Firefox OS.
-
- Usando la Consola web remota con Firefox OS
-
- La característica Consola web remota incluida en Firefox te permite ver la salida de la consola en un dispositivo con Firefox OS.
-
- Depurando B2G con gdb
-
- El popular depurador gdb se puede utilizar para depurar Firefox OS y aplicaciones que estén en ejecución tanto en un dispositivo como en un emulador. Esta guía te mostrará cómo hacerlo.
-
- Depurar utilizando el cliente de escritorio B2G
-
- Hay una serie de características disponibles en el cliente de escritorio B2G que puedes utilizar para ayudarte a depurar tus aplicaciones. Aprende sobre ellas en este artículo.
-
- Consejos generales para la depuración con B2G
-
- Consejos de uso general aplicables a cualquier depuración con B2G que realices.
-
- Personalizando el script b2g.sh
-
- Puedes personalizar el script b2g.sh para ajustar las variables del entorno y así cambiar el comportamiento de Gecko.
-
- Obtención de registros NSPR en B2G
-
- Puedes usar los registros NSPR para grabar HTTP y otras redes.
-
- Registro HTTP
-
- Cómo registrar tráfico de red HTTP network para propósitos de depuración.
-
-

Ver todo...

- 		-

obten ayuda de la comunidad

-

Si estás trabajando con Firefox OS, o desarrollando aplicaciones que te gustaría ejecutar en dipositivos con Firefox OS, ¡hay una serie de recursos de la comunidad que te pueden ayudar!

- -

Y no te olvides de la netiqueta...

-
-

 

diff --git a/files/es/archive/b2g_os/debugging/personalizando_el_script_b2g.sh/index.html b/files/es/archive/b2g_os/debugging/personalizando_el_script_b2g.sh/index.html deleted file mode 100644 index fb75932f44..0000000000 --- a/files/es/archive/b2g_os/debugging/personalizando_el_script_b2g.sh/index.html +++ /dev/null @@ -1,42 +0,0 @@ ---- -title: Personalizando el script b2g.sh -slug: Archive/B2G_OS/Debugging/Personalizando_el_script_b2g.sh -translation_of: Archive/B2G_OS/Developing_Firefox_OS/Customizing_the_b2g.sh_script ---- -

-

Borrador
- Esta página no está completa.

- -

-

En el teléfono, la aplicación b2g (que provee las APIs de Firefox OS entre otras cosas) se inicia a través del script /system/bin/b2g.sh. Se puede personalizar este script para cambiar el comportamiento de Firefox OS.

-

Establecer variables de entorno

-

Si desea establecer una variable de entorno para una ejecución simple de B2G, puede hacer lo siguiente:

-
adb shell stop b2g
-abd shell "export ENV_VAR=value && /system/bin/b2g.sh"
-
-

Si desea usar las mismas variables de entorno todo el tiempo, puede editar b2g.sh, como se describe en la siguiente sección.

-

Editando b2g.sh

-

Para depurar, usted puede desear establecer variables de entorno para conseguir inormación de registro o de otra manera afectar como se ejecuta el programa b2g. Puede hacer esto editando el script b2g.sh. No hay herramientas incluídas en el teléfono para editar este archivo en su lugar, así que necesitará copiarlo primero.

-

Connect the phone to your computer, open a terminal window, and execute the following command to edit the script:

-
adb pull /system/bin/b2g.sh
-

Edite el script para hacer todos los cambios que desee. Por ejemplo, supongamos que desea ver alguna salida de los registros (lo que require una compliación de depuración), debería agregar algo como:

-
export NSPR_LOG_FILE=/data/local/tmp/mylog.txt
-export NSPR_LOG_MODULES=Layers:5
-
-

Y luego hacer lo siguiente para subir el script b2g.sh al teléfono:

-
adb shell stop b2g
-adb remount
-adb push b2g.sh /system/bin
-adb shell chmod 0755 /system/bin/b2g.sh
-adb shell start b2g
-
-
-

Nota: /data/local/tmp es el único lugar del sistema de archivos en el que pueden escribir los procesos de contenido.

-
-

Véase también

- -

 

diff --git a/files/es/archive/b2g_os/debugging/setting_up/index.html b/files/es/archive/b2g_os/debugging/setting_up/index.html deleted file mode 100644 index c223edb982..0000000000 --- a/files/es/archive/b2g_os/debugging/setting_up/index.html +++ /dev/null @@ -1,37 +0,0 @@ ---- -title: Setting up to debug Firefox OS using Firefox developer tools -slug: Archive/B2G_OS/Debugging/Setting_up -translation_of: Archive/B2G_OS/Debugging/Setting_up ---- -
-

Firefox OS supports the same remote debugging protocol that Firefox mobile supports on Android. This means you can use the Firefox development tools to debug Gaia applications running on a Firefox OS device or emulator. In order to debug Firefox OS running on your device or on the Firefox OS Simulator, you need to use Firefox 18 or later; in addition, there are settings that need to be changed both in your desktop browser's configuration and on your Firefox OS device or simulator.

-
-
-

Note: If you want to debug apps on a Firefox OS device, and you are running Firefox 1.2+, your best option is to use the App Manager instead.

-
-

Firefox desktop

-

You need to be sure you have a build of Firefox 18 or later in order to have remote debugging support. If you don't already have a recent copy of Firefox, download the latest Nightly build to get access to all the latest features.

-

Once you're running an appropriate version of Firefox on your computer, type about:config in the URL bar and change the value of devtools.debugger.remote-enabled to true. Then you'll need to restart Firefox to get remote debugging enabled. After restarting Firefox, the Web Developer menu will have a new option, Tools > Connect...

-

Enabling debugging

-

When using the Firefox OS Simulator (or B2G Desktop), setting up for debugging is pretty easy. You don't need to do any port forwarding like you do when debugging on a physical device. Simply open your device's Developer settings and enable Remote Debugging.

-
-

Note: This no longer works on Firefox OS devices as of January 10, 2013. As of this date device builds of Firefox OS have debugging disabled. There will eventually be a way to build your own build with it re-enabled, but this doesn't exist yet. This document will be updated once that happens. In addition, the preference for turning off out-of-process support has been removed. For now, you'll need to do your debugging in the Firefox OS Simulator.

-
-

If using a real Firefox OS device, open the Developer settings and:

- -
-

Note: If you flash your device, you'll need to redo these configuration changes.

-
-

Now you're ready to use the debugger!

-

Enabling console logging on a Firefox OS device

-

On production builds of Firefox OS, console logging (for example console.log()) is disabled by default. In order to enable it, go to your device's Developer settings and enable Console Enabled.

-

Note: read On-device console logging for more details about how to use console logging on Firefox OS.

-

See also

- diff --git a/files/es/archive/b2g_os/developing_gaia/entendiendo_el_codigo_base_de_gaia/index.html b/files/es/archive/b2g_os/developing_gaia/entendiendo_el_codigo_base_de_gaia/index.html deleted file mode 100644 index 6c1ea3499d..0000000000 --- a/files/es/archive/b2g_os/developing_gaia/entendiendo_el_codigo_base_de_gaia/index.html +++ /dev/null @@ -1,104 +0,0 @@ ---- -title: Entendiendo el código base de Gaia -slug: Archive/B2G_OS/Developing_Gaia/Entendiendo_el_codigo_base_de_Gaia -translation_of: Archive/B2G_OS/Developing_Gaia/Understanding_the_Gaia_codebase ---- -
-

Before you start to make your own changes to the Gaia codebase, you should understand the basics of how it is all structured, and what coding conventions are used. This article covers both of these points.

-
-

Gaia branches

-

There are many different branches in the Gaia codebase, and depending on what work you are doing (or what device you have) you might not just want to download, hack and make the master branch. Here is a brief guide to the most common repos you'll likely be interested in:

- -

Gaia codebase structure

-

The following section outlines all the most important parts of the Gaia codebase.

-

apps/

-

This directory contains all of the main Gaia apps, both apps shown in the homescreen — such as calendar and camera — and underlying apps — such as system, homescreen, and keyboard.
-
- The apps work in slightly different ways, but all have a number of common features, including:

- -
-

Note: You can find more information about the apps actually work on our Gaia apps guide.

-
-

build/

-

This directory contains build scripts.

-

dev_apps/

-

This directory contains other apps that are included by customization. For example you could include custom apps that you want to include in custom builds in here.

-
-

Note: For more information about Gaia customization, read our Market customizations guide.

-
-

keyboard/

-

The keyboard directory contains keyboard dictionaries and layouts for different languages.

-

locales/

-

This directory contains a JSON file, languages_all.json, which defines what languages are supported on Gaia. For more insight into how apps are localized, read Getting started with app localization.

-

shared/

-

This directory contains a number of resources that multiple apps make use of; the most notable parts of these are:

- -

tools/

-

The tools directory contains tools for build scripts and tests.

-

Gaia coding style

-

Gaia follows the Google JavaScript coding style.

-

Background information:

- -

Specific rules

-
    -
  1. Make sure HTML files are declared with <!DOCTYPE html> (that is, as HTML5 documents). If you don't, Internet Explorer 9 and later will load them in compatibility mode.
    2. -
  2. Include the "use strict"; statement (just like that, including the quotes) to the top of your JavaScript files to put them into strict mode.
    3. -
  3. Always use two spaces for indentation, rather than tabs.
    4. -
  4. Please use line breaks to separate logical bits of code!
    5. -
  5. Multi-word file names should use the "underscore" character to separate words, like_this.js.
    6. -
  6. Use single quotes instead of double quotes for strings.
    7. -
  7. Use expanded conditional structures: - 
    Bad
-if (expression) doSomething();
-
-Correct
-if (expression) {
-  doSomething();
-}
    -
    8. -
  8. If you're working on the System app, check out the guidance listed here.
    9. -
-

Per commit coding style check

-

Gaia uses jshint to automatically check JS coding styles before each commit (via a git pre-commit hook). Once you submit a Pull Request to the Gaia repository, the Travis (Github Continuous Integration) server will run this linter to double check all styles are right.

-

The precommit hook script is in gaia/tools/pre-commit and will be copied to project's .git/hooks folder once a make command is executed.

-
-

Note: We used to use gjslint to check coding styles, but we have since deprecated its use as jshint is stricter and produces better results. We’ve been using JSHint since Firefox OS 1.4, and gjslint is now only recommended for legacy files that have not yet been moved to JSHint.

-
-

Running linting checks manually via Gaia

-

Before submitting a patch we recommend you run JSHint on it manually to check for any style errors.
-
- You should look in the gaia/build/jshint directory for more details about jshint in Gaia; Gaia provides the build script for you. You can run:

-
$ make lint
-

to automatically run both the gjslint and jshint style checks. Or you can run

-
$ make hint
-

to just run the jshint style check.

-
-

Note: If you want to install jshint yourself, without using Gaia, you can use the following:

- 
npm install jshint -g
-jshint myfile.js
-
-
-

 

diff --git a/files/es/archive/b2g_os/developing_gaia/index.html b/files/es/archive/b2g_os/developing_gaia/index.html deleted file mode 100644 index 93fce20871..0000000000 --- a/files/es/archive/b2g_os/developing_gaia/index.html +++ /dev/null @@ -1,61 +0,0 @@ ---- -title: Desarrollando Gaia -slug: Archive/B2G_OS/Developing_Gaia -tags: - - Construir - - Firefox OS - - Gaia - - Mozilla -translation_of: Archive/B2G_OS/Developing_Gaia ---- -
-

Gaia es la interfaz de usuario de Firefox OS y el conjunto de aplicaciones por defecto: Incluye la pantalla de bloqueo, la pantalla de inicio, marcadores, y otras aplicaciones. Esencialmente, Gaia es un conjunto de aplicaciones web complejas que se ejecutan en la capa superior de la plataforma Firefox OS. Este conjunto de articulos cubre todo lo que necesita saber para contribuir con el proyecto Gaia.

-
-

En esta guía te llevaremos a un proceso de trabajo eficaz para contribuir con Gaia — y por eso queremos decir la adición de características al codigo base de  Gaia y trabajando en errores presentes en el proyecto Gaia. El primer grupo de articulos se puden trabajar en orden, o se puede saltar a la sección que necesita para recordar un aspecto específico de el proceso.

-

Después de eso, se proporcionan materiales de referencia e información de temas adicionales.

-

-

Lo básico

-
    -
  1. Ejecutar el codigo base de Gaia
    2. -
  2. Entender el código base de Gaia
    3. -
  3. Hacer cambios en el código de Gaia
    4. -
  4. Probando los cambios en el código de Gaia
    5. -
  5. Enviar los cambios de Gaia
    6. -
-

Referencia contrucción de Gaia

- -

Ver también

- -

 

-

- -
-

Join the Gaia community

-
-
Choose your preferred method for joining the discussion:
- -
-
- -
-
-

diff --git a/files/es/archive/b2g_os/developing_gaia/running_the_gaia_codebase/index.html b/files/es/archive/b2g_os/developing_gaia/running_the_gaia_codebase/index.html deleted file mode 100644 index 334a44b435..0000000000 --- a/files/es/archive/b2g_os/developing_gaia/running_the_gaia_codebase/index.html +++ /dev/null @@ -1,47 +0,0 @@ ---- -title: Ejecutar el codigo base de Gaia -slug: Archive/B2G_OS/Developing_Gaia/Running_the_Gaia_codebase -tags: - - Gaia -translation_of: Archive/B2G_OS/Developing_Gaia/Running_the_Gaia_codebase ---- -
-

Este artículo se muestra en detalle cómo ejecutar el código base de Gaia, y qué herramienta están disponibles en esta configuración.

-
-

Para empezar, debemos señalar que NO tiene que compilar Gecko, o B2G, para contribuir con Gaia. Sólo tienes que descargar el código fuente de Gaia y tendrás la capacidad de ejecutarlo y editarlo.
-
- Hay diferentes formas de ejecutar Gaia:

- -

Puedes encontrar información concisa de como ejecutar Gaia de estas diferentes maneras desde esta página, junto con enlaces e información detallada. En general, estos se ordenan de lo más complejo (experiencia más realista), a lo más fácil (experiencia menos realista).

-

En este artículo vamos a concentrarnos en el funcionamiento de Gaia dentro de Firefox Mulet o en el WebIDE — para la mayoría de los cambios que hagas en el código base de Gaia, este mecanismo ofrece la forma más rapida de probar los cambios, pero obviamente hay algunas características (tales como probar las API del dispositivo o la interaccíon con el hardware del teléfono) no estarán disponibles, ya que necesitara un dispositivo real.

-
-

Nota: Para obtener más ayuda con Gaia, los mejores lugares son el canal #gaia (ver Mozilla IRC para más información) y la lista de correo dev-gaia.

-
-

Ejecutar tu construcción de Gaia

-
    -
  1. Primero, hacer una bifurcación (fork) de el Repositorio de Gaia en Github.
    2. -
  2. Después, clona tu bifurcación localmente: - 
    git clone https://github.com/your-username/gaia.git
    -
    3. -
  3. Agrega tu producción (upstream) como esto: - 
    cd gaia
-git remote add upstream https://github.com/mozilla-b2g/gaia
    -
    4. -
  4. Now you need to create a Gaia profile. Running make inside your repo folder creates a profile in the profile directory, which is setup for optimal debugging. It creates unpackaged (hosted versions) of the Gaia apps that can be served directly via the local HTTPD server bundled along with Firefox desktop as an extension. When you make a change you just need to refresh your browser window to see the result (as you'll see later), rather than having to rebuild the profile, repush it to the device, etc. This is really good for rapid CSS/JS/HTML hacking.
    5. -
  5. With your debug profile built, run it in Mulet or WebIDE, using the linked instructions.
    6. -
-

Troobleshooting and known issues

-

Error: Python executable "python3" is v3.x, which is not supported by gyp.

-

On some Linux distributions (eg: Archlinux), the default python is python3. This makes npm fail when running some commands (eg. when running tests). To fix it once and for all, you can run the following command:

-
npm config set python python2
-

You can look at this Stack Overflow page for other solutions.

-

Then you should delete your node_modules directory and run the failed command again.

-

Please Install NodeJS -- (use aptitude on linux or homebrew on osx)

-

So, you get this error although you think you installed it. Chances are you're running Debian or another Debian-based distribution like Ubuntu. On these distributions, NodeJS is contained in the nodejs package, and you can install the nodejs-legacy package to set up everything correctly:

-
sudo aptitude install nodejs-legacy
-

If you have issues installing this package, maybe you're using Chris Lea's PPA for Node; please remove it before moving forward.

diff --git a/files/es/archive/b2g_os/elegir_como_ejecutar_gaia_o_b2g/index.html b/files/es/archive/b2g_os/elegir_como_ejecutar_gaia_o_b2g/index.html deleted file mode 100644 index 3a741cb101..0000000000 --- a/files/es/archive/b2g_os/elegir_como_ejecutar_gaia_o_b2g/index.html +++ /dev/null @@ -1,61 +0,0 @@ ---- -title: Elegir cómo ejecutar Gaia o B2G -slug: Archive/B2G_OS/Elegir_como_ejecutar_Gaia_o_B2G -tags: - - B2G - - Firefox OS -translation_of: Archive/B2G_OS/Choosing_how_to_run_Gaia_or_B2G ---- -

-

Dependiendo de tus necesidades, tienes varias opciones a considerar cuando experimentes con Firefox OS o la interfaz gráfica Gaia. Puedes elegir entre las opciones que te presentamos en esta página; cada opción tiene ventajas y desventajas a tener en cuenta, y algunas opciones son más flexibles que otras.

-

Ejecutar B2G en un equipo

-

Es posible compilar un simulador de Firefox OS y ejecutar Gaia en él. Este programa está basado en Firefox pero se comporta de forma muy parecida a Firefox OS en un móvil. Actualmente, Mozilla proporciona versiones diarias de esta aplicación para desarrolladores. Si estás familiarizado con cómo compilar el código fuente de Firefox u otros proyectos en C++, puedes compilar la aplicación tú mismo siguiendo estas instrucciones.

-

Ventajas

- -

Desventajas

- -

Razones para utilizar el simulador B2G

-

El simulador es una sólida solución intermedia para desarollo y testeo. Es una buena manera de obtener una referencia de cómo tu aplicación o cualquier otro código funciona en un entorno similar a un móvil, sin tener que flashear un teléfono cada vez que quieras probar algo.

-
- Atención: Antes de distribuir una aplicación, debes testearla primero en teléfonos de verdad.
-

Variantes del simulador

-

Hay diferentes variantes del simulador de Firefox OS:

-
-
- Add-on
-
- Esta extensión en la herramienta fundamental para testear apps en Firefox OS, y es la solución recomendada para la mayoría de usuarios. Es compatible con las herramientas para desarrolladores, agregar aplicaciones al entorno de testeo, etcétera.
-
- Versiones "desktop" para desarrolladores
-
- Estas versiones del simulador son aplicaciones independientes creadas para ayudar al equipo de desarrolladores de Firefox OS a verificar características técnicas.
-
- Versiones "desktop" para traductores
-
- Las versiones para traductores son útiles para los equipos de localización, que las usan en su trabajo y para probar las traducciones de Firefox OS y sus aplicaciones.
-
-

Ejecutar B2G en un dispositivo móvil

-

La forma más completa de probar tu código para B2G o Gaia, o tu aplicación web, es compilar e instalar Firefox OS en un dispositivo móvil de verdad. Ésta es también la forma más compleja.

-

Ventajas

- -

Desventajas

- -

Razones para utilizar B2G en un dispositivo móvil

-

Obviamente, ésta es la forma más realista de testear cualquier código o proyecto web en B2G o Gaia. Ejecutando en hardware real, te aseguras de que tu proyecto rinde bien, de que su presentación es correcta, y de que utiliza todos las APIs del dispositivo adecuadamente. Además, siempre debes probar tu código en hardware de verdad antes de distribuirlo; no hacerlo puede tener desafortunadas consecuencias que son difíciles de predecir.

diff --git a/files/es/archive/b2g_os/firefox_os_apps/building_blocks/index.html b/files/es/archive/b2g_os/firefox_os_apps/building_blocks/index.html deleted file mode 100644 index e3d6ceee63..0000000000 --- a/files/es/archive/b2g_os/firefox_os_apps/building_blocks/index.html +++ /dev/null @@ -1,195 +0,0 @@ ---- -title: Firefox OS Building Blocks -slug: Archive/B2G_OS/Firefox_OS_apps/Building_blocks -tags: - - Design - - Design patterns - - Firefox OS - - NeedsTranslation - - TopicStub - - UI - - building blocks -translation_of: Archive/B2G_OS/Firefox_OS_apps/Building_blocks ---- -

- -
-

The Firefox OS Building Blocks are reusable UI components (also called 'common controls') that reflect OS-wide design patterns. Building Blocks are used to create the interfaces of all Gaia default apps. You are free to make use of these components in your own Firefox OS apps, or general Web apps.

-
- -

Using the Firefox OS Building Blocks

- -

The code for the Firefox OS Building Blocks can be found in the Gaia Github repo under shared/style. Here, you can find a CSS file that contains the CSS for that particular Building Block, and a sub directory containing the HTML fragments and image assets. If you are creating your own standalone Web app, you can simply copy the CSS, HTML and image asset files across into your own project; if your app is intended to be installed on Firefox OS only (or you want to use these features only when the app is being used on Firefox OS), then you can link to the versions available inside Gaia.

- -

The pages for the individual Building Block implementations can be found under the pages for each building block — see next section. These contain instructions on how to implement each one.

- -
-

Note: The version 2.0 building block code is used in Firefox OS releases 2.0 through 2.2. Version 2.3 sees an update, with the building blocks being reimplemented using Web components — these provide the same functionality, but implemented in a much more powerful, flexible way. You'll see 2.3 pages appear underneath the main building block pages covering these Web components as soon as the information is available.

-
- -
-

Note: We also have an old guide covering the v1.x building blocks used in older versions of Firefox OS. This is mainly for legacy information.

-
- -

Web components preliminary setup

- -

This section details the preliminary setup needed to use Gaia Web components.

- -

Web components browser support

- -

To use Gaia Web components at all, you need to run them using a browser that supports Web components. The state of support is as follows:

- - - -

Web components are supported in Firefox OS from v2.1 onwards, although most of them weren't actually implemented until v2.3. Be aware also that currently Web components won't work for Firefox OS apps below internal (certified) level. This restriction should be lessened in the future.

- -
-

Note: If your app is certified, the components will just work. You don't need to set a specific manifest permission.

-
- -

Web components installation notes

- -

Gaia Web components are installed in your app using the Bower package manager. To install this, you first need Node.js/npm and Git installed. Once they are installed you can install Bower with

- -
npm install -g bower
- -

At this point you could also install the Gaia Fira Sans font that Firefox OS uses in your app , with the following command:

- -
bower install gaia-components/gaia-fonts
- -

You can then make use of the font by including the following in your head (along with a font-family of FiraSans):

- -
<link rel="stylesheet" type="text/css" href="bower_components/gaia-fonts/style.css"></link>
- -

Firefox OS Building Blocks

- -
-
-
-
Action menu
-
An action menu presents a list of actions, related to the app's content, from which the user may make a selection.
-
Banners
-
Banners (Status, in older versions of Firefox OS) provide information to the user in a transitory fashion, typically to confirm an action or to alert the user to a system event.
-
Buttons
-
Buttons are used to perform explicit actions. Buttons may be text or images.
-
Context menu
-
Accessed via a tap and hold gesture (sometimes called a long press), the Context Menu (called the Object Menu in older versions of Firefox OS) allows users to perform actions on objects without having to leave their current view.
-
Dialog
-
A Dialog (Confirm, in older versions of Firefox OS) provides the user with some important information, asks the user to take or confirm an action, or allows the user to make a choice or enter some information.
-
Drawer
-
The drawer is a scalable way for users to navigate between views or filter views. The drawer can also include links to app settings or other tools.
-
Header
-
A header is a dedicated space at the top of the screen, most often used to display the view title. It can also include navigation, action buttons and other controls.
-
Input area
-
An input area is a data entry field, and can be as simple as a text only entry field, or as complex as a multipart entry field with text entry, value selections, and buttons.
-
Layout
-
The Layout utility will help you to create common layout structures for your Firefox OS apps. Note that Layout is only available in Firefox OS 2.1 and above.
-
List items
-
List items are typically used to navigate to a new screen, or to display information or controls.
-
-
- -
-
-
Picker
-
The Picker is designed to select a group of items as attachments for messaging and email.
-
Progress and activity
-
Progress and activity indicators provide the user with visual feedback that a process (such as a resource loading) is active.
-
Scrolling
-
Scrolling areas allow the user to move text and/or images across the device's display.
-
Search
-
Search is used to filter a list or find context-specific content.
-
Slider
-
A Slider (which was called Seekbar in older Firefox OS versions) is used to select a value from a continuous or discrete range of values by dragging the handle.
-
Select mode
-
Select Mode (which was called Edit Mode in older Firefox OS versions) is designed to select and perform actions on items.
-
Subheader
-
Subheaders are used to describe a subsection of content.
-
Switches
-
Switches (such as checkboxes, etc.) allow users to activate and deactivate items. Switches are also used to select items within a list.
-
Tab/Filter
-
A Tab/Filter gives the user a way to easily switch between views or to filter a set of data.
-
Toolbars
-
Toolbars contain actions, indicators and navigation elements associated with the current view.
-
Value selector
-
Value Selectors let the user choose from among a list of possible values.
-
-
-
- -
-

Note: For a detailed guide to the design pattern followed by the building blocks when the Arabic locale (bidirectional) is selected, read Firefox OS in Arabic.

-
- -

Cross browser CSS

- -

Arnau March wrote a CSS file called cross browser CSS, containing rules to allow Firefox 2.0 building blocks to render properly across different browsers (ie 9, Firefox 18, Chrome 24, Safari 5.1.) If you want to write hosted apps that look ok across different browsers, include this CSS in your project.

- -

Browse Firefox OS Building Block implementations by version

- -

The pages below list links to pages covering the Firefox OS Building Block implementations as they appear in different versions of Firefox OS.

- - diff --git a/files/es/archive/b2g_os/firefox_os_apps/index.html b/files/es/archive/b2g_os/firefox_os_apps/index.html deleted file mode 100644 index 370236dd14..0000000000 --- a/files/es/archive/b2g_os/firefox_os_apps/index.html +++ /dev/null @@ -1,85 +0,0 @@ ---- -title: Firefox OS apps -slug: Archive/B2G_OS/Firefox_OS_apps -tags: - - Apps - - Building - - Components - - Firefox OS - - Installing - - NeedsTranslation - - TopicStub - - device APIs -translation_of: Archive/B2G_OS/Firefox_OS_apps ---- -

This section of the Firefox OS docs covers the specific techniques required — and available tools — for building Firefox OS apps. You'll find a number of details below, from Firefox OS building blocks/web components, to device APIs and App installation.

- -

Building Firefox OS apps

- -
-
Building apps for Firefox OS
-
Firefox OS/Firefox platform app specifics, including App installation and management APIs, manifest files, packaged and hosted apps, handling API permissions.
-
Localization
-
This set of articles provides information for developers wishing to provide localized versions of their apps.
-
Performance
-
This page lists performance-related topics specific to Firefox OS.
-
Firefox Accounts on Firefox OS
-
This article provides an overview of using Firefox Accounts in Firefox OS.
-
Reference apps
-
This page lists a number of sample apps we've put together for you to download, install, play with and learn from. Have fun!
-
Screencast series: App Basics for Firefox OS
-
In this collection of short videos, developers from Mozilla and Telenor explain in a few steps how you can get started with building applications for Firefox OS.
-
- -

Building blocks

- -
-
Building Blocks
-
The Firefox OS Building Blocks are reusable UI components (also called 'common controls') that reflect OS-wide design patterns. Building Blocks are used to create the interfaces of all Gaia default apps. You are free to make use of these components in your own Firefox OS apps, or general Web apps.
-
- -

Styleguides

- -
-
Firefox OS Visual styleguide
-
Our style guide for Firefox OS visual design, covering colours, typeface, backgrounds, app icons, and the design of specific UI elements.
-
Firefox OS Copy styleguide
-
This guide outlines the rules we follow for writing Firefox OS app copy, but can be used as a general guide to writing good copy for any app interfaces.
-
Firefox OS in Arabic
-
A guide to the specific UX design implementation Firefox OS has in place for dealing with Arabic (and other RTL languages.)
-
- -

Assets

- -
-
Firefox OS design asset library
-
In this section you'll find design assets, artwork, graphic templates, fonts and other materials that will be helpful as you design Firefox OS/Gaia apps.
-
Firefox OS icon font
-
Firefox OS has its own icon font set available: this article explains how to use it in your own apps.
-
Firefox OS transitions
-
A reference to some of the transitions used in Firefox OS to move between different states in apps, including animated GIFs demonstrating the animations used, plus code samples to show the CSS animation code needed to implement these animations.
-
- -

References

- -
-
Firefox OS device APIs
-
This article provides a list of pages covering those APIs, as well as the app manifest permissions for each one.
-
Firefox OS app tools
-
This page provides a list of useful tools, libraries, examples, etc. that are useful for Firefox OS app developers, whether you want a code template to copy, or need help with adding a specific feature to your Firefox OS app.
-
- -

Other app topics

- -
-
Porting Chrome apps to Firefox OS Apps
-
This article discusses the differences between Chrome apps and Firefox OS Apps, and how you can convert between the two.
-
App development FAQ
-
This FAQ is a compilation of answers to common app development questions.
-
- -

See also

- - diff --git a/files/es/archive/b2g_os/firefox_os_build_prerequisites/index.html b/files/es/archive/b2g_os/firefox_os_build_prerequisites/index.html deleted file mode 100644 index f21ca58901..0000000000 --- a/files/es/archive/b2g_os/firefox_os_build_prerequisites/index.html +++ /dev/null @@ -1,204 +0,0 @@ ---- -title: Prerrequisitos para compilar Firefox OS -slug: Archive/B2G_OS/Firefox_OS_build_prerequisites -translation_of: Archive/B2G_OS/B2G_OS_build_prerequisites ---- -

Antes de bajarte el código fuente para compilar Firefox OS, necesitas un sistema de compilación configurado correctamente. Ahora mismo, es posible compilar en distribuciones Linux de 64 bits, y en Mac OS X.

-

Necesitas un teléfono móvil compatible o un emulador

-

Esto es importante. Aunque hay varios teléfonos compatibles, algunos de ellos tienen variantes y es posible que sólo algunas de esas variantes sean compatibles. Además, algunos teléfonos son más compatibles que otros. Ahora mismo, puedes utilizar Firefox OS / B2G en los siguientes teléfonos y dispositivos:

-

Categoría 1

-

Dispositivos de Categoría 1 son aquellos que recomendamos para tareas de desarrollo, porque son los que primero reciben nueva funcionalidad y soluciones a problemas y errores. Los dispositivos de Categoría 1 son:

-
-
- Unagi
-
- Unagi es un teléfono que usamos como plataforma de prueba y desarrollo para smartphones simples o de mediana capacidad. Muchos de los desarrolladores del equipo de Firefox OS utilizan Unagi.
-
- Otoro
-
- Otoro es un teléfono que usamos como plataforma de prueba y desarrollo para smartphones simples o de mediana capacidad. Muchos de los desarrolladores del equipo de Firefox OS utilizan Otoro.
-
- Pandaboard
-
- Pandaboard es una mini placa base que se usa en el desarrollo de plataformas móviles. La placa está basada en la arquitectura OMAP 4.
-
- Emulator (ARM and x86)
-
- Hay dos emuladores: uno emula código ARM y el otro ejecuta en código x86.
-
- Ordenador
-
- También puedes construir una versión de Firefox OS para ordenador que ejecuta Gecko en una aplicación XULRunner y utiliza la experiencia de usuario que proporciona Gaia
-
-

La versión para ordenador y los emuladores no requieren teléfono.

-

Categoría 2

-

Los teléfonos de Categoría 2 en general funcionan, y muchos desarrolladores, especialmente desarrolladores de aplicaciones, los utilizan; pero tienden a recibir cambios y novedades más tarde.

-
-
- Samsung Nexus S
-
- Los modelos de Nexus S que sabemos funcionan son el GT-I9020A y el GT-I9023. Es posible que otros modelos también funcionen.
-
- Samsung Nexus S 4G
-
- El modelo SPH-D720 es compatible como Categoría 2.
-
-

Categoría 3

-

Se puede construir Firefox OS para estos teléfonos, pero los desarrolladores del equipo de Firefox OS no trabajan en ellos regularmente, así que su funcionamiento y funcionalidad puede que sean significativamente peores que los de Categorías 1 y 2.

-
-
- Samsung Galaxy S2
-
- El único modelo que funciona es el i9100. Ninguna de las otras variantes es oficialmente compatible. (Es posible que el i9100P también funcione, ya que la única diferencia es la adición del chip NFC).
-
- Samsung Galaxy Nexus
-
- En estos momentos no sabemos de ninguna variante que no sea compatible.
-
-
- Importante: Sólo son compatibles los teléfonos que utilizan como mínimo Android 4 (alias Ice Cream Sandwich). Si tu teléfono se menciona en esta página pero usa una versión de Android más antigua, actualízalo primero.
-

Requisitos para Linux

-

Para compilar en Linux, necesitas:

- -

Estos requisitos son más que el mínimo indispensable, pero los recomendamos porque la construcción puede fallar debido a falta de recursos.

-

Puedes utilizar otras distribuciones, pero recomendamos Ubuntu 12.04 porque es el sistema que más gente utiliza sin dar problemas. Distribuciones que quizá no funcionen: distribuciones de 32 bits y distribuciones recientes (Ubuntu 12.10, Fedora 17/18, Arch Linux debido a gcc 4.7).

-

También necesitas instalar las siguiente utilidades:

- -

Ejemplos de instalación de 64 bits:

-

Ubuntu 12.04 / Linux Mint 13 / Debian 6

-
$ sudo apt-get install autoconf2.13 bison bzip2 ccache curl flex gawk gcc g++ g++-multilib git ia32-libs lib32ncurses5-dev lib32z1-dev libgl1-mesa-dev libx11-dev make
-

Cuando compiles en Ubuntu 64 bits, es posible que necesites crear enlaces simbólicos (symlinks) a las versiones de 32 bits de libX11.so y libGL.so:

-
$ sudo ln -s /usr/lib/i386-linux-gnu/libX11.so.6 /usr/lib/i386-linux-gnu/libX11.so
-$ sudo ln -s /usr/lib/i386-linux-gnu/mesa/libGL.so.1 /usr/lib/i386-linux-gnu/libGL.so
-

Ubuntu 12.10

-
$ sudo apt-get install autoconf2.13 bison bzip2 ccache curl flex gawk gcc-4.6 g++-4.6 g++-4.6-multilib git ia32-libs lib32ncurses5-dev lib32z1-dev libgl1-mesa-dev libx11-dev make
-

Además del paso ya explicado para solucionar el problema con las versiones 32 bits de libX11.so y libGL.so, también necesitas especificar GCC 4.6 como el compilador del host por defecto antes de empezar a construir. Una vez que te hayas descargado el código, lee nuestras instrucciones al respecto.

-

Fedora 16:

-
$ sudo yum install autoconf213 bison bzip2 ccache curl flex gawk gcc-c++ git glibc-devel glibc-static libstdc++-static libX11-devel make mesa-libGL-devel ncurses-devel patch zlib-devel ncurses-devel.i686 readline-devel.i686 zlib-devel.i686 libX11-devel.i686 mesa-libGL-devel.i686 glibc-devel.i686 libstdc++.i686 libXrandr.i686
-

Arch Linux (distribución aún incompatible):

-
$ sudo pacman -S --needed alsa-lib autoconf2.13 bison ccache curl firefox flex gcc-multilib git gperf libnotify libxt libx11 mesa multilib-devel wireless_tools yasm lib32-mesa lib32-ncurses lib32-readline lib32-zlib
-

Por defecto, Arch Linux utiliza Python3. Necesitas forzar el uso del antiguo python2:

-
$ cd /usr/bin
-
-$ sudo ln -fs python2 python
-

Requisitos para Mac OS X

-

Para compilar Firefox OS con Mac OS X, necesitas instalar Xcode, que está disponible en el Mac App Store.

-

Instalar las Utilidades de Línea de Comandos (XCode 4.3.1 y versiones más recientes)

-

Xcode 4.3.1 (OS X 10.7 "Lion") y versiones más recientes como 4.4.1+ (Mac OS X10.8 "Mountain Lion") no incluyen necesariamente las Utilidades de Línea de Comandos. Cuando instales Xcode, abre las Preferencias, luego el Panel de Descargas, e instala las Utilidades de Línea de Comandos. Además, asegúrate de que tienes como mínimo 20 GB de espacio libre en el disco duro.

-

Imagen de la opción de para bajarse la Utilidades de Línea de Comandos en Xcode

-
- Atención: El emulador de Firefox OS necesita un procesador Core 2 Duo o más reciente, es decir, un sistema compatible con Mac OS X 10.7 "Lion". No tienes por qué utilizar Lion, pero tu sistema debe ser compatible con Lion. Esto es sólo para el emulador: puedes construir Firefox OS en Macs más antiguos.
-

Cómo iniciar Firefox OS en Mac

-

Abre una consola y ejecuta el comando siguiente:

-
curl -fsSL https://raw.github.com/mozilla-b2g/B2G/master/scripts/bootstrap-mac.sh | bash
-

Este comando obtiene y ejecuta un programa de inicio que se asegura de que tienes todo lo necesario para compilar el emulador. También solicitará permiso para instalar cualquier cosa que falte. El programa buscará e instalará lo siguiente:

- -
-

Xcode

-

Si ya has actualizado Xcode a la versión 4.4+ pero recibes un mensaje diciendo que Xcode necesita actualización, revisa la ruta de Xcode con este comando:

- 
xcode-select -print-path
- Si la ruta todavía apunta a /Developer puedes actualizarla haciendo: - 
sudo xcode-select -switch /Applications/Xcode.app
- Asegúrate también de que el SDK de Mac OS X 10.6 existe en: - 
/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/
-

Si no existe, tendrás que extraerlo y copiarlo del archivo DMG de Xcode 4.3, que está disponible en el Portal para desarrolladores de Apple. Puedes usar una utilidad que se llama Pacifist para extraer el SDK 10.6. Asegúrate de crear un enlace simbólico (symlink) entre el SDK y el directorio /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/

-

Mountain Lion

-
-

Si construyendo en OS X 10.8 "Mountain Lion" (Xcode 4.4.1 o más reciente) te encuentras un error como éste:

- 
external/qemu/android/skin/trackball.c:130:25: error: 'M_PI' undeclared (first use in this function)
- Edita el archivo: B2G/external/qemu/makefile.android y añade en la línea 78:
- 
MY_CFLAGS += -DM_PI=3.14159265358979323846264338327950288   #/* B2G_fix: not finding M_PI constant */
-
-
- Si usando Mountain Lion, y durante la instalación de las dependencias vía homebrew, te encuentras un error como éste:
-
-
-
- 
clang: error: unable to execute command: Segmentation fault: 11
-

... prueba a reinstalar las dependencias manualmente añadiendo la opción --use-gcc como se muestra en el ejemplo:

- 
brew install mpfr --use-gcc
-
-

Samsung Galaxy S2

-

Si tu intención es compilar para el Samsung Galaxy S2, también necesitarás instalar heimdall. Para más información, visita {{ anch("Instalación de heimdall") }}. ¡El programa de inicio no ejecuta este paso!

-
- Atención: Si has instalado la utilidad Samsung Kies, que se utiliza para administrar los contenidos de muchos teléfonos Samsung, tienes que eliminarla antes de flashear Firefox OS en el teléfono. En Windows, puedes utilizar el procedimiento estándar para remover aplicaciones; en Mac, la imagen de Kies incluye una utilidad para desinstalar Kies completamente. Flashear Firefox OS fallará si tienes Kies instalado. Si se te olvida eliminar Kies, el sistema de compilación lo detectará y te recordará que debes desinstalarlo. Ten en cuenta que la utilidad de desinstalación no elimina correctamente el directorio ~/Library/Application Support/.FUS, y deja una referencia a cierta utilidad en ese directorio en la lista de programas a ejecutar en inicio. Necesitas eleminar el directorio y la refencia manualmente.
-
- Atención: Mac OS X utiliza un sistema de archivos que ignora las mayúsculas, lo que no te permitirá construir Firefox OS en el futuro (NOTA DEL EDITOR: yo nunca he tenido problemas con esto). Te recomendamos que generes una imagen de disco "sparse" sensible a las mayúsculas y que trabajes desde ese directorio. Para construir una imagen de disco "sparse" sensible a las mayúsculas ejecuta:
-
hdiutil create -type SPARSE -fs 'Case-sensitive Journaled HFS+' -size 40g ~/firefoxos.dmg
-

Monta la imagen ejecutando:

-
open ~/firefoxos.dmg
-

Navega al directorio de la imagen montada con:

-
cd /Volumes/untitled/
-

Cómo arreglar la dependencia de libmpc si no funciona

-

gcc 4.6 fue creado con libmpc 0.9; si utilizas homebrew para actualizar paquetes, libmpc se actualiza a la versión 1.0, pero homebrew no recompila gcc 4.6 tras el cambio de versión. Por ello debes crear un enlace simbólico (symlink) para asegurarte de que todo funciona correctamente. Creas el enlace así:

-
cd /usr/local/lib/
-ln -s libmpc.3.dylib libmpc.2.dylib
-

Opcional: Instalación de HAX

-

Intel proporciona un "driver" especial que permite al emulador x86 de B2G ejecutar código nativamente en el Mac en lugar de emularlo. Si quieres utilizar esta opción, puedes bajártela e instalarla. No es obligatorio, pero puede mejorar la estabilidad y velocidad de la emulación.

-

Instalación de adb

-

El proceso de compilado necesita obtener bloques binarios de la instalación de Android en el teléfono antes de compilar B2G (a menos, claro, que estés compilando el emulador). Para ello necesitas adb, el "Android Debug Bridge".

-

Para obtenerlo, debes instalar el paquete básico del Android SDK (Android SDK starter package) para tu versión de Android. Luego, ejecuta el gestor de paquetes haciendo $SDK_HOME/tools/android, y usa la interfaz gráfica para instalar las herramientas de sistema del Android SDK (Android SDK Platform-tools).

-

adb será instalado en $SDK_HOME/platform_tools. Asegúrate de añadir este directorio a tu PATH. Para ello, añade esta línea:

-
PATH=$SDK_HOME/platform_tools:$PATH
-

a tu ~/.bashrc o equivalente, sustituyendo $SDK_HOME con el directorio del Android SDK. También es recomendable ejecutar:

-
adb pull /system <backup target dir>/system
-
-

para hacer una copia de seguridad de la partición de Android en tu teléfono. Así tendrás una copia de todos los bloques binarios para Android en caso de que quieras eliminar los archivos de B2G. Dependiendo del teléfono, también necesitas hacer copia de seguridad de los directorios /data y/o /vendor:

-
adb pull /data <backup target dir>/data
-adb pull /vendor <backup target dir>/vendor
-
-

Instalación de heimdall

-

Heimdall es una utilidad para flashear el Samsung Galaxy S2. B2G la utiliza para reemplazar los contenidos del teléfono con Firefox OS, y para flashear versiones nuevas de B2G y Gaia. Necesitas Heimdall para instalar Firefox OS sólo en el Galaxy S2; no es necesaria para ningún otro teléfono. Para otros móviles, se construye y utiliza la utilidad fastboot.

-
- Atención: Recuerda que heimdall se necesita sólo para instalar Firefox OS en el Samsung Galaxy S2.
-

Hay dos maneras de instalar heimdall:

- -

Configuración de ccache

-

El tamaño estándar de ccache es 1GB; la compilación de B2G enseguida agota esta capacidad. Puedes cambiar el tamaño de tu cache con este comando:

-
$ ccache --max-size 2GB
-

Configuración de la regla udev en tu móvil

-

Llegado a este punto, puedes obtener el código de identificación del fabricante del USB ejecutando lsusb, pero por lo general es Google (código 18d1) o Samsung (código 04e8). Por tanto, añadir la línea siguiente:

-
SUBSYSTEM=="usb", ATTR{idVendor}=="18d1", MODE="0666", GROUP="plugdev"
-

al archivo /etc/udev/rules.d/51-android.rules debería funcionar.

-

Guarda los cambios, cierra el archivo, y hazlo legible:

-
$ sudo chmod a+r /etc/udev/rules.d/51-android.rules
-
-

Configurar el teléfono

-

Antes de conectar tu teléfono al puerto USB, pon el USB en modo desarrollo, lo que te permitirá acceder al teléfono para depurar y flashear. Para ello, abre la aplicación de Ajustes, accede a la sección de Aplicaciones > Desarrollo, y selecciona la opción "Depuración USB".

-

Siguiente paso

-

Llegado a este punto, ¡ya estás listo para bajarte el código de Firefox OS!

diff --git a/files/es/archive/b2g_os/gaia_hacking_guide/index.html b/files/es/archive/b2g_os/gaia_hacking_guide/index.html deleted file mode 100644 index 8d4ba30890..0000000000 --- a/files/es/archive/b2g_os/gaia_hacking_guide/index.html +++ /dev/null @@ -1,6 +0,0 @@ ---- -title: Guía para hackear Gaia -slug: Archive/B2G_OS/Gaia_hacking_guide -translation_of: Archive/B2G_OS/Developing_Gaia ---- -

La guía para hackear Gaia aún no ha sido escrita. Sin embargo,  puedes hacer referencia a este artículo en el wiki de Mozilla, por el momento.

diff --git a/files/es/archive/b2g_os/gonk/index.html b/files/es/archive/b2g_os/gonk/index.html deleted file mode 100644 index e524f46f74..0000000000 --- a/files/es/archive/b2g_os/gonk/index.html +++ /dev/null @@ -1,23 +0,0 @@ ---- -title: Gonk -slug: Archive/B2G_OS/Gonk -translation_of: Archive/B2G_OS/Platform/Gonk ---- -

-

Borrador
- Esta página no está completa.

- -

-
-

Gonk es un sistema operativo de bajo nivel de la plataforma Firefox OS que consiste de un kernel Linux basado sobre el Android Open Source Project (AOSP) y una capa de abstracción de hardware (HAL). Este artículo intenta explicar qué constituye Gonk; para obtener más información sobre la arquitectura general del Firefox OS y cómo Gonk encuadra en ella, lea nuestra guía sobre la Arquitectura de Firefox OS.

-
-

Panorama de Gonk

-

En el código fuente de Gecko hay una carpeta b2g\ que contiene el Gonk Port, el cual habilita las capacidades del hardware móvil para la Web. Consiste de un núcleo, o kernel, Linux, HAL y otras librerías OEM específicas. Varias librerías Gonk son proyectos de código abierto comunes: libusb, bluez, etcétera. Algunas de las otras partes de la HAL están compartidas con el Proyecto Android: GPS, cámara y otros.

-

Gonk es una capa de adaptación (port) de dispositivos: un adaptador entre el hardware y Gecko. Gonk es una distribución de Linux bastante sencilla que puede ser tratada como un adaptador Gecko empardado con capas de adaptación Gecko —entonces Gonk es un objetivo para adaptar Gecko a Firefox OS así como también hay adaptadores de Gecko para OS X, Windows y Android.

-
-

Nota: debido a que diferentes dispositivos móviles pueden tener diferentes chips y otras especificaciones de hardware, los dispositivos pueden tener diferentes distribuciones de Gonk.

-
-

Como el Proyecto Firefox OS goza de control total sobre Gonk, podemos exponer interfaces a Gecko que no podrían ser expuestas en otros sistemas operativos. Por ejemplo, Gecko posee a través de Gonk acceso directo al conjunto completo de telefonía y al buffer de pantalla.

-

Código fuente de Gonk

-

El repositorio B2g en Github contiene soporte oficial para todas las adaptaciones de Gonk para una variedad de dispositivos, así que puede tratarlo como un repositorio de Gonk. La lista de dispositivos soportados está en B2g/config.sh.

-

La mayor parte del trabajo diario realizado en Gonk implica adaptar el sistema a diferentes placas y asegurarse de que Gecko responda bien a los diferentes dispositivos.

diff --git a/files/es/archive/b2g_os/index.html b/files/es/archive/b2g_os/index.html deleted file mode 100644 index 05e4a3fabb..0000000000 --- a/files/es/archive/b2g_os/index.html +++ /dev/null @@ -1,94 +0,0 @@ ---- -title: B2G OS -slug: Archive/B2G_OS -tags: - - B2G - - B2G OS - - Basic - - Empezando con B2G OS - - Gaia - - Gecko - - Gonk - - Mozilla - - Overview - - Principiante - - SO web Gecko - - SO web basado en Mozilla - - b2g smartphone os -translation_of: Archive/B2G_OS ---- -
B2G OS es un sistema operativo completo e independiente para un internet abierto. Es un proyecto de código abierto desarrollado por la comunidad de Mozilla, y conforma la base de los productos para Firefox OS.
- -

B2G OS es un sistema operativo de código abierto mantenido por la comunidad, para teléfonos inteligentes, tabletas, televisiones inteligentes, y otros dispositivos conectados. El proyecto se comenzó en 2011, y está basado en el kernel de Linux y en el motor de renderizado Gecko. Toda la interfaz de usuario está hecha con tecnologías web (HTML, CSS y JavaScript), y se puede utilizar para lanzar y utilizar aplicaciones web. Desde que Mozilla discontinuó su programa comercial de Firefox OS para teléfonos inteligentes, la parte de teléfonos del proyecto es mantenida enteramente por la comunidad de voluntarios de Mozilla, y se ha renombrado a B2G OS.

- -

- -
-

Nota: Se ha realizado una Llamada a contribuir y una Llamada para la adopción de Apps para reunir a más gente, ¡siéntete libre de compartirlo!

-
- -
-
-

Cómo puedes ayudar

- -
    -
  • Reporta y soluciona bugs (el bug principal es el bug 1252143).
    • -
  • Ayúdanos a solucionar pruebas fallidas.
    • -
  • Migra a gaia una app de teléfono: -
      -
    1. Conviértela en una aplicación web (ó)
      2. -
    2. Conviértela en chrome:// (por qué?) y repórtalo
      3. -
    -
    • -
  • Porta B2G OS a tu teléfono, o ayúdanos a mantener una portabilidad.
    • -
  • Ayuda a mejorar y traducir esta documentación y la wiki.
    • -
  • Propón e implementa nuevas funcionalidades para teléfonos inteligentes.
    • -
-
- -
-

Involúcrate

- - - -

Para participar en reuniones y en los Grupos de Trabajo de la comunidad, regístrate en este Calendario. Se anuncia en Discourse, donde puedes encontrar información sobre cómo asistir y notas.

-
- -
-

Dispositivos compatibles

- - - -

Para más información visita esta página.
- Flashea tu dispositivo fácilmente con B2G installer.
- ¿Tu dispositivo no está en la lista? Prueba Mulet para escritorio.

- -

*TEP = Trabajo En Progreso.

-
-
- -

-

-

Nota: Se han movido algunas páginas a los Archivos de MDN — Haznos saber si tienes problemas para encontrar algo o si hay algo en los archivos que crees que debería regresar a esta sección.

-
-

diff --git a/files/es/archive/b2g_os/installing_on_a_mobile_device/index.html b/files/es/archive/b2g_os/installing_on_a_mobile_device/index.html deleted file mode 100644 index 690ea49147..0000000000 --- a/files/es/archive/b2g_os/installing_on_a_mobile_device/index.html +++ /dev/null @@ -1,79 +0,0 @@ ---- -title: Instalar Firefox OS en un dispositivo móvil -slug: Archive/B2G_OS/Installing_on_a_mobile_device -tags: - - Firefox OS - - Flashear - - Galaxy S2 - - i9100 -translation_of: Archive/B2G_OS/Installing_on_a_mobile_device ---- -

-

Una vez que se ha construido Boot to Gecko para un dispositivo móvil compatible, puede instalarlo. Este artículo le guiará a través del proceso.

-
- Nota: La primera vez que flashea su teléfono, deberá tener Android 4 (Ice Cream Sandwich) instalado. De lo contrario el proceso no funcionará correctamente. Una vez que usted ha hecho su primera instalación de B2G, sin embargo, sólo tiene que actualizar en la parte superior de la misma.
-

Instalando ADB

-

En OSX:

-

Si tienes homebrew en OSX:

-
brew install android-platform-tools
-
-

De lo contrario descargue las Herramientas para Desarrolladores Android y agrega los binarios a tu PATH.

-

En Ubuntu:

-
sudo apt-get install android-tools-adb
-

Flasheando su telefono

-

Para actualizar todo a su teléfono, sólo tiene que conectar el teléfono y el tipear:

-
./flash.sh
-
-

Eso es todo. El B2G que tienes actualmente en construcción flasheara el dispositivo.

-

Configuración de la regla de udev para su dispositivo

-

En Linux, si obtine,

-
< waiting for device >
-

probablemente significa que usted no ha añadido una regla udev para el dispositivo fastboot, que no es el mismo que el de adb. Usted puede obtener el ID de proveedor USB al ejecutar lsusb ahora, pero por lo general es de Google: 18d1, por lo que añadir esta línea en el archivo / etc/udev/rules.d/51-android.rules funcionaría:

-
SUBSYSTEM=="usb", ATTR{idVendor}=="18d1", MODE="0666", GROUP="plugdev"
-
- Nota: Si usted recibe un error libusb muy útil "-3" en Linux, esto significa que usted tiene que ser root para tener el acceso necesario para el dispositivo USB. Ejecute el script de nuevo usando sudo.
-
- Nota 2: Si tienes un un teléfono Keon Geeksphone o Unagi, necesita dos líneas como esta - una para la identificación del proveedor original del teléfono y otra para la de Google.
-

Notas especiales para el Samsung Galaxy S2

-

Si el teléfono es un Galaxy S2 y utiliza Heimdall 1.3.2 (la versión más reciente, use heimdall version para comprobar), es posible que vea un error alarmante "FACTORYFS upload failed!" seguido de "Heimdall flashing failed" y alguna información adicional. Esto es realmente una condición de finalización satisfactoria, y se puede hacer caso omiso de los consejos.

-
-  
-
- Para deshacerse de este extraño comportamiento, tomar una copia de origen de Heimdall, degradar a la versión 1.3.1 ("git checkout fbbed42c1e5719cc7a4dceeba098981f19f37c06"), luego compilarlo según el README, a continuación, instalarlo para que el error desaparezca. Sin embargo, esto no es estrictamente necesario.
-
-  
-
- Todas las versiones de Heimdall son incapaces de flashear una system.img mayor que 100 MB. hacer:
-
ls -l ./out/target/product/galaxys2/system.img
-
-

para ver qué tan grande es el suyo. Si es demasiado grande, pregunte en el IRC para aconsejarlo; hay maneras de hacerlo en dos etapas.

-

Paso añadido para el Samsung Galaxy S2

-

Si está flasheando el Galaxy S2, hay un paso adicional a seguir. Gaia no consigue flashear automáticamente por el script flash.sh, necesitará hacer también:

-
./flash.sh gaia
-
-

Flasheando particiones específicas para teléfonos fastboot

-

Usted puede flashear particiones específicas para teléfonos fastboot (es decir, cualquier teléfono que no sea el Samsung Galaxy S2). Por ejemplo:

-
./flash.sh system
-./flash.sh boot
-./flash.sh user
-
-

Actualización de módulos específicos

-

Puede actualizar los componentes específicos de B2G especificando sus nombres cuando flashea. Por ejemplo:

-
./flash.sh gaia
-./flash.sh gecko
-
-

Para actualizar sólo una aplicación puede utilizar la variable de entorno BUILD_APP_NAME:

-
BUILD_APP_NAME=calendar ./flash.sh gaia
-

Próximos pasos

-

En este punto, el teléfono debe estar ejecutando Boot to Gecko! Es hora de experimentar, escribir algo de código, prueba, o hacer algo de depuración!

-
- Note: Un consejo útil de uso: si su estructura de B2G se inicia con la pantalla de bloqueo solicitar un código de acceso para desbloquear el teléfono, el código por defecto es 0000.
-

Solución de problemas

-

Aquí hay algunos consejos sobre qué hacer si el dispositivo no funciona correctamente después de instalar B2G, o actualizar a una nueva versión

-

Si la interfaz de usuario no se inicia

-

Si actualizas el teléfono y la interfaz de usuario no inicia, puede restablecerla para limpiar configuración fuera de fecha y similares. Esto puede traer de vuelta a la vida. He aquí cómo:

-
cd gaia
-make reset-gaia
-
-

"la imagen es demasiado grande" mensaje de error en la ejecución ./flash.sh

-

Podría significar que el teléfono necesita ser arraigada primero antes de flashear ella. Como b2g tiene que ser escrito en la partición root, el teléfono debe estar enraizado con el fin de instalarlo.

diff --git a/files/es/archive/b2g_os/introduction/index.html b/files/es/archive/b2g_os/introduction/index.html deleted file mode 100644 index 76ac08d8c4..0000000000 --- a/files/es/archive/b2g_os/introduction/index.html +++ /dev/null @@ -1,27 +0,0 @@ ---- -title: Introducción a Firefox OS -slug: Archive/B2G_OS/Introduction -translation_of: Archive/B2G_OS/Introduction ---- -

Firefox OS (también llamado por su nombre clave "Boot to Gecko" o "B2G") es el sistema operativo de código abierto de Mozilla basado en Linux y la tecnología Gecko de Mozilla. La idea es esencialmente tener todo el software accesible al usuario ejecutándose en el teléfono siendo una aplicación web que use técnicas avanzadas de HTML5 y APIs de dispositivos para acceder al hardware del teléfono directamente vía JavaScript.

-

Para los desarrolladores web, la parte más importante a entender es que la interfaz de usuario completa es una aplicación web, que es capaz de mostrar e iniciar otras aplicaciones web. Cualquier modificación que haga a la interfaz de usuario y cualquier aplicación que crees para ejecutarse en Firefox OS son páginas web, aunque con acceso mejorado al hardware del dispositivo móvil y sus servicios.

-

Puede aprender cómo construir e instalar Firefox OS siguiendo nuestra guía práctica.

-

Tips de uso

-

Esta sección proporciona algunos consejos que realmente le ayudarán a usar Firefox OS. Esto es algo así como un marcador de posición hasta que tengamos real documentación de uso.

-

Desbloqueando el teléfono

-

Si tu versión de Firefox OS inicia preguntando por una clave para desbloquear el dispositivo, el código por defecto es 0000. Algunas versiones harán eso mientras desarrollamos y probamos la pantalla de bloqueo.

-

Capturando una pantalla

-

Actualmente no hay soporte en el dispositivo para capturar pantalla. Sin embargo, puede hacer desde la terminal en la computadora Linux o Mac OS X que tenga un sistema de construcción de Firefox OS instalado.

-
    -
  1. Asegúrese que tiene ffmpeg instalado. -
      -
    1. En Mac, si usa MacPorts, puede hacerlo con sudo port install ffmpeg. Para homebrew, haga brew install ffmpeg.
      2. -
    2. En Linux (Ubuntu/Debian), utilice sudo apt-get install ffmpeg.
      3. -
    -
    2. -
  2. Conecte su teléfono a la computadora usando un cable USB.
    3. -
  3. Navegue en su teléfono a cualquier situación donde desea obtener la captura de pantalla.
    4. -
  4. cd hacia el directorio B2G/gaia
    5. -
  5. make screenshot
    6. -
  6. Ahora puede tener una captura de pantalla llamada screenshot.png.
    7. -
diff --git a/files/es/archive/b2g_os/phone_guide/fairphone/index.html b/files/es/archive/b2g_os/phone_guide/fairphone/index.html deleted file mode 100644 index 9f09a19917..0000000000 --- a/files/es/archive/b2g_os/phone_guide/fairphone/index.html +++ /dev/null @@ -1,186 +0,0 @@ ---- -title: Fairphone -slug: Archive/B2G_OS/Phone_guide/Fairphone -tags: - - B2G - - Celular - - Comercio justo - - Dispositivo - - Fairphone - - Firefox OS - - Gaia - - Guía -translation_of: Archive/B2G_OS/Phone_guide/Fairphone ---- -
-

Advertencia: Este dispositivo todavía no ejecuta Firefox OS, pero este es el objetivo final. Esta página pretende ser un punto central de información para la comunidad de la coordinación del trabajo de portabilidad.

-
- -

El Fairphone es un smartphone de economía justa; centrado en el abastecimiento, la producción, la distribución, la auto-reparación y el reciclaje de productos electrónicos. No es completamente hardware software libre, pero es compatible con la idea de devolver al menos algún tipo de control de hardware para los usuarios.

- -

Información de publicación del dispositivo

- -

Fairphone ha lanzado dos dispositivos hasta ahora - la FP1 v1 Fairphone (primera edición) fue lanzado el 30 de diciembre del 2013 y el FP1U (segundo lote) fue lanzado el 22 de julio de 2014. Las ventas han llegado a su fin para el dispositivo v1. El v2 Fairphone fue lanzado el 16 de julio 2015 y se puede pedir a Fairphone.

- - - - - - - - - - - - - - -
Fairphone v1Fairphone v2
A picture of the Fairphone v1 device, showing lockscreen and the back. Credit : Fairphone. CC BY-NC-SA.Fairphone 2 Black Matte
- -
-

Nota: Puede seguir el progreso en el blog Fairphone, y revisar la estrategia anunciada y el enfoque.

-
- -

Portabilidad de Firefox OS al dispositivo Fairphone

- -

Esto aún no ha sucedido, pero se está trabajando.

- -

Problemas reales

- -

Fairphone v1 no pudo actualizar su sistema operativo Android personalizado porque el fabricante del chipset no dio a conocer un código abierto de banda actualizada o compilación.

- -

En el Mobile World Congress 2015, Fairphone hizo un llamado a los posibles sistemas operativos alternativos disponibles para el próximo Fairphone v2. Estas conversaciones que se llevaron a cabo dieron por inicio la portabiliad de Firefox OS al dispositivo Fairphone. Una portabilidad de Firefox OS puede ser una manera de salvar al Fairphone v1, así como evitar estas cuestiones para las futuras generaciones de teléfonos. La colaboración de Mozilla con los tres principales proveedores de chipset también ayudaría.

- -

Fairphone v2 es orientado a código abierto con contribuciones de la comunidad a código fuente y a compilación de Fairphone OS.

- -

El progreso y la solución

- -

En este momento el proyecto de portabilidad está empezando (fase de encendido). Esperamos que el trabajo de portabilidad comienze pronto — ver este espacio para más información. 

- -

Contribuyendo

- -

Si usted está interesado en saber más o contribuir al esfuerzo para la portabilidad, los siguientes enlaces le llevaran a donde usted necesita ir.

- -

Si usted está interesado en saber más o contribuir al esfuerzo de llevar a cabo, los siguientes enlaces le llevaran a donde usted necesita ir.

- -

Herramientas de Proyecto

- - - -

Firefox OS

- -

Si usted es un desarrollador de portabilidad y quieres saber más acerca del sistema operativo Firefox OS:

- - - -

Comunidad de portabilidad XDA

- -

Si usted es un desarrollador de Firefox OS y desea saber más acerca de portar un sistema operativo:

- - - -

Especificaciones del dispositivo

- -

Fairphone v1

- -

Usted puede encontrar una lista detallada de las especificaciones en la página de las especificaciones de Fairphone.

- -

Red

- - - -

Hardware

- - - -

Software

- - - -

Fairphone v2

- -

Usted puede encontrar una lista detallada de las especificaciones en la página de las especificaciones de Fairphone.

- -

Red

- - - -

Hardware

- - - -

Software

- - - -

Ver también

- - diff --git a/files/es/archive/b2g_os/phone_guide/flame/configuracion_inicial/index.html b/files/es/archive/b2g_os/phone_guide/flame/configuracion_inicial/index.html deleted file mode 100644 index 90bb74f775..0000000000 --- a/files/es/archive/b2g_os/phone_guide/flame/configuracion_inicial/index.html +++ /dev/null @@ -1,122 +0,0 @@ ---- -title: Configuración Inicial -slug: Archive/B2G_OS/Phone_guide/Flame/Configuracion_Inicial -tags: - - B2G - - Firefox OS - - Flame - - developer phone - - dispositivo de referencia(2) - - reference device - - teléfono desarrollador -translation_of: Archive/B2G_OS/Phone_guide/Flame/Initial_setup ---- -
-

Después de conseguir un Flame, hay un par de pasos que usted debe asegurarse de que usted sigue para su sistema operativo particular, antes de empezar a tratar de actualizar su dispositivo Flame, por ejemplo para actualizar la versión de Firefox OS de su Flame, o instalar aplicaciones a su teléfono. Ambos están cubiertos en los artículos siguientes, pero se debe trabajar a través de este artículo primero.

-
- -

Todos los sistemas operativos

- -

Necesita instalar ADB y Fastboot en su ordenador — estos son aplicaciones que le permiten interactuar con su teléfono desde la computadora cuando los dos están conectados a través de cable de carga USB del teléfono. Son necesarios para que pueda flashear el teléfono a una nueva versión de Firefox OS, recuperarse de un estado no interactivo, instalando aplicaciones a su teléfono, etc.

- -
-

Nota: Si estás en Ubuntu puede instalar ADB y Fastboot simplemente usando sudo apt-get install android-tools-adb android-tools-fastboot en la línea de comandos.

-
- -
-

Nota: Si usted está en Mac OS puede instalar ADB y Fastboot simplemente usando Homebrew en la línea de comandos. Mire Instalando y usando ADB.

-
- -

ADB y Fastboot se encuentra disponible en Android Developer Toolkit:

- -
    -
  1. Vaya al link anterior.
    2. -
  2. Presione el botón Download Eclipse ADT.
    3. -
  3. Acepte las condiciones de la licencia.
    4. -
  4. Elija entre la versión de 32 bits y 64 bits (elija 32-bit si no estás seguro).
    5. -
  5. Clic en el botón final Download Eclipse ADT with the Android SDK....
    6. -
  6. Una vez finalizada la descarga, descomprima el contenido del archivo zip en el escritorio de su ordenador.
    7. -
  7. El nombre de la carpeta es un poco complicado; cambiarle el nombre a simplemente adt.
    8. -
- -

ADB es una herramienta que se ejecuta desde la línea de comandos. Si usted abre su terminal / simbolo de sistema, vaya a adt/sdk/platform-tools y ejecute el comando adb, debería ver una carga de la información arrojada de vuelta a usted acerca de lo que puede hacer con ADB. Ejecutando adb devices debe devolver la línea List of devices attached, y nada más, porque no tienes ningún dispositivo aún conectado.

- -

En este punto, es necesario establecer la variable PATH para que apunte a la herramienta ADB, para que pueda ejecutarlo desde cualquier lugar, no sólo cuando se está en el directorio exacto en que está el ADB.

- -

Para hacer esto en Windows 8 (Windows 7 será muy similar, pero con pocas diferencias de opciones de menú):

- - - -
-

Nota: Para abrir el símbolo del sistema, haga clic en el botón derecho en el botón de Windows en la parte inferior izquierda y seleccione la línea de comandos.

-
- -

En Mac/Linux:

- - - -

Habilitando depuración remota

- -

Asegúrese de depuración remota segura está activado en tu Flame, usando la opción Depuración Remota/Depuración via USB en Ajustes de desarrollador en el dispositivo (opción es diferente, dependiendo de si usted tiene Firefox 1.3 e inferior, o Firefox 1.4+ instalado).

- -

Pasos extra para Linux

- -

Dependiendo de su distro Linux, es probable que tenga que agregar una regla udev para su teléfono.

- -

Para descubrir el ID de proveedor de su dispositivo, conectar su teléfono a través de USB y utilice el comando lsusb para ver los dispositivos detectados en el subsistema USB. Encuentre su teléfono en la lista, y tome nota de las cuatro primeras cifras inmediatamente seguido de "ID". Un ID común para Flame es 05c6, por lo que una regla udev en este caso sería:

- -
SUBSYSTEM=="usb", ATTRS{idVendor}=="05c6", MODE="0666"
-
- -

Si el dispositivo muestra un número diferente, utilice en su lugar. Por ejemplo:

- -
SUBSYSTEM=="usb", ATTRS{idVendor}=="18d1", MODE="0666"
-
- -

Asegúrese de ejecutar el comando udevadm control --reload-rules (podría ser automática dependiendo de su configuración), a continuación, desconecte y vuelva a conectar el dispositivo antes de continuar.

- -

Pasos extra para Windows

- -

Para acceder al dispositivo Flame con ADB y herramientas Mozilla dev como App Manager/WebIDE, se requiere un controlador USB. Siga los pasos descritos en las secciones siguientes para instalarlo.

- -

Descargando el controlador

- -

Descargue el controlador de Windows desde esta ubicación. Una vez descargado, extraer el contenido del archivo ZIP en un lugar adecuado en su disco duro.

- -
-

Nota: Android Debug Bridge (ADB) se debe instalar primero: ver instrucciones anteriores si no has hecho esto ya.

-
- -

Instalando el controlador USB

- -

En este punto, conecte el dispositivo Flame al ordenador mediante un cable USB.

- -

Para instalar el controlador abra el directorio Alcatel_USB_Driver_Q_4.0.0_2013_11_11_noinstall  dentro del archivo ZIP extraídos y haga doble clic sobre el ejecutable DriverInstaller.exe. Es posible que reciba una advertencia en este punto que el ejecutable es de un editor desconocido. Si es así, seleccione el botón Si y se pondrá en marcha el ejecutable.

- -

Simple dialog box showing a picture of a phone along with install and uninstall buttons.

- -

Clic en el botón Install para instalar el controlador.

- -

Después de que el controlador se ha instalado, puede comprobar que está trabajando abriendo una ventana de línea de comandos y escribiendo adb devices.

- -

Esto debe listar el dispositivo conectado con una salida algo como:

- -
List of devices attached
-3561d02a          device
- -

Si el dispositivo no aparece aquí, compruebe en el Administrador de dispositivos de Windows. Su Flame puede aparecer como "ACER ADB Interface". Puede confirmar esto desconectando el dispositivo y ver si desaparece del administrador de dispositivos. Desinstale el software del controlador haciendo clic derecho sobre "ACER ADB Interface" y haciendo clic en desinstalar.  Asegúrese de marcar la casilla en el cuadro de diálogo para eliminar el software del controlador. Ahora vuelva a ejecutar el instalador anteriormente. Es recomendable establecer el tiempo de espera de pantalla en su Flame a algo alto (Ajustes > Pantalla > Screen timeout) en Windows aparece a veces para volver a instalar los controladores predeterminados cuando la pantalla se apaga.

diff --git a/files/es/archive/b2g_os/phone_guide/flame/index.html b/files/es/archive/b2g_os/phone_guide/flame/index.html deleted file mode 100644 index caf801ff64..0000000000 --- a/files/es/archive/b2g_os/phone_guide/flame/index.html +++ /dev/null @@ -1,78 +0,0 @@ ---- -title: Flame -slug: Archive/B2G_OS/Phone_guide/Flame -tags: - - Firefox OS - - Flame - - developer phone - - dispositivo de referência - - teléfono desarrollador -translation_of: Archive/B2G_OS/Phone_guide/Flame ---- -
-

Actualizaciones en tu Flame: Le animamos a unirse a la siguiente lista de correo para recibir actualizaciones periódicas sobre el software builds y otras noticias relacionadas a su dispositivo Flame: https://mail.mozilla.org/listinfo/flamenews

-
- -

A picture of the Flame device, showing the Firefox OS homescreen containing several app icons.

- -

Flame es el dispositivo de referencia oficial para el desarrollo, prueba y depuración de Firefox OS y aplicaciones web abiertas. Esta guía proporciona información básica acerca de sus especificaciones de hardware, así como documentación práctica específica experimentando con, desarrollando para, y prueba de software compatible con este teléfono.

- -

El hardware de Flame ofrece un conjunto representativo de especificaciones — incluyendo pantalla FWVGA y procesador de doble núcleo — para ayudar a los desarrolladores a crear gran contenido y experiencias. Una única plataforma de hardware también es bueno para los probadores, por lo que es más fácil de probar y abordar cuestiones específicas de software sin tener que preocuparse de dispositivos de modelos específicos, errores, etc.

- -

Si usted tiene su teléfono en la mano y quiere empezar a jugar con el, desarrollando y distribuyendo aplicaciones, o contribuir a la plataforma de Firefox, los siguientes enlaces le llevarán a donde necesita ir:

- - - -

Si desea obtener más información sobre actualizar el sistema operativo, recuperación, instalación de aplicaciones, o especificaciones del teléfono, usted encontrará la información que necesita en los dos artículos siguientes:

- - - -

Obtener un dispositivo

- -

Las ventas de Flame han llegado a su fin. Todavía hay un montón de oportunidades para los colaboradores de Mozilla para obtener Flame gratuitos, incluyendo una próxima segunda ronda del programa Foxtrot. Si tiene preguntas acerca de cómo obtener un dispositivo gratis para desarrollo o pruebas, por favor, comuniquese con Asa Dotzler o Marcia Knous (marcia) en el canal #fxos en IRC.

- -

Especificaciones del dispositivo

- -

Usted puede encontrar más de las especificaciones del dispositivo que aparecen en nuestra página Phone and device specs.

- -

Red

- - - -

Hardware

- - - -

Mire también

- -

 

- - - -

 

diff --git a/files/es/archive/b2g_os/phone_guide/flame/updating_your_flame/index.html b/files/es/archive/b2g_os/phone_guide/flame/updating_your_flame/index.html deleted file mode 100644 index 62e3ec86a4..0000000000 --- a/files/es/archive/b2g_os/phone_guide/flame/updating_your_flame/index.html +++ /dev/null @@ -1,301 +0,0 @@ ---- -title: Actualiza tu Flame -slug: Archive/B2G_OS/Phone_guide/Flame/Updating_your_Flame -tags: - - Firefox OS - - Flame - - developer phone - - dispositivo de referência - - reerence device - - teléfono desarrollador -translation_of: Archive/B2G_OS/Phone_guide/Flame/Updating_your_Flame ---- -
-

En este artículo se explica cómo actualizar el software en su Flame - incluyendo la actualización de Firefox OS e instalación de nuevas aplicaciones a su teléfono - junto con copias de seguridad de sus datos, y alguna otra solución útil de problemas e información de prueba. Antes de empezar a hacer algo de esto, usted debe asegurarse de que ha iniciado a través de la información de configuración inicial (Initial setup).

-
- -

Actualizando el software del Flame

- -

Tenemos dos principales "canales" de versiones Firefox OS para el Flame:

- - - -

Imagen Base

- -

Usted puede obtener archivos de recuperación y herramientas en los siguientes lugares de almacenamiento:

- -

Up-to-date (utilice éstos a menos que tenga una buena razón para no hacerlo)

- - - -
-

Nota: Puede averiguar qué imagen base está funcionando en su dispositivo con el comando adb shell getprop ro.bootloader. La versión son los últimos cuatro caracteres, con el último entonces removido, el prefijo 'v' (e.j. L1TC000118D0 > v18D).

-
- -
-

Importante: Cuando se ejecuta un flasheo completo o poco profundo (shallow flash), se sobrescribirán los datos del teléfono: por lo tanto, debe hacer una copia de seguridad de sus datos antes de actualizar! Mire la sección Respaldando y restaurando su información del Flame para más detalles.

-
- -

Obsoleto

- -

Estas imágenes base de son solo estables y de producción.

- - - -
-

Nota: Using a locale with base image v188 produces a mixed UI with locale and English languages.

-
- -
-

Nota: Las Imágenes v180 de Firefox OS y anteriores se basan en Android KK (Kitkat, 4,4); Builds JB (Jellybean, 04.01 a 04.03) ahora han sido descontinuados y ya no son compatibles, por lo que no debe usar nada más antiguo a v180.

-
- -

Instalación de imágen base

- -

Para instalar la imagen base en su dispositivo:

- -
    -
  1. Asegúrate de que la depuración remota esté habilitada en el Flame, utilizando la opción Depuración remota/Depuración vía USB en Ajustes de desarrollador (la opción es diferente, dependiendo de si usted tiene Firefox 1.3 e inferior, o Firefox 1.4+ instalado).
    2. -
  2. Conecta tu Flame al ordenador mediante un cable USB. Comprueba que el equipo está conectado al dispositivo mediante el comando adb devices en una terminal.
    3. -
  3. Descarga el archivo .zip mencionado anteriormente. Descomprímelo en tu escritorio.
    4. -
  4. Abre la carpeta en la que has extraído la Imágen y ejecuta: -
      -
    • En Windows, abriendo desde la línea de comandos flash.bat (o haz doble clic en el archivo en el explorador de archivos)
      - Nota: Si falta flash.bat, simplemente cambie el nombre del archivo flash.sh a flash.bat, a continuación, ejecute eso. Asegúrese de tener adb y fastboot instalado y disponible en PATH.
      • -
    • En Linux / OSX, entra en la carpeta mediante la terminal, a continuación, ejecuta el script flash.sh usando ./flash.sh (instrucciones previas le recomiendan utilizar sudo. No. Es muy peligroso utilizar sudo con las cosas que se descargan de Internet. Si el script de flasheo no encuentra su dispositivo, por favor compruebe que sus Reglas udev son correctas). Si usted no ve un archivo flash.sh, simplemente cambie el nombre del archivo flash.bat a flash.sh primero y luego usar el comando anterior.
      • -
    -
    5. -
- -
-

Nota: Si usted recibe un error "permiso denegado" al ejecutar los comandos anteriores, el script de shell, probablemente no tiene los permisos adecuados. Ejecutando chmod +x flash.sh en él debe resolver este problema.

-
- -
-

Nota: Si el script de flasheo queda atascado en "< waiting for device >" mientras la pantalla muestra "ThunderSoft (R)", el script no tiene permiso para acceder al dispositivo mientras está en modo fastboot. Necesita configurar las reglas udev para darle acceso. También puertos USB 3 no funcionan bien con fastboot y pueden ser la causa de este problema.

-
- -
-

Nota: También te invitamos a construir su propio build para instalar en Flame: mire Compilando e instalando Firefox OS.

-
- -

Arreglar la Fuente

- -
-

Importante: Este paso sólo es necesario para la imagen base v180.

-
- -

Después de actualizar Gecko y Gaia a Nightly con la imagen base v180, habrá una falta de correspondencia entre las fuentes que espera Gecko y Gaia y lo que la imagen base proporciona (esto se ha solucionado a partir de V188). Para solucionar esto, usted tiene dos opciones:

- - - -

Actualizando su Flame a una build nightly

- -
-

Nota: Para la versión actual, el desarrollo Nightly Builds de Firefox OS no es compatible con A-GPS, que puede conducir a un rendimiento lento de la funcionalidad GPS. Tenemos la intención de resolver esto de una futura actualización del canal Nightly.

-
- -
-

Importante: Cuando se ejecuta un flasheo completo o poco profundo (shallow flash), se sobrescribirán los datos del teléfono: por lo tanto, debe hacer una copia de seguridad de sus datos antes de actualizar! Mire la sección Respaldando y restaurando su información del Flame para más detalles.

-
- -
    -
  1. Antes de actualizar su teléfono a una build Nightly usted debe flashear la última imágen base para asegurarse de que los sistemas subyacentes están al día. Descargue una imágen base con la misma o una versión superior de Firefox OS de la versión que va a utilizar en el paso 3 y use esto para actualizar el software del dispositivo, como se explicó anteriormente.
    2. -
  2. Debido a que en el paso anterior se instala un sistema operativo nuevo en el dispositivo, tendrás que habilitar de nuevo la depuración remota en tu Flame, usando la opción Depuración remota en Ajustes de desarrollador del dispositivo.
    3. -
  3. A continuación, elija una build para instalar (las puedes encontrar en http://ftp.mozilla.org/pub/mozilla.org/b2g/nightly/). Usted querrá una de las siguientes: - -
    4. -
  4. Escoja una versión y descarge tanto el archivo b2g-XX.XX.en-US.android-arm.tar.gz y gaia.zip files. Guardelos dentro de un directorio en el escritorio llamado algo así como fxos.
    5. -
  5. Descarga el script de flasheo poco produnfo y guárdelo en el mismo directorio que los dos archivos anteriores.
    6. -
  6. Para usuarios de Windows: Descargue también el script windows shallow_flash.bat e instale Cygwin, que proporciona un entorno de comandos de Linux-como en Windows. Usted tendrá que instalar la categoría predeterminada Cygwin base más el paquete descomprimido pero shallow_flash.bat lo hará por usted si usted descarga y copia la configuración Cygwin * .exe en la misma carpeta que el script.
    7. -
  7. -

    Desde la línea de comandos o Terminal, utilice el cd para entrar en la carpeta en la que ha guardado los archivos y luego usa el siguiente comando:

    - -

    Linux:

    - - 
    ./shallow_flash.sh --gaia=gaia.zip --gecko=b2g-XX.XX.en-US.android-arm.tar.gz
-
    - -

    Mac:

    - - 
    ./shallow_flash.sh --gaia gaia.zip --gecko b2g-XX.XX.en-US.android-arm.tar.gz
    - -

    Windows:

    - -

    Doble clic en shallow_flash.bat (con el icono de engranajes) o ejecutarlo desde una consola de comandos (CMD). Se flasheará gaia.zip y un solo b2g-XX.XX.en-US.android-arm.tar.gz file.

    -
    8. -
- -
-

Nota: Si usted recibe un error "permiso denegado" al ejecutar los comandos anteriores, el script de shell, probablemente no tiene los permisos adecuados. Ejecutando chmod +x flash.sh en él debe resolver este problema.

-
- -
-

Nota: Un "shallow flash"actualiza Gecko y Gaia más directorios de datos, en lugar de un flash completo, que actualiza Gecko / Gaia, sino también la capa Gonk subyacente y binarios asociados en particular a este tipo de dispositivo. Es por esto que es una buena idea para actualizar a la primera base image, como se sugirió anteriormente, entonces flasheo poco produnfo sobre la parte superior de esa, una vez que tienes la correcta capa Gonk/binario.

-
- -

Una vez que el proceso de instalación termina el teléfono debe reiniciarse en la build actualizada y mostrar primero el flujo de trabajo del usuario.

- -

Cambiar al canal de actualización "nightly"l

- -

En v2.2 usted puede cambiar el Canal de actualizaciones default por nightly en los Ajustes de desarrollador.

- -

A continuación es el método más antiguo, si no encuentra esa configuración en su dispositivo.

- -
    -
  1. Asegúrate de que la depuración remota esté habilitada en su Flame, usando la opción Depuración Remota en Ajustes de desarrollador del dispositivo.
    2. -
  2. Descarga el script cambiar canal: haz click en el enlace, pulsa el botón Raw, continuación utiliza la función "Guardar como" de su navegador y guarde la página como change_channel.sh.
    3. -
  3. En tu terminal, utiliza cd para acceder a la carpeta que contiene al script y ejecuta el siguiente comando:
    - - 
    ./change_channel.sh -v nightly
    -
    4. -
  4. Una vez que se reinicie el teléfono, revisa actualizaciones en Ajustes > Información > Revisar ahora.
    5. -
- -

Ahora puedes obtener actualizaciones OTA (over-the-air) "nightly" en tu Flame.

- -
-

Nota: Puede seleccionar entre varios canales de actualización diferentes. Ejecuta "./change_channel.sh -h" para ver otras opciones de canales.

-
- -

Modo fastboot

- -

Puede que al aplicar un Shallow Flash o una actualización de la imágen base el telefono deje de responder. Cuando esto ocurre debes reiniciar el teléfono en modo de recuperación. El modo de recuperación ofrece algunas opciones (Reiniciar, Actualizar desde adb, Limpiar datos, Limpiar cache, y Actualizar desde sdcard). Desafortunadamente, seleccionando Update from adb entra en un modo (sideload) en el que no puede utilizar los otros comandos de ADB. El comando adb sideload funcionaría pero los diversos script de flasheo dependen de otros comandos adb.

- -

Puede forzar el modo fastboot de la siguiente manera:

- -
    -
  1. Apague el teléfono (que puede implicar el remover la batería en casos extremos...)
    2. -
  2. Conecte el cable USB.
    3. -
  3. Encender el teléfono de nuevo pulsando los botones Bajar volumen y Encender, juntos.
    4. -
- -

El teléfono debe mostrar el texto "FASTBOOT": este es el modo fastboot y está a la espera de una conexión USB.  En este punto conecta tu teléfono y ejecuta el siguiente comando fastboot devices. Tenga en cuenta que regularmente adb no vería el dispositivo — sólo fastboot puede verlo. En este modo, puedes usar el script flash para instalar la última imágen base como se explicó antes. A medida que el script hace uso de comandos tanto adb y fastboot, es posible que aparezca algún error inicial y advertencias de adb, pero el dispositivo será flasheado y funcionará de nuevo al final del procedimiento.

- -

Modo descarga de Emergencia

- -

Si al instalar una nueva build, el teléfono deja de responder y además no puedes entrar en el modo Fastboot, puedes usar el modo de emergencia para recuperarlo. Usted necesitará el cable USB de emergencia proporcionada con la etiqueta roja “Recovery Cable” en él y la Herramienta de descarrga de emergencia para entrar en este modo. Para obtener instrucciones completas, consulte el tutorial de la herramienta rescate de emergencia incluido en los archivos de la herramienta de descarga. Póngase en contacto con el fabricante del dispositivo (flameservice [at] thundersoft.com) si usted necesita cualquier ayuda técnica.

- -

Emergency download tool dialog box as it is when it start.

- -
-

Nota: La herramienta proporcionada es sólo para Windows.

-
- -

Modo de Recuperación

- -

Puedes entrar en modo de recuperación para borrar los datos del teléfono o actualizar manualmente el firmware. Hay dos maneras de entrar en este modo:

- -

Si tu teléfono está apagado, presiona los botones Subir Volúmen + Encender, juntos.

- - - -

Cuando ingreses al Modo de Recuperación presiona las teclas de Volumen (Subir y Bajar) para moverte dentro del menú y utiliza el botón de Encendido para seleccionar una opción. Asegurate de tener un respaldo de la información que tengas en el teléfono asi como en la tarjeta de memoria (SD) así como de haber descargado los ultimos paquetes de actualización.

- -

Respaldando y restaurando su información del Flame

- -

Cuando utiliza Flame, no querrá perder los contactos de su teléfono y otros datos, mientras actualiza a una nueva versión (como se ha explicado anteriormente en este artículo). Para respaldar y restaurar información puede utilizar nuestra herramienta Backup and restore profile, que está contenida en B2G-flash-tool Git repo.

- -
    -
  1. Para utilizarlo, primero abra su  terminal / línea de comandos.
    2. -
  2. Clone el repositorio anterior (necesita tener Git instalado) usando - 
    git clone https://github.com/Mozilla-TWQA/B2G-flash-tool
    -
    3. -
  3. La herramienta es un archivo Python: backup_restore_profile.py. Asegúrese de que tiene instalado Python (2.7.x es probablemente el mejor.) Sistemas Linux y Mac deben tener esto fuera de la caja.
    4. -
  4. Entre al directorio que acaba de clonar utilizando cd B2G-flash-tool.
    5. -
- -
-

Nota: Al utilizar esta herramienta, usted también tendrá que asegurarse de que su teléfono está conectado a través de USB al ordenador, y que ADB (mire Important steps to follow first antes) y que Depuración via USB (Ajustes de desarrollador en su dispositivo) está habilitado.

-
- -
-

Nota: Si recibe un mensaje sobre la falta de permisos para ejecutar este archivo, use cd para el directorio donde guardó el archivo y ejecuta el siguiente comando:

- -
chmod +x backup_restore_profile.py
-
- -

Respaldando su información

- -

Antes de realizar copias de seguridad usted debe asegurarse de que su dispositivo se ha actualizado con la actualización OTA más reciente. Para ello, en el teléfono vaya a Ajustes > Información > Actualizaciones > clic en Revisar ahora. Si hay una actualización disponible, usted debe obtener en breve una notificación de una actualización disponible. Elija instalar la actualización.

- -

Ahora, en el directorio donde guardó backup_restore_profile.py, ejecute lo siguiente:

- -
python backup_restore_profile.py -b
- -

Esto debe guardar su perfil de dispositivo a un directorio llamado mozilla-profile, en el mismo directorio donde se encuentra el script.

- -

Restaurando su información

- -

Antes de restaurar usted debe asegurarse de que su dispositivo se ha actualizado con la actualización OTA más reciente.. Para ello, en el teléfono vaya a Ajustes > Información > Actualizaciones > clic en Revisar ahora. Si hay una actualización disponible, usted debe obtener en breve una notificación de una actualización disponible. Elija instalar la actualización.

- -

En el directorio dondese encuentra mozilla-profile (mire la sección anterior), ejecute lo siguiente:

- -
python backup_restore_profile.py -r
- -
-

Nota: Usted puede obtener una lista de todas las opciones de la herramienta compatible con Python en ejecución
- backup_restore_profile.py -h.

-
- -

Instalando apps en tu Flame

- -

Las herramientas App Manager y WebIDE hacen que sea fácil instalar aplicaciones a su teléfono, para pruebas, etc.

- -

Ajuste de RAM

- -

Puede ajustar la capacidad de la memoria RAM disponible para ver cómo las aplicaciones funcionan en los teléfonos Firefox OS con capacidad de memoria más bajos.

- -

Esto se logra mediante la introducción al modo fastboot (primero instale fastboot, que está disponible en la misma página SDK como ADB) y ejecute:

- -
adb reboot bootloader
-fastboot oem mem [0|256-1024]
- -

“0” es la memoria detectada automáticamente y “256-1024” es el número en megabytes (MB). Por ejemplo, si deseas usar 512 MB de memoria RAM debes usar este comando:
- fastboot oem mem 512.

- -

Luego tendrás que reiniciar el dispositivo para que los cambios surtan efecto. Esto se puede hacer usando:

- -
fastboot reboot
- -

El tamaño de la memoria actual puede ser restaurado entrando en el modo fastboot y escribiendo:

- -
fastboot getvar mem
-
diff --git a/files/es/archive/b2g_os/phone_guide/fx0/index.html b/files/es/archive/b2g_os/phone_guide/fx0/index.html deleted file mode 100644 index 5decb58319..0000000000 --- a/files/es/archive/b2g_os/phone_guide/fx0/index.html +++ /dev/null @@ -1,51 +0,0 @@ ---- -title: Fx0 -slug: Archive/B2G_OS/Phone_guide/Fx0 -tags: - - Firefox OS - - Fx0 - - KDDI - - Phone - - consumer -translation_of: Archive/B2G_OS/Phone_guide/Fx0 ---- -
-
- -
-

El Fx0 es un teléfono inteligente de consumo de gama alta Firefox OS, y marca el primer lanzamiento de teléfonos Firefox OS en Japón. Fue lanzado por KDDI en diciembre de 2014.

- -

Obtener un dispositivo

- -

El Fx0 está disponible para comprar a través de canales minoristas japoneses estándar. Es un dispositivo SIM-bloqueado, por lo que sólo puede ser utilizado en Japón.

- -

Actualizando el software

- -

La imágen del sistema del dispositivo está bloqueada, por lo que sólo puede actualizarse el software cuando el operador de la red publica una actualización OTA. La imagen del sistema del dispositivo está basada en Firefox OS 2.0.

-
-
- -

Especificaciones

- -

Usted puede encontrar más de las especificaciones del dispositivo que aparecen en nuestra página Phone and device specs.

- -

Hardware

- - - -

Vea también

- - diff --git a/files/es/archive/b2g_os/phone_guide/geeksphone/index.html b/files/es/archive/b2g_os/phone_guide/geeksphone/index.html deleted file mode 100644 index e4cc268f49..0000000000 --- a/files/es/archive/b2g_os/phone_guide/geeksphone/index.html +++ /dev/null @@ -1,124 +0,0 @@ ---- -title: Geeksphone -slug: Archive/B2G_OS/Phone_guide/Geeksphone -tags: - - Firefox OS - - Gaia - - Geeksphone - - Tutorial - - Update - - actualizacion -translation_of: Archive/B2G_OS/Phone_guide/Geeksphone ---- -
-
Ediciones Developer Preview de teléfonos Firefox OS se están convirtiendo en una amplia difusión entre la comunidad, principalmente a través de Geeksphone. Dado que estos son para desarrolladores, naturalmente queremos que testees y juegues con ellos lo mas posible! En este articulo se cubriran algunos tips básicos sobre comó mantener el telefono actualizado y como ajustar las aplicaciones del sistema Gaia.
-
-
(Nota: Estas instrucciones son para los viejos modelos Keon y Peak, no necesariamente para el ultimo telefono Geeksphone Revolution)
-

 

-

Actualizando tu Geeksphone a las últimas versiones

-

Las actualizaciones de Firefox Os pueden ser descargadas desde la aplicación Configuración, que se encuentra bajo información del Dispositivo. Puede configurarse el dispositivo para que cheque por actualizaciones diriamente, semanalmente o  mensualmente. Además se proporciona un botón "checar ahora". Cuando hay una actualización disponible se le pedira que descargue e instale la versión actual.

-

The screen for checking updates on the Firefox OS settings app

-

Flasheando su teléfono

-

El equipo de Geeksphone también ofrece la última versión estable y nightly build como descargas autonomas para flasear tu telefono.

-

Configure su teléfono y computadora

-

Antes de intentar flashear su teléfono asegurese de que ha realizado las configuraciones descritas en la sección "Configuración del dispositivo Geeksphone" en  Instalando Apps Firefox OS al Geeksphone. Esto le asegurara que puede transferir datos a su teléfono. En esa misma sección, siga las instrucciones y asegurese que cuenta con los drivers USB correctos.

-
-

Nota: Es particularmente importante en las computadoras Windows esten configuradas con los drivers USB correctos.

-
-

Las imagenes estan localizadas en el sitio de descarga de Geeksphone. En este sitio se le presentaran varias opciones para seleccionar su dispositivo y que tipo de imagen desea utilizar.

-

Two phone images side by side, the Geeksphone Keon and Peak, with different software download options below each one.

-

Descarge la imagen que usara y extraiga el archivo en su sistema de archivos. El archivo contiene imagenes y comandos requeridos para flashear el teléfono usando Windows, Mac OS, o Linux. Antes de empezar a flashear el teléfono asegúrese de que tiene habilitada la depuración remota en el teléfono. Esta opción puede ser habilitada lanzando la aplicación Configuraciones y navegando a Informació del dispositivo -> Mas información -> Desarrollador. Asi mismo, no intente flashear el dispositivo si la batería tiene menos del 50% de carga.

-

Enabling remote debugging on the Firefox OS Settings app

-
-

Nota: Si tu dispositivo no se encuentra con el script de los siguientes pasos, incluso si esta conectado via USB, tendrás que desbloquear tu teléfono y esperar a que aparezca en el sistema.

-
-
-

Nota: "Flashear" el teléfono eliminara todos los datos en el. Si deseas hacer un respaldo de tus datos y restaurarlos despues, sigue las siguientes instrucciones en  Copia de seguridad de la partición del sistema del teléfono.

-
-

Windows

-
-

Nota: Puede que tenga la necesidad de instalar los drivers USB en Windows. Para obtener estas instrucciones vea la sección "Configuración del dispositivo Geeksphone" en  Instalando Apps Firefox OS al Geeksphone.

-
-

Abra una linea de comandos(inicio -> escriba cmd in la busqueda -> enter en Windows 7, tecla de window + X -> seleccionar linea de comandos en Windos 8) y dirigete a la ruta del directorio donde se encuentran los archivos extraidos con  cd "ruta del directorio". Enter:

-
flash.bat
-
-

Esto instalara la nueva imagen en el teléfono. El teléfono necesitara ser configurado nuevamente ya que todos los datos habrán sido borrados.

-

Mac OS

-

Abra una ventana de Terminal (Cmd + espacio -> escriba terminal -> enter) y dirijase a la ruta del directorio que contiene los archivos extraidos. Enter:

-
./flash_mac.sh
-
-

Esto instalara la nueva imagen en el teléfono. El teléfono necesitara ser configurado nuevamente ya que todos los datos habrán sido borrados.

-

Linux

-

Para flashear un Keon desde Ubuntu hay que agregar la siguientes reglas a /etc/udev/rules.d/51-android.rules

-
- SUBSYSTEM=="usb", ATTR{idVendor}=="05c6", ATTR{idProduct}=="8013", MODE="0666"
-
- SUBSYSTEM=="usb", ATTR{idVendor}=="18d1", ATTR{idProduct}=="d00d", MODE="0666"
-
-  
-

Abra una ventana de Terminal (control-alt-t en Ubuntu) y dirijase al directorio que contiene los archivos extraidos. Enter:

-
./flash.sh
-
-

Esto instalara la nueva imagen en el teléfono. El teléfono necesitara ser configurado nuevamente ya que todos los datos habrán sido borrados.

-

Esto debe flashear la nueva imagen en el teléfono. El teléfono debera configurarse de nuevo ya que toda la información ha sido borrada. Si quiere tener un respaldo de su información y restaurarla despues, puede seguir las instrucciones en Respaldo del sistema de partición del teléfono.

-
-

Otra forma de "Flashear" el Keon usando Ubuntu es de la siguiente manera:

-
-

Paso 1: Conecta el dispositivo

-

Paso 2: Abre la Terminal

-

Paso 3: Escribe el comando sudo nautilus, escribe tu contraseña de Root para abrir el sistema de ficheros

-
sudo nautilus
-

Paso 4: Pega la carpeta de Firefox O.S Geeks Phone Build en el directorio

-

Paso 5: Haz click en el archivo llamado "flash.sh"

-
./flash.sh
-

Si tiene un 'unagi' o un teléfono developer preview que no sea un Geeksphone

-

Si usted cuenta con un teléfono de desarrollador y no es Geeksphone como un 'unagi' o un dispositivo basado en Android, tal vez necesite realizar los siguientes pasos. Si este no es el caso, por favor siga a la siguiente sección.

-

Usted necesitara instalar el adb y fastboot. Estas utilidades se pueden enconrar en el Kid de herramientas de desarrollo Android (ADT).

-

No es necesario instalar todo el kit de desarrollo. Descargue el kit de desarrollo desde aqui y extraiga el contenido. Adb y fastboot se encuentrar en el directorio /platform-tools/carpeta. Estos pueden ser copiados a /usr/bin en Linux o Mac OS, o copiados en alguna carpeta siempre y cuando se especifique el $PATH de los binarios agregados.

-

Si usted esta tratando de flashear su dispositivo y tiene otro conectado via USB, su teléfono posiblemente no sea detectado por las utilidades correctamente. Solamente tenga conectado su teléfono mientras intente flashearlo.

-

Afinando Gaia

-

Si usted es parte de la industria, usted puede adaptar las aplicaciones por default en Gaia - la UI en Firefox OS. En esta sección se cubrira algunos aspectos básicos para clonar Gaia y hacer cambios en las aplicaciones por default del sistema. Tenga en cuenta que estos consejos son "bajo su propio riesgo" y pueden involucrar la sección "Ok, he brickeado mi teléfono". Antes de proceder, este seguro de tener instalado adb y fastboot en su sistema. Para verificar que los tiene instalado abra una ventana de Terminal y escriba   adb devices   con su dispositivo conectado. Usted deberia ver su teléfono listado bajo los dispositivos conectados.

-

Usted tambien puede correr fastboot desde terminal. Si usted corre fastboot, se debera mostrar un conjunto de opciones. Si usted no tiene instalado adb o fastboot, una busqueda rapida en Google con su sistema operativo volvera varios resultados sobre como instalarlos. Adicionalmente a adb y fastboot usted necesitara tener Git. Si no tiene instalado Git, de un vistazo a esta guia de configuració. Finalmente asegurese de que su teléfono esta configurado para la depuración remota, paso descrito en la sección previa.

-

Una vez que tenga todos los prerequisitos abra una terminal y dirijase al directorio donde le gustaría clonar el código fuente de Gaia. Escriba el siguiente comando:

-
git clone git://github.com/mozilla-b2g/gaia.git gaia
-cd gaia
-
-

Esto clonara la ultima versión del código de Gaia en su sistema.

-
-

Si su plan es subir cambios de regreso al código de Gaia, asegurese de hacer un fork del codigo antes de clonar como se describe en Hacking Gaia.

-
-

Recientemente el Geeksphone Keon ustiliza la rama v1.0.1 del código de Gaia, así que asigne la rama adecuada con el siguiente comando antes de hacer cualquier otra cosa:

-
git checkout -b v1.0.1 origin/v1.0.1
-
-

La mayor parte de las aplicaciones del sistema estan localizadas en el subdirectorio de aplicaciones de Gaia. Usted ahora puede hacer cualquier cambio que desee en las aplicaciones de Firefox OS. Una vez que haya hecho los cambios, asegurese que su dispositivo ha sido montado apropiadamente usando el siguiente comando:

-
adb remount
-

A continuación, ejecute el siguiente comando para hacer push de las aplicaciones modificadas en su teléfono. Esto hará push por defecto a todas las apps del teléfono:

-
B2G_SYSTEM_APPS=1 make install-gaia
-
-

Si sólo hizo cambios en una sola app puedes especificar los cambios de esta usando una sintaxis similar. En este ejemplo sólo la aplicación de calendario sera instalada en el teléfono:

-
APP=calendar B2G_SYSTEM_APPS=1 make install-gaia
-
-

Si tiene problemas mientras hace los cambios, puede reiniciar el teléfono a los valores por defecto usando los siguientes comandos:

-
make production
-make reset-gaia
-
-
-

Nota: Tenga en cuenta que cualquiera de los comandos anteriores limpiaran cualquier dato o aplicación lanzada en el teléfono. Si quiere hacer un respaldo de su información y restaurarla después, debe seguir las instrucciones en el apartado de Copia de seguridad de la partición del sistema del teléfono .

-
-

"Ok, he bloqueado mi teléfono"

-

Si esta en el proceso de modificación de su teléfono y "no responde" debería ser capaz de recuperarlo usando fastboot con un simple procedimiento. A continuación se ilustra como reestablecer el Keon pero con otros teléfonos el proceso debería ser similar. También necesitara verificar si tiene instalado fastboot.

-

Primero retire el cable USB y después remueva la batería del teléfono por 30 segundos. Entonces reinserte la batería y presiones el botón de bajar volumen  mientras mantiene el botón de encendido por unos cuantos segundos. A continuación reconecte el cable USB y ejecute los siguientes comandos desde una ventana de Terminal en el directorio que contiene los ultimos archivos img descritos en la primera sección de este post:

-
fastboot flash recovery recovery.img
-fastboot flash boot boot.img
-fastboot flash userdata userdata.img
-fastboot flash system system.img
-fastboot reboot
-
-

Este proceso debera recuperar su teléfono. Si no funciona, es posible que tenga que  intentar una segunda vez.

-

A jugar!

-

Esperamos que estas instrucciones te sean utiles, y naturalmente queremos que seas feliz con Firefox OS y las posibilidades que somos! Sientete libre de jugar con las actualizaciones de tu dispositivo, de hacer cambios/actualizaciones de las aplicaciones Gaia, y también sientete inspirado de construir tus propias Open Web Apps.

-

Ver también

- diff --git a/files/es/archive/b2g_os/phone_guide/index.html b/files/es/archive/b2g_os/phone_guide/index.html deleted file mode 100644 index 6047637215..0000000000 --- a/files/es/archive/b2g_os/phone_guide/index.html +++ /dev/null @@ -1,43 +0,0 @@ ---- -title: Guía de Desarrollo en Firefox OS -slug: Archive/B2G_OS/Phone_guide -tags: - - B2G - - Firefox OS - - desarrollo - - telefonos -translation_of: Archive/B2G_OS/Phone_guide ---- -
-

Esta sección contiene información relevante para el desarrolladores sobre las especificaciones de los teléfonos que ejecutan Firefox OS. Tenemos información general disponible en Construir e instalar Firefox OS y Hacking Firefox OS, así que por favor vaya por la información acerca de construir e instalar la plataforma desde cero. Sin embargo, los desarrolladores que posean teléfonos especificos de desarrollo pueden encontrar los siguientes articulos de gran ayuda.

-
-

Información especifica del dispositivo

-
-
- Datos del teléfono Firefox OS
-
- En este artículo enumeramos los distintos teléfonos disponibles Firefox OS, junto con información como sus nombres en clave, la disponibilidad y características de hardware específicos.
-
- Geeksphone
-
- En este artículo vamos a cubrir algunos consejos básicos sobre cómo mantener su Geeksphone hasta a la fecha y la forma de modificar el sistema de aplicaciones de Gaia.
-
- El ZTE OPEN Firefox OS
-
- Este artículo es para compartir la información que tenemos disponible del dispositivo ZTE OPEN Firefox OS.
-
-

Información general de Firefox OS

-
-
- Información general de las caracteristicas
-
- Esta página muestra las características típicas de hardware Firefox OS y los requisitos mínimos de hardware.
-
- Solución de problemas
-
- Este artículo proporciona consejos para la solución de problemas comunes que pueden surgir al utilizar Firefox OS.
-
- Mejores prácticas para dispositivos abiertos de referencia
-
- Un conjunto de mejores prácticas que creemos y recomendamos para cualquier dispositivo de referencia abierto. Todas las recientes referencias de dispositivos Firefox OS siguen estas prácticas.
-
diff --git a/files/es/archive/b2g_os/phone_guide/lista_dispositivos/index.html b/files/es/archive/b2g_os/phone_guide/lista_dispositivos/index.html deleted file mode 100644 index 86ac8aba87..0000000000 --- a/files/es/archive/b2g_os/phone_guide/lista_dispositivos/index.html +++ /dev/null @@ -1,712 +0,0 @@ ---- -title: Lista de Dispositivos -slug: Archive/B2G_OS/Phone_guide/lista_dispositivos -tags: - - B2G - - Dispositivos - - Especificaciones - - Firefox OS - - Guia(2) - - Guía - - Móvil - - Telefono - - movil(2) -translation_of: Archive/B2G_OS/Phone_guide/Phone_specs ---- -
-

Este artículo entrega información acerca de los dispositivos disponibles con Firefox OS. Incluye además las especificaciones del Hardware, nombres clave, la versión de Firefox OS con la que fue lanzado al mercado y mucho más.

-
- -

Dispositivos con Firefox OS disponibles

- -

Durante el desarrollo de Firefox OS hemos tenido diversos dispositivos para realizar pruebas. Hoy en día con la salida al mercado de Firefox OS contamos con diversos modelos de distintos vendedores.

- -
-

Nota: Para información comercial de los dispositivos que se venden actualmente por favor revisa nuestra página para encontrar un dispositivo Firefox OS cerca tuyo.

-
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-

Nombre / Nombre Clave

- 		LanzamientoVersión FxOSDisponibleComentarios
-

Alcatel One Touch Fire

- -

hamachi, buri

- 		Julio 12, 20131.0.1Actualmente disponible -

Disponible publicamente en Brasil, Uruguay, Italia, Alemania, Grecia, Serbia, Hungria y Polonia. Disponible por revendedores en eBay.

-
Alcatel One Touch Fire EJulio 18, 20141.3.0Actualmente disponibleDisponible publicamente en Alemania.
otoro, unagi, inari   off the shelf ZTE phone used for development prior to the ZTE Open.
-

ZTE Open

- -

ikura

- 		Julio 2, 20131.0.1Actualmente disponibleSimilar al inari; Publicamente disponible en eBay
-

LG Fireweb

- -

leo

- 		Octubre 24, 20131.1Actualmente disponiblePublicamente disponible en Brasil.
-

Geeksphone Keon

- -

keon

- 		Abril 24, 20131.0.1Actualmente agotadoSolo para desarrolladores
-

Geeksphone Peak

- -

peak

- 		Abril 24, 20131.0.1Actualmente agotadoWas codenamed "twist" for a while; developer-only devices
Geeksphone Peak+---cancelado
Geeksphone RevolutionMarzo 4, 20141.3preActualmente disponibleDisponible en linea.
-

LG Google Nexus 4

- -

nexus-4

- 		   Experimental. Not supported by either LG or Google. Discontinued hardware.
-

Flame

- -

"the reference device"

- 		Fines de Abril, 20141.3 Available to pre-order
-

Spreadtrum

- -

tarako

- 		Al final del Q2, 2014 Pronto. 
ZTE Open CMayo 13, 20141.3DisponibleDisponible en linea.
Symphony GoFox F15Septiembre 16, 20141.4DisponibleAvailable through Grameenphone channels in Bangladesh only.
Intex Cloud Fx 1.3 DisponibleDisponible en Snapdeal, solo en India.
Spice Fire One (Mi-FX1) -
 
- 		1.3DisponibleDisponible en Snapdeal, solo en India.
Alcatel OneTouch FireC 4020DOctubre 1, 20141.3DisponibleDisponible en Filpkart
Zen Fire 105Octubre 16, 20141.3DisponibleDisponible en Homeshop18
- -

Versiones de Firefox OS

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
VersionFeature Complete (FC) dateRelease To Partner
- (RTP) date		CodenameGecko versionIncluded security fixesRelease notes
1.0Diciembre 22, 2012Febrero 21, 2013TEFGecko 18Gecko 18 
1.0.1Enero 15, 2013Septiembre 6, 2013ShiraGecko 18Gecko 20Developer
- Consumer
1.1Marzo 29, 2013Octubre 9, 2013LeoGecko 18+ (new APIs)Gecko 23Developer
- Consumer
1.1.1 TBDHDSame as 1.1.0 with WVGAGecko 23 
1.2Septiembre 15, 2013Diciembre 9, 2013KoiGecko 26[39]Gecko 26Developer
- Consumer
1.3Diciembre 9, 2013TBD Gecko 28Gecko 28Developer
- Consumer
1.4Marzo 17, 2014TBD Gecko 30Gecko 30Developer
- Consumer (TBD)
2.0TBDTBD Gecko 32Gecko 32Developer
- Consumer (TBD)
- -

Especificaciones de dispositivos

- -

Nota hay algunos casos donde hay un upcoming device que no ha sido anunciado pero podemos compartir el nobre del codigo and (some of) the capabilities of the device.  DO NOT put extra info down for these devices unless Andreas Gal or someone else equally able to bless the public disclosure of the information has disclosed it.

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
NombreVersionesResoluciónPantalla (pulgadas)CPUCamara(s), MpxRAMROMStorageBattery (mAh)
-

Alcatel One Touch Fire

- -

hamachi, buri

- 		v1.0.1/v1.1 -

320 x 480
- PX=1

- 		3.5Qualcomm Snapdragon S1 MSM7227A 1 GHzRear: 3.2256MB512MB/data: probably the same as inari; specs say 160MB "end user memory"
- Probably no built-in DeviceStorage, MicroSD card (up to 32GB) required
-  		1400
Alcatel One Touch Fire Ev1.3.0540 x 9604.5 -

Qualcomm Snapdragon 200
- MSM8210
- 1.2 GHz
- dual-core
-  

- 		Rear: 5512MB4GB 1700
-

ZTE Open / variants

- -

ikura

- 		v1.0.1 (as shipped)320 x 480
- PX=1		3.5Qualcomm Snapdragon S1 MSM7225A 800 MHzRear: 3.2256MB512MB -

/data: 152M
- No built-in DeviceStorage, MicroSD card required

- 		1200
-

LG Fireweb

- -

leo

- 		v1.1320 x 480
- PX=1		4Qualcomm  Snapdragon S1 MSM7227A 1 GHzRear: 5512MB4GB -

/data: 1007.90M
- built-in DeviceStorage: yes, size unsure. possibly 3.7G, but that might be bad math.  (On an unhapy device /sys/devices/platform/msm_sdcc.3/mmc_host/mmc0/mmc0:0001/block/mmcblk0/block is 7733248, and then assuming a 512 byte block size, we get 3.7G)

- 		1540
-

Geeksphone Keon

- -

keon

- 		-

v1.0.1 - nightly
- downloads here

- 		320 x 480
- PX=1		3.5Qualcomm Snapdragon S1 7225AB 1 GHzRear: 3512MB4GB -

/data: 1.5G
- built-in DeviceStorage: 1023.4M

- 		1580
-

Geeksphone Peak

- -

peak

- 		v1.0.1 - nightly
- downloads here		540 x 960
- PX=1.5		4.3Qualcomm Snapdragon S4 8225 1.2 GHz dual-core -

Front: 2
- Rear: 8

- 		512MB4GB/data: 1.5G
- built-in DeviceStorage: 1023.4M		1800
Geeksphone Revolutionv1.3pre (as shipped)540 x 960 PX=1.54.7Dual-core Intel® Atom™ processor Z2560 with up to 1.6GHz -

Front: 1.3 Rear: 8

- 		1GB4GB -

/data: 2G
- built-in DeviceStorage: 2.5GB

- 		2000
-

Nexus 4

- -

nexus-4

- 		v1.3 - nightly768 x 1280
- 720p		4.7 -

Qualcomm
- Snapdragon S4 Pro
- 1.5 GHz quad-core

- 		Rear: 82GB8 or 16GBeverything exists in one big soup, there is no external (MicroSD) storage.  The size of the soup varies based on what model Nexus 4 you got.2100
-

Foxconn InFocus

- -

flatfish

- 		 1280 x 80010Allwinner A31, Cortex A7 Quad-Core 1.0 GHz -

Front: 2
- Rear: 5

- 		2GB16GB 7000
-

some phone thing

- -

fugu

- 		v1.2f (branch) per320 x 480   256MB   
-

Spreadtrum SC6821

- -

tarako

- 		v1.3 perHVGA
- 320 x 480		3.5Spreadtrum SC6821, Cortex A5 1GHz0.3 (rear only?)128MB (zram)2GB NAND flash (external) + 1GB LPDDR1 (embedded)32GB micro SD card1100
-

VIA Vixen

- -

community-driven customization of flatfish?

- 		 1024 x 6007Cortex-A9 Dual Core 1.2 GHz -

Front: 0.3 Rear: 2
-  

- 		1GB8GB  
-

Flame

- -

"the reference device"

- 		v1.3 -

FWVGA
- 854 × 480
- PX=1.5
-  

- 		4.5 capacitive touch -

Qualcomm Snapdragon 200 MSM8210, 1.2GHZ Dual core processor

- 		Front: 2
- Rear: 5 auto focus with flash		256MB–1GB (adjustable by developer)8GB32GB micro SD card (USB 2.0)1800
ZTE Open Cv1.3 -

800 x 480 PX=1.5

- 		4Qualcomm Snapdragon 200 MSM8210, 1.2GHZ Dual core processorRear: 3512MB4GB -

/data: 1G

- 		1400
Symphony GoFox F15 -

v1.4

- 		320 x 480
- PX=?		3.5Spreadtrum 1 GHz Single Core Processor -

Front: 0.3
- Rear: 3.2 with Flash

- 		512MB512MB 1450
Intex Cloud FxV 1.3320 x 4803.5Spreadtrum 1 GHz
- Rear: 2.0 without Flash		128 MB256 MB -

Data : 2G

- -

Internal Storage: 46 MB(User Memory)

- -

External -Micro SD Card : Upto 4GB Expanable

- 		1250
Spice Fire One (Mi-FX1)V 1.3320 x 4803.5Spreadtrum 1 GHz -

Front :VGA

- -

Rear 1.3

- 		128 MB512 MB -

Data : 2G

- -

Internal Storage: 67.9 MB(User Memory)

- -

External -Micro SD Card: Upto 4GB Expanable

- 		1400
Alcatel OneTouch FireC 4020DV 1.3320 x 4803.5Spreadtrum 1 GHz 128 MB256 MB -

Data : 2G

- -

Internal Storage : 65 MB(User Memory)

- -

External -Micro SD Card: Upto 32GB Expanable

- 		1000
Zen Fire 105V 1.3320 x 4803.5Spreadtrum 1GHz -

Front :VGA

- Rear 2 MP		128 MB256 MB -

Data : 2G

- -

External -Micro SD Card: Upto 16GB Expanable

- 		1200
- -

Column explanations:

- - diff --git a/files/es/archive/b2g_os/phone_guide/zte_open/index.html b/files/es/archive/b2g_os/phone_guide/zte_open/index.html deleted file mode 100644 index f5ae618098..0000000000 --- a/files/es/archive/b2g_os/phone_guide/zte_open/index.html +++ /dev/null @@ -1,287 +0,0 @@ ---- -title: The Firefox OS ZTE OPEN -slug: Archive/B2G_OS/Phone_guide/ZTE_OPEN -translation_of: Archive/B2G_OS/Phone_guide/ZTE_OPEN ---- -
-

Mozilla is partnered with ZTE. This partnership helped to create the ZTE OPEN, a powerful Firefox OS-based device aimed at developers and early adopters worldwide. They are unlocked and open for testing and experimentation.

-
- -
-

Note: The instructions are not valid for the ZTE Open C device. If you have a ZTE Open C device you should go to our ZTE Open C page instead.

-
- -

Purchasing a device

- -

These devices are available through ZTE's US and UK eBay stores, and a separate Hong Kong page aimed at Asian and Oceanian customers who don't want to pay high postage costs. They are priced at $79.99/£59.99.

- - - -

Upgrading Firefox OS

- -

This section provides instructions for upgrading Firefox OS on your ZTE OPEN device.

- -

General

- -

In general, Firefox OS builds, updates and testing are done by connecting your phone to a computer using a USB cable, and using ADB (Android Debugging Bridge) and Fastboot to join the devices together and issue commands. You'll therefore need to install ADB and fastboot from the Android Developer Toolkit on your desktop machine. It is not necessary to install the entire toolkit. adb and fastboot are found in the /platform-tools/ folder.

- -

Next, you need to go to your phone and enable remote debugging.

- -

Firefox OS 1.1

- -

On 10th December 2013: ZTE released a Firefox OS 1.1 upgrade for the ZTE OPEN. This now has fastboot enabled, which was caused the problems with the previous published builds.

- -

At this point, it's best to first upgrade your phone to version 1.1, even if you wanted to go to version 1.2. To do this, download the 1.1 package that corresponds to your phone (OPEN (American Standard) or OPEN (European Standard)).  Note that you need to download the version with your OS revision in it (that is, download the "V1.1.0B02(for V1.0)" if you are upgrading from V1.0). The zip file you’ll download will also contain documentation for the upgrade.  Unzip it and copy the firmware ZIP (inside the downloaded zip) as described below.

- -
-

Note: User data will be wiped by the SD package installation. You should backup your data before starting.

-
- -

Now follow these steps:

- -
    -
  1. Power off your phone, remove the battery to access the microSD card and extract the card from its holder.
    2. -
  2. Connect the microSD card to your desktop machine.
    3. -
  3. Move US_DEV_FFOS_V1.1.0B04_UNFUS_SD.zip or EU_DEV_FFOS_V1.1.0B04_UNFUS_SD.zip (depending on the version you downloaded) to the root directory of your microSD card. Do NOT unzip the file.
    4. -
  4. Disconnect the microSD card from your desktop computer and return it to your phone.
    5. -
  5. Hold the volume up button and power key down simultaneously. Volume up is activated by pressing the upper part of the long key on the left side of the phone. If you did it properly, you’ll enter the Firefox OS recovery mode. (Note: the Firefox OS logo may display briefly before you enter the recovery mode; sometimes this can take a little while.)
    6. -
  6. Use the volume up/down key to move from one item to the other in the menu, and choose “apply update from external storage.”
    7. -
  7. Press the power key to confirm the selection. You’ll see a new screen listing the files you have on the microSD card.
    8. -
  8. Again use volume up/down key to select the firmware: either US_DEV_FFOS_V1.1.0B04_UNFUS_SD.zip or EU_DEV_FFOS_V1.1.0B04_UNFUS_SD.zip (depending on the version you downloaded), and press the power key to confirm.
    9. -
- -

If everything went well, you’ll see a sequence of status messages, culminating with one that says, “Install from sdcard complete.”. You’ll need to select “reboot system now” after the installation has completed. Your phone will then reboot, and you’ll see the configuration screen you saw the first time you powered on the phone.

- -

Firefox OS 1.2

- -

In January 2014, ZTE released a beta version of Firefox OS 1.2 (fastboot enabled, with root access). It is basically version 1.1 baseline + version 1.2 Gecko and Gaia, and doesn't require the build to be put on the phone's SD Card.

- -

With 1.1 installed as described above, open a terminal and check that the connection is made with the following command:

- -
adb devices -l
-
- -

You should see your device as something like, "roamer2    device usb:2-1.2", in response.

- -

Download the appropriate version of the build from the Dropbox account ZTE has set up: US version or UK version. For Windows users, you can also download special instructions, and an upgrade tool to help you to install the new version easily. The steps below however will work on all operating systems – Linux, OS X, and Windows – without relying on the special tool.

- -

Once you have the file, extract the contents, and open a console. Note that those steps will erase your personal data, so be sure to make a (backup) first. Then navigate to the folder where the files are. Still in the console, type this command:

- -
adb reboot bootloader
- -

While the phone is rebooting, execute the following command. (Fastboot only works inside a reboot):

- -
sudo fastboot devices
-
- -

If you see, "< waiting for device >", hit Ctrl-C and retry the command until you see something like, "ROAMER2    fastboot", in response.

- -

Then, quickly execute the following commands while it is still rebooting:

- -
fastboot flash boot boot.img
-fastboot flash userdata userdata.img
-fastboot flash system system.img
-fastboot flash recovery recovery.img
-fastboot erase cache
-fastboot reboot
- -
-

Note: If you keep encountering "waiting device" message. Try add sudo before the commands, like "sudo fastboot flash boot boot.img".

-
- -

(The reboot completed before I was done entering all the commands as I was distracted. I simply restarted from the, "adb reboot bootloader".)

- -

If everything went well, your phone should reboot at this point. You’ll find that this version of 1.2 from ZTE includes many test applications, which you can remove if you like.

- -
-

Note: Upgrading your ZTE Open to Firefox 1.1 or 1.2 (fastboot enabled) by Frédéric Harper also provides a useful breakdown of the install process.

-
- -
-

Note: There is a bug in ZTE's 1.2 build for the Open, whereby the notification tray won't pull down/open. This can be fixed by flashing the latest engineering version Firefox OS 1.2 to your phone. Make sure you have ADB installed and remote debugging turned on, then run the following commands in your terminal:
-
- git clone -b v1.2 https://github.com/mozilla-b2g/gaia.git gaia_v1.2
- cd gaia_v1.2
- make reset-gaia

-
- -

Firefox OS 1.3 and beyond

- -

ZTE currently haven't released builds for Firefox OS 1.3 and beyond. To get these on your ZTE open you'll have to manually build and install a new Firefox OS/B2G build on it (start at the build prerequisite instructions, and treat the ZTE like it is an Inari device, for the purposes of configuration). You can recover your phone if necessary, using the procedure cited in the I bricked my phone section.

- -

Phone features

- - - -
-

Note: the Hong Kong phones also support tri-band 3G Networks — HSDPA 850/1900/2100 (850/1900 for US, CA, 850/1900/2100 for Asia, AU, and 900/2100 for EU.)

-
- -

Wireless carriers

- -
-

Pricing information is for reference only and may not be accurate. Visit the associated link for official information.

-
- -

US carriers

- -

AT&T

- - - -
Sampling of prepaid AT&T plans
- -

Prepaid GoPhone®, Smartphone Plans

- - - -

Aio

- - - -
Sampling of prepaid Aio plans
- - - -

Good2GO

- - - -
Sampling of prepaid Good2GO plans
- - - -

Other AT&T MVNOs

- -

These carriers do not offer additional 3G data.

- - - -

T-Mobile

- - - -

Canadian carriers

- -

The US version of the ZTE Open also work in Canada on carriers that use the Bell/Telus network, or the Rogers network. Some regional carriers like Sasktel or MTS that have UMTS should work too.

- -

It will not work on carriers that do not use UMTS or GSM, like Public Mobile, nor on the carriers that use the AWS band like WIND Mobile, Mobilicity, Videotron or Eastlink.

- -

Memory card

- -

File system

- -

In order to be recognized by the phone, the MicroSD card must be formatted as a FAT32 file system. If a card is new or has never been reformatted, it should work as is.

- -

Device revisions

- -

Revision 01

- -

Phones produced before 09/27/2013 do not have fastboot enabled and must be updated. Normally, this would be handled by Software Updates, but since some users have reported trouble with this method, ZTE have made SD card packages available to enable fastboot on earlier devices. Flash images for:

- - - -

The zip file is linked under Downloads.  Note that you need to download the version with your OS revision in it (that is, download the "V1.1.0B02(for V1.0)" if you are upgrading from V1.0).  Once the file is downloaded and unzipped, follow the instructions in the bundled PDF to flash the package to your phone.

- -

Related Support Forum Questions:

- - - -

Revision 02

- -

Phones produced on or after 09/27/2013 are fastboot enabled by default. This includes the Hong Kong phones.

- -
-

Note: If you are unsure of your phone's revision, check it in Settings > Device Information > Software. If it is older than the following version numbers, you will need to update your phone using the above SD packages to enable fastboot.

- - -
- -

Device support

- -

Once your phone has fastboot enabled, you will then be able to build and install new Firefox OS/B2G builds on it (start at the build prerequisite instructions, and treat the ZTE like it is an Inari device, for the purposes of configuration), and recover your phone if necessary, using the procedure cited in the I bricked my phone section.

- -

If you encounter errors about setting the system time while flashing a custom build, you may need to download a modified boot image.

- -

I bricked my phone

- -

If you are in the process of modifying your phone and it becomes “unresponsive” you should be able to recover it using fastboot with the following simple procedure.

- -

First remove the USB cable and then remove the battery from the phone for 30 seconds. Then reinsert the battery and press the volume up button while holding the power button for a few seconds. Next reconnect the USB cable and run the following commands from a terminal window in the directory that contains the SD package files described above (it is worth checking for an update to the SD package before you do this):

- -
fastboot flash recovery recovery.img
-fastboot flash boot boot.img
-fastboot flash userdata userdata.img
-fastboot flash system system.img
-fastboot reboot
-
- -

This process should recover your phone. If it doesn't seem to work, you may have to try it a second time.

- -

Headphones not working?

- -

We found that the headset jack is designed by a Chinese manufacturer that has compatibility problems with other brands of headsets that include microphones. You may have voice mute problems when you try to use headsets made by Apple, Samsung, HTC, and others. You can buy a 3.5 mm headset adapter that reverses the microphone and ground pins to avoid this problem. For more information, see error 812607.

- -

Other support notes

- -

Some customers have come across an Issue of FOTA updates failing to enable fastboot; this is still under investigation, and we are assisting ZTE to analyze every scenario. We will post more information as it is available.

- -

If your phone was unfortunately damaged during the FOTA update because of ZTE providing false or wrong update files, you can attempt to restore it to factory settings using the appropriate SD image and instructions referenced in Revision 01. Otherwise, send your phone back to the eBay store you purchased it from in exchange for a new one. You may contact the store owner directly via an eBay message.

- -

See also

- -

Official Dev Phone page on Firefox Marketplace

- -

Draft User Manual [en-US] - PDF

diff --git a/files/es/archive/b2g_os/phone_guide/zte_open_c/index.html b/files/es/archive/b2g_os/phone_guide/zte_open_c/index.html deleted file mode 100644 index 985a7e413e..0000000000 --- a/files/es/archive/b2g_os/phone_guide/zte_open_c/index.html +++ /dev/null @@ -1,226 +0,0 @@ ---- -title: ZTE OPEN C -slug: Archive/B2G_OS/Phone_guide/ZTE_OPEN_C -tags: - - Dispositivos - - Gaia - - Guia(2) - - Móvil - - Open C - - Smarthpone - - Teléfono(2) - - Teléfonos(2) - - zte -translation_of: Archive/B2G_OS/Phone_guide/ZTE_OPEN_C ---- -
-

El ZTE Open C con Firefox OS es un móvil con Firefox OS mejorado por ZTE que ofrece un hardware más potente, incluyendo una cámara de 3MP y pantalla de 4 pulgadas con una calida WVGA, y viene instalado con Firefox OS 1.3. Este artículo proporciona información acerca del dispositivo, incluyendo como actualizarlo y detalles de como solucionar problemas.

-
- -
-

Nota: Las instrucciones no son válidas para el ZTE Open. Si tienes un ZTE Open debes ir al link del ZTE Open

-
- -
-

Nota: La herramienta de actualización que es necesaria para desbloquear el dispositivo (mirar abajo) solo está disponible para Windows en este momento. Sin embargo, hay una manera más complicada de desbloquear el dispositivo en OS X o Linux que es descrita más abajo.

-
- -

El ZTE Open C es el primer dispositivo con las últimas actualizaciones de Firefox os de mediados de 2014 ofreciendo nuevas características incluyendo un acceso al reproductor de música desde la pantalla de bloqueo o la barra de notificaciones y compartir archivos por Bluetooth, permitiendo transferir varios archivos simultaneamente. Los usuarios pueden desplazarse por el dispositivo más rápido con las carpetas inteligentes que agrupan apicaciones o búsquedas de aplicaciones automaticamente en categorías, un sistema de scroll mejorado y aplicaciones del sistema que se inician más rápido.(ej: calendario, contactos, cámara...)

- -

Obtén tu dispositivo

- -

El dispositivo está disponible para comprar en ebay a un precio de 70$

- - - -
-

Nota: Clientes de Francia deben echar un vistazo a la página francesa de MDN para obtener sus respectivos proveedores.

-
- -
-

Nota: Los dispositivos no vienen con ninguna aplicación específica de cada operador o sus servicios y están liberados para todas las variantes de los primeros clientes.

-
- -

Especificaciones del dispositivo

- -

Puedes encontrar más información de sus especificaciones en el listado de especifiaciones del telefono y dispositivo.

- -

Actualizando el software

- -
-

Nota: La comunidad francesa de Mozilla proporciona builds actualizadas del ZTE Open C.

-
- -

Para actualizar el software de tu ZTE Open C, la forma más facil usar las builds disponibles en la página de ZTE. Para encontrar esto, ve al centro de soporte de ZTE, selecciona tu región en la columna derecha, en la columa del centro selecciona Smartphones, y Open C (estándar europeo) o Open C (estándar americano), dependiendo de donde viniera el dispositivo que compraste. Sólo pudimos encontrar el ZTE Open C en España a partir de Agosto del 2014. Luego clickea en Seleccionar para ir a la página de descarga.

- -

Cuandp vayas a descargar una build, deberás encontrar un PDF en un ZIP explicando como instalar la build.

- -

Actualización manual.

- -

Si quieres actualizar Gecko o Gaia tú mismo, el proceso es un poco complicado, porque el teléfono está bloqueado por defecto (no hay permisos root). Para desbloquear tu teléfono, puedes usar la herramienta de actualización del Open C.

- -
-

Nota: Esta herramienta de actualización solo está disponible para Windows por ahora.

-
- -

Si quieres desbloquear tu móvil desde OS X o Linux, esto es lo que tienes que hacer:

- -
    -
  1. Descarga la build desde el link de Comebuy.com
    2. -
  2. Extrae la build del paso 1 y deberás encontrar un archivo boot.img dentro del zip.
    3. -
  3. -

    Añade las siguientes líneas en  in /etc/udev/android.rules :

    - - 
    SUBSYSTEM=="usb", ATTR{idVendor}=="19d2", ATTR{idProduct}=="1350", MODE="0666", GROUP="plugdev"
-SUBSYSTEM=="usb", ATTR{idVendor}=="18d1", ATTR{idProduct}=="d00d", MODE="0666", GROUP="plugdev"
    -
    4. -
  4. Para entrar en el modo fastboot usa los siguientes comandos en tu terminal: - 
     adb reboot-bootloader
    -
    5. -
  5. Para flashear el archivo boot.img del paso 2 al dispositivo, usa este comando: - 
     fastboot flash boot boot.img
    - si lo prefieres, para verificar que fumciona antes de flashear, deberás usar: - - 
     fastboot boot boot.img
    -
    6. -
  6. Para reiniciar el dispositivo usa: - 
     fastboot reboot
    -
    7. -
  7. Ahora deberás tener el móvil desbloqueado y funcionando: - 
    adb shell getprop ro.secure
    - deberás volver al paso 0.
    8. -
- -

Actualizando Gecko y Gaia

- -

Una vez que tu móvil esté en modo fastboot, podrás construir e instalar una nueva versión de Firefox OS/B2G y los componenetes Gecko y Gaia.

- -
    -
  1. Comienza en instrucciones, y trata al Open C como al Flame en términos de configuración: esto es debido a que el Flame y el Open c están basados en Android Jellybean. - -
    -

    Cuidado: Esto no significa que puedas flashear una imagen del Flame. Hacer esto provocará un brick permanente en tu móvil que no podrá ser solucionado.

    -
    -
    2. -
  2. Durante el paso de configuración, necesitarás un archivo manifest para el Open C. Descargalo desde aquí y guardalo en cualquier lugar de tu disco local como openc.xml.
    3. -
  3. Limpia el  directorio B2G, borrando los directorios innecesarios: - 
    rm -rf objdir-gecko/ out/ backup-flame/
    -
    4. -
  4. Opcional: Antes de continuar, puedes escoger la versión de Gecko y Gaia que quieres construir. Para hacer eso, abre el archivo openc.xml, localiza las etiquetas gecko git, gaia y gonk-misc, y modifica el valor de su revisión para coincidir con la versión que quieres. Ejemplo: puedes construir la versión 2.2 de Gecko y Gaia, con lo siguiente: - 
    <project name="gecko.git" path="gecko" remote="mozillaorg" revision="v2.2"/>
-(...)
-<project name="gaia" path="gaia" remote="mozillaorg" revision="v2.2"/>
-<project name="gonk-misc" path="gonk-misc" remote="b2g" revision="v2.2"/>
    -
    5. -
  5. Ahora configura Firefox OS con los siguientes comandos: (Nota: el directorio no puede contener espacios, de otra manera no funcionará) - 
    ./config.sh flame /PATH/TO/openc.xml
    -
    6. -
  6. Puedes construir el componente Gecko y flashearlo en tu teléfono usando lo siguiente: - 
    ./build.sh gecko
-./flash.sh gecko
    - -
    -

    Nota: El último paso del comando flash.sh es para reiniciar el dispositivo, pero la secuencia de inicio no se completará (se congelará cuando salga el zorro animado). No te preocupes, esto es normal.

    -
    -
    7. -
  7. Ahora puedes actualizar Gaia, para que la nueva versión de Gecko funcione con la nueva versión de Gaia en tu dispositivo : - 
    cd gaia
-make reset-gaia
    -
    8. -
  8. Finalmente, puede que necesites actualizar las fuentes.
    9. -
- -
-

Cuidado: Intentar flashear una imagen del Flame dejará tu móvil brickeado.

-
- -

 

- -

Actualizando Gaia

- -

 

- -

Para actualizar solo Gaia, dejando Gecko solo, necesitas clonar el repositorio de Gaia desde Github, luego flashealo en tu dispositivo.

- -
    -
  1. Asegurate de que tienes ADB instalado.
    2. -
  2. Ve a https://github.com/mozilla-b2g/gaia, luego haz click en el botón "fork", situado en la esquina derecha arriba para forkearlo en tu repositorio.
    3. -
  3. Clona el código desde tu repositorio forkeado en tu escritorio ejecutando lo siguiente en tu terminal: - 
    git clone https://github.com/your-github-username/gaia.git
    -
    4. -
  4. Usa el comando cd en el directorio resultante.
    5. -
  5. En tu teléfono, activa la depuración remota (elige ADB y la opción Devtools)
    6. -
  6. Ahora conecta tu móvil al ordenador vía USB; asegurate de que es reconocido metiendo dispositivos adb en tu terminal.
    7. -
  7. Ejecuta los siguientes comandos para reiniciar tu móvil y actualiza con el nuevo código fuente de Gaia. - 
    make reset-gaia
    -
    8. -
- -

Arreglar fuentes

- -

Después de actualizar Gecko/Gaia, puede que encuentres diferencias entre las fuentes de Gecko y Gaia. Para arreglar esto, descarga nuestra actualización de fuentes, extraelo, accede al directorio creado tras la extracción, y ejecuta el script flash.sh.                                                                                                      
-
- Otra opción es usar el script para actualizar las fuentes del sistema, que descarga y flashea las fuentes del sistema automaticamente.

- -

Imágenes del sistema

- -

Si no quieres compilar Gecko y Gaia por ti mismo, puedes usar una imágen compabitle del Flame ofrecida por Mozilla. Siempre que tu teléfono haya sido desbloqueado con la herramienta de ZTE, puedes flashear una imágen del sistema desde el directorio de imágenes de prueba (nightly builds). Este proceso borrará todos tus datos; para hacer una copia de seguridad de tu perfil de usuario usa este script antes de flashear el nuevo sistema.

- -

Elige tu sabor favorito entre mozilla-centra, aurora, o vanilla y elige el entorno Gecko. Todas los directorios de imagen son llamados como "2014-10-06-xx-yy-zz-mozilla-your_flavor-device_codename" así que necesitarás buscar "2014-10-06-xx-yy-zz-mozilla-your_flavor-flame". La imágen de B2G que está dentro del directorio específico de Gecko tiene una versión y lenguaje básico, "b2g-34.0a2.en-US.android-arm.tar.gz" es la versión Gecko 34 y el lenguaje es inglés americano por defecto, descarga "Gaia.zip" si quieres actualizar Gaia también.

- -

Para flashear estos archivos en el dispositivo necesitarás un script llamado shallow_flash; puedes encontrarlo aquí, descarga el script y ejecútalo vía terminal.

- -

En Mac y Cygwin

- -
./shallow_flash.sh -g gaia.zip -G b2g-XX.XX.en-US.android-arm.tar.gz
- -

En Linux

- -
./shallow_flash.sh -ggaia.zip -Gb2g-XX.XX.en-US.android-arm.tar.gz
- -

 

- -

He bloqueado (brick) mi teléfono

- -

Si tu equipo no responde, deberías desbloquearlo (unbrick) utilizando las builds oficiales y las intrucciones para flashearlo vía tarjeta SD, en la página oficial de ZTE.

- - - -

Sin embargo, si la partición de tu sistema es defectuosa, tendrás que repararlo usando directamente el acceso fastboot. Asumiendo que estás utilizando Ubuntu GNU/Linux:

- -
    -
  1. Descarga la imágen del sistema de recuperación desde la página de soporte de ZTE y extrae el archivo update.zip en tu escritorio.
    2. -
  2. Extrae el archivo recovery.img desde update.zip.
    3. -
  3. Crea un directorio small-system/ en el escritorio y copia dentro el archivo build.prop, y los directorios lib/ y bin/ que encontrarás en el archivo update.zip.
    4. -
  4. Instala el paquete android-tools-fsutils ( o instala ext4_utils desde la fuente en XDAdevelopers.
    5. -
  5. Crea tu  small-system.img: - 
    ./make_ext4fs -l 40M small-system.img ~/Desktop/small-system/
    -
    6. -
  6. Mueve el archivo small-system.img a tu escritorio y enciende el dispositivo en modo fastboot presionando el botón power y el botón de bajar volumen a la vez.
    7. -
  7. Conecta el dispositivo a tu ordenador (los dispositivos fastboot se deberían mostrar) y flasea small-system.img - 
    fastboot flash system small-system.img
    -
    8. -
  8. Entonces enciende el móvil en modo recovery usando recovery.img: - 
    fastboot boot recovery.img
    -
    9. -
  9. En el menú de booteo, selecciona la entrada apply udate from ADB (usando volúmen arriba y volumen abajo para navegar y power para seleccionar) y entonces: - 
    adb sideload update.zip
    -
    10. -
  10. -

    Al finalizar el proceso, sólo tienes que reiniciar tu dispositivo.

    -
    11. -
- -
-

Nota: Puedes hacer referencia a esta entrada de soporte para más información.

-
diff --git a/files/es/archive/b2g_os/platform/gaia/hacking/index.html b/files/es/archive/b2g_os/platform/gaia/hacking/index.html deleted file mode 100644 index 22599068e9..0000000000 --- a/files/es/archive/b2g_os/platform/gaia/hacking/index.html +++ /dev/null @@ -1,226 +0,0 @@ ---- -title: Hackeando Gaia -slug: Archive/B2G_OS/Platform/Gaia/Hacking -translation_of: Firefox_OS/Developing_Gaia ---- -
-

Esta página está dirigida a desarrolladores de Gaia. Si usted está buscando información acerca de cómo construir y ejecutar Firefox OS, debería consultar la página de Construyendo e Instalando Firefox OS en su lugar.

-
- -

Gaia es la colección de aplicaciones web que forman la interfaz de Firefox OS. Cualquier cosa que usted vea en la pantalla del Firefox OS es creada usando tecnologías web abiertas. Esto incluye la pantalla de inicio y todas las aplicaciones predeterminadas.

- -

Obteniendo el código fuente

- -

Para obtener el código fuente de Gaia, fork us on GitHub and then clone your fork using git.

- -
$ git clone https://github.com/mozilla-b2g/gaia.git
- -

Ejecutando Gaia

- -

Usted puede ejecutar Gaia en el escritorio, en Firefox, o en un un dispositivo móvil compatible.

- -

B2G desktop

- -

B2G desktop es una versión de escritorio de la aplicación de ejecución utilizada en los dispositivos Firefox OS, la cual puedes utilizar para correr Gaia en tu computadora de escritorio.

- -

Puedes descargar una versión nightly de B2G desktop desde aquí.Dependiendo de qué versión estés utilizando, puede que quieres una versión específica de latest-mozilla-b2g18. Hay versiones para Linux (32 bits y 64 bits), Mac OS X y Windows.

- -

Las versiones Nightly tienen empaquetadas con ellas una versión reciente de Gaia. Una vez que hayas descargado el archivo, todo lo que necesitas es extraerlo en una carpeta y correr el binario de b2g desde la carpeta extraída.

- -
-

Nota: Las versiones de 64-bits de Linux no funcionan correctamente con algunas distribuciones, se trata del error 812484. Si tienes problemas trata con una versión de 32-bits en lugar de una de 64-bits

-
- -
$ cd b2g
-$ ./b2g
- -

Para correr B2G con tu propia versión de Gaia para propósitos de desarrollo primero necesitas una construir una versión de tu copia:

- -
$ cd /path/to/gaia
-$ DEBUG=1 make
- -

Esto generara un directorio en tu carpeta gaia llamada profile. La parte DEBUG correo Gaia como aplicaciones locales en servidor-web interno, en lugar las aplicaciones empaquetadas por defecto, estas tienen que ser re-empaquetadas después de cada cambio. Puedes encontrar la ruta del perfil de directorio tomando un vistazo a la última línea de salida después de ejecutar el comando de abajo, que debería verse así:

- -
Profile Ready: please run [b2g|firefox] -profile /path/to/gaia/profile
- -

Puedes entonces correr B2G Desktop con tu perfil generado como se indica abajo:

- -
$ ./b2g /path/to/gaia/profile
- -

Si quieres puedes compilar tu propio B2G desktop desde el código.

- -

Usando Gaia en Firefox

- -

It's also possible to run Gaia inside of Firefox. This gives you the advantages of having a rapid development cycle, as well as standard web development tools and debuggers. See Using Gaia in Firefox for details on how to do this.

- -

Usando Gaia en un dispositivo

- -

If you have a compatible mobile device you can also run Gaia by flashing it with Firefox OS. See Building and installing Firefox OS for details on how to do this. We also have documentation for how to test Firefox OS.

- -

Unidad de pruebas

- -

See Gaia unit tests for documentation about how to create and run unit tests for Gaia.

- -

Presentando errores

- -

Bugs are filed on Bugzilla under Firefox OS > Gaia. File a new bug under the Gaia component (or one of the sub-components).

- -

Contribuyendo a Gaia

- -

Mozilla depends on contributions from the open source community to help develop Gaia apps and we'd love you to get involved.

- -

Some great places to find some bugs to start hacking on:

- - - -

Estilos de codificación básicos

- - - -

Reglas Adicionales

- -

Mal:

- -
if (expression) doSomething();
-
- -

Correcto:

- -
if (expression) {
-  doSomething();
-}
-
- -

If you're working on the system app, check out the guidance listed here.

- -

Before submitting a patch we recommend you run gjslint on it to check for any style errors:

- -
gjslint --nojsdoc my_file.js
- -

Enviando un parche

- -

First file or assign a bug to yourself on Bugzilla, you'll need a Bugzilla account.

- -

Then create a branch on your fork of Gaia:

- -
$ git branch branchname
-$ git checkout branchname
- -

Commit your changes:

- -
$ git add /file/to/add
-$ git commit -m "Bug XXXXX - Fix the broken Gaia and save the world"
- -

Push your branch:

- -
$ git push origin branchname
- -

Send a pull request by navigating to the branch in your fork on GitHub and finding the pull request button.

- -

To request a review of your patch, add an attachment to the bug in Bugzilla referencing the URL of the pull request and set the review ("r") flag to "?" and enter the bugzilla ID of one of the module owners and peers. The Github tweaks for bugzilla extension on AMO can help automate this process by automatically creating the attachment and adding it to the bug; you will still need to set the review flag on Bugzilla.

- -

The reviewer may ask you to make some changes. Once they're is happy with your patch, they will merge it into the master branch for you. Before they do this they would prefer it if you could squash all your changes into a single commit, so your contribution can be tracked easily.

- -

The person who merge the commit (usually the reviewer) would add a r= flag in the comment of the merge commit.

- -

Opciones de Make

- -

There are many undocumented nor unsupported environment variable presists in the Makefile. Do not depend on them as they may be removed in the future.

- -

Default

- -
make
- -

Make a profile with packaged apps, lunachable by B2G Desktop and can be pushed to device.

- -

Debug make

- -
DEBUG=1 make
- -

The DEBUG part runs Gaia as hosted apps on a built-in web server, rather than the default packaged apps which have to be re-packaged after every change. Launch the profile with the latest Firefox Nightly will also give you nice B2G specific panels on the Firefox Developer Tools.

- -

Push to device

- -
make install-gaia
-
-make reset-gaia
- -

With adb (Android Debug Bridge) setup, these make targets will push Gaia to the device. reset-gaia will purge the profile and all other webapps before pushing the new Gaia copy.

- -

Selective build

- -
APP=system make
-
-APP=system make install-gaia
- -

With a profile already exists, APP allow you to specify which app to re-package, instead of re-pack and re-push all the Gaia apps.

- -

High resolution image assets

- -
GAIA_DEV_PIXELS_PER_PX=1.5 make
- -

When packaging the app, replace images with their *@1.5x.(gif|jpg|png) ones if such image exists.

- -

Gaia is currently targetting HBGA (320x240), qHD (540×960) and WVGA (480×800) only; use GAIA_DEV_PIXELS_PER_PX to make sure the images looks sharp on qHD and WVGA devices. see A pixel is not a pixel for more information about device pixels per css pixels.

- -

Script compression and optimization

- -
GAIA_OPTIMIZE=1 make
- -

(TBA)

- -

App selection

- -
GAIA_APP_SRCDIRS=apps test_apps showcase_apps
- -

(TBA)

- -

App selection shortcuts

- -
PRODUCTION=1
-DOGFOOD=1
- -

(TBA)

- -

Preference shortcuts

- -
NOFTU=1
-REMOTE_DEBUGGER=1
- -

(TBA)

- -

Device webapp installation partation selection

- -
B2G_SYSTEM_APPS=1
- -

(TBA)

- -

Distribution and market customization build

- -
GAIA_DISTRIBUTION_DIR=./dir
- -

Read Customization Overview for detail.

- -

Contacting the Team

- - diff --git a/files/es/archive/b2g_os/platform/gaia/index.html b/files/es/archive/b2g_os/platform/gaia/index.html deleted file mode 100644 index f8664fd4ee..0000000000 --- a/files/es/archive/b2g_os/platform/gaia/index.html +++ /dev/null @@ -1,61 +0,0 @@ ---- -title: Gaia -slug: Archive/B2G_OS/Platform/Gaia -tags: - - '#B2G #gaia' -translation_of: Archive/B2G_OS/Platform/Gaia ---- -

Gaia es la capa de interfaz de usuario de Firefox OS. Todo lo que aparece en la pantalla luego que Firefox OS inicia es presentado por Gaia, incluyendo la pantalla de bloqueo, el marcador y otras aplicaciones. Gaia está completamente escrito en HTML, CSS, y JavaScript. Su única interfaz al sistema operativo y hardware subyacentes es a través de interfaces web estándar (Web API), implementadas por Gecko.

-

Por su diseño, Gaia puede ser ejecutado no solo en dispositivos Firefox OS, sino en otros sistemas operativos y otros navegadores (aunque posiblemente con funcionalidad reducida dependiendo de las capacidades del navegador).

-

Aplicaciones de terceros instaladas junto a Gaia pueden ser cargados por Gaia.

- - - - - - - -
-

Documentación sobre Gaia

-
-
- Introducción a Gaia
-
- Gaia es la intefaz de usuario para dispositivos Firefox OS; Es simplemente una aplicación web corriendo en la parte superior de Firefox OS. Esta guia te introducirá a Gaia.
-
- Guía para hackear Gaia
-
- La guía para hackear y modificar la interfaz de Gaia.
-
-

Ver todas...

- 		-

Obteniendo ayuda de la comunidad

-

Si estas trabajando en Gaia, o desarrollando aplicaciones para Gaia, estos son los recursos de la comunidad para ayudarte

- -
    -
  • Haz tus preguntas en el canal Gaia del irc de Mozilla: #gaia
    • -
-

No olvides como hacer adecuadamente tus preguntas...

-
- - -

Recursos

- -
-


-  

diff --git a/files/es/archive/b2g_os/platform/gaia/introduction_to_gaia/index.html b/files/es/archive/b2g_os/platform/gaia/introduction_to_gaia/index.html deleted file mode 100644 index 14c7fb3e16..0000000000 --- a/files/es/archive/b2g_os/platform/gaia/introduction_to_gaia/index.html +++ /dev/null @@ -1,13 +0,0 @@ ---- -title: Introducción a Gaia -slug: Archive/B2G_OS/Platform/Gaia/Introduction_to_Gaia -translation_of: Archive/B2G_OS/Platform/Gaia/Introduction_to_Gaia ---- -

Gaia es la interfaz de usuario de Boot to Gecko (B2G); es un conjunto de aplicaciones Web que se ejecutan en un dispositivo B2G, emulador, repertorio de escritorio, o versión de Firefox. Todo lo que necesitas conocer para añadir aplicaciones o realizar cambios a Gaia son tecnologías Web como JavaScript, HTML, and CSS.

-

Pantalla de bloqueo de Gaia

-

Predeterminadamente, la pantalla de bloqueo está habilitada, y el PIN por defecto para desbloquear el equipo es "0000". Es muy probable que esta característica cambie con el tiempo mientras es optimizada.

-

La interfaz por defecto de Gaia

-

La interfaz por defecto en Gaia es similar a lo que se observa en la mayoría de los teléfonos inteligentes, como se muestra aquí.

-

Gaia HomeEsta imagen es evidentemente de una versión preliminar del sistema operativo, con iconos de relleno (y algunas aplicaciones de prueba). La barra de estado en la parte superior indica la red en la que el teléfono está operando (o "No hay tarjeta SIM" para un dispositivo sin ninguna red telefónica), la intensidad de la red, la intensidad de la señal WiFi, nivel de batería, y la hora actual.

-

La sección media de la pantalla muestra los iconos de las aplicaciones; al deslizar hacia la izquierda y derecha se desplaza a través de pantallas de iconos.

-

En la parte inferior de la pantalla se localiza una barra con espacio para hasta siete de las aplicaciones más usadas. Puedes arrastrar y soltar aplicaciones a esta barra desde la sección media.

diff --git a/files/es/archive/b2g_os/platform/index.html b/files/es/archive/b2g_os/platform/index.html deleted file mode 100644 index 1e6dda531b..0000000000 --- a/files/es/archive/b2g_os/platform/index.html +++ /dev/null @@ -1,94 +0,0 @@ ---- -title: La Plataforma Firefox OS -slug: Archive/B2G_OS/Platform -translation_of: Archive/B2G_OS/Platform ---- -

La Plataforma Firefox OS esta formada por varios componenetes. No obstante no es necesario comprender su arquitectura para desarrollar aplicaciones que funcionen en Firefox OS, si estás trabajando en el desarrollo o adaptación de esta plataforma, o simplemente estás curioseando, esta documentación puede resultar de tu interés.

- - - - - - - -
-

DocumentaCion sobre la plataforma Firefox OS

-
-
- Introducción al Firefox OS
-
- Información introductoria sobre qué y cómo trabaja Firefox OS.
-
- Instalación y Montaje de Firefox OS
-
- Una guía para Instalar y Montar Firefox OS en terminales compatibles. Esta guía además incluye un emulador para poder arrancar Firefox OS en un PC.
-
- Gaia
-
- Documentacion sobre Gaia, la interfaz de usuario para los dispositivos Firefox OS; se trata de una Aplicación Web que se ejecuta en el propio dispositivo plataformado con Firefox OS.
-
- Gonk
-
- Documentación sobre Gonk, la capa del sistema operativo sobre el que corre Gaia. Está formado por un nucleo de Linux (Linux kernel) y una capa de drivers que permiten la comunicación entre Gecko y el propio dispositivo.
-
- Gecko
-
- Gecko es la capa de Firefox OS que proporciona a la plataforma los mismos estándares web abiertos, utilizados por Firefox y Thunderbird, así como muchas otras aplicaciones.
-
- Feature support chart
-
- A chart of which features are available in which types of Firefox OS builds.
-
- Firefox OS architecture overview
-
- An overview of how Firefox OS is structured internally; this is primarily of interest to platform developers and people doing porting work.
-
- Firefox OS apps architecture
-
- An overview of the application model on Firefox OS.
-
- Testing Firefox OS
-
- A guide to testing Firefox OS, including information about creating automated tests.
-
- Porting Firefox OS
-
- Information about how to port Firefox OS to new devices.
-
- Customization with the .userconfig file
-
- How to customize the build and execution of Firefox OS by changing the .userconfig file.
-
-

View All...

- 		-

Getting help from the community

-

If you're working with Firefox OS, or developing applications you'd like to run on Firefox OS devices, there are community resources to help you!

- -
    -
  • Ask your question on Mozilla's Boot to Gecko IRC channel: #b2g
    • -
-

Don't forget about the netiquette...

-
- - -

Resources

- -
-

 

diff --git a/files/es/archive/b2g_os/platform/settings_list/index.html b/files/es/archive/b2g_os/platform/settings_list/index.html deleted file mode 100644 index d5397affd8..0000000000 --- a/files/es/archive/b2g_os/platform/settings_list/index.html +++ /dev/null @@ -1,709 +0,0 @@ ---- -title: Firefox OS settings list -slug: Archive/B2G_OS/Platform/Settings_list -translation_of: Archive/B2G_OS/Platform/Settings_list ---- -
-

Firefox OS offers a number of settings that configure the device and its built-in features. These settings can be accessed by certified apps using the Settings API.

-
-
-

Note: Because of differences in features provided by different devices and different releases of Firefox OS, this list may or may not be an exact match for what's available on every device.

-
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Setting nameTypeDefault value
accessibility.invertBooleanfalse
accessibility.screenreaderBooleanfalse
alarm.enabledBooleanfalse
app.reportCrashesStringask
app.update.intervalNumber86400
audio.volume.alarmNumber15
audio.volume.bt_scoNumber15
audio.volume.dtmfNumber15
audio.volume.contentNumber15
audio.volume.notificationNumber15
audio.volume.ttsNumber15
audio.volume.telephonyNumber5
bluetooth.enabledBooleanfalse
bluetooth.debugging.enabledBooleanfalse
camera.shutter.enabledBooleantrue
clear.remote-windows.dataBooleanfalse
debug.grid.enabledBooleanfalse
debug.oop.disabledBooleanfalse
debug.fps.enabledBooleanfalse
debug.ttl.enabledBooleanfalse
debug.log-animations.enabledBooleanfalse
debug.paint-flashing.enabledBooleanfalse
debug.peformancedata.sharedBooleanfalse
deviceinfo.firmware_revisionString 
deviceinfo.hardwareString 
deviceinfo.osString 
deviceinfo.platform_build_idString 
deviceinfo.platform_versionString 
deviceinfo.softwareString 
deviceinfo.update_channelString 
gaia.system.checkForUpdatesBooleanfalse
general.useragent.updates.enabledBooleantrue
geolocation.enabledBooleantrue
keyboard.layouts.englishBooleantrue
keyboard.layouts.dvorakBooleanfalse
keyboard.layouts.otherlatinsBooleanfalse
keyboard.layouts.cyrillicBooleanfalse
keyboard.layouts.arabicBooleanfalse
keyboard.layouts.hebrewBooleanfalse
keyboard.layouts.zhuyinBooleanfalse
keyboard.layouts.pinyinBooleanfalse
keyboard.layouts.greekBooleanfalse
keyboard.layouts.japaneseBooleanfalse
keyboard.layouts.polishBooleanfalse
keyboard.layouts.portugueseBooleanfalse
keyboard.layouts.spanishBooleanfalse
keyboard.vibrationBooleanfalse
keyboard.clicksoundBooleanfalse
keyboard.autocorrectBooleantrue
keyboard.wordsuggestionBooleantrue
keyboard.currentStringen
language.currentStringen-US
lockscreen.passcode-lock.codeString0000
lockscreen.passcode-lock.timeoutNumber0
lockscreen.passcode-lock.enabledBooleanfalse
lockscreen.notifications-preview.enabledBooleantrue
lockscreen.enabledBooleantrue
lockscreen.lockedBooleantrue
lockscreen.unlock-sound.enabledBooleanfalse
mail.sent-sound.enabledBooleantrue
message.sent-sound.enabledBooleantrue
operatorvariant.mccString0
operatorvariant.mncString0
ril.iccInfo.mbdnString 
ril.sms.strict7BitEncoding.enabledBooleanfalse
ril.cellbroadcast.searchlistString 
debug.console.enabledBooleanfalse
phone.ring.keypadBooleantrue
powersave.enabledBooleanfalse
powersave.thresholdNumber0
privacy.donottrackheader.enabledBooleanfalse
ril.callwaiting.enabled  
ril.cf.enabledBooleanfalse
ril.data.enabledBooleanfalse
ril.data.apnString 
ril.data.carrierString 
ril.data.defaultServiceIdNumber0
ril.data.passwdString 
ril.data.httpProxyHostString 
ril.data.httpProxyPortNumber0
ril.data.mmscString 
ril.data.mmsproxyString 
ril.data.mmsportNumber0
ril.data.roaming_enabledBooleanfalse
ril.data.userString 
ril.mms.apnString 
ril.mms.carrierString 
ril.mms.httpProxyHostString 
ril.mms.httpProxyPortString 
ril.mms.mmscString 
ril.mms.mmsportString 
ril.mms.mmsproxyString 
ril.mms.passwdString 
ril.mms.userString 
ril.radio.preferredNetworkTypeString 
ril.radio.disabledBooleanfalse
ril.supl.apnString 
ril.supl.carrierString 
ril.supl.httpProxyHostString 
ril.supl.httpProxyPortString 
ril.supl.passwdString 
ril.supl.userString 
ril.sms.strict7BitEncoding.enabledBooleanfalse
ril.sms.defaultServiceIdNumber0
ril.telephony.defaultServiceIdNumber0
ring.enabledBooleantrue
screen.automatic-brightnessBooleantrue
screen.brightnessNumber1
screen.timeoutNumber60
tethering.usb.enabledBooleanfalse
tethering.usb.ipString192.168.0.1
tethering.usb.prefixString24
tethering.usb.dhcpserver.startipString192.168.0.10
tethering.usb.dhcpserver.endipString192.168.0.30
tethering.wifi.enabledBooleanfalse
tethering.wifi.ipString192.168.1.1
tethering.wifi.prefixString24
tethering.wifi.dhcpserver.startipString192.168.1.10
tethering.wifi.dhcpserver.endipString192.168.1.30
tethering.wifi.ssidStringFirefoxHotspot
tethering.wifi.security.typeStringopen
tethering.wifi.security.passwordString1234567890
tethering.wifi.connectedClientsNumber0
tethering.usb.connectedClientsNumber0
time.nitz.automatic-update.enabledBooleantrue
time.timezone  
ums.enabledBooleanfalse
ums.modeNumber0
vibration.enabledBooleantrue
wifi.enabledBooleantrue
wifi.screen_off_timeoutNumber600000
wifi.disabled_by_wakelockBooleanfalse
wifi.notificationBooleanfalse
wifi.connect_via_settingsBooleanfalse
icc.displayTextTimeoutNumber40000
icc.inputTextTimeoutNumber40000
-

See also

- diff --git a/files/es/archive/b2g_os/portando/index.html b/files/es/archive/b2g_os/portando/index.html deleted file mode 100644 index 6dada46208..0000000000 --- a/files/es/archive/b2g_os/portando/index.html +++ /dev/null @@ -1,369 +0,0 @@ ---- -title: Portando a Boot to Gecko -slug: Archive/B2G_OS/Portando -tags: - - B2G - - portar - - porting -translation_of: Archive/B2G_OS/Porting_B2G_OS/basics ---- -

Boot to Gecko (FirefoxOS) utiliza un kernel derivado de Android, con una interfaz de usuario basada en Gecko sobre él. Este artículo provee la guía básica de cómo portar el sistema operativo en nuevos dispositivos.

-

Esta guía asume que tu estas portando en un dispositivo nuevo que está funcionando con Andriod; Si estás portando a otro dispositivo, el trabajo va a ser más enredado.

-

Prequisitos

-

Configurando la compilación de tu sistema

-

El primer paso es configurar la compilación del sistema; puedes seguir la guía en prerequisitos para compilar B2G.

-

Crear una copia de seguridad local del sistema original de Android

-

A continuación, deberás hacer una copia de seguridad de tu dispositivo Android antes de empezar a bombardearlo con tu compilación de pruebas de B2G. Además, algunos de estos comandos serán necesarios para el proceso de compilación e instalación.

-
mkdir my_device_backup
-cd my_device_backup
-adb pull /system system
-
-

Nota: Esto es opcional pero es recomendado, ya que algunas veces es posible tener perdidas mayores ocasionadas por problemas de compilaciones, en donde si no posees una copia de los archivos propietarios de tu telefono, lo mas probable es que el problema sea irreparable.

-
-

B2G

-

Crea un fork del repositorio de B2G

-

Para esto necesitas una cuenta en Github.com, si no la tienes, creala y luego realiza un fork del siguiente repositiorio:

-
https://github.com/mozilla-b2g/B2G
-

Si no sabes como crear un fork de un repositorio en visita este sitio para obtener ayuda.

-

Clona tu repositorio de B2G

-

Una vez hecho el fork anterior, para empezar a portar B2G a tu nuevo dispositivo, es necesario que clones el repositiorio en tu equipo, clonamos el reposiorio de la siguiente manera:

-
git clone https://github.com/Your-User-Name/B2G.git
-
-

Remplaza Your-User-Name con el usuario de tu cuenta de Github.

-
-

Agrega un nuevo dispositivo al config.sh

-

El siguiente paso, es agregar un nuevo dispositivo a config.sh; puedes usar uno de los existentes como plantilla. Esto básicamente consiste en proporcionar las instruciones para obtener los archivos correctos para hacer la compilación.

-

Busca la linea siguiente en tu archivo config.sh:

-
case "$1" in
-

Seguidamente agrega:

-
"device-name")
-
-echo DEVICE=device-name >> .tmp-config &&
-
-repo_sync $1
-
-;;
-
-

Nota: Debes remplazar la parte en que dice device-name, con el nombre de tu dispositivo, como por ejemplo si tu dispositivo fuera el Samsung Galaxy S3, quedaria asi:

- 
"i9300")
-
-echo DEVICE=i9300 >> .tmp-config &&
-
-repo_sync $1
-
-;;
-
-

Como ultimo paso (opcional, no influye en nada si realizas o no este paso), buscas esta parte en tu archivo config.sh:

-
echo Usage: $0 \(device name\)
-
-echo
-
-echo Valid devices to configure are:
-
-echo - galaxy-s2
-
-echo - galaxy-nexus
-
-echo - nexus-s
-
-echo - nexus-s-4g
-
-echo - otoro
-
-echo - unagi
-
-echo - pandaboard
-
-echo - emulator
-
-echo - emulator-x86
-
-exit -1
-
-;;
-

Y agregas tu dispositivo:

-
echo - device-name
-
-
-

Nota: Debes remplazar la parte en que dice device-name, con el nombre de tu dispositivo, como por ejemplo si tu dispositivo fuera el Samsung Galaxy S3, quedaria asi:

- 
echo - i9300
-
-

Crear un árbol de configuración para el nuevo dispositivo

-

Este arbol de configuracion debe incluir, al menos:

- -

El contenido aquí puede variar en gran medida entre un dispositivo y otro. En particular, BoardConfig.mk y extract-files.sh podrían variar significativamente. Esta parte requiere un conjunto de hacking, pruebas, y depuración para averiguar que pedazos binarios deberán ser extraidos. Este arbol de configuracion debe estar hosteado en un repo en tu cuenta de Github, mira este repositorio de ejemplo para que te hagas una idea de como tiene que quedar. (Solo es un ejemplo y no tiene que quedar igual a este, todos los telefonos tienen distinto Hardware)

-
-

Nota: No es necesario que crees estos archivos por tu propia cuenta, por lo general la mayoria de los telefonos y dispositivos que corren CyanogenMod o AOKP tienen un repositorio en Github con todos estos archivos del arbol de configuracion, puedes distinguirlos, porque la mayoria de estos repositorios llevan el nombre de: ej "android_device_samsung_i9300" (como es en este caso ejemplo, el nombre varia dependiendo de tu dispositivo). Asi que es recomendable que antes de que empieces a crear estos archivos por tu cuenta, revises algunos de los repositorios de CyanogenMod o AOKP, para ver si el arbol de configuracion de tu dispositivo ya esta creado por alguien mas.

-

Caso contrario ocurre con los dispositivos ZTE o algunos otros dispositivos a los cuales CyanogenMod o AOKP aun no han llegado, que requieren que crees estos archivos por tu propia cuenta desde 0. El Foro XDA  es otro buen lugar para debatir y ver recursos.

-
-

Una vez que tengas estos archivos, si te ha tocado crearlos desde 0 o tienes los archivos del arbol de configuracion en tu equipo, es totalmente necesario que los subas a un repositorio en tu cuenta de Github como se habia mencionado anteriormente. Si no sabes como crear el repositorio en donde alojar tus archivos de configuracion, por favor revisa esta guia. Al final del proceso deberas tener un repositorio como este:

-
https://github.com/Your-User-Name/android-device-your-new-device
-
-

En donde dice Your-User-Name deberia aparecer tu nombre de usuario de tu cuenta en Github, y en donde dice android-device-new-device, deberia aparecer el nombre que le has puesto a tu repositiorio cuando estabas creandolo. (ej: android-device-samsung-i9300)

-
-

Si por el contrario has tenido suerte de encontrar que CyanogenMod o AOKP, o algun otro usuario ya ha creado estos archivos, tienes que hacer un fork del repo en tu cuenta. En pocas palabras, es necesario que tengas todos los repos de tu dispositivo ha realizar el port de FirefoxOS, alojados en tu cuenta de Github.

-

El Archivo Manifest

-

Crea un fork del repositorio b2g-manifest

-

De nuevo realizamos un fork al repositorio de b2g-manifest.

-
https://github.com/mozilla-b2g/b2g-manifest
-

Si no sabes como crear un fork de un repositorio en visita este sitio para obtener ayuda.

-
-

Este fork tiene que quedar igualmente en tu cuenta de Github.

-
-

Crea tu propio repositorio de b2g-manifest

-

Una vez mas, es necesario que el repositorio que acabas de clonar en el paso anterior, sea hosteado por una cuenta de Github tuya en donde puedas hacer las modificaciones especiales para tu dispositivo. Quedando de la siguiente manera:

-
git clone https://github.com/Your-User-Name/b2g-manifest.git
-

Crear el archivo de manifiesto para el nuevo dispositivo

-

Ahora necesitas agregar los repositorios requeridos para el archivo de manifiesto para el nuevo dispositivo; este archivo de manifiesto es llamado device-name.xml (el nombre de este archivo debe ser cambiado por el nombre de tu dispositivo, conservando la extension que lo caracteriza, el .xml). Este archivo debe tener la siguiente estructura:

-
- 
<?xml version="1.0" encoding="UTF-8"?>
-
-<manifest>
-
-
-  <remote name="aosp"
-
-           fetch="https://android.googlesource.com/" />
-
-  <remote name="b2g"
-
-          fetch="git://github.com/mozilla-b2g/" />
-
-  <remote name="linaro"
-
-           fetch="git://android.git.linaro.org/" />
-
-  <remote name="mozilla"
-
-fetch="git://github.com/mozilla/" />
-
-  <remote name="mozillaorg"
-
-      fetch="https://git.mozilla.org/releases" />
-
-  <default revision="refs/tags/android-4.0.4_r1.2"
-
-           remote="linaro"
-
-           sync-j="4" />
-
-
-  <!-- Gonk specific things and forks -->
-
-  <project path="build" name="platform_build" remote="b2g" revision="master">
-
-    <copyfile src="core/root.mk" dest="Makefile" />
-
-  </project>
-
-  <project path="dalvik" name="fake-dalvik" remote="b2g" revision="master" />
-
-  <project path="gaia" name="gaia.git" remote="mozillaorg" revision="master" />
-
-  <project path="gecko" name="gecko.git" remote="mozillaorg" revision="master" />
-
-  <project path="gonk-misc" name="gonk-misc" remote="b2g" revision="master" />
-
-  <project path="rilproxy" name="rilproxy" remote="b2g" revision="master" />
-
-  <project path="external/moztt" name="moztt" remote="b2g" revision="master" />
-
-
-  <!-- Stock Android things -->
-
-  <project path="abi/cpp" name="platform/abi/cpp" />
-
-  <project path="bionic" name="platform/bionic" />
-
-  <project path="bootable/recovery" name="platform/bootable/recovery" />
-
-  <project path="device/common" name="device/common" />
-
-  <project path="device/sample" name="device/sample" />
-
-  <project path="external/apriori" name="platform_external_apriori" remote="b2g" revision="master" />
-
-  <project path="external/bluetooth/bluez" name="platform/external/bluetooth/bluez" />
-
-  <project path="external/bluetooth/glib" name="platform/external/bluetooth/glib" />
-
-  <project path="external/bluetooth/hcidump" name="platform/external/bluetooth/hcidump" />
-
-  <project path="external/bsdiff" name="platform/external/bsdiff" />
-
-  <project path="external/bzip2" name="platform/external/bzip2" />
-
-  <project path="external/dbus" name="platform/external/dbus" />
-
-  <project path="external/dhcpcd" name="platform/external/dhcpcd" />
-
-  <project path="external/dnsmasq" name="platform/external/dnsmasq" />
-
-  <project path="external/elfcopy" name="platform_external_elfcopy" remote="b2g" revision="master" />
-
-  <project path="external/elfutils" name="platform_external_elfutils" remote="b2g" revision="master" />
-
-  <project path="external/expat" name="platform/external/expat" />
-
-  <project path="external/fdlibm" name="platform/external/fdlibm" />
-
-  <project path="external/flac" name="platform/external/flac" />
-
-  <project path="external/freetype" name="platform/external/freetype" />
-
-  <project path="external/giflib" name="platform/external/giflib" />
-
-  <project path="external/gtest" name="platform/external/gtest" remote="linaro" revision="master" />
-
-  <project path="external/harfbuzz" name="platform/external/harfbuzz" />
-
-  <project path="external/icu4c" name="platform/external/icu4c" />
-
-  <project path="external/iptables" name="platform/external/iptables" />
-
-  <project path="external/jpeg" name="platform/external/jpeg" />
-
-  <project path="external/libgsm" name="platform/external/libgsm" />
-
-  <project path="external/liblzf" name="platform/external/liblzf" />
-
-  <project path="external/libnfc-nxp" name="platform/external/libnfc-nxp" />
-
-  <project path="external/libnl-headers" name="platform/external/libnl-headers" />
-
-  <project path="external/libpng" name="platform/external/libpng" />
-
-  <project path="external/libvpx" name="platform/external/libvpx" />
-
-  <project path="external/mksh" name="platform/external/mksh" />
-
-  <project path="external/opensans" name="platform_external_opensans" remote="b2g" revision="master" />
-
-  <project path="external/openssl" name="platform/external/openssl" />
-
-  <project path="external/protobuf" name="platform/external/protobuf" />
-
-  <project path="external/safe-iop" name="platform/external/safe-iop" />
-
-  <project path="external/screencap-gonk" name="screencap-gonk" remote="b2g" revision="master" />
-
-  <project path="external/sonivox" name="platform/external/sonivox" />
-
-  <project path="external/speex" name="platform/external/speex" />
-
-  <project path="external/sqlite" name="platform/external/sqlite" />
-
-  <project path="external/stlport" name="platform/external/stlport" />
-
-  <project path="external/strace" name="platform/external/strace" />
-
-  <project path="external/tagsoup" name="platform/external/tagsoup" />
-
-  <project path="external/tinyalsa" name="platform/external/tinyalsa" />
-
-  <project path="external/tremolo" name="platform/external/tremolo" />
-
-  <project path="external/webp" name="platform/external/webp" />
-
-  <project path="external/webrtc" name="platform/external/webrtc" />
-
-  <project path="external/wpa_supplicant" name="platform/external/wpa_supplicant" />
-
-  <project path="external/wpa_supplicant_8" name="platform/external/wpa_supplicant_8" />
-
-  <project path="external/zlib" name="platform/external/zlib" />
-
-  <project path="external/yaffs2" name="platform/external/yaffs2" />
-
-  <project path="frameworks/base" name="platform/frameworks/base" />
-
-  <project path="frameworks/opt/emoji" name="platform/frameworks/opt/emoji" />
-
-  <project path="frameworks/support" name="platform/frameworks/support" />
-
-  <project path="hardware/libhardware" name="platform/hardware/libhardware" />
-
-  <project path="hardware/libhardware_legacy" name="platform/hardware/libhardware_legacy" />
-
-  <project path="hardware/ril" name="platform/hardware/ril" />
-
-  <project path="libcore" name="platform/libcore" />
-
-  <project path="ndk" name="platform/ndk" />
-
-  <project path="prebuilt" name="platform/prebuilt" />
-
-  <project path="system/bluetooth" name="platform/system/bluetooth" />
-
-  <project path="system/core" name="platform/system/core" />
-
-  <project path="system/extras" name="platform/system/extras" />
-
-  <project path="system/media" name="platform/system/media" />
-
-  <project path="system/netd" name="platform/system/netd" />
-
-  <project path="system/vold" name="platform/system/vold" />
-
-
-  <!-- Cosas de tu dispositivo  -->
-
-
-
-</manifest>
-

El archivo manifesto es muy facil de crear, simplemente necesitaras el codigo anterior y entenderlo un poco. Copia el codigo anterior

-

Booteo de B2G

-
-

Recompilar boot.img

-

Una vez lo tengas todo hecho, necesitas recompilar la imágen de arranque. Esto no suele ser necesario para el propio Kernel, pero recoge los cambios en  init.rc.

-

Cambios a init.rc

-

El init.rc que utilizas no es el proporcionado por B2G; en su lugar, tienes que tirarlo desde el dispositivo

-

Las principales cosas que necesitarás modificar son:

-
Importar init.b2g.rc
-

Añade las siguientes líneas para importar init.b2g.rc:

-
on early-init
-    start ueventd
-    import /init.b2g.rc
-
Fijar permisos
-

Corrige los permisos en los archivos /system/b2g/b2g, /system/b2g/updater, /system/b2g/plugin-container; esto se deberá hacer después de las líneas que montan los archivos del sistema de lectura/escritura:

-
chmod 0755 /system/b2g/b2g
-chmod 0755 /system/b2g/updater
-chmod 0755 /system/b2g/plugin-container
-

Es posible que quieras iniciar modificando init.rc del nuevo dispositivo en vez de usar el init.rc proveido por la compilación del sistema; si es así, necesitas recordar configurar TARGET_PROVIDES_INIT_RC en BoardConfig.mk.

-

Kernel precompilado vs. compilando el kernel desde una fuente

-

Puedes usar un Kernel precompilado, o podrías compilar el Kernel desde una fuente. Para compilar el Kernel desde una fuente, añade AndroidKernel.mk  y la configuración del kernel al árbol de configuración del dispositivo.

-

El maguro en la vieja compilación del sistema es un ejemplo de compilación del kernel desde una fuente.

-

Flasheo del dispositivo

-

Añade el nuevo dispositivo a flash.sh

-

Añade el nuevo dispositivo a  flash.sh; las especificaciones de como hacer esto dependerán de que herramientas necesitas usar para flashear el nuevo dispositivo.

-

Primer arranque

-

Configura, compila y  flashea el nuevo dispositivo

-

Ahora puedes probar compilando y flasheando tu nuevo dispositivo:

-
ANDROIDFS_DIR=my_device_backup ./config.sh <device_id> default.xml
-./build.sh
-./flash.sh
-

Probar y depurar

-

Necesitamos añadir algunos detalles aqui; de hecho, este artículo podría usar algo de ayuda.

-

FAQ

-

¿A que dispiositivos se le puede hacer Port?

-

Si tu dispositivo corre Android 4.0.4 lo mas probable es que pueda correr FirefoxOS, no obstante no quiere decir que a la primera correra sin ningun problema. El Porting es todo un proceso de prueba y error, es posible que tardes mas tiempo solucionando problemas en los archivos que compiles, que recopilandolos todos.

-

Mi dispositivo es de arquitectura ARMv6, ¿correra alli?

-

Puede que si o puede que no, todo depende de tus conocimientos y de hasta donde puedas llegar con el Port, por ahora solo se conoce un caso en los foros de Geeksphone en donde un usuario a logrado completar un Port estable a uno de los telefonos que ofrece Geeksphone de arquitectura ARMv6.

-

¿Alguien mas esta trabajando en realizar Port a los diferentes dispositivos?

-

Quienes realizan los Port son desarrolladores, geeks o mozillians. No se puede definir un equipo especial de Mozilla que este trabajando en ello. Por otro lado la comunidad Mozilla Hispano tiene un proyecto conformado por un grupo de personas con el fin de lograr el Port a varios dispositivos. Para mas informacion puedes visitar este link.

-

¿Necesito algunos conocimientos previos para empezar a realizar el Port?

-

Si, de hecho hay dos tipos de casos que pueden suceder mientras realices el Port. El primero de ellos es que tengas la suerte de que todos los sources y archivos que encuentre en Github para tu Port esten bien y compilen sin ningun problema (Poco probable que suceda). El segundo caso es que te toque re escribir algunos, si no son todos los archivos y sources de tu dispositivo para lograr que compilen y que arranquen FirefoxOS (Es lo que probablemente te pueda suceder con seguridad). Por lo que por recomendacion, seria bueno que tuvieras previos conocimientos acerca del funcionamiento de Android, algo de C y C++.

-

Mira también

- diff --git a/files/es/archive/b2g_os/porting_firefox_os/index.html b/files/es/archive/b2g_os/porting_firefox_os/index.html deleted file mode 100644 index 9da87c1802..0000000000 --- a/files/es/archive/b2g_os/porting_firefox_os/index.html +++ /dev/null @@ -1,71 +0,0 @@ ---- -title: Porting Firefox OS -slug: Archive/B2G_OS/Porting_Firefox_OS -tags: - - Firefox OS - - NeedsTranslation - - TopicStub - - porting -translation_of: Archive/B2G_OS/Porting_B2G_OS ---- -

This page lists the available resources for porting Firefox OS.

- -
-
Porting basics
-
Basic information about how to port Firefox OS to new devices.
-
Porting on CyanogenMod
-
This article explains how to port Firefox using CyanogenMod.
-
diff --git a/files/es/archive/b2g_os/porting_firefox_os/portando_de_cyanogenmod/index.html b/files/es/archive/b2g_os/porting_firefox_os/portando_de_cyanogenmod/index.html deleted file mode 100644 index cc9e9b19a1..0000000000 --- a/files/es/archive/b2g_os/porting_firefox_os/portando_de_cyanogenmod/index.html +++ /dev/null @@ -1,239 +0,0 @@ ---- -title: Portando en CyanogenMod -slug: Archive/B2G_OS/Porting_Firefox_OS/Portando_de_CyanogenMod -translation_of: Archive/B2G_OS/Porting_B2G_OS/Porting_on_CyanogenMod ---- -

- -

Firefox OS es tradicionalmente compilado encima de AOSP. Esto no significa que nosotros solamente usemos AOSP. Varias ramas (forks) de AOSP existen que tienen como objetivo apoyar una amplia gama de hardware. CyanogenMod, el fork mas popular de AOSP, incluye cientos de añadiduras, modificaciones, y hacks para dar soporte a cientos de disposivitos Android al por menor. Este articulo explica como portar Firefox OS usando CyanogenMod.

- -

Cuando compilamos Firefox OS encima de CyanogenMod podemos dar soporte al mismo numero de despositivos que CyanogenMod soporta. Debido a la gran cantidad de dispositivos soportados por CyanogenMod, es muy probable que ya tengas un dispositivo para el cual puedas compilar.

- -
Importante: Esta guía es solamente para usuarios avanzados; debes de saber al menos cómo compilar CyanogenMod o AOSP.
- -

Si nunca has compilado CyanogenMod para tu dispositivo entonces te sugerimos insistentemente que aprendas como hacerlo antes de portar Firefox OS. Esto tiene dos propositos: aprenderás como usar las herramientas necesarias para portar Firefox OS, y verificarás la calidad del 'port' de CyanogenMod.

- -

Más explícitamente, ésta guía asume que tu dispositivo esta desbloqueado y tiene CyanogenMod instalado. Esta guia no te enseñara como rootear y/o desbloquear tu dispositivo, o como preparar tu maquina para compilar o como usar git para solucionar los fallos de combinación.

- -

Un resumen de los pasos a seguir es el siguiente:

- -
    -
  1. Descargar el codigo fuente
    2. -
  2. Modificar los 'repos' del dispositivo
    3. -
  3. Modicar el núcleo
    4. -
  4. Compilar e Instalar
    5. -
- -

Descargar el código de fuente

- -
Para hacer: Convinar el manifiesto de mozilla-b2g: Bugzilla: 1211870.
- -

Tenemos varias herramientas útiles para construir Firefox OS, todas ellas contenidas en un simple repositorio. Descárga estas herramientas por git para crear tu directorio de trabajo.

- -
git clone https://github.com/cm-b2g/B2G.git && cd B2G
-
- -

Hecho esto, necesitamos descargar el código fuente:

- -
./config.sh cm-porting
-
- -

El archivo config.sh  inicializa la herramienta repo usando el manifiesto  base-l-cm.xml  que se encuentra en el repositorio b2g-manifest.  Éste archivo XML es en realidad una lista de repositorios específicos del SO necesarios para construir B2G OS.  Luego, utiliza la herramienta repo para descargar todo el código de fuente.

- -

La descarga de estos repositorios, muchos de los cuales tienen varias gigas,  tomará bastante tiempo, así que te recomendamos hacer esto en la noche si tienes una conección lenta, o justo después del almuerzo si tienes una conección rápida.

- -

Este paso también crea un archivo .config que podrás editar después.

- -

Manifiesto local para tu dispositivo

- -

El manifiesto anterior no contiene ningún repositorio específico de dispositivo, asunto diferente al típico manifiesto. Necesitaremos entonces crear un local_manifest.xml con todos los repositorios de tu dispositivo. La manera más rápida de hacerlo es usando breakfast, un herramienta automática escrita por CyanogenMod para crear un manifiesto local y descargar los repositorios adicionales directamente de la cuenta de CyanogenMod en GitHub.

- -
. build/envsetup.sh && breakfast 123
-
- -

Reemplace 123 por el nombre clave de su dispositivo.

- -

Si tu dispositivo no está oficialmente soportado por CyanogenMod, pero hay un 'port' no oficial, tu puedes crear el archivo local_manifest.xml manualmente en la carpeta  .repo/local_manifests.

- -
<?xml version="1.0" encoding="UTF-8"?>
-<manifest>
-     <remote name="xyz" fetch="git://github.com/xyz/" revision="cm-12.1" />
-     <project name="device_oem_123" path="device/oem/123" remote="xyz" />
-     <project name="device_oem_1xx-common" path="device/oem/1xx-common" remote="xyz" />
-     <project name="kernel_oem_1xx" path="kernel/oem/1xx" remote="xyz" />
-     <project name="vendor_oem" path="vendor/oem" remote="xyz" />
-</manifest>
-
- -

Recuerda correr repo sync cuando hayas creado tu manifiesto.

- -

Modificar los 'repos' del dispositivo

- -

Parte de la configuración de un dispositivo se encuentra en los archivos XML de superposición, usados por el sistema de construcción AOSP para establecer las opciones por defecto en las apps de Android. Firefox OS no los usa así que podemos reimplementar algunas de estas opciones, tales como el botón de inicio de la pantalla, el almacenamiento emulado, etc.

- -

Podemos establecer opciones predeterminadas más sanas mediante la inclusión de dos archivos desde vendor/cm. La primera línea podría ser agregada en la parte superior de device.mk y la segunda en la parte inferior de BoardConfig.mk:

- -
# Extra mk import at the top of device.mk
-$(call inherit-product, vendor/cm/config/common_full.mk)
-
-# Extra mk import at the bottom of BoardConfig.mk
-include vendor/cm/BoardConfig.mk
-
- -

Todavía se necesitan más opciones, ya que muchas son propiamente específicas del dispositivo . A continuación encontrarás una lista de adiciones y eliminaciones específicas de dispositivos comunes. Esta lista no es exhaustiva, pero agregando las dos líneas mencionadas arriba y configurando todas las de abajo,  tendrás un sistema funcional.

- -
# for Gecko to use the correct resolution assets
-# Valid options are: 1.5 | 2 | 2.25
-GAIA_DEV_PIXELS_PER_PX := 2.25
-
- -
# for Gecko to use the correct boot animation
-# Valid options are: hvga | fwvga | qHD | 720p | 1080p
-BOOTANIMATION_ASSET_SIZE := 1080p
-
- -
# for Gecko to support separate internal storage partition
-# This is for legacy devices only. You must prvide your own volume.cfg file
-GECKO_BOARD_SEPARATE_STORAGE_PARTITON := true
-
- -
# for Gecko to support virtual home button
-PRODUCT_PROPERTY_OVERRIDES += \
-    ro.moz.has_home_button=0
-
- -
# for Gecko to support usb mass storage
-# You may need to add mass_storage to init.oem.usb.rc
-PRODUCT_DEFAULT_PROPERTY_OVERRIDES += \
--    persist.sys.usb.config=mtp
-+    persist.sys.usb.config=mass_storage
-
- -
# for Gecko to support NFC
-PRODUCT_PROPERTY_OVERRIDES += \
-    ro.moz.nfc.enabled=true
-
-PRODUCT_PACKAGES += \
-    nfcd
-
- -
# Changes in init.device.rc
--on property:init.svc.bootanim=running
--on property:init.svc.bootanim=stopped
--on property:service.bootanim.exit=1
-+on property:sys.boot_completed=1
-
- -

Modificar el núcleo

- -

Necesitamos habilitar en el núcleo algunas características de seguridad adicionales para Firefox OS. Estas características no estaban presentes en núcleos Android hasta Marshmallow así que muchos dispositivos necesitarán algunos parches 'backported' adicionales para el núcleo. Más información al respecto en Bugzilla: 790923.

- -

Es suficiente tomar la mejor selección de parches para tu núcleo; el sistema de compilación habilitará automáticamente las nuevas características. Para un trabajo de ejemplo ver el LGE MSM8994 kernel.

- -
Importante: Este paso es obligatorio. Firefox OS no arrancará sin estas características de seguridad.
- -

Compilar e instalar

- -

¿Recuerdas el archivo .config creado anteriormente? Ahora necesitamos reemplazar cm-porting con el nombre clave de tu dispositivo.

- -
$ grep -r PRODUCT_NAME device/oem/123
-
- -

Nota: No uses el valor en cm.mk, usa el que está en device.mk, este debería ser algo como full_123. Puedes hacer el reemplazo manualmente o con sed:

- -
$ sed -i "s/cm-porting/full_123/g" .config
-
- -

Ahora es momento de comenzar la compilación:

- -
$ ./bldcm.sh
-
- -

Esto tomará, en todo caso, de 30 minutos a un par de horas dependiendo de tu PC, así que podría ser un buen momento para ir a la tienda y preparar algo de comer, o ayudar en las tareas de la casa.

- -

Instalar Firefox OS a través de fastboot

- -

Si tu dispositivo soporta fastboot, puedes simplemente mandar las imágenes de partición directamente al dispositivo:

- -
cd out/target/product/123/
-fastboot flash boot boot.img
-fastboot flash recovery recovery.img
-fastboot flash system system.img
-fastboot flash userdata userdata.img
-
- -

Instalar Firefox OS através del recovery

- -

Si tu dispositivo no soporta fastboot entonces puedes usar update.zip en su lugar. Este puede ser inicializado por el dispositivo a través de adb sideload. Una vez allí, deberás mandar el archivo .zip:

- -
adb sideload out/target/product/123/fota/fullimg/update.zip
-
- -

Solución de problemas

- -

¿Algo no funciona? ¡Es momento de remangarse la camisa!

- -

Lo primero que debes hacer es determinar si la característica está funcionando en CyanogenMod. Puede que simplemente falte  alguna configuración para Firefox OS.

- -

Si la característica no funciona en CyanogenMod entonces significa que debes implementarla para tu 'port'. Sería bueno si también presionas tu revisión yendo atrás en el código.

- -

Cámara

- -

Algunas partes de Android fueron removidas del proceso de compilación por ser innecesarias. Si tu cámara  arrojaburbujas de queja sobre la pérdida de funciones, verifica los marcos o la base para ver si las funciones fueron removidas. Podría ser posible traerlas de vuelta.

- -

WiFi

- -

El dispositivo podría no ver ciertos Puntos de Acceso si no están en un canal oficial. Este parecería ser un problema de CyanogenMod o incluso de AOSP, ya que este afecta distintos tipos de hardware y diferentes OEMs.

diff --git a/files/es/archive/b2g_os/preparing_for_your_first_b2g_build/index.html b/files/es/archive/b2g_os/preparing_for_your_first_b2g_build/index.html deleted file mode 100644 index c0a20668ca..0000000000 --- a/files/es/archive/b2g_os/preparing_for_your_first_b2g_build/index.html +++ /dev/null @@ -1,151 +0,0 @@ ---- -title: Preparándote para tu primer binario de B2G -slug: Archive/B2G_OS/Preparing_for_your_first_B2G_build -translation_of: Archive/B2G_OS/Preparing_for_your_first_B2G_build ---- -

- -

Antes de construir B2G, necesitas clonar el repositorio y configurar tu binario. Este artículo te explica cómo.

- -

Cómo clonar el repositorio de B2G

- -

El primer paso antes de empezar a construir tu primer binario es clonar el repositorio de B2G. Esto no lo bajará todo: bajará solamente el "build system" de B2G y las utilidades de configuración. La mayoría del código de B2G está en el repositorio general Mercurial de Mozilla.

- -

Para clonar el repositorio, usa git:

- -
git clone git://github.com/mozilla-b2g/B2G.git
- -

Tras clonarlo (lo que debería tardar sólo un momento), cd al directorio de B2G:

- -
cd B2G
-
- -

Cómo copiar la estructura de B2G a otro ordenador

- -

Si tienes un ordenador nuevo (¡vaya suerte!), tu vida será mucho más fácil si simplemente migras la estructura completa de B2G de un ordenador al otro.

- -

Para ello, monta el disco duro de tu ordenador viejo en el nuevo, y haz:

- -
rsync -a source/ dest/
-
- -

Donde source es la ruta completa (incluida la barra oblicua del final) a la estructura del código, y dest es el destino al que la quieres mover (la barra oblicua del final también es importante en este caso).

- -
-

Atención: Si copias los archivos de un ordenador con un sistema operativo diferente asegúrate de ejecutar './build.sh clean' antes de empezar el proceso de construcción. Si no, puedes causar problemas de compilación.

-
- -

Si sigues estas instrucciones, puedes saltarte el resto de este artículo e ir directamente a la página de construcción.

- -

Cómo configurar B2G en tu móvil

- -
Importante: Recuerda que sólo son compatibles los móviles con Android 4 (alias Ice Cream Sandwich o ICS). Asegúrate de que tu teléfono tiene instalado ICS, si no este paso probablemente fallará ya que algunos "drivers" se obtienen de móviles que no son Nexus. Si tienes que flashear tu móvil con ICS, ten en cuenta que algunas extensiones USB no funcionan bien con utilidades para flashear, y que tendrás que conectar tu teléfono a uno de los puertos del ordenador.
- -

Una vez tengas el "build system" de B2G, necesitas configurarlo para el móvil en el que lo vas a instalar. Para ver una lista de aparatos compatibles, puedes utilizar la herramienta config.sh:

- -
./config.sh
-
- -

Este comando te muestra una lista de aparatos compatibles. Por ejemplo:

- -
Usage: ./config.sh [-cdflnq] (device name)
-Flags are passed through to |./repo sync|.
-
-Valid devices to configure are:
-- galaxy-s2
-- galaxy-nexus
-- nexus-4
-- nexus-4-kk
-- nexus-5
-- nexus-5-l
-- nexus-s
-- nexus-s-4g
-- flo (Nexus 7 2013)
-- otoro
-- unagi
-- inari
-- keon
-- peak
-- hamachi
-- helix
-- tarako
-- dolphin
-- dolphin-512
-- pandaboard
-- vixen
-- flatfish
-- flame
-- flame-kk
-- flame-l
-- rpi (Revision B)
-- emulator
-- emulator-jb
-- emulator-kk
-- emulator-l
-- emulator-x86
-- emulator-x86-jb
-- emulator-x86-kk
-- emulator-x86-l
-> Sony Xperia devices
-- aries (Z3 Compact KK)
-- aries-l (Z3 Compact L)
-- leo-kk (Z3 KK)
-- leo-l (Z3 L)
-- scorpion-l (Z3 Tablet Compact L)
-- sirius-l (Z2 L)
-- tianchi-l (T2U L)
-- flamingo-l (E3 L)
- -

-Si tu aparato no está en la lista, no continúes: ayúdanos a hacer B2G compatible con tu aparato o espera a que alguien lo haga. ¡Pero siempre es mejor que seas tú el que nos ayudes!
- -
 
- -
Atención: Si por cualquier razón quieres construir una versión específica de B2G, lee el artículo Cómo construir una versión específica de Gecko antes de hacerlo.
- -

Cómo configurar un teléfono móvil

- -

Primero conecta tu móvil: el proceso de configuración necesita acceder al teléfono.

- -

Si tu teléfono aparece en la lista de aparatos compatibles, puedes empezar el proceso de configuración ejecutando config.sh otra vez, pero ahora incluyendo el nombre del aparato. Por ejemplo, para construir para el Samsung Google Nexus S, escribirías:

- -
./config.sh nexus-s
-
- -

Al principio de la configuración es posible que tengas que configurar la opción de uso del color, tras lo cual el proceso continúa. Éste es un buen momento para tomarse un descanso, ya que es ahora cuando te estás descargando por primera vez todo el código necesario para construir B2G.

- -

Si tu teléfono ya no tiene Android y tu estructura de B2G no tiene los bloques binarios, pero has hecho una copia de seguridad de la partición /system tal y como te recomendó el artículo Prerrequisitos para construir Firefox OS, puedes utilizar dicha copia de seguridad haciendo:

- -
ANDROIDFS_DIR=<absolute path to parent dir of system dir> ./config.sh <target>
-
- -

Configuración para construir un emulador

- -

Si quieres construir uno de los emuladores, especifica "emulator" para construir la versión ARM, o "emulator-x86" para construir la versión x86. La versión x86 es más rápida, pero su simulación de dispositivos móviles es menos fiel a la realidad.

- -

Por ejemplo, para construir el emulador ARM, escribirías lo siguiente:

- -
./config.sh emulator
-
- -

Al principio de la configuración es posible que tengas que configurar la opción de uso del color, tras lo cual el proceso continúa. Éste es un buen momento para tomarse un descanso, ya que es ahora cuando te estás descargando por primera vez todo el código necesario para construir B2G.

- -
-

Atención: ./config.sh puede llevar más tiempo y consumir más recursos de red de lo que esperabas. Puedes parar el proceso haciendo Ctrl-C y reiniciarlo más tarde. Si sospechas que parte del proceso fue interrumpido antes de terminar, ejecuta './repo sync' para reparar cualquier posible error.

-
- -

Cómo construir una versión específica de Gecko

- -

Algunas veces querrás o necesitarás construir B2G basado en una versión de Gecko distinta de la que se usa por defecto (la que se especifica en el manifiesto). Puedes hacerlo editando el archivo.userconfig antes de hacer "pull" en el repositorio (es decir, antes de ejecutar config.sh). Por ejemplo, si quieres construir basándote en mozilla-central:

- -
GECKO_PATH=/path/to/mozilla-central
-GECKO_OBJDIR=/path/to/mozilla-central/objdir-gonk
-
- -
-

Atención: si construyes para otra versión de Gecko en Mac OS X, el directorio mozilla-central tiene que estar en un sistema de archivos sensible a las mayúsculas.

-
- -

Lee Personalización del archivo .userconfig para más información sobre adaptaciones que puedes hacer.

- -

Próximo paso: empieza a construir.

diff --git a/files/es/archive/b2g_os/probando_firefox_os/index.html b/files/es/archive/b2g_os/probando_firefox_os/index.html deleted file mode 100644 index 282a2fc9cc..0000000000 --- a/files/es/archive/b2g_os/probando_firefox_os/index.html +++ /dev/null @@ -1,81 +0,0 @@ ---- -title: Probar Firefox OS -slug: Archive/B2G_OS/Probando_Firefox_OS -translation_of: Archive/B2G_OS/Automated_testing ---- -

-

Considerando que Boot to Gecko esta todavía en desarrollo y la compatibilidad para hardware nuevo está pensada para un futuro inmediato, es importante saber cómo probarlo. Esta página ofrece enlaces a artículos que proveen información sobre varios aspectos las pruebas de Boot to Gecko.

- - - - - - - -
-

Pruebas de unidades

- -
-
-

Temas de prueba diversos

-
-
- Depurar OpenGL
-
- Como depurar código OpenGL en Boot to Gecko.
-
- Gráfico de soporte de características
-
- Un gráfico de que características están soportadas por las diferentes compilaciones de Boot to Gecko.
-
-

Marionette para Boot to Gecko

- -

Prueba de Gaia

- -

Tutoriales de Marionette

- -

Escribiendo pruebas para Marionette

- -

Ver todo...

- 		-

Obtener ayuda de la comunidad

-

Si está trabajando con Boot to Gecko o desarrollando aplicaciones que funcionarán en dispositivos basados en Boot to Gecko, hay recursos de la comunidad que lo ayudarán.

- -
    -
  • Pregunte en el canal de IRC de Mozilla: #b2g
    • -
-

No se olvide de la netiquette...

-
- - -
-

 

diff --git a/files/es/archive/b2g_os/quickstart/app_tools/index.html b/files/es/archive/b2g_os/quickstart/app_tools/index.html deleted file mode 100644 index a179d64a23..0000000000 --- a/files/es/archive/b2g_os/quickstart/app_tools/index.html +++ /dev/null @@ -1,16 +0,0 @@ ---- -title: App tools -slug: Archive/B2G_OS/Quickstart/App_tools -translation_of: Archive/B2G_OS/Quickstart/App_tools ---- -
-

What do you use to build Open Web Apps? The answer is "anything you would normally use to build for the web." The following is a list of tools and resources to help you get started making Open Web Apps. They can be easily integrated into your existing web development workflow, if you have one, or you can build a new workflow around them.

-
-

App Validator

-

Is your app ready for the Firefox Marketplace? The App validator will check your manifest and show you any errors it may have, or warnings you should consider.

-

Firefox OS Simulator

-

Installing and using the Firefox OS Simulator is the easiest way to get up and running with your app. After installed the simulator is accessible via the Tools -> Web Developer -> Firefox OS Simulator menu. The simulator launches with a JavaScript console so that you may debug your application from within the simulator!

-

App Manager

-

The new kid on the block with regards to testing tools is called the App Manager. This tool allows you to connect desktop Firefox to a compatible device via USB (or a Firefox OS simulator), push apps straight to the device, validate apps, and debug them as they run on the device.

-

Firefox Developer Tools

-

Firefox now ships with a default set of developer tools built from the ground up to ensure a great development experience that is both snappy and efficient. To find out more about how these tools work, and see a detailed list of what else Mozilla has to offer, head on over to our Tools zone.

diff --git a/files/es/archive/b2g_os/quickstart/index.html b/files/es/archive/b2g_os/quickstart/index.html deleted file mode 100644 index ebe1f7c220..0000000000 --- a/files/es/archive/b2g_os/quickstart/index.html +++ /dev/null @@ -1,49 +0,0 @@ ---- -title: Build -slug: Archive/B2G_OS/Quickstart -tags: - - NeedsTranslation - - TopicStub -translation_of: Archive/B2G_OS/Quickstart ---- -
-

Quickstart information on coding open web apps.

-
-
-
- Introduction to open web apps
-
- What are open web apps? How they differ from regular web pages? Why is this significant? This article aims to answer these questions and more.
-
- Your first app
-
- This article takes you through the basic steps and additional knowledge on top of regular web development required to create installable open web apps.
-
- Introduction to Firefox OS
-
- An introduction to Firefox OS, Mozilla's new open web app-based mobile platform.
-
- Introduction to manifests
-
- An FAQ designed to answer any questions you may have about manifests, hosting apps, origins, and other such topics.
-
- App development for web developers
-
- If you're a web developer, how do open web apps differ from what you're used to? This article explains all.
-
- App development for mobile developers
-
- If you're a native mobile application developer, what advantages can open web apps bring to you, and how do they differ from what you are used to? Here are some ideas.
-
- Developing app functionality
-
- This page talks about the kinds of different functionality that you might want to build into your apps, with links to further information.
-
- Payments
-
- How do you build functionality to make people pay for installing your open web apps? Here is the lowdown.
-
- App tools
-
- Last for this section, we provide some links to more information on the tools available to help you develop great open web apps.
-
diff --git a/files/es/archive/b2g_os/quickstart/intro_to_manifests/index.html b/files/es/archive/b2g_os/quickstart/intro_to_manifests/index.html deleted file mode 100644 index 84ab7f30d9..0000000000 --- a/files/es/archive/b2g_os/quickstart/intro_to_manifests/index.html +++ /dev/null @@ -1,90 +0,0 @@ ---- -title: Introducción al manifest -slug: Archive/B2G_OS/Quickstart/Intro_to_manifests -translation_of: Archive/B2G_OS/Quickstart/Intro_to_manifests ---- -
-

Este articulo proporciona toda la información básica que usted necesita saber a cerca de trabajar con archivos de manifiesto open web app.

-
-
-
- ¿Por qué mi aplicación necesita un app manifest?
-
- La aplicación manifest proporciona útil información a cerca de una aplicación (tal como nombre, autor, icono y descripción)  es un simple documento usado por los usuarios y las tiendas de aplicacion. Lo mas importante, está contendra una lista de Web APIs (Tal como geolocation) que su aplicación necesita. Esto permite a usuarios tomar decisiones informadas a cerca de aplicaciones antes de instalarla.
-
- Es la Open Web app manifest la misma cosa como el  manifest usado por la extensión de Google Chrome y las web app instalables? o el W3C Widgets manifest? o el  HTML5 cache manifest?
-
- No a todos ellos. . La open web app manifest es probablemente la mas similar a google manifest, pero no son identicos. Es esperado que el Open web apps manifest llegará a ser un estandar.
-
- ¿Qué es un origen?
-
- El origen de una aplicación es el protocolo, dominio y puerto de la url junto. Cada una de las siguientes urls son diferentes a la original: -
    -
  • http://example.com
    • -
  • http://example.com:8080 (diferente puerto)
    • -
  • https://example.com (diferente protocolo)
    • -
  • http://www.example.com
    • -
  • http://myapp.example.com (subdominio)
    • -
-
-
- Las siguientes urls son la misma original: -
    -
  • http://Example.com:80
    • -
  • http://example.com
    • -
-
-
-
-
- Las siguientes urls son la misma original: -
    -
  • http://example.com/drawingApp
    • -
  • http://example.com/notesApp
    • -
-
-
-
-
- ¿Por qué tengo que hospedar el app manifest en el mismo origen que mi aplicación?
-
- Asumimos que solo usted puede alojar una aplicación manifest en el mismo origen que su aplicación. Esto significa que los usuarios pueden instalar su aplicación con confianza, sabiendo que la instalación es basada en su aplicación manifiesto y no en alguien más.  Los usuarios deberían tener esta confianza si están instalando su aplicación para Firefox OS Marketplace, para alguna otra tienda de aplicaciones o para su propio sitio web si es auto-publicada su aplicación.
-
- Si la aplicación manifest no fué hospedada en el mismo origen que la aplicación misma, allí no habría nada para prevenir que terceros hagan directamente aplicaciones fuera de el contenido alojado en su origen.Incluso empeora, terceros podrían crear una aplicación manifiest usando su marca eso sería engañar a los usuarios para que instalen una aplicación que es una fachada para un robo de contraseñas u otros comportamientos imprevistos .
-
- ¿hacer esto significa que no puedo incrusptar imagenes o javascript de otros origenes?
-
- No.  La restricción de origen es sobre solo contenido (paginas HTML) . imagenes y otros recursos embebidos pueden ser localizados en otras partes (por ejemplo, en una red de entrega de contenido), excepto por el icono de la aplicación.
-
- Puedo tener mas de una aplicación en mi origen?
-
- No, allí solo puede estar una aplicación por origen. Si se permitiera multiples aplicaciones de un solo origen, ellos podrian vivir en una simple web sandbox — examinarían cada localStorage del otro , hace solicitud ajax a cada APIS del otro, o incluso roba acceso a las APIS privilegiadas que deberían de haber tenido concebida solo una de las aplicaciones. Esto sería especialmente peligroso para dominios públicos que públican contenido generado por usuario para muchos usuarios.
-
- Nosotros recomendamos que use una separación de subdominios para cada una de sus aplicaciones. Por ejemplo, spreadsheet.mycoolapps.com por una aplicación y texteditor.mycoolapps.com por otro. Para mas información, ver Añadiendo un subdominio por una aplicación.
-
- Muchos recursos y permisos en la web ya están en el ambito de un solo origen. por definición una aplicación y un origen como la misma cosa  que usamos la misma restrinción que son usados en otra parte de la web y en HTML5.
-
- ¿Porqué no subir el manifiesto directamente al Firefox Os Marketplace?
-
- Hay varios beneficios de alojas el manifiesto en su dominio y proporcionando la url de la aplicación manifest a el Marketplace: -
    -
  • Nosotros pretendiamos que el Marketplace (y otras tiendas de aplicaciones) revisarían periodicamente todo el manifiesto  en la URL proporcionada y verifique actualizaciones en ellos. Esto evita la necesidad de que vuelva a subir su aplicación manifiesto por cada actualización .
    • -
  • El marketplace pasará tanto el original contenido de la aplicación manifiesto como la URL para el dispositivo del usuario. esto permite al dispositivo verificar por bajos costos en la aplicación manifiesto que podría indicar la manipulación. Este será especialmente importante para aplicaciones que usen APIS web(por ejemplo geolocalización).
    • -
- Nota: A partir de este escrito, nosotros estamos todavía diseñando un proceso por el cual el Marketplace pasará una actualizada aplicación  manifiesto a el dispositivo del usuario.
-
-
- ¿Por qué mi servidor Web tiene que utilizar la cabecera Content-Type de HTTP adecuada al servir mi aplicación manifiesta?
-
- Esta restricción previene a usuarios de un sitio web que permite contenido de usuarios generados (por ejemplo, un sitio pastebin) para inadvertidamente o inapropiadamente reclamando que todo sitio web como su aplicación.
-
- Debería usar HTTPS para servir mi aplicación ?
-
- Si, es una buena idea. Nosotros anticipamos que el firefox Os Marketplace requerirá cualquier aplicación usando APIS web (Tal como geolocación) para servir a su aplicación manifesto a través de HTTPS como una defensa adicional contra ataques hombre-en-el-medio. Si usas HTTPS para su manifiesto, usted necesita también usarla para todas las páginas en su sitio.
-
- Qué pasa si alguien más entrega mi aplicación a el Markeplace de Firefox OS?
-
- En el afortunado evento que alguien adivine la url de su aplicación manifiesto y lo entrega a el Marketplace de Firefox Os antes que usted, por favor presentar una queja con el equipo de apoyo del mercado.
-
-

Vease también

-

App manifest

diff --git a/files/es/archive/b2g_os/quickstart/introduccion_a_las_open_web_apps/index.html b/files/es/archive/b2g_os/quickstart/introduccion_a_las_open_web_apps/index.html deleted file mode 100644 index 37caf3ab16..0000000000 --- a/files/es/archive/b2g_os/quickstart/introduccion_a_las_open_web_apps/index.html +++ /dev/null @@ -1,108 +0,0 @@ ---- -title: Introducción a las Open Web Apps -slug: Archive/B2G_OS/Quickstart/Introduccion_a_las_open_web_apps -tags: - - Apps - - Web Open App -translation_of: Archive/B2G_OS/Quickstart/Intro_to_open_web_apps ---- -

Multi devices

- -
-

Este artículo está diseñado para actuar como un buen punto de partida para cualquiera que desee aprender más sobre Open Web Apps, si usted es un desarrollador o administrador del proyecto, o tiene otro rol relevante en el desarrollo de aplicaciones o en la distribución. Aquí te ofrecemos un panorama claro de las Open Web Apps y la filosofía detrás de ellas.

-
- -

Las Open Web Apps son esencialmente diferentes de sitios web estándar o páginas Web. Se construyen utilizando tecnologías web abiertas estándar - HTML, CSS, JavaScript, etc - y se pueden acceder mediante un navegador Web. Las principales diferencias radican en su capacidad para ser instaladas en un dispositivo, trabajar sin conexión y tener acceso a API's avanzadas que permiten la interacción con las características del dispositivo, como la cámara, agenda, y otras cosas. Además, se basan en tecnologías abiertas tanto como sea posible. Cuando las diferencias radican en la implementación de tecnología entre las plataformas, se deben hacer esfuerzos para asegurar que ambos son compatibles, a través de una combinación de detección de características y código apropiado para diferentes plataformas, y la degradación agraciada.

- -

Ventajas de las Open Web Apps

- -

Echemos un vistazo a las ventajas de Open Web Apps con más de detalle:

- - - -

El siguiente video también se ve en las ventajas generales de las Open Web Apps, y el desarrollo para la plataforma Firefox OS:

- -

- -

La Web es la plataforma

- -

Una Open Web App, como tal existe instalada en una plataforma como Firefox OS no es un bookmark - es una parte propia del sistema. Las Open Web Apps son una gran promesa. Se trata de una oportunidad que no hay que perderse, de lo contrario la web puede llegar a ser una vez más dividida. Con esto en mente, debe quedar claro que las Open Web Apps (OWA) están destinadas a ser estandarizadas y de formar parte de "la Web". Si tiene éxito, OWA debería eventualmente trabajar en todos los navegadores, sistemas operativos y dispositivos.

- -

En Mozilla estamos trabajando duro para crear esta plataforma de aplicaciones que está respaldada en su totalidad por la open Web. No es la intención de ser la "plataforma Mozilla" o la "plataforma Firefox". La Web es la plataforma. Estamos creando un conjunto de APIs abiertas y las implementaciones para demostrar cómo pueden existir aplicaciones portátiles en la web sin dependencia de un proveedor. Otros grupos, como Facebook y Google Chrome también están trabajando en las plataformas de aplicaciones soportadas por la Web. Facebook apps estan hechas para encajar en Facebook y Chrome apps estan diseñadas para dispositivos Chrome OS y servidores de Google. Las Chrome apps son las más similares a las Open Web Apps. Seguimos colaborando con el equipo de Google Chrome como las normas de las apps evolucionan y que sin duda compartimos nuestra visión en gran parte. Existe un enorme potencial para todas las plataformas de apps basadas en la Web para converger e invitamos a todos los proveedores a ayudarnos a construir las correctas Open Web App APIs.

- -

A pesar de que actualmente se debe tener un motor basado en Firefox Mozilla ("Web runtime") para usar las Open Web Apps, no se pretende que este será siempre el caso. Muchas partes del proyecto de aplicaciones Web abiertas aún se están elaborando y no es posible implementar todo en todos los navegadores a la vez. Aunque muchas partes de las Open Web Apps ya están estandarizadas, muchas otras partes todavía están en proceso de cambio. Se pretende y se espera que las Open Web Apps serán una estándar que estará disponible en los principales navegadores.

- -

Por lo tanto, cuando usted lee las páginas  de MDN que tienen que ver con las Open Web Apps, por favor, tenga en cuenta que a pesar de que mucha de la información es específica para Firefox en este momento, es de esperar que  se permitirá desarrollar Open Web Apps para todos los navegadores en el futuro.

- -

Estándares Web

- -

La tecnología de OWA no es una sola pieza, es un paraguas que agrupa a muchas tecnologías diferentes y algunas de ellas son muy nuevas. Por el momento, partes de OWA están estandarizadas (HTML5, CSS, JavaScript, IndexedDB, etc.). Otras partes aún no están estandarizadas y la implementación Mozilla es solo específica para Firefox o a alguna otra tecnología de Mozilla. Como la misión de Mozilla es de compartir y potenciar a todos, esta situación es sólo temporal. Es por eso que en la documentación OWA vamos a tratar de identificar claramente las partes de OWA que no están todavía estandarizadas.

- -

Tenga en cuenta también que puede haber algunas propuestas relacionadas con OWA y normas potenciales que no son utilizadas por Mozilla.

- -

Normas eventualmente previstas.

- -

Así que aquí están las piezas no estandarizadas aún a través de las distintas plataformas web y que aún son Firefox, sólo por el momento:

- - - -

Marketplace

- -

Compra una vez, Ejecuta donde sea

- -

Desde el principio Mozilla ha construido un sistema de aplicaciones que permite a los usuarios comprar una aplicación una vez y ejecutarla en todos sus dispositivos HTML5. Muy pronto Mozilla lanzara el smartphone FirefoxOS pero eso será sólo un dispositivo en el que se ejecuten sus aplicaciones. Cuando usted compra una aplicación a través de la Firefox Marketplace, el sistema instala un recibo en su dispositivo. El recibo es un JSON Web Token con metadata que enlaza con la clave pública del mercado y su dirección URL del servicio de verificación. Cuando una aplicación se inicia, puede verificar el recibo pero el recibo en el dispositivo no está atado al Firefox MarketPlace. El recibo es sólo una prueba criptográficamente verificable de compra. Cualquiera puede vender Open Web Apps si siguen las especificaciones del recibo. Cuando usted compra una aplicación, se pretende que sea portable a través de cualquier dispositivo compatible con el sistema de Open Web Apps.

- -
-
Mozilla está construyendo la infraestructura necesaria para ejecutar Open Web Apps en cualquier dispositivo HTML5. Firefox para Android le permitirá instalar y ejecutar aplicaciones (se puede probar hoy). Los iconos de las apps instaladas estarán en tu pantalla principal justo como en las aplicaciones normales de Android. También se puede instalar y ejecutar Open Web Apps en el escritorio de Windows, Mac o Linux usando Firefox (esto funciona actualmente). Actualmente se requiere alguna versión de Firefox, pero está previsto que el sistema de Open Web finalmente reciba el apoyo de todos los navegadores principales con un conjunto de normas. Desde el primer día Mozilla ha incluido todos los navegadores compatibles con HTML5 en su prueba de conceptos, se puede echar un vistazo a esta shim alojada en JavaScript para obtener ideas sobre cómo apoyar a la plataforma de aplicaciones en un navegador que no sea Firefox.
- -
 
-
- -

En el futuro, el sistema de Open Web Apps apoyará sinconizando tus apps instaladas entre dispositivos. Dado que los recibos son portátiles sólo podrías sincronizarlos tú mismo si quieres. En caso de que no, es obvio  que siempre se puede ejecutar una Open Web App gratis en cualquier navegador, ya que no es diferente de un sitio web. 

- -
-
Se podría, sin embargo, utilizar las nuevas APIs especificas para mobiles que no se aplican en todas las plataformas.
- -
 
-
- -

El video a continuación ofrece un panorama útil de las ventajas de los MarketPlace abiertos y un enfoque para el descubrimiento de las Open Apps:

- -

- -

WebPayment API

- -

Comercio para Apps

- -
-
Parte del éxito de las plataformas de aplicaciones móviles como iOS y Android es que hacen que sea muy fácil de probar nuevos modelos de negocio a través de los pagos móviles. Estos modelos todavía están evolucionando pero el comercio es sin duda algo que, en el momento, es incómodo en la Web de escritorio y más natural en el móvil. En concreto, es muy conveniente para cargar algo a su factura de teléfono cuando usted ya está accediendo a ella desde el teléfono de todos modos. Con el lanzamiento de Firefox OS, el entorno de aplicaciones apoyará compras de aplicaciones y los pagos dentro de la aplicación a través de la WebPayment API. Apoyar el comercio es crucial para el crecimiento de una plataforma de aplicaciones. El uso de la API de pago propuesto es completamente opcional. Mozilla no impedirá que cualquier aplicación utilice su propio sistema de pago independiente.
- -
 
-
- -

Véase también

- - diff --git a/files/es/archive/b2g_os/quickstart/tu_primera_aplicacion/index.html b/files/es/archive/b2g_os/quickstart/tu_primera_aplicacion/index.html deleted file mode 100644 index a1f58175e8..0000000000 --- a/files/es/archive/b2g_os/quickstart/tu_primera_aplicacion/index.html +++ /dev/null @@ -1,257 +0,0 @@ ---- -title: Tu primera Aplicación -slug: Archive/B2G_OS/Quickstart/tu_primera_aplicacion -translation_of: Archive/B2G_OS/Quickstart/Your_first_app ---- -
-
-

Las aplicaciones de la web abierta le dan a los desarrolladores lo que justamente han querido por años: un entorno multiplataforma dedicado a la construccion de aplicaciones con HTML, CSS y Javascript, con Firefox OS siendo la primera plataforma dedicada a las aplicaciones web. Esta guía tiene como objetivo iniciarte y orientarte rápidamente en una estructura básica e instrucciones de construcción, ¡de tal manera que tú puedas crear la siguiente generación de aplicaciones!

-
- -

Si deseas continuar con esta guía, puedes descargar nuestro quick start app template. Encuentra más provechoso el contenido leyendo la guía  Apps template.

- -

Estructura de la Aplicación

- -

Aplicaciones Empaquetadas vs. Aplicaciones Alojadas

- -

Hay dos tipos de aplicaciones web abiertas: empaquetadas y  alojadas. Las aplicaciones empaquetadas son esencialmente archivos  zip  conteniendo todos los archivos necesarios: HTML, CSS, JavaScript, imágenes, manifest, etc. Las aplicaciones alojadas están corriendo desde un servidor en un dominio dado, como un sitio web estandard. Ambos tipos de aplicaciones  requieren un manifest válido. Cuando llega el momento de listar tu aplicación  en el Firefox Marketplace, ya sea que tu subas tu aplicación como un archivo zip o la URL del servidor donde está tu aplicación.

- -
-
-

Hecho en colaboración con Treehouse: Check them out!

-
-
- -

A los efectos de esta guía, crearás una aplicación alojada que vivirá en tu dirección localhost. Una vez que tu aplicación esté lista para ser publicada en el Firefox Marketplace, podras tomar la decisión de agruparla como una aplicación empaquetada o lanzarla como una aplicación alojada.

- -

Manifest de la Aplicación

- -

Cada aplicación de Firefox  requiere un archivo manifest.webapp en la raíz de la aplicación. El archivo manifest.webapp  proporciona información importante sobre la aplicación, como la versión, nombre, descripción, localización de íconos, strings locales, dominios donde la aplicación puede ser instalada, y mucho más. Sólo el nombre y la descripción son obligatorios. Una plantilla simple dentro de la aplicación es similar a lo que sigue:

- -
{
-  "version": "0.1",
-  "name": "Open Web App",
-  "description": "Your new awesome Open Web App",
-  "launch_path": "/app-template/index.html",
-  "icons": {
-    "16": "/app-template/app-icons/icon-16.png",
-    "48": "/app-template/app-icons/icon-48.png",
-    "128": "/app-template/app-icons/icon-128.png"
-  },
-  "developer": {
-    "name": "Your Name",
-    "url": "http://yourawesomeapp.com"
-  },
-  "locales": {
-    "es": {
-      "description": "Su nueva aplicación impresionante Open Web",
-      "developer": {
-        "url": "http://yourawesomeapp.com"
-      }
-    },
-    "it": {
-      "description": "Il vostro nuovo fantastico Open Web App",
-      "developer": {
-        "url": "http://yourawesomeapp.com"
-      }
-    }
-  },
-  "default_locale": "en"
-}
- -
-
-

Hecho en colaboración con Treehouse: Check them out!

-
-
- -

 

- -

Un manifiesto básico es todo lo que necesitas para empezar. Para más detalles sobre los manifiestos, lee App Manifest.

- -

App Layout & Design

- -

El responsive design (diseño adaptativo) se ha convertido cada vez más importante a medida que más resoluciones de pantalla en diferentes dispositivos se convierten en la norma. Aunque el principal objetivo de tu aplicación sean las plataformas móviles como Firefox OS, otros dispositivos probablemente también tengan acceso a ella. Las CSS media queries permiten adaptar el diseño al dispositivo, como se muestra en este ejemplo de esqueleto en CSS:

- -
/* The following are examples of different CSS media queries */
-
-/* Basic desktop/screen width sniff */
-@media only screen and (min-width : 1224px) {
-  /* styles */
-}
-
-/* Traditional iPhone width */
-@media
-  only screen and (-webkit-min-device-pixel-ratio : 1.5),
-  only screen and (min-device-pixel-ratio : 1.5) {
-  /* styles */
-}
-
-/* Device settings at different orientations */
-@media screen and (orientation:portrait) {
-  /* styles */
-}
-@media screen and (orientation:landscape) {
-  /* styles */
-}
- -

Hay muchos frameworks JavaScript y CSS disponibles para ayudar en el diseño adaptativo y el desarrollo de aplicaciones móviles (Bootstrap, etc.). Elige el frameworks(s) que mejor se adapte a tu aplicación y estilo de desarrollo.

- -

Web APIs

- -

JavaScript APIs are being created and enhanced as quickly as devices are. Mozilla's WebAPI effort brings dozens of standard mobile features to JavaScript APIs. A list of device support and status is available on the WebAPI page. JavaScript feature detection is still the best practice, as shown in the following example:

- -
// If this device supports the vibrate API...
-if('vibrate' in navigator) {
-    // ... vibrate for a second
-    navigator.vibrate(1000);
-}
- -

In the following example, the display style of a <div> is modified based on changes in the battery state of the device:

- -
// Create the battery indicator listeners
-(function() {
-  var battery = navigator.battery || navigator.mozBattery || navigator.webkitBattery,
-      indicator, indicatorPercentage;
-
-  if(battery) {
-    indicator = document.getElementById('indicator'),
-    indicatorPercentage = document.getElementById('indicator-percentage');
-
-    // Set listeners for changes
-    battery.addEventListener('chargingchange', updateBattery);
-    battery.addEventListener('levelchange', updateBattery);
-
-    // Update immediately
-    updateBattery();
-  }
-
-  function updateBattery() {
-    // Update percentage width and text
-    var level = (battery.level * 100) + '%';
-    indicatorPercentage.style.width = level;
-    indicatorPercentage.innerHTML = 'Battery: ' + level;
-    // Update charging status
-    indicator.className = battery.charging ? 'charging' : '';
-  }
-})();
- -

In the code sample above, once you confirm that the Battery API is supported, you can add event listeners for chargingchange and levelchange to update the element's display. Try adding the following to the quickstart template, and see if you can get it working.

- -

Check the WebAPI page frequently to keep up to date with device API statuses.

- -

Install API functionality

- -

In our sample quickstart app template, we've implemented an install button that you can click when viewing the app as a standard Web page, to install that site on Firefox OS as an app. The button markup is nothing special:

- -
<button id="install-btn">Install app</button>
- -

This button's functionality is implemented using the Install API (see install.js):

- -
var manifest_url = location.href + 'manifest.webapp';
-
-function install(ev) {
-  ev.preventDefault();
-  // define the manifest URL
-  // install the app
-  var installLocFind = navigator.mozApps.install(manifest_url);
-  installLocFind.onsuccess = function(data) {
-    // App is installed, do something
-  };
-  installLocFind.onerror = function() {
-    // App wasn't installed, info is in
-    // installapp.error.name
-    alert(installLocFind.error.name);
-  };
-};
-
-// get a reference to the button and call install() on click if the app isn't already installed. If it is, hide the button.
-var button = document.getElementById('install-btn');
-
-var installCheck = navigator.mozApps.checkInstalled(manifest_url);
-
-installCheck.onsuccess = function() {
-  if(installCheck.result) {
-    button.style.display = "none";
-  } else {
-    button.addEventListener('click', install, false);
-  };
-};
-
- -

Let's run through briefly what is going on:

- -
    -
  1. We get a reference to the install button and store it in the variable button.
    2. -
  2. We use navigator.mozApps.checkInstalled to check whether the app defined by the manifest at http://people.mozilla.com/~cmills/location-finder/manifest.webapp is already installed on the device. This test is stored in the variable installCheck.
    3. -
  3. When the test is successfully carried out, its success event is fired, therefore installCheck.onsuccess = function() { ... } is run.
    4. -
  4. We then test for the existence of installCheck.result using an if statement. If it does exist, meaning that the app is installed, we hide the button. An install button isn't needed if it is already installed.
    5. -
  5. If the app isn't installed, we add a click event listener to the button, so the install() function is run when the button is clicked.
    6. -
  6. When the button is clicked and the install() function is run, we store the manifest file location in a variable called manifest_url, and then install the app using navigator.mozApps.install(manifest_url), storing a reference to that installation in the installLocFind variable. You'll notice that this installation also fires success and error events, so you can run actions dependent on whether the install happened successfully or not.
    7. -
- -

You may want to verify the implementation state of the API when first coming to Installable web apps.

- -
-

Note: Installable open web apps have a "single app per origin" security policy; basically, you can't host more than one installable app per origin. This makes testing a bit more tricky, but there are still ways around this, such as creating different sub-domains for apps, testing them using the Firefox OS Simulator, or testing the install functionality on Firefox Aurora/Nightly, which allows you to install installable web apps on the desktop. See FAQs about apps manifests for more information on origins.

-
- -

WebRT APIs (Permissions-based APIs)

- -

There are a number of WebAPIs that are available but require permissions for that specific feature to be enabled. Apps may register permission requests within the manifest.webapp file like so:

- -
// New key in the manifest: "permissions"
-// Request access to any number of APIs
-// Here we request permissions to the systemXHR API
-"permissions": {
-    "systemXHR": {}
-}
- -

The three levels of permission are as follows:

- - - -

For more information on app permission levels, read Types of packaged apps. You can find out more information about what APIs require permissions, and what permissions are required, at App permissions.

- -
-

It's important to note that not all Web APIs have been implemented within the Firefox OS Simulator.

-
- -

Tools & Testing

- -

Testing is incredibly important when supporting mobile devices. There are many options for testing installable open web apps.

- -

Firefox OS Simulator

- -

Installing and using the Firefox OS Simulator is the easiest way to get up and running with your app. After you install the simulator, it is accessible from the Tools -> Web Developer -> Firefox OS Simulator menu. The simulator launches with a JavaScript console so you can debug your application from within the simulator.

- -

App Manager

- -

The new kid on the block with regards to testing tools is called the App Manager. This tool allows you to connect desktop Firefox to a compatible device via USB (or a Firefox OS simulator), push apps straight to the device, validate apps, and debug them as they run on the device.

- -

Unit Testing

- -

Unit tests are extremely valuable when testing on different devices and builds. jQuery's QUnit is a popular client-side testing utility, but you can use any set of testing tools you'd like.

- -

Installing Firefox OS on a Device

- -

Since Firefox OS is an open source platform, code and tools are available to build and install Firefox OS on your own device. Build and installation instructions, as well as notes on what devices it can be installed on, can be found on MDN.

- -

Dedicated Firefox OS developer preview devices are also available: read our Developer preview phone page for more information.

- -

App Submission and Distribution

- -

Once your app is complete, you can host it yourself like a standard web site or app (read Self-publishing apps for more information), or it can be submitted to the Firefox Marketplace. Your app's manifest will be validated and you may choose which devices your app will support (e.g. Firefox OS, Desktop Firefox, Firefox Mobile, Firefox Tablet). Once validated, you can add additional details about your app (screenshots, descriptions, price, etc.) and officially submit the app for listing within the Marketplace. Once approved, your app is available to the world for purchase and installation.

- -

More Marketplace & Listing Information

- -
    -
  1. Submitting an App to the Firefox OS Marketplace
    2. -
  2. Marketplace Review Criteria
    3. -
  3. App Submission Video Walkthrough
    4. -
-
diff --git a/files/es/archive/b2g_os/releases/2.0/index.html b/files/es/archive/b2g_os/releases/2.0/index.html deleted file mode 100644 index df409eb076..0000000000 --- a/files/es/archive/b2g_os/releases/2.0/index.html +++ /dev/null @@ -1,116 +0,0 @@ ---- -title: Firefox OS 2.0 para desarrolladores -slug: Archive/B2G_OS/Releases/2.0 -tags: - - '2.0' - - B2G - - Firefox OS - - Notas de la versión -translation_of: Archive/B2G_OS/Releases/2.0 ---- -
-

En esta página se detallan las características para desarrolladores recientemente implementadas en Gecko específicos para Firefox OS 2.0.

-
-
-

El componente Gecko de Firefox OS 2.0 esta basado en Firefox 31/32.

-
-

Nuevas características

-

Esta sección provee un resumen de las nuevas características disponibles en Firefox OS 2.0. Para mas detalles de cambios en una plataforma especifica (Adiciones API, etc.), revisa la sección Adiciones de la plataforma en detalle.

-
-
- NFC
-
- Esta versión incluye soporte para contenido de dispositivo a dispositivo compartido con la tecnología NFC (Near Field Communication). Tu puedes emparejar tu dispositivo con cualquier otro y luego deslizar para compartir tus contactos, multimedia o URL's favoritas con otros.
-
- Telefonía
-
- Firefox OS ahora soporta direcciones IPv4 e IPv6 en el administrador de red.
-
- Encontrar Mi Dispositivo
-
- Si has perdido tu teléfono Firefox OS, Encontrar Mi Dispositivo puede ayudarte a encontrarlo (ve al sitio web http://find.firefox.com). Puedes verlo en un mapa, hacer que reproduzca un sonido y que muestre un mensaje en pantalla. También puedes bloquearlo remotamente o borrar tu información personal. Para empezar, crea una cuenta Firefox (Ajustes > Firefox Accounts en tu dispositivo) y activa Encontrar Mi Dispositivo (Ajustes > Encontrar mi dispositivo).
-
- Multimedia
-
- Ahora puedes crear tus propios ringtones usando tu propia colección de música, o canciones que has descargado de la web.
-
- Cámara
-
- La aplicación de la cámara ahora soporta varios modos de enfoque: Touch, auto continuo, y seguimiento de rostro.
-
- Productividad
-
- Hemos realizado una actualización visual a las aplicaciones de Correo, Calendario y Reloj.
-
- Pantalla de inicio
-
- Firefox OS 2.0 introduce una pantalla de inicio con desplazamiento vertical sencillo e iconos mas grandes.
-
- Cambio de aplicación con gestos en los bordes
-
- Gestos en los bordes están ahora disponibles para intercambiar entre las diferentes aplicaciones (desliza tu pulgar desde el borde izquierdo de la pantalla hacia el derecho y viceversa, para cambiar entre las múltiples aplicaciones abiertas).
-
-

Nuevas características para socios

-
-
- Integración E.ME 
-
- La integración E.ME proporciona acceso directo a aplicaciones web mientras proveedores de búsqueda configurables pueden buscar en la web al mismo tiempo.
-
-

Nuevas características en las DevTools

-

Las Herramientas para desarrolladores de Firefox han tenido un gran numero de características añadidas en las versiones 31 y 32 de Firefox; estas no son especificas de Firefox OS, pero puede tomar ventaja de ellas depurando tus aplicaciones para Firefox OS mediante el WebIDE. Para saber mas, lea:

- -

Adiciones de la plataforma en detalle

-
-

Nota: Esta lista incluye las características mas importantes de Firefox OS. Para una lista ampliada de característica añadidas a Gecko (que generalmente están presentes también en Firefox OS 2.0), consulta las notas de la versión para desarrolladores de Firefox 31 y las notas para desarrolladores de Firefox 32.

-
-

Web API

- -

CSS

- -

Mejoras en las tecnologías soportadas

- -

Versiones Antiguas

-

- -

diff --git a/files/es/archive/b2g_os/releases/2.1/index.html b/files/es/archive/b2g_os/releases/2.1/index.html deleted file mode 100644 index d43116ad1e..0000000000 --- a/files/es/archive/b2g_os/releases/2.1/index.html +++ /dev/null @@ -1,40 +0,0 @@ ---- -title: Firefox OS 2.1 para desarrolladores -slug: Archive/B2G_OS/Releases/2.1 -tags: - - '2.1' - - B2G - - Firefox OS - - Notas de la versión -translation_of: Archive/B2G_OS/Releases/2.1 ---- -
-

Firefox OS 2.1 está en una etapa de pre-lanzamiento en este momento. Su componente Gecko está basado en Firefox 33/34. En esta página se detallan las características para desarrolladores recientemente implementadas en Gecko específicamente para Firefox OS 2.1.

-
-
-

Nota: Para las características generales de Gecko que están también presentes en Firefox OS Gecko, consulta las notas de Firefox 33 para desarrolladores y notas de Firefox 34 para desarrolladores.

-
-

Cambios en la plataforma

-

Firefox OS tenia una política de seguridad de "Aplicación individual (single app) por origen", pero esto ha cambiado desde Firefox 34/Firefox OS 2.1 (leer FAQ para mas información). Si usted necesita compatibilidad con las versiones anteriores, considere alojar tus aplicaciones en orígenes separados; una estrategia posible es crear diferentes subdominios para tus aplicaciones.

-

Cambios en la API Web  

- -

Mira también

- -

Versiones Antiguas

-

- -

diff --git a/files/es/archive/b2g_os/releases/index.html b/files/es/archive/b2g_os/releases/index.html deleted file mode 100644 index f4d3874b14..0000000000 --- a/files/es/archive/b2g_os/releases/index.html +++ /dev/null @@ -1,24 +0,0 @@ ---- -title: Firefox OS developer release notes -slug: Archive/B2G_OS/Releases -tags: - - Firefox OS - - NeedsTranslation - - TopicStub -translation_of: Archive/B2G_OS/Releases ---- -

Firefox OS release notes by version

-

This section provides articles covering each new release of Gaia and Gecko for Firefox OS, explaining what features were added and bugs eliminated in each update. There is also a linked summary table showing what APIs are supported by each version of Firefox OS.

-
-
  1. Firefox OS 2.0 para desarrolladores
  2. Firefox OS 2.1 para desarrolladores
-

Other supporting information

-
-
- Firefox OS API support table
-
- Lists the different APIs available, and what versions of Firefox have support for them.
-
- App permissions
-
- Lists hosted, privileged and certified APIs, along with information on the permissions they need to have set in the App Manifest of your installable apps, such as the manifest permission name, app type required, description, access property, and default permission.
-
diff --git a/files/es/archive/b2g_os/screencast_series_colon__app_basics_for_firefox_os/index.html b/files/es/archive/b2g_os/screencast_series_colon__app_basics_for_firefox_os/index.html deleted file mode 100644 index 77c5748c58..0000000000 --- a/files/es/archive/b2g_os/screencast_series_colon__app_basics_for_firefox_os/index.html +++ /dev/null @@ -1,228 +0,0 @@ ---- -title: 'Series de Screencast: Lo Básico sobre Aplicaciones para Firefox OS' -slug: 'Archive/B2G_OS/Screencast_series:_App_Basics_for_Firefox_OS' -tags: - - API - - Apps - - B2G - - Firefox OS -translation_of: 'Archive/B2G_OS/Firefox_OS_apps/Screencast_series:_App_Basics_for_Firefox_OS' ---- -
-

Firefox OS es un sistema operativo que trae la Web a los dispositivos móviles; en lugar de ser un nuevo Sistema Operativo con nuevas tecnologías y entornos de desarrollo,  Firefox OS se basa en tecnologías web estándar que han estado en uso desde hace años. Si tu eres un desarrollador web y quieres construir una aplicación móvil, Firefox OS te da las herramientas para  hacerlo sin tener que cambiar tu flujo de trabajo o aprender un entorno de desarrollo totalmente nuevo. En esta colección de vídeos cortos, desarrolladores de Mozilla y Telenor se reunieron en Oslo, Noruega para explicar en pocos pasos como puedes empezar a construir aplicaciones para Firefox OS.

-
- -

En esta serie aprenderás:

- - - -
-

Nota: Cada uno de los screencast son lo suficientemente cortos para verlos durante un descanso. Toda la serie no debe tomar mas de una hora para observarla.

-
- -

Código y entorno de desarrollo

- -

Además de los screencasts, tu puedes descargar los códigos de ejemplo desde GitHub que los acompañan. Si deseas probar los códigos de ejemplo por ti mismo, necesitarás configurar un entorno de desarrollo muy sencillo. Todo lo que necesitas es:

- - - -

Presentación de la serie

- -

La serie nos muestra a Jan Jongboom (@janjongboom) y Sergi Mansilla (@sergimansilla) de Telenor Digital, y Chris Heilmann (@codepo8) de Mozilla; Fue grabada durante tres días en Oslo, Noruega en la sede central de Telenor en Febrero del 2014.

- -

Aquí estamos nosotros tres hablándote acerca de la serie y qué puedes esperar de ella:

- -

- -

Sección 1: Construyendo tu primera aplicación para Firefox Os y como publicarla

- -

En los primeros cinco screencast de la sección 1 mostraremos como construir una aplicación para Firefox Os, como depurarla y probarla en tu computadora y en un dispositivo real,  y como tenerla listada en el Firefox Marketplace. Esto puede sonar como mucho trabajo, pero pronto descubrirás que si ya sabes como construir un sitio web, tienes 90% del camino listo.

- -

Más que un sitio web

- -

Las aplicaciones de Firefox OS son HTML5, En esencia, estas usan las mismas tecnologías que los sitios web. Puedes empezar escribiendo un sitio web y convertirlo en una aplicación simplemente dándole un archivo de manifiesto (ver The app manifest para más detalles). Esto le dice a Firefox OS que estas escribiendo una aplicación y te permite:

- - - -

En esencia, las aplicaciones HTML5 son sitios web sobre alimentados y deben seguir las mismas reglas, como por ejemplo:

- - - -

La diferencia principal es que para que una página web se convierta en una gran aplicación, debes tener muy en cuenta a los usuarios móviles. Esto significa, ante todo, que tu aplicación debe:

- - - -

En muchos casos, esto significa que necesitas hacer más ligera tu página web y simplificar la interface. La buena noticia es que todos tus usuarios serán beneficiados por eso.

- -

- -
-

Nota: Para encontrar más información acerca de cómo diseñar una buena aplicación HTML5, entra al App Center en MDN.

-
- -

El archivo manifest de tu app

- -

El App Manifest en Firefox OS en un archivo simple de JSON que le dice al sistema operativo acerca de tu aplicación. En esencia, esto es lo que convierte una página web en una Open Web App. Dentro del manifest, tu defines el nombre en diferentes localidades y solicitas al sistema operativo tener acceso a varios servicios y al hardware. Incluso puedes editar la orientación predeterminada de tu aplicación, y de ser necesario, bloquear la orientación.

- -

- -

Para más información acerca del manifest y herramientas que pueden ayudarte:

- - - -

El gestor de aplicaciones

- -

La forma más sencilla de empezar a trabajar con Firefox OS es probando el gestor de aplicaciones App Manager.  Esta herramienta se encuentra junto al Firefox developer tools for desktop y te permite conectarte a un simulador de Firefox OS en su computadora, o a un dispositivo real con Firefefox OS si tienes uno disponible. Desde allí, puedes jugar con Firefox OS, instalar aplicaciones directamente dentro del simulador o en un dispositivo real, y depurarlas como si se ejecutaran en un Firefox OS , viendo los cambios inmediatamente en tiempo real sin necesidad de desinstalar o actualizar las aplicaciones.

- -

El siguiente video presenta los primeros pasos para el uso del App Manager junto con el simulador:

- -

- -
-

Nota: El App Manager te permite depurar tus propias aplicaciones sin ningun problema incluso cuando no estes conectado.

-
- -

Para más información sobre el App Manager:

- - - -

Probar en un Dispositivo Real

- -

Probar tus aplicaciones en un simulador esta bien, pero solo te lleva tan lejos como un ambiente simulado puede hacerlo. Si quieres probar el rendimiento de la interacción de la aplicación o la reacción a algunas cosas como la orientación del dispositivo, necesitas un dispositivo real. Con las herramientas de desarrollo y el App Manager juntos, puedes usar el dispositivo y adentrarte en los detalles de lo que pasa dentro de tu aplicación mientras la usas.

- -

- -

Publicar en el Marketplace

- -

El Marketplace de Firefox OS es el sitio mas conveniente para listas tus aplicaciones y ponerlas a disposicion de las personas en sus dispositivos y en la web. El Marketplace también te permite listar tu aplicación para otras plataformas como Firefox Desktop y Firefox para Android. Tambien puedes permitir que las personas valoren tu aplicación, den su opinión, y compren  tu aplicación usando un proceso simple de verificación. Listar tu aplicación es simple:

- - - -

- -

Las aplicaciones enviadas al Marketplace son revisadas por el equipo revisor de aplicaciones de Mozilla y se te notificara sobre el estado de tu envío en pocos días. Si existen problemas con tu aplicación recibirás un mensaje de validación durante el proceso, pero es posible que también recibas una explicación legible por humanos sobre lo que está mal y como solucionarlo.

- -
-

Nota: Lee Submitting an application to the Firefox Marketplace para más nformación sobre el procesos de envío.

-
- -

Sección 2: Tópicos Avanzados sobre Firefox OS

- -

En los primeros videos te presentamos Firefox OS y como desarrollar tu primera aplicación. También abarcamos como depurar tu aplicación en el escritorio (y en un dispositivo real), y como listar tu aplicación en el Marketplace de Firefox. En los cinco videos restantes nos adentraremos en las tecnologías que permiten a Firefox OS ir un paso más adelante y darte acceso a las funcionalidades que hacen del desarrollo para smartphones y tablets interesante para los desarrolladores. Pese a que muchas de estas tecnologías actualmente solo funcionan en Firefox OS, son todas de código abierto y han sido enviadas como propuestas estándar. Trabajar hoy con estas APIs significa que estás preparado para otros dispositivos y plataformas que emergerán en el futuro cercado.

- -

Web APIs

- -

Los Smartphones están llenos de tecnología grandiosa (cámaras, acelerómetros, y GPS para nombras algunos).  El problemas era que ellas no eran accesibles para tecnologias web, si querías acceder a ellas necesitabas escribir aplicaciones nativas. Para solucionar esto, Mozilla y sus socios diseñaron un conjunto de APIs para permitir a los desarrolladores alcanzar las profundidades del hadrware de los dispositivos móviles usando JavaScript de una forma segura. Estas son llamadas Web APIs y estan definidas abiertamente y disponibles para que otros las implementen. Firefox OS es la primera plataforma que las usa.

- -

 Más infromación en el siguiente screencast:

- -

- -

Para más información sobre las Web APIs:

- - - -

Web Activities

- -

Web Activities son métodos alternativos para acceder al hardware de un dispositivo. En vez de hacer que una API se comunique con el dispositivo directamente, Web Arctivities te permitirá crear un ecosistema de aplicaciones en el dispositivo que se comunican entre sí y comparten sus habilidades. Por ejemplo, en vez de acceder a la cámara directamente, tu aplicación puede usar un Web Activity para solicitar una imagen y el usuario del dispositivo puede usar su aplicación favorita para tomar una foto la cual es devuelta a la aplicación que realizo la petición originalmente.

- -

En vez de solicitar a los usuarios acceso a los dispositivos (lo cual es importante en términos de seguridad), les permitirás usar aplicaciones en la que ellos ya confían para realizar dichas funciones. Además,  puedes registrar tus aplicaciones como las opciones preferidas para ciertas tareas en el sistema operativo. Puedes pensar sobre los Web Activities como el equivalente de hacer clic con el botón derecho sobre un documento en el escritorio del computador y seleccionar con cual aplicación abrir dicho documento. Aparecerán diferentes opciones más una opción para hacer que el sistema operativo utilice de manera predeterminada esta aplicación para abrir los archivos de ahora en adelante.

- -

Web Activities permite a las aplicaciones comunicarse entre sí en el dispositivo sin ninguna necesidad de utilizar un servidor. Lo único que transmiten de una aplicación a la otra es la información final.

- -

- -

Para más información sobre Web Activities:

- - - -

Notificaciones Push

- -

Notificaciones Push (invocada usando el SimplePush Web API) son métodos para que una aplicación reaccione cuando el dispositivo recibe un mensaje específico. Esto te permitirá desarrollar aplicaciones que pueden estar cerradas (y ahorrando energía) hasta que sean necesarias. Las notificaciones creadas de esta manera tendrán el beneficio de no portar información y de esta manera Mozilla nunca obtendrá información sobre la aplicación y los atacantes no podrán acceder a la misma.

- -

- -

Para más información sobre cómo usar Notificaciones Push con SimplePush:

- - - -

Funcionalidad sin conexión

- -

Las aplicaciones no son muy útiles si no funcionan sin conexión web. Este es un motivo por el cual los usuarios prefieren aplicaciones ya instaladas en vez abrir el navegador del dispositivo y buscar el contenido en él. El término “aplicación web” pareciera indicar que se necesita de una conexión web para que la aplicación  se pueda usar.

- -

Nuestros usuarios estarán sin conexión web en algunas ocasiones (ya sea en un avión, en el subterráneo o sin plan de datos en la tarjeta SIM) y necesitamos asegurarnos de que nuestras aplicaciones sean útiles cuando eso suceda. HTML5 ofrece algunas tecnologías que permiten funcionalidad sin conexión web, principalmente AppCache y DOMStorage.

- -

- -

Para más información sobre funcionalidad sin conexión:

- - - -

Donde encontrar más

- -

Esperamos que esta serie de videos te haya dado una clara introducción para el desarrollo de tus propias aplicaciones web abiertas. Si te interesa aprender más, existen algunos recursos y canales que puedes usar:

- -

- - - -

Esperamos verte allí.

- -

Chris, Sergi y Jan

diff --git a/files/es/archive/b2g_os/security/application_security/index.html b/files/es/archive/b2g_os/security/application_security/index.html deleted file mode 100644 index 0573a493e0..0000000000 --- a/files/es/archive/b2g_os/security/application_security/index.html +++ /dev/null @@ -1,118 +0,0 @@ ---- -title: Seguridad en aplicaciones -slug: Archive/B2G_OS/Security/Application_security -translation_of: Archive/B2G_OS/Security/Application_security ---- -
-
-

Borrador
- Esta página no está completa.

- -
-

Los controles clave en la seguridad de las aplicaciones web introducidas por FirefoxOS son:

- -

Tipos de aplicaciones

-

FirefoxOS soporta tres tipos de aplicaciones web: "web", "privilegiadas" y "certificadas". Un tipo de aplicacion es declarado en su manifest, y determina la lista de permisos que puede solicitar.

- -

Para más detalles de los tres tipos, véase la documentación del App Manifest.

-

Entrega de aplicaciones

-

Las aplicaciones pueden ser  pueden ser entregadas por dos mecanismos diferentes en Firefox OS:  alojadas o enpaquetadas. Las aplicaciones web regulares pueden ser entregadas por cualquier mecanismo, mientras que las aplicaciones privilegiadas deben ser empaquetadas.

-

Aplicaciones alojadas

-

Una aplicación alojada consiste simplemente en un archivo manifest en el servidor del desarrollador. A menudo el manifest apunta también a un manifest de appcache que permite a la aplicación ser cacheada para un arranque más rápido y para habilitar el uso offline, pero de otra manera no afecta a la aplicación para nada. Desde el punto de vista de la seguridad, las aplicaciones alojadas funcionan como un sitio web normal. Cuando una aplicación alojada es cargada, la URL de las paginas cargadas son las URL que aquellas paginas tendrian normalmente en su servidor web. Así para enlazar a una página web específica o recurso en la aplicación, la misma URL es usada como cuando una URL es usada para enlazar a esa página o URL en un sitio web específico.

-

Aplicaciones empaquetadas

-

Una aplicación empaquetada es una Open Web App que tiene todos sus recursos (HTML, CSS, JavaScript, app manifest, etc.) contenidos en un archivo zip, en vez de tener sus recursos en un servidor web. Para más detalles en este formato, vease aplicaciones empaquetadas. 

-

Instalación de aplicaciones

-

Las aplicaciones son instaladas mediante la API Javascript de aplicaciones:

- -

Para asegurarse que una aplicación realmente quiere ser instalada como una aplicación web tenemos que asegurar que no es posible engañar a un sitio web para que aloje un manifest de aplicación. Esto es hecho exigiendo que el manifest sea servido con un mime-type específico, "application/x-web-app-manifest+json". Esta restricción se relaja cuando la aplicación manifest, y por lo tanto el manifest de aplicación, es del mismo origen que la página que hizo el pedido para instalar la aplicación.

-

Actualizaciones

-

El proceso de actualizaciones para las aplicaciones está descrito aquí:  Actualizando apliaciones [en-US]

-

Permisos

-

Se le pueden otorgar privilegios adicionales a las aplicaciones por sobre los privilegios de un sitio normal. Por defecto las aplicaciones tienen los mismos permisos que las páginas web normales. Para poder ganar permisos adicionales, el primer paso es enumerar los permisos adicionales que esta necesita en el manifest de la aplicación.

-

Declaración del manifest

-

Para cada permiso adicional que la aplicación quiera, el manifest debe enumerar el permiso junto con una descripción sencilla de por qué la aplicación necesita ese permiso. Por ejemplo si una aplicación quiere usar la API navigator.geolocation, debe incluir en su archivo manifest:

-
"permissions": {
-  "geolocation":{
-    "description": "Requerido para el autocompletado en la pantalla compartida",
-  }
-},
-
-

Esto permite a la aplicación indicar el permiso para la geolocalización, de la misma manera que una página web normal lo haría. Para más detalles acerca de los manifest, véase App manifest.

-

Nota: Actualemente la intensión de uso de los permisos no se muestran al usuario - véase bug 823385.

-

Otorgando permisos

-

Cuando los permisos son solicitados en el manifest, el permiso es definido como "allow" (permitir) o "prompt" (preguntar). Los permisos permitidos son otorgados al ser declarados en el manifest sin necesidad de más aprobaciones. Para permisos preguntados, se le pide el permiso al usuario la primera vez que la aplicación accede a la API relacionada, y tiene que tomar la decisión antes de que el acceso a la API sea otorgado. En general, Firefox OS solo pide a los usarios acerca de los permisos cuando estos pueden tener un impacto en la privacidad, y es razonable para el usuario entender que esta siendo pedido. Por ejemplo el acceso a los contactos es pedido,  sin embargo el acceso para hacer una conección TCP es simplemente garantizada porque no razonable para un usuario entender  las implicaciones de seguridad implicadas en permitir estos permisos. El uso de permisos "allow" es revisado como parte de la revisión de seguridad del Marketplace para asegurar que los usuarios se encuentran protegidos.

-

Revocando permisos

-

Los usuarios pueden cambiar su opinión en cualquier momento acerca de permisos "prompt" en cualquier momento, y puede revocar los permisos a través de la aplicación de configuracion de Firefox OS. Los permisos "allow" no son configurables por el usuario.

-

Sandbox de las aplicaciones Web

-

Información almacenada por aplicación

-

Cada aplicación corre su propio sandbox, eso significa que toda la información guardada por una aplicación es separada de toda la información guardada por cualquier otra aplicación. Esto incluye cosas como información de cookies, información almacenada localmente, bases de datos indexadas localmente, y permisos de sitios.

-

Esto significa que si un usuario instaló dos aplicaciones, la Aplicación A y la Aplicación B, estas tendrán cookies completamente diferentes, diferente información local, y diferentes permisos. Esto se aplica inclusive si ambas aplicaciónes abren un <iframe> que apunta hacia el mismo origen. Por ejemplo, si ambas aplicaciones A y B abren un <iframe> que apunta a "http://www.mozilla.org", ambas mostrarán la misma página web, sin embargo el sitio será cargado y mostrado con diferentes cookies en las dos aplicaciones.

-

Un resultado de esto es que si un usuario se registra en, por ejemplo Facebook, cuando está usando la aplicación A, esto afecta la capacidad de B para interactuar con la cuenta del usuario en Facebook. La cookie que que usa facebook para registrarse cuando el usuario está usando la aplicación A está solo disponible para la aplicación A. Si la aplicación B abre un <iframe> a Facebook, la cookie no estará allí y entonces cuando la aplicación B abre Facebook, recibe la pantalla de registro en vez de la cuenta del usuario.

-

Las aplicaciones no se pueden abrir entre ellas

-

Esto significa que las aplicaciones no pueden abrir otras aplicaciones a través del uso de iframes. Si la aplicación A crea un iframe con el src de la aplicación B, esto no abrirá la aplicación B en el iframe. Esto simplemente abrirá el sitio web qe se encuentra en esa URL. No usará ninguna de las cookies de B y por lo tanto no se comportará diferente si la aplicación B no estuviera instalada en el dispositivo.

-

Esto se aplica inclusive para las aplicaciones empaquetadas (más información acerca de estas abajo). inclusive si la aplicación A intenta abrir la aplicación enpaquetada B usando un iframe que apunte a app:// Dirección de la aplicación B, esto simplemente no podrá cargar. Si esto resulta en un error 404 o algún tipo de error determinado todavía falta deteminarse, pero definitivamente fallará al cargar. Y fallará de la misma manera no importa si la aplicación está instalada en el dispositivo o no, de modo que es imposible determinar para la aplicación A si la aplicación B se encuentra instalada.

-

Lo mismo sucede si el marco superior de la aplicación A es navegado por una URL a la aplicación B. Nosotros sabremos para un determinado marco que aplicación lo abrio, y por lo tanto cuando intente cargar la URL de la aplicación B en el marco de la aplicación A, esto sucederá exactamente como las dos situaciones descriptas arriba, por ejemplo, no hay forma de que use los recursos de B, como ser cookies u otra información local.

-

Motivación

-

Hay tanto beneficios como desventajas con este enfoque. La desventaja es que si un usuario interactúa con el mismo sitio web a través de diferentes aplicaciones, deberá registrarse en cada aplicación. Así tambien si un sitio web necesita almacenar información localmente, y el usuario interactúa con ese sitio en varias aplicaciones, la información terminará dplicada en cada aplicación, lo cual puede ser un problema si hay grandes cantidades de información.

-

El principal beneficio de de este enfoque es un modelo mucho más estable. No hay forma de que varias aplicaciones puedan hacerlo a través de sitios web de terceros en formas inesperadas que harían que instalar una aplicación haga que otra aplicación deje de funcionar. Cuando una aplicación es desinstalada, no hay forma que la información necesaria para otra aplicación se pierda, o que una aplicación deje de funcionar debido a una dependencia funcional con la aplicación desinstalada.

-

Un usuario puede instalar de forma segura la "Fabulosa Aplicación Social" para registrarse en Facebook sin tener que preocuparse que la aplicación "El Juego de DIbujos" pueda montar algún tipo de ataque para obtener la información del usuario de Facebook usando algún tipo de error o atajo que pueda existir en el sitio web de facebook.

-

También existen buenos beneficios para la privacidad. El usuario puede instalar de forma segura la "Aplicación de mi partido político" sin tener que preocuparse de que la "Apliación de empleados de la Megacorporación" sea capaz de detectar que aplicación se encuentra instalada o que información fue creada.

-

Permisos aislados

-

Así como la información de un sitio web es aislada por medio de una sandbox, también son aislados los permisos otorgados. Si la aplicación A carga una página de http://maps.google.com y la página pide utilizar la geolocalización y el usuario dice "permitir y recordar la decisión", esto solo significa que http://maps.google.com tiene acceo a la geolocalización dentro de la aplicación A. Si la aplicación B abre http://maps.google.com, esa página no tendrá acceso a la geolocalización a menos que el usuario le garantice ese permiso de vuelta.

-

Y como en un navegador normal, los permisos se encuentran separados por origen. Si la aplicación A tiene el acceso garantizado para utilizar geolocalización, esto no significa que todos los origenes corriendo en la aplicación A tendrán ese permiso. Si la aplicación A abre un <iframe> a http://maps.google.com, entonces http://maps.google.com tiene que pedir permiso antes que el acceso a la geolocalización sea garantizado.

-

Sandbox de la API para Navegadores

-

Para una seguridad adicional para aquellas aplicaciones que necesitan abrir una gran cantidad de URLs, como por ejemplo navegadores, añadimos el "browserContent flag" (indicador de contenido de navegador). El browserContent flag permite que cada aplicación tenga no una, sino dos sandbox, una para la aplicación en sí, y otra para cualquier contenido web que abra. Por ejemplo:

-

Digamos que la aplicación "Mi Navegador" carga desde el sitio  https://minavegador.com. Este es el dominio de donde los scripts y otros recursos son cargados. Los scripts y recursos pertenecen a este dominio.

-

Ahora bien, si esta aplicación crea un <iframe mozbrowser>, un sandbox diferente es creado para este <iframe>, el cual será un sandbox diferente del usado por la aplicación - por ejemplo, si este oframe navega a https://minavegador.com, esto resultará en diferentes cookies usados dentro del <iframe mozbrowser>. Así también el contenido dentro del <iframe mozbrowser> verá diferentes IndexedDB y bases de datos localStorage de las que abrió la aplicación.

-

Esto también se aplica si "Mi Navegador" quiere crear integración con, por ejemplo, Google Maps para implementar navegación basada en  to implementar navegación basada en la ubicación. Si la aplicación abre un <iframe> a http://maps.google.com, esto abrirá un iframe que recibirá las cookies para el sitio http://maps.google.com. Si el usuario navega dentro del área de contenido web, por ejemplo del <iframe mozbrowser>, a http://maps.google.com, este usará cookies diferentes y permisos diferentes de los que existen a nivel de la aplicación.

-

Otro ejemplo donde esto sería util sería en una aplicación tipo Yelp. Yelp tiene la capacidad de visitar el website de un restaurante direntamente desde la aplicación. Al usar un <iframe mozbrowser> para abrir el sitio web de un restorante, la aplicación Yelp se asegura que el el sitio web no puede tener un <iframe> apuntando a la aplicación de Yelp (lo cual apuntaría a http://yelp.com). Si lo hiciera, el sitio web recibiría el sitio web de Yelp, en vez de la aplicación. Así no existe manera de que el sitio web pueda montar un ataque a la aplicación ya que el sitio web de Yelp no compartirá ninguno de los permisos o la información de la aplicación Yelp.

-

Resumen de la Seguridad en Aplicaciones

-

La tabla de abajo resume los diferente tipos de aplicaciones de Firefox OS, y describe el formato, instalación, y el proceso de actualización de las Open Web Apps corriendo en Firefox OS.

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
- Tipos de aplicaciones web
TipoEntregaModelo de PermisosInstalaciónActualizaciones
WebAlojada o empaquetadaMenos sensible a los permisos que no son peligrosos para exponer a contenido web sin validadInstaladas desde cualquier lugarPueden ser actualizadas de forma transparente por el usuario o desde el marketplace, dependiendo de donde la aplicación fue instalada, y el mecanismo de entrega.
PrivilegiadaEmpaquetada y firmadaAPIs privilegiadas que requieren de validación y autenticación de la aplicaciónInstaladas desde un marketplace confiableActualizadas desde un marketplace confiable, al usuario se le pide aprovación para descargar e instalar las actualizaciones.
CertificadaEmpaquetadaAPIs poderosas y peligrosas que no se encuentran disponibles para aplicaciones de terceros.Preinstaladas en el dispositivoActualizadas solo como parte de las actualizaciones a nivel del sistema.
-

Nota: Para la  version 1.0 de Firefox OS, si bien las aplicaciones  web pueden ser instaladas desde cualquier sitio web o marketplace, las aplicaciones privilegiadas solo pueden ser instaladas desde el Mozilla Marketplace, como el soporte a multiples marketplaces confiable no está todavía completo.

diff --git a/files/es/archive/b2g_os/security/index.html b/files/es/archive/b2g_os/security/index.html deleted file mode 100644 index e88430f481..0000000000 --- a/files/es/archive/b2g_os/security/index.html +++ /dev/null @@ -1,72 +0,0 @@ ---- -title: Firefox OS security -slug: Archive/B2G_OS/Security -tags: - - B2G - - Firefox OS - - Mobile - - Móvil - - Seguridad - - TopicStub - - movil(2) -translation_of: Archive/B2G_OS/Security ---- -

Los siguienes artículos cubren información sobre la seguridad de Firefox OS. Esto incluye caracerísticas generales de seguridad así como seguridad en las aplicaciones y mantener el proceso de instalación seguro.

- - - - - - - - -
-

Documentación de seguridad de Firefox OS

- -
-
Modelo de seguridad de Firefox os
-
Un vistazo al manual de seguridad de Firefox  OS
-
Seguridad del sistema
-
Detalles de los controles de seguridad integrados en el runtime de Firefox OS
-
Seguridad de aplicaciones en Firefox OS
-
Un vistazo de cómo las aplicaciones son seguras en Firefox OS
-
Instalación y actualización segura de aplicaciones
-
Cómo Firefox OS instala y acualiza las aplicaciones de forma segura.
-
Permisos de Software en Firefox OS
-
Una guía de qué tipos de software tienen permisos para realizar varias tareas en Firefox OS.
-
 Depuración y pruebas de seguridad con Firefox OS
-
Esta guía muestra los pasos básicos de las pruebas de seguridad, desde la apertura de abrir un depurador remoto de JavaScript hasta la creación de un proxy HTTP/S de intercepción contra una versión de escritorio de Firefox OS.
-
- -

Ver Todo...

- 		-

Obtener ayuda de la Comunidad

- -

Si estás trabajando con Firefox OS, o desarrollando aplicaciones que te gustaría ejecutar en dispositivos Firefox OS, ¡Hay recursos de la comunidad para ayudarte!

- - - -

No te olvides de la  netiquette...

- - - - - -
- -

 

- -

-Firefox OS
diff --git a/files/es/archive/b2g_os/security/modelo_seguridad/index.html b/files/es/archive/b2g_os/security/modelo_seguridad/index.html deleted file mode 100644 index 8c03acd89e..0000000000 --- a/files/es/archive/b2g_os/security/modelo_seguridad/index.html +++ /dev/null @@ -1,255 +0,0 @@ ---- -title: Introducción a la seguridad de Firefox OS -slug: Archive/B2G_OS/Security/modelo_seguridad -translation_of: Archive/B2G_OS/Security/Security_model ---- -

Este documento proporciona una visión general del marco de trabajo de seguridad del sistema operativo de Mozilla Firefox OS, que está diseñado para proteger los dispositivos móviles de las amenazas a la plataforma, aplicaciones y datos. En Firefox OS, Mozilla ha implementado un modelo exhaustivo, integrado y de múltiples capas de seguridad que ofrece una protección mejor frente a los riesgos de seguridad en los teléfonos móviles.

-

Seguridad de la plataforma

-

Firefox OS en su plataforma utiliza un modelo de seguridad de varias capas que esta diseñado para reducir los riesgos de seguridad en todos los niveles. Contramedidas de primera línea se combinan con una estrategia de defensa en profundidad que proporciona protección completa contra amenazas.

-

Arquitectura de la seguridad

-

Firefox OS conecta las aplicaciones basadas en la web con el hardware subyacente. Se trata de una pila de tecnologías integradas que consiste en los siguientes niveles:

-

-

Mobile device es el teléfono móvil ejecutando Firefox OS. Gonk consiste en el kernel de Linux, las librerías del sistema, el firmware y los controladores del dispositivo. Gecko es la capa de tiempo de ejecución de aplicaciones que proporciona el marco de trabajo para la ejecución de aplicaciones, e implementa las API Web que se usan para acceder a las funciones del dispositivo móvil. Gaia es la colección de aplicaciones web que conforman la experiencia de usuario (aplicaciones que contienen desde HTML5, CSS, JavaScript, imágenes, medios, y así sucesivamente).

-

Gecko es el portero que hace cumplir las políticas de seguridad diseñadas para proteger el dispositivo móvil de un mal uso. La Capa Gecko actúa como intermediario entre las aplicaciones web (en la capa Gaia) y el teléfono. Gonk le ofrece las características del hardware del teléfono móvil directamente a la capa Gecko . Las aplicaciones web acceden a las funcionalidades del teléfono móvil sólo a través de las API Web, y sólo si Gecko permite la petición de acceso, no hay accesos directos ni "puertas traseras" en el teléfono. Gecko aplica los permisos e impide el acceso a las solicitudes no autorizadas.

-

Implementación del sistema de seguridad

-

Firefox OS viene instalado en el teléfono inteligente. la imagen original del sistema es creada por un conocido, una fuente de confianza que por lo general es el OEM del dispositivo, el cuál es responsable de ensamblar, construir, probar y firmar digitalmente el paquete que se distribuye.

-

Las medidas de seguridad se utilizan en toda la pila de tecnologías. Los privilegios del sistema de archivos son impuestas por las listas del control de acceso de Linux`s (ACLs). Las aplicaciones del sistema se instalan en un volumen que es de solo lectura (excepto durante las actualizaciones, donde es temporalmente tienen lectura y escritura ). Sólo las áreas que contienen los datos de usuario son de lectura y escritura. Varios componentes del hardware del dispositivo tiene una función de protección que se aplican de forma predeterminada como la práctica estándar de la industria. Los fabricantes de Chipset, por ejemplo, emplean técnicas de endurecimiento para reducir las vulnerabilidades. El núcleo de la plataforma (Gecko and Gonk) se endurece para reforzar su defensa contra las amenazas potenciales, utilizándose en su caso las características de endurecimiento del compilador. Para más detalles ver Seguridad en tiempo de ejecución.

-

Actualizaciones seguras del sistema

-

Las actualizaciones y parches a la plataforma Firefox OS se implementan usando un proceso seguro de Mozilla que asegura la integridad de la imagen del sistema en el teléfono móvil. La actualización es creada por un conocido, una fuente de confianza que por lo general es el OEM del dispositivo, el cuál es responsable de ensamblar, construir, probar y firmar digitalmente el paquete que se distribuye.

-

Las actualizaciones del sistema pueden incluir la totalidad o una parte de la pila de Firefox OS. Si cambios en Gonk son incluidos en la actualización, entonces FOTA (Firmware sobre el aire ) es el proceso de instalación utilizado. La actualización por FOTA puede incluir cualquier otra parte de la pila de Firefox OS, incluyendo la gestión del dispositivo(FOTA, firmware / drivers), gestión de la configuración(configuraciones de Firefox OS), actualizaciones de seguridad, Gaia, Gecko y otros parches.

-

Actualizaciones que no involucren a Gonk pueden hacerse usando la utilidad de actualización de sistemas de Mozilla. Firefox OS utiliza el mismo marco de trabajo de actualizaciones, los procesos y el formato de archivos de Mozilla (MAR)  (usado para actualizar los paquetes) como el producto Firefox para Escritorio. Para más información, consulte https://wiki.mozilla.org/Software_Update.

-

Al integrar el servicio de actualización que puede ser proporcionado por el fabricante, en el teléfono móvil comprueba periódicamente si hay actualizaciones del sistema. Una vez que un paquete del sistema esta disponible y es detectado por el servicio de actualizaciones, se solicita al usuario que confirme la actualización. Antes de instalar las actualizaciones en dispositivo móvil, se comprueba que haya suficiente espacio para aplicar la actualización y la distribución se verifica para:

- -

Las siguientes medidas de seguridad son utilizadas durante el proceso de actualización:

- -

Rigurosas comprobaciones se llevan a cabo para asegurar que la actualización es aplicada correctamente en teléfono móvil.

-

Seguridad en aplicaciones

-

Firefox OS utiliza una estrategia de seguridad de tipo defensa en profundidad apara proteger el teléfono móvil de las aplicaciones intrusivas o maliciosos. Esta estrategia cuenta con una variedad de mecanismos, incluyendo los niveles de permisos implícitos basados en un modelo de aplicaciones de confianza, la ejecución de recinto de seguridad en tiempo de ejecución, únicamente acceso al hardware subyacente teléfono móvil a través del API, un modelo de permisos robusto y seguridad en la instalación y los procesos de actualización. Para obtener información técnica, consulte: Seguridad de las aplicaciones.

-

En Firefox OS, todas las aplicaciones son aplicaciones web - programas escritos utilizando HTML5, JavaScript, CSS, media y otras tecnologías web abiertas (las páginas que se ejecutan en el navegador no se conocen como aplicaciones Web en este contexto). Porque no hay binario ("nativo") las aplicaciones instaladas por el usuario, todo acceso al sistema está mediada estrictamente a través de las API Web. Incluso el acceso al sistema de archivos es sólo a través de las API de Web y una base de datos SQLite de fondo - no hay acceso directo desde las aplicaciones a los archivos almacenados en la tarjeta SD.

-

Firefox OS limita y hace cumplir el ámbito de los recursos que pueden ser accedidos o utilizados por una aplicación, mientras que también apoya una amplia gama de aplicaciones con diferentes niveles de permisos. Mozilla implementa controles estrictos sobre qué tipo de aplicaciones pueden acceder a qué APIs. Por ejemplo, sólo las aplicaciones certificadas (se suministran con el teléfono) pueden tener acceso a la API de telefonía. La aplicación Marcador tiene privilegios para acceder a la API de telefonía para hacer llamadas telefónicas, pero no todas las aplicaciones certificadas se puede acceder a esta API. Esto evita que un escenario, por ejemplo, en el que se instala una aplicación de terceros arbitraria, marca un número de teléfono de pago por uso (900 y 910), y por debajo te consume gran cantidad del saldo del teléfono celular. Sin embargo, otras aplicaciones OEM pueden darse de forma selectiva el acceso a la API de telefonía. Por ejemplo, un operador podría proporcionar una aplicación de gestión de sistemas que permite a los clientes administrar su cuenta, incluyendo la posibilidad de llamar a la facturación del operador o de la oficina de apoyo directamente.

-

Aplicaciones confiables y no confiables

-

Firefox OS clasifica las aplicaciones de acuerdo a los siguientes tipos:

- - - - - - - - - - - - - - - - - - - - - - - - - -
-

Tipo

- 		-

Nivel de confianza

- 		-

Descripción

-
-

Certificadas

- 		-

Altamente confiable

- 		-

Aplicaciones del sistema que han sido aprobadas por el operador o el OEM (debido al riesgo de corrupción para el dispositivo o riesgo para las funcionalidades críticas). Aplicaciones y servicios del sistema solamente, no destinadas a aplicaciones de terceros.
- Esta designación se reserva para sólo un pequeño número de aplicaciones críticas. Ejemplos: SMS, Bluetooth, cámara, reloj del sistema, la telefonía y el marcador por defecto (para garantizar que los servicios de emergencia siempre están accesibles).

-
-

Privilegiadas

- 		-

Confiables

- 		-

Aplicaciones de terceros que han sido revisados, aprobados y firmados digitalmente por un mercado autorizado.

-
-

Web (todo lo demás)

- 		-

No confiables

- 		-

Contenido web regular. Incluye tanto las aplicaciones instaladas (almacenadas en el teléfono móvil) y las aplicaciones de servidor (almacenados remotamente, con sólo un archivo de manifiesto de aplicación almacenada en el teléfono móvil). El manifiesto para aplicaciones de servidor se puede obtener a través de un mercado de aplicaciones.

-
-

El nivel de confianza de una aplicación determina, en parte, su capacidad para acceder a la funcionalidades en el teléfono móvil.

- -

Algunas operaciones, como el acceso a la red, se supone de un permiso implícito para todas las aplicaciones. En general, cuanto más sensible es la operación (por ejemplo, marcar un número de teléfono o el acceso a la lista de contactos), mayor es el nivel de confianza requerido en la aplicación para ejecutarla.

-

Principle of Least Permissions

-

For web apps, the Firefox OS security framework follows the principle of least permissions: start with the absolute minimum permissions, then selectively grant additional privileges only when required and reasonable. By default, an app starts with very low permissions, which is comparable to untrusted web content. If the app makes Web API calls that require additional permissions, it must enumerate these additional permissions in its manifest (described later in this document). Gecko will consider granting Web API access to an application only if the applicable privileges are explicitly requested in its manifest. Gecko will grant the requested permission only if the type of the Web App (certified, trusted, or web) is sufficiently qualified for access.

-

Review Process for Privileged Apps in the Marketplace

-

In order for an app to become privileged, the app provider must submit it for consideration to an authorized Marketplace. The Marketplace subjects the app to a rigorous code review process: verifying its authenticity and integrity, ensuring that requested permissions are used for the purposes stated (in the permission rationale), verifying that the use of implicit permissions is appropriate, and validating that any interfaces between privileged app content and unprivileged external content have the appropriate mitigations to prevent elevation of privilege attacks. The Marketplace has the responsibility to ensure that the web app will not behave maliciously with the permissions that it is granted.

-

After an app passes this review, it is approved for use, its app manifest is digitally signed by the Marketplace, and it is made available for mobile users to download. The signature ensures that, if the web store were somehow hacked, the hacker could not get away with installing arbitrary content or malicious code on users’ phones. Due to this vetting process, Firefox OS gives privileged apps obtained from a Marketplace a higher degree of trust than everyday (untrusted) web content.

-

Packaged and Hosted Apps

-

Apps for Firefox OS can be either packaged (stored on the mobile phone) or hosted (stored on a remote web server, with just a manifest stored on the mobile phone). There are some differences in the way in which security is managed for each. Nonetheless, packaged and hosted apps are both subject to application sandboxing, which is described later in this document.

-

Packaged Apps

-

A packaged app consists of a ZIP file containing application resources (HTML5, CSS, JavaScript, images, media), as well as a manifest that provides an explicit list of assets and their corresponding hashes. Certified and privileged apps must be packaged apps because the app manifest needs to be digitally signed. When a user obtains a packaged app, the ZIP file is downloaded onto the mobile phone, and the manifest is read from a known location inside the ZIP file. During the install process, app assets are verified and remain stored locally in the package. All explicit permissions are requested at runtime, showing the user the app's data usage intentions, and persisted by default.

-

To refer to app resources in a packaged app, the URL begins with app: using the following format:

-

app://identifier/path_within_zipfile/file.html

-

where app:// represents the mount point for the ZIP file, and identifier is a UUID that is generated when the app is installed on the mobile phone. This mechanism ensures that resources referred to with an app: URL are contained in the ZIP file. The path within an app: is relative, so relative links to resources in the ZIP file are allowed.

-

While packaged apps are primarily intended to be used for Certified or Privileged apps, regular web apps can also be packaged. However, they do not gain any increase in trust or permissions access simply because they are packaged.

-

Hosted Apps

-

Hosted apps are located on a web server and loaded via HTTP. Only the app manifest is stored on the mobile phone. Everything else is stored remotely. Certain APIs are available only to privileged and certified apps, which requires the app to be packaged due to signing requirements. Therefore, a hosted app will not have access to any of the Web APIs operations that require privileged or certified app status.

-

From a security point of view, hosted apps work very much like normal websites. A hosted app is loaded by invoking a hard-coded, fully-qualified URL that points to the startup page in the root directory of the app on that web server. Once a hosted app is loaded, the mobile phone links to pages using the same URLs that are used when browsing the web site.

-

App Manifest

-

An Open Web App manifest contains information that a Web browser needs in order to interact with an app. A manifest is a JSON file with (at a minimum) a name and description for the app. For further details, refer to FAQs about app manifests.

-

Example Manifest

-

The following code listing shows an example manifest with just basic settings:

-
{
-  "name": "My App",
-  "description": "My elevator pitch goes here",
-  "launch_path": "/",
-  "icons": {
-    "128": "/img/icon-128.png"
-  },
-  "developer": {
-    "name": "Your name or organization",
-    "url": "http://your-homepage-here.org"
-  },
-  "default_locale": "en"
-}
-

Security Settings in the App Manifest

-

The manifest can also contain other settings, including the following security settings:

- - - - - - - - - - - - - - - - - - - - - - - - - -
-

Field

- 		-

Description

-
-

permissions

- 		-

Permissions required by the app. An app must list every Web API it intends to use that requires user permission. Most permissions make sense for privileged apps or certified apps, but not for hosted apps. Properties per API:

-
    -
  • description - A string specifying the intent behind requesting use of this API. Required.
    • -
  • access - A string specifying the type of access required for the permission. Implicit permissions are granted at install time. Required for only a few APIs. Accepted values: read, readwrite, readcreate, and createonly.
    • -
-
-

installs_allowed_from

- 		-

Origin of the app. Array of origins (scheme+unique hostname) that are allowed to trigger installation of this app. Allows app providers to restrict installs from only an authorized Marketplace (such as https://marketplace.firefox.com/).

-
-

csp

- 		-

Content Security Policy (CSP). Applied to all pages loaded in the app. Used to harden the app against bugs that would allow an attacker to inject code into the app. If unspecified, privileged and certified apps have system-defined defaults. Syntax:
- https://developer.mozilla.org/en-US/docs/Apps/Manifest#csp

-

Note that this directive can only increase the CSP applied. You cannot use it, for example, to reduce the CSP applied to a privileged App.

-
-

type

- 		-

Type of application (web, privileged, or certified).

-
-

Firefox OS requires that the manifest be served with a specific mime-type ("application/x-web-app-manifest+json") and from the same fully-qualified host name (origin) from which the app is served. This restriction is relaxed when the manifest app (and thus the app manifest) is same-origin with the page that requested the app to be installed. This mechanism is used to ensure that it's not possible to trick a website into hosting an application manifest.

-

Sandboxed Execution

-

This section describes application and execution sandboxes.

-

Application Sandbox

-

The Firefox OS security framework uses sandboxing as a defense-in-depth strategy to mitigate risks and protect the mobile phone, platform, and data. Sandboxing is a way of putting boundaries and restrictions around an app during run-time execution. Each app runs in its own worker space and it has access only to the Web APIs and the data it is permitted to access, as well as the resources associated with that worker space (IndexedDB databases, cookies, offline storage, and so on). For details, see https://developer.mozilla.org/en-US/docs/Mozilla/Firefox_OS/Security/Security_model.

-

The following figure provides an overview of this security model.

-

-

By isolating each app, its impact is contained within its own worker space. It cannot interfere with anything (such as other apps or their data) outside of that worker space.

-

Execution Sandbox

-

B2G (Gecko) runs in a highly-privileged system process that has access to hardware features in the mobile phone. At run-time, each app runs inside an execution environment that is a child process of the B2G system process. Each child process has a restricted set of OS privileges – for example, a child process cannot directly read or write arbitrary files on the file system. Privileged access is provided through Web APIs, which are mediated by the parent B2G process. The parent ensures that, when a child process requests a privileged API, it has the necessary permission to perform this action.

-

Apps communicate only with the B2G core process, not with other processes or apps. Apps do not run independently of B2G, nor can apps open each other. The only “communication” between apps is indirect (for example, when a listener process detects an event generated by some other process), and is mediated through the B2G process.

-

Hardware Access Only via the Web API

-

Web apps have only one entry point to access mobile phone functionality: the Firefox OS Web APIs, which are implemented in Gecko. Gecko provides the sole gateway to the mobile device and underlying services. The only way to access device hardware functionality is to make a Web API call. There is no “native” API and there are no other routes (no “back doors”) to bypass this mechanism and interact directly with the hardware or penetrate into low-level software layer.

-

Security Infrastructure

-

The following figure shows the components of this security framework:

-

- -

Permissions Management and Enforcement

-

Firefox OS security is designed to verify and enforce the permissions granted to web apps.
- The system grants a particular permission to an app only if the content requests it, and only if it has the appropriate permissions requested in the app’s manifest. Some permissions require further authorization from the user, who is prompted to grant permission (as in the case of an app requesting access to the user’s current location). This app-centric framework provides more granular control over permissions than traditional role-centric approaches (in which individual roles are each assigned a set of permissions).

-

A given Web API has a set of actions and listeners. Each Web API has a required level of permission. Every time a Web API is called, Gecko checks permission requirements (role lookup) based on:

- -

If the request does not meet the permission criteria, then Gecko rejects the request. For example, untrusted apps cannot execute any Web APIs that are reserved for trusted apps.

-

Prompting Users for Permission

-

In addition to permissions that are implicitly associated with the web apps, certain operations require explicit permission from the user before they can be executed. For these operations, web apps are required to specify, in their manifest, their justification for requiring this permission. This data usage intention informs users about what the web app intends to do with this data if permission is granted, as well as any risk involved. This allows users to make informed decisions and maintain control over their data.

-

Secure App Update Process

-

-

For app upgrades and patches to a privileged app, app providers submit the updated package to an authorized Marketplace, where it is reviewed and, if approved, signed and made available to users. On Firefox OS devices, an App Update Utility periodically checks for app updates. If an update is available, then the user is asked whether they want to install it. Before a update is installed on the mobile device, the package is verified for:

- -

Rigorous checks are in place to ensure that the update is applied properly to the mobile phone.
- The complete update package must be downloaded in a specific and secure location before the update process begins. Installation does not overwrite any user data.

-

Device Security (Hardware)

-

Security mechanisms for the mobile device hardware are typically handled by the OEM. For example, an OEM might offer SIM (Subscriber Identity Module) card locks, along with PUK (PIN Unlock Key) codes to unlock SIM cards that have become locked following incorrect PIN entries. Contact the OEM for details. Firefox OS does allow users to configure passcodes and timeout screens, which are described in the next section.

-

Data Security

-

Users can store personal data on their phone that they want to keep private, including contacts, financial information (bank & credit card details), passwords, calendars, and so on. Firefox OS is designed to protect against malicious apps that could steal, exploit, or destroy sensitive data.

-

Passcode and Timeout Screens

-

Firefox OS allows users to set a passcode to their mobile phone so only those who supply the passcode can use the phone. Firefox OS also provides a timeout screen that is displayed after a configurable period of phone inactivity, requiring passcode authentication before resuming use of the phone.

-

Sandboxed Data

-

As described earlier, apps are sandboxed at run time. This prevents apps from accessing data that belongs to other apps unless that data is explicitly shared, and the app has sufficient permissions to access it.

-

Serialized Data

-

Web apps do not have direct read and write access to the file system. Instead, all access to storage occurs only through Web APIs. Web APIs read from, and write to, storage via a an intermediary SQLite database. There is no direct I/O access. Each app has its own data store, which is serialized to disk by the database.

-

Data Destruction

-

When a user uninstalls an app, all of the data (cookies, localStorage, Indexeddb, and so on) associated with that application is deleted.

-

Privacy

-

Mozilla is committed to protecting user privacy and user data according to its privacy principles (https://www.mozilla.org/privacy/), which stem from the Mozilla Manifesto (https://www.mozilla.org/about/manifesto.html). The Mozilla Firefox Privacy Policy describes how Mozilla collects and uses information about users of the Mozilla Firefox web browser, including what Firefox sends to websites, what Mozilla does to secure data, Mozilla data practices, and so on. For more information, see:

- -

Firefox OS implements these principles by putting the control of the user data in the hands of the user, who gets to decide where this personal information goes. Firefox OS provides the following features:

- -

 

diff --git a/files/es/archive/b2g_os/simulator/index.html b/files/es/archive/b2g_os/simulator/index.html deleted file mode 100644 index e05c481b85..0000000000 --- a/files/es/archive/b2g_os/simulator/index.html +++ /dev/null @@ -1,258 +0,0 @@ ---- -title: Simulador de Firefox OS -slug: Archive/B2G_OS/Simulator -translation_of: Archive/B2G_OS/Simulator ---- -
-

El Simulador de Firefox OS está todavía en una etapa temprana de desarrollo, y aún no llega al nivel de confiabilidad que queremos.

- -

Si encuentra un error de cualquier tipo, cree un informe en GitHub, y si quiere hacernos una pregunta, utilice la lista de correo dev-developer-tools o en el canal #devtools de irc.mozilla.org (en inglés).

-
- -

El complemento Simulador de Firefox OS es una herramienta que le permite probar y depurar aplicaciones para Firefox OS en el escritorio. El ciclo de «programar–probar–depurar» es mucho más rápido con el Simulador que con un dispositivo de hardware real y, obviamente, no necesitará uno para utilizarlo.

- -

En esencia, el complemento del Simulador consiste de:

- - - -

La siguiente captura de pantalla muestra una sesión de depuración utilizando el Simulador.

- -

El tablero se encuentra en la esquina superior derecha de la imagen, ubicado en una pestaña de Firefox. Hemos añadido una aplicación empaquetada, llamada «Where am I?». En la esquina superior izquierda, hay una aplicación ejecutándose en el Simulador. Asimismo, hemos conectado las herramientas de depuración, que están en la ventana inferior. Puede ver que se ha alcanzado un punto de interrupción en la aplicación.

- -

- -

Esta guía abarca los temas siguientes:

- - - -

Para un tutorial práctivo que le muestra cómo utilizar el Simulador para depurar una aplicación web real, véase la página Paso a paso con el Simulador.

- -

Instalar el complemento del Simulador

- -

El Simulador está empaquetado y distribuido como un complemento de Firefox. Para instalarlo:

- -
    -
  1. Mediante Firefox, vaya a la página del Simulador en addons.mozilla.org.
    2. -
  2. Pulse en «Añadir a Firefox».
    3. -
  3. Una vez que se haya descargado completamente el complemento, se le solicitará instalarlo: pulse en «Instalar ahora».
    4. -
- -

Debido al tamaño del complemento, Firefox puede colgarse durante unos segundos mientras se instala, y es posible que aparezca el cuadro de diálogo «Aviso: script sin respuesta». Si esto ocurre, pulse en «Continuar» y espere a que la instalación finalice. Este problema se sigue en el error n.º 814505.
-
- Una vez instalado el complemento, Firefox comprobará si hay actualizaciones regularmente y lo mantendrá actualizado automáticamente.

- -

Cuando instala el Simulador, el tablero se abre automáticamente; y puede volverlo a abrir en cualquier momento yendo al menú «Firefox» (o el menú «Herramientas» en OS X y Linux) ▸ «Desarrollador web» ▸ «Firefox OS Simulator»:

- -


- El tablero es la herramienta que usará para añadir su aplicación al Simulador y ejecutarla. Así es como luce:
-

- -

Añadir, actualizar y desinstalar aplicaciones

- -

Añadir aplicaciones

- -

Para añadir una aplicación empaquetada al Simulador, abra el tablero, pulse en «Añadir un directorio» y seleccione el archivo manifest para su aplicación.
-
- Para añadir una aplicación alojada en la Web, escriba un URL en el cuadro de texto «URL de página o manifest.webapp», y luego pulse en «Añadir URL». Si el URL apunta a un manifest, ese manifest se utilizará. Si no, el tablero generará un manifest para el URL. De este modo puede añadir cualquier sitio como aplicación con tan solo introducir su URL.
-
- Cuando añade una aplicación, el tablero ejecutará una sserie de pruebas en el archivo manifest para comprbar problemas comunes. Consulte la sección Validación de manifest para obtener detalles sobre las pruebas que se ejecutan.

- -

A menos de que la validación del manifest muestre que su aplicación tiene errores, el tablero ejecutará la aplicación en el Simulador automáticamente.

- -

Gestión de aplicaciones

- -

Una vez que ha añadido una aplicación, ésta aparecerá en la lista de aplicaciones instaladas del gestor:
-
- Cada entrada proporciona información sobre la aplicación:

- - - -

También proporciona tres órdenes:

- - - -

Si ha conectado un dispositivo con Firefox OS a su equipo, verá una cuarta orden llamada «Instalar en dispositivo».

- -

Validación de manifest

- -

Cuando proporciona un manifest, el gestor ejecutará algunas pruebas de validación en él. El gestor informa tres clases de problemas:

- - - -

Se muestran resúmenes de los problemas encontrados en la entrada de la aplicación, al pulsar en los resúmenes se muestran más detalles.

- -

Errores del manifest

- -

El tablero informará las condiciones siguientes como errores, lo cual significa que no podrá ejecutar su aplicación si no los corrige:

- - - -

A continuación se muestra el resultado de intentar añadir un archivo manifest que carece del campo «name»:
-
-

- -

Avisos del manifest

- -

El tablero informará de los siguientes problemas de manifest como avisos:

- - - -

Avisos específicos del Simulador

- -

Finalmente, el gestor emitirá avisos para las aplicaciones que utilicen funciones de Firefox OS que todavía no son totalmente compatibles con el Simulador:

- - - -

Ejecutar el Simulador

- -

El Simulador se puede abrir de dos maneras:

- - - -

Una vez que inició el Simulador mediante cualquiera de estas formas, el botón «Detenido» se vuelve verde y su etiqueta cambia a «Ejecutándose». Para detener el Simulador, pulse en este botón de nuevo.
-
- El Simulador aparece en una ventana separada cuyo tamaño simula las dimensiones de una pantalla de 320 × 480 píxeles, y posee una barra de herramientas en la parte inferior que contiene algunas funciones adicionales.

- -

Para simular toques, puede pulsar con el ratón y arrastrar mientras mantiene oprimido el botón izquieerdo. Asi que, para ver las aplicaciones incorporadas en el sistema —y las que haya instalado—, pulse y arrastre con el ratón sobre la pantalla de inicio:

- -

- -

Barra de herramientas del Simulador

- -

La barra de herramientas ubicada en la parte inferior de la ventana contiene tres botones:
-
- De izquierda a derecha, son el botón «Inicio», «Simulación de giro» y «Simulación de geolocalización».

- - - -

Activar el registro de consola

- -

Si activa la casilla «Consola» que se ubica bajo el botón «Detenido/Ejecutándose», la Consola de errores se abrirá junto al Simulador. Su aplicación podrá crear registros en esta consola mediante el bojeto global «console».

- -

Adjuntar herramientas para desarolladores

- -

Puedes adjuntar herramientas para desarrolladores en el Simulador, para ayudar a depurar tu aplicación. Por el momento, puedes adjuntar únicamente el Depurador de JavaScript y la Consola Web, pero estamos trabajando para añadir soporte para mas herramientas para desarrolladores.

- -

Mientras que el Simulador esté en funcionamiento otro botón aparecerá debajo de la casilla "Consola". Está etiquetado "Conectar...":

- -

- -

Haz clic, y te llevará a una página parecida a esta:

- -

Haz clic en "Conectar" aquí y verás otra página, esta vez como esta:
-
-

- -

Para usar el Depurador de JavaScript, selecciona aquí "chrome://prosthesis/content/shell.xul". Una vez ejecutado, necesitarás buscar los scripts de tu aplicación en el seleccionador de script, pero si abres tu aplicación y luego te conectas al depurador, el script principal de tu aplicación será seleccionado como predeterminado:

- -

Para usar la Consola Web con tu aplicación, selecciona "Proceso Principal" en la ventana "Conectar a dispositivo remoto".

- -

Lamentablemente, no hay depuración de objetivo único que funcione con ambos la Consola Web y el Depurador JS - pero puedes ejecutar dos dos casos simultáneamente de las herramientas de depuración, una dirigida a "shell.xul" y otra a "Proceso Principal".

- -

Subir al dispositivo

- -

Si tienes un dispositivo Firefox OS puedes conectarlo al Simulador, y por ello puedes subirlo desde el panel de control a el dispositivo.

- -

Conectar un dispositivo

- -

Para conectar un dispositivo, sigue las instrucciones en la guía de connecting a Firefox OS device to the desktop. Recuerda que no tienes que instalar adb, ya que el complemento del Simulador ya lo incluye.

- -

 

- -

Subir aplicaciones al dispositivo

- -

Una vez que hayas configurado el dispositivo y escritorio, y conectado el dispositivo a tu escritorio mediante USB, verás aparecer el comentario "Dispositivo conectado." a la izquierda del panel de control, y un nuevo comando en la entrada por cada aplicación etiquetada "Subir":

- -

- -

Click "Push", and the app will be installed on the Firefox OS device.

- -

Solucionar problemas en Linux

- -

Si no puedes conectar tu dispositivo después de crear reglas udev, por favor vea este bug.

- -

 

- -

Limitaciones del Simulador

- -

Recuerda que el Simulador de Firefox OS no es una simulación perfecta.

- -

Limitaciones de hardware

- -

Aparte del tamaño de la pantalla, el Simulador no simula las limitaciones de hardware del dispositivo Firefox OS tales como memoria disponible o velocidad de la CPU.

- -

Códecs de Audio/Video

- -

Los siguientes códecs dependen en decodificación acelerada por hardware y por lo cual no hay asistencia todavía:

- - - -

Esto significa que no es posible usar el Simulador para probar la reproducción de video en aplicaciones y en páginas web como Youtube que dependen de esos códecs.

- -

APIs no admitidas

- -

Ciertas APIs que funcionan en el dispositivo no funcionarán en el Simulador, generalmente porque el soporte hardware no está disponible para el escritorio. Hemos implementado simulaciones para algunas APIs como geolocalización, y esperamos añadir más en futuras versiones. Sin embargo, por el momento las siguientes APIs no son compatibles. Usárlas podría traer errores o dar resultados incorrectos:

- - - -

Obtener ayuda

- -

Si encuentras algún bug, por favor archívalos en GitHub. Si tienes alguna cuestión, preguntanos en dev-developer-tools mailing list o en #devtools en irc.mozilla.org.

diff --git a/files/es/archive/b2g_os/usando_el_b2g_escritorio_cliente/index.html b/files/es/archive/b2g_os/usando_el_b2g_escritorio_cliente/index.html deleted file mode 100644 index 0fbbe96e02..0000000000 --- a/files/es/archive/b2g_os/usando_el_b2g_escritorio_cliente/index.html +++ /dev/null @@ -1,134 +0,0 @@ ---- -title: Usando el cliente de escritorio B2G -slug: Archive/B2G_OS/usando_el_B2G_escritorio_cliente -translation_of: Archive/B2G_OS/Building_the_B2G_OS_simulator ---- -

El cliente de escritorio Firefox OS, también llamado "Cliente de escritorio B2G", te permite correr Gaia y Apps Web en un entorno Gecko-based muy parecido a un dispositivo actual. No emula el hardware del dispositivo, por lo tanto no es apto para probar APIs de dispositivo, tampoco es un reemplazo para probar hardware actual. Sin embargo, tiene múltiples APIs habilitadas que no están disponibles en Firefox como las de Contactos y Opciones. Por lo tanto puede ser muy util durante el desarrollo de nuestra aplicación, o durante el trabajo con la intefaz de usuario de Gaia.

-

Este articulo trata sobre la descarga o compilación del cliente de escritorio Firefox OS i como utilizarlo.

-
-

Nota: La forma más sencilla para utilizar el cliente de escritorio de Firefox OS es utilizar el simulador de Firefox OS. No necesita de instalación de cliente por su parte.

-
-

Descarga una compilación "nightly"

-
-

Note: Firefox OS version 1.0 is based on a branch of Gecko 18. There are also nightly builds based on mozilla-central here:
- http://ftp.mozilla.org/pub/mozilla.org/b2g/nightly/latest-mozilla-central/

-
-

Just like Firefox Nightlies, the Firefox OS desktop client is built every day from the latest source code. The latest build is available from the Mozilla FTP server. Be sure to pick the latest version and the right archive for your operating system. This lets you bypass having to build it yourself. In addition, you don't have to download Gaia on your own either.

-

Be sure to install the application in a writeable location; the application needs to be able to update included the Gaia profile.

-

You can now skip ahead to Running the desktop client, unless you actually want to build it for yourself.

-

Building the desktop client

-

The first thing we need to do is set up a standard Mozilla build environment. Once we have that, we can pull down the code we'll need and configure to build the Firefox OS desktop client.

-

Downloading the code for the first time

-

In a directory where we'd like the source code to go, let's clone the mozilla-central repository that contains all of Gecko:

-
 hg clone http://hg.mozilla.org/mozilla-central
-
-

Updating the code

-

When we do subsequent builds later, we'll want to make sure we have the latest code. Here's how to pull the latest changes:

-
cd mozilla-central
-hg pull -u
-
-

Create a mozconfig

-

Next, we need to create a mozconfig file in the mozilla-central directory to configure the build system to build the Boot to Gecko client instead of Firefox:

-
mk_add_options MOZ_OBJDIR=../build
-mk_add_options MOZ_MAKE_FLAGS="-j9 -s"
-
-ac_add_options --enable-application=b2g
-ac_add_options --disable-libjpeg-turbo
-
-# This option is required if you want to be able to run Gaia's tests
-ac_add_options --enable-tests
-
-# turn on mozTelephony/mozSms interfaces
-# Only turn this line on if you actually have a dev phone
-# you want to forward to. If you get crashes at startup,
-# make sure this line is commented.
-#ac_add_options --enable-b2g-ril
-

Building

-

Now we're ready to build the desktop client with the following command issued from the mozilla-central directory:

-
make -f client.mk
-
-

The built client will be placed in the ../build/dist directory (based on the value you specify for MOZ_OBJDIR in the mozconfig file).

-

Downloading Gaia

-

By default the desktop client will show an empty screen because it doesn't know which Web app to load initially as the system app. The collection of system apps and default apps that come with Firefox OS is called Gaia.

-

To download Gaia for the first time, let's clone the source code repository on GitHub:

-
git clone https://github.com/mozilla-b2g/gaia
-cd gaia
-

To update an already existing clone of Gaia, we can pull in the latest changes from GitHub:

-
cd gaia
-git pull
-
-

Generating a profile

-

Next we need to set up Gaia's apps for the desktop client. This includes packaging the Gaia apps in the same way like they would be installed on the device, as well as setting up the permissions for the privileged system apps. We do this by generating a profile. The following command (run in the gaia directory) will take care of that:

-
make
-
-

This should create a profile directory below the gaia directory. The new profile contains a customized extension and other configuration needed to make B2G run properly.

-

Running the desktop client

-

Once you've built the client and downloaded Gaia (or downloaded and installed the nightly desktop application), you're ready to fire up the Firefox OS desktop client.

-

Running on Linux

-

To run the desktop client on Linux using the embedded Gaia profile, just run the b2g executable. If you want to specify a different Gaia profile, you need to bypass the b2g wrapper program and run the b2g-bin binary. The binary is in the archive you downloaded earlier or in the ../build/dist/bin directory if you built the client yourself.

-
.../b2g-bin -profile gaia/profile
-
-

You may experience annoying rendering problems. To avoid them, add the following line to your gaia/profile/user.js file:

-
user_pref("layers.acceleration.disabled", true);
-
-

Running on Mac

-

If you downloaded the nightly build, you can simply launch it from the Finder as usual. Any console output is visible by running the standard Console utility program included with your Mac.

-

If you want to specify a different Gaia profile, you need to bypass the b2g wrapper program and run the b2g-bin binary. The command line is slightly more complicated due to the location of the b2g-bin binary and the need for absolute paths when specifying the profile directory:

-
.../B2G.app/Contents/MacOS/b2g-bin -profile /full/path/to/gaia/profile
-
-

Running on Windows

-

Running the nightly build on Windows is as simple as launching b2g.exe. If you want to customize the execution, you can do so by running the b2g-bin.exe executable instead; this bypasses the wrapper program that automatically uses the bundled Gaia.

-

Command line options

-

There are a number of command line options you can use to adjust the runtime experience while using the desktop client. You can get a list by using the -help option. This section covers some of the particularly interesting ones.

-

Specifying the screen size

-

You can specify the screen size of the device you want to simulate using the --screen option:

-
b2g --screen=<width>x<height>[@<dpi>]
-

Where <width>, <height>, and <dpi> are fairly self-explanatory parameters: the width and height of the device's screen in pixels and the device resolution in DPI. For example:

-
b2g --screen=320x480
-b2g --screen=320x480@160
-
-

Optionally, you can specify certain devices by name to simulate their screen size and resolution:

- -

Opening the JavaScript console

-

You can open the JavaScript console when launching the desktop B2G client by launching it from the command line with the -jsconsole flag. After building, just do:

-
.../b2g -jsconsole -profile /path/to/your/profile
-

If you've installed the nightly build on a Mac, you can do the following:

-
/Applications/B2G.app/Contents/MacOS/b2g-bin -jsconsole -profile /path/to/your/profile
-
-

Note: On production builds of Firefox OS, console logging (such as by console.log()) is disabled by default. In order to enable it, open the Settings app and navigate down through Device Information->More Information->Developer, then toggle on the "Console Enabled" preference.

-
-

Launching a specific application at startup

-

You can now specify an application to be launched automatically when b2g starts up in the desktop client. This is done as soon as the rest of the system is done loading up. To do this, just use the --runapp option, which takes as a parameter the name of the application to run. For example:

-
 .../b2g-bin -profile /path/to/your/gaia/profile --runapp email
-

Before looking for an app to launch, the specified name is normalized by converting it to all lower case and removing all dashes and spaces. This normalized name is then compared to similarly normalized names from the manifests of available apps' manifests.

-

For example, the name of the email app is currently "E-mail", but --runapp email will work because of this normalization.

-

If you specify the --runapp option without an argument, or with an empty argument, the b2g client will output to your terminal a list of the known applications as well as a brief usage message.

-
-

Note: Using the --runapp option disables the lock screen as a side effect and does not re-enable it. It's assumed that you won't use this command on a profile on which you will be testing the lock screen, or you will turn it back on manually in Settings application. Feel free to contribute a patch to change this behavior if it's a problem.

-
-

Usage tips

-

This section provides a few helpful tips to using the B2G desktop client.

- -

Next steps

-

Now that you have a desktop build of Boot to Gecko running, you can do testing, development, and other work in it:

- diff --git a/files/es/archive/b2g_os/using_firefox_os_simulator/index.html b/files/es/archive/b2g_os/using_firefox_os_simulator/index.html deleted file mode 100644 index 158cdca809..0000000000 --- a/files/es/archive/b2g_os/using_firefox_os_simulator/index.html +++ /dev/null @@ -1,57 +0,0 @@ ---- -title: Using Firefox OS Simulator -slug: Archive/B2G_OS/Using_Firefox_OS_Simulator -translation_of: Archive/B2G_OS/Simulator ---- -

The Firefox OS Simulator is a desktop platform tool that shows you what apps will look like on a phone that is running the Firefox OS. It is the easiest way to try out apps on Firefox OS before submitting them to the Firefox Marketplace. The Firefox OS Simulator was formerly called "r2d2b2g", but that name is too difficult.

-

The Simulator is packaged as a desktop Firefox add-on. You can use any recent version of Firefox from Firefox 17 onward.

-

Although there are other ways to run the Firefox OS desktop, the best and most convenient way for app developers is this one. If you're a core Firefox OS platform developer, or are working on localization, there are other tools that are better suited for your needs. The Simulator add-on includes support for adding apps to the test environment, and is configured to support remote debugging, remote Web console, and other features. It also provides a visible Home button you can click, and sets the user-agent string to the one used by Firefox OS on devices. The result is, in nearly every way, a better environment for app developers.

-

Installing Firefox OS Simulator

-
    -
  1. Using Firefox, go to this link: https://addons.mozilla.org/addon/firefox-os-simulator/
    2. -
  2. Click Add to Firefox. It's a large download. Follow the prompts that appear.
    3. -
-
-

Because of the size of the add-on, Firefox may freeze for several seconds while installing it, and its unresponsive script dialog may appear, due to bug 814505. If it does, just click the Continue button, and Firefox will continue installing the add-on.

-
-

Starting the Simulator

-
    -
  1. On the Firefox menu (Windows) or the Tools menu (Mac, Linux), go to Web Developer and click Firefox OS Simulator. The dashboard appears. -

    Dashboard

    -
    2. -
  2. Click the Stopped button. It changes into the Running button and Firefox OS boots up in its own window. The default size for this window is 320x480. -

    Simulator

    -

    To stop the Simulator, click the Running button in the dashboard, or just close the Simulator window.

    -
    3. -
-
-

Note: You can also start and stop the Simulator in the Developer Toolbar command line using firefoxos start and firefoxos stop.

-
- -

Imitate swipe motions in the Simulator by clicking and dragging with the mouse. The mouse scroll wheel will move a list up and down, such as in the Settings app. Click and hold down the mouse button to simulate a long press.

-

To get back to the home screen, click the home button at the bottom of the Simulator, or press the Home key on your keyboard. On Mac keyboards without a Home key, use Fn + Left Arrow.

-

Console checkbox

-

Click the Console check box before you start the Simulator to open an error console so you can spot errors that might occur while you're working on your app.

-

Web APIs in the Simulator

-

Mozilla is working on many Web APIs to make native platform capabilities available to Open Web Apps. The Web APIs currently supported in the Simulator are:

- -

Installing an app in the Simulator

-

To install a hosted app in the Simulator, type the URL to the app's manifest in the URL box, and click Add Manifest. This will install the app in the Simulator. Here is a simple weather app that you can use as a test:

-
http://jlongster.github.com/weatherme/manifest.webapp
-

The app's icon will be added to one of the home screens in the Simulator.

-

You can also install a plain website in the same way. Just type the website's URL in the box and click Add URL, and an icon for the site will be added to a home screen. Autocompletion works if you have the website open in another tab.

-

To install a packaged app in the Simulator, click the Add Directory button, then select the mini-manifest of the app on your local filesystem.

-

To remove an app from the Simulator, click the Remove link for the app in the dashboard. You may have to restart the Simulator to see it gone.

-

Updating an app

-

If you are working on an app and need to update it in the Simulator, click the app's Update button in the dashboard. You will have to restart the Simulator. Hosted apps follow the usual rules for Website caching and working with appcache.

-

Reporting bugs

-

Remember that the Simulator is a brand-new tool and is still heavily under development. Please let us know if you find any bugs.

-

More information

-

The Simulator itself is the Firefox OS desktop client (also called the B2G desktop client), which is a build of Firefox OS that runs on Windows, Mac, and Linux. Firefox OS Simulator makes it easier to test apps on Firefox OS desktop because it includes functionality for adding apps to the environment and is configured/extended in a variety of ways to better meet the needs of app developers.

-

However, because the Simulator uses the Firefox OS desktop client, the documentation for B2G Desktop, Gaia, and B2G generally will also apply to the Simulator to some extent. Here are a couple of those docs:

-

Using the Firefox OS desktop client

-

Hacking Gaia

diff --git a/files/es/archive/b2g_os/using_the_app_manager/index.html b/files/es/archive/b2g_os/using_the_app_manager/index.html deleted file mode 100644 index bd8b6e6427..0000000000 --- a/files/es/archive/b2g_os/using_the_app_manager/index.html +++ /dev/null @@ -1,179 +0,0 @@ ---- -title: Usando el App Manager -slug: Archive/B2G_OS/Using_the_App_Manager -translation_of: Archive/B2G_OS/Using_the_App_Manager ---- -
-

El App Manager es una nueva herramienta disponible en Firefox para escritorio, que provee una cantidad de útiles herramientas para ayudarte a probar, desarrollar y depurar aplicaciones HTML5 en teléfonos Firefox OS y el Simulador de Firefox OS, directamente en tu navegador.

-
-

El App Manager se compone de:

- -

Instalación rápida:

-

Esta seccion esta diseñada para conseguir la puesta en funcionamiento lo antes posible; si necesitas mas detalles por favor siga adelante con la sección Configuración del dispositivo y sistema y continue leyendo desde allí. Vea también la sección Solución de problemas para obtener ayuda si tiene algún problema.

-
    -
  1. Asegúrate de tener Firefox para escritorio 26+ instalado
    2. -
  2. Abre el App Manager (en la barra de direcciones, tipea about:app-manager)
    3. -
  3. Si no tienes un dispositivo real: -
      -
    1. Install the Firefox OS Simulator
      2. -
    2. En la barra inferior del App Manager, haz clic en Start Simulator, después haz clic en el nombre del simulador instalado, que debe aparecer ahí.
      3. -
    -
    4. -
  4. Si tienes un dispositivo real: -
      -
    1. Asegúrate que tu dispositivo está corriendo Firefox OS 1.2+
      2. -
    2. En Opciones de tu dispositivo, desactiva el Bloqueo de pantalla (Opciones > Bloqueo de pantalla) y activa Depuración remota (Opciones > Información del dispositivo > Más información > Desarrollador)
      3. -
    3. Instala el ADB Helper como complemento en tu Firefox de escritorio
      4. -
    4. Conecta tu dispositivo a tu máquina vía cable USB
      5. -
    5. El nombre de tu dispositivo debería aparecer en la barra inferior del App Manager. Haz clic en él.
      6. -
    -
    5. -
  5. En la barra inferior debe aparecer "Conectar con: xxx"
    6. -
  6. Haz  clic en el panel de Apps y añade una app (empaquetada y hospedada)
    7. -
  7. El botón Iniciar valida tu app y la instala en el simulador / dispositivo
    8. -
  8. El botón Depurar conecta las herramientas para desarrolladores con la app arrancada
    9. -
-

Configuración del dispositivo y el sistema

-

Lo primero que tendrá que hacer cuando se utiliza el App Manager es asegurarse de que su sistema y el teléfono están configurados correctamente. En esta sección se ejecutarán todos los pasos necesarios.

-

Se requiere Firefox OS 1.2+

-

Asegúrese de que su dispositivo se está ejecutando Firefox OS 1.2/Boot2Gecko 1.2 o superior. Para comprobar qué versión de Firefox OS del dispositivo está funcionando, vaya a Ajustes > Información > Software.

-

Si usted no tiene una versión lo suficientemente alta instalada, dependiendo del teléfono que tiene, necesitará ya sea instalar una construcción nocturna disponible de Firefox OS 1.2 superior, o configurar y construir por sí mismo desde la fuente.

-

Construcciones disponibles:

- -

Para construir tu propia distribución de Firefox OS 1.2+, siga las instrucciones que se encuentran en Building and installing Firefox OS, iniciando con Firefox OS build prerequisites.

-

Depuración remota

-

A continuación, debe habilitar la depuración remota en Firefox OS. Para ello, vaya a Ajustes> Información> Más información> Desarrollador y active la casilla de depuración remota.

-

ADB o ADB helper

-

El proceso utiliza el puente de depuración Android (ADB) para manejar la conexión y comunicación entre el dispositivo y la computadora. Hay dos opciones para ejecutar ADB:

- -
-

Nota: no es necesario ejecutar este comando si tienes instalado el complemento ADB Helper.

-
-

Conectando tu disporitivo al App Manager

-

Con toda la configuración hecha, ahora es el momento de conectar el dispositivo a tu ordenador e iniciar el App Manager:

-
    -
  1. Conecta el dispositivo a tu computadora via USB
    2. -
  2. Desactiva el bloqueo de pantalla en tu dispositivo, vaya a Ajustes> Pantalla y desmarque la casilla Bloquear la pantalla. Esta es una buena idea, porque cuando la pantalla se bloquea, la conexión del teléfono se pierde, lo que significa que ya no está disponible para la depuración.
    3. -
  3. Inicia el App Manager, en el Navegador Firefox de escritorio seleccione la opción de menú Herramientas > Desarrollo web > App Manager, o escriba about:app-manager in la barra de direcciones.
    4. -
  4. En la parte inferior del App Manager, verás una barra de estado de conexión (vea la imagen de abajo). Usted debe ser capaz de conectar el dispositivo, haga clic en el botón "Connect to localhost: 6000".
    5. -
  5. Si esto funciona correctamente, un mensaje deberá aparecer en el dispositivo: "An incoming request to permit remote debugging connection was detected. Allow connection?". Pulsa el botón OK (También puede que tengas que pulsar el botón de encendido del teléfono para que pueda ver el mensaje.) La barra de estado de la conexión debe decir "Connected to B2G", con un botón Desconectar disponible para presionar si quieres cancelar la conexión.
    6. -
-

-
-

Tenga en cuenta que los otros controles en la barra de estado de la conexión permiten conectar un simulador para el Administrador de la aplicación, lo que vamos a cubrir en la siguiente sección, a continuación, y cambiar el puerto que la conexión pasa sucesivamente. Si cambia el puerto, también será necesario que habilite el reenvío de puertos para este puerto, así, como se indica en la sección ADB o ADB Helper.

-
-

Usar el complemento Firefox OS Simulator

-

Si no tienes un dispositivo real disponible para usar con el App Manager, puedes probarlo utilizando un el complemento Firefox OS Simulator. Para empezar, instala el simulador apropiado para su sistema operativo:

-

Install Simulator

-

Una vez que hayas instalado el simulador, tienes que ir a la barra de estado de la conexión en la parte inferior del App Manager, y haga clic en el botón "Start simulator". Aparecerán tres botones:

- -

Panel de aplicaciones

-

 

-

Ahora que todo funciona, vamos a revisar la funcionalidad disponible dentro de la App Manager, empezando por el Panel de aplicaciones. A partir de aquí, puede importar una aplicación existente para instalar en su dispositivo y depurarlo:

- -

La información sobre su aplicación debe aparecer en la parte derecha de la ventana, como se ve a continuación:

-

-

Editor del Manifiesto

-

Desde Firefox 28 en adelante, el panel de aplicaciones incluye un editor para el manifiesto de la aplicación:

-

-

Depuración

-

Al hacer clic en "Update" actualizará (o instalará) la aplicación en el dispositivo. Al hacer clic en "debug" se conectará una caja de herramientas de la aplicación, lo que le permite depurar su código directamente:

-

-
-

Nota: podrás disfrutar jugando con la caja de herramientas - intenta alterar el DOM, CSS, etc y verás los cambios reflejados en el dispositivo en tiempo real. Tales cambios se guardarán en el código de la aplicación instalada, las verás la próxima vez que abras la aplicación en el dispositivo.

-
-

Antes de Firefox 28, las herramientas se ponen en marcha en una ventana separada. Desde Firefox 28 en adelante, las herramientas se inician en una ficha independiente en la propia App Manager, junto con las aplicaciones y las fichas de dispositivos. La ficha tendrá el icono de la aplicación, así que es fácil de encontrar:

-

-

Errores

-

Si una aplicación no se ha añadido con éxito - por ejemplo, si la URL es incorrecta, o se ha seleccionado una carpeta aplicación empaquetada - una entrada se agrega a la página de esta aplicación, pero esto va a incluir información de errores.

-

-

También puedes eliminar una aplicación desde esta vista, el ratón encima del nombre/Descripción de la App en la izquierda de la ventana, y pulsando el botón "X" que aparece en cada caso. Sin embargo, esto no elimina la aplicación del dispositivo. Para ello es necesario eliminar manualmente la aplicación utilizando el propio dispositivo.

-

Panel del Dispositivo

-

La ficha de dispositivos muestra información sobre el dispositivo conectado. Desde la ventana "Aplicaciones instaladas", las aplicaciones en el dispositivo se pueden iniciar y depurar.

-

-
-

Nota: las aplicaciones certificadas no están listadas por defecto. Vea como depurar aplicaciones certificadas.

-
-

La ventana "Permissions" muestra los privilegios requeridos por las diferentes Web APIs en el dispositivo actual:

-

-

Finalmente, puedes tomar una captura de pantalla del dispositivo haciendo click en el botón "Screenshot". la imagen aparecerá en una nueva pestaña en Firefox, y desde allí podrás guardarla o descartarla si es tu elección.

-

Depurar aplicaciones certificadas

-

Actualmente, sólo los dispositivos que ejecutan una versión de desarrollo de Firefox OS 1.2 son capaces de depurar aplicaciones certificadas. Si tienes una versión en desarrollo, puede habilitar la depuración de aplicaciones certificadas por el cambio de las prefe-certificada devtools.debugger.forbid-apps en false en tu perfil. Para ello, siga los pasos a continuación:

-
    -
  1. -

    En tu computadora, ingresa el siguiente comando en el terminal para entrar al sistema de archivos de tu dispositivo via consola:

    - 
    adb shell
    -

    tu consola debe cambiar a root@android.

    -
    2. -
  2. -

    A continuación, detener B2G corriendo el siguiente comando:

    - 
    stop b2g
    -
    3. -
  3. -

    Navega al siguiente directorio:

    - 
    cd /data/b2g/mozilla/*.default/
    -
    4. -
  4. -

    Aquí, actualiza el archivo pref.js con la siguiente linea:

    - 
    echo 'user_pref("devtools.debugger.forbid-certified-apps", false);' >> prefs.js
    -
    5. -
  5. -

    Después de que termines de editar y salvar el archivo, inicia B2G usando el siguiente comando:

    - 
    start b2g
    -
    6. -
  6. -

    Sal del sistema de archivos del dispositivo cuando el comando exit; con esto regresarás a tu terminal normal.

    -
    7. -
  7. -

    Ahora reconecta el App Manager y deberías poder ver las aplicaciones certificadas para su depuración.

    -
    8. -
-
-

Nota: Si deseas agregar esta preferencia a tu construcción de Gaia puedes correr el comando make DEVICE_DEBUG=1 reset-gaia.

-
-

Solución de problemas

-

Si el dispositivo no es renonocido:

- -

¿No puedes conectar tu dispositivo al App Manager o iniciar el simulador?  Háganos saber o abra un bug.

diff --git a/files/es/archive/b2g_os/ux/building_blocks/action_menu/coding/index.html b/files/es/archive/b2g_os/ux/building_blocks/action_menu/coding/index.html deleted file mode 100644 index a914e72083..0000000000 --- a/files/es/archive/b2g_os/ux/building_blocks/action_menu/coding/index.html +++ /dev/null @@ -1,80 +0,0 @@ ---- -title: 'Coding guide: Action menus' -slug: Archive/B2G_OS/UX/Building_blocks/Action_menu/Coding -translation_of: Archive/B2G_OS/Firefox_OS_apps/Building_blocks/1.x/Action_menu/Coding ---- -

Here you can find examples of how to create action menus on Firefox OS, as well as downloads for the CSS and image resources used by the built-in apps on Firefox OS. You can copy these resources into your app and make use of them to build apps that match these apps' appearances.

- -
-

Note: Object menus are implemented using the same code; the only difference is that you never use a title in an object menu.

-
- -

Implementing action menus

- -

To implement an action menu using the style shown here, place the CSS and media files into your app and then import the CSS using the {{cssxref("@import")}} at-rule:

- -
@import url(resources/action_menu.css);
- -

Make sure the media files are in the location expected by the CSS (either by placing them in a corresponding location or by revising the CSS).

- -

Examples

- -

With title

- -

HTML to create the menu

- -

The HTML below creates the dialog with four buttons, one of which is disabled.

- -
<form role="dialog" data-type="action" onsubmit="return false;" id="sample-menu">
-  <header id="sample-title"> Title </header> <!-- this header is optional -->
-  <menu>
-    <button id="button1"> Action 1 </button>
-    <button id="button2" disabled> Action 2 (disabled) </button>
-    <button id="button3"> Action 3 </button>
-    <button id="cancel"> Cancel </button>
-  </menu>
-</form>
-
- -

JavaScript content

- -

The JavaScript below simply adds code to some of the buttons to change the title of the dialog when clicked.

- -
var btn = document.querySelector("#button1");
-btn.addEventListener("click", function() {
-  var title = document.getElementById("sample-title");
-  title.innerHTML="Button 1";
-});
-
-var btn = document.querySelector("#button3");
-btn.addEventListener("click", function() {
-  var title = document.getElementById("sample-title");
-  title.innerHTML="Button 3";
-});
-
- -

Working demo

- -

You can try out the action menu in this live demonstration.

- -

Without title

- -

HTML to create the menu

- -

The HTML below creates the dialog with four buttons, one of which is disabled.

- -
<form role="dialog" data-type="action" onsubmit="return false;" id="sample-menu">
-  <menu>
-    <button id="button1"> Action 1 </button>
-    <button id="button2" disabled> Action 2 (disabled) </button>
-    <button id="button3"> Action 3 </button>
-    <button id="cancel"> Cancel </button>
-  </menu>
-</form>
-
- -

Working demo

- -

You can try out the action menu in this live demonstration.

- -

 

diff --git a/files/es/archive/b2g_os/ux/building_blocks/action_menu/index.html b/files/es/archive/b2g_os/ux/building_blocks/action_menu/index.html deleted file mode 100644 index e4263d2d1a..0000000000 --- a/files/es/archive/b2g_os/ux/building_blocks/action_menu/index.html +++ /dev/null @@ -1,46 +0,0 @@ ---- -title: Menú de acciones -slug: Archive/B2G_OS/UX/Building_blocks/Action_menu -translation_of: Archive/B2G_OS/Firefox_OS_apps/Building_blocks/1.x/Action_menu ---- -

Un menú de acciones, como indica su nombre, muestra un listado de acciones, relativas al contenido de la aplicación, a traves del cual el usuario puede elegir qué hacer. Visita la Guía de código para saber cómo implementar un menú de acciones en tu aplicación.

-

Caracteristicas

- -

Visuales

- - - - - - - -
-

Estado de reposo

-

-

El boton de acciones abierto, esperando a que el usuario presione una seleccion.

- 		-

Estado pulsado

-

-

Aspecto del menu mientras el dedo del usuario presiona la "Opcion 03".

-
-

Variaciones

-

Existen dos variaciones basicas en el menu de acciones: que el menu tenga o no una cadena de titulo en la parte superior.

-

-

Interaccion

-

El diagrama muestra como trabaja el flujo de interaccion del ususario con el menu de acciones.

-

-

Ver tambien

- diff --git a/files/es/archive/b2g_os/ux/building_blocks/button/index.html b/files/es/archive/b2g_os/ux/building_blocks/button/index.html deleted file mode 100644 index a2e0612620..0000000000 --- a/files/es/archive/b2g_os/ux/building_blocks/button/index.html +++ /dev/null @@ -1,231 +0,0 @@ ---- -title: Botón -slug: Archive/B2G_OS/UX/Building_blocks/Button -translation_of: Archive/B2G_OS/Firefox_OS_apps/Building_blocks/1.x/Button ---- -

Realiza una acción cuando es pulsado por el usuario. Son objetos de interfaz de usuario que tienen una amplia variedad de estilos. Consulta la Guía de codificación para informarte sobre cómo implementar botones con un aspecto como los que aquí se describen.

-

Características

- -

Hay multiples tipo de botones:

-
-
- Botones de acción
-
- Se utilizan cuando solo hay unas pocas acciones y no es necesaria una lista. La acción principal del botón utiliza un color especial resatado para indicar que es la opción principal.
-
- Botones de lista
-
- Se utilizan para mostrar una lista de acciones,  o para activar la presentación de un valor de selección.
-
- Botones de campo de entrada
-
- Se utilizan para llevar a cabo acciones con campos de entrada.
-
- Botones especiales/pesonalizados
-
- Se utilizan para proporcionar acciones específicas incluyendo grabar, llamar y similares.
-
-

Visualización

-

Aquí hay varios ejemplos visuales de cómo deberían verse los botones. No olvides que puedes usar la hoja de estilos y los recursos de imágenes proporcionados en la Guía de codificación para implementarlos.

-

Botones de acción

-

Se utilizan cuando solo hay unas pocas acciones y no es necesaria una lista. La acción principal del botón utiliza un color especial resatado para indicar que es la opción principal.

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 Acción principalAcción secundariaBorrar
Normal
Presionado
Deshabilitado
-

Sobre fondo oscuro, los botones deshabilitados tienen un aspecto especial, como se ve abajo.

- - - - - - - - - - - - - - - -
 Acción principalAcción secundaria
Disabled
-

Botones de lista

-

Se utilizan para mostrar una lista de acciones,  o para activar la presentación de un valor de selección.

-

Desencadenar acciones

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 Desecadenar una acción en la vista actualDesencadenar una acción en una nueva vistaMostrar un selector de valores
Normal
Presionado
Deshabilitado
-

Selección de valores

-

Una vez que se abre un selector de valores, necesitarás al menos un botón en el panel de selección de valores para descartar el valor seleccionado. Estos botones deberían tener el siguiente aspecto:

- - - - - - - - - - - - - - - -
NormalPresionadoDeshabilitado
-

Botones de campos de entrada

-

Los botones de campos de entrada son botones asociados a un campo de entrada, que cuando se presionan, llevan a cabo una acción relacionada con ese campo de entrada.

- - - - - - - - - - - - - - - -
NormalPresionadoDeshabilitado
-

Botones especiales

-

Los botones especiales son botones visuales al estilo icono que se utilizan para propósitos especiales, tales como operar con la cámara del dispositivo, contestar o colgar el teléfono y activar el teclado de llamada. Por supuesto puedes encontrar otras utilidades a estos botones especiales.

-

Botones de cámara

-

Estos botones no tienen estado deshabilitado; simplemente no los muestras si la ocpión de tomar fotos no está disponible.

- - - - - - - - - - - - - - - - - - - - - - - -
 Grabar videoDetener grabación videoTomar foto
Normal
Presionado
-

Botones de teléfono

- - - - - - - - - - - - - - - - - - - - - - - - - - - -
 DescolgarColgarOcultar teclado
Normal
Presionado
Deshabilitado
-

Botones personalizados

-

Estos son ejemplos de botones personalizados; en este caso, para añadir un contacto.

- - - - - - - - - - - - - - - -
Normal
Presionado
Deshabilitado
-

Ver también

- diff --git a/files/es/archive/b2g_os/ux/building_blocks/index.html b/files/es/archive/b2g_os/ux/building_blocks/index.html deleted file mode 100644 index 33fc3c8a70..0000000000 --- a/files/es/archive/b2g_os/ux/building_blocks/index.html +++ /dev/null @@ -1,268 +0,0 @@ ---- -title: Componentes básicos de UX de Firefox OS -slug: Archive/B2G_OS/UX/Building_blocks -translation_of: Archive/B2G_OS/Firefox_OS_apps/Building_blocks/1.x ---- -

Aquí encontrarás una descripción de los elementos de la interfaz de usuario comunes en las aplicaciones de Firefox  OS, además de ejemplos de cómo debe verse y funcionar.

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-

Menú de acciones

-
-


-  Detalles
- Guía del programador

- 		-

 

-
-

Botón

-
-

- -

Detalles
- Guía del programador

- 		-

 

-
-

Confirmación

-
-

- -

Detalles
- Guía del programador
-  

- 		-

 

-
-

Filtro

-
-

- -

Detalles
- Guía del programador

- 		-

 

-
-

Cabecera

-
-

- -

Detalles
- Guía del programador

- 		-

 

-
-

Área de entrada

-
-

- -

Detalles
- Guía del programador

- 		-

 

-
-

Lista

-
-

- -

Detalles
- Guía del programador

- 		-

 

-
-

Menú de objetos

-
-

- -

Detalles
- Guía del programador

- 		-

 

-
-

Indicador de progreso y actividad

-
-

- -

Detalles
- Guía del prgramador

- 		-

 

-
-

Desplazamiento por letras

-
-

- -

Detalles
- Guía del programador

- 		-

 

-
-

Barra de búsqueda

-
-

- -

Detalles
- Guía del programador

- 		-

 

-
-

Estado

-
-


- Detalles
- Guía del programador

- 		-

 

-
-

Interruptor

-
-

- -

Detalles
- Guía del programador

- 		-

 

-
-

Pestañas

-
-

- -

Detalles
- Guía del programador

- 		-

 

-
-

Barra de herramientas

-
-

- -

Detalles
- Guía del programador

- 		-

 

-
-

Selector de valor

-
-

- -

Detalles
- Guía del programador

- 		-

 

-
- -

 

diff --git a/files/es/archive/b2g_os/ux/guia_estilo/index.html b/files/es/archive/b2g_os/ux/guia_estilo/index.html deleted file mode 100644 index 5a205c7bdf..0000000000 --- a/files/es/archive/b2g_os/ux/guia_estilo/index.html +++ /dev/null @@ -1,62 +0,0 @@ ---- -title: Guía de estilo de Firefox OS -slug: Archive/B2G_OS/UX/Guia_estilo -translation_of: Archive/B2G_OS/Firefox_OS_apps/Copy_styleguide ---- -

Hemos puesto a su disposición elementos de diseño visual, incluyendo componentes básicos, plantillas, fondos de pantalla y más, que puede descargarlos desde nuestra colección de elementos.

-

Iconos para aplicaciones

-

¿Necesita ayuda para crear un icono para su aplicación? Échele un vistazo a nuestras pautas y plantillas.

-

Tono de voz del texto

-

Títulos

- -

Botones

- -

Listas de selector de valores

- -

Mejores prácticas generales

- -

Formularios

- -

Términos específicos

- -

Cómo mostrar unidades de tamaños de archivo

- -

Véase también

- diff --git a/files/es/archive/b2g_os/web_telephony_api/index.html b/files/es/archive/b2g_os/web_telephony_api/index.html deleted file mode 100644 index 149350095e..0000000000 --- a/files/es/archive/b2g_os/web_telephony_api/index.html +++ /dev/null @@ -1,28 +0,0 @@ ---- -title: Web Telephony API -slug: Archive/B2G_OS/Web_Telephony_API -tags: - - NeedsTranslation - - Phone - - Telephony - - TopicStub - - Voice - - WebAPI -translation_of: Archive/B2G_OS/Web_Telephony_API ---- -

WebTelephony is an API that makes it possible for web content to handle voice phone calls from JavaScript code.

-

The API is available using window.navigator.mozTelephony. See below for a full list of interfaces:

-

DOM interfaces

- -

Sample code and introduction

-
-
-

See also

- diff --git a/files/es/archive/b2g_os/web_telephony_api/introduccion_a_la_webtelephony/index.html b/files/es/archive/b2g_os/web_telephony_api/introduccion_a_la_webtelephony/index.html deleted file mode 100644 index 1b7eb653f8..0000000000 --- a/files/es/archive/b2g_os/web_telephony_api/introduccion_a_la_webtelephony/index.html +++ /dev/null @@ -1,64 +0,0 @@ ---- -title: Introducción a la WebTelephony -slug: Archive/B2G_OS/Web_Telephony_API/Introduccion_a_la_WebTelephony -translation_of: Archive/B2G_OS/Web_Telephony_API/Using_the_Web_Telephony_API ---- -

La base de acceder a la funcionalidad del teléfono es simplemente a través de navigator.mozTelephony, que es parte de la WebTelephony API. Una vez que tenga una referencia a ese objeto se puede empezar a hacer y de recibir llamadas. Aquí hay algunos ejemplos:

-
// Objeto telephony
-var tel = navigator.mozTelephony;
-
-// Comprueba si el teléfono está silenciado (propiedad de lectura/escritura)
-console.log(tel.muted);
-
-// Comprueba si el altavoz está activado (propiedad de lectura/escritura)
-console.log(tel.speakerEnabled);
-
-// Realizar una llamada
-var call = tel.dial("123456789");
-
-// Eventos para esa llamada
-call.onstatechange = function (event) {
-    /*
-        Valores posibles del estado:
-        "dialing", "ringing", "busy", "connecting", "connected",
-        "disconnecting", "disconnected", "incoming"
-    */
-    console.log(event.state);
-};
-
-// Opciones anteriores como eventos directos
-
-      // Conectar llamada
-       call.onconnected = function ();
-
-      // Desconectar llamada
-      call.ondisconnected = function ();
-
-      // Resivir una llamada
-      tel.onincoming = function (event) {
-      var incomingCall = event.call;
-
-    // Obtener el número de la llamada entrante
-    console.log(incomingCall.number);
-
-    // Responder a la llamada
-    incomingCall.answer();
-};
-
-// Desconectar llamada
-call.hangUp();
-
-
-// Iteración sobre las llamadas, y la adopción de medidas en función de su estado de cambiado
-tel.oncallschanged = function (event) {
-    tel.calls.forEach(function (call) {
-        // Registrar el estado de cada llamada
-        console.log(call.state);
-    });
-};
-
-

Ver también

- -- cgit v1.2.3-54-g00ecf