cordova-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ste...@apache.org
Subject [42/51] [partial] added 3.4.0 for other languages
Date Mon, 24 Feb 2014 18:38:02 GMT
http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/2506e7b9/docs/de/3.4.0/guide/hybrid/plugins/index.md
----------------------------------------------------------------------
diff --git a/docs/de/3.4.0/guide/hybrid/plugins/index.md b/docs/de/3.4.0/guide/hybrid/plugins/index.md
new file mode 100644
index 0000000..f2285fc
--- /dev/null
+++ b/docs/de/3.4.0/guide/hybrid/plugins/index.md
@@ -0,0 +1,152 @@
+---
+
+license: Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file distributed with this work for additional information regarding copyright ownership. The ASF licenses this file to you under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at
+
+           http://www.apache.org/licenses/LICENSE-2.0
+    
+         Unless required by applicable law or agreed to in writing,
+         software distributed under the License is distributed on an
+         "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+         KIND, either express or implied.  See the License for the
+         specific language governing permissions and limitations
+    
+
+   under the License.
+---
+
+# Plugin-Entwicklung-Guide
+
+Ein *Plugin* ist ein Paket von eingefügten Code, der die Cordova Webview ermöglicht, innerhalb, die derer Ihre Anwendung rendert mit der einheitlichen Plattform für die Kommunikation auf dem es ausgeführt wird. Plugins ermöglichen den Zugriff auf Geräte und Plattform-Funktionalität, die normalerweise nicht für Web-basierte Anwendungen verfügbar ist. Die wichtigsten Cordova API-Features sind als Plugins implementiert, und viele andere stehen, dass aktivieren wie Barcode-Scannern, NFC-Kommunikation Funktionen, oder zu Kalender anpassen Schnittstellen.
+
+Plugins umfassen eine einzelne JavaScript-Schnittstelle zusammen mit entsprechenden native Code-Bibliotheken für jede unterstützte Plattform. Dieser Abschnitt schrittweise einen einfachen *Echo* -Plugin, die übergibt eine Zeichenfolge von JavaScript zum einheitlichen Plattform und zurück, die Sie als Modell verwenden können, um viel komplexere Features zu erstellen. Dieser Abschnitt beschreibt die grundlegenden Plugin-Struktur und die nach außen gerichtete JavaScript-Schnittstelle. Jede entsprechende Benutzeroberfläche finden Sie in der Liste am Ende dieses Abschnitts.
+
+Zusätzlich zu diesen Anweisungen, wenn bereiten auf ein Plugin zu schreiben, ist es am besten über die [vorhandenen Plugins][1] , Anleitungen zu schauen.
+
+ [1]: https://github.com/apache/cordova-android/tree/master/framework/src/org/apache/cordova
+
+## Eine Plugin erstellen
+
+Anwendungsentwickler verwenden der CLI `plugin add` Befehl (beschrieben in The Command-Line Interface), eine Plugin zu einem Projekt anzuwenden. Das Argument für diesen Befehl ist die URL für ein *Git* -Repository mit dem Plugin-Code. In diesem Beispiel implementiert Cordova's Device API:
+
+        $ cordova plugin add https://git-wip-us.apache.org/repos/asf/cordova-plugin-device.git
+    
+
+Das Plugin Repository muss eine Top-Level-Funktion `plugin.xml` manifest-Datei. Es gibt viele Möglichkeiten um diese Datei zu konfigurieren, die Informationen für die in der Plugin-Spezifikation verfügbar sind. Diese gekürzte Version von der `Device` Plugin bietet ein einfaches Beispiel, als Vorbild zu verwenden:
+
+        <?xml version="1.0" encoding="UTF-8"?>
+        <plugin xmlns="http://apache.org/cordova/ns/plugins/1.0"
+                id="org.apache.cordova.device" version="0.2.3">
+            <name>Device</name>
+            <description>Cordova Device Plugin</description>
+            <license>Apache 2.0</license>
+            <keywords>cordova,device</keywords>
+            <js-module src="www/device.js" name="device">
+                <clobbers target="device" />
+            </js-module>
+            <platform name="ios">
+                <config-file target="config.xml" parent="/*">
+                    <feature name="Device">
+                        <param name="ios-package" value="CDVDevice"/>
+                    </feature>
+                </config-file>
+                <header-file src="src/ios/CDVDevice.h" />
+                <source-file src="src/ios/CDVDevice.m" />
+            </platform>
+        </plugin>
+    
+
+Der obersten Ebene `plugin` Tag `id` Attribut verwendet das gleiche umgekehrt-Domäne-Format in das Plugin-Paket zu identifizieren, wie die apps, die sie hinzugefügt haben. Die `js-module` Tag gibt den Pfad zu "common Interface" JavaScript. Die `platform` Tag gibt einen entsprechenden Satz von systemeigenem Code für die `ios` Plattform in diesem Fall. Die `config-file` Tag kapselt ein `feature` Tag, der in der Plattform-spezifischen eingespritzt ist `config.xml` Datei, die Plattform der zusätzliche Codebibliothek aufmerksam zu machen. Die `header-file` und `source-file` Markierungen geben Sie den Pfad zu der Bibliothek-Komponentendateien.
+
+## Eine Plugin überprüfen
+
+Können Sie das `plugman` -Dienstprogramm zum Überprüfen, ob das Plugin richtig für jede Plattform installiert. Installieren Sie `plugman` mit den folgenden [Knoten][2] -Befehl:
+
+ [2]: http://nodejs.org/
+
+        $ npm install -g plugman
+    
+
+Sie benötigen eine gültige app Quellcode-Verzeichnis, z. B. der obersten Ebene `www` Verzeichnis in ein CLI-generierte Standardprojekt enthalten, wie in der Command-Line Interface beschrieben. Sicherstellen, dass der app `index.html` Homepage verweisen den Namen der das Plugin-JavaScript-Schnittstelle, als handele es sich im gleichen Quellverzeichnis,:
+
+        <script src="myplugin.js"></script>
+    
+
+Führen Sie dann einen Befehl wie den folgenden zu testen, ob iOS Abhängigkeiten richtig geladen:
+
+        $ plugman -platform ios /path/to/my/project/www /path/to/my/plugin
+    
+
+Einzelheiten zum `plugman` Optionen, siehe unter Verwendung Plugman zu Plugins verwalten. Finden Sie Informationen zu tatsächlich *debug* Plugins jede Plattform systemeigene Schnittstelle an der Unterseite dieser Seite verzeichnet.
+
+## Die JavaScript-Schnittstelle
+
+JavaScript stellt die vorderseitige-Schnittstelle, so dass es vielleicht den wichtigsten Teil des Plugins. Sie können Ihr Plugin-JavaScript strukturieren, aber Sie mögen, aber Sie aufrufen müssen `cordova.exec` für die Kommunikation mit der einheitlichen Plattform, mit der folgenden Syntax:
+
+        cordova.exec(function(winParam) {},
+                     function(error) {},
+                     "service",
+                     "action",
+                     ["firstArgument", "secondArgument", 42, false]);
+    
+
+So funktioniert jedes Parameters:
+
+*   `function(winParam) {}`: Ein Erfolg-Callback-Funktion. Vorausgesetzt, Ihre `exec` Aufruf erfolgreich abgeschlossen ist, diese Funktion führt zusammen mit allen Parametern, die Sie an es übergeben.
+
+*   `function(error) {}`: Eine Fehler-Callback-Funktion. Wenn der Vorgang nicht erfolgreich abgeschlossen wird, führt diese Funktion mit einem optionalen Parameter.
+
+*   `"service"`: Der Dienstname für die systemeigene Seite aufrufen. Dies entspricht einer systemeigenen Klasse, für die weitere Informationen in den einheimischen Führern, die unten aufgeführten verfügbar ist.
+
+*   `"action"`: Den Namen der Aktion auf die systemeigene Seite aufrufen. Dies entspricht im Allgemeinen der systemeigenen Klasse-Methode. Finden Sie die nativen Handbüchern aufgeführt.
+
+*   `[/* arguments */]`: Ein Array von Argumenten in der nativen Umgebung übergeben.
+
+## Beispiel JavaScript
+
+Dieses Beispiel zeigt eine Möglichkeit, das Plugin-JavaScript-Schnittstelle implementieren:
+
+        window.echo = function(str, callback) {
+            cordova.exec(callback, function(err) {
+                callback('Nothing to echo.');
+            }, "Echo", "echo", [str]);
+        };
+    
+
+In diesem Beispiel das Plugin heftet sich an die `window` -Objekts als die `echo` -Funktion, die Plugin-Benutzer wie folgt nennen würde:
+
+        window.echo("echome", function(echoValue) {
+            alert(echoValue == "echome"); // should alert true.
+        });
+    
+
+Sehen Sie sich die letzten drei Argumente für die `cordova.exec` Funktion. Die ersten Aufforderungen der `Echo` *Dienst*, einen Klassennamen. Die zweiten Anfragen der `echo` *Aktion*, eine Methode in der betreffenden Klasse. Der dritte ist ein Array von Argumenten, welche die Echo-Zeichenfolge, die die `window.echo` Funktion ist der erste Parameter.
+
+Der Erfolg-Rückruf übergebenen `exec` ist lediglich ein Verweis auf die Callback-Funktion `window.echo` nimmt. Wenn die native Plattform den Fehler-Rückruf ausgelöst wird, ruft den Erfolg-Rückruf es einfach auf und übergibt eine Standardzeichenfolge.
+
+## Native Schnittstellen
+
+Wenn Sie JavaScript für Ihr Plugin definieren, müssen Sie es mit mindestens einem nativen Implementierung zu ergänzen. Details für jede Plattform sind unten aufgeführt, und jede baut auf dem einfachen Echo-Plugin-Beispiel oben:
+
+*   Amazon Fire OS Plugins
+*   Android Plugins
+*   iOS Plugins
+*   BlackBerry 10 Plugins
+*   Windows Phone Plugins
+
+Tizen-Plattform unterstützt keine Plugins.
+
+## Publishing Plugins
+
+Wenn Sie Ihr Plugin zu entwickeln, empfiehlt es sich, zu veröffentlichen und mit der Community teilen. Können Sie das Plugin auf der Cordova-Registrierung veröffentlichen (basierend auf [ `npmjs` ][3]) oder jede andere `npmjs` -basierte Registry. Andere Entwickler können installieren automatisch mit entweder `plugman` oder Cordova-CLI. (Für Details zu jedem Entwicklungspfad, siehe Plugman Plugins verwalten und die Befehlszeilenschnittstelle verwenden.)
+
+ [3]: https://github.com/isaacs/npmjs.org
+
+Um ein Plugin zu veröffentlichen, Sie verwenden müssen, die `plugman` -tool und gehen Sie durch die folgenden Schritte aus:
+
+    $ plugman adduser # that is if you don't have an account yet
+    $ plugman publish /path/to/your/plugin
+    
+
+Das ist es!
+
+Unter `plugman --help` sind andere verfügbare registrierungsbasierte Befehle aufgeführt.
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/2506e7b9/docs/de/3.4.0/guide/hybrid/webviews/index.md
----------------------------------------------------------------------
diff --git a/docs/de/3.4.0/guide/hybrid/webviews/index.md b/docs/de/3.4.0/guide/hybrid/webviews/index.md
new file mode 100644
index 0000000..0406502
--- /dev/null
+++ b/docs/de/3.4.0/guide/hybrid/webviews/index.md
@@ -0,0 +1,25 @@
+---
+
+license: Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file distributed with this work for additional information regarding copyright ownership. The ASF licenses this file to you under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at
+
+           http://www.apache.org/licenses/LICENSE-2.0
+    
+         Unless required by applicable law or agreed to in writing,
+         software distributed under the License is distributed on an
+         "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+         KIND, either express or implied.  See the License for the
+         specific language governing permissions and limitations
+    
+
+   under the License.
+---
+
+# Einbetten von Webansichten für
+
+Cordova-Anwendungen werden normalerweise als eine Browser-basierte *WebView* innerhalb der native mobile Plattform implementiert. In diesem Abschnitt zeigt, wie, Stütz-Plattformen, um eigene WebView erstellen Komponenten, die voll von Cordova APIs verwenden. Sie können dann diese Cordova-Anwendungskomponenten zusammen mit systemeigenen Komponenten in einer Hybridanwendung bereitstellen.
+
+Wenn einen WebView bereitstellen möchten, müssen Sie mit jedem native Programmierumgebung vertraut sein. Im folgenden finden Sie Anweisungen für die unterstützten Plattformen:
+
+*   Amazon Fire OS Webansichten für
+*   Android Webansichten für
+*   iOS Webansichten für
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/2506e7b9/docs/de/3.4.0/guide/overview/index.md
----------------------------------------------------------------------
diff --git a/docs/de/3.4.0/guide/overview/index.md b/docs/de/3.4.0/guide/overview/index.md
new file mode 100644
index 0000000..d00d13f
--- /dev/null
+++ b/docs/de/3.4.0/guide/overview/index.md
@@ -0,0 +1,63 @@
+---
+
+license: Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file distributed with this work for additional information regarding copyright ownership. The ASF licenses this file to you under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at
+
+           http://www.apache.org/licenses/LICENSE-2.0
+    
+         Unless required by applicable law or agreed to in writing,
+         software distributed under the License is distributed on an
+         "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+         KIND, either express or implied.  See the License for the
+         specific language governing permissions and limitations
+         under the License.
+    
+
+---
+
+# Übersicht
+
+Cordova ist ein Open-Source-mobile-Entwicklung-Framework. Sie können standard-Web-Technologien wie HTML5, CSS3 und JavaScript für Cross-Plattform-Entwicklung, Vermeidung jeder mobilen Plattformen native Entwicklung der Sprache zu verwenden. Anwendungen werden in Verpackungen, die gezielt auf jede Plattform und verlassen sich auf standardkonforme API Anbindungen an jedes Gerät Sensoren, Daten und Netzwerkstatus zugreifen.
+
+Verwenden Sie Cordova, falls Sie sind:
+
+*   mobile Entwickler und wollen eine Anwendung über mehrere Plattformen hinweg zu erweitern, ohne es erneut mit Sprache und Tool jede Plattform implementieren festgelegt.
+
+*   Speichern Portale, Webentwickler und wollen eine Webanwendung bereitstellen, die für den Vertrieb in verschiedenen app gepackt ist.
+
+*   mobile Entwickler interessiert mischen systemeigene Anwendungskomponenten mit einer *WebView* (Browser-Fenster), die auf Geräteebene APIs, zugreifen kann oder wollen Sie eine Plugin-Schnittstelle zwischen systemeigenen und WebView Komponenten entwickeln.
+
+## Basiskomponenten
+
+Cordova-Anwendungen basieren auf einer gemeinsamen `config.xml` -Datei, enthält Informationen über die app und gibt Parameter, die beeinflussen, wie es funktioniert, z. B. ob es reagiert auf Orientierung verschiebt. Diese Datei entspricht der W3C-Spezifikation für [Verpackt Web App][1]oder *Widget*.
+
+ [1]: http://www.w3.org/TR/widgets/
+
+Die Anwendung selbst ist als eine Web-Seite implementiert, mit dem Namen *index.html* standardmäßig die verweist, was CSS, JavaScript, Bilder, Mediendateien, oder andere Ressourcen sind notwendig für die Ausführung. Die app führt als ein *WebView* in der Ausgangsanwendung-Wrapper, die Sie auf app Stores zu verteilen. Für die Web-app für die Interaktion mit verschiedenen Gerätefunktionen Weg native apps zu tun, muss es auch verweisen eine `cordova.js` -Datei, die API Bindungen bietet.
+
+Der Cordova-fähigen WebView kann die Anwendung mit der gesamten Benutzeroberfläche bereitstellen. Es kann auch eine Komponente innerhalb einer größeren, Hybridanwendung sein, die die WebView mit nativen Komponenten mischt. Cordova bietet eine *Plugin* -Schnittstelle für diese Komponenten miteinander kommunizieren.
+
+## Entwicklungspfade
+
+Ab Version 3.0 können Sie zwei einfache Workflows verwenden, um eine mobile Anwendung zu erstellen. Während Sie das gleiche mit beiden Workflows ausführen können, sind bestimmte Aufgaben besser geeignet zur Verwendung von einem Workflow über die andere. Aus diesem Grund sollten Sie beide Workflows kennen, damit Sie das beste Werkzeug für die beste Situation verwenden können.
+
+Die zwei wichtigsten Workflows, die unterstützt werden sind der *Web Projekt Dev* -Workflow und der *Einheitlichen Plattform Dev* -Workflow.
+
+### Web-Projekt-Dev
+
+Sie können den ersten Workflow als *Web Projekt Dev* -Workflow vorstellen. Sie sollten diesen Workflow verwenden, wenn eine Cordova-Anwendung zu erstellen, die auf so viele mobile Betriebssysteme wie möglich mit so wenig plattformspezifische Entwicklungsarbeit wie möglich ausgeführt werden soll. Dieser Workflow erbte bestehen mit Cordova 3.0 und die Schaffung von Cordova- *Befehlszeilenschnittstelle* (CLI). Die CLI abstrahiert entfernt viele der Funktionen von Low-Level-Shell-Skripte, die Pflege der Details, die mit dem Bau Ihrer Anwendung, z. B. Kopieren-Ihr Web-Vermögen in die richtigen Ordner für jede mobile Plattform, Plattform-spezifische Konfigurationsänderungen oder Ausführen von bestimmten Buildskripts um Anwendungsbinärdateien zu generieren. Erfahren Sie mehr über den *Web-Projekt-Dev* -Workflow in der Command-Line Interface. Bitte beachten Sie, dass oft, wenn Menschen von der "CLI" sprechen, sie über dieses *Web-Projekt-Dev* -Workflow sprechen.
+
+### Native Plattform-Dev
+
+Der zweite Workflow kann als *Native Plattform Dev* Workflow betrachtet werden. Sie sollten es verwenden, wenn Sie wollen sich auf die Erstellung einer Anwendung für eine einzige Plattform und ändern die Low-Level-Plattform-Details interessiert sind. Während Sie diesen Workflow noch verwenden können, um Cross-Plattform-Anwendungen erstellen, wird der Mangel an Tools, um die verschiedenen Buildschritte abstrahieren erschweren. Beispielsweise müssen Sie Plugman verwenden, um das gleiche Plugin einmal für jede Plattform zu installieren, die Sie unterstützen möchten. Der Vorteil bei der Verwendung dieser *Einheitlichen Plattform Dev* -Workflow ist es, was gibt Ihnen Zugang zu den Low-Level-Shell-Skripte erstellen und Testen der Anwendung, also wenn Sie auf die systemeigene Seite der Dinge Hacking sind, diesen Workflow ist der effizienteste Weg, um Ihre Änderungen zu testen. Dieser Workflow ist auch geeignet, wenn Sie die CordovaWebView als eine kleine Rolle in einer größeren 
 native Anwendung verwenden möchten (siehe Einbettung Webansichten für Guide.) Sie können diesen Workflow in den verschiedenen Shell-Tool-Führern, z.B. Android Shell Tool Guide und iOS Shell Tool Guide nachlesen.
+
+Beim ersten ausgehend, könnte es am einfachsten, den *Web Projekt Dev* -Workflow verwenden zum Erstellen einer Anwendung sein. (Um die CLI zu installieren, siehe The Command-Line Interface). Abhängig von den Plattformen richten möchten, können Sie auf der CLI für schrittweise größere Anteile des Entwicklungszyklus verlassen:
+
+*   Im einfachsten Szenario können die CLI Sie einfach erstellen ein neues Projekt, das gefüllt ist mit Standard-Konfiguration zu ändern.
+
+*   Für viele mobile Plattformen können Sie auch die CLI einrichten weitere Projekt-Dateien erforderlich, um innerhalb jedes SDK kompilieren. Damit dies funktioniert müssen Sie jede gezielte Plattform-SDK installieren. (Siehe den Plattform-Führern Anweisungen.) Gemäß den Plattform-Support-Tabelle, müssen Sie möglicherweise die CLI auf verschiedenen Betriebssystemen abhängig von der Zielplattform ausgeführt.
+
+*   Zur Unterstützung der Plattformen, kann die CLI Dienstprogramme kompilieren und führen sie in einem SDK-basiertes Gerät-Emulator. Für umfassende Tests, können Sie auch Anwendungsdateien zu generieren und installieren Sie sie direkt auf einem Gerät.
+
+Zu jedem Zeitpunkt im Entwicklungszyklus wechseln Sie mit mehr von der *Einheitlichen Plattform Dev* -Workflow. Die plattformspezifischen SDK Tools können eine umfangreichere Optionen bieten. (Siehe die Plattform-Führer für Details über jede Plattform-SDK-Tool festgelegt.)
+
+Eine SDK-Umgebung ist besser geeignet, wenn Sie möchten, eine Hybrid-app zu implementieren, die Web-basierte und native Anwendungskomponenten mischt. Sie können das Befehlszeile-Dienstprogramm verwenden, um zunächst die app generieren oder iterativ danach, aktualisierten Code zu SDK-Tools zu ernähren. Sie können die app-Konfigurationsdatei auch selbst erstellen. (Siehe die Datei config.xml Datei für Details.)
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/2506e7b9/docs/de/3.4.0/guide/platforms/amazonfireos/config.md
----------------------------------------------------------------------
diff --git a/docs/de/3.4.0/guide/platforms/amazonfireos/config.md b/docs/de/3.4.0/guide/platforms/amazonfireos/config.md
new file mode 100644
index 0000000..a4c5001
--- /dev/null
+++ b/docs/de/3.4.0/guide/platforms/amazonfireos/config.md
@@ -0,0 +1,53 @@
+---
+
+license: Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file distributed with this work for additional information regarding copyright ownership. The ASF licenses this file to you under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at
+
+           http://www.apache.org/licenses/LICENSE-2.0
+    
+         Unless required by applicable law or agreed to in writing,
+         software distributed under the License is distributed on an
+         "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+         KIND, either express or implied. See the License for the
+         specific language governing permissions and limitations
+    
+
+   under the License.
+---
+
+# Amazon Fire OS Konfiguration
+
+Die `config.xml` Datei steuert eine app-Grundeinstellungen, die für jede Anwendung und CordovaWebView Instanz gelten. Dieser Abschnitt Informationen über Einstellungen, die nur für Amazon Fire OS gelten baut. Finden Sie die Datei config.xml Datei Informationen auf globalen Konfigurations-Optionen.
+
+*   `KeepRunning`(Boolean, wird standardmäßig auf `true` ): bestimmt, ob die Anwendung bleibt auch nach im Hintergrund läuft ein `pause` -Ereignis ausgelöst.
+    
+        <preference name="KeepRunning" value="false"/>
+        
+
+*   `ErrorUrl`: Gibt eine Fehlerseite, die als Reaktion auf standard-HTTP-Fehler im Bereich von 400-500 anzeigt. Platzieren Sie die angegebene Datei im obersten Verzeichnis enthält die Homepage und andere Web-Ressourcen.
+    
+        <preference name="ErrorUrl" value="error.html"/>
+        
+
+*   `LoadingDialog`: Zeigen Sie einen nativen Dialog, wenn die app laden. Der Wert Format ist *Titel, Nachricht*
+    
+        <preference name="LoadingDialog" value="Please wait, the app is loading"/>
+        
+
+*   `LoadingPageDialog`: Zeigen Sie einen nativen Dialog, wenn Unterseiten innerhalb einer app laden. Der Wert Format ist *Titel, Nachricht*
+    
+        <preference name="LoadingPageDialog" value="Please wait, the data is loading"/>
+        
+
+*   `LoadUrlTimeoutValue`(Anzahl, Standard ist `20000` ): beim Laden einer Seite, die Zeitspanne zu warten, bevor ein Timeoutfehler auslösen. In diesem Beispiel gibt 10 Sekunden anstatt 20:
+    
+        <preference name="LoadUrlTimeoutValue" value="10000"/>
+        
+
+*   `SplashScreen`: Der Name der Datei abzüglich ihrer Erweiterung in das `res/drawable` Verzeichnis. Verschiedene Vermögenswerte müssen diesem gemeinsamen Namen in verschiedenen Unterverzeichnissen teilen.
+    
+        <preference name="SplashScreen" value="splash"/>
+        
+
+*   `SplashScreenDelay`(Nummer, der Standardwert ist `5000` ): die Zeitspanne zeigt das Bild des Begrüßungsbildschirms.
+    
+        <preference name="SplashScreenDelay" value="10000"/>
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/2506e7b9/docs/de/3.4.0/guide/platforms/amazonfireos/index.md
----------------------------------------------------------------------
diff --git a/docs/de/3.4.0/guide/platforms/amazonfireos/index.md b/docs/de/3.4.0/guide/platforms/amazonfireos/index.md
new file mode 100644
index 0000000..c771d61
--- /dev/null
+++ b/docs/de/3.4.0/guide/platforms/amazonfireos/index.md
@@ -0,0 +1,127 @@
+---
+
+Lizenz: eine oder mehrere Mitwirkende/r Lizenzverträge an die Apache Software Foundation (ASF) lizenziert. Finden Sie verteilte mit dieser Arbeit für weitere Informationen bezüglich Urheberrecht und Datenschutz-Datei. Die ASF-Lizenzen-diese Datei, um Sie unter der Apache License, Version 2.0 (die "Lizenz"); Sie können diese Datei nur in Übereinstimmung mit der Lizenz. Sie können eine Kopie der Lizenz zu erhalten.
+
+           http://www.Apache.org/licenses/LICENSE-2.0 sofern gesetzlich erforderlich oder schriftlich vereinbart, ist die Software unter der Lizenz verteilt auf einer "AS IS" BASIS, ohne Gewährleistungen oder Bedingungen irgendwelcher Art, weder ausdrücklich noch stillschweigend.  Finden Sie die Lizenz für die jeweilige Sprache, EZB, Berechtigungen und Beschränkungen
+    
+
+## unter der Lizenz.
+
+# Handbuch für die OS-Plattform von Amazon-Feuer
+
+Diese Anleitung zeigt Ihre Entwicklungsumgebung SDK einrichten, Cordova apps für Amazon-Feuer-OS-Geräte wie der Kindle Fire HDX bereitstellen.
+
+Finden Sie im folgenden detaillierte Plattform-spezifischen Informationen:
+
+*   Amazon Fire OS Konfiguration
+*   Amazon Fire OS Webansichten für
+*   Amazon Fire OS Plugins
+
+## Anforderungen und Unterstützung
+
+Die Entwicklung von Cordova apps für Amazon Fire OS erfordert das Android SDK und das Amazon-WebView-SDK. Überprüfen Sie die Anforderungen für diese SDKs an den Verbindungen unten:
+
+*   [Android SDK-System][1]
+
+*   [Amazon WebView SDK][2]
+
+ [1]: http://developer.android.com/sdk/
+ [2]: https://developer.amazon.com/sdk/fire/IntegratingAWV.html#installawv
+
+## Installation
+
+### Android SDK
+
+Installieren Sie das Android SDK von [developer.android.com/sdk][1]. Sie können mit einer Wahl, wo das SDK installieren vorgelegt werden sonst die heruntergeladenen verschieben `adt-bundle` Baum, wo Sie Entwicklungstools zu speichern.
+
+Für Cordova Kommandozeilen-Tools arbeiten, müssen Sie das SDK enthalten `tools` und `platform-tools` Verzeichnisse in Ihrer PATH-Umgebung.
+
+Auf Mac, Linux oder andere Unix-ähnliche Plattformen, können Sie einen Text-Editor zum Erstellen oder ändern die `~/.bash_profile` -Datei eine Zeile wie die folgende, je nachdem, wo das SDK installiert:
+
+    Export PATH = ${PATH}: / Entwicklung/Adt-Bundle/Sdk/Plattform-Tools: / Entwicklung/Adt-Bundle/Sdk/Tools
+    
+
+Dies macht die SDK-Tools im neu eröffneten terminal-Fenster verfügbar. Sonst laufen Sie hier, um sie in der aktuellen Sitzung zur Verfügung stellen:
+
+    $ Quelle ~/.bash_profile
+    
+
+Die PATH-Umgebung unter Windows 7 zu ändern:
+
+*   Im Menü " **Start** " in der unteren linken Ecke des Desktops mit der rechten Maustaste auf **Computer**, klicken, **Eigenschaften**.
+
+*   Klicken Sie in der Spalte auf der linken Seite auf **Erweiterte Systemeinstellungen** .
+
+*   Drücken Sie im daraufhin angezeigten Dialogfeld **Umgebungsvariablen**.
+
+*   Wählen Sie die **PATH** -Variable und klicken Sie **Bearbeiten**.
+
+*   Fügen Sie Folgendes in den Pfad basierend auf dem Sie das SDK, zum Beispiel installiert:
+    
+        ;C:\Development\adt-bundle\sdk\platform-Tools;C:\Development\adt-bundle\sdk\tools
+        
+
+*   Speichern Sie den Wert und schließen Sie beide Dialogfelder zu.
+
+Sie müssen möglicherweise auch Java und Ant öffnen eine Eingabeaufforderung und geben aktivieren `java` , und geben Sie auch `ant` . Hängen Sie an den Pfad, welcher nicht ausgeführt:
+
+    ;%JAVA_HOME%\bin;%ANT_HOME%\bin
+    
+
+### Amazon WebView SDK
+
+Laden Sie das Amazon WebView SDK aus dem [Amazon-Entwicklerportal][2].
+
+*   Erstellen einer `libs/` Ordner im `~/.cordova/lib/amazon-fireos/cordova/3.1.0/` Ordner.
+*   Fügen Sie die `awv_interface.jar` aus dem heruntergeladenen SDK zu`~/.cordova/lib/amazon-fireos/cordova/3.1.0/libs/`
+
+## Öffnen Sie ein Projekt im SDK
+
+Verwendung der `cordova` Utility für ein neues Projekt, wie in der Cordova The Command-Line Interface beschrieben einrichten. Zum Beispiel in einem Quellcode-Verzeichnis:
+
+    $ cordova create hello com.example.hello "HelloWorld"
+    $ cd hello
+    $ cordova platform add amazon-fireos
+    $ cordova build
+    
+
+Einmal erstellt, wird hier das SDK zu verwenden, um es zu ändern:
+
+*   Starten Sie die **Eclipse** -Anwendung.
+
+*   Wählen Sie **Neues Projekt** .
+
+*   Wählen Sie **Android Projekt aus vorhandenem Code** aus dem daraufhin angezeigten Dialogfeld, und klicken Sie auf **weiter**: ![][3]
+
+*   Navigieren Sie zu `hello` , oder welches Verzeichnis Sie für das Projekt erstellt, dann auf die `platforms/amazon-fireos` Unterverzeichnis.
+
+*   Drücken Sie **Fertig stellen**.
+
+ [3]: img/guide/platforms//eclipse_new_project.png
+
+Sobald das Eclipse-Fenster wird geöffnet, erscheint ein rotes **X** auf ungelöste Probleme hinweisen. Wenn ja, gehen Sie zusätzlichen folgendermaßen:
+
+*   Rechtsklick auf das Projektverzeichnis.
+
+*   Wählen Sie in den daraus resultierenden **Eigenschaften** im Navigationsbereich des **Android** .
+
+*   Erstellen Sie Ziel für das Projekt zu, wählen Sie die höchste Android API-Ebene, die Sie installiert haben.
+
+*   Klicken Sie auf **OK**.
+
+*   Wählen Sie im Menü **Projekt** **Clean** . Dies sollten alle Fehler im Projekt korrigieren.
+
+## Bereitstellung auf Gerät
+
+Um eine app direkt auf das Gerät zu drücken, stellen Sie sicher, dass USB debugging auf dem Gerät wie beschrieben auf der [Android Developer-Website][4]aktiviert ist, und verwenden Sie einen Mini-USB-Kabel zu, um es an Ihr System anschließen.
+
+ [4]: http://developer.android.com/tools/device.html
+
+Drücken Sie die app auf das Gerät von der Befehlszeile aus:
+
+    $ cordova run amazon-fireos
+    
+
+Abwechselnd innerhalb von Eclipse, Maustaste auf das Projekt, und wählen Sie **Ausführen als → Android-Anwendung**.
+
+**Hinweis**: derzeit über einen Emulator testen wird nicht unterstützt für Amazon WebView-apps basierte.
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/2506e7b9/docs/de/3.4.0/guide/platforms/amazonfireos/plugin.md
----------------------------------------------------------------------
diff --git a/docs/de/3.4.0/guide/platforms/amazonfireos/plugin.md b/docs/de/3.4.0/guide/platforms/amazonfireos/plugin.md
new file mode 100644
index 0000000..fac2acd
--- /dev/null
+++ b/docs/de/3.4.0/guide/platforms/amazonfireos/plugin.md
@@ -0,0 +1,100 @@
+---
+
+license: Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file distributed with this work for additional information regarding copyright ownership. The ASF licenses this file to you under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at
+
+           http://www.apache.org/licenses/LICENSE-2.0
+    
+         Unless required by applicable law or agreed to in writing,
+         software distributed under the License is distributed on an
+         "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+         KIND, either express or implied. See the License for the
+         specific language governing permissions and limitations
+    
+
+   under the License.
+---
+
+# Amazon Fire OS Plugins
+
+Folgen Sie den Anweisungen im Handbuch für das Android Plugins für einen Überblick über die Entwicklung von benutzerdefinierten Plugins.
+
+## Echo Amazon Fire OS Plugin Beispiel
+
+Um die JavaScript-Schnittstelle in Anwendung Plugins beschriebene *Echo* -Funktion, verwenden die `plugin.xml` zu injizieren eines `feature` Spezifikation der lokalen Plattform `config.xml` Datei:
+
+    <platform name="amazon-fireos">
+        <config-file target="config.xml" parent="/*">
+            <feature name="Echo">
+                <param name="android-package" value="org.apache.cordova.plugin.Echo"/>
+            </feature>
+        </config-file>
+    </platform>
+    
+
+Fügen Sie die folgenden Schritte, um die `src/org/apache/cordova/plugin/Echo.java` Datei:
+
+    package org.apache.cordova.plugin;
+    
+    import org.apache.cordova.CordovaPlugin;
+    import org.apache.cordova.CallbackContext;
+    
+    import org.json.JSONArray;
+    import org.json.JSONException;
+    import org.json.JSONObject;
+    
+    /**
+     * This class echoes a string called from JavaScript.
+     */
+    public class Echo extends CordovaPlugin {
+    
+        @Override
+        public boolean execute(String action, JSONArray args, CallbackContext callbackContext) throws JSONException {
+            if (action.equals("echo")) {
+                String message = args.getString(0);
+                this.echo(message, callbackContext);
+                return true;
+            }
+            return false;
+        }
+    
+        private void echo(String message, CallbackContext callbackContext) {
+            if (message != null && message.length() > 0) {
+                callbackContext.success(message);
+            } else {
+                callbackContext.error("Expected one non-empty string argument.");
+            }
+        }
+    }
+    
+
+Wenn Sie möchten wiederverwenden Android Plugin-Code für die Amazon-Feuer-OS-Plattform dann ändern die plugin.xml darauf zu die `android` bestimmte Quelldatei. Zum Beispiel
+
+    <platform name="amazon-fireos">
+        <config-file target="config.xml" parent="/*">
+            <feature name="Echo">
+                <param name="android-package" value="org.apache.cordova.plugin.Echo"/>
+            </feature>
+        </config-file>
+        <source-file src="src/android/Echo.java" target-dir="src/org/apache/cordova/plugin" />
+    </platform>
+    
+
+Möchten Sie eine angepasste Plugin für die Amazon-Feuer-OS-Plattform zu schreiben, dann erstellen Sie einen Ordner mit dem Namen `amazon` unter Ihr Plugin-Src / Ordner und ändern die plugin.xml darauf zu die `amazon` bestimmte Quelldatei. Zum Beispiel
+
+    <platform name="amazon-fireos">
+        <config-file target="config.xml" parent="/*">
+            <feature name="Echo">
+                <param name="android-package" value="org.apache.cordova.plugin.Echo"/>
+            </feature>
+        </config-file>
+        <source-file src="src/amazon/Echo.java" target-dir="src/org/apache/cordova/plugin" />
+    </platform>
+    
+
+## Verwendung von Amazon WebView in Ihr plugin
+
+Cordova für Amazon Fire OS nutzt benutzerdefinierte Amazon WebView, die auf der Open-Source-Projekt Chromium basiert. Es ist GPU beschleunigt und optimiert für die flüssige Performance am Feuer zu entzünden.
+
+Um zu verstehen, wie man am besten Amazon WebView in Ihrem Projekt verwenden, überprüfen Sie heraus das [Amazon-Entwicklerportal][1].
+
+ [1]: https://developer.amazon.com/sdk/fire/IntegratingAWV.html
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/2506e7b9/docs/de/3.4.0/guide/platforms/amazonfireos/webview.md
----------------------------------------------------------------------
diff --git a/docs/de/3.4.0/guide/platforms/amazonfireos/webview.md b/docs/de/3.4.0/guide/platforms/amazonfireos/webview.md
new file mode 100644
index 0000000..be80d28
--- /dev/null
+++ b/docs/de/3.4.0/guide/platforms/amazonfireos/webview.md
@@ -0,0 +1,116 @@
+---
+
+license: Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file distributed with this work for additional information regarding copyright ownership. The ASF licenses this file to you under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at
+
+           http://www.apache.org/licenses/LICENSE-2.0
+    
+         Unless required by applicable law or agreed to in writing,
+         software distributed under the License is distributed on an
+         "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+         KIND, either express or implied.  See the License for the
+         specific language governing permissions and limitations
+    
+
+   under the License.
+---
+
+# Amazon Fire OS Webansichten für
+
+Beginnend mit 3.0.0, können Sie Cordova als Komponente in Amazon-Feuer-OS-Anwendungen. Amazon Fire OS bezieht sich auf diese Komponente als `CordovaWebView` . `CordovaWebView`erweitert Amazon WebView, die auf der open-Source-Projekt Chromium basiert. Durch die Nutzung dieser Funktion, können Ihre Webanwendungen der neuesten HTML5-Web-Standards, die in einem modernen Web-Runtime-Engine ausgeführt nutzen.
+
+## Voraussetzungen
+
+*   Cordova 3.0.0 oder größer
+
+*   Android SDK aktualisiert, um neuesten SDK
+
+*   Amazon WebView SDK
+
+## Anleitung zur Verwendung von CordovaWebView in einem Amazon-Feuer-OS-Projekt
+
+1.  Download [Amazon WebView SDK][1] zu erweitern, und kopieren Sie die awv_interface.jar in `/framework/libs` Verzeichnis. Erstellen einer Libs / Ordner, wenn es nicht vorhanden ist.
+
+2.  `cd`in `/framework` und `ant jar` baut die Cordova-Jar. Es schafft die .jar-Datei als `cordova-x.x.x.jar` in das `/framework` Verzeichnis.
+
+3.  Bearbeiten der Anwendung `main.xml` Datei (unter `/res/layout` ) mit folgenden Aussehen der `layout_height` , `layout_width` und `id` Ihrer Anwendung angepasst:
+    
+        <org.apache.cordova.CordovaWebView
+            android:id="@+id/tutorialView"
+            android:layout_width="match_parent"
+            android:layout_height="match_parent" />
+        
+
+4.  Ihre Aktivität ändern, sodass es implementiert die `CordovaInterface` . Sie sollten die enthaltenen Methoden implementieren. Vielleicht möchten Sie Kopieren von `/framework/src/org/apache/cordova/CordovaActivity.java` , oder setzen sie auf eigene Faust. Das folgende Codefragment zeigt eine einfache Anwendung, die die Schnittstelle verwendet. Beachten Sie, wie die referenzierten anzeigen-Id entspricht der `id` in das XML-Fragment oben angegebene Attribut:
+    
+        public class CordovaViewTestActivity extends Activity implements CordovaInterface {
+            CordovaWebView cwv;
+            /* Called when the activity is first created. */
+            @Override
+            public void onCreate(Bundle savedInstanceState) {
+                super.onCreate(savedInstanceState);
+                setContentView(R.layout.main);
+                cwv = (CordovaWebView) findViewById(R.id.tutorialView);
+                Config.init(this);
+                cwv.loadUrl(Config.getStartUrl());
+            }
+        
+
+ [1]: https://developer.amazon.com/sdk/fire/IntegratingAWV.html#installawv
+
+Wenn Sie die Kamera verwenden, sollten Sie dies auch implementieren:
+
+        @Override
+        public void setActivityResultCallback(CordovaPlugin plugin) {
+            this.activityResultCallback = plugin;
+        }
+        /**
+         * Launch an activity for which you would like a result when it finished. When this activity exits,
+         * your onActivityResult() method is called.
+         *
+         * @param command           The command object
+         * @param intent            The intent to start
+         * @param requestCode       The request code that is passed to callback to identify the activity
+         */
+        public void startActivityForResult(CordovaPlugin command, Intent intent, int requestCode) {
+            this.activityResultCallback = command;
+            this.activityResultKeepRunning = this.keepRunning;
+    
+            // If multitasking turned on, then disable it for activities that return results
+            if (command != null) {
+                this.keepRunning = false;
+            }
+    
+            // Start activity
+            super.startActivityForResult(intent, requestCode);
+        }
+    
+        @Override
+        /**
+         * Called when an activity you launched exits, giving you the requestCode you started it with,
+         * the resultCode it returned, and any additional data from it.
+         *
+         * @param requestCode       The request code originally supplied to startActivityForResult(),
+         *                          allowing you to identify who this result came from.
+         * @param resultCode        The integer result code returned by the child activity through its setResult().
+         * @param data              An Intent, which can return result data to the caller (various data can be attached to Intent "extras").
+         */
+        protected void onActivityResult(int requestCode, int resultCode, Intent intent) {
+            super.onActivityResult(requestCode, resultCode, intent);
+            CordovaPlugin callback = this.activityResultCallback;
+            if (callback != null) {
+                callback.onActivityResult(requestCode, resultCode, intent);
+            }
+        }
+    
+
+Denken Sie daran, den Threadpool hinzufügen, sonst die Plugins keine Threads ausgeführt:
+
+        @Override
+        public ExecutorService getThreadPool() {
+            return threadPool;
+        }
+    
+
+1.  Kopieren Sie Ihre Anwendung HTML und JavaScript-Dateien zu Ihrem Amazon-Feuer-OS-Projekts `/assets/www` Verzeichnis.
+
+2.  Kopie `config.xml` von `/framework/res/xml` zu Ihrem Projekts `/res/xml` Verzeichnis.
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/2506e7b9/docs/de/3.4.0/guide/platforms/android/config.md
----------------------------------------------------------------------
diff --git a/docs/de/3.4.0/guide/platforms/android/config.md b/docs/de/3.4.0/guide/platforms/android/config.md
new file mode 100644
index 0000000..2a70ac8
--- /dev/null
+++ b/docs/de/3.4.0/guide/platforms/android/config.md
@@ -0,0 +1,71 @@
+---
+
+license: Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file distributed with this work for additional information regarding copyright ownership. The ASF licenses this file to you under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at
+
+           http://www.apache.org/licenses/LICENSE-2.0
+    
+         Unless required by applicable law or agreed to in writing,
+         software distributed under the License is distributed on an
+         "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+         KIND, either express or implied. See the License for the
+         specific language governing permissions and limitations
+    
+
+   under the License.
+---
+
+# Android-Konfiguration
+
+Die `config.xml` Datei steuert eine app-Grundeinstellungen, die für jede Anwendung und CordovaWebView Instanz gelten. Dieser Abschnitt beschreibt die Einstellungen, die nur auf Android Builds gelten. Finden Sie die Datei config.xml Datei Informationen auf globalen Konfigurations-Optionen.
+
+*   `KeepRunning`(Boolean, wird standardmäßig auf `true` ): bestimmt, ob die Anwendung bleibt auch nach im Hintergrund läuft ein `pause` -Ereignis ausgelöst. Hinweis: Diese Einstellung auf False wird nicht töten die app nach einer Pause, wird es nur Ausführung von Code in der Webview Cordova zu stoppen, während die app im Hintergrund ist.
+    
+        <preference name="KeepRunning" value="false"/>
+        
+
+*   `LoadUrlTimeoutValue`(Nummer in Millisekunden, standardmäßig `20000` , 20 Sekunden): beim Laden einer Seite, die Zeitspanne zu warten, bevor ein Timeoutfehler auslösen. In diesem Beispiel gibt 10 Sekunden anstatt 20:
+    
+        <preference name="LoadUrlTimeoutValue" value="10000"/>
+        
+
+*   `SplashScreen`(string, der Standardwert ist `splash` ): der Name der Datei abzüglich ihrer Erweiterung in das `res/drawable` Verzeichnis. Verschiedene Vermögenswerte müssen diesem gemeinsamen Namen in verschiedenen Unterverzeichnissen teilen.
+    
+        <preference name="SplashScreen" value="mySplash"/>
+        
+
+*   `SplashScreenDelay`(Zahl in Millisekunden, der Standardwert ist `3000` ): die Zeitspanne zeigt das Bild des Begrüßungsbildschirms.
+    
+        <preference name="SplashScreenDelay" value="10000"/>
+        
+
+*   `InAppBrowserStorageEnabled`(Boolean, wird standardmäßig auf `true` ): Steuerelemente ob Seiten innerhalb einer InAppBrowser geöffnet können Zugriff auf die gleichen LocalStorage und WebSQL Speicher als Seiten mit Standardbrowser geöffnet.
+    
+        <preference name="InAppBrowserStorageEnabled" value="true"/>
+        
+
+*   `LoadingDialog`(string, der Standardwert ist `null` ): Wenn gesetzt, zeigt einen Dialog mit dem angegebenen Titel und Nachricht und einen Spinner, wenn Sie die erste Seite einer Anwendung zu laden. Titel und Nachricht sind durch Kommas getrennt in dieser Wertzeichenfolge, und das Komma wird entfernt, bevor das Dialogfeld angezeigt wird.
+    
+        <preference name="LoadingDialog" value="My Title,My Message"/>
+        
+
+*   `LoadingPageDialog`(string, der Standardwert ist `null` ): dasselbe wie `LoadingDialog` , aber für das Laden von jeder Seite nach der ersten Seite in der Anwendung.
+    
+        <preference name="LoadingPageDialog" value="My Title,My Message"/>
+        
+
+*   `ErrorUrl`(URL, wird standardmäßig auf `null` ): Wenn gesetzt, wird die referenzierte Seite ein Fehler in der Anwendung statt ein Dialogfeld mit dem Titel "Application Error" angezeigt.
+    
+        <preference name="ErrorUrl" value="myErrorPage.html"/>
+        
+
+*   `ShowTitle`(Boolean, wird standardmäßig auf `false` ): den Titel am oberen Rand des Bildschirms anzeigen.
+    
+        <preference name="ShowTitle" value="true"/>
+        
+
+*   `LogLevel`(string, der Standardwert ist `ERROR` ): legt die minimale Protokollebene durch welches Protokoll Nachrichten aus Ihrer Anwendung gefilterte. Gültige Werte sind `ERROR` , `WARN` , `INFO` , `DEBUG` , und`VERBOSE`.
+    
+        <preference name="LogLevel" value="VERBOSE"/>
+        
+
+*   `SetFullscreen`(Boolean, wird standardmäßig auf `false` ): wie die `Fullscreen` Parameter in der globalen Konfiguration dieser XML-Datei. Dieses Android-spezifische Element ist veraltet, zu Gunsten der globalen `Fullscreen` Element, und wird in einer zukünftigen Version entfernt.
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/2506e7b9/docs/de/3.4.0/guide/platforms/android/index.md
----------------------------------------------------------------------
diff --git a/docs/de/3.4.0/guide/platforms/android/index.md b/docs/de/3.4.0/guide/platforms/android/index.md
new file mode 100644
index 0000000..d654c01
--- /dev/null
+++ b/docs/de/3.4.0/guide/platforms/android/index.md
@@ -0,0 +1,194 @@
+---
+
+license: Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file distributed with this work for additional information regarding copyright ownership. The ASF licenses this file to you under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at
+
+           http://www.apache.org/licenses/LICENSE-2.0
+    
+         Unless required by applicable law or agreed to in writing,
+         software distributed under the License is distributed on an
+         "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+         KIND, either express or implied.  See the License for the
+         specific language governing permissions and limitations
+    
+
+   under the License.
+---
+
+# Android-Plattform-Guide
+
+Diese Anleitung zeigt wie Ihre Entwicklungsumgebung SDK eingerichtet, Cordova apps für Android-Geräte bereitzustellen. Es führt Sie durch den Prozess der Installation des Android SDK, öffnen ein Android-Projekt in Eclipse SDK und Bereitstellung auf einem Emulator oder Gerät. Sie müssen folgen dieser Anleitung um mindestens das Android SDK installieren, unabhängig davon, welcher Workflow du folgst. (Die Workflows *Web Projekt Dev* und *Einheitlichen Plattform Dev* erfordern das Android SDK installiert und Ihren Pfad erreichbar werden.)
+
+Finden Sie im folgenden detaillierte Plattform-spezifischen Informationen:
+
+*   Android-Konfiguration
+*   Android Webansichten für
+*   Android Plugins
+*   Aktualisierung von Android
+*   Android-Befehlszeilenprogrammen
+
+Die Befehlszeilentools, die oben beziehen sich auf Versionen vor 3.0 Cordova. Informationen über die aktuelle Schnittstelle finden Sie unter The Command-Line Interface.
+
+## Anforderungen und Unterstützung
+
+Finden Sie die [Systemanforderungen][1] für das Android SDK.
+
+ [1]: http://developer.android.com/sdk/index.html
+
+Cordova unterstützt Android 2.2, 2.3 und 4.x. Als allgemeine Regel sind Plattformen veraltet, da sie weniger als 5 % auf Googles [Verteilung Dashboard][2] Tauchen.
+
+ [2]: http://developer.android.com/about/dashboards/index.html
+
+<!--
+NOTE, doc said:
+- Android 2.1 (Deprecated May 2013)
+- Android 3.x (Deprecated May 2013)
+-->
+
+Entwickler sollten verwenden das `cordova` -Dienstprogramm in Verbindung mit dem Android SDK. Finden Sie unter The Command-Line Interface Informationen installieren Sie es, Projekte, hinzufügen dann erstellen und Bereitstellen eines Projekts.
+
+Installieren Sie das Android SDK von [Developer.Android.com/SDK][3]. Das androide Sdk wird vertrieben als ein ' Adt-Bündel -<os>-<arch>-<ver>' Datei. Unter Windows ist das Adt-Bundle mit einem Installer gepackt. Einfach entpacken Sie auf OSX und Linux, das Adt-Bundle in der Lage, die Sie speichern Entwicklungstools. [Weitere detaillierte Informationen über Android SDK Setup finden Sie hier][4]
+
+ [3]: http://developer.android.com/sdk/
+ [4]: http://developer.android.com/sdk/installing/bundle.html
+
+Für Cordova Kommandozeilen-Tools arbeiten, müssen Sie das SDK enthalten `tools` und `platform-tools` Verzeichnisse in Ihrer PATH-Umgebung. Auf Mac, können Sie einen Text-Editor zum Erstellen oder ändern die `~/.bash_profile` -Datei eine Zeile wie die folgende, je nachdem, wo das SDK installiert:
+
+    Export PATH = ${PATH}: / Entwicklung/Adt-Bundle/Sdk/Plattform-Tools: / Entwicklung/Adt-Bundle/Sdk/Tools
+    
+
+Dies macht die SDK-Tools im neu eröffneten terminal-Fenster verfügbar. Sonst laufen Sie hier, um sie in der aktuellen Sitzung zur Verfügung stellen:
+
+    $ Quelle ~/.bash_profile
+    
+
+Die PATH-Umgebung unter Windows 7 zu ändern:
+
+*   Im Menü " **Start** " in der unteren linken Ecke des Desktops mit der rechten Maustaste auf **Computer**, klicken, **Eigenschaften**.
+
+*   Klicken Sie in der Spalte auf der linken Seite auf **Erweiterte Systemeinstellungen** .
+
+*   Drücken Sie im daraufhin angezeigten Dialogfeld **Umgebungsvariablen**.
+
+*   Wählen Sie die **PATH** -Variable und klicken Sie **Bearbeiten**.
+
+*   Fügen Sie Folgendes in den Pfad basierend auf dem Sie das SDK, zum Beispiel installiert:
+    
+        ;C:\Development\adt-bundle\sdk\platform-tools;C:\Development\adt-bundle\sdk\tools
+        
+
+*   Speichern Sie den Wert und schließen Sie beide Dialogfelder zu.
+
+Sie müssen möglicherweise auch Java und Ant öffnen eine Eingabeaufforderung und geben aktivieren `java` , und geben Sie auch `ant` . Hängen Sie an den Pfad, welcher nicht ausgeführt:
+
+        ;%JAVA_HOME%\bin;%ANT_HOME%\bin
+    
+
+## Öffnen Sie ein Projekt im SDK
+
+Verwendung der `cordova` Utility für ein neues Projekt, wie in der Cordova The Command-Line Interface beschrieben einrichten. Zum Beispiel in einem Quellcode-Verzeichnis:
+
+        $ cordova create hello com.example.hello "HelloWorld"
+        $ cd hello
+        $ cordova platform add android
+        $ cordova build
+    
+
+Einmal erstellt, wird hier das SDK zu verwenden, um es zu ändern:
+
+*   Starten Sie die **Eclipse** -Anwendung.
+
+*   Wählen Sie **Neues Projekt** .
+
+*   Wählen Sie **Android Projekt aus vorhandenem Code** aus dem daraufhin angezeigten Dialogfeld, und klicken Sie auf **weiter**: ![][5]
+
+*   Navigieren Sie zu `hello` , oder welches Verzeichnis Sie für das Projekt erstellt, dann auf die `platforms/android` Unterverzeichnis.
+
+*   Stellen Sie sicher, beide `hello` und `hello-CordovaLib` Projekte werden ausgewählt, importiert werden. Das `hello-CordovaLib` Projekt wird ab Cordova 3.3.0 benötigt, da Cordova jetzt als Android-Bibliothek anstelle einer JAR-Datei verwendet wird.
+
+*   Drücken Sie **Fertig stellen**.
+
+ [5]: img/guide/platforms/android/eclipse_new_project.png
+
+Sobald das Eclipse-Fenster wird geöffnet, erscheint ein rotes **X** auf ungelöste Probleme hinweisen. Wenn ja, gehen Sie zusätzlichen folgendermaßen:
+
+*   Rechtsklick auf das Projektverzeichnis.
+
+*   Wählen Sie in den daraus resultierenden **Eigenschaften** im Navigationsbereich des **Android** .
+
+*   Erstellen Sie Ziel für das Projekt zu, wählen Sie die höchste Android API-Ebene, die Sie installiert haben.
+
+*   Klicken Sie auf **OK**.
+
+*   Wählen Sie im Menü **Projekt** **Clean** . Dies sollten alle Fehler im Projekt korrigieren.
+
+## Bereitstellen auf Emulator
+
+Können Sie das `cordova` -Dienstprogramm eine app in einem Emulator, oder Sie laufen kann es im SDK ausgeführt. In jedem Fall muss das SDK zuerst konfiguriert werden um mindestens ein Gerät anzuzeigen. Verwenden Sie hierzu das Android SDK Manager, eine Java-Anwendung, die separat von Eclipse verläuft. Es gibt zwei Möglichkeiten, es zu öffnen:
+
+*   Führen Sie `android` in der Befehlszeile.
+
+*   Drücken Sie von Eclipse, dieses Symbol in der Symbolleiste:
+    
+    ![][6]
+
+ [6]: img/guide/platforms/android/eclipse_android_sdk_button.png
+
+Nach dem Öffnen zeigt das Android SDK Manager verschiedene Laufzeit-Bibliotheken:
+
+![][7]
+
+ [7]: img/guide/platforms/android/asdk_window.png
+
+Wählen Sie **Extras → Verwaltung AVDs** (Android Virtual Devices), dann wählen Sie ein Element aus **Gerätedefinitionen** in dem daraufhin angezeigten Dialogfeld:
+
+![][8]
+
+ [8]: img/guide/platforms/android/asdk_device.png
+
+Presse **AVD erstellen**, ändern optional den Namen und drücken Sie **OK** um die Änderungen zu übernehmen.
+
+![][9]
+
+ [9]: img/guide/platforms/android/asdk_newAVD.png
+
+Der AVD wird dann in der Liste **Android Virtual Devices** angezeigt:
+
+![][10]
+
+ [10]: img/guide/platforms/android/asdk_avds.png
+
+Um den Emulator als separate Anwendung zu öffnen, wählen Sie den AVD, und drücken Sie **Start**. Es bringt viel, wie es auf dem Gerät mit zusätzliche Steuerelemente für Hardware-Tasten zur Verfügung:
+
+![][11]
+
+ [11]: img/guide/platforms/android/asdk_emulator.png
+
+An dieser Stelle können Sie das `cordova` -Dienstprogramm zum Bereitstellen der Anwendung für den Emulator von der Befehlszeile aus:
+
+        $ cordova emulate android
+    
+
+Wenn Sie stattdessen in Eclipse arbeiten, Maustaste auf das Projekt, und wählen Sie **Ausführen als → Android-Anwendung**. Sie möglicherweise aufgefordert, eine AVD angeben, wenn keine bereits geöffnet.
+
+Verwenden Sie für eine schnellere Erfahrung ein Intel-basierten Emulator-Image:
+
+*   Installieren eine oder mehrere `Intel x86 Atom` System-Images als auch die `Intel Hardware Accelerated Execution Manager` , finden Sie unter **Extras**.
+
+*   Führen Sie das Intel-Installationsprogramm aus, das innerhalb Ihres Android SDK unter verfügbar ist`extras/intel/Hardware_Accelerated_Execution_Manager`.
+
+*   Erstellen Sie eine neue AVD, mit dem Ziel, die auf einem Intel-Bild festgelegt.
+
+*   Wenn Sie den Emulator zu starten, stellen Sie sicher, es gibt keine Fehlermeldungen angezeigt, der angibt, einer Störungsmeldung HAX Module laden.
+
+## Bereitstellung auf Gerät
+
+Um eine app direkt auf das Gerät zu drücken, stellen Sie sicher, dass USB debugging auf dem Gerät wie beschrieben auf der [Android Developer-Website][12]aktiviert ist, und verwenden Sie einen Mini-USB-Kabel zu, um es an Ihr System anschließen.
+
+ [12]: http://developer.android.com/tools/device.html
+
+Drücken Sie die app auf das Gerät von der Befehlszeile aus:
+
+        $ cordova run android
+    
+
+Abwechselnd innerhalb von Eclipse, Maustaste auf das Projekt, und wählen Sie **Ausführen als → Android-Anwendung**.
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/2506e7b9/docs/de/3.4.0/guide/platforms/android/plugin.md
----------------------------------------------------------------------
diff --git a/docs/de/3.4.0/guide/platforms/android/plugin.md b/docs/de/3.4.0/guide/platforms/android/plugin.md
new file mode 100644
index 0000000..fcc40ac
--- /dev/null
+++ b/docs/de/3.4.0/guide/platforms/android/plugin.md
@@ -0,0 +1,176 @@
+---
+
+license: Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file distributed with this work for additional information regarding copyright ownership. The ASF licenses this file to you under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at
+
+           http://www.apache.org/licenses/LICENSE-2.0
+    
+         Unless required by applicable law or agreed to in writing,
+         software distributed under the License is distributed on an
+         "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+         KIND, either express or implied. See the License for the
+         specific language governing permissions and limitations
+    
+
+   under the License.
+---
+
+# Android Plugins
+
+Dieser Abschnitt enthält Informationen für das native Plugin-Code auf der Android-Plattform zu implementieren. Finden Sie bevor Sie dies lesen einen Überblick über die Plugin-Struktur und ihre gemeinsame JavaScript-Schnittstelle Anwendung Plugins. In diesem Abschnitt weiterhin das Beispiel- *Echo* -Plugin, das zum einheitlichen Plattform und zurück von Cordova-Webview kommuniziert. Ein weiteres Beispiel finden Sie auch die Kommentare in [CordovaPlugin.java][1].
+
+ [1]: https://github.com/apache/cordova-android/blob/master/framework/src/org/apache/cordova/CordovaPlugin.java
+
+Android Plugins basieren auf Cordova-Android, bestehend aus einem Android WebView mit Haken verbunden. Plugins werden dargestellt als Klasse Zuordnungen in der `config.xml` Datei. Eine Plugin besteht aus mindestens einer Java-Klasse, die erweitert die `CordovaPlugin` -Klasse überschreiben eines seiner `execute` Methoden. Als beste Praxis, das Plugin sollte auch behandeln, `pause` und `resume` Veranstaltungen, zusammen mit jeder Nachrichtenaustausch zwischen Plugins. Plugins mit lang andauernden Anfragen, Hintergrundaktivitäten wie Medienwiedergabe, Zuhörer oder internen Zustand sollten Implementieren der `onReset()` -Methode. Es wird ausgeführt, wenn die `WebView` navigiert zu einer neuen Seite oder Aktualisierungen, die das JavaScript lädt.
+
+## Plugin-Klasse Zuordnung
+
+Das Plugin-JavaScript-Schnittstelle verwendet die `cordova.exec` -Methode, wie folgt:
+
+        exec(<successFunction>, <failFunction>, <service>, <action>, [<args>]);
+    
+
+Dies marshallt ersuchen die WebView Android native seitlich effektiv Aufrufen der `action` -Methode für die `service` -Klasse, mit zusätzlichen übergebenen Argumente der `args` Array.
+
+Ob Sie eine Plugin als Java-Datei oder als eine *Jar* -Datei eigene verteilen, kann das Plugin angegeben werden, in Ihrer Cordova-Android-Anwendung `res/xml/config.xml` Datei. Weitere Informationen zur Verwendung finden Sie Anwendung Plugins die `plugin.xml` Datei, dies zu injizieren `feature` Element:
+
+        <feature name="<service_name>">
+            <param name="android-package" value="<full_name_including_namespace>" />
+        </feature>
+    
+
+Der verwendet in der JavaScript übereinstimmt `exec` aufrufen. Der Wert ist die Java-Klasse voll qualifizierten Namespacebezeichner. Andernfalls kann das Plugin kompiliert, aber noch nicht verfügbar, Cordova.
+
+## Plugin-Initialisierung und Lebensdauer
+
+Wird eine Instanz eines Plugin-Objekts erstellt, für das Leben eines jeden `WebView` . Plugins werden nicht instanziiert bis sie zuerst durch einen Aufruf von JavaScript, verwiesen wird, es sei denn, `<param>` mit einem `onload` `name` Attribut auf festgelegt ist `"true"` in `config.xml` . Z.B.:
+
+    <feature name="Echo">
+        <param name="android-package" value="<full_name_including_namespace>" />
+        <param name="onload" value="true" />
+    </feature>
+    
+
+Plugins sollten verwenden die `initialize` -Methode für ihre Start-up-Logik.
+
+    @override
+    public void initialize(CordovaInterface cordova, CordovaWebView webView) {
+        super.initialize(cordova, webView);
+        // your init code here
+    }
+    
+
+## Schreibe ein Android Java-Plugin
+
+Ein JavaScript-Aufruf feuert eine Plugin-Anforderung an die systemeigene Seite und das Java-Plugin von Correspoinding zugeordnet ist, richtig in die `config.xml` -Datei, aber was bedeutet die endgültige Android Java Plugin Klasse aussehen? Was auch immer an das Plugin mit JavaScript gesendet wird `exec` Funktion ist in der Plugin-Klasse übergeben `execute` Methode. Die meisten `execute` Implementierungen wie folgt aussehen:
+
+        @Override public Boolean ausführen (String Aktion, JSONArray Args, CallbackContext CallbackContext) löst JSONException {wenn ("beep".equals(action)) {this.beep(args.getLong(0));
+                callbackContext.success();
+                true zurück.
+            } return false;  / / Falsche Ergebnisse in eine "MethodNotFound"-Fehler zurückgegeben.
+        }
+    
+
+Das JavaScript `exec` Funktion `action` Parameter entspricht einer private Klasse-Methode mit optionalen Parametern zu versenden.
+
+Wann Abfangen von Ausnahmen und Fehler zurückgeben, ist es wichtig aus Gründen der Klarheit, die Störungen an JavaScript Spiel Java Ausnahme Namen so weit wie möglich zurückgegeben.
+
+## Threading
+
+Das Plugin-JavaScript ist *nicht* führen Sie in der Haupt-Thread der die `WebView` Schnittstelle; stattdessen läuft auf die `WebCore` thread, wie die `execute` Methode. Wenn Sie mit der Benutzeroberfläche interagieren müssen, verwenden Sie die folgende Variante:
+
+        @Override
+        public boolean execute(String action, JSONArray args, final CallbackContext callbackContext) throws JSONException {
+            if ("beep".equals(action)) {
+                final long duration = args.getLong(0);
+                cordova.getActivity().runOnUiThread(new Runnable() {
+                    public void run() {
+                        ...
+                        callbackContext.success(); // Thread-safe.
+                    }
+                });
+                return true;
+            }
+            return false;
+        }
+    
+
+Verwendung Folgendes, wenn Sie nicht benötigen, führen Sie auf dem Hauptbildschirm thread ist, aber wollen nicht blockieren die `WebCore` thread entweder:
+
+        @Override
+        public boolean execute(String action, JSONArray args, final CallbackContext callbackContext) throws JSONException {
+            if ("beep".equals(action)) {
+                final long duration = args.getLong(0);
+                cordova.getThreadPool().execute(new Runnable() {
+                    public void run() {
+                        ...
+                        callbackContext.success(); // Thread-safe.
+                    }
+                });
+                return true;
+            }
+            return false;
+        }
+    
+
+## Echo-Android-Plugin-Beispiel
+
+Um die JavaScript-Schnittstelle in Anwendung Plugins beschriebene *Echo* -Funktion, verwenden die `plugin.xml` zu injizieren eines `feature` Spezifikation der lokalen Plattform `config.xml` Datei:
+
+        <platform name="android">
+            <config-file target="config.xml" parent="/*">
+                <feature name="Echo">
+                    <param name="android-package" value="org.apache.cordova.plugin.Echo"/>
+                </feature>
+            </config-file>
+        </platform>
+    
+
+Fügen Sie die folgenden Schritte, um die `src/org/apache/cordova/plugin/Echo.java` Datei:
+
+        package org.apache.cordova.plugin;
+    
+        import org.apache.cordova.CordovaPlugin;
+        import org.apache.cordova.CallbackContext;
+    
+        import org.json.JSONArray;
+        import org.json.JSONException;
+        import org.json.JSONObject;
+    
+        /**
+         * This class echoes a string called from JavaScript.
+         */
+        public class Echo extends CordovaPlugin {
+    
+            @Override
+            public boolean execute(String action, JSONArray args, CallbackContext callbackContext) throws JSONException {
+                if (action.equals("echo")) {
+                    String message = args.getString(0);
+                    this.echo(message, callbackContext);
+                    return true;
+                }
+                return false;
+            }
+    
+            private void echo(String message, CallbackContext callbackContext) {
+                if (message != null && message.length() > 0) {
+                    callbackContext.success(message);
+                } else {
+                    callbackContext.error("Expected one non-empty string argument.");
+                }
+            }
+        }
+    
+
+Die notwendigen Importe am oberen Rand der Datei erweitert die Klasse von `CordovaPlugin` , deren `execute()` Methode überschreibt Nachrichten empfangen `exec()` . Die `execute()` -Methode prüft zunächst den Wert des `action` , auf die in diesem Fall kommt nur eine gültige `echo` Wert. Jede andere Aktion gibt `false` und führt zu einem `INVALID_ACTION` Fehler, der eine Fehler-Callback aufgerufen, auf der Seite JavaScript übersetzt.
+
+Als nächstes die-Methode ruft die Echo-Zeichenfolge unter Verwendung der `args` des Objekts `getString` Methode, Angabe des ersten Parameters an die Methode übergeben. Nachdem der Wert, zu einem privaten übergeben wird `echo` Methode, es ist Parameter überprüft, um sicherzustellen, dass es ist nicht `null` oder eine leere Zeichenfolge, in diesem Fall `callbackContext.error()` ruft JavaScript-Fehler-Callback. Wenn die verschiedenen Prüfungen übergeben, die `callbackContext.success()` übergibt das Original `message` an JavaScripts-Erfolg-Rückruf als Parameter zurück.
+
+## Android Integration
+
+Android-Funktionen ein `Intent` System, das Prozesse miteinander kommunizieren kann. Plugins haben Zugriff auf ein `CordovaInterface` Objekt, das die Android zugreifen können `Activity` , die die Anwendung ausgeführt wird. Dies ist die `Context` eine neue Android starten erforderlich `Intent` . Die `CordovaInterface` können Plugins starten eine `Activity` für ein Ergebnis und das Rückruf-Plugin für den Zeitpunkt festlegen der `Intent` an die Anwendung zurückgegeben.
+
+Ab Cordova 2.0, Plugins können nicht mehr direkt zugreifen, die `Context` , und das Erbe `ctx` Mitglied ist veraltet. Alle `ctx` Methoden gibt es auf der `Context` , also beide `getContext()` und `getActivity()` kann das gewünschte Objekt zurückgeben.
+
+## Debuggen von Android Plugins
+
+Eclipse können Sie Debuggen von Plugins wie Java-Quellcode in das Projekt einbezogen. Nur die neueste Version von Android Developer-Tools können Sie *JAR-* Abhängigkeiten, Source-Code zuordnen, so dass diese Funktion noch nicht vollständig unterstützt wird.
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/2506e7b9/docs/de/3.4.0/guide/platforms/android/tools.md
----------------------------------------------------------------------
diff --git a/docs/de/3.4.0/guide/platforms/android/tools.md b/docs/de/3.4.0/guide/platforms/android/tools.md
new file mode 100644
index 0000000..b459fd8
--- /dev/null
+++ b/docs/de/3.4.0/guide/platforms/android/tools.md
@@ -0,0 +1,70 @@
+---
+
+license: Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file distributed with this work for additional information regarding copyright ownership. The ASF licenses this file to you under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at
+
+           http://www.apache.org/licenses/LICENSE-2.0
+    
+         Unless required by applicable law or agreed to in writing,
+         software distributed under the License is distributed on an
+         "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+         KIND, either express or implied.  See the License for the
+         specific language governing permissions and limitations
+    
+
+   under the License.
+---
+
+# Android-Befehlszeilenprogrammen
+
+Die `cordova` Befehlszeilen-Dienstprogramm ist ein High-Level Tool, das Ihnen erlaubt, Anwendungen auf mehreren Plattformen gleichzeitig zu erstellen. Eine ältere Version von Cordova Rahmen bietet Gruppen von Befehlszeilentools, die spezifisch für jede Plattform. Wenn sie als Alternative zu den CLI verwenden möchten, müssen Sie diese Version von Cordova von [cordova.apache.org][1]herunterladen. Der Download enthält separate Archiv für jede Plattform. Erweitern Sie die gewünschte Ziel-Plattform. Die hier beschriebenen Tools sind in der Regel in der obersten Ebene `bin` Verzeichnis, sonst finden Sie in die **README** -Datei ausführlichere Wegbeschreibung.
+
+ [1]: http://cordova.apache.org
+
+Informationen über die Low-Level-Befehlszeilenschnittstelle, die Plugins ermöglicht, finden Sie unter Verwendung von Plugman zu Plugins verwalten. Eine Übersicht finden Sie unter Application Plugins.
+
+## Erstellen Sie ein Projekt
+
+Führen Sie den `create` Befehl, der vorhandenen Pfad für das Projekt, die rückwärts-Domäne-Style Paket-ID und die app-Anzeigenamen angeben. Hier ist die Syntax für Mac und Windows:
+
+    $ /path/to/cordova-android/bin/create /path/to/project com.example.project_name ProjectName
+    $ C:\path\to\cordova-android\bin\create.bat C:\path\to\project com.example.project_name ProjectName
+    
+
+## Build
+
+Dies reinigt dann ein Projekt erstellt.
+
+Debuggen Sie, auf Mac oder Windows:
+
+    $ /path/to/project/cordova/build --debug
+    $ C:\path\to\project\cordova\build.bat --debug
+    
+
+Version auf Mac oder Windows:
+
+    $ /path/to/project/cordova/build --release
+    $ C:\path\to\project\cordova\build.bat --release
+    
+
+## Führen Sie die Anwendung
+
+Der `run` Befehl akzeptiert die folgenden *optionalen* Parameter:
+
+*   Lastenheft. Dazu gehören `--emulator` , `--device` , oder`--target=<targetID>`.
+
+*   Spezifikation zu bauen. Dazu gehören `--debug` , `--release` , oder`--nobuild`.
+    
+    $ /path/to/project/cordova/run \[Target\] \[Build\] $ C:\path\to\project\cordova\run.bat \[Target\] \[Build\]
+
+Vergewissern Sie sich, erstellen Sie mindestens ein Android virtuelles Gerät, sonst Sie werden aufgefordert zu tun mit dem `android` Befehl. Wenn mehr als eine AVD als Ziel verfügbar ist, werden Sie aufgefordert, einen auswählen. In der Standardeinstellung der `run` Befehl erkennt ein angeschlossenes Gerät oder einen laufenden Emulator, wenn kein Gerät gefunden wird.
+
+## Protokollierung
+
+    $ /path/to/project/cordova/log
+    $ C:\path\to\project\cordova\log.bat
+    
+
+### Reinigung
+
+    $ /path/to/project/cordova/clean
+    $ C:\path\to\project\cordova\clean.bat
\ No newline at end of file


Mime
View raw message