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 --- .../b2g_os/anwendungsentwicklung/index.html | 12 - files/de/archive/b2g_os/api/index.html | 156 ---- files/de/archive/b2g_os/api/navigator/index.html | 19 - .../api/navigator/requestwakelock/index.html | 37 - .../index.html" | 48 -- files/de/archive/b2g_os/apps/index.html | 50 -- .../arbeiten_mit_dem_b2g_desktop_client/index.html | 135 ---- .../b2g_os/benutzung_des_app_managers/index.html | 264 ------- files/de/archive/b2g_os/building/index.html | 268 ------- .../compatible_devices/index.html | 357 --------- .../firefox_os_build_overview/index.html | 155 ---- .../building_and_installing_firefox_os/index.html | 45 -- .../b2g_os/debugging/developer_settings/index.html | 197 ----- files/de/archive/b2g_os/debugging/index.html | 80 --- .../b2g_os/debugging/installing_adb/index.html | 70 -- .../index.html" | 41 -- .../filing_bugs_against_firefox_os/index.html | 183 ----- .../b2g_os/developing_firefox_os/index.html | 26 - .../firefox_os_build_prerequisites/index.html | 446 ------------ files/de/archive/b2g_os/firefox_os_faq/index.html | 41 -- files/de/archive/b2g_os/gaia/gaia_apps/index.html | 86 --- files/de/archive/b2g_os/gaia/hacking/index.html | 181 ----- files/de/archive/b2g_os/gaia/index.html | 56 -- .../b2g_os/gaia/introduction_to_gaia/index.html | 35 - .../gaia_entwickeln/build_system_primer/index.html | 190 ----- .../customizing_build-time_apps/index.html | 117 --- .../durchfuehrung_der_gaia_codebase/index.html | 71 -- files/de/archive/b2g_os/gaia_entwickeln/index.html | 52 -- .../making_gaia_code_changes/index.html | 85 --- files/de/archive/b2g_os/index.html | 163 ----- .../installing_on_a_mobile_device/index.html | 81 --- files/de/archive/b2g_os/introduction/index.html | 84 --- .../phone_guide/alcatel_one_touch_fire/index.html | 102 --- .../de/archive/b2g_os/phone_guide/flame/index.html | 39 - .../b2g_os/phone_guide/geeksphone/index.html | 202 ------ files/de/archive/b2g_os/phone_guide/index.html | 44 -- .../b2g_os/phone_guide/phone_specs/index.html | 800 --------------------- .../b2g_os/phone_guide/zte_open_c/index.html | 82 --- .../b2g_os/platform/app_architektur/index.html | 29 - .../archive/b2g_os/platform/architektur/index.html | 740 ------------------- files/de/archive/b2g_os/platform/index.html | 81 --- .../b2g_os/quickstart/deine_erste_app/index.html | 339 --------- .../quickstart/einfuerung_zu_firefox_os/index.html | 13 - .../quickstart/for_mobile_developers/index.html | 40 -- files/de/archive/b2g_os/quickstart/index.html | 49 -- .../open_web_apps_and_web_standards/index.html | 38 - files/de/archive/b2g_os/releases/1.4/index.html | 71 -- files/de/archive/b2g_os/releases/2.0/index.html | 112 --- files/de/archive/b2g_os/releases/index.html | 24 - files/de/archive/b2g_os/simulator/index.html | 86 --- files/de/archive/b2g_os/troubleshooting/index.html | 44 -- 51 files changed, 6766 deletions(-) delete mode 100644 files/de/archive/b2g_os/anwendungsentwicklung/index.html delete mode 100644 files/de/archive/b2g_os/api/index.html delete mode 100644 files/de/archive/b2g_os/api/navigator/index.html delete mode 100644 files/de/archive/b2g_os/api/navigator/requestwakelock/index.html delete mode 100644 "files/de/archive/b2g_os/apps/eine_app_f\303\274r_firefox_os_schreiben/index.html" delete mode 100644 files/de/archive/b2g_os/apps/index.html delete mode 100644 files/de/archive/b2g_os/arbeiten_mit_dem_b2g_desktop_client/index.html delete mode 100644 files/de/archive/b2g_os/benutzung_des_app_managers/index.html delete mode 100644 files/de/archive/b2g_os/building/index.html delete mode 100644 files/de/archive/b2g_os/building_and_installing_firefox_os/compatible_devices/index.html delete mode 100644 files/de/archive/b2g_os/building_and_installing_firefox_os/firefox_os_build_overview/index.html delete mode 100644 files/de/archive/b2g_os/building_and_installing_firefox_os/index.html delete mode 100644 files/de/archive/b2g_os/debugging/developer_settings/index.html delete mode 100644 files/de/archive/b2g_os/debugging/index.html delete mode 100644 files/de/archive/b2g_os/debugging/installing_adb/index.html delete mode 100644 "files/de/archive/b2g_os/debugging/verbinden_eines_firefox_os_ger\303\244ts_mit_dem_rechner/index.html" delete mode 100644 files/de/archive/b2g_os/developing_firefox_os/filing_bugs_against_firefox_os/index.html delete mode 100644 files/de/archive/b2g_os/developing_firefox_os/index.html delete mode 100644 files/de/archive/b2g_os/firefox_os_build_prerequisites/index.html delete mode 100644 files/de/archive/b2g_os/firefox_os_faq/index.html delete mode 100644 files/de/archive/b2g_os/gaia/gaia_apps/index.html delete mode 100644 files/de/archive/b2g_os/gaia/hacking/index.html delete mode 100644 files/de/archive/b2g_os/gaia/index.html delete mode 100644 files/de/archive/b2g_os/gaia/introduction_to_gaia/index.html delete mode 100644 files/de/archive/b2g_os/gaia_entwickeln/build_system_primer/index.html delete mode 100644 files/de/archive/b2g_os/gaia_entwickeln/customizing_build-time_apps/index.html delete mode 100644 files/de/archive/b2g_os/gaia_entwickeln/durchfuehrung_der_gaia_codebase/index.html delete mode 100644 files/de/archive/b2g_os/gaia_entwickeln/index.html delete mode 100644 files/de/archive/b2g_os/gaia_entwickeln/making_gaia_code_changes/index.html delete mode 100644 files/de/archive/b2g_os/index.html delete mode 100644 files/de/archive/b2g_os/installing_on_a_mobile_device/index.html delete mode 100644 files/de/archive/b2g_os/introduction/index.html delete mode 100644 files/de/archive/b2g_os/phone_guide/alcatel_one_touch_fire/index.html delete mode 100644 files/de/archive/b2g_os/phone_guide/flame/index.html delete mode 100644 files/de/archive/b2g_os/phone_guide/geeksphone/index.html delete mode 100644 files/de/archive/b2g_os/phone_guide/index.html delete mode 100644 files/de/archive/b2g_os/phone_guide/phone_specs/index.html delete mode 100644 files/de/archive/b2g_os/phone_guide/zte_open_c/index.html delete mode 100644 files/de/archive/b2g_os/platform/app_architektur/index.html delete mode 100644 files/de/archive/b2g_os/platform/architektur/index.html delete mode 100644 files/de/archive/b2g_os/platform/index.html delete mode 100644 files/de/archive/b2g_os/quickstart/deine_erste_app/index.html delete mode 100644 files/de/archive/b2g_os/quickstart/einfuerung_zu_firefox_os/index.html delete mode 100644 files/de/archive/b2g_os/quickstart/for_mobile_developers/index.html delete mode 100644 files/de/archive/b2g_os/quickstart/index.html delete mode 100644 files/de/archive/b2g_os/quickstart/open_web_apps_and_web_standards/index.html delete mode 100644 files/de/archive/b2g_os/releases/1.4/index.html delete mode 100644 files/de/archive/b2g_os/releases/2.0/index.html delete mode 100644 files/de/archive/b2g_os/releases/index.html delete mode 100644 files/de/archive/b2g_os/simulator/index.html delete mode 100644 files/de/archive/b2g_os/troubleshooting/index.html (limited to 'files/de/archive/b2g_os') diff --git a/files/de/archive/b2g_os/anwendungsentwicklung/index.html b/files/de/archive/b2g_os/anwendungsentwicklung/index.html deleted file mode 100644 index 0c09cc1103..0000000000 --- a/files/de/archive/b2g_os/anwendungsentwicklung/index.html +++ /dev/null @@ -1,12 +0,0 @@ ---- -title: Firefox OS Anwendungsentwicklung -slug: Archive/B2G_OS/Anwendungsentwicklung -translation_of: Archive/B2G_OS/Firefox_OS_apps/Building_apps_for_Firefox_OS ---- -

Firefox OS apps sind nichts anderes als Open Web apps, die auf einem Smartphone mit Firefox OS installiert werden.

- -
- Note: Firefox OS currently identifies using the same UA string as Firefox for Android, except without the "Android;" clause. For example: "Mozilla/5.0 (Mobile; rv:15.0) Gecko/15.0 Firefox/15.0a1".
diff --git a/files/de/archive/b2g_os/api/index.html b/files/de/archive/b2g_os/api/index.html deleted file mode 100644 index 706080ff54..0000000000 --- a/files/de/archive/b2g_os/api/index.html +++ /dev/null @@ -1,156 +0,0 @@ ---- -title: B2G OS APIs -slug: Archive/B2G_OS/API -tags: - - API - - B2G API - - NeedsTranslation - - TopicStub - - b2g os api's -translation_of: Archive/B2G_OS/API ---- -

List of B2G OS APIs 

- -

-A -B -C -D - - -F - - -H - - - - - - - - -M -N - - -P - - - - -S -T -U - - -W - - - - - - - -

diff --git a/files/de/archive/b2g_os/api/navigator/index.html b/files/de/archive/b2g_os/api/navigator/index.html deleted file mode 100644 index 553b9dd513..0000000000 --- a/files/de/archive/b2g_os/api/navigator/index.html +++ /dev/null @@ -1,19 +0,0 @@ ---- -title: Navigator (Firefox OS extensions) -slug: Archive/B2G_OS/API/Navigator -tags: - - API - - Firefox OS - - Interface - - Navigator - - Non-standard - - Reference -translation_of: Archive/B2G_OS/API/Navigator ---- -

{{APIRef("Firefox OS")}}{{Draft}}{{Non-standard_Header}}

- -

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.

- -

{{SubpagesWithSummaries}}

diff --git a/files/de/archive/b2g_os/api/navigator/requestwakelock/index.html b/files/de/archive/b2g_os/api/navigator/requestwakelock/index.html deleted file mode 100644 index 49d5275686..0000000000 --- a/files/de/archive/b2g_os/api/navigator/requestwakelock/index.html +++ /dev/null @@ -1,37 +0,0 @@ ---- -title: Navigator.requestWakeLock() -slug: Archive/B2G_OS/API/Navigator/requestWakeLock -translation_of: Archive/B2G_OS/API/Navigator/requestWakeLock ---- -

{{APIRef("Wake Lock API")}}{{ non-standard_header() }}

- -

This Navigator.requestWakeLock() method of the Wake Lock API is used to request a {{ domxref("MozWakeLock") }} on any resource of the device. This means that you can prevent that resource from becoming unavailable as long as your app holds a lock for that resource. For example, a voice recording app can obtain a lock to keep the screen on during recording so that it can give prover visual feedback to the user that recording is progressing.

- -
-

Note: When the window that requested one or more wake locks is closed or destroyed, any wake locks it acquired are implicitly released; no manual release is necessary.

-
- -

Syntax

- -
lock = window.navigator.requestWakeLock(resourceName);
- -

Parameters

- -
-
resourceName
-
A string representing the name of the resource to lock. Gaia uses four basic resources names: screen, cpu,  wifi, and gps, but any certified application can expose new resources.
-
- -

Return value

- -

Returns a {{domxref("MozWakeLock")}} object you can use to keep track of or release the lock..

- -

Specification

- -

W3C tracks Wake Lock: Use cases and is working on the Editor's traft API.

- -

See also

- - diff --git "a/files/de/archive/b2g_os/apps/eine_app_f\303\274r_firefox_os_schreiben/index.html" "b/files/de/archive/b2g_os/apps/eine_app_f\303\274r_firefox_os_schreiben/index.html" deleted file mode 100644 index 915a3be22d..0000000000 --- "a/files/de/archive/b2g_os/apps/eine_app_f\303\274r_firefox_os_schreiben/index.html" +++ /dev/null @@ -1,48 +0,0 @@ ---- -title: Eine App für Firefox OS schreiben -slug: Archive/B2G_OS/Apps/eine_app_für_firefox_os_schreiben -tags: - - Apps - - Firefox OS - - Handy -translation_of: Web/Apps/Fundamentals/Quickstart ---- -

Firefox OS Apps sind Web-Apps, die in HTML, CSS und JavaScript geschrieben sind. Die App wird im Internet publiziert, wie Sie es mit jeder anderen Website auch tun. Um die Website als installierbare Web-App auf dem Gerät zu erstellen, müssen Sie die App mit einem manifest und einem hock up, einem Installations-Button, wie nachfolgend erläutert, versehen.

-

Die folgenden Themen können als Ausgangspunkt genutzt werden:

- -

Natürlich können Sie auch tiefer in die Technologie von Web-Apps eintauchen.

-

Die Web-App installieren

-

Mit der App und dem manifest im Internet, müssen Sie es Gecko bekannt machen. Während der Installationsphase schaut Gecko nach dem manifest und fügt die wichtigsten Einträge dem HomeScreen u.a. hinzu.

-

Um die App zu installieren, müssen sie die navigator.mozApps.install API aufrufen. Hier finden Sie ein Beispiel für einen Installations-Button, den Sie in ihre App einbinden können, wenn Sie sie selbst hosten.

-
<button id="install">
-  Installieren Sie diese App auf Ihrem HomeScreen!
-</button>
-
-<script>
-(function(){
-  function install(ev) {
-    ev.preventDefault();
-    // Definierung der Manifest URL
-    var manifest_url = "http://my.webapp.com/manifest.webapp";
-    // App installieren
-    var myapp = navigator.mozApps.install(manifest_url);
-    myapp.onsuccess = function(data) {
-      // App ist installiert, Entfernen-Button
-      this.parentNode.removeChild(this);
-    };
-    myapp.onerror = function() {
-      // App war noch nicht installiert, Info ist in this.error.name definiert
-      console.log('Es ist ein Fehler bei der Installation aufgetreten., error: ' + this.error.name);
-     };
-  };
-  // Ein Verweis auf den Button und Aufruf von install() beim betätigen.
-  var button = document.getElementById('install');
-  button.addEventListener('click', install, false);
-})();
-</script>
-
-

Tipp: DenInstallations-Button können Sie auch in App-Stores, wie zum Beispiel dem Firefox Marketplace, einbinden, aber es ist oft sehr praktisch den Installations-Button auf der Startseite des Projekts zu haben.

-

Nun besuchen Sie Ihre Website mit der Firefox OS Browser App und benutzen Sie den Installations-Button.

diff --git a/files/de/archive/b2g_os/apps/index.html b/files/de/archive/b2g_os/apps/index.html deleted file mode 100644 index 6846cbffe7..0000000000 --- a/files/de/archive/b2g_os/apps/index.html +++ /dev/null @@ -1,50 +0,0 @@ ---- -title: Apps entwickeln für Firefox OS -slug: Archive/B2G_OS/Apps -translation_of: Web/Apps/Fundamentals ---- -

Applikationen für Firefox OS Geräte sind einfach offene Web Apps die komplett auf offenen Web Technologien basieren, wie etwa Javascript, HTML oder CSS. Unsere hauptsächliche Dokumentation erklärt Dir alles grundlegende was Du wissen musst und es gibt speziellere Artikel über das Entwickeln und das Testen von Apps für Firefox OS.

-
-
-

DoKumentation und Anleitungen

-
-
- Eine App für Firefox OS schreiben
-
- Anleitung wie Du deine eigene erste Web Applikation für Firefox OS entwickelst.
-
- Benutzererlebnis
-
- Leitfaden der Dir helfen soll deine Apps mit einem aufgeräumten und attraktiven Erlebnis für den Benutzer auszustatten inklusive Codebeispielen und Templates.
-
- Tipps und Techniken
-
- Ein Sortiment mit Tipps und Tricks (wie auch möglichen Problemlösungen) die unsere Entwickler für Dich ausgewählt haben!
-
-

Alle anzeigen...

-
-
-

Hol dir Hilfe von der Community

-

Du brauchst Hilfe bei einem Problem mit deiner App und kannst keine Lösung in der Dokumentation finden?

-
    -
  • Konsultiere das Web Apps Forum: {{DiscussionList("dev-webapps", "mozilla.dev.webapps")}}
    • -
  • Konsultiere das Layout Forum, welches sich mit HTML und CSS beschätigt: {{ DiscussionList("dev-tech-css", "mozilla.dev.tech.layout") }} - -
    • -
-

Vergiss die Netiquette nicht...

-

Werkzeuge

- -

Alle anzeigen...

- - -
-
-

 

diff --git a/files/de/archive/b2g_os/arbeiten_mit_dem_b2g_desktop_client/index.html b/files/de/archive/b2g_os/arbeiten_mit_dem_b2g_desktop_client/index.html deleted file mode 100644 index 14e53a827e..0000000000 --- a/files/de/archive/b2g_os/arbeiten_mit_dem_b2g_desktop_client/index.html +++ /dev/null @@ -1,135 +0,0 @@ ---- -title: Arbeiten mit dem B2G Desktop-Client -slug: Archive/B2G_OS/Arbeiten_mit_dem_B2G_Desktop_Client -translation_of: Archive/B2G_OS/Building_the_B2G_OS_simulator ---- -

Der Firefox OS desktop client, auch bekannt als B2G desktop client, bietet die Möglichkeit an Gaia and Web apps in einer Gecko-basierten Umgebung auf dem Desktop laufen zu lassen. Dabei wird die Geräte-Hardware jedoch nicht emuliert, sodass es zum Testen von Geräte-Api nicht taugt. Auch ist es kein Ersatz um auf einem Gerät zu testen. Dennoch, hat es einige aktivierte APIs, welche nicht im Firefox verfügbar sind, wie z.B. Kontakt- und Einstellungs-API. Es kann also durchaus nützlich sein, wenn man eine Anwendung entwickelt oder während man am Gaia-Inteface direkt arbeitet. Dieser Artikel behandelt das Downloaden bzw. zusammenbauen des Firefox OS Desktop Clients, jedoch auch wie man ihn benutzt.

-
-

Note: The easiest way to use the Firefox OS desktop client is to use the Firefox OS Simulator. It does not require you to build the desktop client yourself.

-
-

Download a nightly build

-
-

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:

-
. "$topsrcdir/b2g/config/mozconfigs/common"
-
-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:

-
DEBUG=1 make
-
-

This should create a profile-debug 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-debug
-
-

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-debug
-
-

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-debug
-
-

Note: On production builds of Firefox OS, console logging (such as by {{domxref("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-debug --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/de/archive/b2g_os/benutzung_des_app_managers/index.html b/files/de/archive/b2g_os/benutzung_des_app_managers/index.html deleted file mode 100644 index 5a03b1fb3b..0000000000 --- a/files/de/archive/b2g_os/benutzung_des_app_managers/index.html +++ /dev/null @@ -1,264 +0,0 @@ ---- -title: Benutzung des App Managers -slug: Archive/B2G_OS/Benutzung_des_App_Managers -translation_of: Archive/B2G_OS/Using_the_App_Manager ---- -
-

Der App Manager ist ein neues Tool, das in Firefox für Desktop integriert wurde. Es stellt einige nützliche Werkzeuge zum Testen, Verteilen und Debuggen von HTML5-Webapps mit Firefox OS Smartphones und dem Firefox OS Simulator bereit, welche direkt im Browser benutzt werden können.

- -

Der App Manager ist an Entwickler, die Firefox OS Version 1.2 oder später entwickeln, gerichtet. Wenn Sie Apps für Firefox OS 1.1 entwickeln, werfen Sie stattdessen einen Blick auf die Dokumentation für den Firefox OS Simulator 1.1.

-
- -

{{EmbedYouTube("z1Bxg1UJVf0")}}

- -

Der App Manager besteht aus folgenden Komponenten:

- - - -

Schnelleinstieg:

- -

Dieser Abschnitt soll einen möglichst schnellen Einstieg ermöglichen. Falls genauere Erklärungen benötigt werden, überspringen Sie bitte diesen Abschnitt und lesen Sie {{ anch("Device and system configuration") }}. Bei Problemen könnte außerdem der Abschnitt {{ anch("Troubleshooting") }} weiterhelfen.

- -
    -
  1. Stellen Sie sicher, dass Firefox Desktop 26+ installiert ist.
    2. -
  2. Öffnen Sie den App Manager (tippen Sie about:app-manager in die URL-Leiste).
    3. -
  3. Falls kein echtes Gerät mit Firefox OS zur Verfügung steht: -
      -
    1. Installieren Sie den Firefox OS Simulator
      2. -
    2. Klicken Sie auf Start Simulator in der unteren Werkzeugleiste des App Managers und anschließend auf den Namen des installierten Simulators.
      3. -
    -
    4. -
  4. Falls Sie ein echtes Gerät besitzen: -
      -
    1. Stellen Sie sicher, dass auf dem Gerät Firefox OS 1.2+ läuft.
      2. -
    2. Wenn Sie unter Windows arbeiten, stellen Sie sicher, dass Sie die bereitgestellten Treiber Ihres Handys installiert haben.
      3. -
    3. Deaktivieren Sie die Bildschirmsperre in den Einstellungen des Geräts (Settings > Screen Lock) und aktivieren Sie Remote Debugging (Settings > Device information > More information > Developer).
      4. -
    4. Installieren Sie das ADB Helper Add-on in Firefox Desktop.
      5. -
    5. Verbinden Sie ihr Gerät über ein USB-Kabel mit dem Computer.
      6. -
    6. Der Name des Geräts sollte nun in der unteren Leiste des App Managers erscheinen. Klicken Sie den Namen an.
      7. -
    -
    5. -
  5. Die untere Leiste sollte anzeigen "Connected to: xxx".
    6. -
  6. Klicken Sie auf das Apps-Panel und fügen Sie eine App hinzu (paketiert oder gehostet).
    7. -
  7. Der Refresh-Button validiert Ihre App und installiert sie auf dem Simulator/Gerät.
    8. -
  8. Der Debug-Button verbindet die Entwickler-Tools mit der laufenden App.
    9. -
- -

Geräte- und System-Konfiguration

- -

Bei der Benutzung des App Manager sollte man zuerst sicherstellen, dass System und Gerät korrekt konfiguriert sind. Dieser Abschnitt beschreibt alle dafür nötigen Schritte.

- -

Firefox 1.2+ wird benötigt

- -

Stellen Sie sicher, dass auf Ihrem Gerät Firefox OS 1.2/Boot2Gecko 1.2 oder höher läuft. Die Versionsnummer von Firefox OS wird unter Settings > Device Information > Software angezeigt.

- -

Falls die installierte Version nicht hoch genug ist, muss je nachdem welches Gerät Sie verwenden, eine der verfügbaren Nightly-Builds von Firefox 1.2+ installiert oder eine Version selbst kompiliert werden.

- -

Verfügbare Builds:

- - - -
-

Hinweis: Für die Erstellung eines eigenen Builds von Firefox OS 1.2+, folgen Sie den Anweisungen unter Building and installing Firefox OS und starten Sie mit Firefox OS build prerequisites.

-
- -

Remote-Debugging

- -

Als nächstes muss Remote Debugging in Firefox OS aktiviert werden. Navigieren Sie zu Settings > Device information > More information > Developer und aktivieren Sie die Checkbox bei Remote Debugging.

- -

ADB oder ADB Helper

- -

Über die Android Debug Bridge (ADB) wird die Verbindung und Kommunikation zwischen Gerät und Computer geregelt. Es gibt zwei Möglichkeiten ADB einzusetzen:

- - - -
-

Achtung: Es ist nicht nötig diesen Befehl auszuführen, wenn Sie das ADB Helper Add-on installiert haben.

-
- -

Verbinden des Geräts mit dem App Manager

- -

Nachdem alles konfiguriert wurde, ist es nun an der Zeit, das Gerät mit dem Computer zu verbinden und den App Manager zu starten:

- -
    -
  1. Verbinden Sie das Gerät via USB mit dem Computer.
    2. -
  2. Deaktivieren Sie Screen lock auf dem Gerät, indem Sie zu Settings > Screen Lock navigieren und die Checkbox bei Lock Screen deaktivieren. Dieses Vorgehen ist sehr ratsam, da die Verbindung abbricht, sobald sich die Bildschirmsperre aktiviert.
    3. -
  3. Starten Sie den App Manager — klicken Sie in der Menüleiste von Firefox Desktop Extras > Web-Entwickler > App Manager an oder tippen Sie about:app-manager in die URL-Leiste.
    4. -
  4. An der Unterseite des App Manager Tabs sehen Sie nun eine Anzeige für den Verbindungsstatus (siehe Screenshot unten). Es sollte nun möglich sein das Gerät durch einen Klick auf den "Connect to localhost:6000" Button zu verbinden.
    5. -
  5. Falls die Verbindung erfolgreich hergestellt wurde, erscheint eine Frage auf dem Gerät: "An incoming request to permit remote debugging connection was detected. Allow connection?". Bestätigen Sie mit dem OK-Button (evtl. müssen Sie den Power-Button am Gerät betätigen, damit Sie die Frage sehen können). Der Verbindungsstatus in der Leiste sollte dann "Connected to B2G" und einen Disconnect-Button zum Abbruch der Verbindung anzeigen.
    6. -
- -

- -
-

Die anderen Bedienelemente in der Verbindungstatus-Leiste ermöglichen die Verbindung eines Simulators mit dem App Manager. Dies wird im nächsten Abschnitt behandelt, wobei der Port für die Verbindung geändert wird. Wenn der Port gewechselt wird, muss auch Portweiterleitung für diesen Port aktiviert werden, wie unter {{anch("Enable port forwarding")}} beschrieben.

-
- -

Firefox OS Simulator Add-on

- -

Steht kein echtes Gerät zur Verfügung, das mit dem App Manager benutzt werden kann, kann es dennoch zusammen einem Firefox OS Simulator Add-on ausprobiert werden. Installieren Sie hierzu einen Simulator, passend für Ihr Betriebssystem (mehrere Versionen verfügbar, es ist ratsam alle zu installieren, für maximale Flexibilität):

- -

Simulator installieren

- - -

Nach der Installation des Simulators/der Simulatoren gehen Sie auf about:app-manager und klicken Sie in der Verbindungsstatus-Leiste unten den "Start Simulator"-Button. Daraufhin erscheinen drei weitere Buttons:

- - - -

Apps-Panel

- -

Da nun alles soweit funktionert, wird nun die Funktionalität des App Managers beschrieben, beginnend mit dem Apps Panel. Von hier aus können Sie eine bereits existierende App importieren, auf Ihr Gerät übertragen und debuggen:

- - - -

Ist dieser Schritt gelungen, sollten auf der rechten Seite des Fensters Informationen über die App angezeigt werden:

- -

- -

Manifest Editor

- -

Mit Firefox 28 und später findet sich im Apps Panel ein Editor für das App-Manifest:

- -

- -

Debugging

- -

Ein Klick auf "Update" überträgt (installiert) die App auf das Gerät. Mit einem Klick auf "Debug"  wird eine Toolbox mit der App verbunden, womit die App getestet werden kann:

- -

- -
-

Anmerkung: Es wird Ihnen gefallen mit der Toolbox herumzuspielen - ändern Sie den DOM, CSS etc. und Sie werden sehen, dass die Änderung in Echtzeit auf dem Gerät ablaufen. Die Änderungen werden im Code der installierten App gespeichert und beim nächsten Öffnen der App auf dem Gerät wieder angezeigt.

-
- -

Before Firefox 28, the tools are launched in a separate window. From Firefox 28 onwards, the tools are launched in a separate tab in the App Manager itself, alongside the Apps and Device tabs. The tab is given your app's icon so it's easy to find:

- -

- -

Fehler

- -

Falls eine App nicht erfolgreich hinzugefügt werden konnte - zum Beispiel weil die angegebene URL nicht korrekt ist oder ein gepackter App-Ordner ausgewählt wurde - wird dennoch ein Eintrag für die App hinzugefügt, dieser enthält jedoch Fehlermeldungen.

- -

- -

Bei dieser Ansicht ist es auch möglich, eine installierte App zu deinstallieren. Halten Sie hierfür den Mauszeiger über den Namen oder die Beschreibung der jeweiligen App auf der linken Seite und klicken Sie den X-Button an. Die App wird dadurch jedoch nicht vom Gerät entfernt. Um dies zu tun, muss das Gerät selbst benutzt werden.

- -

Device-Panel

- -

Im Tab unter Device werden Informationen zum verbundenen Gerät angezeigt. Von dem Fenster "Installed Apps" aus können die Apps auf dem Gerät gestartet und gedebuggt werden.

- -

- -
-

Anmerkung: Zertifizierte Apps werden standardmäßig nicht aufgelistet. Weitere Informationen zum Debuggen von zertifizierten Apps.

-
- -

Das Fenster "Permissions" zeigt die benötigten Rechte für verschiedene Web-APIs des Geräts:

- -

- -

Abschließend können Sie einen Screenshot mit dem Bildschirminhalt des Geräts erstellen, indem Sie den Screenshot-Button anklicken. Der Screenshot wird dann in einem neuen Tab in Firefox geöffnet und kann von dort aus gespeichert oder verworfen werden.

- -

Debuggen von zertifizierten Apps

- -

Bis dato können nur Geräte, welche mit einem Development-Build von Firefox OS 1.2 laufen, für das Debuggen von zertifizierten Apps benutzt werden. Falls auf ihrem Gerät ein Development-Build installiert ist, können Sie das Debuggen von zertifzierten Apps erlauben, indem Sie die Einstellung devtools.debugger.forbid-certified-apps in ihrem Firefox-Profil auf false setzen. Gehen sie hierfür wie folgt vor:

- -
    -
  1. -

    Geben Sie auf ihrem Computer den folgenden Befehl in ein Terminal/Konsole ein, um über die Shell auf das Dateisystem des Geräts zuzugreifen:

    - - 
    adb shell
    - -

    Daraufhin sollte sich der Prompt zu root@android ändern.

    -
    2. -
  2. -

    Als nächstes stoppen sie B2G mit dem Befehl:

    - - 
    stop b2g
    -
    3. -
  3. -

    Wechseln Sie mit folgenden Befehl zum Profilordner:

    - - 
    cd /data/b2g/mozilla/*.default/
    -
    4. -
  4. -

    Und fügen Sie mit folgendem Befehl eine Zeile für die Einstellung in die Datei prefs.js ein:

    - - 
    echo 'user_pref("devtools.debugger.forbid-certified-apps", false);' >> prefs.js
    -
    5. -
  5. -

    Nachdem die Datei bearbeitet und gespeichert wurde, starten Sie B2G erneut:

    - - 
    start b2g
    -
    6. -
  6. -

    Verlassen Sie das Android-Dateisystem mit der Eingabe des Befehls exit. Damit kehren Sie zum normalen Terminal-Prompt zurück.

    -
    7. -
  7. -

    Stellen Sie nun eine Verbindung mit dem App Manger her. Die zertifizierten Apps sollten nun angezeigt werden.

    -
    8. -
- -
-

Anmerkung: Falls Sie diese Einstellung ihrem Gaia build hinzufügen möchten, sodass sie aktiv ist auch wenn ihr Telefon zurückgesetzt wird, fügen Sie die Einstellung in der Datei build/custom-prefs.js hinzu und führen Sie make reset-gaia aus.

-
- -

Running custom builds in the App Manager

- -

You can run custom B2G Desktop and Gaia builds in the App Manager via the simulator. Read Running custom Firefox OS/Gaia builds in the App Manager for more details.

- -

Fehlerbehandlung

- -

Falls das Gerät nicht gefunden wird:

- - - -

Die Verbindung des Geräts mit dem App Manager funktioniert nicht oder der Simulator kann nicht gestartet werden? Lassen Sie es uns wissen oder schreiben Sie einen Bugreport.

diff --git a/files/de/archive/b2g_os/building/index.html b/files/de/archive/b2g_os/building/index.html deleted file mode 100644 index 3b0c91142b..0000000000 --- a/files/de/archive/b2g_os/building/index.html +++ /dev/null @@ -1,268 +0,0 @@ ---- -title: Building Firefox OS -slug: Archive/B2G_OS/Building -translation_of: Archive/B2G_OS/Building ---- -
-
-
-

Once you've set up your build system and performed your initial pull and configure of the code, you can build Boot to Gecko. This guide explains how.

-
-

Updating your code

-

If this isn't your very first time building B2G, you might want to pull the latest code before you start to build. To do that, you should update both the B2G tools and the dependencies, using the following two commands:

-
git pull
-./repo sync -d
-
-

The -d option switches the various projects HEAD back to their Android manifest revision (i.e the default mainstream repository version). It is helpful if you made modifications to the repos (and have associated source changes) but you want to revert back to the master version temporarily. It will indeed leave your staged or working directory changes untouched (see the following SO question for the full explanation). If you did not touch the source code, you can use the normal command:

-
git pull
-./repo sync
-

You can update a specific make target's repository by specifying its name:

-
./repo sync gaia
-
-

The repo command has other options available that might be interesting; repo help will give you a lot of information.

-

Building

-
-

Note: Before building, you may want to set up a .userconfig file to customize the build. See Customization with the .userconfig file for details.

-
-

To build Boot to Gecko, simply use the build.sh tool:

-
cd B2G
-./build.sh
-
-

Time for another coffee break, or possibly a nap (especially if this is your first build, it takes about 30 min on a Core i7 with 8GB of RAM). As in the configure step on the previous page, if you are using a directory of previously-extracted Android system files, you should set ANDROIDFS_DIR before running build.sh.

-
-

Note: For more instructions on flashing your new build to a phone, read Installing Firefox OS on a mobile device.

-
-

Building specific modules

-

If you want to build just a particular module, such as Gecko, you can specify it by name:

-
./build.sh gecko
-
-

In order to refresh only one application, you can build only gaia module by using the BUILD_APP_NAME environment variable:

-
BUILD_APP_NAME=calendar ./build.sh gaia
-

To get a list of the modules you can build, you can do:

-
./build.sh modules
-
-

Setting the number of processor cores to use

-

By default, the B2G build scripts use the number of cores your system has plus two as the number of parallel tasks to run. You can change this by specifying the -j parameter when running build.sh. This can be handy if you're using your system for other things while building in the background and need to reduce CPU load a bit. It's also handy when you're having build problems, as it can make reading error output from the build process easier if you have just one task going at a time!

-

For example, to build using just two parallel tasks:

-
./build.sh -j2
-
-

The most common use case for this, however, is to prevent builds from running in parallel at all. This makes the output of the process much easier to read, making it easier to sort out build problems. To do this:

-
./build.sh -j1
-
-

Building multilocale

-

To create a multilocale build, do the following:

-

Gaia

-
    -
  1. Determine which Gaia languages file to use. We're currently using locales/languages_dev.json and locales/languages_all.json as our Gaia languages files.
    2. -
  2. Clone the appropriate locales from http://hg.mozilla.org/gaia-l10n into a directory; we use gaia-l10n/. You could use the locales/ directory . You'll need to clone a repo for each locale listed in the languages file.
    3. -
  3. In your environment, set LOCALE_BASEDIR to the absolute path of the directory in step 2. Set LOCALES_FILE to the absolute path of the file in step 1.
    4. -
  4. Also, you can set a GAIA_DEFAULT_LOCALE if you want to set a default locale.
    5. -
-
cd gaia/locales/
-hg clone https://hg.mozilla.org/releases/gaia-l10n/v1_2/es
-
- Set your environment variables:
-
-  
-
export LOCALE_BASEDIR=$PWD/locales
-export LOCALES_FILE=$PWD/locales/languages_dev.json
-export GAIA_DEFAULT_LOCALE=es
-
-

And the languages-dev.json could be replaced by your own languages-own.json path, which could formed like this. You would need to add an entry per each repo cloned in your locales directory.:

-
{
-  "en-US"     : "English (US)",
-  "es"        : "Español"
-}
-
-
-

Since bug 884752 landed (November 2013), to add keyboard layouts (if available in Gaia), you can use parameter GAIA_KEYBOARD_LAYOUTS. 

-

Bug: https://bugzilla.mozilla.org/show_bug.cgi?id=884752

-

Layouts: https://github.com/mozilla-b2g/gaia/tree/v1.2/keyboard/layouts

-

For example, to add Spanish and Italian keyboard layout, run the previous command adding

- 
  GAIA_KEYBOARD_LAYOUTS=en,es,it
-

At this point you're ready to flash Gaia to the phone for the first time. Connect the phone and make sure Remote Debugging is checked in Settings > Device Information > More Information > Developer.  You only need to do this once, for your own build of Gaia will have that pref turned on thanks to REMOTE_DEBUGGER=1:

- 
 make clean && make production LOCALES_FILE=locales/languages-own.json
-
-

If you want to clone and/or update all supported locales for a particular branch, you can use this script

-
-

Gecko

-
    -
  1. Determine which Gecko languages file to use. We're currently using b2g/locales/all-locales as our Gecko languages file.
    2. -
  2. Clone the appropriate locales into a directory; this can be gecko-l10n/ . - -
    3. -
  3. Clone compare-locales.
    4. -
  4. -

    In your environment, set L10NBASEDIR to the absolute path of the directory in step 2. Set MOZ_CHROME_MULTILOCALE to a string of space-delimited locales from step 1.

    -

    Add the compare-locales/scripts dir to your PATH, and compare-locales/lib to your PYTHONPATH.

    - For instance, - 
    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"
-
    -

    Once you have the above set up, you can run build.sh.

    -

    You can use .userconfig as well:

    - 
    ## Gaia
-export GAIA_DEFAULT_LOCALE=es
-export LOCALE_BASEDIR=/b2g/gaia-l10n-transifex-v1.2/
-export LOCALES_FILE=/b2g/languages_propio.json
-
-## Gecko
-export L10NBASEDIR='/b2g/gecko-l10n-v1.2'
-export MOZ_CHROME_MULTILOCALE="es-ES eu ca gl pt-BR"
-export PATH="$PATH:/b2g/compare-locales/scripts"
-export PYTHONPATH="/b2g/compare-locales/lib"
-
    -
    5. -
-
-

There are some mappings between Gaia languages and Gecko ones. For example, in Gaia, Spanish is "es", but on Gecko is tranlated to "Spanish of Spain" (es-ES)

-
-

These instructions may change as we smooth things out.

-

Known errors

-

"Build failed!"

-

If you get a general "Build failed" message, you should always try reconnecting your phone to your computer; sometimes the phone can become unmounted for a variety of reasons.

-
-

Note that configuring and building B2G for Keon DOESN'T WORK on Mac. You'll need to use Linux to build for this device.

-
-

Mountain Lion-specific build errors

-
-

1. If you are building on OS X 10.8 "Mountain Lion" (Xcode 4.4.1 or later) and encounter the following error:

- 
external/qemu/android/skin/trackball.c:130:25: error: 'M_PI' undeclared (first use in this function)
- Edit the file: B2G/external/qemu/Makefile.android and add in line 78:
- 
MY_CFLAGS += -DM_PI=3.14159265358979323846264338327950288   #/* B2G_fix: not finding M_PI constant */
-
-
-
- 2. If you are on Mountain Lion and you receive an error during ./build.sh like:
-
- 
/System/Library/Frameworks/IOKit.framework/Headers/usb/USB.h:797:9: error: too many #pragma options align=reset
-

Replace all instances of '#pragma options align=reset' with '#pragma pack()' inside /System/Library/Frameworks/IOKit.framework/Headers/usb/USB.h

-
-

Undefined symbols "_sqlite3_androidopt_handle_pragma" and "_sqlite3_androidopt_open"

-

This error appears if you are building on OS X 10.7 or newer with Xcode 4.5 or newer. To fix this, apply the patch at https://groups.google.com/forum/#!msg/android-building/yAfPyUqCsiQ/7zvICk4GWjYJ to the external/sqlite/dist/Android.mk file.

-

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

-

This error appears when your gcc version is too recent. Install gcc/g++/g++-multilib 4.6.x versions. See Customizing with the .userconfig file for more information.

-
-

Community Note: It is possible to use gcc 4.7.x with slight modifications to the B2G code (gcc will guide you) but you won't get any help! Neither with modifying the code nor with bugs you encounter.

-
-

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

-

If you see this message, it most likely means that free memory is lacking. Ensure there is enough free memory before running ./build.sh. It should run fine if your system has 4GB of RAM.

-

"...is referenced by DSO" error

-

While building the emulator, if you get /usr/bin/ld: out/host/linux-x86/obj/EXECUTABLES/triangleCM_intermediates/triangleCM: hidden symbol `_XGetRequest' in out/host/linux-x86/obj/STATIC_LIBRARIES/libSDL_intermediates/libSDL.a(SDL_x11dyn.o) is referenced by DSO.

-

You can get this with some versions in binutils. If you run Debian Stable, you can use the gold linker by installing the package binutils-gold. Note that the gold linker is already installed by binutils, but it's not used by default; binutils-gold does just that.

-

If you get build errors while the build system is running tests

-

Sometimes (especially after build tool or operating system updates) you'll get weird errors like this when the build system runs its post-build tests:

- 
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
-

In this situation, try deleting the gaia/xulrunner-sdk directory and re-pulling the code:

- 
rm -r gaia/xulrunner-sdk
-
-

This deletes the downloaded, precompiled copy of XULRunner that the build system retrieves automatically; on your next build, a new copy of XULRunner will be automatically retrieved.

-

Cannot fetch platform/libcore

-

If you tried to configure your B2G build for Nexus S (./config.sh nexus-s) and got an error related to libcore, it is because of a problem with the linaro git that feeds into this. To fix this, checkout the B2G manifest like so:

- 
git clone https://github.com/mozilla-b2g/b2g-manifest.git
-

Edit the nexus-s.xml file in this repo, replacing the linaro git entry with a reference to the aosp entry, which should read like so:

- 
<default revision="refs/tags/android-4.0.4_r1.2"
-              remote="aosp"
-              sync-j="4" />
-

Commit these changes (git commit -a) and then change the config.sh file in the master branch of the main B2G repo that you checked out to point to your modified local manifest instead of the Mozilla one:

- 
GITREPO=${GITREPO:-"file:///home/path/to/my/b2g-manifest"}
-

clang errors when building with Xcode 5 on Mac

-

If you are building on Mac OS X 10.8 with Xcode 5, you will likely see errors like the following:

- 
clang: error: argument unused during compilation: '-include system/core/include/arch/darwin-x86/AndroidConfig.h'
-clang: error: argument unused during compilation: '-U DEBUG'
-clang: error: argument unused during compilation: '-U DEBUG'
-clang: error: argument unused during compilation: '-MF out/host/darwin-x86/obj/EXECUTABLES/obbtool_intermediates/Main.d'
-make: *** [out/host/darwin-x86/obj/EXECUTABLES/obbtool_intermediates/Main.o] Error 1
-

This is because Xcode 5 changes the g++ compiler in /usr/bin, which breaks the build process if you try to use it to compile. In order to work around the problem, edit the following line in build/core/combo/HOST_darwin-x86.mk:

- 
HOST_CXX := g++
-

to

- 
HOST_CXX := g++-4.6
-ifeq (,$(wildcard /usr/local/bin/g++-4.6))
- HOST_CXX := g++
-endif
-

Next, you'll want to uninstall gcc, using brew (this assumes you've run the Mac OS bootstrap script — if not, you'll need to complete that step before continuing):

- 
brew uninstall gcc-4.6
-

Now reinstall gcc with multilib and c++ support:

- 
brew install --enable-cxx https://gist.github.com/artlogic/6988658/raw/aeb9d1ea098274ad3f3fe2637b9df7f308a8a120/gcc-4.6.rb
-

Make sure /usr/local/bin is on your PATH. You can do this temporarily by typing the following into the command prompt:

- 
export PATH=/usr/local/bin:$PATH
-

You can make the above change permanent by adding it to the .bash_profile file in your home directory.

-

After you've set your PATH, make sure you can run both of the following commands:

- 
gcc-4.6 -v
-
-g++-4.6 -v
-

If either of these commands fail, you may need to relink your gcc using brew with the following command:

- 
brew link --overwrite gcc-4.6
-

It's also possible that /usr/bin/c++ is not pointing at clang++ as it should be with Xcode 5 installed. You can determine if it is by typing the following:

- 
ls -l /usr/bin/c++
-

It should return something that looks like this:

- 
lrwxr-xr-x 1 root admin 7 Sep 19 11:40 /usr/bin/c++ -> clang++
-
-

If c++ is pointing at something other than clang++, update it with the following commands:

- 
sudo rm /usr/bin/c++
-
-sudo ln -s /usr/bin/clang++ /usr/bin/c++
-

Cannot pull files from backup directory

-

This could happen when the USB connection is broken while the script pulls data from device to computer.

-

When you run the script again, you'll probably get the following (the example is for the Peak device):

- 
Pulling files from ../../../backup-peak
-cat: ../../../backup-peak/system/build.prop: No such file or directory
-Found firmware with build ID
-Pulling "libaudioeq.so"
-cp: cannot stat `../../../backup-peak/system/lib/libaudioeq.so': No such file or directory
-Failed to pull libaudioeq.so. Giving up.
-
-> Build failed! <
-
-Build with |./build.sh -j1| for better messages
-If all else fails, use |rm -rf objdir-gecko| to clobber gecko and |rm -rf out| to clobber everything else.
-

To solve this, it is not necessary to remove the whole objdir-gecko or out directories. Just remove the backup directory, like this (for the example above):

- 
$rm -rf backup-peak
-

Emulator build issues

-

If you are making an emulator build, you need to pay attention to these issues:

-
-

First, note that you shouldn't use the x86 emulator — it is hard to install and not well supported.

-
-

Next, the build-system for the emulator builds both 32bit and 64bit versions of the emulator. As the emulator depends on OpenGL, this means that you need to have both 32bit and 64bit versions of OpenGL libraries installed on your system. See the discussion in bug 897727.

-

There are two ways that you can solve this problem:

- -

If your linux distro has multilib packages for OpenGL libraries, you can attempt installing them. You might then have to manually create some symlinks.

-

For example, here is the situation on Ubuntu 12.04 LTS x86-64. On this distribution, the libgl1-mesa-dev package cannot be installed simultaneously in x86-64 and i386 versions, but you can have the following combination of packages simultaneously installed:

- 
sudo apt-get install libgl1-mesa-dev libglapi-mesa:i386 libgl1-mesa-glx:i386
-

After having run this command, you will still have to manually create some symlinks for the emulator build to succeed:

- 
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
-

Solution #2: just patch the emulator so it only builds 64bit

-

Just apply this patch to the sdk/ git repository under the B2G repo. This will cause the B2G emulator to only attempt to build the 64bit emulator if you're on a 64bit system, thus avoiding any multilib issues. The 32bit emulator is unused anyway on a 64bit system. This is the simplest solution, until this patch eventually bit-rots.

-

Next steps

-

After building, your next step depends on whether you built Boot to Gecko for the emulator or for a real mobile device; see the following articles for details:

- -
-

Submitting bugs on B2G/Firefox OS/Gaia

-

Once you've got a B2G/Firefox OS build running, you'll probably want to start to file bugs against this specific version, so the Firefox OS community can improve things as effectively as possible. You'll want to file the bug on Bugzilla, under the "Firefox OS" project, but you should include version specifics:

-
    -
  1. To start with, tell us the major version number, e.g. 1.4.0.0-prerelease. This can be found on the device under Settings > Device Information.
    2. -
  2. You can provide more specific version identifiers by  returning the current hashes from the gaia and gecko repositories. This can be done like so: - 
    #!/bin/bash
-(cd gaia;  echo "gaia  $(git rev-parse HEAD)")
-(cd gecko; echo "gecko $(git rev-parse HEAD)")
    -
    3. -
diff --git a/files/de/archive/b2g_os/building_and_installing_firefox_os/compatible_devices/index.html b/files/de/archive/b2g_os/building_and_installing_firefox_os/compatible_devices/index.html deleted file mode 100644 index ea95805479..0000000000 --- a/files/de/archive/b2g_os/building_and_installing_firefox_os/compatible_devices/index.html +++ /dev/null @@ -1,357 +0,0 @@ ---- -title: Kompatible Geräte -slug: Archive/B2G_OS/Building_and_installing_Firefox_OS/Compatible_Devices -translation_of: Archive/B2G_OS/Building_and_installing_B2G_OS/Compatible_Devices ---- -
-

Install B2G OS in you device easily with B2G installer - a Firefox Add-on.

-
- -
-

Note: All devices have the recommended build target below its name (see nickname or codenames). For example to build for Nexus 6 do ./build.sh nexus-6-l. Device codenames where given directly by manufacturers. You can find it in build.prop file of a stock ROM.

-
- -

Development Devices

- -

These devices are official reference devices for developing B2G OS.

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Image
Name
- (Android version)		Z3 Compact (Kitkat)
- Sony Shinano platform		Z3 (Kitkat)
- Sony Shinano platform		Flame (Kitkat)
Nicknamearies-kkleo-kkflame-kk
Build and installation informationhttps://discourse.mozilla-community.org/t/building-b2g-os-for-aries-z3c/8082 https://discourse.mozilla-community.org/t/flame-builds/8548
Available in B2G InstallerYesNoYes
- -

Community Supported Devices

- -

Those devices are supported by community efforts. Feel free to help them !

- -
-

Builds distribution frequency may vary depending of maintainers number and time available.

-
- -

Working devices

- -

These devices have builds available running B2G OS :

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Image
Name
- (Android version)		ZTE Open CNexus 5WileyFox SwiftFairphone 2
Nicknameopenc-fr / openc-ebay                         
Build and installation informationhttps://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

-
Available in B2G Installer -

No

- -

(but a buildbot is available)

- 		YesYesNot yet, but almost done. Blobfull build working.
- -

Work in progress

- -

Work is going on to support these devices :

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Image 
Name
- (Android version)		E3
- Sony Yukon platform		Z1 Compact (Lollipop)
- Sony Rhine platform		Xiaomi Redmi 1S
Nicknameflamingo-lamami-larmani
Build and installation informationhttps://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
Support statusBlocked, problem with flashing toolsEarly building testsEarly building tests
- -

Devices with porting possibilities

- -

This is a (non-exhaustive) list of devices with porting potential, thanks to available AOSP or Cyanogen Mod version, or because they supported Firefox OS until version 2.6.

- -
-

Note: There aren't currently any ports for these phones, but it is possible to build B2G OS. See how to build section for more info. You are welcome to maintain these builds.

-
- -

Nexus Devices

- -

These devices are (almost) automatically supported by B2G OS because they are Google's reference devices for AOSP.

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

Sony Devices

- -

These devices use Sony Mobile's Open Devices initiative, which aims to support all modern Xperia devices in AOSP.

- -

These devices are built on a Lollipop AOSP base.

- -
-

Right now most of the Sony devices are missing camera support. This depends on work in progress by Sony developers.
- Also, we need contributors to maintain these ports.

-
- -

Devices where support for B2G OS is ongoing are not listed here.

- -

Sony Shinano Platform

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

Sony Rhine Platform

- -
-

Rhine devices use a legacy NFC chip so this feature is currently missing. See bug 1226720 We need contributors to maintain these ports.

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

Sony Yukon Platform

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

CyanogenMod Supported Devices

- -

Here be dragons! (To be completed)

- -

Legacy Devices

- -

Some old devices are no longer maintained by the community, but it is still possible for volunteers to keep them alive (Yay Open-Source!). Feel free to contact the team previously working on these devices to get some help.

- -

No device here right now.

- -

Obsolete Devices

- -
-

Forget about these device's support if you have one.

-
- -

Several old devices are no longer maintained for B2G OS , and we do not have a community to keep them alive. The current status of these devices is unknown, which probably means they cannot be built on B2G OS master branches.

- - - - - - - - - - - - - - - - - - - - - - -
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/de/archive/b2g_os/building_and_installing_firefox_os/firefox_os_build_overview/index.html b/files/de/archive/b2g_os/building_and_installing_firefox_os/firefox_os_build_overview/index.html deleted file mode 100644 index 56422c4cf6..0000000000 --- a/files/de/archive/b2g_os/building_and_installing_firefox_os/firefox_os_build_overview/index.html +++ /dev/null @@ -1,155 +0,0 @@ ---- -title: 'Firefox OS Build Prozess: Übersicht' -slug: Archive/B2G_OS/Building_and_installing_Firefox_OS/Firefox_OS_build_overview -tags: - - Firefox OS - - build - - install -translation_of: Archive/B2G_OS/Building_and_installing_B2G_OS/B2G_OS_build_process_summary ---- -
-

Firefox OS zu kompilieren und zu installieren erfordert eine erhebliche Menge Zeit, Netzwerkbandbreite und Rechenleistung. Leider können auch Dinge schiefgehen. Dieser Artikel beschreibt die Ziele und Schritte des Build-Prozesses, um Benutzern während der Firefox OS Installation zu helfen. Details der einzelnen Schritte werden in den verlinkten Seiten erläutert.

-
- -
-

Anmerkung: Der Firefox OS Build Prozess ist voll von Bezügen zu 'B2G' oder 'Boot2Gecko'. 'Boot2Gecko' war der ursprüngliche Codename des Firefox OS Projekts.

-
- -

Das Ziel: vier 'image'-Dateien

- -

Der grundsätzliche Zweck des Build Prozesses ist es vier Dateien zu erzeugen, die auf das Firefox OS-Gerät kopiert werden können.

- - - - - - - - - - - - - - - - - - - - -
boot.imgDer Linux-Kernel und ein Image des root-Dateisystems, wobei letzteres ein Set von grundlegenden UNIX-Tools zur Verfügung stellt.
system.imgDer Kern von Firefox OS inklusive einiger Teile von Gonk, der Portierung von Gecko, und dem ausführbaren Programm b2g.
userdata.imgDas Gecko-Profil des Benutzers und die Gaia Web-Anwendungen für das Gerät.
recovery.imgEin Linux-Kernel und ein Image des root-Dateisystems zusammen mit einem einfachen Werkzeug, um eine defekte Installation zu reparieren.
- - -

Wenn diese 4 Images erzeugt wurden, können sie auf das Gerät übertragen werden.

- -

Firefox OS setzt auf dem Android Open Source Project (AOSP) auf. Die AOSP-Werkzeuge adb und fastboot bieten Möglichkeiten auf ein Gerät zuzugreifen und es zu verändern. Insbesondere kann das Kommando adb reboot-bootloader ein angeschlossenes Gerät dazu bringen, neu zu starten und in einem frühen Bootloaderstadium zu pausieren, während das Kommando fastboot flash $partition $image dazu benutzt werden kann, ein Image auf das Gerät zu kopieren.

- -

Das Boot-Image

- -

Das Boot-Image (boot.img) ist eine Kombination aus dem Linux-Kernel und einer initialen root Partition, die die grundlegenden Werkzeuge und Initialisierungs-Skripte bereit stellt. Letzteres wird für eine effektive Nutzung durch das Gerät in den Gerätespeicher kopiert und wird deshalb als "ramdisk" (RAM-Disk) bezeichnet. Das Boot-Image wird in die boot Partition des Gerätes kopiert und die Inhalte der RAM-Disk erscheinen unter dem root-Verzeichnis, wenn zur Laufzeit auf das Geräte-Dateisystem zugegriffen wird; zum Beispiel beim Ausführen von adb shell.

- -

Das Boot-Image richtet auch die Berechtigungen des root-Benutzers in der Datei default.prop im root-Verzeichnis ein.

- -

Es ist auch möglich vorhandene Boot-Images zu verändern, indem man die Datei untersucht, sie in Kernel und RAM-Disk trennt, die Inhalte der RAM-Disk extrahiert, diese ändert, das RAM-Disk-Image neu zusammenstetzt und daraus eine funktionierende boot.img-Datei erzeugt. Ein Beispiel findet man auf der Alcatel One Touch Fire Hacking (Mini) Guide-Seite.

- -

Boot-Images können vor der Installation getestet werden, indem man sie dem Gerät "unterschiebt" (sideload). Der Geräte-Start kann im Bootloader angehalten werden. Im Bootloader-Modus kann man dann mit fastboot von einem eigenen Boot-Image booten, indem man das Kommando fastboot boot /some/path/to/boot.img verwendet.

- -

Das System-Image

- -

Das System-image (system.img) stellt die Grundfunktionen von Firefox OS bereit:

- - - -
-

Siehe Firefox OS platform guide für nähere Informationen zur System-Architektur.

-
- -

Das System-Image wird in die system Partition des Geräts kopiert und ist im laufenden Betrieb im Verzeichnis /system/ zu sehen wenn das Dateisystem gemountet wurde.

- -
-

Hinweis: Das System-Image stellt zudem vom Gerät genutze Binär-Programme zur Verfügung, insbesondere den RIL (Radio Interface Layer) für die Funk-Verbindungen.

-
- -

Das User Data Image

- -

Das User Data Image (userdata.img) enthält die Gaia Apps des Anwenders.

- -

Das User Data Image wird in die userdata Partition des Gerätes kopiert. Der Inhalt ist im laufenden Betrieb im Verzeichnis /data/ zu sehen wenn das Dateisystem gemountet wurde. Das Verzeichnis /data/b2g/ enthält das Mozilla Gecko Profil des Anwenders, das Verzeichnis /data/local/webapps/ enthält die verfügbaren Apps.

- -

Das Recovery Image

- -

Das Recovery Image (recovery.img) enthält denselben Kernel und eine vergleichbare RAM-Disk wie die Boot Image Partition. Das Recovery Image verwendet allerdings ein anderes Initialisierungs-Skript, welches dem Anwender verschiedene Recovery-Funktionen zur Verfügung stellt die mit den Tasten des Gerätes bedient werden können.

- -

Das Recovery Image wird in die recovery Partition des Gerätes kopiert, welche im Normalbetrieb nicht ins Dateisystem gemountet wird.

- -

Der Build Prozess: setup, configure, build, install

- -

Build Prozess und Installation von Firefox OS  bestehen aus 4 Schritten:

- - - - - - - - - - - - - - - - - - - - -
SetupBereitstellen aller für den Build Prozess benötigten Programme wie z.B. Compiler und Bibliotheken.
ConfigureDownload des Quellcodes und Erzeugen einer configure Datei welche Umgebungsvariablen definiert in denen die benötigten Pfade und Parameter gespeichert werden.
BuildErzeugen des Gecko Anwender-Profils und der Gaia Anwendungen des Gerätes.
InstallInstallieren der Dateien auf dem Gerät.
- - -

 

- -

Setup

- -

Die Setup-Phase ist notwendig um sicher zu stellen dass sämtliche für den Build Prozess benötigte Software zur Verfügung steht, z.B. Compiler und Build Tools.

- -

Dieser Schritt kann manuell oder per Skript durchgeführt werden. Details hierzu findest Du auf Firefox OS build prerequisites.

- -
-

Hinweis: Auf UNIX und UNIX-artigen Computern kann man mit dem Kommando which prüfen, ob ein für den Build Prozess benötigtes Programm vorhanden ist. Als Parameter erwartet which den Namen des benötigten Programms.

-
- -

Configuration

- -

Der eigentliche Build Prozess startet mit dem Erstellen einer Kopie der Firefox OS (bzw. B2G) Software, gewöhnlich wird ein Git Clone des B2G Projekts erstellt. Der Schritt Configuration kopiert den gesamten benötigten Quellcode und erzeugt eine config Datei, welche die benötigten Installations-Parameter enthält.

- -

Ausgeführt wird dieser Schritt mit dem config.sh Skript. Details findest Du auf der Preparing for your first B2G build Seite.

- -

Das Configure Skript benötigt einen Parameter mit dem der Gerätetyp spezifiziert wird. Diese sogenannten Code Names fliessen in den Build Namen ein und stehen für eine bestimmte CPU Architektur und nicht für ein spezielles Gerät. Momentan kann man also nicht anhand des Build Names bestimmen ob ein Build auf einem bestimmten Gerät lauffähig ist.  Eine Liste der verfügbaren Code Names findest Du hier.

- -

Der Schritt Configure nutzt repo, ein Tool des Android Open Source Projekts, für den Download der für den Build benötigten Software. Die Software wird gespeichert im Verzeichnis repo/projects. Aufgrund der herunter zu ladenden Datenmenge und der durchzuführenden Schritte kann der Schritt Configure länger dauern.

- -

Build

- -

Im Schritt Build wird der Quellcode kompiliert und die Image-Dateien werden erzeugt.

- -

Hierzu wurd das build.sh Skript ausgeführt. Details hierzu findest Du in Building Firefox OS.

- -

Das Skript versucht alle Quellcodes in einem Schritt zu kompilieren: Die Android Open Source Project Tools, den Linux Kernel und die Gaia Web Anwendungen. Wenn dieser Schritt fehl schlägt ist nicht immer klar, an welcher Stelle der Build ein Problem hatte.

- -

Es ist möglich, nur einzelne Komponenten des Gesamtpakets zu kompilieren. Z.B. kann Gecko einzeln kompiliert werden, indem das Build Skript mit dem gecko Parameter aufgerufen wird. Das gleiche gilt für Gaia, wo das Build Skript mit dem  gaia Parameter gestartet wird. Diese Pakete können einzeln installiert werden,wie im folgenden beschrieben Abschnitt wird.

- -

Ebenso ist es möglich die oben beschriebenen Image-Dateien zu erzeugen. Z.B. kann man das System-Image mit ./build.sh out/platform/$target/system.img erzeugen, wobei der Parameter $target derselbe ist wie im Schritt Configuration.

- -

Install

- -

Im Schritt Install wird der neu kompilierte Code auf das Gerät kopiert. Hierzu wird das Skript flash.sh ausgeführt.

- -

Es können auch gezielt einzelne Komponenten des neu erstellten Build-Pakets installiert werden, indem das Flash Skript mit den entsprechenden Parametern gestartet wird . Zum Beispiel können die Gaia Web Anwendungen durch ./flash.sh gaia installiert werden.

diff --git a/files/de/archive/b2g_os/building_and_installing_firefox_os/index.html b/files/de/archive/b2g_os/building_and_installing_firefox_os/index.html deleted file mode 100644 index 51b1e0f6d4..0000000000 --- a/files/de/archive/b2g_os/building_and_installing_firefox_os/index.html +++ /dev/null @@ -1,45 +0,0 @@ ---- -title: Erstellen und Installieren von Firefox OS -slug: Archive/B2G_OS/Building_and_installing_Firefox_OS -translation_of: Archive/B2G_OS/Building_and_installing_B2G_OS ---- -

B2GOS befindet sich derzeit in aktiver Entwicklung und ist daher im Status einer Vorveröffentlichung. Um sicher die aktuellste Version zu benutzen empfiehlt es sich B2GOS selbst zu erstellen und zu installieren. Die Artikel auf dieser Seite führen dich durch die Prozesse um B2GOS für den Emulator, ein kompatibles Endgerät, oder das Gaia Benutzer Interface im Firefox Browser, zu erstellen.

- - - - - - - - -
-

Beschaffen und Erstellen von B2GOS

- -
-
Voraussetzungen zum Erstellen von B2GOS
-
Was du vor der Ersterstellung von B2GOS brauchst und tun musst.
-
Vorbereitungen zum Erstellen von B2GOS
-
Um B2GOS zu erstellen müssen zuerst die Quelldaten heruntergeladen werden. Was du dazu tun musst und wie es funktioniert wird in diesem Artikel erklärt. 
-
Erstellen von B2GOS
-
Erstellen von B2GOS für die Zielplattform.
-
- -

View All...

- 		-

Installieren von B2GOS und/oder Gaia

- -
-
Möglichkeiten B2GOS zu testen
-
Hier wird erklärt welche verschiedenen Möglichkeiten es gibt B2GOS zu testen. Ob direkt im Browser mittels Gaia, auf dem Mobiltelefon oder im Emulator? Hier kannst du dir einen Überblick über die Möglichkeiten verschaffen.
-
Gaia im Browser
-
Wie man Gaia im Webbrowser testet.
-
B2GOS als Desktop Anwendung
-
Firefox OS kannst du in einer Desktop Anwendung die die Gaia Umgebung simuliert testen. Damit erzielst du bessere Ergebnisse als im Browser, es ist aber noch nicht so akkurat wie im Emulator.
-
B2GOS im Emulator
-
Eine Anleitung zur Benutzung von B2GOS im Emulator, und eine Einführung in die Auswahl des richtigen Emulators zur entsprechenden Aufgabe.
-
B2GOS auf deinem Gerät
-
Anleitung zur Installation von B2GOS auf Mobiltelefonen.
-
-
- -

 

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

Die Entwicklereistellungen befinden sich in den Firefox OS Einstellungen. Dieses Panel bietet eine Vielzahl an Optionen, die das Debugging deiner Open Web Anwendung für Firefox OS erleichtern. Dieser Artikel beschreibt die verfügbaren Optionen und erklärt wie diese benutzt werden können.

-
-

Der Einstellungsbereich für die Entwickler-Optionen wurde bewusst in einem Untermenüpunkt versteckt, um ein versehentliches Aktivieren durch unerfahrene Benutzer zu vermeiden, was eine Beeinträchtigung der Performance oder Auswirkungen auf die visuelle Darstellung von Firefox haben kann. Das Entwicklermenü sieht ähnlich aus wie auf der folgenden Darstellung gezeigt (dieses Bild wurde mit einem Geeksphone Keon mit einer im April 2014 erzeugten Version von Firefox OS 2.0 erstellt):

-

-

Das Entwicklermenü kann folgendermaßen erreicht werden:

- -

Im folgenden Abschnitt werden alle Optionen einzeln vorgestellt und erklärt wie diese verwendet werden können.

-
-

Wichtig: Diese Tools sind hilfreich, aber können Probleme im normalen Gebrauch des Telefons versursachen. Einstellungen, die dafür bekannt sind, dass sie Probleme verursachen können, sind per default abgeschaltet. Falls du Probleme mit den Funktionen feststellen solltes, versuche die entsprechenden Funktionen wieder zu deaktivieren.

-
-

Einstellungen der Developer Tools

-

Debugging via USB

-

Die "Remote debugging" Option aktiviert das ferngesteuerte debugging deines Firefox OS Gerätes. Außerdem wird die ADB Kommando-Eingabe aktiviert. In Firefox < 1.4 gibt es dafür nur ein aktivierbares Kontrollkästchen; ab Firefox 1.4 sind es drei Optionen:

- -

Developer HUD

-

Ab Firefox OS 1.4, öffnet ein Berühren des Menüeintrages Developer HUD folgendes Auswahlmenü:

-

-

Die beiden ersten Kontrollboxen (immer aktiv) sind:

- -

Anschließend folgt ein Slider, mit dem weitere Entwickler-Optionen ('Developer Tools') aktiviert werden können , auch weitere Checkboxen sind verfügbar:

- -

Frames per second

-

Enabling this option reports three numbers in the top left of the Firefox OS display; the values reported are an average of recent results within a sliding window, meant to be "instantaneous" but fairly accurate. As such, all numbers are "guesses":

- -

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 {{ anch("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 {{domxref("console.log()")}} function does nothing.

-

Gaia debug traces

-

Enabling this directly enables DEBUG traces in Gaia; see {{ bug("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 {{ anch("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 {{ anch("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 {{ anch("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 {{ Bug("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 {{ Bug("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/de/archive/b2g_os/debugging/index.html b/files/de/archive/b2g_os/debugging/index.html deleted file mode 100644 index a83bb6ae67..0000000000 --- a/files/de/archive/b2g_os/debugging/index.html +++ /dev/null @@ -1,80 +0,0 @@ ---- -title: Debugging on Firefox OS -slug: Archive/B2G_OS/Debugging -tags: - - B2G - - Debugging - - Firefox OS - - NeedsTranslation - - QA - - Testing - - TopicStub -translation_of: Archive/B2G_OS/Debugging ---- -
-

There are two main types of debugging you'll want to with Firefox OS: debugging apps, and debugging other aspects of the system. This section of the site provides articles covering the different tools at your disposal to debug your Firefox OS code.

-
-

Debugging apps

-

When debugging your web apps, the best tool at your disposal is Mozilla's powerful App Manager, which allows you to run your apps directly on a real device or simulator, update any changes instantly, and debug them directly on the device using Mozilla's excellent developer tools. This should be your first choice, especially for app/Gaia debugging.

-
-
- Using the App Manager
-
- The App Manager is a new tool available in Firefox for Desktop, which provides a number of useful tools to help you test, deploy and debug HTML5 web apps on Firefox OS phones and the Firefox OS Simulator, directly from your browser.
-
- Debugging out of memory errors on Firefox OS
-
- This article describes how B2G's multiprocess architecture affects what the phone does when we run out of memory, and how to understand and debug OOM crashes.
-
-

Debugging Gaia/B2G

-

If you want to debug code from the Gaia apps suite or B2G itself, the following tools will be of use to you.

-
-
- Debugging using the desktop B2G client
-
- You can use the dedicated B2G desktop application (and associated tools) to debug multiple aspects of B2G and Gaia.
-
- Quickstart guide to Gaia development
-
- This guide provides a very quick easy guide to developing and debugging Gaia apps, including running Gaia inside desktop Firefox, and debugging Gaia with App Manager.
-
- Debugging B2G using gdb
-
- The popular gdb debugger can be used to debug Firefox OS and web apps running on a device, or on an emulator. This guide will show you how it's done.
-
- Debugging B2G using Valgrind
-
- Valgrind gives developers access to information about memory allocations, threads, and other information important to performance. This guide shows how to run Valgrind either on desktop B2G or select phone hardware.
-
- Getting NSPR logs in B2G
-
- You can use NSPR logs to record HTTP and other networking.
-
- Debugging OpenGL
-
- How to debug OpenGL code on Firefox OS.
-
-

General setup and information

-

The following articles provide information on individual aspects of setup for Firefox OS development. The chances are that you won't need these, especially if you are just debugging apps using the App Manager. But we have made them available here in case you do.

-
-
- Developer settings for Firefox OS
-
- There are a number of settings options available for developers on Firefox OS. This guide explains what they do and how to take advantage of them.
-
- Installing and using ADB
-
- Many aspects of Firefox OS development require installation of adb, the Android Debug Bridge. This article explains how to do that, and shares some common useful ADB commands.
-
- On-device console logging
-
- How to log to console on a Firefox OS device, and how to access the resulting logs for review on your computer.
-
- Connecting a Firefox OS device to the desktop
-
- This short guide explains how to set up your Firefox OS device and your desktop so that the desktop can communicate with the device over USB.
-
- Setting up to debug Firefox OS code
-
- Before you can begin using most of the tools integrated into Firefox for debugging code running under Firefox OS, you need to do a little configuration work. This article explains what you need to do.
-
diff --git a/files/de/archive/b2g_os/debugging/installing_adb/index.html b/files/de/archive/b2g_os/debugging/installing_adb/index.html deleted file mode 100644 index 9e49cc786b..0000000000 --- a/files/de/archive/b2g_os/debugging/installing_adb/index.html +++ /dev/null @@ -1,70 +0,0 @@ ---- -title: ADB installieren und benutzen -slug: Archive/B2G_OS/Debugging/Installing_ADB -tags: - - ADB - - B2G - - Debugging - - Firefox OS - - Installation - - mobil -translation_of: Archive/B2G_OS/Debugging/Installing_ADB ---- -
-

Viele Aspekte der Firefox OS Entwicklung erfordern die Installation von ADB, der Android Debug Bridge. Dieser Artikel erklärt, wie das geht und zeigt einige häufig verwendete und nützliche ADB Befehle.

-
-

ADB Installieren

-

ADB kann als Bestandteil des Android SDK Pakets für Mac, Linux oder Windows heruntergeladen und installiert werden - besuchen Sie dazu die Get the Android SDK Seite.

-

Bei neueren Linux Distributionen ist adb bereits in den Repositories verfügbar. Für Ubuntu 12.10 und neuere, führen Sie folgenden Befehl aus:

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

Oder für Fedora 18/19:

-
sudo yum install android-tools
-

Oder auf OSX mit Homebrew:

-
brew install android-platform-tools
-

Falls ihre Distribution kein Paket für adb zur Verfügung stellt (z.B. Ubuntu 12.04 oder Fedora 17), müssen Sie das Android SDK starter package für ihre Plattform installieren (wählen Sie die Option ADT Bundle, nicht SDK Tools Only). Führen Sie dann deren Paketmanager, $SDK_HOME/tools/android aus und nutzen Sie dann die GUI zum Installieren von "Android SDK Platform-tools".

-

Finden Sie heraus, wo adb installiert wurde (üblicherweise in usr/bin, unter Umständen zusätzlich in adt/platform-tools, je nach Installationsart). Stellen Sie sicher, dieses Verzeichnis zu ihrem PATH hinzuzufügen. Dies erreichen Sie durch Hinzufügen  der Zeile

-
PATH=$SDK_HOME:$PATH
-

in der Sie $SDK_HOME durch den Pfad ihres android sdk  ersetzen, zu ihrer ~/.bashrc oder vergleichbarem.

-

Fehlerbehebung

-

Wenn Sie eine 64-bit Installation verwenden, und Sie den Fehler "File not found" bei der Ausführung von 'adb' bekommen, obwohl diese Datei vorhanden ist, müssen Sie 32-bit Kompatibilitätsbibliotheken installieren. Um das mit apt zu tun:

-
sudo apt-get install ia32-libs
-

Häufig verwendete ADB Befehle

-

Der folgende Abschnitt erklärt einige häufig verwendete, nützliche adb Befehle.

-

Den b2g Prozess neu starten

-

b2g ist das Äquivalent einer XULRunner Anwendung die auf einem Smartphone auf einem Android-basierten Kernel ausgeführt wird. Manchmal kann ein Neustart dieser Anwendung nützlich sein; so können Sie die Anwendungsumgebung zurücksetzen ohne das Gerät neu zu starten. Sie können dies tun indem Sie folgendes in ihr Terminal eingeben, während ihr Gerät mit ihrem Computer verbunden ist (oder während der Ausführung des Debuggers):

-
adb shell killall b2g
-

Portweiterleitung zum Debuggen aktivieren

-

Um einfach eine Portweiterleitung zu aktivieren (zum Beispiel wenn Sie den App Manager nutzen um Apps auf ihrem Firefox OS Gerät zu debuggen), geben Sie folgenden Befehl in Ihrem Terminal ein:

-
adb forward tcp:6000 localfilesystem:/data/local/debugger-socket
-

Dies müssen Sie jedesmal beim neu Starten oder Aus- und wieder Einstecken des Smartphones tun. Sie können die Socket Nummer ändern, wenn gewünscht.

-

Portweiterleitung zu einem lokalen Rechner

-

Um Ports zu einem lokalen Rechner weiterzuleiten, müssen Sie die netcat and ssh binaries herunterladen und folgende Befehle ausführen:

-
# this is an awful hack but does in fact work...
-host$ adb forward tcp:7979 tcp:6969
-
-# make some named pipes so that we can make a bidirectional netcat
-phone$ mknod readback p
-host$ mknod readback p
-
-# this sets up a one time use connection to back to the host
-# listen on ports 6969 and 5959 and forward all the information between them
-phone$ ./netcat -l -p 6969 < readback | ./netcat -l -p 5959 > readback
-# connect to port 7979 (port 6969 on the device) and the local ssh server and forward all information between them
-host$ ./netcat localhost 7979 < readback | ./netcat localhost 22 > readback
-
-# now when we connect to port 5959 on the phone it will be like connecting to ssh server on the host
-
-# use the netcat reversal to set up an ssh connection back to the host and forward port 9999 on the device to 'localhost:8000' (this could be anything like 'google.com:80')
-phone$ ./ssh localhost -p 5959 -L 9999:localhost:8000
-

Das wird Port 9999 auf dem Gerät zu Port 8000 des Hosts weiterleiten.

-

Alternativ können Sie einen SSH-Server (dropbear und host_key) mit folgenden Befehlen direkt auf dem Gerät verwenden:

-
phone$ DROPBEAR_PASSWORD=root ./dropbear -p 9000 -F -v -a -r host_key ./dropbear
-host$ adb forward tcp:8888 tcp:9000
-# public key authentication has been hard coded to succeed (make sure you have a public key for ssh to use)
-host$ ssh -vvv root@localhost -p 8888 -R 9999:people.mozilla.org:80
-
-

Weitere Anleitungen:

- diff --git "a/files/de/archive/b2g_os/debugging/verbinden_eines_firefox_os_ger\303\244ts_mit_dem_rechner/index.html" "b/files/de/archive/b2g_os/debugging/verbinden_eines_firefox_os_ger\303\244ts_mit_dem_rechner/index.html" deleted file mode 100644 index d82f69789d..0000000000 --- "a/files/de/archive/b2g_os/debugging/verbinden_eines_firefox_os_ger\303\244ts_mit_dem_rechner/index.html" +++ /dev/null @@ -1,41 +0,0 @@ ---- -title: Connecting a Firefox OS device to the desktop -slug: Archive/B2G_OS/Debugging/Verbinden_eines_Firefox_OS_Geräts_mit_dem_Rechner -tags: - - ADB - - Firefox OS -translation_of: Archive/B2G_OS/Debugging/Connecting_a_Firefox_OS_device_to_the_desktop ---- -
-

Diese Anleitung erklärt, wie man ein Firefox OS  Gerät mit dem Rechner über USB verbindet.

-
-
-

Achtung: Um Apps auf einem Firefox OS Gerät zu debuggen und wenn auf dem Gerät Firefox 1.2+ läuft, ist der beste Weg den App Manager zu benutzen. Details können unter Benutzung des App Mangers nachgelesen werden. Wird eine Version von Firefox OS kleiner 1.2 benutzt, kann man unter Einrichtung des Firefox OS Debugging Modus unter Verwendung der Entwickler Tools mehr über das Standard Remote Debugging  erfahren.

-
-

Einrichtung des Geräts

-

Auf deinem Firefox OS Gerät (see the layout):

-
    -
  1. öffnen der App Einstellungen, dann Geräteinformationen > Weitere Informationen > Entwickler.
    2. -
  2. Im Entwickler Menü  "Debugging über USB" aktivieren.
    3. -
-

Einrichtung des Rechners

-

Um ein Gerät mit dem Rechner zu verbinden muss die Android Debug Bridge (adb) installiert sein. Beachte dass das Firefox OS Simulator add-on eine adb mitbringt.

-

Instructions for setting up your desktop are specific to your operating system and are detailed in point 3 of "Setting up a Device for Development" on the Android developer site. We've listed some additional instructions below.

-

Spezielle Anweisungen für Mac OS X

-

If you're running Mac OS X, you have downloaded a package which has a name along adt-bundle-mac-x86_64-20130522. Put that folder into the Applications folder, so that you get /Applications/adt-bundle-mac-x86_64-20130522/ which contains two directories: eclipse and sdk. Then you can edit your ~/.bashrc and add

-
export PATH="/Applications/adt-bundle-mac-x86_64-20130522/sdk/platform-tools:$PATH"
-

(It will be ready for the next time you start your shell). You can now type on the CLI of the shell:

-
adb devices
-
-

and it will return a list of connected devices such as:

-
List of devices attached
-AA:BB:A5:B5:AA:BB    device
-

Spezielle Anweisungen für Linux

-

If you're running Linux, the vendor ID to use for Firefox OS Geeksphone devices is 05c6, so your /etc/udev/rules.d/51-android.rules file should contain an entry similar to:

-
SUBSYSTEM=="usb", ATTR{idVendor}=="05c6", MODE="0666", GROUP="plugdev"
-

Spezielle Anweisungen für Windows

-

You can download Windows drivers for the Geeksphone from the Geeksphone website.

-

Windows 8 by default will not let you install unsigned drivers. See this tutorial on "How to install an unsigned driver on Windows 8".

-

Since Windows XP Home Edition doesn't include tasklist.exe, Simulator won't detect the device. This can be solved downloading that file from ComputerHope website and putting it in Windows\System32 folder.

-

Einrichtung überprüfen

-

Once you've followed these instructions, attach the device to the desktop using a USB cable, open a command prompt and type "adb devices" (ensuring that adb is in your path). You should see your Firefox OS device listed in the output.

diff --git a/files/de/archive/b2g_os/developing_firefox_os/filing_bugs_against_firefox_os/index.html b/files/de/archive/b2g_os/developing_firefox_os/filing_bugs_against_firefox_os/index.html deleted file mode 100644 index 6a269b17bc..0000000000 --- a/files/de/archive/b2g_os/developing_firefox_os/filing_bugs_against_firefox_os/index.html +++ /dev/null @@ -1,183 +0,0 @@ ---- -title: Firefox OS Fehler melden -slug: Archive/B2G_OS/Developing_Firefox_OS/Filing_bugs_against_Firefox_OS -tags: - - Abbruch - - Bugs - - Bugzilla - - Fehler - - Firefox OS -translation_of: Archive/B2G_OS/Developing_Firefox_OS/Filing_bugs_against_Firefox_OS ---- -
-

Dieser Artikel enthält eine Anleitung zum Melden von Fehlern zum Firefox OS Projekt, zu Gaia und zu B2G (Boot to Gecko).

-
- -

Bugzilla

- -

Wie die meisten Mozilla-Projekte nutzen wir Bugzilla für die Fehler- und Problemverfolgung. Du kannst Fehler an Bugzilla melden, wenn Du Fehler entdeckt hast — wir haben eine eigene Bugzilla Kategorie (Product) für Firefox OS mit Unter-Kategorien (Components) für Gaia, Gonk und Gecko. Du solltest diese Kategorien verwenden, um Fehler und Probleme bezüglich Firefox OS, Gaia etc. zu melden.

- -

Fehler melden

- -

Zum effektiven Melden von Fehlern und Problemen kannst Du dieses Bugzilla Template verwenden. Hinweise zum Ausfüllen des Templates findest Du weiter unten.

- -

Pflichtfelder und optionale Felder

- -

Die folgenden Felder in Bugzilla sind immer auszufüllen:

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
FeldBeschreibung
ComponentKategorie, in die der Fehler gehört. Wenn der Fehler in keine der vorhandenen Kategorien passt kannst Du "General" verwenden.
SummaryZusammenfassung, die den Fehler kurz und treffend beschreibt.
DescriptionAussagefähige Beschreibung des Fehlers. Eine gute Fehlermeldung sollte die Schritte zum Reproduzieren (steps to reproduce, STR) des Fehlers, die erwarteten und die tatsächlichen Ergebnisse enthalten. Bitte gib auch an, wie oft dieser Fehler auftritt (z.B. wenn Du die Schritte öfter wiederholst).
Build InformationGehe zu Einstellungen > Geräteinformationen > Weitere Informationen und füge folgende Informationen in die Fehlermeldung ein: Betriebssystemversion, Plattform-Version, Build-ID, Updatekanal und die Informationen zum Commit auf Git. Falls Du einen Mac oder Linux Computer mit adb hast und dort git installiert ist, dann kannst Du dieses Skript ausführen und dessen Ergebnis in die Meldung kopieren.
ScreenshotsBitte füge Bildschirmfotos ein. Das kann uns helfen, den Fehler zu analysieren. Auf dem Flame Smartphone drückst Du dafür 2 Sekunden lang gleichzeitig den Ein-/Aus Schalter und die "Lautstärke runter/leiser" Taste bis auf dem Display eine Bestätigung des Bildschirmfotos angezeigt wird. Anschließend überträgst Du dieses Foto via USB auf Deinen Computer.
VideoFalls sich Dein Fehler auf ungewöhnliche Veränderungen des Displays bezieht die mit einem Bildschirmfoto nicht dargestellt werden können, dann mach bitte ein Video davon. Dieses Video kannst Du dann als Anhang zur Fehlermeldung hinzufügen. Du kannst das Video auch nach YouTube hochladen und die URL in die Fehlermeldung einfügen.
ADB logsFalls adb auf Deinem Computer installiert ist: Schließe bitte Dein Smartphone an den Computer an und führe das Kommando |adb logcat| aus. Bitte füge das Ergebnis dieses Kommandos in eine Text-Datei ein und füge diese als Anhang zur Fehlermeldung hinzu.
- -

Die folgenden Felder sind optional:

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
FeldBeschreibung
Depends/BlockZeige uns Abhängigkeiten zu anderen Fehlermeldungen.
KeywordsSchlüsselwörter für Bugzilla. Bestimmte Support-Abteilungen nutzen diese zur Statusverfolgung von Fehlern.
WhiteboardBeinhaltet Tags. Füge beliebige Tags zur Statusverfolgung hinzu. Du solltest keine vorhandenen Tags ohne Erlaubnis löschen.
See AlsoHin und wieder haben Fehler Bezug zu einem anderen Fehler. Das kannst Du hier angeben.
FlagsKennzeichen für die Statusverfolgung; das am häufigsten verwendete Kennzeichen in Firefox OS Fehlern ist blocking-b2g. Wenn eine Meldung als blocking-b2g gekennzeichnet ist, dann kann der Fehler die Veröffentlichung eines Releases gefährden und ist somit besonders zu beachten.
SecurityWenn ein Fehler die Sicherheit der persönlichen Daten gefährdet, monetäre Verluste oder ähnliches verursacht, dann solltest Du dieses Feld ankreuzen. Somit ist die Fehlermeldung nur noch für ausgewählte Mitarbeiter sichtbar.
- -

Nähere Informationen zu den Bugzilla-Feldern findest Du auf Bugzilla Fields.

- -

Lokalisierungs-Probleme melden

- -

Wenn Du eine nicht übersetzte Zeichenkette siehst, dann kann das zwei Gründe haben:

- - - -

Wie Lokalisierungs-Probleme (l12y) gemeldet werden

- -
    -
  1. Lege eine Meldung in Bugzilla an, als "Product" wählst Du 'Firefox OS'. Wähle unter "Component" die Firefox OS Komponente, in der das Lokalisierungsproblem auftritt. Trage bitte 'l12y' als Schlüsselwort in das Feld "Keyword" ein.
    2. -
  2. Fülle alle anderen Pflichtfelder aus.
    3. -
- -

Besondere Schlüsselwörter (Keywords)

- -

Die folgende Tabelle enthält Informationen zu speziellen Schlüsselwörten, die Du in Firefox OX Fehlermeldungen häufiger finden wirst.

- -


- Du solltest immer die Kombination Build-Version/Betriebssystem/Plattform, unter der der Fehler behoben ist, ins Kommentarfeld der Fehlermeldung eintragen bevor Du den Status auf Verified setzt. Wenn der Fehler auf allen Plattformen gemeldet ist und Du die Behebung des Fehlers nur auf einer bestimmten Plattform verifizieren kannst, dann gebe dies bitte in der Fehlermeldung an. Bitte setze den Status der Meldung in einem solchen Fall nicht auf Verified. Es müssen erst alle Plattformen erfolgreich getestet worden sein, bevor der Status auf Verified gesetzt wird.
-
- Zu guter Letzt: Falls andere Meldungen als Duplikat Deiner Meldung markiert wurden und Du Deine Meldung auf Verified setzt, dann prüfe diese Duplikate bitte ebenfalls und kommentiere diese Meldungen entsprechend. Oftmals markieren Entwickler eine Meldung als Duplikat obwohl der Fehler nur ähnlich, aber nicht identisch ist. Solche Fehlermeldungen können übersehen werden, wenn der Status ungeprüft auf Verified gesetzt wird.

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
KeywordBeschreibung
metaZeigt an, dass eine Meldung nur zur Statusverfolgung genutzt wird. Mozilla benutz dies, um die Stati mehrerer Meldungen einer komplexeren Entwicklung in einer einzigen Meldung zu verfolgen. Meldungen mit diesem Keyword sollten von Entwicklern nicht in die Patch-Planung einbezogen werden. Bitte denk daran, dass Projektleiter und Tester dieses Keyword für die Statusverfolgung nutzen.
qablockerDieses Keyword wird benutzt, wenn eine Meldung das Testen in der Qualitätssicherung blockiert (manueller oder automatisierter Test eine neuen Entwicklung) und der Fehler daher im nächsten Projekt-Meilenstein der Beta-Phase bzw. Release-Veröffentlichung behoben sein muss.
qawantedNutze dieses Keyword für Meldungen die mehr Informationen, mehr Testfälle oder weitere Informationen zur Reproduzierbarkeit benötigen oder als Duplikat gekennzeichnet sind, ohne dass Du die duplizierte Original-Meldung finden kannst. Der über dieses Keyword angeforderte Qualitätssicherungs-Prozess wird im sogenannten Whiteboard aufgezeichnet. Wenn die Qualitätssicherung ihre Arbeit erledigt hat, sollte dieses Keyword entfernt werden.
regressionDieses Keyword bedeutet, dass das Problem gelöst war und wieder aufgetreten ist (regressed). Um dieses Wiederauftreten des Problems zu verfolgen wird eine neue Meldung mit Keyword "regression" angelegt. Es wird ebenso für Fehler verwendet, die in früheren Releases behoben waren und im aktuellen Release wieder auftreten. Das Nachverfolgen dieser Probleme hilft uns fehleranfällige und instabile Bereiche zu identifizieren, die beim Testen besonders beachtet werden sollten.
regressionwindow-wantedKennzeichnet eine Meldung als "regression" Meldung bei der es sehr hilfreich wäre zu wissen, wann genau der Fehler aufgetreten ist (Zeitpunkt oder Zeitraum).
steps-wantedBei Meldungen mit diesem Keyword wäre es sehr hilfreich zu wissen, wie der Fehler reproduziert werden kann.
verifymeSo gekennzeichnete Probleme sollten von einem Dritten zusätzlich verifiziert werden, auch wenn der Fehler für den Melder und die Qualitätssicherung behoben zu sein scheint.  Die Meldung enthält dann spezielle Angaben zur Hardware und zur Konfiguration, für die die Lösung zusätzlich noch verifiziert werden soll. Du solltest versuchen, diesen Fehler zu reproduzieren. Wenn Du dann bestätigen kannst, dass der Fehler bei Dir ebenfalls behoben ist, dann kann der Status von Fixed auf Verified geändert werden.
-  
crashNutze dieses Keyword, wenn Du Abbrüche in Firefox OS bekommst.
- -
-

Hinweis: Weitere Informationen erhälst Du auf der Seite Bug writing guidelines. Das Mozilla B2G QA Wiki enthält zudem nützliche Informationen zum Melden von Firefox OS Fehlern; die hilfreichsten Seiten sind Bugzilla Usage und Incoming bug triage for Firefox OS.

-
- -
-

Hinweis: Nähere Informationen zum Umgang mit Fehlern in der Gaia-Entwicklung findes Du auf  Submitting a Gaia patch.

-
- -

 

diff --git a/files/de/archive/b2g_os/developing_firefox_os/index.html b/files/de/archive/b2g_os/developing_firefox_os/index.html deleted file mode 100644 index 29f0a9c290..0000000000 --- a/files/de/archive/b2g_os/developing_firefox_os/index.html +++ /dev/null @@ -1,26 +0,0 @@ ---- -title: Hacking Firefox OS -slug: Archive/B2G_OS/Developing_Firefox_OS -translation_of: Archive/B2G_OS/Developing_Firefox_OS ---- -
-

This section provides some useful articles covering different ways in which the Firefox OS experience can be modified/customized during the build or app writing process.

-
-
-
- Modifying the hosts file
-
- A guide to what can be achieved by modifying the Firefox OS hosts file.
-
- Customization with the .userconfig file
-
- How to customize the build and execution of Firefox OS by changing the .userconfig file.
-
- Localizing Firefox OS
-
- A guide to localising the Firefox OS platform, making it available in your preferred languages.
-
- Customizing the keyboard in Firefox OS apps
-
- This guide shows how to customize the keyboard in your Firefox OS apps.
-
diff --git a/files/de/archive/b2g_os/firefox_os_build_prerequisites/index.html b/files/de/archive/b2g_os/firefox_os_build_prerequisites/index.html deleted file mode 100644 index 0c2f90d39c..0000000000 --- a/files/de/archive/b2g_os/firefox_os_build_prerequisites/index.html +++ /dev/null @@ -1,446 +0,0 @@ ---- -title: Firefox OS build prerequisites -slug: Archive/B2G_OS/Firefox_OS_build_prerequisites -translation_of: Archive/B2G_OS/B2G_OS_build_prerequisites ---- -

Vor dem Holen des Codes zum Bauen von Firefox OS benötigt man ein geeignet konfiguriertes Build-System. Im folgenden wird dieser Vorgang beschrieben. Zur Zeit eignen sich 64-bit-Linux-Distributionen und Mac OS X.

-
-

Anmerkung: Wenn man Firefox OS auf ein Telefon installieren will, beginnt man, ohne das Telefon an den Computer angeschlossen zu haben. Im Text wird dann später erklärt, wann man das Telefon anschließen muß.

-
-

Kompatibles Gerät oder Emulator besorgen

-

Das System kann nur für ein kompatibles Gerät (i.a. ein Smartphone) oder einen Emulator gebaut werden. Obwohl wir diverse Geräte unterstützen, gibt es für einige von diesen unterschiedliche Ausführungen. Von diesen Ausführungen unterstützen wir zur Zeit nur bestimmte, und außerdem werden einige Geräte besser unterstützt als andere.

-
-

Anmerkung: Mozillas B2G-Quellcode ist die Referenzimplementation von B2G, aber Telefonherstellern ist es freigestellt, Fehlerkorrekturen ("Patches") hinzuzufügen oder andere Änderungen vorzunehmen. Wenn man zum Beispiel ein Alcatel One Touch kauft, läuft darauf eine herstellerspezifische Version. Das ist für die installierten Apps irrelevant, aber unter Umständen kann es auf  Plattform-Ebene Unterschiede geben. Die Version für das  Nexus-4 ("Nexus 4 Port") wird direkt von Mozilla gepflegt, also ist es viel wahrscheinlicher, dass dieses Telefon mit unserer Gecko-Version auf Anhieb funktioniert, als zum Beispiel bei Rang-3-Geräten.

-
-

Rang 1 (Tier 1)

-

Tier-1-Geräte werden bei der Entwicklung bevorzugt und sind typischerweise die ersten, die Fehlerkorrekturen ("bugfixes") und Erweiterungen ("feature updates") erhalten.

-
-
- Keon
-
- Keon ist ein Gerät der FIrma Geeksphone und eines der ersten Entwicklertelefone. Beachte, dass Binärpakete ("builds") für diese Geräte von Geeksphone bereitgestellt werden.
-
- Inari
-
- Inari ist ein weiteres Testgerät. Benutze diese Konfiguration, um FirefoxOS für die ZTE-Open-Geräte zu bauen. Warnung: Neuere Firefox-OS-Builds könnten auf ZTE Open Probleme beim Booten von der Standard-Boot-Partition machen.
-
- Flame
-
- Flame is Mozillas neues Standard-Referenztelefon für Firefox OS. Die Konfiguration für Flame sollte auch verwendet werden, wenn man für das Gerät ZTE Open C baut, weil beide Geräte auf der Android-Jellybean-Basis aufbauen.
-
-  
-
- Emulatoren (ARM und x86)
-
- Zur Zeit gibt es zwei Emulatoren, einen für die Emulation eines ARM-Prozessors und einen für die Emulation eines x86-Prozessors. Hier erfährt man mehr über die Installation und die Verwendung der Emulatoren.
-
- Achtung: Der x86-Emulator ist derzeit nicht praxistauglich, sowohl was die Installation angeht als auch die Unterstützung.
-
-  
-
- Desktop
-
- Man kann auch eine Version von Firefox OS für Desktop-Rechner bauen; diese führt Gecko in einer XULRunner-Anwendung aus und darin Benutzerumgebung Gaia.
-
- Flatfish
-
- Flatfish ist das erste für Firefox OS entwickelte Tablet, auf dem jedoch einige Telefoniefunktionen fehlen. Es werden ein paar spezielle Einstellungen benötigt, um den Code zu bauen.
-
-

Natürlich kann man den Desktop-Client und die Emulatoren auch bauen, ohne ein Telefon zu benutzen.

-

Rang 2 (Tier 2)

-

Bei den Tier-2-Geräten ist die Grundfunktionalität gegeben, und viele Entwickler, insbesondere App-Entwickler, arbeiten damit, daher sind es üblicherweise die nächsten Geräte (nach Tier-1), für die Änderungen bereitgestellt werden.

-
-
- Samsung Nexus S
-
- Die einzigen Varianten dieses Smartphones, von denen bekannt ist, daß sie mit Firefox OS funktionieren, sind GT-I9020A (mit Amoled-Bildschirm) and GT-I9023 (Billigmodell mit LCD). Möglicherweise funktionieren aber auch weitere.
-
- Samsung Nexus S 4G
-
- The SPH-D720 is supported as a tier 2 device.
-
-

Rang 3 (Tier 3)

-

Man kann Firefox OS für diese Geräte bauen, aber die Hauptentwickler verwenden sie nicht regelmäßig. Bezüglich Stabilität, Zuverlässigkeit und Funktionsvielfalt stehen sie daher den Tier-1- und Tier-2- Geräten möglicherweise nach.

-
-
- Samsung Galaxy S2
-
- Nur die Variante i9100 funktioniert, keine andere, zumindest nicht offiziell (i9100P könnte auch funktionieren, da sie sie sich nur durch einen zusätzlichen NFC-Baustein unterscheidet.)
-
- Samsung Galaxy Nexus
-
- Zur Zeit ist keine Variante bekannt, die nicht funktioniert.
-
- Nexus 4
-
- Einige Anwender haben laut IRC dieses Gerät mit Erfolg getestet. Möglicherweise muß man für den Fall, daß man Android 4.4 installiert hat, vorher auf 4.3 zurückgehen (Android- Betriebssystem-Images sind bei Google erhältlich)
-
- Nexus 5
-
- Einige Anwender haben laut IRC dieses Gerät mit Erfolg getestet.
-
- Tara
-
- Tara ist ebenfalls ein Testgerät. Das "Manifest" für Tara existiert nur im "master branch". Um den Tara-Code zu erhalten, ruft man folgendes Script auf: "BRANCH=master ./config.sh tara".
-
- Unagi
-
- Unagi ist ein Telefon, das als Test- und Entwicklungsplattform für einfache bis Mittelklasse- Smartphones verwendet wird. Viele Core-Firefox-OS-Entwickler arbeiten auf Unagi.
-
- Pandaboard
-
- Das Pandaboard ist eine Entwicklungsplatine ("Board"), die auf der OMAP-4-Architektur basiert, und wird verwendet, um auf mobilen Plattformen zu entwickeln.
-
-
- Wichtig: Nur solche Geräte werden unterstützt, auf denen mindestens Android 4 (alias Ice Cream Sandwich) lauffähig ist. Für den Fall, daß ein Gerät oben aufgeführt ist, aber ein älteres Android-System installiert ist, muß man erst eine neuere Android-Version installieren.
-
-

Bemerkung: Tier-2 und Tier-3-Geräte haben einen virtuellen, d.h durch Software dargestellten, Home-Button anstelle eines physikalischen.

-

Alle Tier-1-Geräte haben  dagegen einen physikalischen "Home"-Button, mit dem man bei Betätigen stets auf den Startbildschirm zurückkehrt. Die meisten Android-Geräte für Version 4 oder später haben einen auf dem Bildschirm dargestellten "Home"-Button. Auch Firefox OS kann solch eine Schaltfläche darstellen; sie wird automatisch bei entsprechenden Geräten aktiviert. Wenn dies versagen sollte, muß man die Einstellungen öffnen und zu den Geräteinformationen navigieren, dort dann "Weitere Informationen" öffnen und "Entwicklermenü" einschalten (falls noch nicht geschehen). Dann wieder zurück zu den Einstellungen navigieren und das Entwickler-Menü öffnen, dort "Software-Startschaltfläche" einschalten.

-
-

Anforderungen für Linux

-

Um auf Linux bauen zu können, benötigt man:

- -

Das ist zwar etwas mehr, als tatsächlich benötigt wird, aber mitunter kommt es vor, daß der Erstellungsprozeß gerade deswegen fehlschlägt, weil ein wenig Speicher fehlt.

-

Außerdem werden folgende Dienstprogramme benötigt und müssen ggf. nachinstalliert werden:

- -

Installation im Falle eines 64-Bit-Linux

-

Im folgenden werden die Kommandos aufgeführt, mit denen man die notwendigen Programmpakete für das Bauen von Firefox OS installieren kann.

-

Ubuntu 12.04 / Linux Mint 13 / Debian 6

-

Diese Kommandos in einem Terminal-Fenster ausführen:

-
sudo apt-get update
-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 zip
-

Für den Fall, daß Firefox OS für das Referenzgerät "Flame" oder Nexus 5 gebaut wird, diese Kommandos auführen:

-

sudo apt-get install libxml2-utils

-

Ein Java-Entwicklungspaket ("JDK") kann von dieser Paketquelle (ppa)  installiert werden.

-

Bitte auch die obigen Anmerkungen berücksichtigen, die die Probleme beschreiben, die auftreten, wenn man für einen Emulator baut!

-

Ubuntu 12.10 / Debian 7

-

Das folgende Kommando im Terminal-Fenster ausführen:

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

Zusätzlich zu den oben erwähnte Schwierigkeiten beim Bauen für einen Emlator tritt hier noch das Problem auf, daß standardmäßig der Compiler in der Version gcc-4.7 verwendet wird, welcher den Compiliervorgang mit folgender Fehlermeldung abbricht:

-

"KeyedVector.h:193:31: error: indexOfKey was not declared in this scope, and no declarations were found by argument-dependent lookup at the point of instantiation"

-

Um diesen Fehler zu beheben, muß man auf die ältere Version gcc-4.6 als Standard-Compiler zurückgehen, und zwar am besten unmittelbar, nachdem man die Quellen für B2G heruntergeladen hat. Der Vorgang wird in der Anleitung "Changing the default host compiler" (engl.) beschrieben.

-

Bei einer unveränderten Ubuntu-12.10-Version gibt es eine Fehlermeldung wegen nicht erfüllter Abhängigkeiten der Systembibliotheken "ia32-libs". Dies wird mit diesen Befehlen behoben:

-
sudo dpkg --add-architecture i386
-sudo apt-get update
-sudo apt-get install ia32-libs
-

Ubuntu 13.04

-

Die folgenden Kommandos sind im Terminal-Fenster auszuführen:

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

Auch hier muß von gcc-4.7 auf gcc-4.6 zurückgegangen werden, wie oben für Ubuntu 12.10 beschrieben.

-

Ubuntu 13.10

-

With Ubuntu 13.10, multi-arch packages are now the main way to support multiple architectures (e.g. 32-bit on a 64-bit install).  You must tell your Ubuntu system that you want to support 32-bit packages as well:
-  

-
sudo dpkg --add-architecture i386
-sudo apt-get update
-

Once you've completed that, then you can install the necessary packages:

-
sudo apt-get install --no-install-recommends autoconf2.13 bison bzip2 ccache curl flex gawk gcc g++ g++-multilib gcc-4.6 g++-4.6 g++-4.6-multilib git lib32ncurses5-dev lib32z1-dev zlib1g:amd64 zlib1g-dev:amd64 zlib1g:i386 zlib1g-dev:i386 libgl1-mesa-dev libx11-dev make zip libxml2-utils
-
-sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-4.6 1
-
-sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-4.8 2
-
-sudo update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-4.6 1
-
-sudo update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-4.8 2
-
-sudo update-alternatives --set gcc "/usr/bin/gcc-4.6"
-
-sudo update-alternatives --set g++ "/usr/bin/g++-4.6"
-

you can install the jdk via this ppa.

-

Ubuntu 14.04

-

Follow the instructions given for Ubuntu 13.10.

-

Fedora 19/20

-

Run the following command in Terminal:

-
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 zip perl-Digest-SHA wget
-

The project should build correctly using the default compiler shipped with Fedora but if you encounter compilation errors you might need to install GCC 4.6.x:

- -

Download the tarball then install it to /opt, with the following command on Fedora 19/20:

-
curl -O http://people.mozilla.org/~gsvelto/gcc-4.6.4-fc19.tar.xz
-sudo tar -x -a -C /opt -f gcc-4.6.4-fc19.tar.xz
-

To use GCC 4.6.x as the default host compiler you will have to set it explicitly after having retrieved the B2G sources: read Changing the default host compiler to find out how to do it.

-

Arch Linux

-

Run the following command in Terminal:

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

To install the lib32-* packages you need to have the multilib repository enabled.

-

B2G can only be compiled with gcc4.6.4, and because Arch Linux always has bleeding edge software you will need to install gcc46-multilib from AUR. Note that you will have to edit the PKGBUILD and add staticlibs to the options array, or gcc will be unable to compile B2G and give you a cannot find -lgcc error when compiling. You will also need to add the following to your .userconfig file:

-
export CC=gcc-4.6.4
-export CXX=g++-4.6.4
-

By default, Arch Linux uses Python3. You'll have to force it to use the old python2. You can do that by linking the python2 executable to python but this is discouraged and considered error-prone. This will also break python 3 if it is installed on your system. A better way is to use virtualenv/virtualenvwrapper:

-
sudo pacman -S python-virtualenvwrapper
-source /usr/bin/virtualenvwrapper.sh
-mkvirtualenv -p `which python2` firefoxos
-workon firefoxos
-

Android will complain that you need make 3.81 or make 3.82 instead of 4.0. You can download make 3.81 from AUR.  This will install the make-3.81 binary on your path, you need to create a symlink named make to a location earlier in the PATH variable for the build to use the correct version.

-
mkdir -p ~/bin
-ln -s `which make-3.81` ~/bin/make
-export PATH=~/bin:$PATH
-

Android also needs the Java6 SDK and Arch only has Java7.  Unfortunately the aur build is broken, but you can still download the Java 6 SDK and install it manually.  You will then need to put it in your path.

-
cp ~/Downloads/jdk-6u45-linux-x64.bin /opt
-su
-cd /opt
-chmod +x jdk-6u45-linux-x64.bin
-./jdk-6u45-linux-x64.bin
-exit
-ln -s /opt/jdk1.6.0_45/bin/java ~/bin/java
-

Gentoo Linux

-
Installing ccache
-

You will need to install ccache, a tool for caching partial builds.

-
# emerge -av ccache
-

Because ccache is known to frequently cause support issues, Gentoo encourages you to use it explicitly and sparingly.

-

To enable the required use of ccache, on the subsequent step of this guide where the ./build.sh script is called, Gentoo users should instead run the command with an explicitly extended path, ie.

-
PATH=/usr/lib64/ccache/bin:$PATH ./build.sh
-
Generating Partition Images
-

If you are building B2G for actual physical hardware, then you may at some point also wish to generate some partition images for upload to your device. (For example, to restore backed up files to the device via the fastboot utility)

-

The filesystem image format used in this case is YAFFS2 (Yet Another Filesystem 2). Gentoo has support for the very latest (ie. git HEAD) yaffs2-utils userland package in portage. (Note: You will also need kernel patches if you want to mount YAFFS2 images, but this is not really required since you can deconstruct and rebuild them instead.)

-
# emerge --autounmask-write yaffs2-utils; etc-update; emerge -av yaffs2-utils
-

In order to generate such an image, simply change to the parent directory of the partition filesystem tree you wish to package, and issue a command like this:

-
mkyaffs2image system/ system.img
-

 

-

Anforderungen für Mac OS X

-

Um Firefox OS unter Mac OS X zu bauen, benötigt man etwas Vorarbeit, die unten detailiert beschrieben ist.  Außerdem werden typische Irrtümer und Fehler und ihre Lösungen erläutert.

-
-

Anmerkung: Das Bauen (und Konfigurieren der Quellen) von B2G für das Gerät Keon funktioniert nicht auf einem Mac OS-Rechner. Stattdessen muß man unter Linux bauen, ggf. auf demselben Rechner, auf dem auch Mac OS läuft.

-
-

Passende XCode-Versionen für Mac OS 10.9

-

XCode 4.2 oder älter sind nicht kompatibel mit OS X 10.9 ("Mavericks") und fallen daher ganz aus. Ansonsten gilt, daß man den ICS-Emulator nicht mit OS X 10.9 oder neuer bauen kann, und für das Gerät "flatfish" scheitert das Bauen mit allen Entwicklungsumgebungen der Versionen XCode 5.x.

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
- Version compatibility of OS X 10.9.x
 emulator (ICS)flatfish/vixen (JB-4.2)emulator-jb (JB-4.3)emulator-kk (KitKat-4.4)
XCode 4.3.3XXXX
XCode 4.4.1XO[1]OO
XCode 4.5.2XO[1]OO
XCode 4.6.3XO[1]OO
XCode 5.0.2XXOO
XCode 5.1.1XXOO
XCode 6.0.1XXXX
XCode 6.1beta2XXXX
-
    -
  1. You must have environment variable BUILD_MAC_SDK_EXPERIMENTAL=1 exported to build flatfish/vixen.
    2. -
-

Install XCode Command Line Utilities

-

You need to install Xcode's Command Line Utilities. You can download just the Command Line Utilities from Apple's developer downloads page for your particular version of OS X, however if you would like the entire Xcode suite of applications, you can install Xcode through the Mac App Store. 

-

Xcode 4.3.1 (OS X 10.7 "Lion") and other newer versions such as 4.4.1+ (that is, Mac OS X10.8 "Mountain Lion"), won't necessarily include the required Command Line Utilities. When you install Xcode, make sure to go into Preferences, then the Downloads panel, and install the Command Line Utilities. In addition, make sure you have at least 20 GB of free disk space.

-

Screenshot of Xcode Downloads Command Line Tools

-
- Note: The Firefox OS emulator requires a Core 2 Duo processor or later; that is, a system that is compatible with Mac OS X 10.7 "Lion." You do not actually have to be running Lion, you just have to be compatible with it. You can, however, build any Firefox OS build on many older Macs.
-

Run Firefox OS Mac Bootstrap

-

Next, open a terminal and run the following command:

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

This will pull and run a bootstrap script that makes sure you have all the prerequisites met to build the emulator. It will also prompt you for permission to install anything you're missing, and provide warnings and suggested fixes to problems. The script will check for and install the following items:

- -

Xcode wrangling

-

If you have already upgraded to Xcode 4.4+ and get the message that Xcode is outdated, check the Xcode path with:

-
xcode-select -print-path
-

If it still points to /Developer you can update the path with:

-
sudo xcode-select -switch /Applications/Xcode.app
-

Making the Mac OS X 10.6 SDK available

-

You also need to have the Mac OS X 10.6 SDK available. The SDK needs to be available at

-
/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/
-

If it cannot be found there you will need to extract and copy it from Xcode 4.3. To do this:

-
    -
  1. Download the XCode 4.3 .dmg file from the Apple Developer portal (you'll need an Apple Developer account).
    2. -
  2. Download the utility Pacifist and use it to extract the 10.6 SDK from the XCode 4.3 .dmg file. Click on the "Extract Package" button, find the SDK by searching for 10.6 in the search box, then Ctrl + click on the MacOSX10.6.sdk directory and Extract it to a suitable location.
    3. -
  3. Add a symlink from the 10.6 SDK location to the /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/ directory. For example, if you put the 10.6 SDK on your desktop, the comment would be
    4. -
-
ln -s /Users/<yourusername>/Desktop/MacOSX10.6.sdk /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/
-
-

Note: We can drop the 10.6 SDK requirement after bug 784227 has been fixed, and our version of platform_build has been updated.

-
-

Be aware of Mac file system case sensitivity

-

By default, Mac OS X ships with a case-insensitive file system.  This is problematic because the Linux kernel has a number of files with the same name, but different case.  For example, see the header files xt_CONNMARK.h and xt_connmark.h.  This results in a number of files appearing to be modified in /kernel after a fresh ./config.sh.

-

In many cases you can run the build just fine; for some platforms, however, you may encounter the following error:

-
ERROR: You have uncommited changes in kernel
-You may force overwriting these changes
-with |source build/envsetup.sh force|
-
-ERROR: Patching of kernel/ failed.
-

Please see bug 867259 for more discussion and possible fixes for this problem.

-

Alternatively, it will always be safest to build on a case sensitive file system.  The easiest way to do this is to create a separate, mountable disk image with case-sensitivity enabled.  You can do this using Apple's Disk Utility application or from the command line:

-
hdiutil create -volname 'firefoxos' -type SPARSE -fs 'Case-sensitive Journaled HFS+' -size 40g ~/firefoxos.sparseimage
-

Mount the drive with:

-
open ~/firefoxos.sparseimage
-

Change into the mounted drive with:

-
cd /Volumes/firefoxos/
-

You can then check out the code and compile from this location without worrying about case-sensitivity problems.

-

Mountain Lion homebrew gotcha

-
-
- If you are on Mountain Lion and you receive an error during the installation of the dependencies via homebrew, such as:
-
-
- 
clang: error: unable to execute command: Segmentation fault: 11
- ... try reinstalling the dependency manually adding the --use-gcc flag, for example: - 
brew install mpfr --use-gcc
-
-

Follow Samsung Galaxy S2 extra steps

-

If you plan to build for the Samsung Galaxy S2, you will also need to install heimdall. See {{ anch("Installing heimdall") }} for details. This is not done for you by the bootstrap script!

-
- Note: If you have installed the Samsung Kies tool, which is used to manage the contents of many Samsung phones, you will have to remove it before you can flash Firefox OS onto your device. You can use the standard application removal process on Windows; on Mac, the Kies install disk image has a utility to fully remove Kies from your system. Flashing will not work if you have Kies installed. If you forget to remove Kies, the build system will detect it and remind you to uninstall it. Note also that the uninstall tool does not correctly remove the folder ~/Library/Application Support/.FUS, and leaves a reference to a utility there in your user startup items list. You will want to remove these manually.
-

Fix libmpc dependency if broken

-

gcc 4.6 was built with libmpc 0.9; if you then use homebrew to update packages, libmpc gets updated to version 1.0, but homebrew doesn't rebuild gcc 4.6 after the library version changes. So you need to create a symlink to make things work again, like this:

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

Optional: Install HAX

-

Intel provides a special driver that lets the B2G emulator run its code natively on your Mac instead of being emulated, when you're using the x86 emulator. If you wish to use this, you can download and install it. It's not required, but it can improve emulation performance and stability.  

-

Before you install HAX you will need to install the Android SDK.

-

Install adb

-

The build process needs to pull binary blobs from the Android installation on the phone before building B2G (unless you're building the emulator, of course).  For this, you will need adb, the Android Debug Bridge.

-

You can download and install adb as part of the Android SDK package, for Mac, Linux or Windows - visit the Get the Android SDK page.

-

Newer Linux distributions have adb already in their repositories. For Ubuntu 12.10 and later, run the following command:

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

Or for Fedora 18/19:

-
sudo yum install android-tools
-

If your distribution does not have packages for adb available (i.e. Ubuntu 12.04 or Fedora 17), you'll need to install the Android SDK starter package for your platform (you'll want the ADT Bundle, not the SDK Tools Only option). Then run their package manager, $SDK_HOME/tools/android, and use the GUI to install "Android SDK Platform-tools".

-

Find out where adb is installed (usually in usr/bin, possibly additionally inside adt/platform-tools, depending on how you installed it). Be sure to add this directory to your PATH. This can be done by adding the line

-
PATH=$SDK_HOME:$PATH
-

replacing $SDK_HOME with the location of the android sdk, to your ~/.bashrc or equivalent.

-

Install heimdall

-

Heimdall is a utility for flashing the Samsung Galaxy S2. It's used by the Boot to Gecko flash utility to replace the contents of the phone with Firefox OS, as well as to flash updated versions of B2G and Gaia onto the device. You'll need it if you want to install Firefox OS on a Galaxy S2; it is not needed for any other device. For other devices, we build and use the fastboot utility instead.

-
- Note: Again, it's important to note that this is only required for installing Firefox OS on the Samsung Galaxy S2.
-

There are two ways to install heimdall:

- -

Configure ccache

-

The B2G build process uses ccache. The default cache size for ccache is 1GB, but the B2G build easily saturates this; around 3GB is recommended. You can configure your cache by running the following command inside terminal:

-
$ ccache --max-size 3GB
-

For Linux: configure the udev rule for your phone

-
-

Note: This section is specific to Linux; Mac OSX has the necessary device permissions set up already.

-
-

Next, you need to confingure the udev rule for your phone,

-

You can get the USB vendor ID by running lsusb with your phone plugged in, but typically it's Google 18d1, Samsung 04e8, ZTE 19d2, Geeksphone/Qualcomm 05c6. Add this line in your /etc/udev/rules.d/android.rules file (replacing XXXX with the ID for your device):

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

Take ZTE for example, the content in android.rules will be

-
SUBSYSTEM=="usb", ATTR{idVendor}=="19d2", MODE="0666", GROUP="plugdev"
-
-

If the file doesn't exist, create it. The rules.d directory is usually read only by default, so you may have to use chmod to make the directory writeable, or the file, or both.

-
-

Once you've saved the file, and closed it,  make the file readable:

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

Now that the udev rules have been updated, restart the udev daemon. For ubuntu:

-
sudo service udev restart
-

Finally, unplug and the USB cable but don't replug it in because we need to enable remote debugging on the phone first.

-

Enable remote debugging

-

Before you plug your phone back into your USB port, put it USB developer mode. This allows you to debug and flash the phone. To enable developer mode, on your phone select Settings app -> Device information -> More Information -> Developer -> Remote debugging (this was called Developer mode on older versions.) Once the option is checked, remote debugging is enabled, and you are ready to go.

-

At this point, connect your phone to your computer via a USB cable (if you created the udev rule before, this will trigger udev to detect the phone and create the device node with the right permissions). Now you can check if you can list your device via the adb devices command. If everything has worked ok, you should see an output similar to this (the following is for a Geeksphone Keon):

-
$ adb devices
-List of devices attached
-full_keon       device
-

If the device did not list as expect, check the file name and the script are all correct (see previous section), then restart the computer and retype the command again. Note also that if your device uses fastboot, the bootloader may identify itself with a different vendor ID than the one you see when the device boots normally.

-

Backup the phone system partition

-
-

Note: You have to do this before you build your device if you do not have existing system backup. Because some libraries will be referenced in build time. These library might be proprietary so we can't provide in our code base.

-
-

It is recommended to back up the entire Android system partition on your phone.

-

You can use this copy of the binary blobs for Android in case you later delete your B2G tree. To do this, run:

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

 Depending on the phone, you may also need to pull the /data and/or /vendor directories:

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

If the pull commands fail with "insufficient permission" message, try the following:

- -

On to the next step

-
At this point, you should be ready to fetch the Firefox OS code!
diff --git a/files/de/archive/b2g_os/firefox_os_faq/index.html b/files/de/archive/b2g_os/firefox_os_faq/index.html deleted file mode 100644 index 0cc309dbfe..0000000000 --- a/files/de/archive/b2g_os/firefox_os_faq/index.html +++ /dev/null @@ -1,41 +0,0 @@ ---- -title: Firefox OS FAQ DE -slug: Archive/B2G_OS/Firefox_OS_FAQ -translation_of: Archive/B2G_OS/Introduction ---- -
-
- Wie bekomme ich ein Developer Preview Telefon?
-
- Weitere Informationen werden bald auf der Geeksphone Website zur Verfügung stehen.
-
- Wenn ich kein Entwickler-Telefon kaufen möchte, kann ich trotzdem eine App für Firefox OS entwickeln?
-
- Selbstverständlich! Sie können die App über Android testen, oder auf dem Computer mit dem (using Marketplace for Firefox)  Firefox OS simulator.
-
- Wann wird das "fertige" Telefon verfügbar sein?
-
- Wir werden mit mehreren Partnern gemeinsam das Telefon auf den Markt bringen, jedoch besprechen wir uns diesbezüglich zu einem späteren Zeitpunkt nochmal.
-
- Wo kann ich mir Firefox OS auf mein Handy laden?
-
- https://developer.mozilla.org/en-US/docs/Mozilla/Firefox_OS/Building_and_installing_Firefox_OS
-
- Wie kann ich meine Firefox OS App testen?
-
- Auf Android oder über unseren OS Simulator.
-
- Was ist Firefox OS?
-
- Es ist ein neues Handy-Betriebssystem, dass komplett auf offenen  Web-Standards basieren wird. Es ermöglicht für jede Geräte-Funktion (Telefonie, Messaging, Browsen usw.) eine eigenenständige auf dem HTML5-Standard basierende Applikation zu entwickeln, die grundsätzlich (theoretisch) auf jedem anderen Gerät (nur verfügbar in systemeigene Anwendungen) funktionieren würde.
-
- Wie ist die Liste der vollständigen Web APIs; Werden diese standardisiert werden?
-
- Eine große Anzahl von WebAPIs wird in die erste Implementierung des Firefox-OS aufgenommen werden. Eine vollständige Liste finden Sie auf
-
- https://wiki.mozilla.orghttps://wiki.mozilla.org/WebAPI#APIs.
-
- Sind die Web-APIs für den plattformübergreifenden Einsatz standardisiert?
-
- Ja, die APIs sind das Ergebnis von Arbeiten mit mehreren Partnern, die bereits auch für andere Plattformen entwickelt haben. Das Umsetzen stellt in Bezug auf die unterschiedlichen Hardware-Anforderungen der Benutzer ein Problem dar, das nicht nur Mozilla beschäftigt. Unsere Anwendungen sind ein guter Anhalts&Ausgangspunkt für weitere zukünftige Plattformen und Entwicklungen.
-
diff --git a/files/de/archive/b2g_os/gaia/gaia_apps/index.html b/files/de/archive/b2g_os/gaia/gaia_apps/index.html deleted file mode 100644 index e4f64963a0..0000000000 --- a/files/de/archive/b2g_os/gaia/gaia_apps/index.html +++ /dev/null @@ -1,86 +0,0 @@ ---- -title: Gaia apps -slug: Archive/B2G_OS/Gaia/Gaia_apps -translation_of: Archive/B2G_OS/Platform/Gaia/Gaia_apps ---- -
-

Gaia is the front-end of Firefox OS, which contains system administration functionality and the built-in suite of apps shipped with Firefox OS devices. All the Gaia source code — even the system, and keyboard IMEs — is fully implemented with HTML5 (HTML + CSS + JavaScript) & Open WebAPIs. This set of documents contains information on how each of the default apps available in the Gaia family works.

-
- -

Gaia functionality categories

- -

The different apps inside Gaia can be roughly categorized into the groups listed below.

- -
-

Note: Many of the pages linked to for more explanation of how the individual apps work are README pages inside the Gaia Github repo. This is because many of the apps are on rapid development cycles and therefore subject to rapid (often daily) change, so it would make little sense to try to keep MDN pages updated with these changes. The engineer-maintained README pages are currently the most accurate source of information.

-
- -

Platform

- -

Including the System, Settings, Lockscreen, build scripts, and Bluetooth apps.

- -

- -

Platform apps: further explanation

- -
-
System
-
The System app is the first web app loaded by Gecko during the Firefox OS bootup procedure, and it handles numerous responsibilities that are required generally for the running of the system, and are therefore not scoped per individual web app.
-
Browser
-
The Browser app (which is now part of System) provides browser-like functionality where it is needed — including page navigation, search and bookmarks.
-
Window Management
-
Firefox OS's window management functionality — including app life cycle and interaction, notifications, animations and much more — is handled by a specific part of the System app. This article looks at Firefox OS Window Management in detail.
-
Settings
-
The Settings app allows Firefox OS users to configure device settings, and responds to incoming activities (Web activities with a name of configure), which allows other apps to jump to different panels inside the Settings app to handle configuration as required (for example showing the wifi settings panel if no data connection is available.)
-
- -

Communication

- -

Including the Dialer, Contact, SMS apps and FTU apps.

- -

- -

Communication apps: further explanation

- -

TBD

- -

Productivity

- -

Including the Email, Calendar, and Clock apps.

- -

- -

Productivity apps: further explanation

- -
-
Calendar
-
The Firefox OS built-in calendar app.
-
Clock
-
Firefox OS's default Clock app, which includes alarm, timer and stopwatch functionality.
-
Email
-
The Gaia e-mail app.
-
- -

Media

- -

Including the Camera, Gallery, Music, and Video apps, and some media related functions such as forward lock DRM and wallpapers.

- -

- -

Media apps: further explanation

- -
-
Video
-
Video is a simple video player app that will play videos present on your Firefox OS device's storage media.
-
Camera
-
Camera allows Firefox OS users to capture and manage videos and photos from the device camera(s), and responding the Web activities of type pick from other apps that want to grab media using Camera's functionality.
-
- -

Other Gaia features

- -

Besides these functions, there are several other major features such as browser, homescreen, marketplace, test framework, PDF viewer, and app manager, which are developed closely alongside Gaia.

- -
-
pdf.js
-
pdf.js is an HTML5-based PDF viewer, used inside Gaia for viewing PDFs. Note that the codebase for pdf.js is maintained in a separate repo, outside Gaia.
-
diff --git a/files/de/archive/b2g_os/gaia/hacking/index.html b/files/de/archive/b2g_os/gaia/hacking/index.html deleted file mode 100644 index 64b9be9f79..0000000000 --- a/files/de/archive/b2g_os/gaia/hacking/index.html +++ /dev/null @@ -1,181 +0,0 @@ ---- -title: Hacking Gaia -slug: Archive/B2G_OS/Gaia/Hacking -translation_of: Firefox_OS/Developing_Gaia ---- -

Gaia ist die Sammlung von Webapps, die das Front-End des Firefox OS (Codename Boot to Gecko) bilden.

-

Alles was Sie auf dem Bildschirm von Firefox OS sehen, inklusive dem Homescreen, wurde nur mit Hilfe von freien Web-Technologien erstellt, 

-

 

-

Quellcode besorgen

-

To get the source code for Gaia, fork us on GitHub and then clone your fork using git.

-
$ git clone https://github.com/username/gaia.git
-

Gaia starten

-

Sie können Gaia entweder auf Ihrem Desktop nutzen oder mit einem kompatiblem mobilen Gerät.

-

 

-

B2G Desktop

-

B2G Desktop is a desktop build of the app runtime used on Firefox OS devices which you can use to run Gaia on your desktop computer.

-

You can download a nightly build of B2G Desktop from here. Currently we recommend installing the latest beta build for your platform. There are builds for Linux (32 bit and 64 bit), OS X and Windows.

-

Nightly builds come packaged with a recent version of gaia. Once you've downloaded the archive, all your need to do is extract it to a folder and run the b2g binary from the extracted folder.

-

Note: 64 bit Linux builds do not currently work on some distributions, this is bug 812484. If you have problems try a 32-bit build instead.

-
$ cd b2g
-$ ./b2g
-

To run B2G with your own version of Gaia for development purposes you first need build a profile from your clone:

-
$ cd /path/to/gaia
-$ DEBUG=1 make
-

This will generate a directory in your gaia directory called "profile". 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.

-

Note: Debug builds are currently broken on B2G Desktop, so until bug 816957 is fixed you need to run "make" without the "DEBUG=1" part, then re-run make every time you make a change to Gaia.

-

 

-

You can then run B2G Desktop with your generated profile like so:

-
$ /path/to/b2g/b2g-bin -profile /path/to/gaia/profile
-

If you want to you can build your own B2G Desktop from source.

-

B2G Device

-

 

-

If you have a compatible mobile device you can also run Gaia by flashing it with Firefox OS. Please see documentation here.

-

There is also documentation here about testing changes on your device.

-

Unit Tests

-

 

-

See here for information about writing and running unit tests for Gaia.

-

Filing Bugs

-

 

-

Bugs are filed on Bugzilla under Boot2Gecko > Gaia.

-

File a new bug under the Gaia component (or one of the sub-components) here.

-

Contributing Code

-

 

-

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:

- -

Coding Style

-

 

- - - - - - - - -

Bad:

-
if (expression) doSomething();
-
-

Correct:

-
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
-

 

-

Submitting a Patch

-

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 "commit message including bug number"
-

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 listed here.

-

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 and add "r=reviewername" to the end of the commit message.

-

Contacting the Team

-

 

- -

Tips

-

Linux B2G Desktop support

-

 

-

The homescreen is empty

-

Currently, under Linux, OOP frame aren't rendered properly. The homescreen isn't actually rendered here...

-

If you just want to happily hack on pure UI (css and JS) you can safely run with OOP disabled and avoid those issues. Change the line in build/settings.py

-
 "debug.oop.disabled": False,
-
-

to

-
 "debug.oop.disabled": True,
-
-

To the profile/user.js in your gaia directory.

-

Port Forwarding

-

 

-

To forward the socket on the phone to the desktop (for desktop development), you first need to get rilproxy to expose it as such, rather than exposing it to Gecko. In the gaia directory:

-
 $ make forward
-
-

This runs the commands:

-
$ adb shell touch /data/local/rilproxyd
-$ adb shell killall rilproxy
-$ adb forward tcp:6200 localreserved:rilproxyd
-
-

The file located at /data/local/rilproxyd will be deleted once the rilproxy daemon will start again. As a consequence you have to do this manipulation every time your device restarts.

-

Restarting B2G on a device from the desktop

-

 

-
adb shell killall b2g
-
-

B2G Desktop JavaScript Console

-

 

-

You can run B2G Desktop with the JavaScript console by using the -jsconsole flag

-
$ /path/to/b2g-bin -jsconsole
-
-

Launching an app directly

-

 

-

A "--runapp" option has been added to the B2G Desktop command-line to automatically start an application. The system app is loaded and everything happens like normal; this is not like the old trick where we loaded your app instead of the system app.

-

"--runapp" takes an argument that it normalizes by lower-casing and removing dashes and spaces, and then checks the argument against the similarly normalized app names from app manifests. For example, the name of the e-mail app is currently "E-Mail", but "--runapp email" will run it. Partial matching is not supported right now, but you can enhance b2g/chrome/content/runapp.js if your app name is unwieldy.

-

If you invoke "--runapp" without an argument (or an empty argument), the command will print out a list of all the apps it knows about as well as a brief usage message.

-

One important note is that this command disables the lock-screen as part of its magic and does not re-enable it. The assumption is that you won't use this command on a profile where you are testing the lock screen, or will turn it back on manually. Feel free to enhance the command to behave better if this is a problem for you.

-

In summary:

-
./b2g -profile /path/to/your/gaia/profile --runapp email
-
-

runs the e-mail app.

-

reset-gaia and install-gaia make targets

-

 

-

The reset-gaia and install-gaia make targets can be used interchangeably. reset-gaia will purge all the existing profiles, database before push Gaia from your working directory (new setting database will also be initialized); install-gaia will just push updates of Gaia.

-

Blank screen when B2G Desktop starts

-

 

-

When you start b2g using b2g -profile $GAIA/profile a blank screen shows up and you see an error Cannot reach app://system.gaiamobile.org. To fix this there are a couple of things you can check

- -

Diagnosing OOM problems

-

 

-

From Cjones:

-

Another way to diagnose possible OOMs is to open a terminal and run

-

$ watch -n 1 'adb shell b2g-procrank'

-

If you see the "USS" of one of the app processes go up near 100MB and then that process disappear from the process list (accompanied by some sort of visual crash in gaia), then you've almost certainly seen an OOM kill.

-

 

-

 

-

 

-

 

-

 

-

 

diff --git a/files/de/archive/b2g_os/gaia/index.html b/files/de/archive/b2g_os/gaia/index.html deleted file mode 100644 index 1405dd58c9..0000000000 --- a/files/de/archive/b2g_os/gaia/index.html +++ /dev/null @@ -1,56 +0,0 @@ ---- -title: Gaia -slug: Archive/B2G_OS/Gaia -tags: - - B2G - - Gaia - - Mobile -translation_of: Archive/B2G_OS/Platform/Gaia ---- -

Gaia ist die Benutzeroberfläche von Firefox OS. Alles was auf dem Bildschirm nach dem Start von Firefox OS erscheint, wird von Gaia gemalt. Einschließlich des Sperrbildschirmes, Homescreen, Dialer und anderen Programmen. Gaia ist komplett in HTML, CSS, und JavaScript geschrieben. Seine einzige Schnittstelle zu dem zugrunde liegenden Betriebssystem und Hardware wird über Standart Web APIs ermöglicht, welche von Gecko implementiert werden.

-

Wegen diesem Aufbaus kann Gaia nicht nur auf Firefox OS Geräten, sondern auch auf anderen Betriebssystemen und Webbrowsern (wenn auch, je nach Fähigkeiten des Browsers, möglicherweise Eingeschränkt) betrieben werden.

-

Anwendungen von Drittanbietern, welchen neben Gaia installiert wurden, können von Gaia gestartet werden.

- - - - - - - -
-

Dokumentationen über Gaia

-
-
- Einführungen zu Gaia
-
- Gaia ist die Benutzeroberfläche für Firefox OS Geräte; Es ist eine Internetapplikation welche auf der Firefox OS Applikationsumgebung läuft. Dieses Handbuch bietete eine Einführung zu Gaia auf einem hohen Niveau.
-
- Gaia hacking guide
-
- Ein Leitfaden für Hacking und Modifizierung der Gaia-Schnittstelle.
-
-

View All...

- 		-

Hilfe von der Community

-

Wenn du mit Gaia, oder an Gaia Anwendungen arbeitest, könnten dir diese Community-Ressourcen helfen!

-
    -
  • Besuche das Boot to Gecko Projekt Forum: {{ DiscussionList("dev-gaia", "mozilla.dev.gaia") }}
    • -
-
    -
  • Stelle deine Fragen im Mozilla's Gaia IRC channel: #gaia
    • -
-

Don't forget about the netiquette...

-
- - -

Ressourcen

- -
-

 

diff --git a/files/de/archive/b2g_os/gaia/introduction_to_gaia/index.html b/files/de/archive/b2g_os/gaia/introduction_to_gaia/index.html deleted file mode 100644 index 2b121e8274..0000000000 --- a/files/de/archive/b2g_os/gaia/introduction_to_gaia/index.html +++ /dev/null @@ -1,35 +0,0 @@ ---- -title: Introduction to Gaia -slug: Archive/B2G_OS/Gaia/Introduction_to_Gaia -translation_of: Archive/B2G_OS/Platform/Gaia/Introduction_to_Gaia ---- -
-

Gaia is the user interface for Boot to Gecko (B2G); it's a set of Web applications that runs locally on a B2G device, emulator, desktop build, or Firefox build. All you need to know in order to add apps or make changes to Gaia are Web technologies like JavaScript, HTML, and CSS.

-
- -

The Gaia lock screen

- -

The lock screen shows the network carrier, current time and date, and a slidebar allowing the user to unlock the phone or go straight to the camera to take a picture. If the user has got a passcode lock set, the lock screen will also show a passcode entry interface.

- -

- -

Note that on some devices the passcode is enabled by default; in these cases the default PIN to unlock the device is "0000". This most likely will change over time as this feature is fleshed out.

- -

The default Gaia interface

- -

The default interface in Gaia, as seen here, is similar to what you see on most typical smartphones.

- -

- -

This image is obviously of a prerelease version of the operating system, with placeholder icons (and some test applications). The status bar at the top indicates the network on which the phone is operating (or "No SIM card" for a device without any network), the network strength, WiFi signal strength, battery level, and current time.

- -

The middle area of the display shows icons for the applications; swiping left and right pages through screens of icons. You can find more about the default suite of apps that comes with Gaia on our Gaia apps page.

- -

At the bottom of the screen is a dock with room for up to seven of your most commonly used applications. You can drag and drop apps to the dock from the middle area.

- -

See also

- - diff --git a/files/de/archive/b2g_os/gaia_entwickeln/build_system_primer/index.html b/files/de/archive/b2g_os/gaia_entwickeln/build_system_primer/index.html deleted file mode 100644 index 8f6f0c7379..0000000000 --- a/files/de/archive/b2g_os/gaia_entwickeln/build_system_primer/index.html +++ /dev/null @@ -1,190 +0,0 @@ ---- -title: 'Gaia Build System: Grundlagen' -slug: Archive/B2G_OS/Gaia_Entwickeln/Build_System_Primer -tags: - - Building - - Firefox OS - - Gaia Grundlagen - - Gaia build -translation_of: Archive/B2G_OS/Developing_Gaia/Build_System_Primer ---- -
-

Dieser Artikel beschreibt die grundlegende Funktionsweise des Gaia Build Systems inklusive make-Datei, Build-Prozess, Umgebungsvariablen und Anpassungsmöglichkeiten.

-
- -

Die wichtigen Schritte eines Builds werden größtenteils von den im Gaia-Unterverzeichnis build/ liegenden Skripten erledigt. Augerufen werden diese mit make, node.js und XPCShell (auch bekannt als JS Shell), einer Laufzeitumgebung von XULRunner. Das Gaia Build System enthält viele Werkzeuge zum Installieren, Testen und Lokalisieren von Apps und um diese als Paket auf ein Gerät zu bringen. Zudem können Entwickler das Gaia-Paket anpassen, z.B. können Hintergrundbilder, Klingeltöne, Apps und Einstellungen geändert werden.

- -
-

Hinweis: XPCShell ist ähnlich wie node.js, bietet aber zusätzlich die Möglichkeit zum Ausführen von Mozilla-spezifischen javascripts. Zudem können Gaia-Skripte mit Hilfe von XPCShell in einer Firefox Erweiterung laufen.

-
- -

Die make-Datei

- -

Die make-Datei enthält eine Menge nützlicher Funktionen. Dieses Kapitel bechreibt die nützlichsten davon.

- -

install-gaia

- -

Gestartet mit dieser Option installiert make alle Apps auf Deinem Gerät. Wenn Du nur eine bestimmte App installieren möchtest, dann starte make wie folgt mit der APP Option:

- -
APP=calendar make install-gaia
- -

Dieses Verzeichnis muss im Gaia-Verzeichnisbaum existieren (z.B. apps).

- -

reset-gaia

- -

Funktioniert genauso wie install-gaia mit dem Unterschied, dass zuerst alle Apps deinstalliert und anschließend wieder mit den Standard-Zugriffsrechten installiert werden. Die Apps befinden sich in /data/local wie bei den Entwickler-Builds. Test- und Debugging-Apps werden hier ebenfalls installiert.

- -
-

Vorsicht: Wenn beim Aufruf von make mit der Option reset-gaia die Umgebungsvariable APP gesetzt ist, dann wird dies Dein Gerät in einen unbrauchbaren Zustand versetzen (das kann allerdings behoben werden durch Aufruf von make mit der Option reset-gaia ohne die APP Umgebungsvariable). Also mach das bitte nicht.

-
- -

production

- -

Genauso wie reset-gaia, aber der Quellcode wird optimiert. Das ermöglicht grundsätzlich die Emulation von User Builds (stabilen Builds). Mit dieser Option werden dieselben Apps installiert wie bei User Builds.

- -
-

Vorsicht: Wenn beim Aufruf von make mit der Option production die Umgebungsvariable APP gesetzt ist, dann wird dies Dein Gerät in einen unbrauchbaren Zustand versetzen (das kann allerdings behoben werden durch Aufruf von make mit der Option production ohne die APP Umgebungsvariable). Also mach das bitte nicht.

-
- -

reference workloads

- -

Diese Option installiert unterschiedlich große Pakete für Laufzeittests auf dem Gerät, um eventuell auftretende Geschwindigkeits- und Skalierungsprobleme debuggen und beheben zu können. Diese Option akzeptiert die APP Umgebungsvariable und auch die APPS Umgebungsvariable mit mehreren durch Leerzeichen voneinander getrennten App-Namen, z.B.:

- -
APP=sms make reference-workload-light
-APPS="sms communications/contacts" make reference-workload-heavy
-
- -
-

Hinweis: Weitere Informationen findest Du auf Hacking Gaia: Reference workloads.

-
- -

Umgebungsvariablen

- -

Mit einigen Umgebungsvariablen kannst Du den Build und die Installation auf dem Gerät steuern, z.B.:

- -

P=1

- -

Das ermöglicht parallele Build-Erzeugungen auf Multikern CPU Architekturen und verkürzt die Laufzeit von Build-Erzeugungen, der Standardwert ist 0.

- -
-

Vorsicht: Parallele Build-Erzeugung ist noch in der Test-Phase und somit vielleicht nicht stabil.

-
- -

GAIA_OPTIMIZE=1

- -

Hiermit wird eine Optimierung der JavaScript Dateien angestossen. Diese Umgebungsvariable wird automatisch beim Ausführen von make production gesetzt. Die Variable kann für install-gaia und reset-gaia verwendet werden.

- -

PRODUCTION=1

- -

Das ist im Grunde ein Alias für make production.

- -

DEBUG=1

- -

Mit dieser Umgebungsvariablen wird eine Debugging-Umgebung aufgebaut, die Du für Gaia unit tests oder für die Entwicklung eigener Apps in Firefox OS nutzen kannst. Du musst ein bereits bestehendes Debugging-Profilverzeichnis löschen, bevor Du ein neues generieren kannst.

- -

DEVICE_DEBUG=1

- -

Deaktiviert die Bildschirmsperre auf dem Gerät.

- -

GAIA_DEVICE_TYPE=phone

- -

Diese Umgebungsvariable ermöglicht eine individuelle Installation mit mehreren 'app.list' Dateien. Alle 'app.list' Dateien müssen in /build/config/$(GAIA_DEVICE_TYPE)/  Verzeichnissen liegen.

- -

Der Standardwert von GAIA_DEVICE_TYPE ist phone.

- -
-

Hinweis: Weitere Details und optionen findest Du auf Hacking Gaia make options.

-
- -

Build-Prozess

- -

Das Ablaufdiagramm, wie ein Build für Gaia erzeugt wird:

- -

- -

pre-app.js, app.js & post-app.js werden von make gestartet und die meisten Build-Schritte werden in den xpcshell Skripten ausgeführt, make ermittelt das Betriebssystem und lädt den b2g-desktop herunter. Wir planen, mehr Build-Schritte von make in die xpcshell Skripte zu migrieren.

- -

Vielleicht fragst Du Dich, warum wir pre-app, app and post-app nutzen. Das liegt daran, dass wir immer mehr Abhängigkeiten von make in die xpcshell Skripte verlagern. Deshalb entwickelten wir pre-app.js und post-app.js basierend auf  bug 1021051, um den Großteil der Abhängigkeiten in die xpcshell Skripte zu verlagern. Am Ende werden dann app.js, pre-app.js und post-app.js auf Basis von  bug 1053703 migriert.

- -

Wir haben drei Typen von Verzeichnissen in einem Gaia Build System:

- -
    -
  1. Source-Verzeichnisse: apps, dev_apps, gemeinsame Verzeichnisse
    2. -
  2. Stage-Verzeichnis: build_stage (stage = Plattform)
    3. -
  3. Profil-Verzeichnisse: profile, profile-debug oder profile-test
    4. -
- -

Unser Ziel ist es, keine Dateien in die Source-Verzeichnisse hinein zu generieren. Leider haben wir immer noch ein paar Stellen, an denen Dateien in die Source-Verzeichnisse generiert werden. Wir planen, diese Probleme zu beheben. Die folgende Tabelle listet auf, von welchen Modulen Dateien ins Source-, ins Stage- und in die Profil-Verzeichnisse generiert werden.

- -

- -

Der Build-Prozess führt bei Aufruf von make im Gaia-Verzeichnis die folgenden Schritte in der angegebenen Reihenfolge aus:

- -
    -
  1. b2g_sdk: b2g-desktop startet die xpcshell Skripte in GAIA_DIR/build/.
    2. -
  2. svoperapps: Download der Apps und Generieren der Konfigurations-Dateien der App-Installation pro SIM-Karten-Anbieter und Land.
    3. -
  3. webapp-manifests: Generieren der Metadaten der Web-Apps für den Build.
    4. -
  4. keyboard-layouts: Generieren der Layout-Konfiguration der Standard-Tastatur.
    5. -
  5. settings.json (settings.js): Dieses JavaScript generiert die Standard-Einstellungen für Firefox OS, die von Gaia gelesen werden.
    6. -
  6. webapp-shared: Kopieren der von den Apps benötigten Dateien vom gemeinsamen Source-Verzeichnis ins Stage-Verzeichnis.
    7. -
  7. preferences: Generiert die Standard-Umgebung für Firefox OS; generiert die Datei user.js und kopiert diese auf das Gerät, wo sie von Gecko gelesen wird. Bitte beachte, dass die Standard-Umgebung abhängig von den Umgebungsvariablen (wie z.B. DEBUG=1) variieren kann.
    8. -
  8. app.js: make-Dateien in den jeweiligen app Verzeichnissen: Sie werden ausgeführt, wenn sie existieren. Für jede App ohne eigene make-Datei kopiert die Gaia make-Datei das App-Verzeichnis ins Stage-Verzeichnis build_stage und führt [app-directory]/build/build.js aus, falls vorhanden. Siehe {{ anch("Build script for apps") }} für weitere Details.
    9. -
  9. test-agent-bootstrap & test-agent-config: Einrichten der zwei make Regeln test-agent-config & test-agent-bootstrap-apps, welche für den Aufbau von Test-Umgebungen pro App benötigt werden.
    10. -
  10. webapp-optimize: Dieses Skript enthält verschiedene Optimierungs-Prozeduren inklusive JavaScript Minimierung, Zusammenfügen von Lokalisierungs-Dateien in die JSON-Dateien und Generieren von HTML-Dateien für die Standard-Sprache, falls nötig.
    11. -
  11. webapp-zip: Hier wird jede App in eine eigene zip-Datei komprimiert und diese im Verzeichnis profile/ abgelegt.
    12. -
  12. optimize-clean: optimize-clean bereinigt die HTML-Dateien für die Standard-Sprache.
    13. -
  13. contacts: Kopiert eine vorgefertigte Kontakte-Datei in Dein Profil in GAIA_DISTRIBUTION_DIR, falls vorhanden.
    14. -
  14. extensions: Kopiert die in GAIA_DIR/tools/extensions liegenden Erweiterungen in Dein Profil-Verzeichnis; verschiedene Konfigurationen ermöglichen das Kopieren verschiedener Erweiterungen.
    15. -
  15. installed-extensions.json (additional-extensions.js): Zu guter Letzt: Dieses Skript kopiert per Download verschiedene zusätzliche Erweiterungen in Dein Profil-Verzeichnis.
    16. -
- -

Build-Skript für Apps

- -

Standardmäßig wird als App Build Skript [app directory]/build/build.js von  app.js ausgeführt, falls vorhanden. Wenn $APP/build/build.js nicht vorhanden ist, dann kopiert app.js die App ins Stage-Verzeichnis build_stage.

- -

Die Dateien im App-Verzeichnis sollten vom App Build-Skript ins Stage-Verzeichnis build_stage kopiert werden; denn app.js kopiert sie nicht, wenn ein App Build-Skript existiert. Beispiel: Die App "Kalender" hat ein Skript build/build.js und utils.copyToStage() sollte in build.js für die "Kalender" App aufgerufen werden.

- -
-

Hinweis: Sourcen, die nicht zu Deiner App gehören (wie in shared/) kannst Du in der index.html in den <head> Bereich einfügen, damit sie von shared/ in Deine App kopiert werden.

-
- -

Build-Skripte für Apps benötigen möglicherweise alle Build Module im Verzeichnis  $GAIA_DIR/build; speziell das utils Modul, ein sehr nützliches Modul für den Build von Apps, kannst Du require('utils') verwenden um das Modul einzubinden.

- -

- -

Anpassen der Voreinstellungen

- -

Wenn Du eine eigene Konfiguration mit Einstellungen und Apps immer wieder beim Flashen Deines Gerätes benötigst, dann kannst Du eine Datei namens custom-prefs.js mit all Deinen Präferenzen im Verzeichnis build/config ablegen. Dort ist sie vor Überschreiben geschützt und unterliegt nicht der Source-Steuerung.

- -

Hier sind einige sinnvolle Voreinstellungen:

- -
// Aktivieren von marionette für Performance-Tests
-// siehe https://developer.mozilla.org/en-US/docs/Mozilla/Firefox_OS/Platform/Testing/Gaia_performance_tests
-user_pref("marionette.defaultPrefs.enabled", true);
-
-// Setzen des Ports für remote Debugging Deiner Anwendung auf Deinem Gerät
-user_pref("devtools.debugger.remote-port", 60000);
-
-// Aktivieren des remote Debuggers
-user_pref("devtools.debugger.remote-enabled", true);
-
-// Ausgeben der Debug-Meldungen über den Radio Interface Layer in logcat
-user_pref("ril.debugging.enabled", true);
-
- -

Diese Datei wird immer gelesen, wenn Du ein Profil generierst. Der sicherste Weg sicherzustellen, dass alles generiert wurde ist das vorherige Löschen des vorhandenen Profils:

- -
rm -rf profile && make profile
- -

Anschließend kannst Du beruhigt die install-gaia Option von make verwenden.

- -

FAQ

- -

Das Display bleibt Schwarz nach einem flash

- -

Das kann manchmal passieren, wenn das Gerät im Ruhemodus geflasht wird. Um das Problem zu beheben starte B2G einfach durch das folgende Kommando neu:

- -
adb shell stop b2g && adb shell start b2g
- -


-  

diff --git a/files/de/archive/b2g_os/gaia_entwickeln/customizing_build-time_apps/index.html b/files/de/archive/b2g_os/gaia_entwickeln/customizing_build-time_apps/index.html deleted file mode 100644 index 928799c864..0000000000 --- a/files/de/archive/b2g_os/gaia_entwickeln/customizing_build-time_apps/index.html +++ /dev/null @@ -1,117 +0,0 @@ ---- -title: 'Gaia-Apps: Build anpassen' -slug: Archive/B2G_OS/Gaia_Entwickeln/Customizing_build-time_apps -tags: - - Anpassung - - Apps - - Firefox OS - - Gaia - - build -translation_of: Archive/B2G_OS/Developing_Gaia/Customizing_build-time_apps ---- -
-

Entwickler und Geräte-Hersteller wollen die App-Pakete oftmals beim Erzeuen eines Builds aus verschiedenen Gründen anpassen. Dieser Artikel erklärt die unterschiedlichen Mechanismen dafür.

-
- -

Pfade für App-Dateien in Gaia

- -

Alle Firefox OS Apps befinden sich in einem der folgenden Pfade im Gaia Verzeichnisbaum:

- - - -

Falls Du in Deinem Gaia/B2G Build Apps herauslassen oder hinzufügen möchtest, dann kannst Du das auf verschiedene Weise tun. Details dazu werden nachfolgend erläutert.

- -

Die harte Methode

- -

Bei der harten Methode werden einfach die Apps gelöscht, die man nicht in den Build mit einbeziehen will.

- -

Anpassen der Konfigurations-Dateien

- -

Die etwas elegantere Methode ist das Anpassen der apps-*.list Dateien (zu finden in den verschiedenen gerätespezifischen Verzeichnissen, die in gaia/build/config/ aufgelistet sind, z.B. phone/ und tablet/), um die für den Build gewünschten Apps zu konfigurieren. Zum Beispiel könnte die Konfigurations-Datei gaia/build/config/phone/apps-production.list wie folgt aussehen:

- -
apps/bluetooth
-apps/bookmark
-apps/browser
-apps/calendar
-apps/callscreen
-etc.
- -

Du kannst hier auch alle Apps eines Verzeichnisses einbinden, und zwar so:

- -
apps/*
- -

Welche apps-*.list Dateien wiederum für den Build verwendet werden um die verfügbaren Apps zu ermitteln ist in der Datei gaia/Makefile hinterlegt, die etwa so aussieht:

- -
GAIA_DEVICE_TYPE?=phone
-  ...
-GAIA_APP_TARGET?=engineering
-  ...
-ifeq ($(MAKECMDGOALS), demo)
-GAIA_DOMAIN=thisdomaindoesnotexist.org
-GAIA_APP_TARGET=demo
-else ifeq ($(MAKECMDGOALS), dogfood)
-DOGFOOD=1
-else ifeq ($(MAKECMDGOALS), production)
-PRODUCTION=1
-endif
-  ...
-ifeq ($(PRODUCTION), 1)
-GAIA_OPTIMIZE=1
-GAIA_APP_TARGET=production
-endif
-
-ifeq ($(DOGFOOD), 1)
-GAIA_APP_TARGET=dogfood
-endif
-  ...
-ifndef GAIA_APP_CONFIG
-GAIA_APP_CONFIG=build$(SEP)config$(SEP)apps-$(GAIA_APP_TARGET).list
-endif
- -

Standardmaßig ist die Variable GAIA_APP_TARGET auf engineering gesetzt und die Variable GAIA_DEVICE_TYPE auf phone, so dass beim Build von Gaia per Default die Datei gaia/config/phone/app-engineering.list verwendet wird (die alle Apps enthält, u.a. auch Test- und Demo-Apps).

- -

Um andere apps-*.list Dateien zu verwenden musst Du entsprechende Parameter beim Aufruf des make Kommandos mitgeben. Um z.B. den Build mit gaia/build/config/phone/apps-production.list zu starten müsstest Du das hier verwenden:

- -
PRODUCTION=1 make
- -

Wenn Du den Build mit DEMO=1 startest, dann wird die Datei apps-demo.list verwendet. Und wenn Du den Build mit DOGFOOD=1 startest, dann wird die Datei apps-dogfood.list verwendet.

- -

Du kannst dieses Verhalten komplett übersteuern, indem Du die Variable GAIA_APP_CONFIG in der Datei gaia/Makefile änderst und dort eine eigene apps-*.list Datei einträgst.

- -

gaia/Android.mk enthält diese Zeilen:

- -
ifneq ($(filter user userdebug, $(TARGET_BUILD_VARIANT)),)
-GAIA_MAKE_FLAGS += PRODUCTION=1
-B2G_SYSTEM_APPS := 1
-endif
- -

Wenn Du den Build mit VARIANT=user oder VARIANT=userdebug startest (dieses Übersteuern spiegelt sich auch in der Variable TARGET_BUILD_VARIANT wieder), dann wird PRODUCTION=1 automatisch gesetzt.

- -
-

Hinweis: Weitere Optionen für make findest Du in der make options reference.

-
- -

Verwenden eigener Distributionen

- -

Die dritte und eleganteste (allerdings auch komplexeste) Methode ist das Verwenden eigener Distributionen. Dies ermöglicht das Einbinden eigener Konfigurationen und Pakete ohne das Gaia Paket selbst zu ändern. Du kannst für Deine angepassten Konfigurationen und Pakete eigene Verzeichnisse oder die mit Gaia ausgelieferten Verzeichnisse verwenden.

- -

Du kannst Deine Distribution durch Setzen der Umgebungsvariable GAIA_DISTRIBUTION_DIR in den Build einbinden, zum Beispiel so:

- -
GAIA_DISTRIBUTION_DIR=<DISTRIBUTION_PATH> make production
- -

Mehr Informationen zum Erstellen individueller Distributionen findest Du auf https://github.com/mozilla-b2g/gaia/tree/master/customization.

- -

Dieses komplexe Thema hat eine komplett eigene Dokumentation. Mehr zum Thema erfährst Du unter Market Customizations guide.

- -
-

Hinweis: Wenn Du Apps von Drittanbietern in Deinen Gaia Build einbinden willst, dann müssen diese auf spezielle Art erzeugt werden bevor sie im Verzeichnis gaia/dev-apps/ abgelegt werden. Nähere Informationen findest Du auf Building Prebundled web apps.

-
- -
-

Wichtig: Wenn Sie als Geräte-Hersteller einen angepassten B2G/Gaia Build für Ihre Distribution verwenden möchten, dann müssen Sie bestimmte Voraussetzungen erfüllen bevor Sie Firefox OS Marketplace Apps auf Ihrem Smartphone, Tablet etc. anbieten dürfen. Bitte kontaktieren Sie in einem solchen Fall Mozilla für nähere Informationen.

-
- -

 

diff --git a/files/de/archive/b2g_os/gaia_entwickeln/durchfuehrung_der_gaia_codebase/index.html b/files/de/archive/b2g_os/gaia_entwickeln/durchfuehrung_der_gaia_codebase/index.html deleted file mode 100644 index eef4cb0c8e..0000000000 --- a/files/de/archive/b2g_os/gaia_entwickeln/durchfuehrung_der_gaia_codebase/index.html +++ /dev/null @@ -1,71 +0,0 @@ ---- -title: Durchführung der Gaia codebase -slug: Archive/B2G_OS/Gaia_Entwickeln/Durchfuehrung_der_Gaia_codebase -tags: - - B2G - - Firefox - - Firefox OS - - Firefox OS lokal ausführen - - Gaia - - beitragen - - 'l10n:priority' -translation_of: Archive/B2G_OS/Developing_Gaia/Running_the_Gaia_codebase ---- -
-

Dieser Artikel beschreibt im Detail die lokale Durchführung der Gaia Codebase und welche Werkzeuge in diesem Setup verfügbar sind.

-
- -

Zuerst sei erwähnt, dass Du NICHT Gecko oder B2G erstellen musst, um zu Gaia beizutragen. Du musst lediglich den Gaia Quellcode herunterladen und die Möglichkeit haben, diesen auszuführen und zu editieren.
-
- Es gibt verschiedene Möglichkeiten, Gaia auszuführen:

- - - -

Du findest auf der Different ways to run Gaia Seite kurzgefasste Informationen über jede der genannten Möglichkeiten, zusammen mit Links zu detailierten Beschreibungen - je nach Bedarf. Generell sind diese nach Komplexität geordnet, absteigend von der komplexesten zur einfachsten (aber unwahrscheinlichsten) Methode.

- -

In diesem Artikel konzentrieren wir uns auf das Ausführen von Gaia innerhalb von Firefox Mulet oder in WebIDE. Für die meisten Änderungen, die Du in der Gaia Codebase machen möchtest, bietet dies den schnellsten Mechanismus, Updates zu testen aber offensichtlich gibt es einige Funktionen (z. B. das Testen von Geräte-APIs oder Interaktion mit der Smartphone Hardware ), für die ein physisches Gerät benötigt wird.

- -
-

Info: Um weitere Hilfe zu Gaia zu bekommen, der beste Platz ist der #gaia IRC Channel (siehe auch Mozilla IRC für weitere Informationen hierzu) und die dev-gaia mailing list.

-
- -

Ausführen der eigenen Gaia Version

- -
    -
  1. Erstelle zuerst eine Verzweigung von der Gaia repo on Github.
    2. -
  2. Als nächstes, klone Deine Verzweigung lokal: - 
    git clone https://github.com/your-username/gaia.git
    -
    3. -
  3. Füge den Upstream wie folgt hinzu: - 
    cd gaia
-git remote add upstream https://github.com/mozilla-b2g/gaia
    -
    4. -
  4. Nun musst Du ein Gaia Profil anlegen. Führe make innerhalb Deines repo Ordners aus, um ein Profil in der profile Directory anzulegen, die für optimales Debugging konfiguriert ist. Dies erzeugt ungepackte (hosted) Versionen der Gaia Apps, welche dazu fungieren, gebündelt und direkt über den lokalen HTTPD Server -zusammen als Erweiterung für Firefox Desktop- übertragen zu werden. Wenn Du Änderungen gemacht hast, musst Du nur Dein Browser Fenster aktualisieren, um das Ergebnis zu sehen (wie Du es später sehen wirst), statt Dein Profil erneuern zu müssen, erneut auf das Gerät übertragen u.s.w..
    - Dies ist sehr gut für schnelles CSS/JS/HTML Hacking.
    5. -
  5. Mit Deinem angelegten Debug Profil, führe es in Mulet or WebIDE aus, mithilfe der Anleitungen hinter den Links.
    6. -
- -

Troubleshooting und bekannte Probleme

- -

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

- -

In manchen Linux Versionen (eg: Archlinux), ist python3 der Standard python. Dadurch scheitert npm beim Ausführen mancher Befehle (z B. beim Testen). Um dies permanent zu beheben, führe folgenden Befehl aus:

- -
npm config set python python2
- -

Weiter Lösungen findest Du auch auf dieser Seite: Stack Overflow page.

- -

Danach solltest Du Deine node_modules Directory löschen und den gescheiterten Befehl erneut ausführen.

- -

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

- -

Nun bekommst Du diesen Fehler obwohl Du NodeJS installiert hast. Möglicherweise benutzt Du Debian oder andere Debian-basierende Versionen wie zum Beispiel Ubuntu. Bei diesen Versionen ist NodeJS im nodejs Paket und Du kannst das nodejs-legacy Paket folgendermaßen installieren, um alles korrekt aufzusetzen:

- -
sudo aptitude install nodejs-legacy
- -

Solltest Du bei der Installation des Paketes Probleme haben, benutzt Du eventuell Chris Lea's PPA for Node; bitte entferne diese bevor Du weitermachst.

diff --git a/files/de/archive/b2g_os/gaia_entwickeln/index.html b/files/de/archive/b2g_os/gaia_entwickeln/index.html deleted file mode 100644 index d6f1d582d6..0000000000 --- a/files/de/archive/b2g_os/gaia_entwickeln/index.html +++ /dev/null @@ -1,52 +0,0 @@ ---- -title: Gaia entwickeln -slug: Archive/B2G_OS/Gaia_Entwickeln -tags: - - B2G - - Bugs - - Firefox OS - - Gaia - - Mozilla - - beitragen -translation_of: Archive/B2G_OS/Developing_Gaia ---- -
-

Gaia ist das User Interface von Firefox OS, sowie eine Suite für die Standard-Apps. Gaia beinhaltet den Sperr- und Startbildschirm, die Telefonie-App und weitere Apps. Im Grunde ist Gaia eine Menge an Web-Apps, welche auf Firefox OS laufen. Diese Artikel behandelt alles, was zur Mitentwicklung an Gaia wissenswert ist.

-
- -

In diesem Guide zeigen wir dir einen produktiven Workflow, um an Gaia mitzuarbeiten - und damit meinen wir, neue Features zu Gaia hinzuzufügen und an Bugs im Gaia Projekt zu arbeiten. Die ersten paar Artikel können in gegebener Reihenfolge durchgearbeitet werden oder du überspringst sie und gehst direkt zum relevanten Abschnitt, wenn du dein Wissen über ein bestimmtes Thema auffrischen möchtest.

- -

Danach stellen wir Referenzmaterialien und Informationen zu weiteren Themen zur Verfügung.

- -

- -

Die Grundlagen

- -
    -
  1. Die Gaia Codebase zum Laufen bringen
    2. -
  2. Die Gaia Codebase verstehen
    3. -
  3. Änderungen am Gaia Code machen
    4. -
  4. Änderungen am Gaia Code testen
    5. -
  5. Einen Gaia Patch einreichen
    6. -
- -

Gaia Build Referenzen

- - - -

Siehe auch

- - diff --git a/files/de/archive/b2g_os/gaia_entwickeln/making_gaia_code_changes/index.html b/files/de/archive/b2g_os/gaia_entwickeln/making_gaia_code_changes/index.html deleted file mode 100644 index 18a2a01cf5..0000000000 --- a/files/de/archive/b2g_os/gaia_entwickeln/making_gaia_code_changes/index.html +++ /dev/null @@ -1,85 +0,0 @@ ---- -title: Gaia Coding ändern -slug: Archive/B2G_OS/Gaia_Entwickeln/Making_Gaia_code_changes -tags: - - Anleitung - - Code - - Firefox OS - - Gaia - - Änderungen -translation_of: Archive/B2G_OS/Developing_Gaia/Making_Gaia_code_changes ---- -
-

Jetzt, wo Gaia auf Deinem Desktop läuft und Du zu einem gewissen Grad die Arbeitweise der Codebase verstehst, solltest Du in der Lage sein Änderungen am Gaia Code durchzuführen. Dieser Artikel beschreibt, wie Änderungen durchgeführt werden und wie man Fehler findet um sie zu beheben.

-
- -

Git Best Practices

- -
    -
  1. Vor dem Ändern von Gaia solltest Du zuerst den master Zweig (branch) aktualisieren: - 
    cd path/to/gaia
-git checkout master
-git pull upstream master
    -
    2. -
  2. Als nächstes  brauchst Du einen eigenen Zweig für Deine Änderungen: - 
    git checkout -b my-code-fix
    -
    3. -
  3. Anschließend gehst Du ins Verzeichnis gaia/apps und führst Deine Änderungen an den App-Dateien durch.
    4. -
- -

Beispiel einer einfachen Code-Änderung

- -

Um Code-Änderungen anzuzeigen:

- -
    -
  1. Führe die gewünschten  Änderungen an der Gaia Codebase durch und speichere die Änderungen.
    2. -
  2. Beende Firefox Mulet oder den WebIDE Simulator.
    3. -
  3. Erneuere Dein Gaia Profil mit make.
    4. -
  4. Starte Firefox Mulet oder den WebIDE Simulator erneut.
    5. -
- -

Lass uns etwas Einfaches ändern wie die Textfarbe der Uhr auf dem Sperrbildschirm:

- -

Gaia lockscreen showing the clock display in white text

- -
    -
  1. Der beste Weg um herauszufinden wo dieser Stil geändert wird ist über die Entwickler-Werkzeuge. Verwende hier Strg/rechte Maustaste + Klick auf die Uhr im Firefox Desktop und wähle im Kontext-Menü Element untersuchen.
    2. -
  2. Nun kannst Du die zu ändernde CSS Datei suchen — in diesem Fall  gaia/apps/system/lockscreen/style/lockscreen.css — und die Änderungen an den CSS Styles auf der rechten Seite des Displays nach Deinen Vorstellungen vornehmen.
    3. -
  3. Wenn Du mit Deinen Änderungen zufrieden bist, dann öffne die Datei und mache dort Deine Änderungen direkt.
    4. -
  4. Als nächstes führst Du die oben aufgeführten Schritte durch, um Dir Deine Änderungen anzusehen.
    5. -
- -

Gaia lockscreen showing the clock display modified from white to red text
-
-
- Einschränkungen im Gaia Firefox Mulet Rendering:

- - - -

Wo man zu bearbeitende Fehler findet

- -

Am besten nutzt Du Josh Matthews' Bugs Ahoy app um Fehler zu finden, die Du bearbeiten kannst — diese Seite liest die vorhandenen Bugs direkt aus Mozilla's Bugzilla und stellt sie im Browser inklusive Suchfunktion dar. Wenn Du einen Fehler gefunden hast den Du bearbeiten willst, dann gehe zu dessen Bugzilla-Seite, trage Dich als Bearbeiter im Feld "assigned to" ein und beginne mit der Arbeit wie oben beschrieben.

- -

Nützliche Tipps

- - - -

https://bugzilla.mozilla.org/buglist.cgi?columnlist=product%2Ccf_blocking_b2g%2Cbug_status%2Cresolution%2Cshort_desc&resolution=---&query_based_on=CLOCK&query_format=advanced&bug_status=UNCONFIRMED&bug_status=NEW&bug_status=ASSIGNED&bug_status=REOPENED&component=Gaia%3A%3AClock&product=Boot2Gecko&known_name=CLOCK&list_id=9776392

- -

Siehe auch

- - diff --git a/files/de/archive/b2g_os/index.html b/files/de/archive/b2g_os/index.html deleted file mode 100644 index 4447e3c024..0000000000 --- a/files/de/archive/b2g_os/index.html +++ /dev/null @@ -1,163 +0,0 @@ ---- -title: B2GOS -slug: Archive/B2G_OS -tags: - - Anfangen - - Anfänger - - B2G OS - - Basic - - Firefox OS - - Gaia - - Gecko - - Gonk - - NeedsTranslation - - TopicStub -translation_of: Archive/B2G_OS ---- -
-

B2G OS ist ein vollständiges, selbstständig arbeitendes Betriebssystem für das offene Web. Es ist ein von der Mozilla-Community entwickeltes Open-Source-Projekt und bildet die Grundlage der Firefox OS-Produkte.

-
- -

B2G OS ist ein von der Community gepflegtes Open-Source-Betriebssystem für Smartphones, Tablets, Smart TVs und andere internetfähige Geräte. Das Projekt startete ursprünglich 2011 und basiert auf dem Linux-Kernel und der Rendering-Engine Gecko. Die komplette Nutzeroberfläche ist mit Web-Technologien geschrieben und kann zum Starten und Benutzen von Web-Anwendungen benutzt werden. Nachdem die Mozilla Corporation ihr kommerzielles Firefox OS Smartphone-Programm eingestellt hat, wird das Projekt für Smartphones von Mozillas Community weiterentwickelt und als B2G OS geführt.

- -

- -
-

Hinweis: Aufruf zur Mitarbeit & Aufruf zur Appanpassung um mehr Personen zu beteiligen. Hilf uns und teile ihn!

-
- -
-
-

Mithelfen

- -
    -
  • Melde & behebe Fehler (Meta-Bug ist Bug 1252143)
    • -
  • Hilf uns, fehlschlagende Tests zu reparieren
    • -
  • Portiere eine Gaia Smartphone-App: -
      -
    1. in eine Web-App (oder)
      2. -
    2. in eine chrome://-Anwendung (warum?) und berichte darüber
      3. -
    -
    • -
  • Portiere B2G OS für dein Smartphone und hilf uns, den Port zu pflegen
    • -
  • Hilf uns, diese Dokumentation und das Wiki zu verbessern und zu übersetzen
    • -
  • Schlage neue Smartphone-Funktionen vor und implementiere sie
    • -
-
- -
-

Mitreden

- - -
- -
-

Geräte

- -

Informationen zu unterstützten Geräten, auf denen B2G OS laufen kann:

- - - -

Mehr Informationen finden sich hier.

- -

Dein Gerät ist nicht dabei? Probier die Mulet-Desktopanwendung aus.

-
-
- -
-

Hinweis: Einige Seiten wurden in das MDN-Archiv verschoben. Lass es uns wissen, wenn du Schwierigkeiten hast, etwas zu finden oder ein Abschnitt aus dem Archiv hierher zurückgeholt werden sollte.

-
- -

 

- - - -
    -
  1. B2G OS Architecture - -
      -
    1. B2G OS Architecture
      2. -
    2. B2G OS APIs
      3. -
    -
    2. -
  2. Gaia -
      -
    1. Gaia overview
      2. -
    2. Different ways to run Gaia
      3. -
    3. Running the Gaia codebase
      4. -
    4. Developing Gaia -
        -
      1. Understanding the Gaia codebase
        2. -
      2. Making Gaia code changes
        3. -
      3. Testing Gaia code changes
        4. -
      4. Submitting a Gaia patch
        5. -
      5. Gaia build system primer
        6. -
      6. Make options reference
        7. -
      7. Gaia tools reference
        8. -
      -
      5. -
    -
    3. -
  3. Build B2G OS -
      -
    1. Build overview
      2. -
    2. B2G OS build process summary
      3. -
    3. Build prerequisites
      4. -
    4. Preparing for your first build
      5. -
    5. Building B2G OS -
        -
      1. Building B2G OS
        2. -
      2. Building B2G OS for Flame on Mac OS X
        3. -
      3. Building for Fairphone
        4. -
      4. B2G build variables reference sheet
        5. -
      -
      6. -
    -
    4. -
  4. Run B2G OS on Desktop -
      -
    1. Choosing how to run Gaia or B2G OS
      2. -
    2. Run B2G OS on desktop using Mulet
      3. -
    -
    5. -
  5. Install B2G OS on mobile -
      -
    1. Installing B2G OS on a mobile device
      2. -
    2. B2G installer add-on
      3. -
    -
    6. -
  6. Compatible Devices
    7. -
  7. Create updates for B2G OS -
      -
    1. Creating and applying B2G OS update packages
      2. -
    2. Building and installing FOTA community build
      3. -
    -
    8. -
  8. Porting B2G OS -
      -
    1. Porting overview
      2. -
    2. Porting basics
      3. -
    3. Porting on CyanogenMod
      4. -
    -
    9. -
diff --git a/files/de/archive/b2g_os/installing_on_a_mobile_device/index.html b/files/de/archive/b2g_os/installing_on_a_mobile_device/index.html deleted file mode 100644 index 96a469353c..0000000000 --- a/files/de/archive/b2g_os/installing_on_a_mobile_device/index.html +++ /dev/null @@ -1,81 +0,0 @@ ---- -title: Installing Firefox OS on a mobile device -slug: Archive/B2G_OS/Installing_on_a_mobile_device -translation_of: Archive/B2G_OS/Installing_on_a_mobile_device ---- -
-

Once you've built Boot to Gecko for a supported mobile device, you can install it. This article will guide you through the process.

-
-
- Note: The first time you flash your phone, it must have Android 4 (Ice Cream Sandwich) installed. The process will not work correctly otherwise. Once you've done your first install of B2G, however, you can simply update on top of it.
-

Installing ADB

-

On OSX

-

If you have homebrew on OSX:

-
brew install android-platform-tools
-

Otherwise, download the Android Developer Tools and add the binaries to your PATH.

-

On Ubuntu

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

Flashing your phone

-

To flash everything to your phone, simply connect your phone and type:

-
./flash.sh
-
-

That's it. The B2G you've currently got built will flash onto your device.

-

Note that If you are updating across revisions with significant Gaia changes, you might need also do:

-
cd gaia
-make reset-gaia
-

This will wipe all of your data stored in Gaia, but also clear out obsolete Gaia settings and prefs so that you'll boot into a "clean" Gaia. In theory ./flash.sh should do this already, but for some devices (e.g. hamachi) ./flash.sh only flashes a subset of modules (./flash.sh -f will force flash everything.)

-

Configuring the udev rule for your device

-

On Linux, if you get this,

-
< waiting for device >
-

that probably means that you haven't added a udev rule for the fastboot device, which is not the same as the one for adb. (Though it also might just mean you need to run ./flash.sh with sudo) You can get the USB vendor ID by running lsusb now, but typically it's Google's: 18d1, so adding this line in your /etc/udev/rules.d/51-android.rules would work:

-
SUBSYSTEM=="usb", ATTR{idVendor}=="18d1", MODE="0666", GROUP="plugdev"
-
- Note: If you get a very helpful libusb error "-3" on Linux, it means you need to be root to have the needed access to the USB device. Run the script again using sudo.
-
- Note 2: If you have an Unagi or a Geeksphone Keon phone, you need two lines like this - one for the original phone vendor's ID, and one for Google's.
-

Special notes for Hamachi, Helix, and Leo devices

-

If your phone is a hamachi, helix or leo device, the ./flash.sh script will now default to flashing only gecko and gaia.  It is recommended that you flash with the OEM as a base build to get the firmware and the gonk layers and then flash the gecko and gaia on top.  If you want to flash using the images, there is an override flash where you can ./flash.sh -f and it will use the image files to flash your device.

-

Special notes for the Samsung Galaxy S2

-

If your phone is a Galaxy S2 and you are using heimdall 1.3.2 (the latest version; use heimdall version to check), you may see an alarming error "FACTORYFS upload failed!" followed by "Heimdall flashing failed" and some additional information. This is actually a success condition, and you can ignore the advice.

-

To get rid of this strange behavior, grab a source copy of heimdall, downgrading to the 1.3.1 release ("git checkout fbbed42c1e5719cc7a4dceeba098981f19f37c06"), then compile it  according to the README, then install that to make the error go away. However, this isn't strictly necessary.

-

All versions of heimdall are unable to flash a system.img larger than 100MB. Do:

-
ls -l ./out/target/product/galaxys2/system.img
-
-

to see how big yours is. If it's too large, ask in IRC for advice; there are ways to do it in two stages.

-

Added step for the Samsung Galaxy S2

-

If you're flashing onto the Galaxy S2, there is an additional step to follow. Gaia does not get flashed automatically by the flash.sh script; you'll need to also do:

-
./flash.sh gaia
-
-

Flashing specific partitions to fastboot phones

-

You can flash specific partitions to fastboot phones (that is, any phone other than the Samsung Galaxy S2). For example:

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

WARNING: flashing user (at least) may delete your user-specific data (contacts, etc.).

-

Updating specific modules

-

You can update specific components of B2G by specifying their names when flashing. For example:

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

In order to update only one application you can use BUILD_APP_NAME environment variable:

-
BUILD_APP_NAME=calendar ./flash.sh gaia
-

If your phone is not for developer (you aren't interested on test apps and/or require optimization), you can update gaia using:

-
VARIANT=user ./flash.sh gaia
-

Next steps

-

At this point, your phone should be running Boot to Gecko! It's time to experiment, write some code, test, or do some debugging!

-
- Note: A helpful usage tip: if your build of B2G starts up with the lock screen requesting a pass code to unlock the phone, the default code is 0000.
-

Troubleshooting

-

Here are a some tips for what to do if your device doesn't work right after installing B2G, or updating it to a new version

-

If the UI doesn't start up

-

If you update your phone and the user interface doesn't start up, you can reset it to clear out out-of-date configuration and the like. This may bring it back to life, but note that it may also delete your user-specific data (contacts, etc.). Here's how:

-
cd gaia
-make reset-gaia
-
-

If you want change from developer to production mode

-
cd gaia
-make reset-gaia PRODUCTION=1
-

WARNING: reset-gaia may delete your user-specific data (contacts, etc.).

-

"image is too large" error message on ./flash.sh execution

-

It might mean that you phone needs to be rooted first before flashing it. As b2g needs to be written on root partition, your phone needs to be rooted in order to install it.

diff --git a/files/de/archive/b2g_os/introduction/index.html b/files/de/archive/b2g_os/introduction/index.html deleted file mode 100644 index 606b63f0e7..0000000000 --- a/files/de/archive/b2g_os/introduction/index.html +++ /dev/null @@ -1,84 +0,0 @@ ---- -title: Einführung in Firefox OS -slug: Archive/B2G_OS/Introduction -translation_of: Archive/B2G_OS/Introduction ---- -

Firefox OS (auch unter seinem Codenamen "Boot to Gecko" oder "B2G" bekannt) ist Mozillas Open Source Betriebssystem für mobile Endgeräte, das auf Linux und Mozillas Gecko-Technologie basiert. Firefox OS ist ein mobiles Betriebssystem, das ohne proprietäre Technologie auskommt und dennoch Anwendungsentwicklern eine leistungsstarke Plattform bietet, um hervorragende Produkte zu erstellen. Darüber hinaus ist es flexibel und leistungsfähig genug, um auch den Endprodukt-Nutzer glücklich zu machen.

-

Für Web-Entwickler ist es am Wichtigsten zu verstehen, dass die gesamte Benutzeroberfläche eine Web-Anwendung ist, von der aus sich andere Web-Anwendungen anzeigen und ausführen lassen. Jede deiner Veränderungen an der Benutzeroberfläche und jegliche Anwendung, die du für den Betrieb unter Firefox OS erstellst, sind Webseiten. Allerdings: Mit erweitertem Zugriff auf Hardware und Dienste des mobilen Endgeräts.

-

Wie man Firefox OS installiert, kannst du unserer Handy-Anleitung entnehmen.

-

Hardware-Voraussetzungen

-

Die Portierung von Firefox OS sollte für die meisten aktuellen Mobilgeräte mit ARM-Chips gelingen. Der vorliegende Abschnitt beschreibt die grundlegenden Hardware-Anforderungen sowie empfohlene Eigenschaften der Hardware.

-

 

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
KomponenteMinimumEmpfohlen
CPUARMv6Cortex A5 class oder besser
- ARMv7a mit NEON
GPU—Adreno 200 class oder besser
Verbindungen—WiFi
- 3G
Sensoren—Accelerometer
- Proximity
- Ambient light
- A-GPS
-

Es wird außerdem empfohlen, dass die Geräte ein einheitliches Farbprofil anbieten sollen (was über den Treiber der Grafikeinheit zu implementieren wäre). Ebenso sollen sie das Stummstellen und die Wiedergabe-Funktion via Kopfhörer-Fernbedienung unterstützen. Beides sind gängige Fähigkeiten moderner Smartphones.

-

Hinweise zur Benutzung

-

Dieser Abschnitt bietet dir einige Hinweise zur Verwendung von Firfox OS. Dabei handelt es sich um eine Art Platzhalter, bis wir eine echte Benutzer-Dokumentation zur Verfügung haben.

-

Entsperren des Telefons

-

Falls dein aus dem Quellcode erstelltes Firefox OS mit der Frage nach einem Entsperr-Code hochfährt, so lautet dieser standardmäßig 0000. Das liegt daran, dass wir bei diesen Code-Versionen mit der Entwicklung und dem Testen des Sperr-Bildschirms (Lock-Screen) beschäftigt sind.

-

Erstellen eines Screenshots

-

Ein Screenshot lässt sich ganz einfach durch gleichzeitiges Drücken von Power- und Home-Taste erzeugen. Das entsprechende Bild wird unter /sdcard/screenshots auf deinem Gerät abgelegt. Du kannst darauf auch mit Hilfe der Galerie-App deines Telefons zugreifen.

-

Sollte das aus irgendeinem Grund nicht funktionieren, kannst du auch jederzeit über ein Terminal des Linux- oder MacOSX-Computers, auf dem ein Firefox OS installiert ist, darauf zugreifen.

-
    -
  1. Stell sicher, dass bei dir ffmpeg installiert ist. -
      -
    1. Wenn Du MacPorts verwendest, kannst du das auf dem Mac mit sudo port install ffmpeg nachholen. Mit homebrew verwende brew install ffmpeg.
      2. -
    2. Unter Linux (Ubuntu/Debian) verwende sudo apt-get install ffmpeg.
      3. -
    -
    2. -
  2. Schließe dein Telefon mit einem USB-Kabel an deinen Rechner an.
    3. -
  3. Erzeuge auf deinem Telefon die Situation, von der Du einen Screenshot willst.
    4. -
  4. Wechsle mit cd ins B2G/gaia Verzeichnis.
    5. -
  5. make screenshot
    6. -
  6. Du hast einen Screenshot namens screenshot.png erstellt.
    7. -
-

Tasten und Bedienelemente

-

Ein typisches Firefox OS-Gerät verfügt hardwareseitig nur über eine geringe Zahl physischer Bedienelemente:

-
-
- Home-Taste
-
- Diese Taste befindet sich im Allgemeinen mittig unterhalb des Bildschirms. Bei Tastendruck wird man zum App-Launcher zurückgeführt. Bei Halten der Taste wird die Ansicht zum Umschalten der Karten geöffnet: Hochwischen auf einer App entfernt diese.
-
- Lautstärken-Wippe
-
- Entlang der linken Seite befindet sich die Lautstärken-Wippe. Druck auf die obere Hälfte erhöht die Lautstärke, Druck auf die untere senkt sie.
-
- Power-Taste
-
- Die Power-Taste befindet sich an der oberen rechten Ecke des Geräts.
-
diff --git a/files/de/archive/b2g_os/phone_guide/alcatel_one_touch_fire/index.html b/files/de/archive/b2g_os/phone_guide/alcatel_one_touch_fire/index.html deleted file mode 100644 index 4ba54a945b..0000000000 --- a/files/de/archive/b2g_os/phone_guide/alcatel_one_touch_fire/index.html +++ /dev/null @@ -1,102 +0,0 @@ ---- -title: Alcatel One Touch Fire -slug: Archive/B2G_OS/Phone_guide/Alcatel_One_Touch_Fire -tags: - - Alcatel One Touch Fire - - Firefox OS -translation_of: Archive/B2G_OS/Phone_guide/Alcatel_One_Touch_Fire ---- -
-
- -
-

Das Alcatel One Touch Fire Smartphone mit Firefox OS verfügt über einen 1 GHz Prozessor und einer rückseitigen 3.2 Megapixel Kamera. Es wird von einer großen Vielzahl von Mobilfunkanbietern in verschiedenen Teilen der Welt angeboten.

- -

Besorge dir ein Gerät

- -

Das Alcatel One Touch Fire ist im allgemeinen Handel erhältlich.

- -

Verfügbare Länder

- -
-
-
    -
  • Brasilien
    • -
  • Chile
    • -
  • Kolumbien
    • -
  • Deutschland
    • -
  • Griechenland
    • -
  • Ungarn
    • -
  • Italien
    • -
-
- -
-
    -
  • Mexico
    • -
  • Montenegro
    • -
  • Peru
    • -
  • Polen
    • -
  • Serbien
    • -
  • Venezuela
    • -
-
-
- -

Mobilfunkanbieter

- -
-
-
    -
  • Congstar
    • -
  • Cosmote
    • -
  • Movistar
    • -
  • T-Mobile
    • -
-
- -
-
    -
  • Telcel
    • -
  • Telenor
    • -
  • TIM
    • -
  • Vivo
    • -
-
-
-
-
- -

Software - Updates & Upgrades

- -

Das Systemabbild des Gerätes ist durch den Mobilfunkanbieter gesperrt. Aus diesem Grund kann ein Update der Software nur durchgeführt werden wenn der Netzbetreiber ein OTA Update veröffentlicht.

- -

Geräteeigenschaften

- -

Mehr Geräteeigenschaften sind auf der Alcatel Website unter dem Reiter "Specification" aufgelistet.

- - - -

Verfügbare Farben

- - - -

Weitere Informationen

- - diff --git a/files/de/archive/b2g_os/phone_guide/flame/index.html b/files/de/archive/b2g_os/phone_guide/flame/index.html deleted file mode 100644 index b8e75bb09a..0000000000 --- a/files/de/archive/b2g_os/phone_guide/flame/index.html +++ /dev/null @@ -1,39 +0,0 @@ ---- -title: Flame -slug: Archive/B2G_OS/Phone_guide/Flame -translation_of: Archive/B2G_OS/Phone_guide/Flame ---- -
-

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

-

The Flame developer reference phone is a milestone in Firefox OS device releases. The Flame hardware offers a representative set of specs — including FWVGA display and dual-core processor (see Phone and device specs for full specs) — to help developers build great content and experiences. A single hardware platform is also good for testers, making it easier to test and address specific software issues without having to worry about device model-specific bugs, etc.

-
-

If you have your phone in hand and want to start playing with it, developing and distributing apps, or contributing to the Firefox platform, the following links will get you where you need to go:

- -

If you’d like to purchase a phone or find out more about using it, you’ll find the information you need below.

-

Purchasing a device

-

Our device manufacturer partner is making the device available for purchase in the latter part of Q2, 2014, retailing at approximately US$170, global shipping included. Available for pre-order soon!

-

Emergency download mode

-

When flashing a new build to your phone fails to work, your phone becomes unresponsive, and the phone cannot enter fastboot mode, you can use emergency download mode for recovery.

-

A USB cable and the Emergency Download Tool are required to enter emergency download mode. (Tool download coming soon.)

-

Recovery mode

-

You can enter recovery mode to clear your phone data or manually update the firmware. There are two ways to enter this mode:

- -

When in recovery mode, press the Volume up/down keys to move the selection highlight, and the Power key to select. Make sure you have your phone data (Contacts, SMS, etc.) backed up before clearing data, and your upgrade packages downloaded before updating.

-

RAM adjustment

-

You can adjust the available RAM capacity to see how apps perform on Firefox OS phones with lower memory footprints.

-

This is accomplished by entering fastboot mode (install fastboot first, which is available in the same SDK page as ADB) and typing:

-
fastboot oem mem [0|256-1024]
-

“0” is the memory automatically detected and “256-1024” is the number of megabytes. For example, if you want to adjust device RAM capacity to 512M, enter fastboot oem mem 512.

-

You'll need to then reboot your device for the settings to take effect. This can be done using:

-
fastboot reboot
-

The current memory size can be returned by entering fastboot mode and typing:

-
fastboot getvar mem
-
diff --git a/files/de/archive/b2g_os/phone_guide/geeksphone/index.html b/files/de/archive/b2g_os/phone_guide/geeksphone/index.html deleted file mode 100644 index b9bc2572df..0000000000 --- a/files/de/archive/b2g_os/phone_guide/geeksphone/index.html +++ /dev/null @@ -1,202 +0,0 @@ ---- -title: Geeksphone -slug: Archive/B2G_OS/Phone_guide/Geeksphone -translation_of: Archive/B2G_OS/Phone_guide/Geeksphone ---- -
-

Developer Preview editions of the Firefox OS phone are now becoming widely available to the community, mainly through Geeksphone. Since these are for developers, naturally we want to encourage you to tinker and play with them as much as possible! In this article we cover some basic tips on how to keep your phone up to date and how to tweak the system Gaia applications.

-
- -
-

Bitte beachten: Diese Anleitungen sind für die älteren Modelle Keon und Peak gedacht und nicht für das aktuellste Geeksphone Revolution.

-
- -

Geeksphone auf das letzte Abbild upgraden

- -

Firefox OS Updates können über die Settings App heruntergeladen werden. Die Funktionalität befindet sich unter Device Informationen. Das Smartphone kann so eingestellt werden, dass es auf neue Updates täglich, wöchentlich oder monatlich prüft. Zusätzlich besteht die Möglichkeit über den "check now" Button eine Aktualisierung durchzuführen. Sobald ein neues Update verfügbar ist wird dies angezeigt und der Download und die Installation der aktuellen Version kann beginnen.

- -

The screen for checking updates on the Firefox OS settings app

- -

Das Telefon flashen

- -

Das Team von Geeksphone stellt die "latest stable" und die "nightly builds" als eigenständige Downloads zum selbstständigen flashen zur Verfügung.

- -

Telefon und Computer vorbereiten

- -

Bevor man mit dem flashen des Smartphone beginnen sollte, sollte man die Anleitung im Abschnitt  “Setting Up the Geeksphone Device” in Pushing Firefox OS Apps to the Geeksphone beachten und die dort beschriebenen Voraussetzungen schaffen. Diese stellt sicher, dass man Daten an das Telefon übertragen kann. Ebenfalls sollte man, die im gleichen Abschnitt beschriebene  Anleitung zur Installation der korrekten USB-Treiber beachten.

- -
-

Bitte beachten: Es ist besonders wichtig, dass auf Windows Computer die korrekten Treiber installiert sind.

-
- -

Die aktuellen Build befinden sich auf der Geeksphone Download-Seite. Auf dieser Seite erhält man nun die Option das korrekte Gerät und den gewünschten Build auszuwählen.

- -

Two phone images side by side, the Geeksphone Keon and Peak, with different software download options below each one.

- -

Lade nun den zu deinem Gerät passenden Build herunten und entpacke die Archive-Datei auf deine Festplatte. Das Archive beinhaltet das Abbild und die benötigten Befehle um das Gerät zu aktualisieren. Dabei stehen Befehle für Windows, Mac OS oder Linux zur Verfügung. Um das Gerät nun zu aktualisieren muss "Remote debugging" unter Einstellungen aktiviert sein.

- -

Settings -> Device information -> More information -> Developer tab.

- -
-

Bitte beachten: Stelle sicher dass dein Handy eine Akkuladung von mit 50% aufweist. Um die System-Dateien zu verändern Bedarf es mehrere Restarts, welche im Falle von fehlender Akkuleistung zu einer Beschädigung führen kann.

-
- -

Enabling remote debugging on the Firefox OS Settings app

- -
-

Bitte beachten: Sollte dein Gerät, obwohl es angesteckt ist, von den mitgelieferten Skripten in den ersten Schritten nicht erkannt werden, musst ggf. das Handy entsperren und warten bis das USB-Zeichen im System-Tray auftaucht.

-
- -
-

Bitte beachten: Das Flashen des Smartphone wird all deine Daten vom Telefon entfernen. Wenn du deine Daten zuvor sichern möchtest, solltest du die folgende Anleitung befolgen: Back up the phone system partition.

-
- -

Windows

- -
-

Bitte Beachten: Es müssten möglicherweise USB-Treiber für Windows installiert werden. Eine Anleitung befindet sich in der folgenden Anleitung “Setting Up the Geeksphone Device” in Pushing Firefox OS Apps to the Geeksphone.

-
- -

Öffne zuerst eine Konsole (Start > Tippe cmd in der Suchfeld > Enter drücken, Unter Windows 7, Windows Taste + X > Wähle Command Prompt unter Windows 8) und wechsel in das Verzeichnis wo sich die entpackten Daten befinden. Führe den folgenden Befehlt aus:

- -
flash.bat
-
- -

Dieser Befehl sollte nun das neue Abbild auf das Telefon flashen. Das Telefon muss nun nochmals erneut aufgesetzt werden, da ja wie zuvor beschrieben alle Daten gelöscht wurden.

- -

Mac OS

- -

Öffnen eines Terminals(Cmd + space -> type terminal -> enter) Fensters und wechsle mit cd in das Verzeichnis wo sich die entpackten Daten befinden. Führe den folgenden Befehlt aus:

- -
./flash_mac.sh
-
- -

Dieser Befehl sollte nun das neue Abbild auf das Telefon flashen. Das Telefon muss nun nochmals erneut aufgesetzt werden, da ja wie zuvor beschrieben alle Daten gelöscht wurden.

- -

Linux

- -

Um ein Keon unter Ubuntu zu fläschen müssten die folgenden Regeln in  /etc/udev/rules.d/51-android.rules hinzugefügt werden:

- -
SUBSYSTEM=="usb", ATTR{idVendor}=="05c6", ATTR{idProduct}=="8013", MODE="0666"
- -
SUBSYSTEM=="usb", ATTR{idVendor}=="18d1", ATTR{idProduct}=="d00d", MODE="0666"
- -
 
- -

Öffne nun ein Terminal (control-alt-t unter Ubuntu) Fehnster und welche in das Verzeichnis wo sich die entapckten Daten befinden. Führe den folgenden Befehl aus:

- -
./flash.sh
-
- -

Dieser Befehl sollte nun das neue Abbild auf das Telefon flashen. Das Telefon muss nun nochmals erneut aufgesetzt werden, da ja wie zuvor beschrieben alle Daten gelöscht wurden.

- -
-

Ein anderer Weg das Keon unter Ubuntu zu aktualisieren ist der folgende:-

-
- -

Schritt 1: Das Gerät verbinden

- -

Schritt 2: Ein Terminal öffnen

- -

Schritt 3: Den Befehl  sudo nautilus eintippen und das Root-Passwort eingeben um den Root-Ordner zu öffnen

- -
sudo nautilus
- -
sudo nautilus "root password"
- -

Schritt 4: Kopiere den Download des Firefox O.S Geeks Phone Builds in das Root-Verzeichnis

- -

Schritt 5: Klicke auf die Datei mit dem Namen "flash.sh"

- -
./flash.sh
- -

 

- -

If you have an 'unagi' or developer preview phone that is not a Geeksphone

- -

If you have a developer phone that is not a Geeksphone such as an 'unagi' or a previously Android-based device, you may need to perform the following steps. If this is not you, please skip to the next section.

- -

You will need to install adb and fastboot. These utilities can be found in the Android Developer Toolkit.

- -

It is not necessary to install the entire toolkit. Download the toolkit from here and extract the contents. adb and fastboot are found in the /platform-tools/ folder. They can be copied to the /usr/bin of your Linux or Mac OS machine, or copied to another folder as long as that folder is added to your $PATH.

- -

If you are attempting to flash your device and have another device plugged in via USB, your phone may not be detected by these utilities correctly. Only have your phone plugged in while trying to flash it.

- -

Tweaking Gaia

- -

If you are the industrious sort, you may want to tweak the default applications in Gaia — the UI in Firefox OS. In this section we will cover some of the basics for cloning Gaia and making changes to the default system apps. Bear in mind these tips are “at your own risk” and may involve you later referring to the section “Ok, I bricked my phone”. Before proceeding make sure that you have adb and fastboot installed on your system. To verify if these are installed open a terminal and type adb devices with your phone connected. You should see your phone listed under the attached devices.

- -

You should also be able to run fastboot from the terminal. If you run fastboot, a set of parameter options should be displayed. If you do not have adb or fastboot installed, a quick Google search with your operating system will return several quick starts on how to install them. In addition to adb and fastboot you will need Git. If you do not currently have Git installed, have a look at this setup guide. Finally make sure your phone is set up for remote debugging as described in the previous section.

- -

Once you have the prerequisites you can open a terminal and cd to the directory you would like to clone the Gaia source code to. Type the following commands:

- -
git clone git://github.com/mozilla-b2g/gaia.git gaia
-cd gaia
-
- -

This will clone the current Gaia code to your system.

- -
-

If you plan on submitting changes back to the Gaia source, be sure to fork the source before cloning as described in Hacking Gaia.

-
- -

Currently the Geeksphone Keon uses the v1.0.1 branch of Gaia code, so set the proper branch using the following command before you do anything else:

- -
git checkout -b v1.0.1 origin/v1.0.1
-
- -

Most of the system apps are located in the apps subdirectory of gaia. You can now make any changes to these Firefox OS apps you wish. Once you have made changes, make sure your device is mounted properly by first running:

- -
adb remount
- -

Next, run the following command to push the modified apps to your phone. This will by default push all the system apps to the phone:

- -
B2G_SYSTEM_APPS=1 make install-gaia
-
- -

If you only changed one of the apps you can specify the particular app using similar syntax. In this example only the calendar app will be pushed to the phone:

- -
APP=calendar B2G_SYSTEM_APPS=1 make install-gaia
-
- -

If you have issues while making the changes, you can reset the phone to default values using either of the following commands:

- -
make production
-make reset-gaia
-
- -
-

Note: Bear in mind that either of the above commands will clear any data or apps that you have pushed to the phone. If you want to back up your data and restore afterwards, you can follow the instructions at Back up the phone system partition.

-
- -

"Ok, 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 a simple procedure. The following illustrates resetting the Keon but other phones should have a similar process. You will also need to verify that you have fastboot and ADB installed (try typing fastboot and adb in the command line if you are not sure).

- -
    -
  1. Remove the USB cable and then remove the battery from the phone for 30 seconds.
    2. -
  2. Reinsert the battery and hold down the volume up and power buttons at the same time, for a few seconds, until the system recovery menu appears.
    3. -
  3. Reconnect the USB cable
    4. -
  4. Type in the command run adb reboot bootloader.
    5. -
  5. When the phone reboots and starts to show the Geeskphone logo, you are now in fastboot mode; run the following commands from a terminal window in the directory that contains the latest img files described in the first section of this post:
    6. -
- -
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.

- -

Go play!

- -

We hope these instructions are useful to you, and naturally we want you to be as happy about Firefox OS and the possibilities as we are! Feel free to play around with updating your devices, make changes/updates to Gaia apps, and also be inspired to build you own open web apps.

- -

See also

- - diff --git a/files/de/archive/b2g_os/phone_guide/index.html b/files/de/archive/b2g_os/phone_guide/index.html deleted file mode 100644 index 472fcd195f..0000000000 --- a/files/de/archive/b2g_os/phone_guide/index.html +++ /dev/null @@ -1,44 +0,0 @@ ---- -title: Firefox OS developer phone guide -slug: Archive/B2G_OS/Phone_guide -tags: - - B2G - - Firefox OS - - NeedsTranslation - - Phones - - TopicStub -translation_of: Archive/B2G_OS/Phone_guide ---- -
-

This section contains developer information relevant to specific phones that run Firefox OS. We have general information available on Building and installing Firefox OS and Hacking Firefox OS, so please go there for information about building and installing the platform from scratch. Developers with specific phones in their possession may however find the following articles useful.

-
-

Specific device information

-
-
- Firefox OS phone data
-
- In this article we list the various available Firefox OS phones along with information such as their code names, availability, and specific hardware features.
-
- Geeksphone
-
- In this article we cover some basic tips on how to keep your Geeksphone up-to-date and how to tweak the system Gaia applications.
-
- The Firefox OS ZTE OPEN
-
- This article exists to share the information we have available on the ZTE OPEN Firefox OS device.
-
-

General Firefox OS information

-
-
- General device features
-
- This page lists typical Firefox OS hardware features and minimum hardware requirements.
-
- Troubleshooting
-
- This article provides tips for resolving common problems you may have while using Firefox OS.
-
- Best practices for open reference devices
-
- A set of best practices that we believe should come highly recommended for any widely available open reference devices. All of the recent Firefox OS reference devices have followed these practices.
-
diff --git a/files/de/archive/b2g_os/phone_guide/phone_specs/index.html b/files/de/archive/b2g_os/phone_guide/phone_specs/index.html deleted file mode 100644 index 8cf863e090..0000000000 --- a/files/de/archive/b2g_os/phone_guide/phone_specs/index.html +++ /dev/null @@ -1,800 +0,0 @@ ---- -title: Firefox OS Geräte und Spezifikationen -slug: Archive/B2G_OS/Phone_guide/Phone_specs -tags: - - Firefox OS - - Gerät - - Handy - - Smartphone -translation_of: Archive/B2G_OS/Phone_guide/Phone_specs ---- -
-

Dieser Artikel enthält Informationen über Firefox OS Geräte und deren Spezifikationen, Code-Namen, standardmäßig installierten FIrefox OS Versionen und mehr.

-
- -

Verfügbare Firefox OS Smartphones

- -

Die folgende Tabelle enthält Informationen zu den verfügbaren und ehemals verfügbaren Firefox OS Smartphones.

- -
-

Hinweis: Nähere Informationen zu den verfügbaren Firefox OS Smartphones und die Länder, in denen sie verfügbar sind, findest Du auf Firefox OS devices.

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

Name / Code-Name

- 		-

Datum der Veröffentlichung

- 		FxOS
- version		VerfügbarkeitWeitere Informationen
-

Alcatel One Touch Fire

- -

hamachi, buri

- 		12. Juli 20131.0.1Zur Zeit verfügbarVerfügbar in Brasilien, Uruguay, Italien, Deutschland, Griechenland, Serbien, Ungarn und Polen.
- Erhältlich auf eBay.
Alcatel One Touch Fire E18. Juli 20141.3.0Zur Zeit verfügbarVerfügbar in Tschechien, Deutschland, Ungarn, Polen, Russland.
otoro, unagi, inari   nicht erhältliche ZTE Entwicklermodelle, Vorgänger des ZTE Open.
-

ZTE Open

- -

ikura

- 		2. Juli 20131.0.1Zur Zeit verfügbarBaugleich mit inari, erhältlich auf eBay.
-

LG Fireweb

- -

leo

- 		24. Oktober 20131.1Zur Zeit verfügbarVerfügbar in Brasilien.
-

Geeksphone Keon

- -

keon

- 		24. April 20131.0.1 -

Zur Zeit nicht verfügbar

- 		Nur für Entwickler
-

Geeksphone Peak

- -

peak

- 		24. April 20131.0.1Zur Zeit nicht verfügbarehemaliger Code-Name "twist", nur für Entwickler
Geeksphone Peak+---gestoppt
Geeksphone Revolution4. März 20141.3preZur Zeit verfügbarOnline erhältlich
-

LG Google Nexus 4

- -

nexus-4

- 		   Test-Gerät. Weder von LG noch von Google unterstützt. Nicht mehr unterstützte Hardware.
-

Flame

- -

Mozillas Referenz-Gerät

- 		April 20141.3  -

Auf Vorbestellung erhältlich

- -

Ausverkauft seit Dezember 2014

-
-

Spreadtrum

- -

tarako

- 		Ende Q2 2014? Demnächst verfügbar 
ZTE Open C13. Mai 20141.3Zur Zeit verfügbarOnline erhältlich
Symphony GoFox F1516. September 20141.4Zur Zeit verfügbarNur in Bangladesch erhältlich bei Grameenphone Vertriebspartnern
Intex Cloud Fx 1.3 Nicht mehr verfügbar 
Spice Fire One (Mi-FX1) 1.3 Nicht mehr verfügbar 
Alcatel OneTouch Fire C 4020D1. Oktober 20141.3 Nicht mehr verfügbar 
Zen U105 Fire16. Oktober 20141.3 Zur Zeit verfügbarErhältlich auf Homeshop18, Indien
Cherry Mobile AceNovember 20141.3TZur Zeit verfügbarErhältlich auf den Philippinen.
Fx0Dezember 20142.0Zur Zeit verfügbarErhältlich in Japan (KDDI.)
Orange Klif20152.0Zur Zeit verfügbarErhältlich in vielen afrikanischen Ländern.
ZTE Open C220152.1Zur Zeit verfügbarOnline erhältlich
- -

Firefox OS Versionen

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Version -

Feature Complete (FC) Datum

- 		Release To Partner
- (RTP) Datum		CodenameGecko VersionEnthaltene Security FixesRelease Infos
1.022. Dezember 201221. Februar 2013TEFGecko 18Gecko 18 
1.0.115. Januar 20136. September 2013ShiraGecko 18Gecko 20Entwickler
- Anwender
1.129. März 20139. Oktober 2013LeoGecko 18+ (new APIs)Gecko 23Entwickler
- Anwender
1.1.1 TBDHDWie 1.1.0 mit WVGAGecko 23 
1.215. September 20139. Dezember 2013KoiGecko 26[39]Gecko 26Entwickler
- Anwender
1.39. December 2013TBD Gecko 28Gecko 28Entwickler
- Anwender
1.417. März 2014TBD Gecko 30Gecko 30Entwickler
- Anwender (TBD)
2.0TBDTBD Gecko 32Gecko 32Entwickler
- Anwender (TBD)
2.1Januar 2015?TBD Gecko 34Gecko 34Entwickler
2.2Juni 2015TBD Gecko 37Gecko 37Entwickler
2.5November 2015TBD TBDTBD 
- -

Geräte-Spezifikationen

- -

Bitte beachte, dass wir in einigen Fällen bereits vor öffentlicher Verfügbarkeit eines angekündigten Gerätes dessen Code-Namen und einige seiner Eigenschaften hier veröffentlichen. Bitte FÜGE KEINE zusätzlichen Informationen zu diesen Geräten hinzu bevor Andreas Gal oder jemand vergleichbares diese Informationen veröffentlicht hat. Im Zweifelsfall wende Dich bitte an den Firefox OS Program Manager.

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
NameVersionenAuflösungDisplay (Inches)CPUKamera(s), MpxRAMROMSpeicherBatterie (mAh)
-

Alcatel One Touch Fire

- -

hamachi, buri

- 		v1.0.1/v1.1 -

320 x 480
- PX=1

- 		3.5Qualcomm Snapdragon S1 MSM7227A 1 GHzRückseite: 3.2256MB512MB/data: wahrscheinlich identisch mit inari; laut Hersteller 160MB Speicher für Anwendungen;
- Wahrscheinlich kein interner DeviceStorage, MicroSD Karte (max. 32GB) benötigt
-  		1400
Alcatel One Touch Fire Ev1.3.0540 x 9604.5Qualcomm Snapdragon 200
- MSM8210
- 1.2 GHz
- dual-core		Rückseite: 5.0512MB   
-

ZTE Open / variants

- -

ikura

- 		v1.0.1 (as shipped)320 x 480
- PX=1		3.5Qualcomm Snapdragon S1 MSM7225A 800 MHzRückseite: 3.2256MB512MB -

/data: 152M
- Kein interner DeviceStorage, MicroSD Karte benötigt

- 		1200
-

LG Fireweb

- -

leo

- 		v1.1320 x 480
- PX=1		4Qualcomm  Snapdragon S1 MSM7227A 1 GHzRückseite: 5.0512MB4GB -

/data: 1007.90M
- interner DeviceStorage: ja, Größe ungewiss, möglicherweise 3.7G, könnte aber auch eine falsche Berechnung sein. Der Wert von /sys/devices/platform/msm_sdcc.3/mmc_host/mmc0/mmc0:0001/block/mmcblk0/block ist 7733248, bei einer angenommenen Blockgröße von 512 byte kommen wir auf 3.7G.

- 		1540
-

Geeksphone Keon

- -

keon

- 		-

v1.0.1 - nightly
- downloads here

- 		320 x 480
- PX=1		3.5Qualcomm Snapdragon S1 7225AB 1 GHzRückseite: 3.0512MB4GB -

/data: 1.5G
- interner 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 -

Frontseite: 2.0
- Rückseite: 8.0

- 		512MB4GB/data: 1.5G
- interner 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 -

Frontseite: 1.3 Rückseite: 8.0

- 		1GB4GB -

/data: 2G
- interner 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

- 		Rückseite: 8.02GB8 or 16GBHier wird alles in einem ziemlich undurchsichtigen Bereich gespeichert, es gibt keinen externen Speicher (MicroSD).  Die Größe des Bereichs variiert je nach dem, welches Nexus 4 Modell Du hast.2100
-

Foxconn InFocus

- -

flatfish

- 		 1280 x 80010Allwinner A31, Cortex A7 Quad-Core 1.0 GHz -

Frontseite: 2.0
- Rückseite: 5.0

- 		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 (nur Rückseite?)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 -

Frontseite: 0.3 Rückseite: 2.0

- 		1GB8GB  
-

Flame

- -

Mozillas Referenz-Gerät

- 		v1.3 -

FWVGA
- 854 × 480
- PX=1.5
-  

- 		4.5 capacitive touch -

Qualcomm Snapdragon 200 MSM8210, 1.2GHZ Dual core processor

- 		-

Frontseite: 2.0
- Rückseite: 5.0 Auto-Fokus und Blitz
-  

- 		256MB–1GB (adjustable by developer)8GB32GB micro SD card (USB 2.0)1800
ZTE Open Cv1.3800 x 4804Qualcomm Snapdragon 200 MSM8210, 1.2GHZ Dual core processorRückseite: 3.0512MB4GB -

/data: 1G

- 		1400
Symphony GoFox F15v1.4320 x 480
- PX=?		3.5Spreadtrum 1 GHz Single Core ProcessorFrontseite: 0.3
- Rückseite: 3.2 mit Blitz		512MB512MB 1450
Intex Cloud FxV 1.3320 x 4803.5Spreadtrum 1 GHzRückseite: 2.0 ohne Blitz128 MB256MB -

Data : 2G

- -

Interner Speicher: 46 MB (User Memory)

- -

Externer Speicher (Micro SD Card): max. 4GB

- 		1250
Spice Fire One (Mi-FX1)V 1.3320 x 4803.5Spreadtrum 1 GHz -

Frontseite: VGA

- -

Rückseite: 1.3

- 		128 MB512MB -

Data : 2G

- -

Interner Speicher: 67.9 MB (User Memory)

- -

Externer Speicher (Micro SD Card): max. 4GB

- 		1400
Alcatel OneTouch Fire C 4020DV 1.3320 x 4803.5Spreadtrum 1 GHz 128 MB256MB -

Data : 2G

- -

Interner Speicher : 65 MB (User Memory)

- -

Externer Speicher (Micro SD Card): max. 32GB

- 		1000
Zen U105 FireV 1.3320 x 4803.5Spreadtrum 1 GHz -

Frontseite: VGA

- Rückseite: 2.0		128 MB256MB -

Data : 2G

- -

Externer Speicher (Micro SD Card): max. 16GB

- 		1200
Fx0V 2.01280 x 7204.7Qualcomm Snapdragon S4 MSM8926 1.2GHz quad-core -

Frontseite: 8.0

- -

Rückseite: 2.1

- 		1.5 GB16GBmicroSDXC Karte: max. 64GB2370
Orange KlifV 2.0480 x 3203.5MediaTek dual-core 1Ghz MT6572MRückseite: 2.0256MB512MBTBC1300
ZTE Open C 2V 2.1WVGA4.0Spreadturn  SC7715 1GBRückseite: 2.0512MB4GBExterner Speicher (Micro SD Card): max. 32GB1400
- -

Anmerkungen zu den Spalten:

- - diff --git a/files/de/archive/b2g_os/phone_guide/zte_open_c/index.html b/files/de/archive/b2g_os/phone_guide/zte_open_c/index.html deleted file mode 100644 index 7b74fddbf2..0000000000 --- a/files/de/archive/b2g_os/phone_guide/zte_open_c/index.html +++ /dev/null @@ -1,82 +0,0 @@ ---- -title: ZTE OPEN C -slug: Archive/B2G_OS/Phone_guide/ZTE_OPEN_C -tags: - - Update - - Upgrade - - ZTE Open C - - reagiert nicht mehr -translation_of: Archive/B2G_OS/Phone_guide/ZTE_OPEN_C ---- -
-

Das ZTE Open C Firefox OS Handy ist ein fortgeschrittenes Firefox OS Gerät von ZTE das über bessere Hardware verfügt, die unter anderem eine 3MP Kamera und einen 4-inch WVGA Display umfasst und bei dem Firefox OS 1.3 vorinstalliert ist. Dieser Artikel enthält Informationen über das Gerät, darunter Anleitungen zum Updaten und zur Fehlerbeseitigung.

-
-
-

Bitte Beachten: Diese Anleitungen sind nicht für das ZTE Open. Wenn Sie ein ZTE Open haben, sollten Sie stattdessen zu unterer ZTE Open Seite gehen.

-
-
-

Bitte beachten: Das Upgrade-Programm welches Sie benötigen, um das Handy zu entsprechen (s.u.) ist derzeit nur für Windows erhältlich. Kaufen Sie das Handy nicht, wenn Sie nicht über ein Windows-System verfügen und trotzdem selbst Ihre eigenen Versionen von Firefox OS installieren wollen.

-
-

Das ZTE Open C ist das erste Handy mit dem jüngsten update für Firefox OS. Es bietet viele neue Funktionen, darunter den Direktzugriff auf den Musikplayer vom Sperrbildschirm oder dem Benachrichtigungsfeld aus und Bluetooth sharing, mit dem dem Sie mehrere Dateien gleichzeitig übertragen können. Nutzer können jetzt schneller durch die Menüs navigieren mithilfe von intelligenten Ordnern, die automatisch Apps oder die Suche nach Apps nach Kategorien ordnen mit verbesserter Geschwindigkeit beim Scrollen und einem schnelleren Start von Systen-Apps wie Kalender, Addressbuch und Kamera.

-

Der Kauf eines Geräts

-

Das Gerät kostet US$99.99, es ist bei eBay erhältlich:

- -
-

Bitte beachten: Sie erhalten das Gerät ohne dass irgendwelche Netzwerk-spezifischen Apps oder Dienste installert wären. Es handelt sich um eine entsperrte, global erhältliche Variante, die für early Adopters gedacht ist.

-
-

Einzelheiten zum Handy

-

Siehe Phone and device specs.

-

Wie Sie Firefox OS upgraden

-

Der einfachste Weg, um die Software Ihres Open C upzugraden ist es, die Dateien von der ZTE-Webseite zu verwenden. Um die richtige Datei zu finden, gehen Sie zu ZTE's Software support page, wählen Sie Ihre Region aus der Liste auf der linken Seite, wählen Sie Smart Phones in der mittleren Liste und Open C(European Standard) bzw. Open C(American Standard), je nachdem, wo Sie das Gerät gekauft haben. Klicken Sie dann auf Selected um zu Ihrer Download-Seite zu gelangen.

-

Sobald Ihr Download beendet ist, finden Sie ein PDF in der ZIP-Datei, das Ihnen erklärt, wie das Upgrade zu installieren ist.

-

"Manuelle" Updates

-

Wenn Sie selbst Gecko oder Gaia updaten wollen, ist der Vorgang etwas verzwickter, weil das Handy standardmäßig gesperrt ist und Sie keinen Root-Zugang haben. Um das Gerät zu entsperren, können Sie folgendes Programm von comebuy.com benutzen:Open_C_upgrade_Tool. Durch die Installation dieses Programms wird die Fimware Ihres Geräts so verändert, dass der Root-Zugang Fastboot aktiviert werden und Sie die Möglichkeit haben, Ihr Telefon mit neuen Softwarekomponenten zu flashen.

-
-

Bitte beachten: Dieses Upgrade-Programm ist derzeit nur für Windows verfügbar.

-
-

Gecko und Gaia upgraden

-

Sobald Sie Fastboot aktiviert haben, können Sie neue Firefox OS/B2G Gecko und Gaia Komponenten erstellen und installieren: build and install new Firefox OS/B2G.

-
    -
  1. Beginnen Sie mit folgender Anleitung: build prerequisite, wobei Sie das Open C zum Zwecke der Konfiguration wie ein Flame behandeln: Beide, Flame und Open C basieren auf dem Android Jellybean Basissystem.
    2. -
  2. Während der Konfiguration müssen Sie ein sog. "Custom Manifest File" für das Open C referenzieren. Laden Sie den Anhang zur Fehlermeldung auf folgender Seite herunter: Download the attachment on this bug und speichern Sie ihn an einem Ort auf ihrem Computer, den Sie leicht wiederfinden unter dem Dateinamen openc.xml.
    3. -
  3. Räumen Sie das B2G Verzeichnis auf und löschen Sie nicht benötigte Unterverzeichnisse:
    - 
    rm -rf objdir-gecko/ out/ backup-flame/
    -
    4. -
  4. Konfigurieren Sie jetzt Firefox OS mit dem nachfolgenden Befehl:
    - 
    ./config.sh flame /PATH/TO/openc.xml
    -
    5. -
  5. Sie können jetzt die Gecko Komponenten mit den nachfolgenden Befehlen bauen und auf Ihr Gerät flashen: - 
    ./build.sh gecko
-./flash.sh gecko
    -
    6. -
  6. Jetzt sollten Sie auch Gaia upgraden, damit die upgegradete Version von Gecko mit der Gaia-Version auf Ihrem Gerät zusammenarbeietet: - 
    cd gaia
-make reset-gaia
    -
    7. -
-
-

Achtung: Der Versuch, ein Image für das Flame auf Ihr Gerät zu flashen würde dieses unbrauchbar machen, weswegen hiervon abgeraten wird.

-
-

Gaia upgraden

-

Wenn Sie nur ein Update von Gaia und nicht auch von Gecko durchführen wollen, müssen Sie zunächst das Gaia Repo auf Github forken und klonen und das Ergebnis auf Ihr Gerät flashen.

-
    -
  1. Stellen Sie sicher dass ADB installiert ist.
    2. -
  2. Gehen Sie zu https://github.com/mozilla-b2g/gaia, klicken Sie dann auf den "fork" button in der oben rechten Ecke um in Ihr eigenes Repo zu forken.
    3. -
  3. Klonen Sie den Code von ihrem geforkten Repo auf Ihren eigenen Rechner, indem Sie folgenden Befehl ausführen: - 
    git clone https://github.com/your-github-username/gaia.git
    -
    4. -
  4. Wechseln Sie in das hierdurch erstellte Verzeichnis.
    5. -
  5. Schalten Sie auf ihrem Gerät remote debugging ein (wählen Sie die ADB und Devtools option).
    6. -
  6. Verbinden Sie jetzt Ihr Handy per USB mit Ihrem Computer, stellen Sie sicher, dass das Gerät erkannt wird, indem Sie den Befehl adb devices im terminal eingeben.
    7. -
  7. Führen Sie folgenden Befehl aus, um Ihr Handy neu zu starten und es mit dem neuesten Gaia Sourcecode upzudaten - 
    make reset-gaia
    -
    8. -
-

Mein Handy reagiert nicht mehr

-

Wenn Ihr Gerät nicht mehr reagiert, ist es unter Umständen möglich, es mit der unter  ZTE Open C user manual auf der Webseite von ZTE verfügbaren Anleitung und der  Anleitung auf dieser Seite wieder zum  Leben zu erwecken.

-

Weitere Informationen sind unter Umständen hier: reference this support entry verfügbar.

diff --git a/files/de/archive/b2g_os/platform/app_architektur/index.html b/files/de/archive/b2g_os/platform/app_architektur/index.html deleted file mode 100644 index 315efb5b4e..0000000000 --- a/files/de/archive/b2g_os/platform/app_architektur/index.html +++ /dev/null @@ -1,29 +0,0 @@ ---- -title: Firefox OS App-Architektur -slug: Archive/B2G_OS/Platform/App_Architektur -tags: - - Anleitung - - Apps - - B2G - - Firefox OS -translation_of: Archive/B2G_OS/Platform/Apps_architecture ---- -
-

Dieser Artikel beschreibt die Details, wie Apps in Firefox OS gestartet und verwaltet werden. Diese Informationen sind hilfreich sowohl für Firefox OS-Plattformentwickler als auch für Gruppen, die das Betriebssystem auf neue Hardware portieren. Als App-Entwickler benötigt man diesen Artikel nicht unbedingt, aber er könnte trotzdem interessant sein.

-
-

Der App-Startprozess

-

Wenn der Nutzer eine App, die er starten möchte, auswählt oder eine App auf andere Weise gestartet werden soll, startet die  Home-Screen-App, indem sie sich eine App-Referenz von der {{domxref("App")}}-API holt  und dann die Methode {{domxref("App.launch()")}} aufruft, um die App zu starten.

-

Gecko empfängt diese Anforderung und sendet das {{domxref("mozChromeEvent")}} mit den App-Details zur System-App. Die System-App verarbeitet dieses Ereignis, indem sie ein neues {{HTMLElement("iframe")}}-Element in den DOM-Baum einfügt und die App in dieses neue {{HTMLElement("iframe")}}-Element lädt. Dieser Rahmen ist dann die Heimat der App, bis sie beendet wird.

-

Jede App benötigt ein Manifest, das sie beschreibt, und hat eine spezielle Dateihierarchie im Paket. Details stehen im Artikel App manifest.

-

Kommunikation mit Gecko

-

Die Kommunikation zwischen Gecko und Gaia's System-App passiert über {{domxref("mozChromeEvent")}} und {{domxref("mozContentEvent")}}. mozChromeEvents werden von Chrome zum Inhalt und mozContentEvents vom Inhalt zu Chrome gesendet. Diese Kommunikation wird benutzt, um die Erzeugung und das Schließen der vertrauten Benutzeroberfläche zu steuern und die benötigten Funktionen für Benachrichtigungen und andere Aufgaben bereitzustellen, dazu gehört auch, der System-App mitzuteilen, dass eine App gestartet werden soll.

-
-

Anmerkung: Mehr dazu, wie diese Ereignisse funktionieren, findet man in der System-App-Dokumentation. Eine andere Quelle, wie man die Ereignisse benutzt, findet man im Quellcode in {{source("b2g/chrome/content/shell.js")}}.

-
-

See also

- diff --git a/files/de/archive/b2g_os/platform/architektur/index.html b/files/de/archive/b2g_os/platform/architektur/index.html deleted file mode 100644 index c438e89c9f..0000000000 --- a/files/de/archive/b2g_os/platform/architektur/index.html +++ /dev/null @@ -1,740 +0,0 @@ ---- -title: Firefox OS Architektur -slug: Archive/B2G_OS/Platform/Architektur -translation_of: Archive/B2G_OS/Architecture ---- -
-

Dieser Artikel gibt eine Übersicht über die Architektur der Firefox OS Plattform und beschreibt die grundlegenden Konzepte und wie die einzelnen Komponenten prinzipiell zusammen arbeiten.

-
- -
-

Hinweis: Bitte denke daran, dass Firefox OS noch nicht veröffentlicht ist. Die hier beschriebene Architektur ist möglicherweise noch nicht endgültig und es können sich noch ein paar Dinge ändern.

-
- -

Firefox OS Begriffserklärungen

- -

Einige Begriffe solltest Du kennen, bevor Du die Dokumentation von Firefox OS liest.

- -
-
B2G
-
Kurzform von "Boot to Gecko"
-
Boot to Gecko
-
Der interne Code-Name für das Firefox OS Betriebssystem. Du wirst diesen Begriff häufig als Synonym für Firefox OX finden, weil dieser Code-Name schon lange genutzt wurde bevor das Projekt einen offiziellen Namen hatte.
-
Firefox OS
-
Firefox OS stellt im Grunde das Mozilla Branding (und das von OEM Partnern) und verschiedene Support-Programme über der Boot to Gecko Ebene bereit, um aus den einzelnen Komponenten ein marktfähiges Produkt zu machen.
-
Gaia
-
Das ist die Benutzeroberfläche (User Interface) der Firefox OS Plattform. Alles, was nach dem Start von Firefox OS auf dem Bildschirm zu sehen ist wird von der Gaia Schicht erzeugt. Gaia implementiert den Sperrbildschirm, die Startseite und alle Apps, die man von einem modernen Smartphone erwartet. Die Gaia Schicht wurde vollständig in HTML, CSS und JavaScript geschrieben. Gaia kommuniziert mit dem darunter liegenden Betriebssystem ausschließlich über offene Web APIs, die durch Gecko bereit gestellt werden. Anwendungen von Drittanbietern können neben Gaia installiert werden.
-
Gecko
-
Gecko ist die Laufzeitumgebung von Firefox OS. Diese Schicht stellt alles zur Verfügung, was für die drei offenen Standards HTML, CSS und JavaScript benötigt wird. Gecko stellt sicher, dass diese APIs auf jedem von Gecko unterstützten Betriebssystem gut funktionieren. Zu diesem Zweck beinhaltet Gecko unter anderem Netzwerk-, Grafik- und Layoutstacks sowie eine Virtuelle Maschine für JavaScript und Schichten für die Portierung.
-
Gonk
-
Gonk ist eine tiefer liegende Schicht des Firefox OS Betriebsystems, bestehend aus dem Linux Kernel (basierend auf dem Android Open Source Project (AOSP)) und der Hardware-Abstraktionsschicht (hardware abstraction layer, HAL). Der Linux Kernel und einige der Anwendungs-Bibliotheken sind allgemeine Open Source Projekte: Linux, libusb, bluez und andere. Einige Pakete des HAL sind Gemeinschafts-Projekte mit AOSP: GPS, Kamera und andere. Man könnte sagen, Gonk ist eine sehr einfache Linux Distribution. Gonk ist ein Port von Gecko. Das heißt, es gibt einen Port von Gecko zu Gonk, so wie es Ports von Gecko zu Mac OS X, Windows und Android gibt. Seit das Firefox OS Projekt die alleinige Kontrolle über Gonk hat können wir Schnittstellen zu Gecko entwickeln, die auf anderen Betriebssystemen nicht möglich sind. Zum Beispiel hat Gecko auf Gonk direkten Zugriff zur gesamten Telefonie-Einheit und zum Display Frame Buffer. Auf anderen Betriebssystemen ist dies nicht möglich.
-
Jank
-
Dieser im Bereich der mobilen Web Apps häufig genutzte Begriff bezeichnet den Effekt von langsamem und ineffizientem Code in einer App, wodurch die Aktualisierung der Benutzeroberfläche blockiert wird und diese nur noch langsam oder überhaupt nicht mehr reagiert. Unsere Gaia Entwickler nutzen verschiedene Optimierungs-Techniken, um diese Probleme unter allen Umständen zu verhindern.
-
- -

Overall architecture

- -

The following figure compares architectures between proprietary platforms and Firefox OS.

- -

on the left is a native mobile architecture stack, on the right is the Firefox OS architecture. they are similarm except that the native stack is all proprietary device functionality, and the Firefox OS stack is all done with open source and web technologies.

- -

Firefox OS eliminates the native API layer between the operating system and application layers. This integrated design reduces platform overhead and simplifies security without sacrificing performance or a rich user smart phone experience.

- -
    -
  1. Gaia is the core web apps of the device, and user interface layer, all written in HTML5, CSS and JavaScript, with a number of exposed APIs to allow the UI code to interact with the phone hardware and Gecko functionality.
    2. -
  2. Gecko is the web engine and presentation layer in Firefox OS that connects hardware to HTML by serving as the interface between web content and the underlying device. Gecko provides an HTML5 parsing and rendering engine, programmatic access to hardware functionality via secure web APIs, a comprehensive security framework, update management, and other core services.
    3. -
  3. Gonk is the kernel-level component in the Firefox OS stack that serves as the interface between Gecko and the underlying hardware. Gonk controls the underlying hardware and exposes hardware capabilities to Web APIs implemented in Gecko. Gonk can be seen as the “black box” that does all the complex, detailed work behind the scenes to control the mobile device by enacting requests at the hardware level.
    4. -
  4. The mobile device is the mobile phone hardware running Firefox OS. The OEM (Original Equipment Manifacturer) is responsible for providing the mobile device.
    5. -
- -

Specific Firefox OS architecture

- -

Firefox OS Architecture

- -

Firefox OS bootup procedure

- -

This section describes the process by which Firefox OS devices boot, what parts are involved, and where. As a quick reference, the general system bootup flow goes from bootloaders in the Kernel space, to init in the native code, to B2G and then Gecko in the user space, and then finally to the system app, window manager, then homescreen app inside Gecko. This is what all other apps are executed on top of.

- -

- -

The bootstrapping process

- -

When a Firefox OS device is first turned on, execution begins in the primary bootloader. From there, the process of loading the main operating system proceeds in the typical way; a succession of increasingly higher-level bootloaders bootstrap the next loader in the chain. At the end of the process, execution is handed off to the Linux kernel.

- -

There are a few points worth noting about the boot process:

- - - -

The Linux kernel

- -

The Linux kernel(s) used by Gonk is very similar to the upstream Linux from which it's derived (based on the Android Open Source Project). There are a few changes made by the AOSP that have not yet been upstreamed. In addition, vendors sometimes modify the kernel and upstream those changes on their own schedule. In general, though, the Linux kernel is close to stock.

- -

The startup process for Linux is well-documented elsewhere on the Internet, so this article won't cover that.

- -

The Linux Kernel will bring up devices and run essential processes. It will execute processes defined in init.rc and the successor init.b2g.rc to boot essential process such as b2g (FirefoxOS basic process, containing Gecko) and rild (telephony related process that might proprietary by different chipsets) — see below for more details. At the end of the process, a userspace init process is launched, as it is in most UNIX-like operating systems.

- -

Once the init process is launched, the Linux kernel handles system calls from userspace, and interrupts and the like from hardware devices. Many hardware features are exposed to userspace through sysfs. For example, here's a code snippet that reads the battery state in 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);
-}
- -

More on the init process

- -

The init process in Gonk handles mounting the required file systems and spawns system services. After that, it stays around to serve as a process manager. This is quite similar to init on other UNIX-like operating systems. It interprets scripts (that is, the init*.rc files) that consist of commands describing what should be done to start various services. The Firefox OS init.rc is typically the stock Android init.rc for that device patched to include the things required to kick-start Firefox OS, and varies from device to device.

- -

One key task the init process handles is starting up the b2g process; this is the core of the Firefox OS operating system.

- -

The code in init.rc that starts this up looks like this:

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

Note: Exactly how much init.rc differs from the Android version varies from device to device; sometimes, init.b2g.rc is simply appended, and sometimes the patches are more significant.

-
- -

The userspace process architecture

- -

Now it's useful to take a high-level look at how the various components of Firefox OS fit together and interact with one another. This diagram shows the primary userspace processes in Firefox OS.

- -

Userspace diagram

- -
-

Note: Keep in mind that since Firefox OS is under active development, this diagram is subject to change, and may not be entirely accurate.

-
- -

The b2g process is the primary system process. It runs with high privileges; it has access to most hardware devices. b2g communicates with the modem, draws to the display framebuffer, and talks to GPS, cameras, and other hardware features. Internally, b2g runs the Gecko layer (implemented by libxul.so). See Gecko for details on how the Gecko layer works, and how b2g communicates with it.

- -

b2g

- -

The b2g process may, in turn, spawn a number of low-rights content processes. These processes are where web applications and other web content are loaded. These processes communicate with the main Gecko server process through IPDL, a message-passing system.

- -

The b2g process runs libxul, which references b2g/app/b2g.js to get default preferences. From the preferences it will open the described HTML file b2g/chrome/content/shell.html, which is compiled within the omni.ja file. shell.html includes b2g/chrome/content/shell.js file, which triggers the Gaia system app.

- -

rild

- -

The rild process is the interface to the modem processor. rild is the daemon that implements the Radio Interface Layer (RIL). It's a proprietary piece of code that's implemented by the hardware vendor to talk to their modem hardware. rild makes it possible for client code to connect to a UNIX-domain socket to which it binds. It's started up by code like this in the init script:

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

rilproxy

- -

In Firefox OS, the rild client is the rilproxy process. This acts as a dumb forwarding proxy between rild and b2g. This proxy is needed as an implementation detail; suffice it to say, it is indeed necessary. The rilproxy code can be found on GitHub.

- -

mediaserver

- -

The mediaserver process controls audio and video playback. Gecko talks to it through an Android Remote Procedure Call (RPC) mechanism. Some of the media that Gecko can play (OGG Vorbis audio, OGG Theora video, and WebM video) are decoded by Gecko and sent directly to the mediaserver process. Other media files are decoded by libstagefright, which is capable of accessing proprietary codecs and hardware encoders.

- -
-

Note: The mediaserver process is a "temporary" component of Firefox OS; it's there to aid in our initial development work, but is expected to go away eventually. This will most likely not happen until Firefox OS 2.0 at the earliest, however.

-
- -

netd

- -

The netd process is used to configure network interfaces.

- -

wpa_supplicant

- -

The wpa_supplicant process is the standard UNIX-style daemon that handles connectivity with WiFi access points.

- -

dbus-daemon

- -

The dbus-daemon implements D-Bus, a message bus system that Firefox OS uses for Bluetooth communication.

- -

Gecko

- -

Gecko, as previously mentioned, is the implementation of web standards (HTML, CSS, and JavaScript) that is used to implement everything the user sees on Firefox OS, and control interactions with the phone hardware. Web apps connect HTML5 to hardware via controlled, secure Web APIs, implemented in Gecko. The Web APIs provide programmatic access to features in the underlying mobile device hardware (such as the battery or vibration), along with data that is stored on, or available to, a device (such as the calendar or contacts). Web content invokes the accessible Web APIs within HTML5.

- -

An app consists of a collection of related HTML5 web content. To build web apps that run on Firefox OS mobile devices, developers simply assemble, package, and distribute this web content. At run time, this web content is interpreted, compiled, and rendered in a web browser. For more information on Apps, see the App Center.

- -
-

Note: To search the Gecko codebase, you could use http://dxr.mozilla.org. It’s more fancy and provides good reference features, but with limited repositories. Or you could try the traditional http://mxr.mozilla.org, which contains more Mozilla projects.

-
- -

Gecko architecture diagram

- -

- - - - - -

b2g/

- -

The b2g folder contains mainly Firefox OS-related functions.

- -
b2g/chrome/content
- -

Contains Javascript files run above the system app.

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

The entry point into Gaia — the HTML for the system app. shell.html pulls in settings.js and shell.js:

- -
<script type="application/javascript;version=1.8" src="chrome://browser/content/settings.js"> </script>
-<script type="application/javascript;version=1.8" src="chrome://browser/content/shell.js"> </script>
- -

settings.js contains system default setting parameters.

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

shell.js is the first script to load in the Gaia system app.

- -

shell.js imports all required modules, registers key listeners, defines sendCustomEvent and sendChromeEvent to communicate with Gaia, and provides webapp install helpers: indexedDB quota, RemoteDebugger, keyboard helper, and screenshot tool.

- -

But the most important function of shell.js is to launch the Gaia system app, then hand over the overall systems related management work to the Gaia system app.

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

This script contains predefined settings, like about:config in browser, and the same as Gaia's pref.js. These settings can be changed from the Settings app, and can be overwritten with Gaia’s user.js in the Gaia build script.

- -

dom/{API}

- -

New API implementations (post-b2g) will be located in dom/. Older APIs will be located in dom/base, for example Navigator.cpp.

- -
dom/apps
- -

.jsm will be loaded — .js API implementations such as webapp.js install, getSelf, etc.

- -
dom/apps/PermissionsTable.jsm
- -

All permissions are defined in PermissionsTable.jsm

- -

dom/webidl

- -

WebIDL is the language used to define web APIs. For supported attributes, read WebIDL_bindings.

- -

hal/gonk

- -

This directory contains files related to the gonk port layer.

- -

Generated files

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

Contains all config files.

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

Contains the pack of styles for resources in the device.

- -

Processing input events

- -

Most action inside Gecko is triggered by user actions. These actions are represented by input events (such as button presses, touches to a touch screen device, and so forth). These events enter Gecko through the Gonk implementation of nsIAppShell, a Gecko interface that is used to represent the primary entrance points for a Gecko application; that is, the input device driver calls methods on the nsAppShell object that represents the Gecko subsystem in order to send events to the user interface.

- -

For example:

- -
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();
-}
- -

These events come from the standard Linux input_event system. Firefox OS uses a light abstraction layer over that; this provides some nice features like event filtering. You can see the code that creates input events in the EventHub::getEvents() method in widget/gonk/libui/EventHub.cpp.

- -

Once the events are received by Gecko, they're dispatched into the DOM by 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);
-}
- -

After that, the events are either consumed by Gecko itself or are dispatched to Web applications as DOM events for further processing.

- -

Graphics

- -

At the very lowest level, Gecko uses OpenGL ES 2.0 to draw to a GL context that wraps the hardware frame buffers. This is done in the Gonk implementation of nsWindow by code similar to this:

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

The FramebufferNativeWindow class is brought in directly from Android; see FramebufferNativeWindow.cpp. This uses the gralloc API to access the graphics driver in order to map buffers from the framebuffer device into memory.

- -

Gecko uses its Layers system to composite drawn content to the screen. In summary, what happens is this:

- -
    -
  1. Gecko draws separate regions of pages into memory buffers. Sometimes these buffers are in system memory; other times, they're textures mapped into Gecko's address space, which means that Gecko is drawing directly into video memory. This is typically done in the method BasicThebesLayer::PaintThebes().
    2. -
  2. Gecko then composites all of these textures to the screen using OpenGL commands. This composition occurs in ThebesLayerOGL::RenderTo().
    3. -
- -

The details of how Gecko handles the rendering of web content is outside the scope of this document.

- -

Hardware Abstraction Layer (HAL)

- -

The Gecko hardware abstraction layer is one of the porting layers of Gecko. It handles low-level access to system interfaces across multiple platforms using a C++ API that's accessible to the higher levels of Gecko. These APIs are implemented on a per-platform basis inside the Gecko HAL itself. This hardware abstraction layer is not exposed directly to JavaScript code in Gecko — this part of the interaction is handled by the Web APIs.

- -

Let's look at the process form a high level. When a user makes a request to use a phone feature (such as dialing a number, accessing a local wifi network, or connecting via Bluetooth), all layers in the Firefox OS technology stack are involved in carrying out the request. Apps and web content in the Gaia layer submits requests to access the underlying device via Web API calls (invoked from within HTML5 functions), which are implemented in Gecko. Gecko in turn submits the request to Gonk. A single request from Gecko can trigger a complex series of operations, initiated and managed by Gonk, in the mobile phone.

- -

How the HAL works

- -

Let's consider the Vibration API as an example. The Gecko HAL for this API is defined in hal/Hal.h. In essence (simplifying the method signature for clarity's sake), you have this function:

- -
void Vibrate(const nsTArray<uint32> &pattern);
- -

This is the function called by Gecko code to turn on vibration of the device according to the specified pattern; a corresponding function exists to cancel any ongoing vibration. The Gonk implementation of this method is in hal/gonk/GonkHal.cpp:

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

This code sends the request to start vibrating the device to another thread, which is implemented in VibratorRunnable::Run(). This thread's main loop looks like this:

- -
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() is the Gonk HAL API that turns on the vibrator motor. Internally, this method sends a message to the kernel driver by writing a value to a kernel object using sysfs.

- -

Fallback HAL API implementations

- -

The Gecko HAL APIs are supported across all platforms. When Gecko is built for a platform that doesn't expose an interface to vibration motors (such as a desktop computer), then a fallback implementation of the HAL API is used. For vibration, this is implemented in hal/fallback/FallbackVibration.cpp.

- -
void Vibrate(const nsTArray<uint32_t> &pattern) {
-}
- -

Sandbox implementations

- -

Because most web content runs in content processes with low privileges, we can't assume those processes have the privileges needed to be able to (for example), turn on and off the vibration motor. In addition, we want to have a central location for handling potential race conditions. In the Gecko HAL, this is done through a "sandbox" implementation of the HAL. This sandbox implementation simply proxies requests made by content processes and forwards them to the "Gecko server" process. The proxy requests are sent using IPDL.

- -

For vibration, this is handled by the Vibrate() function implemented in hal/sandbox/SandboxHal.cpp:

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

This sends a message defined by the PHal interface, described by IPDL in hal/sandbox/PHal.ipdl. This method is described more or less as follows:

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

The receiver of this message is the HalParent::RecvVibrate() method in hal/sandbox/SandboxHal.cpp, which looks like this:

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

This omits some details that aren't relevant to this discussion; however, it shows how the message progresses from a content process through Gecko to Gonk, then to the Gonk HAL implementation of Vibrate(), and eventually to the Vibration driver.

- -

DOM APIs

- -

DOM interfaces are, in essence, how web content communicates with Gecko. There's more involved than that, and if you're interested in added details, you can read about the DOM. DOM interfaces are defined using IDL, which comprises both a foreign function interface (FFI) and object model (OM) between JavaScript and C++.

- -

The vibration API is exposed to web content through an IDL interface, which is provided in nsIDOMNavigator.idl:

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

The jsval argument indicates that mozVibrate() (which is our vendor-prefixed implementation of this non-finalized vibration specification) accepts as input any JavaScript value. The IDL compiler, xpidl, generates a C++ interface that's then implemented by the Navigator class in Navigator.cpp.

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

There's a lot more code in this method than what you see here, but it's not important for the purposes of this discussion. The point is that the call to hal::Vibrate() transfers control from the DOM to the Gecko HAL. From there, we enter the HAL implementation discussed in the previous section and work our way down toward the driver. On top of that, the DOM implementation doesn't care at all what platform it's running on (Gonk, Windows, OS X, or anything else). It also doesn't care whether the code is running in a content process or in the Gecko server process. Those details are all left to lower levels of the system to deal with.

- -

The vibration API is a very simple API, which makes it a good example. The SMS API is an example of a more complex API which uses its own "remoting" layer connecting content processes to the server.

- -

Radio Interface Layer (RIL)

- -

The RIL was mentioned in the section The userspace process architecture. This section will examine how the various pieces of this layer interact in a bit more detail.

- -

The main components involved in the RIL are:

- -
-
rild
-
The daemon that talks to the proprietary modem firmware.
-
rilproxy
-
The daemon that proxies messages between rild and Gecko (which is implemented in the b2g process). This overcomes the permission problem that arises when trying to talk to rild directly, since rild can only be communicated with from within the radio group.
-
b2g
-
This process, also known as the chrome process, implements Gecko. The portions of it that relate to the Radio Interface Layer are dom/system/gonk/ril_worker.js, which implements a worker thread that talks to rild through rilproxy and implements the radio state machine; and the nsIRadioInterfaceLayer interface, which is the main thread's XPCOM service that acts primarily as a message exchange between the ril_worker.js thread and various other Gecko components, including the Gecko content process.
-
Gecko's content process
-
Within Gecko's content process, the nsIRILContentHelper interface provides an XPCOM service that lets code implementing parts of the DOM, such as the Telephony and SMS APIs talk to the radio interface, which is in the chrome process.
-
- -

Example: Communicating from rild to the DOM

- -

Let's take a look at an example of how the lower level parts of the system communicate with DOM code. When the modem receives an incoming call, it notifies rild using a proprietary mechanism. rild then prepares a message for its client according to the "open" protocol, which is described in ril.h. In the case of an incoming call, a RIL_UNSOL_RESPONSE_CALL_STATE_CHANGED message is generated and sent by rild to rilproxy.

- -

rilproxy, implemented in rilproxy.c, receives this message in its main loop, which polls its connection to rild using code like this:

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

Once the message is received from rild, it's then forwarded along to Gecko on the socket that connects rilproxy to Gecko. Gecko receives the forwarded message on its IPC thread:

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

The consumer of these messages is SystemWorkerManager, which repackages the messages and dispatches them to the ril_worker.js thread that implements the RIL state machine; this is done in the RILReceiver::MessageReceived() method:

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

The task posted to that thread in turn calls the onRILMessage() function, which is implemented in JavaScript. This is done using the JavaScript API function JS_CallFunctionName():

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

onRILMessage() is implemented in dom/system/gonk/ril_worker.js, which processes the message bytes and chops them into parcels. Each complete parcel is then dispatched to individual handler methods as appropriate:

- -
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);
-  }
-}
- -

This code works by getting the request type from the object, making sure it's defined as a function in the JavaScript code, then calling the method. Since ril_worker.js implements each request type in a method given the same name as the request type, this is very simple.

- -

In our example, RIL_UNSOL_RESPONSE_CALL_STATE_CHANGED, the following handler is called:

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

As you see in the code above, when notification is received that the call state has changed, the state machine simply fetches the current call state by calling the getCurrentCall() method:

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

This sends a request back to rild to request the state of all currently active calls. The request flows back along a similar path the RIL_UNSOL_RESPONSE_CALL_STATE_CHANGED message followed, but in the opposite direction (that is, from ril_worker.js to SystemWorkerManager to Ril.cpp, then rilproxy and finally to the rild socket). rild then responds in kind, back along the same path, eventually arriving in ril_worker.js's handler for the REQUEST_GET_CURRENT_CALLS message. And thus bidirectional communication occurs.

- -

The call state is then processed and compared to the previous state; if there's a change of state, ril_worker.js notifies the nsIRadioInterfaceLayer service on the main thread:

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

nsIRadioInterfaceLayer is implemented in dom/system/gonk/RadioInterfaceLayer.js; the message is received by its onmessage() method:

- -
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;
-   ...
- -

All this really does is dispatch the message to the content process using the Parent Process Message Manager (PPMM):

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

In the content process, the message is received by receiveMessage() method in the nsIRILContentHelper service, from the 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;
- -

This, in turn, calls the nsIRILTelephonyCallback.callStateChanged() methods on every registered telephony callback object. Every web application that accesses the window.navigator.mozTelephony API has registered one such callback object that dispatches events to the JavaScript code in the web application, either as a state change of an existing call object or a new incoming call event.

- -
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<TelephonyCall> call =
-          TelephonyCall::Create(this, aNumber, aCallState, aCallIndex);
-  nsRefPtr<CallEvent> event = CallEvent::Create(call);
-  nsresult rv = event->Dispatch(ToIDOMEventTarget(), NS_LITERAL_STRING("incoming"));
-  NS_ENSURE_SUCCESS(rv, rv);
-  return NS_OK;
-}
- -

Applications can receive these events and update their user interface and so forth:

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

Take a look at the implementation of handleEvent() in the Dialer application as an extended example.

- -

3G data

- -

There is a RIL message that initiates a "data call" to the cellular service; this enables data transfer mode in the modem. This data call ends up creating and activating a Point-to-Point Protocol (PPP) interface device in the Linux kernel that can be configured using the usual interfaces.

- -
-

Note: This section needs to be written.

-
- - - -

This section lists DOM APIs that are related to RIL communications:

- - - -

WiFi

- -

The WiFi backend for Firefox OS simply uses wpa_supplicant to do most of the work. That means that the backend's primary job is to simply manage the supplicant, and to do some auxiliary tasks such as loading the WiFi driver and enabling or disabling the network interface. In essence, this means that the backend is a state machine, with the states following the state of the supplicant.

- -
-

Note: Much of the interesting stuff that happens in WiFi depends deeply on possible state changes in the wpa_supplicant process.

-
- -

The implementation of the WiFi component is broken up into two files:

- -
-
dom/wifi/DOMWifiManager.js
-
Implements the API that's exposed to web content, as defined in nsIWifi.idl.
-
dom/wifi/WifiWorker.js
-
Implements the state machine and the code that drives the supplicant.
-
- -

These two files communicate with one another using the message manager. The backend listens for messages requesting certain actions, such as "associate", and responds with a message when the requested action has been completed.

- -

The DOM side listens for the response methods as well as several event messages that indicate state changes and information updates.

- -
-

Note: Any synchromous DOM APIs are implemented by caching data on that side of the pipe. Synchronous messages are avoided whenever possible.

-
- -

WifiWorker.js

- -

This file implements the main logic behind the WiFi interface. It runs in the chrome process (in multi-process builds) and is instantiated by the SystemWorkerManager. The file is generally broken into two sections: a giant anonymous function and WifiWorker (and its prototype). The anonymous function ends up being the WifiManager by providing a local API, including notifications for events such as connection to the supplicant and scan results being available. In general, it contains little logic and lets its sole consumer control its actions while it simply responds with the requested information and controls the details of the connection with the supplicant.

- -

The WifiWorker object sits between the WifiManager and the DOM. It reacts to events and forwards them to the DOM; in turn, it receives requests from the DOM and performs the appropriate actions on the supplicant. It also maintains state information about the supplicant and what it needs to do next.

- -

DOMWifiManager.js

- -

This implements the DOM API, transmitting messages back and forth between callers and the actual WiFi worker. There's very little logic involved.

- -
-

Note: In order to avoid synchronous messages to the chrome process, the WiFi Manager does need to cache the state based on the received event.

-
- -

There's a single synchronous message, which is sent at the time the DOM API is instantiated, in order to get the current state of the supplicant.

- -

DHCP

- -

DHCP and DNS are handled by dhcpcd, the standard Linux DHCP client. However, it's not able to react when the network connection is lost. Because of this, Firefox OS kills and restarts dhcpcd each time it connects to a given wireless network.

- -

dhcpcd is also responsible for setting the default route; we call into the network manager to tell the kernel about DNS servers.

- -

Network Manager

- -

The Network Manager configures network interfaces opened by the 3G data and WiFi components.

- -
-

Note: This needs to be written.

-
- -

Processes and threads

- -

Firefox OS uses POSIX threads to implement all application threads — this includes the main thread of each application as well as web workers and helper threads. Control groups are used to prioritize process and thread execution thus relying on the Linux kernel's completely fair scheduler. Depending on the status of a process we assign it to different control group. We've currently got 6 priority levels corresponding to 5 control groups:

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Process priority levels
PriorityControl groupUsed for
MASTER Main b2g process
FOREGROUND_HIGHapps/criticalCritical applications holding the cpu or highpriority wakelock; this is currently reserved for the clock and communications applications
FOREGROUNDappsForeground applications
FOREGROUND_KEYBOARDappsKeyboard application
BACKGROUND_PERCEIVABLEapps/bg_perceivableBackground applications playing audio or holding the holding the cpu or highpriority wakelock and having at least a system message handler registered
BACKGROUNDapps/bg_non_interactiveAll other applications running in the background
- -

Some levels share the same control group, that's because those levels currently differ in the way they're treated by the out of memory killer. All priorities can be adjusted at build time via preferences; the relevant entries can be found in the b2g/app/b2g.js file.

- -

The following control groups are currently used:

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Control groups
PathCPU allocationDescription
 50% of total CPU timeRoot control group reserved for the main b2g process and system daemons
apps50% of total CPU timeRegular applications
apps/critical95% of appsCritical applications
apps/bg_perceivable10% of appsPerceivable background applications
apps/bg_non_interactive5% of appsBackground applications
- -
-

Note: for more information on the out-of-memory killer, and how Firefox OS manages low memory situations, read Out of memory management on Firefox OS.

-
- -

Within a process the main thread inherits the "nice value" of the process whilst web worker threads are given a "nice value" that is one point higher than the main thread thus running at lower priority. This is done in order to prevent CPU-intensive workers from excessively slowing down the main thread. All threads of an application are currently assigned to the same control group. Process priorities are changed whenever a major event happens such as an application being sent into the background or foreground, a new application starting up or an existing application grabbing a CPU wakelock.

- -
-

Note: cgroups support on ICS devices is currently broken due to a kernel bug.

-
diff --git a/files/de/archive/b2g_os/platform/index.html b/files/de/archive/b2g_os/platform/index.html deleted file mode 100644 index db8c4e9960..0000000000 --- a/files/de/archive/b2g_os/platform/index.html +++ /dev/null @@ -1,81 +0,0 @@ ---- -title: Firefox OS Plattform -slug: Archive/B2G_OS/Platform -tags: - - Architektur - - Firefox OS - - Plattform - - Übersicht -translation_of: Archive/B2G_OS/Platform ---- -

Die Firefox OS Plattform besteht aus vielen Komponenten. Du musst seine Architektur nicht verstehen, um Apps für Firefox OS zu entwickeln. Falls Du aber an der Plattform selbst oder an ihrer Portierung mitentwickelst oder einfach nur neugierig bist, dann könnte diese Dokumentation interessant für Dich sein.

- - - - - - - - -
-

Dokumentationen zur Firefox OS Plattform

- -
-
Firefox OS Architektur: Überblick
-
Ein Überblick über die interne Struktur von Firefox OS; vor allem für diejenigen interessant, die an der Plattform oder ihrer Portierung mitentwickeln.
-
Firefox OS Architektur: Apps
-
Ein Überblick über das Anwendungs-Modell von Firefox OS.
-
Gaia
-
Dokumentation über Gaia, die Benutzeroberfläche von Firefox OS Geräten. Gaia ist eine Web-Anwendung, die auf der Firefox OS Betriebssystem-Schicht läuft.
-
Gonk
-
Dokumentation über Gonk, die Betriebssystem-Schicht unterhalb von Gaia. Gonk besteht aus einem Linux Kernel und einer Hardware-Abstraktionsschicht, mit der Gecko kommuniziert.
-
Gecko
-
Gecko ist die Ebene im Firefox OS, die dieselben offenen Web Standard-Implementierungen bereit stellt wie sie auch von Firefox, Thunderbird und vielen anderen Anwendungen genutzt werden.
-
 Sicherheit
-
Dokumentation über die Sicherheit in Firefox OS; dies beinhaltet alle Themen rund um die Sicherheit von Firefox OS Geräten: für die App-Entwicklung, für die Integration von Geräten in Netzwerke und so weiter.
-
Speicherengpässe in Firefox OS
-
Dieser Artikel erläutert wie Firefox OS mit Hilfe des "low memory killers" und der "low memory notifications" mit Speicherengpässen umgeht.
-
Feature Liste
-
Eine Liste mit den verfügbaren Features pro Firefox OS Release.
-
Firefox OS Einstellungen
-
Eine Liste allgemeiner Einstellungen, die mit dem Settings API vorgenommen werden können.
-
- -

Alle anzeigen...

- 		-

Wir helfen Dir

- -

Wenn Du mit Firefox OS arbeitest oder Apps für Firefox OS Geräte entwickelst, dann kann Dir unsere große MDN-Geimeinschaft bei Fragen und Problemen helfen!

- -
    -
  • Besuche das Boot to Gecko Projekt Forum: {{ DiscussionList("dev-b2g", "mozilla.dev.b2g") }}
    • -
- -
    -
  • Stell Deine Fragen in Mozilla's Boot to Gecko IRC Channel: #b2g
    • -
- -

Bitte vergiss nicht die netiquette...

- -

 

- - - - - - -

Quellen

- - -
- -

 

diff --git a/files/de/archive/b2g_os/quickstart/deine_erste_app/index.html b/files/de/archive/b2g_os/quickstart/deine_erste_app/index.html deleted file mode 100644 index abd858245b..0000000000 --- a/files/de/archive/b2g_os/quickstart/deine_erste_app/index.html +++ /dev/null @@ -1,339 +0,0 @@ ---- -title: Deine erste App -slug: Archive/B2G_OS/Quickstart/deine_erste_app -tags: - - Anfänger - - Apps - - FirefoxOS - - Guide -translation_of: Archive/B2G_OS/Quickstart/Your_first_app ---- -
-

Hinweis: Das Quickstart-Abschnitt wurde mit einem neuen, fokussierter Quick Artikel, der alle bisherigen Artikel ersetzt aktualisiert. Wir hoffen, dass Sie diese nützlicher finden, und eine schnellere Lernerfahrung als die älteren Artikel haben.

-
-
-
-

Offene Web-Anwendungen (Web-Entwickler) geben, was sie seit Jahren gewünscht haben: ein Cross-Plattform-Umgebung, um installierbare Apps mit nur HTML, CSS und JavaScript erstellen gewidmet - mit Firefox OS, der erste dedizierte Open Web App-Plattform.

-
-
- Dieser Leitfaden soll Sie unternehmungslustig schnell mit einer grundlegenden Architektur und Anweisungen zu bauen inspirieren, so dass Sie die nächste große app erstellen können!
-
-
-

Wenn Sie dieser Anleitung folgen möchten, können Sie unsere Schnellstart-app-Vorlage herunterladen. Finden Sie mehr heraus was unser Apps-Vorlage-Guide enthält.

-
-

App-Struktur

-

 

-
-
-

Verpackt vs. gehostete Anwendungen

-
-

Es gibt zwei Arten der offenen Web-apps :  verpackt und gehostet. Verpackte apps sind im Wesentlichen die Zip-Dateien, alle Anwendung Anlagewerten: HTML, CSS, JavaScript, Bilder, Manifest, etc.. Gehostete Anwendungen laufen von einem Server in einer bestimmten Domain, genau wie eine standard-Website. Beide app-Arten benötigen ein gültiges Manifest. Wenn Ihre app auf dem Firefox-Marktplatz kommt, wird Ihre Anwendung als  Zip-Datei hochladen oder geben Sie die URL an, wo Ihre gehostete Anwendung  ist.

-
-

-
-

In Partnerschaft mit Treehouse erstellt : Zu die Treehouse Seite

-
-
-

Für die Zwecke dieses Leitfadens erstellen Sie eine gehostete app die werden dann an Ihre Adresse "localhost" geschickt. Sobald Ihre app bereit ist um auf die Liste des Firefox-Marktplatz zukommen, können Sie die Entscheidung, als verpackte app oder als gehostete Anwendung zu starten.

-

Manifeste App

-

Alle Firefox-app erfordern eine manifest.webapp -Datei im Stammverzeichnis der app.  Die manifest.webapp -Datei enthält wichtige Informationen über die app wie Version, Name, Beschreibung, Symbolspeicherort, Locale Zeichenfolgen, Domains, wo die app aus, installiert werden kann, und vieles mehr. Nur der Name und die Beschreibung sind erforderlich. Das einfache Manifest innerhalb der app-Vorlage enthalten ist, die der folgenden ähnelt:

- 
{
-  "version": "0.1",
-  "name": "Open Web App",
-  "description": "Die eeindruckende 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": "Ihr Name",
-    "url": "http://ihrebeeindruckendeapp.eu"
-  },
-  "locales": {
-    "es": {
-      "description": "Su nueva aplicación impresionante Open Web",
-      "developer": {
-        "url": "http://ihrebeeindruckendeapp.eu"
-      }
-    },
-    "it": {
-      "description": "La tua nuova fantastica Open Web App",
-      "developer": {
-        "url": "http://ihrebeeindruckendeapp.eu"
-      }
-    }
-  },
-  "default_locale": "de"
-}
-
-

-
-

In Partnerschaft mit Treehouse erstellt : Zu die Treehouse Seite

-
-
-

 

-

Eine grundlegende Manifest ist alles, was Sie brauchen um loszulegen. Lesen Sie mehr über Manifeste Apps.

-

App Layout & Design

-

Das Design ist zunehmend wichtig, da die Bildschirmauflösungen standard auf verschiedenen Geräten geworden ist. Selbst wenn das Hauptziel Ihrer App mobile Plattformen wie Firefox-OS ist, haben andere Geräte wahrscheinlich auch darauf zugriff.  Mit CSS Media Queries können Sie das Layout des Gerät anpassen, wie in diesem CSS-Beispiel gezeigt:

-
-
-  
-
- 
-/* Im folgenden Text werden Beispiele von Verschiedenen CSS Media Queries gezeigt */
-
-  /* Grundlegende Desktop/Bildschirm breite */
-@media only screen and (min-width : 1224px) {
-  /* style */
-}
-
-/* iPhone breite */
-@media
-  only screen and (-webkit-min-device-pixel-ratio : 1.5),
-  only screen and (min-device-pixel-ratio : 1.5) {
-  /* styles */
-}
-
-/* Geräteeinstellungen auf verschiedenen Ausrichtungen */
-@media screen and (orientation:portrait) {
-  /* styles */
-}
-@media screen and (orientation:landscape) {
-  /* styles */
-}
-

Es gibt viele JavaScript und CSS-Frameworks für responsive Design und mobile app Entwicklung (Bootstrap, etc.) Wählen Sie die Framework(s), die am besten zu Ihrer app-Entwicklung passen.

-

Web APIs

-

JavaScript-APIs werden erstellt und so schnell wie Geräte erweitert. Mozillas WebAPI Aufwand bringt Dutzende von mobilen Standardfunktionen von JavaScript-APIs. Eine Liste der Geräte-Support und Status steht auf der Seite des WebAPI zur Verfügung. JavaScript-Feature-Erkennung ist immer noch die beste Praxis, wie im folgenden Beispiel gezeigt:// Wenn dieses Gerät das Vibrieren API unterstützt

- 
// Wenn dieses Gerät Vibration API unterstützt ...
-
-if('vibrate' in navigator) {
-    // ... Vibration in Sekunden
-    navigator.vibrate(1000);
-}
-

Im folgenden Beispiel wird das Anzeigeformat von einer <div> basierend auf die Änderungen in der Ladezustand des Geräts geändert :

- 
// Erstellen Sie die Batterie Indiktator Hörer
-(function() {
-  var battery = navigator.battery || navigator.mozBattery || navigator.webkitBattery,
-      indicator, indicatorPercentage;
-
-  if(battery) {
-    indicator = document.getElementById('indicator'),
-    indicatorPercentage = document.getElementById('indicator-percentage');
-
-    // Zuhörer für Änderung
-    battery.addEventListener('chargingchange', updateBattery);
-    battery.addEventListener('levelchange', updateBattery);
-
-    // Aktualisiert sofort
-    updateBattery();
-  }
-
-  function updateBattery() {
-    // Prozent aktualisieren Breite und Text
-    var level = (battery.level * 100) + '%';
-    indicatorPercentage.style.width = level;
-    indicatorPercentage.innerHTML = 'Battery: ' + level;
-    // Ladestatus Updaten
-    indicator.className = battery.charging ? 'charging' : '';
-  }
-})();
-

Im Beispiel oben sobald Sie bestätigen, dass die Batterie-API unterstützt wird, können Sie Ereignis-Listener für Chargingchange und Levelchange um das Element Anzeige aktualisieren hinzufügen. Versuchen Sie, die folgenden auf die Quickstart-Vorlage, und sehen Sie, wenn Sie es funktioniert.

-
-
- Überprüfen Sie die WebAPI-Seite regelmäßig, um sich mit Gerät API Status aktuell zu halten.
-
-  
-
-
-

API-Funktionen installieren

-
-  
-
-

In unserem Quickstart-app Beispielvorlage, haben wir eine installierungs-Schaltfläche, die Sie anklicken können, wenn Sie die app als standard website haben möchten ,
- und diese Website auf Firefox-OS als app zu installieren. Das Knopf-Markup ist nichts Besonderes:

- 
<button id="install-btn">App Installieren</button>
-
-
- Diese Tastenfunktionen wird mithilfe der installieren-API implementiert (siehe install.js):
-
-  
-
- 
var mainifest_url = location.href + 'manifest.webapp';
-
-function install(ev) {
-  ev.preventDefault();
-//Manifest URL Definieren
-// App Installieren
-  var installLocFind = navigator.mozApps.install(manifest_url);
-  installLocFind.onsuccess = function(data) {
-    // Wenn die App Installiert ist
-  };
-  installLocFind.onerror = function() {
-    // App ist nicht Installiert
-    // installapp.error.name
-    alert(installLocFind.error.name);
-  };
-};
-
-// Eine Verweis auf die Schaltfläche und rufen Sie install() auf Klick wenn die App nicht Installiert ist. Wenn sie installiert ist ist die Schaltfläche ausgeblendet.
-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);
-  };
-};
-
-

Gehen Sie kurz alles durch was vor sich geht :

-
    -
  1. -
    - Wir erhalten einen Verweis auf die Schaltfläche "installieren" und speichern Sie sie in die Schaltfläche "Variablen".
    -
    2. -
  2. Wir verwenden navigator.mozApps.checkInstalled um zu prüfen, ob die App definiert durch das Manifest im http://people.mozilla.com/~cmills/location-finder/manifest.webapp bereits auf dem Gerät installiert ist. Dieser Text wird als Variable installCheck gespeichert.
    3. -
  3. Wenn der Test erfolgreich durchgeführt wird, dann wird sein Success Ereignis ausgelöst, daher wird installCheck.onsuccess = function() { ... } ausgeführt.
    4. -
  4. Wenn die App bereits Installiert ist wird die Schaltfläche ausgeblendet.
    5. -
  5. -
    -
    -
    -
    - Wenn die app nicht installiert ist, fügen wir einen Click-Ereignis-Listener zur Schaltfläche, so dass die Funktion install() ausgeführt wird, wenn die Schaltfläche geklickt wird.
    -
    -
    -
    -
    6. -
  6. Wenn die Schaltfläche angeklickt wird, und die Funktion install() ausgeführt wird, wird die Betriebsstätte für die manifest-Datei in eine Variable namens manifest_url und installieren dann die app unter Verwendung navigator.mozApps.install(manifest_url), einen Verweis auf die Installation in der InstallLocFind-Variablen zu speichern. Sie werden bemerken, dass diese Installation auch Erfolg und Fehler-Ereignisse auslöst, damit Sie Aktionen abhängig ausführen können, ob die Installation erfolgreich oder nicht passiert ist.
    7. -
-

Vielleicht möchten Sie den Umsetzung Stand der API prüfen, wenn dann aber zuerst nach installierbare Webanwendungen.

-
-
-
- Hinweis: Installierbare offene Web-Anwendungen haben eine Sicherheitsrichtlinie "einzelne app pro Herkunft"; Grundsätzlich können Sie nicht mehr als eine installierbare app pro Herkunft hosten. Dies vereinfacht das Testen ein wenig komplizierter, aber es gibt noch Wege, um dieses, wie das Erstellen von verschiedenen Subdomains für apps, testen sie mit der Firefox-OS-Simulator, oder testen die Install-Funktionalität auf Firefox Aurora/nächtliche, welches Ihnen erlaubt zu installierbare Webanwendungen auf dem Desktop zu installieren. Siehe FAQs über apps Manifeste für weitere Informationen zur Herkunft.
-
-
-
-

WebRT APIs (APIs auf der Grundlage von Berechtigungen)

-
-
-
- Es gibt eine Reihe von WebAPIs, aber die benötigen spezielle Berechtigungen für dieses Feature aktiviert werden. Apps können registrieren Berechtigungsanforderungen innerhalb der manifest.webapp-Datei wie folgt:
-
-  
-
- 
// Neuer Key im Manifest : "permissions"
-// Anforderung der Zugriffe auf eine belibige Anzahl von APIs
-// Hier bitten wir um die berechtigung für die SystemXHR API
-"permissions": {
-    "systemXHR": {}
-}
-
-
- Die drei Stufen der Berechtigung sind wie folgt:
-
-  
-
- -
-
- Weitere Informationen zu app-Berechtigungsstufen, Arten von verpackten apps lesen. Sie finden weitere Informationen über Berechtigungen welche APIs erfordern , und welche Berechtigungen sind erforderlich, um App-Berechtigungen.
-
-  
-
-
-
-
- Es ist wichtig zu beachten, dass nicht alle Web-APIs in der Firefox-OS-Simulator umgesetzt werden.
-
-
-

Tools & Testen

-
-
- Testen ist unglaublich wichtig, wenn mobile Geräte unterstützt. Es gibt viele Optionen zum Testen von installierbaren open-Web-apps.
-
-  
-
-

Firefox OS Simulator

-
-
- Installation und Verwendung der Firefox-OS-Simulator ist der einfachste Weg zum aufstehen und laufen mit Ihrer app. Nach der Installation des Simulators ist es aus dem Tools-> Web Developer-> Firefox-OS-Simulator-Menü zugänglich. Der Simulator startet mit einer JavaScript-Konsole, damit Sie Ihre Anwendung in den Simulator Debuggen können.
-
-  
-
-

App Manager

-
-
- Das neue Kind auf den Block im Hinblick auf die Testtools nennt man den App-Manager. Mit diesem Tool können Sie Verbindung mit einem kompatiblen Gerät über USB (oder ein Firefox-OS-Simulator) desktop Firefox, apps direkt auf das Gerät schieben, apps zu validieren und Debuggen sie, wie sie auf dem Gerät ausgeführt.
-
-  
-
-

Unit Tests

-
-
- Unit-Tests sind sehr wertvoll, wenn Sie auf verschiedenen Geräten zu testen und baut. jQuery's QUnit ist eine beliebte Client-seitige Dienstprogramm zum Testen, aber können Sie einen beliebigen Satz von Testtools, die Sie möchten.
-
-  
-
-
-

Firefox OS auf einem Gerät installieren

-
-
-
- Da Firefox-OS ein open-Source-Plattform ist sind Code und Tools Erstellen und installieren Firefox-OS auf Ihrem eigenen Gerät verfügbar. Build sowie Installationsanweisungen und Anmerkungen zu welchen Geräten es auf, installiert werden kann finden Sie auf MDN.
-
-  
-
-
-
- Spezielle Firefox-OS Entwickler Vorschau Geräte stehen zur Verfügung: Lesen Sie unsere Entwickler-Vorschau-Telefon-Seite für weitere Informationen.
-
-  
-
-  
-
-
-

App-einreichen und Verteilung

-
-

Wenn Ihre app abgeschlossen ist, können Sie es selbst hosten wie eine standard-Website oder app (Lesen Sie self-publishing-Anwendungen für weitere Informationen), oder es kann eingereicht werden, auf den Firefox-Markt. Ihre Anwendung Manifest überprüft werden können Sie wählen, welche Geräte Ihr app unterstützt (z.B. Firefox OS, Desktop, Firefox, Firefox Mobile, Firefox Tablet). Sobald validiert, können die app Liste innerhalb der Marktplatz Sie fügen Sie zusätzliche Informationen über Ihre app (Screenshots, Beschreibungen, Preise, etc.) und offiziell einreichen. Sobald die App genehmigt ist, ist Ihre app der Welt für die Beschaffung und Installation zur Verfügung.

-
-

Marktplatz & Mehr Angaben

-
-
    -
  1. Senden Sie eine App auf den Firefox-OS-Marktz
    2. -
  2. Marktplatz-Prüfkriterien
    3. -
  3. - -
    4. -
-

 

-

 

-

Übersetzung bei Enes E.

-
diff --git a/files/de/archive/b2g_os/quickstart/einfuerung_zu_firefox_os/index.html b/files/de/archive/b2g_os/quickstart/einfuerung_zu_firefox_os/index.html deleted file mode 100644 index b262d5f208..0000000000 --- a/files/de/archive/b2g_os/quickstart/einfuerung_zu_firefox_os/index.html +++ /dev/null @@ -1,13 +0,0 @@ ---- -title: Einführung zu Firefox OS -slug: Archive/B2G_OS/Quickstart/Einfuerung_zu_Firefox_OS -translation_of: Archive/B2G_OS/Quickstart/Intro_to_Firefox_OS ---- -
-

Firefox OS ist ein neues Mobilbetriebssystem, entwickelt von Mozillas Boot to Gecko (B2G) Projekt. Es besteht aus einem Linux Kernel und bootet als eine auf Gecko basierende Laufzeitumgebung, die es Nutzern ermöglicht Anwendungen, geschrieben in HTML, JavaScript, und mit anderen offenen APIs für Webanwendungen, auszuführen.

-
-

Firefox OS (also referred to by its codename "Boot to Gecko" or "B2G") is Mozilla's open source mobile operating system, based a Linux kernel, which boots into a Gecko-based runtime engine that lets users run applications developed entirely using HTML, CSS, JavaScript, and open web application APIs. Firefox OS is a mobile operating system that's free from proprietary technology while still a powerful platform that provides application developers an opportunity to create excellent products. In addition, it's flexible and capable enough to make the end user happy.

-

-

Firefox OS comes with a suite of pre-installed applications called Gaia, which handle the fundamental functions of the phone such as settings, calls, SMS, taking and storing photos, etc.

-

For Web developers, the most important part to understand is that the entire user interface is a Web app, one that is capable of displaying and launching other Web apps. Any modifications you make to the user interface and any applications you create to run on Firefox OS are Web pages, albeit with enhanced access to the mobile device's hardware and services.

-

Firefox OS is currently under heavy development; we are constantly working on ways to make it easier for you to use and hack on Gaia and create apps. However, you need knowledge about systems in order to do things like build the entire Firefox OS stack, or flash a phone with a build of Firefox OS. To find such information, and lots more besides, head on over to our Firefox OS content zone.

diff --git a/files/de/archive/b2g_os/quickstart/for_mobile_developers/index.html b/files/de/archive/b2g_os/quickstart/for_mobile_developers/index.html deleted file mode 100644 index e4a00e9335..0000000000 --- a/files/de/archive/b2g_os/quickstart/for_mobile_developers/index.html +++ /dev/null @@ -1,40 +0,0 @@ ---- -title: App development for mobile developers -slug: Archive/B2G_OS/Quickstart/For_mobile_developers -translation_of: Archive/B2G_OS/Quickstart/For_mobile_developers ---- -
-

If you are a native mobile platform developer, why should you look into developer open web apps? This article talks you through open web app advantages, and the basic steps required to create one.

-
-

Advantages

-

For mobile application developers, the open web apps project offers these advantages:

- -

Steps to developing a Web app

-
-
- 1. Develop your app using open Web technologies.
-
- You probably already know at least a bit about HTML, CSS, and JavaScript. The Learn section of this website has resources to help you ramp up even more. As a mobile app developer, you already have a Mobile First approach to Web design.
-
- 2. Add an app manifest.
-
- All that inherently separates a Web app from a normal website is a single, JSON-format text file.
-
- 3. Publish the app, either on your own site or in an app store (or both).
-
- Publishing it yourself requires adding some code to your site to manage installing and updating the app in users' browsers.
-
-

Optional features

-

{{ page("/en-US/docs/Web/Apps/For_Web_developers", "Optional_features") }}

-

Useful technologies

-

See Useful technologies.

-

See also

- diff --git a/files/de/archive/b2g_os/quickstart/index.html b/files/de/archive/b2g_os/quickstart/index.html deleted file mode 100644 index ebe1f7c220..0000000000 --- a/files/de/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/de/archive/b2g_os/quickstart/open_web_apps_and_web_standards/index.html b/files/de/archive/b2g_os/quickstart/open_web_apps_and_web_standards/index.html deleted file mode 100644 index f0767b57ed..0000000000 --- a/files/de/archive/b2g_os/quickstart/open_web_apps_and_web_standards/index.html +++ /dev/null @@ -1,38 +0,0 @@ ---- -title: Offene Web Apps und Web Standards -slug: Archive/B2G_OS/Quickstart/Open_Web_apps_and_Web_standards -translation_of: Archive/B2G_OS/Quickstart/Intro_to_open_web_apps ---- -

Multi devices

-

Das Web ist die Plattform

-

Open Web Apps are a great opportunity for those who need to develop applications that work on the largest number of devices, and for those who cannot afford to develop an app for every vendor platform (such as Android, iOS, and "classical" desktop web browsers). The difference between an app and a website is that you can install an app and more thoroughly integrate it into your device. It’s not a bookmark — it’s part of a system. Open Web Apps hold that great promise. They are an opportunity that we should not miss, otherwise the Web might become fragmented once more.

-

With this in mind it should be clear that Open Web Apps (OWA in short) are intended to be standardized and to become part of "the Web". If successful, OWA should eventually work on all browsers, operating systems anddevices.

-

At Mozilla we are working hard to create this apps platform that is backed entirely by the open Web. It’s not intended to be a “Mozilla platform” or a “Firefox platform”. The Web is the platform. We’re creating a set of open APIs and implementations to show how portable apps can exist on the Web without vendor lock-in. Other groups like Facebook and Google Chrome are also working on apps platforms backed by the Web. Facebook apps are meant to hook into Facebook and Chrome apps are designed for Chrome OS devices and Google servers. Chrome apps are the most similar to Open Web Apps. We continue to collaborate with the Google Chrome team as app standards evolve and we definitely share a lot of the same vision. There is tremendous potential for all Web based app platforms to converge and we invite all vendors to help us build the right Open Web App APIs.

-

Even though currently you must have a Mozilla Firefox-based engine ("Web runtime") to use Open Web Apps, it is not intended that this always will be the case. Many parts of the Open Web Apps project are still being worked out and it isn't possible to implement everything in all browsers at once. Although many parts of Open Web Apps are already standardized, many other parts are still in flux. It is intended and hoped that Open Web Apps will be a standard capability that is available in all major browsers.

-

Therefore, when you read the MDN pages that deal with Open Web Apps, please keep in mind that even though much of the information is specific to Firefox right now, it will hopefully enable you to develop Open Web Apps for all browsers in the future.

-

Web standards

-

OWA technology is not a single piece, it is an umbrella that groups many different technologies and some of them are very young. At the moment, parts of OWA are standardized (HTML5, CSS, JavaScript, IndexedDB, etc.). Other parts are not yet standardized and the Mozilla implementation is thus specific to Firefox or to some other Mozilla technology. As the Mozilla mission is to share and to empower everyone, this situation is only temporary. That's why in the OWA docs we will try to clearly identify the parts of OWA that are not yet standardized.

-

Please also note that there may be some OWA-related proposals and potential standards that are not used by Mozilla.

-

Intended eventual standards

-

So here are the parts not standardized yet across the different Web platforms and that still are Firefox-only for the moment:

- -

Marketplace

-

Buy Once, Run Everywhere

-

From the ground up Mozilla has been building an apps system that lets users buy an app once and run it on all of their HTML5 devices. Very soon Mozilla will launch the first Firefox OS phone but that will be just one device on which to run your apps. When you purchase an app through the Firefox Marketplace, the system installs a receipt on your device. The receipt is a JSON Web Token with metadata that links to the Marketplace’s public key and its verification service URL. When an app starts up it can verify the receipt but the receipt on the device is not tied to the Firefox Marketplace. The receipt is just a cryptographically verifiable proof of purchase. Anyone can sell open Web apps if they follow the receipt specs. When you buy an app, it is intended to be portable across any device that supports the Open Web Apps system.

-

Mozilla is building the infrastructure needed to run Open Web Apps on any HTML5 device. Firefox for Android will let you install and run apps (you can try it today on the nightly build). Installed app icons go to your home screen just like regular Android apps. You can also install and run Web apps on your Windows, Mac, or Linux desktop using Firefox (this currently works in the nightly build). Currently some version of Firefox is required, but it is intended that the Open Web Apps system will eventually be supported by all major browsers as a set of standards. From day one Mozilla has included all major HTML5 compliant browsers in its proof of concepts; you can take a look at this hosted JavaScript shim for ideas on how to support the apps platform on a non-Firefox browser.

-

In the future the Open Web Apps system will support syncing your installed apps across devices. Since receipts are portable you could just sync them yourself if you wanted to. In case it’s not obvious, you can always run a free open Web app in any browser because it is no different than a website. It might, however, use new mobile specific web APIs which are not implemented on all platforms.

-

WebPayment API

-

Commerce For Apps

-

Part of the success of mobile app platforms like iOS and Android is that they make it very easy to try out new business models through mobile payments. Those models are still evolving but commerce is no doubt something that, at the moment, is awkward on the desktop Web and more natural on mobile. Specifically, it’s very convenient to charge something to your phone bill when you’re already accessing it from your phone anyway. With the launch of Firefox OS, the apps ecosystem will support app purchases and in-app payments through the WebPayment API. Supporting commerce is crucial for the growth of an apps platform. The use of the proposed payment API is completely optional. Mozilla won’t prevent any app from using its own in-app payment system.

-

See also

- diff --git a/files/de/archive/b2g_os/releases/1.4/index.html b/files/de/archive/b2g_os/releases/1.4/index.html deleted file mode 100644 index 47b18c0fbc..0000000000 --- a/files/de/archive/b2g_os/releases/1.4/index.html +++ /dev/null @@ -1,71 +0,0 @@ ---- -title: Firefox OS 1.4 for developers -slug: Archive/B2G_OS/Releases/1.4 -translation_of: Archive/B2G_OS/Releases/1.4 ---- -
-

Firefox OS 1.4 ist derzeit noch eien Vorabversion. Die Gecko Komponenten basieren auf Firefox 30 (dazu:Firefox 30 release notes for developers). Diese Seite beschreibt die neu hinzugefügten Entwicklerfunktionen in Firefox OS 1.4.

-
-

CSS

-

Gecko allgemein:

- -

JavaScript

-

SpiderMonkey general:

- -

Interfaces/APIs/DOM

-

Firefox OS specific:

- -

Gecko general:

- -

SVG

-

Gecko general:

- -

Manifest

- -

See also

- -

Older versions

-

- -

-

diff --git a/files/de/archive/b2g_os/releases/2.0/index.html b/files/de/archive/b2g_os/releases/2.0/index.html deleted file mode 100644 index 175d141e00..0000000000 --- a/files/de/archive/b2g_os/releases/2.0/index.html +++ /dev/null @@ -1,112 +0,0 @@ ---- -title: Firefox OS 2.0 for developers -slug: Archive/B2G_OS/Releases/2.0 -translation_of: Archive/B2G_OS/Releases/2.0 ---- -
-

This page details the developer features newly implemented in Gecko that are specific to Firefox OS 2.0.

-
- -
-

Firefox OS 2.0's Gecko component is based on Firefox 31/32.

-
- -

New product features

- -

This section provides a summary of the new features available in Firefox OS 2.0. For more details on specific platform changes (API additions, etc.), see the Platform additions in detail section.

- -
-
NFC
-
This release includes support for device-to-device content sharing support with NFC (Near Field Communication). You can pair your device with another, then swipe to share your contacts, media, or favorite URLs with others.
-
Telephony
-
Firefox OS now supports both IPv4 and IPv6 addresses in the network manager.
-
Find My Device
-
If you’ve lost your Firefox OS smartphone, Find My Device can help you find it (see the http://find.firefox.com website). You can see it on a map, make it play a sound and have it display a message. You can also remotely lock it or delete your personal info. To get started, create a Firefox Account (Settings > Firefox Accounts on your device) and enable Find My Device (Settings > Find My Device).
-
Media
-
You can now create your own ringtones using your own music collection, or songs you download from the Web.
-
Camera
-
The Camera app now supports various focus modes: Touch, Continuous Auto and Face tracking.
-
Productivity
-
We've done a visual refresh of the Email, Calender, and Clock apps.
-
Homescreen
-
Firefox OS 2.0 introduces a simpler vertical-scrolling homescreen with larger icons.
-
Edge-gesture app switching
-
Edge gestures are now available for switching between apps (swipe your thumb from the left edge of the screen to the right and vice versa, to switch between multiple open apps.)
-
- -

New partner features

- -
-
E.ME integration
-
E.ME integration provides direct access to web apps while configurable search providers can search the web at the same time.
-
- -

New DevTools features

- -

The Firefox Developer Tools have had a large number of features added in Firefox versions 31 and 32; these aren't Firefox OS-specific, but you can take advantage of them when debugging your Firefox OS apps through WebIDE. To find out more, read:

- - - -

Platform additions in detail

- -
-

Note: Our list here includes features most important to Firefox OS. For an expanded list of general Gecko feature additions (which are generally also present in Firefox OS 2.0), consult the Firefox 31 release notes for developers and Firefox 32 release notes for developers.

-
- -

Web API

- - - -

CSS

- - - -

Technology support improvements

- - - -

Older versions

- -

- -

diff --git a/files/de/archive/b2g_os/releases/index.html b/files/de/archive/b2g_os/releases/index.html deleted file mode 100644 index 3edbcd4c75..0000000000 --- a/files/de/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.

-
- {{ListSubpages("",1,0,1)}}
-

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/de/archive/b2g_os/simulator/index.html b/files/de/archive/b2g_os/simulator/index.html deleted file mode 100644 index 5fa8770578..0000000000 --- a/files/de/archive/b2g_os/simulator/index.html +++ /dev/null @@ -1,86 +0,0 @@ ---- -title: Firefox-OS-Simulator -slug: Archive/B2G_OS/Simulator -translation_of: Archive/B2G_OS/Simulator ---- -
-

Diese Seite beschreibt den Firefox-OS-Simulator für Entwickler für Firefox OS 1.2 oder neuer. Wenn Sie Apps für Firefox OS 1.1 entwickeln, sollten Sie sich stattdessen die Dokumentation für Firefox-OS-1.1-Simulator ansehen.

-
- -

Der Firefox-OS-Simulator ist eine Version der höheren Schichten von Firefox OS, die ein Firefox-OS-Gerät simuliert, aber auf dem Desktop läuft. Dies bedeutet, dass Sie in vielen Fällen kein echtes Gerät benötigen, um Ihre App zu testen und zu debuggen. Er läuft in einem Fenster mit der selben Größe wie ein Firefox-OS-Gerät, enthält die Benutzeroberfläche sowie die integrierten Apps von FirefoxOS und simuliert viele der APIs eines Firefox-OS-Geräts.

- -

Der Simulator wird als Firefox-Add-on gepackt und verteilt. Sobald Sie ihn heruntergeladen und in Firefox installiert haben, können Sie ihn ausführen, Apps darauf laden und mit dem App-Manager Entwicklerwerkzeuge einsetzen.

- -

Installation

- -

Um den Simulator zu installieren, klicken Sie auf die folgende Schaltfläche. (Es stehen mehrere Versionen zur Verfügung und zwecks maximaler Flexibilität sollten Sie alle installieren):

- -

Simulator installieren

- -

Um den Simulator zu starten, lesen sie die Anweisungen in der Dokumentation des App-Managers. Sobald der Simulator läuft, können Sie Apps darauf laden und dann mit dem App-Manager debuggen, genau wie mit einem echten Gerät. Ich habe unter Windows 7, Firefox 37.0.1 und mit Firefox OS Simulator die Erfahrung gemacht, dass erster Start in der WebIDE klappt nicht, dafür funktioniert 2. oder 3. Start. Auch dann, wenn eine Meldung: "Zeitüberschreitung bei der operation: connecting to runtime Firefox OS 2.0" in der WebIDE angezeigt wird.

- -

Die Simulator-Oberfläche

- -

Der Simulator erscheint als eigenes Fenster, so dass der simulierte Bildschirm 320×480 Pixel groß ist. Um Berührereignisse zu simulieren, können Sie mit der Maustaste klicken und die Maus bei gedrückter Taste ziehen. Durch Klicken und Ziehen von rechts nach links vom Startbildschirm aus sehen Sie also die integrierten Apps, sowie solche, die Sie hinzugefügt haben:

- -

- -

Der Simulator verfügt am unteren Rand über deine Symbolleiste mit zwei Schaltflächen:

- - - -

Einschränkungen des Simulators

- -

Beachten Sie, dass der Firefox-OS-Simulator keine perfekte Simulation ist.

- -

Hardware-Einschränkungen

- -

Abgesehen von der Bildschirmgröße simuliert der Simulator keine hardwareseitigen Einschränkungen eines Firefox-OS-Geräts, wie den verfügbaren Speicher oder die CPU-Geschwindigkeit.

- -

Audio-/Video-Codecs

- -

Die folgenden Codecs hängen von hardwarebeschleunigter Dekodierung ab und werden daher noch nicht unterstützt:

- - - -

Dies bedeutet, dass es nicht möglich ist,  mit dem Simulator die Wiedergabe von Videos in Apps und Websites wie YouTube zu testen, die diese Codecs benötigen.

- -

Nicht unterstützte APIs

- -

Bestimmte APIs, die auf dem Gerät funktionieren, funktionieren nicht im Simulator, was meist daran liegt, weil die unterstützende Hardware auf dem Desktop nicht verfügbar ist. Wir haben Simulationen für bestimmte APIs, wie Geolokation, eingebaut und fügen in zukünftigen Versionen vermutlich weitere hinzu. Derzeug werden die folgenden APIs allerdings nicht unterstützt. Deren Verwendung kann zu Fehlermeldungen oder einfach falschen Ergebnissen führen:

- - - -

Hilfe erhalten

- -

Wenn Sie eine Frage haben, versuchen Sie, uns auf der Mailingliste dev-developer-tools oder in #devtools auf irc.mozilla.org zu erreichen.

- -

Ausführliche Protokollierung aktivieren

- -

In der Web-Konsole, die Sie über den App-Manager mit Ihrer App verknüpfen können, werden Nachrichten, von Ihrer App aufgezeichnet. Wenn Sie Nachrichten frühzeitig erfassen möchten, die während des Starts erscheinen, bevor die Konsole verbunden wird und funktioniert, können Sie im Simulator die ausführliche Protokollierung aktivieren.

- -

Öffnen Sie about:config und erstellen Sie ein neue Einstellung. Der Name der Einstellung hängt von der Version des Simulators ab:

- - - -

Setzen Sie den String-Wert auf „all“ und deaktivieren und reaktivieren Sie das Add-on im Add-ons-Manager. Jetzt erscheinen zusätzliche Nachrichten über die Ausführung des Simulators in der Browser-Konsole.

diff --git a/files/de/archive/b2g_os/troubleshooting/index.html b/files/de/archive/b2g_os/troubleshooting/index.html deleted file mode 100644 index a83cc46042..0000000000 --- a/files/de/archive/b2g_os/troubleshooting/index.html +++ /dev/null @@ -1,44 +0,0 @@ ---- -title: Troubleshooting Firefox OS -slug: Archive/B2G_OS/Troubleshooting -translation_of: Archive/B2G_OS/Troubleshooting ---- -
-

This article provides tips for resolving common problems you may have while using Firefox OS. Please feel free to add more content to this page!

-
- -

Networking problems

- -

If you are having trouble connecting to Wi-Fi networks, it may be helpful to delete the Wi-Fi configuration file:

- -
adb shell rm /data/misc/wifi/wpa_supplicant.conf
-adb reboot
-
- -
-

Note: These instructions assume you have configured the udev settings for your device.

-
- -

Bricked Phone

- -

If you happen to brick the phone, by, for example, trying to flash wrong images on it,  try rebooting into the bootloader (fastboot or heimdal depending on your phone). The exact sequence varies depending on the phone. Try removing the usb cable, removing and then re-inserting the battery. For the Unagi and Otoro, press and hold volume up and power for several seconds until you see the splash screen. Verify that the phone is in bootloader mode by using fastboot devices (or heimdall devices for some Samsung phones). Once you can see your phone using fastboot devices, you can use ./flash.sh to flash your image for Unagi.

- -

Flashing Red LED (otoro/unagi)

- -

This means that the battery is too low to boot the phone. You can let it charge for a while (until the red LED stops flashing and a little bit longer), or you can unplug the USB cable, remove the battery, insert the USB cable, and re-insert the battery.

- -

Failure to receive SMS after switching over from iPhone

- -

If you have switched your SIM card over from an iPhone to a Firefox OS (or another different platform) device, you may run into a problem whereby you can no longer receive text messages from iPhone users. This is because iPhone to iPhone SMS messages are sent using iMessage, which works by routing iPhone-to-iPhone messages through Apple's servers instead of sending them as actual text messages, saving iPhone users money. Unfortunately when you leave iPhone, iMessage has no way of knowing you've left and SMS from other iPhone users will still go through iMessage, meaning that you won't receive them.

- -

To fix this you have to turn off iMessage for your SIM; there is a guide on how to do this at imore.com — read Here's how to turn off iMessage.

- -

Device not appearing to ADB on OSX

- -

When running adb devices in OSX, some devices may simply not appear in the device list, for a variety of reasons. This can be fixed by adding your device's vendor ID to your ~/.android/adb_usb.ini file, to provide a hint to ADB for finding your device.

- -
-

Note: See this stackoverflow post for a lot more detail, including how to find the vendor ID of the attached device, and how to add it into adb_usb.ini.

-
- -

 

-- cgit v1.2.3-54-g00ecf