cordova-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ste...@apache.org
Subject [47/52] [abbrv] [partial] docs commit: CB-12747: added 7.x docs
Date Thu, 04 May 2017 15:02:28 GMT
http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/5ad93d20/www/docs/de/7.x/guide/platforms/android/index.md
----------------------------------------------------------------------
diff --git a/www/docs/de/7.x/guide/platforms/android/index.md b/www/docs/de/7.x/guide/platforms/android/index.md
new file mode 100644
index 0000000..78dfb92
--- /dev/null
+++ b/www/docs/de/7.x/guide/platforms/android/index.md
@@ -0,0 +1,276 @@
+---
+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.
+
+title: Android-Plattform-Guide
+toc_title: Android
+---
+
+# Android-Plattform-Guide
+
+Diese Anleitung zeigt wie Ihr SDK-Umgebung einrichten, um Cordova apps für Android-Geräte bereitzustellen sowie optional mithilfe von Befehlszeilentools Android-zentrierte in Ihrem Entwicklungs-Workflow. Sie müssen installieren Sie das Android SDK unabhängig davon, ob Sie für die Entwicklung dieser Plattform-zentrierte Shell-Werkzeugen oder plattformübergreifende Cordova CLI verwenden möchten. Einen Vergleich der zwei Entwicklungswege finden Sie in der [Übersicht](../../overview/index.html). Details über die CLI finden Sie unter The Command-Line Interface.
+
+## Anforderungen und Unterstützung
+
+Cordova für Android erfordert das Android SDK, welches auf OS X, Linux oder Windows Betriebssystem installiert werden konnte. Finden Sie unter das Android SDK- [Systemanforderungen][1].
+
+ [1]: http://developer.android.com/sdk/index.html#Requirements
+
+Cordova unterstützt Android 4.0.x (beginnend mit Android API-Ebene 14) und höher. Als allgemeine Regel werden Android Versionen von Cordova nicht unterstützt, wie sie unter 5 % auf Googles [Verteilung Dashboard][2]sinken. Androide Versionen früher als API Stufe 10 und die 3.x-Versionen (Waben, API-Level 11-13) unterschreiten deutlich die 5 %-Schwelle.
+
+ [2]: http://developer.android.com/about/dashboards/index.html
+
+## Cordova Shell Tools installieren
+
+Wenn Sie Cordova's Android-zentrierte Shell-Werkzeugen in Verbindung mit dem SDK verwenden möchten, laden Sie Cordova von [cordova.apache.org][3]. Andernfalls überspringen Sie diesen Abschnitt, wenn Sie das Cross-Plattform-CLI-Tool beschrieben in der Befehlszeilenschnittstelle verwenden möchten.
+
+ [3]: http://cordova.apache.org
+
+Der Cordova-Download enthält separate Archiv für jede Plattform. Achten Sie darauf, um das entsprechende Archiv zu erweitern `android` in diesem Fall in ein leeres Verzeichnis. Die entsprechenden ausführbaren Dienstprogramme sind in der obersten Ebene `bin` Verzeichnis. (Konsultieren Sie die **README** -Datei, ggf. für eine genauere Wegbeschreibung.)
+
+Diese Shell-Tools können Sie erstellen, erstellen und Ausführen von Android apps. Informationen über die zusätzliche Befehlszeilenschnittstelle, die Plugin-Features für alle Plattformen aktiviert, finden Sie unter Using Plugman zu Plugins verwalten. Details zum Entwickeln von Plugins finden Sie in der Anwendung-Plugins.
+
+## Installieren Sie das Java Development Kit (JDK)
+
+Installieren Sie [Java Development Kit (JDK) 7][4] oder höher.
+
+ [4]: http://www.oracle.com/technetwork/java/javase/downloads/jdk7-downloads-1880260.html
+
+Wenn Sie auf Windows installieren, müssen Sie auch `JAVA_HOME` -Umgebungsvariable nach JDK-Installationspfad (z.B. C:\Program Files\Java\jdk1.7.0_75) festgelegt.
+
+## Das Android SDK installieren
+
+Installieren Sie [Android eigenständige SDK Tools][5] oder das [Android-Studio][6]. Procceed mit `Android-Studio` Wenn Sie planen, entwickeln neue Cordova für [Android Plugins](plugin.html) oder Verwenden von systemeigenen Tools ausführen und Debuggen der Android-Plattform. Andernfalls sind `Android Stand-Alone-SDK-Tools` genug, um erstellen und Bereitstellen von Android-Anwendung.
+
+ [5]: http://developer.android.com/sdk/installing/index.html?pkg=tools
+ [6]: http://developer.android.com/sdk/installing/index.html?pkg=studio
+
+Detaillierte Installationsanweisungen finden Sie im Rahmen der Installationslinks oben.
+
+Für Cordova Befehlszeilen-Tools für die Arbeit oder die CLI, das darauf basiert, müssen Sie das SDK `Tools` und `Plattform` Verzeichnisse im `Pfad`enthalten. Auf einem Mac oder Linux können Sie einen Text-Editor erstellen oder Ändern der Datei `~/.bash_profile` hinzufügen eine Zeile wie die folgende, je nachdem, wo das SDK installiert:
+
+        export PATH=${PATH}:/Development/android-sdk/platform-tools:/Development/android-sdk/tools
+
+
+Diese Zeile in `~/.bash_profile` macht diese Werkzeuge in neu eröffneten terminal-Fenster verfügbar. Wenn Ihr terminal-Fenster bereits geöffnet in OSX oder ein Logout/Login auf Linux zu vermeiden ist, führen Sie dies, um sie in aktuellen terminal-Fenster zur Verfügung stellen:
+
+        $ source ~/.bash_profile
+
+
+So ändern Sie die `PATH` -Umgebung unter Windows:
+
+1.  Klicken Sie auf das **Start** -Menü in der unteren linken Ecke des Desktops, mit der rechten Maustaste auf **Computer**, und wählen Sie **Eigenschaften**.
+
+2.  Wählen Sie die **Erweiterte Systemeinstellungen** in der Spalte auf der linken Seite.
+
+3.  Drücken Sie im daraufhin angezeigten Dialogfeld **Umgebungsvariablen**.
+
+4.  Wählen Sie die **PATH** -Variable und klicken Sie **Bearbeiten**.
+
+5.  Fügen Sie Folgendes, um die `PATH` auf der Grundlage von wo Sie das SDK, zum Beispiel installiert:
+
+        ;C:\Development\android-sdk\platform-tools;C:\Development\android-sdk\tools
+
+
+6.  Speichern Sie den Wert und schließen Sie beide Dialogfelder zu.
+
+## SDK-Pakete installieren
+
+Android SDK Manager öffnen (z.B. über Terminal: `android`) und installieren:
+
+1.  Android 5.1.1 (API 22) Platform SDK
+2.  Android SDK-Build-Tools Version 19.1.0 oder höher
+3.  Android Unterstützung Repository (Extras)
+
+Weitere Informationen finden Sie im [SDK-Pakete installieren][7] .
+
+ [7]: http://developer.android.com/sdk/installing/adding-packages.html
+
+## Konfigurieren Sie einen Emulator
+
+Android Sdk kein Standardinstanz Emulator standardmäßig zur Verfügung. Sie können eine neue mit `android` in der Befehlszeile erstellen. Die Presse **Tools → verwalten AVDs** (Android Virtual Devices), dann wählen Sie ein Element aus **Gerätedefinitionen** in dem daraufhin angezeigten Dialogfeld:
+
+![][8]
+
+ [8]: {{ site.baseurl }}/static/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]: {{ site.baseurl }}/static/img/guide/platforms/android/asdk_newAVD.png
+
+Der AVD wird dann in der Liste **Android Virtual Devices** angezeigt:
+
+![][10]
+
+ [10]: {{ site.baseurl }}/static/img/guide/platforms/android/asdk_avds.png
+
+Um den Emulator als separate Anwendung zu öffnen, wählen Sie den AVD und **Starten**. Es bringt viel, wie es auf dem Gerät mit zusätzliche Steuerelemente für Hardware-Tasten zur Verfügung:
+
+![][11]
+
+ [11]: {{ site.baseurl }}/static/img/guide/platforms/android/asdk_emulator.png
+
+Für eine schnellere Erfahrung können Sie die `Virtual Machine-Beschleunigung` verwenden, um die Ausführungsgeschwindigkeit zu verbessern. Viele moderne CPUs bieten Erweiterungen um virtuelle Maschinen effizienter auszuführen. Bevor Sie versuchen, diese Art von Beschleunigung verwenden, müssen Sie bestimmen, ob Ihre aktuelle Entwicklungssystem CPU, unterstützt man die folgenden Virtualisierungstechnologien:
+
+*   **Intel Virtualization Technology** (VT-X, Vmx) → [Intel VT-X unterstützt Prozessor Liste][12]
+*   **AMD Virtualization** (AMD-V, SVM), nur für Linux unterstützt (seit Mai 2006 gehören alle CPUs AMD AMD-V, außer Sempron).
+
+ [12]: http://ark.intel.com/products/virtualizationtechnology
+
+Eine weitere Möglichkeit herauszufinden, ob Ihr Prozessor Intel VT-X-Technologie unterstützt, es ist durch Ausführen des `Intel ® Processor Identification Utility`, für `Windows`Sie es im Intel [Download Center][13]herunterladen können oder können Sie das [Booteable-Dienstprogramm][14], das ist `Betriebssystemunabhängig`.
+
+ [13]: https://downloadcenter.intel.com/Detail_Desc.aspx?ProductID=1881&DwnldID=7838
+ [14]: https://downloadcenter.intel.com/Detail_Desc.aspx?ProductID=1881&DwnldID=7840&lang=eng
+
+Nach dem Installieren und Ausführen des `Intel Processor Identification Utility` über Windows, erhalten Sie folgende Fenster, um zu prüfen, ob deine CPU den Virtualisierungs-Technologien unterstützt:
+
+![][15]
+
+ [15]: {{ site.baseurl }}/static/img/guide/platforms/android/intel_pid_util_620px.png
+
+Um den Emulator zu beschleunigen, müssen Sie downloaden und installieren Sie ein oder mehrere Bilder der `Intel X 86 Atom` -System sowie die `Intel Hardware beschleunigte Ausführung Manager (HAXM)`.
+
+Öffnen Sie Ihr Android SDK Manager, und wählen Sie das `X 86 Intel Atom` Systemabbild, unabhängig davon, welche Version, die Sie testen möchten. Dann gehen Sie auf `Extras` und wählen Sie `Intel X 86 Emulator Accelerator (HAXM)`, und installieren Sie diese Pakete zu:
+
+![][16]
+
+ [16]: {{ site.baseurl }}/static/img/guide/platforms/android/asdk_man_intel_image_haxm.png
+
+Nach dem Download, das Intel-Installationsprogramm ausführen, das in Ihrem Android SDK unter `Extras/Intel/Hardware_Accelerated_Execution_Manager`zur Verfügung steht. **Hinweis**:`Wenn Sie irgendwelche Probleme Installation des Pakets finden Sie weitere Informationen und Schritt-für-Schritt-Anleitung, check this` [Intel Artikel][17].
+
+ [17]: http://software.intel.com/en-us/android/articles/speeding-up-the-android-emulator-on-intel-architecture
+
+1.  Installieren Sie ein oder mehrere Bilder der `Intel X 86 Atom` -System sowie die `Intel Hardware beschleunigte Ausführung-Manager`finden Sie unter **Extras**.
+
+2.  Führen Sie das Intel-Installationsprogramm aus, das in Ihrem Android SDK unter `Extras/Intel/Hardware_Accelerated_Execution_Manager` zur Verfügung steht.
+
+3.  Erstellen Sie eine neue AVD, mit dem Ziel, die auf einem Intel-Bild festgelegt.
+
+4.  Wenn Sie den Emulator zu starten, stellen Sie sicher, es gibt keine Fehlermeldungen angezeigt, der angibt, einer Störungsmeldung HAX Module laden.
+
+## Erstellen eines neuen Projekts
+
+Zu diesem Zeitpunkt zum Erstellen eines neuen Projekts können Sie zwischen das Cross-Plattform-CLI-Tool in der Kommandozeilen-Schnittstelle oder die Menge der Android-spezifischen Shell Tools beschrieben. Von in einem Quellcode-Verzeichnis ist hier der CLI-Ansatz:
+
+        $ cordova create hello com.example.hello HelloWorld
+        $ cd hello
+        $ cordova platform add android
+        $ cordova prepare              # or "cordova build"
+
+
+Hier ist der entsprechende Low-Level-Shell-Tool-Ansatz für Unix und Windows:
+
+        $ /path/to/cordova-android/bin/create /path/to/new/hello com.example.hello HelloWorld
+        C:\path\to\cordova-android\bin\create.bat C:\path\to\new\hello com.example.hello HelloWorld
+
+
+## Erstellen Sie das Projekt
+
+Wenn Sie in der Entwicklung die CLI verwenden, enthält das Projektverzeichnis der obersten Ebene `Www` -Verzeichnis die Quelldateien. Führen Sie diese im Projekt-Verzeichnis, die app neu zu erstellen:
+
+        $ cordova build                   # build all platforms that were added
+        $ cordova build android           # build debug for only Android
+        $ cordova build android --debug   # build debug for only Android
+        $ cordova build android --release # build release for only Android
+
+
+Verwenden Sie die Android-spezifische-Shell-Werkzeugen in der Entwicklung, gibt es ein anderen Ansatz. Sobald Sie das Projekt erstellen, ist die Standard-app-Quelle verfügbar im Unterverzeichnis `assets/www` . Nachfolgende Befehle stehen in dessen `Cordova` -Unterverzeichnis.
+
+Der `build` -Befehl reinigt Projektdateien und Umbauten, die app. Hier ist die Syntax für Mac und Windows. Das erste paar Beispiele Debuginformationen generiert, und die zweite baut die apps für Release:
+
+        $ /path/to/project/cordova/build --debug
+        C:\path\to\project\cordova\build.bat --debug
+
+        $ /path/to/project/cordova/build --release
+        C:\path\to\project\cordova\build.bat --release
+
+
+## Die app bereitstellen
+
+`Cordova` -CLI-Dienstprogramm können Sie die Anwendung im Emulator oder das Gerät von der Befehlszeile aus bereitstellen:
+
+        $ cordova emulate android       #to deploy the app on a default android emulator
+        $ cordova run android --device  #to deploy the app on a connected device
+
+
+Verwenden Sie andernfalls die Alternative Shell-Schnittstelle:
+
+        $ /path/to/project/cordova/run --emulator
+        $ /path/to/project/cordova/run --device
+
+
+Können Sie **cordova run android --list** alle verfügbaren Ziele sehen und **cordova run android --target=target_name** Anwendung auf ein bestimmtes Gerät oder einen Emulator ausführen (z. B. `cordova run android --target="Nexus4_emulator"`).
+
+Sie können auch **cordova run --help** finden Sie unter zusätzliche Build und Ausführungsoptionen.
+
+Dies drückt die app zum home-Bildschirm und startet es:
+
+![][18]
+
+ [18]: {{ site.baseurl }}/static/img/guide/platforms/android/emulator2x.png
+
+Wenn Sie die app `run` Sie auch `build` es. Sie können zusätzliche Anhängen `--debug`, `--release`, und `--nobuild` -Flags zu steuern, wie sie gebaut ist, oder sogar ob ein Umbau notwendig ist:
+
+        $ /path/to/project/cordova/run --emulator --nobuild
+
+
+## Andere Befehle
+
+Im folgenden wird ein detailliertes Protokoll der app, wie es läuft:
+
+        $ /path/to/project/cordova/log
+        C:\path\to\project\cordova\log.bat
+
+
+Folgende reinigt die Projektdateien:
+
+        $ /path/to/project/cordova/clean
+        C:\path\to\project\cordova\clean.bat
+
+
+## Öffnen Sie ein neues Projekt im SDK
+
+Nachdem android-Plattform zu Ihrem Projekt hinzugefügt haben, können Sie es von [Android][6]-Studio öffnen:
+
+1.  Starten Sie die **Android-Studio** -Anwendung.
+
+2.  Wählen Sie **Import-Projekt (Eclipse ADT, Gradle usw.)**.
+
+    ![][19]
+
+3.  Wählen Sie die Stelle, wo die android-Plattform gespeicherten (`Ihr/Projekt/Plattformen/Android` ist).
+
+    ![][20]
+
+4.  Für die Frage, `Gradle Sync` können Sie einfach **Ja** beantworten.
+
+ [19]: {{ site.baseurl }}/static/img/guide/platforms/android/asdk_import_project.png
+ [20]: {{ site.baseurl }}/static/img/guide/platforms/android/asdk_import_select_location.png
+
+Sie können sind eingestellt jetzt bauen und führen Sie die Anwendung direkt vom `Android-Studio`.
+
+![][21]
+
+ [21]: {{ site.baseurl }}/static/img/guide/platforms/android/asdk_import_done.png
+
+Finden Sie unter [Übersicht über Android-Studio][22] und und [erstellen und Ausführen von Android-Studio][23] für weitere Details.
+
+ [22]: http://developer.android.com/tools/studio/index.html
+ [23]: http://developer.android.com/tools/building/building-studio.html

http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/5ad93d20/www/docs/de/7.x/guide/platforms/android/plugin.md
----------------------------------------------------------------------
diff --git a/www/docs/de/7.x/guide/platforms/android/plugin.md b/www/docs/de/7.x/guide/platforms/android/plugin.md
new file mode 100644
index 0000000..2c9b7f6
--- /dev/null
+++ b/www/docs/de/7.x/guide/platforms/android/plugin.md
@@ -0,0 +1,183 @@
+---
+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.
+
+title: Android Plugins
+toc_title: Android
+---
+
+# 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](../../../cordova/events/events.pause.html)` und `[resume](../../../cordova/events/events.resume.html)` [Veranstaltungen](../../../cordova/events/events.html), 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 >, < Aktion >, [< arg >]);
+    
+
+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 entsprechende Java-Plugin zugeordnet ist richtig in der `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](../../next/index.html) 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/5ad93d20/www/docs/de/7.x/guide/platforms/android/tools.md
----------------------------------------------------------------------
diff --git a/www/docs/de/7.x/guide/platforms/android/tools.md b/www/docs/de/7.x/guide/platforms/android/tools.md
new file mode 100644
index 0000000..6c9a1ea
--- /dev/null
+++ b/www/docs/de/7.x/guide/platforms/android/tools.md
@@ -0,0 +1,205 @@
+---
+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.
+
+title: Android Shell Tool Guide
+---
+
+# Android Shell Tool Guide
+
+Diese Anleitung zeigt wie Cordovas Satz von Plattform-zentrierte Shell Tools verwenden, um Android apps zu entwickeln. Dieser Entwicklungspfad, diskutiert in der [Übersicht](../../overview/index.html), möglicherweise einen größeren Bereich von Entwicklungsoptionen als das Cross-Plattform-CLI-Tool beschrieben in The Command-Line Interface anbieten. Beispielsweise müssen Sie Shell-Hilfsmittel zu verwenden, wenn Sie eine benutzerdefinierte Cordova WebView neben systemeigenen Komponenten bereitstellen. Vor der Verwendung von entweder Entwicklungsweg, müssen Sie zuerst die Android SDK-Umgebung konfigurieren, wie in der Android-Plattform-Handbuch beschrieben.
+
+Zum Aktivieren der Shell-Hilfsmittel für Android download Cordova von [cordova.apache.org][1]. Der Download enthält separate Archiv für jede Plattform. Erweitern Sie jedes Ziel, soll `android` in diesem Fall. Die entsprechenden Tools stehen in der Regel in den übergeordneten `bin` Verzeichnis, sonst finden Sie in der **README** -Datei für detailliertere Wegbeschreibung.
+
+ [1]: http://cordova.apache.org
+
+Diese Tools können Sie erstellen, erstellen und Ausführen von Android apps. Informationen über die zusätzliche Befehlszeilenschnittstelle, die Plugin-Features für alle Plattformen aktiviert, finden Sie unter Using Plugman zu Plugins verwalten. Details zum Entwickeln von Plugins finden Sie in der Anwendung-Plugins.
+
+## Erstellen Sie ein Projekt
+
+Führen Sie den `create` Befehl, der vorhandenen Pfad für das Projekt, die Reverse-Domäne-Style Paket-ID und die app-Anzeigenamen angeben. Hier ist die Syntax für Mac/Linux und Windows:
+
+        $ /path/to/cordova-android/bin/create /path/to/project com.example.project_name ProjectName
+    
+        C:\>\path\to\cordova-android\bin\create.bat \path\to\project com.example.project_name ProjectName
+    
+
+## Build
+
+Dies reinigt dann ein Projekt erstellt.
+
+Debug auf Mac/Linux oder Windows:
+
+        $ /path/to/project/cordova/build --debug
+    
+        C:\>\path\to\project\cordova\build.bat --debug
+    
+
+Version auf Mac/Linux 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.
+
+## Unterzeichnung der App
+
+Sie können überprüfen, dass Android app Signaturanforderungen hier: http://developer.android.com/tools/publishing/app-signing.html
+
+Um eine app zu signieren, benötigen Sie die folgenden Parameter:
+
+*   Keystore (`--keystore`): Pfad in eine Binärdatei, die eine Reihe von Schlüsseln aufnehmen können.
+
+*   Schlüsselspeicher-Kennwort (`--storePassword`): Kennwort zum Schlüsselspeicher
+
+*   Alias (`--alias`): die Id angeben des privaten Schlüssels für Gesang.
+
+*   Passwort (`--password`): Kennwort für den privaten Schlüssel angegeben.
+
+*   Typ des Schlüsselspeichers (`--keystoreType`): pkcs12, Jks (Default: automatische Erkennung anhand der Dateierweiterung)
+
+Diese Parameter können mithilfe der Befehlszeilenargumente oben zu `build` oder `run` von Skripts angegeben werden.
+
+Alternativ könnten Sie sie in ein Build Startkonfigurationsdatei (build.json) mit angeben ( `--buildConfig` ) Argument. Hier ist ein Beispiel für eine Konfigurationsdatei erstellen:
+
+    {
+         "android": {
+             "debug": {
+                 "keystore": "..\android.keystore",
+                 "storePassword": "android",
+                 "alias": "mykey1",
+                 "password" : "password",
+                 "keystoreType": ""
+             },
+             "release": {
+                 "keystore": "..\android.keystore",
+                 "storePassword": "",
+                 "alias": "mykey2",
+                 "password" : "password",
+                 "keystoreType": ""
+             }
+         }
+     }
+    
+
+Für eine Veröffentlichung Signierung wird Kennwörter ausgeschlossen werden können und das Buildsystem nach dem Passwort gefragt.
+
+Es gibt auch Unterstützung zu kombinieren, Kommandozeilen-Parameter und Parameter in der Datei build.json. Werte aus der Befehlszeilenargumente erhalten Vorrang. Dies ist hilfreich für Kennwörter in der Befehlszeile angeben.
+
+## 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
+    
+
+## Gebäude mit Gradle
+
+Stand: cordova-android@4.0.0, Projektbuilds mit [Gradle][2]. Finden Sie Anweisungen zum Gebäude mit ANT ältere Versionen der Dokumentation.
+
+ [2]: http://www.gradle.org/
+
+### Gradle-Eigenschaften
+
+Diese [Eigenschaften][3] können festgelegt werden, um den Build anzupassen:
+
+ [3]: http://www.gradle.org/docs/current/userguide/tutorial_this_and_that.html
+
+*   **cdvBuildMultipleApks** (Standard: false)
+    
+    Wenn dies festgelegt ist, mehrere APK-Dateien erzeugt werden: eine pro native von Bibliotheksprojekten unterstützte Plattform (X 86, ARM, etc.). Dies kann wichtig sein, wenn das Projekt große native Bibliotheken verwendet, die die generierten APK drastisch vergrößern können.
+    
+    Wenn nicht gesetzt, dann einen einzigen APK generiert wird, die auf allen Geräten verwendet werden können.
+
+*   **cdvVersionCode**
+    
+    Überschreibt die VersionCode inmitten `AndroidManifest.xml`
+
+*   **cdvReleaseSigningPropertiesFile** (Standard: release-signing.properties)
+    
+    Pfad zu einer .properties-Datei, die Signaturinformationen für Release enthält baut. Die Datei sollte wie aussehen:
+    
+        storeFile=relative/path/to/keystore.p12
+        storePassword=SECRET1
+        storeType=pkcs12
+        keyAlias=DebugSigningKey
+        keyPassword=SECRET2
+        
+    
+    `storePassword` und `keyPassword` sind optional und werden aufgefordert für fehlt.
+
+*   **cdvDebugSigningPropertiesFile** (Standard: debug-signing.properties)
+    
+    Wie CdvReleaseSigningPropertiesFile, jedoch für Debug baut. Nützlich, wenn Sie mit anderen Entwicklern einen Signaturschlüssel freigeben müssen.
+
+*   **cdvMinSdkVersion**
+    
+    Setzt den Wert von `minSdkVersion` in der `AndroidManifest.xml`festgelegt. Nützlich beim Erstellen mehrerer APKs Grundlage SDK Version.
+
+*   **cdvBuildToolsVersion**
+    
+    Überschreiben Sie den automatisch erkannten `android.buildToolsVersion` Wert.
+
+*   **cdvCompileSdkVersion**
+    
+    Überschreiben Sie den automatisch erkannten `android.compileSdkVersion` Wert.
+
+### Verlängerung build.gradle
+
+Wenn Sie `build.gradle`anpassen, anstatt direkt bearbeiten müssen, sollten Sie eine Geschwister-Datei mit dem Namen `Build-extras.gradle`erstellen. Diese Datei wird von den wichtigsten `build.gradle` wenn vorhanden enthalten sein. Hier ist ein Beispiel:
+
+    # Example build-extras.gradle
+    # This file is included at the beginning of `build.gradle`
+    ext.cdvDebugSigningPropertiesFile = '../../android-debug-keys.properties'
+    # When set, this function allows code to run at the end of `build.gradle`
+    ext.postBuildExtras = {
+        android.buildTypes.debug.applicationIdSuffix = '.debug'
+    }
+    
+
+Beachten Sie, dass Plugins auch `build-extras.gradle` Dateien über enthalten kann:
+
+    <framework src="some.gradle" custom="true" type="gradleReference" />
+    
+
+### Beispiel-Build
+
+    export ORG_GRADLE_PROJECT_cdvMinSdkVersion=14
+    cordova build android -- --gradleArg=-PcdvBuildMultipleApks=true
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/5ad93d20/www/docs/de/7.x/guide/platforms/android/upgrade.md
----------------------------------------------------------------------
diff --git a/www/docs/de/7.x/guide/platforms/android/upgrade.md b/www/docs/de/7.x/guide/platforms/android/upgrade.md
new file mode 100644
index 0000000..6e284e9
--- /dev/null
+++ b/www/docs/de/7.x/guide/platforms/android/upgrade.md
@@ -0,0 +1,500 @@
+---
+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.
+
+title: Aktualisierung von Android
+---
+
+# Aktualisierung von Android
+
+Diese Anleitung zeigt, wie Android Projekte Upgrade von älteren Versionen von Cordova ändern. Die meisten diese Anweisungen gelten für Projekte, die mit einer älteren Befehlszeilentools, die vorangehen erstellt die `cordova` CLI-Hilfsprogramm. Informationen finden Sie unter The Command-Line Interface die CLI-Version zu aktualisieren.
+
+## Upgrade auf 4.0.0
+
+Gibt es bestimmte Schritte benötigt, um wichtige Änderungen in 4.0.0 nutzen. Zunächst werden die gemeinsamen Schritte wie unten beschrieben.
+
+Für nicht-CLI-Projekte führen:
+
+        bin/update path/to/project
+
+
+CLI-Projekte:
+
+1.  Update der `cordova` CLI-Version. Finden Sie die Befehlszeilenschnittstelle.
+
+2.  `cordova platform update android` in Ihre bestehenden Projekte ausgeführt.
+
+### Aktualisierung der weißen Liste
+
+Alle Whitelist-Funktionalität ist jetzt via Plugin implementiert. Ohne Plugin ist Ihre Anwendung nicht mehr durch eine Whitelist geschützt, nach dem Upgrade auf 4.0.0. Cordova hat zwei Whitelist-Plugins, die verschiedene Ebenen des Schutzes zur Verfügung zu stellen.
+
+1.  `Cordova-Plugin-Whitelist` Plugin *(empfohlen)*
+
+    *   Dieses Plugin wird dringend empfohlen, da es sicherer und konfigurierbar als die Whitelist in früheren Versionen ist,
+    *   Siehe [Cordova-Plugin-Whitelist][1] für Details auf die Konfigurationsänderungen erforderlich
+    *   Ausführung: `cordova plugin add cordova-plugin-crosswalk-webview`
+
+2.  `Cordova-Plugin-Legacy-Whitelist` plugin
+
+    *   Dieses Plugin bietet das Whitelist-Verhalten wie in früheren Versionen. Siehe [Cordova-Plugin-Legacy-whitelist][2]
+    *   Keine Konfigurationsänderungen sind erforderlich, aber es bietet weniger Schutz als die empfohlenen plugin
+    *   Ausführung: `cordova plugin add cordova-plugin-legacy-whitelist`
+
+ [1]: https://github.com/apache/cordova-plugin-whitelist
+ [2]: https://github.com/apache/cordova-plugin-legacy-whitelist
+
+### Mithilfe der Zebrastreifen WebView
+
+Standardmäßig wird Ihre Anwendung weiterhin das System verwenden WebView vom Gerät zur Verfügung gestellt. Wenn Sie den Zebrastreifen WebView stattdessen verwenden möchten, fügen Sie einfach das Zebrastreifen-Plugin:
+
+    cordova plugin add cordova-plugin-crosswalk-webview
+
+
+Das Plugin hinzufügen, erhalten Ihre app den Zebrastreifen WebView ordnungsgemäß installiert und konfiguriert.
+
+### Upgrade auf das Splashscreen-Plugin
+
+Wenn Ihre app macht Verwendung von einen Splash-Screen Funktionalität zu einem Plugin verschoben wurde. Die Konfigurationsoptionen für Begrüßungsbildschirme sind unverändert. Der einzige Upgrade Schritt benötigt, ist das Plugin hinzufügen:
+
+    cordova plugin add cordova-plugin-splashscreen
+
+
+## Upgrade von 3.6.0 auf 3.7.1
+
+Für nicht-CLI-Projekte führen:
+
+        bin/update path/to/project
+
+
+CLI-Projekte:
+
+1.  Update der `cordova` CLI-Version. Finden Sie die Befehlszeilenschnittstelle.
+
+2.  Führen Sie `cordova platform update android` in Ihre bestehenden Projekte.
+
+## Upgrade von 3.2.0 auf 3.3.0
+
+Folgen Sie die Anweisungen wie für `3.2.0`.
+
+Beginnend mit 3.3.0, wird Cordova-Runtime jetzt als Android-Bibliothek anstelle von einem Glas kompiliert. Dies sollte keine Auswirkungen für Command-Line Usage, aber IDE-Benutzer müssen das neu hinzugefügte `MyProject-CordovaLib`-Projekt in ihren Arbeitsbereich zu importieren.
+
+## Upgrade von 3.1.0 auf 3.2.0
+
+Für Projekte, die mit Cordova CLI erstellt wurden:
+
+1.  Update der `cordova` CLI-Version. Finden Sie die Befehlszeilenschnittstelle.
+
+2.  `cordova plattform update android` ausführen
+
+Für Projekte, die nicht mit der Cordova CLI erstellt ausgeführt:
+
+        bin/update <project_path>
+
+
+**WARNUNG:** Auf Android 4.4 - Android 4.4.3, Erstellen einer Datei input-Element mit type="file" wird nicht im Dialog Datei Picker. Dies ist eine Regression mit Chrom auf Android und das Problem reproduzierbar in der Standalone-Chrome-Browser auf Android (siehe http://code.google.com/p/android/issues/detail?id=62220) die empfohlene Problemumgehung besteht darin die FileTransfer und Datei-Plugins für Android 4.4 verwenden. Sie können für ein OnClick-Ereignis aus der Eingabetyp type="file" und dann pop-up eine Dateiauswahl UI. Um die Formulardaten mit dem Upload zu binden, können Sie JavaScript Formularwerte FileTransfer macht die mehrteilige POST-Anforderung an.
+
+## Upgrade von 3.0.0 auf 3.1.0
+
+Für Projekte, die mit Cordova CLI erstellt wurden:
+
+1.  Update der `cordova` CLI-Version. Finden Sie die Befehlszeilenschnittstelle.
+
+2.  `cordova plattform update android` ausführen
+
+Für Projekte, die nicht mit der Cordova CLI erstellt ausgeführt:
+
+        bin/update <project_path>
+
+
+## Upgrade auf die CLI (3.0.0) aus 2.9.0
+
+1.  Erstellen Sie ein neues Apache Cordova 3.0.0-Projekt mit Cordova CLI, wie in der Command-Line Interface beschrieben.
+
+2.  Fügen Sie Ihrer Plattformen Projektes Cordova, zum Beispiel: `cordova platform add android`.
+
+3.  Kopieren Sie den Inhalt der `Www`-Verzeichnis des Projekts in das `Www`-Verzeichnis im Stammverzeichnis des Projektes Cordova soeben erstellten.
+
+4.  Nativen Vermögen aus dem alten Projekt kopieren, in die entsprechenden Verzeichnisse unter `platforms/android`: in diesem Verzeichnis werden in dem systemeigene Cordova-Android Projekt vorhanden ist.
+
+5.  Verwenden Sie das Cordova CLI Tool irgendwelche Plugins installieren, die Sie brauchen. Beachten Sie, dass die CLI behandelt alle Kern-APIs wie Plugins, so müssen sie möglicherweise hinzugefügt werden. Nur 3.0.0 Plugins sind kompatibel mit CLI.
+
+## Ein Upgrade auf 3.0.0 von 2.9.0
+
+1.  Erstellen Sie ein neues Apache Cordova Android Projekt.
+
+2.  Kopieren Sie den Inhalt des Verzeichnisses `www` zum neuen Projekt.
+
+3.  Kopieren Sie nativen Android Vermögen aus dem `res`-Verzeichnis zum neuen Projekt.
+
+4.  Kopieren Sie über alle Plugins, die Sie aus der `src`-Unterverzeichnissen in das neue Projekt installiert.
+
+5.  Achten Sie darauf, alle aktualisieren veraltet `<plugin>` Verweise aus der alten Datei `"config.xml"` auf der neuen `<feature>` Spezifikation.
+
+6.  Alle Verweise auf das `org.apache.cordova.api`-Paket `org.apache.cordova` zu aktualisieren.
+
+    **Hinweis**: alle Core APIs wurden entfernt und als Plugins installiert sein. Einzelheiten finden Sie unter der Verwendung von Plugman zum Verwalten von Plugins-Anleitung.
+
+## Ein Upgrade auf 2.9.0 von 2.8.0
+
+1.  Run `bin/update <project_path>`.
+
+## Ein Upgrade auf 2.8.0 von 2.7.0
+
+1.  Entfernen Sie `Cordova-2.7.0.jar` aus dem Projektverzeichnis `Libs` .
+
+2.  `Cordova-2.8.0.jar` des Projekts `Libs` Verzeichnis hinzufügen.
+
+3.  Wenn Sie Eclipse verwenden, aktualisieren das Eclipse-Projekt und eine saubere zu tun.
+
+<!-- SS Eclipse -->
+
+1.  Kopieren Sie die neue `cordova.js` in Ihr Projekt.
+
+2.  Aktualisieren Sie den HTML-Code um die neue `cordova.js` -Datei verwenden.
+
+3.  Kopieren Sie die Datei `res/xml/config.xml` , um `framework/res/xml/config.xml` zu entsprechen.
+
+4.  Update `framework/res/xml/config.xml` ähnliche Einstellungen haben, wie es früher war.
+
+5.  Kopieren Sie Dateien aus `bin/templates/cordova` dem Projekt `cordova` Verzeichnis.
+
+## Ein Upgrade auf 2.7.0 von 2.6.0
+
+1.  Entfernen Sie `Cordova-2.6.0.jar` aus dem Projektverzeichnis `Libs` .
+
+2.  `Cordova-2.7.0.jar` des Projekts `Libs` Verzeichnis hinzufügen.
+
+3.  Wenn Sie Eclipse verwenden, aktualisieren das Eclipse-Projekt und eine saubere zu tun.
+
+4.  Kopieren Sie die neue `cordova-2.7.0.js` in Ihr Projekt.
+
+5.  Aktualisieren Sie den HTML-Code um die neue `cordova-2.7.0.js` -Datei verwenden.
+
+6.  Kopie der `res/xml/config.xml` entsprechend`framework/res/xml/config.xml`.
+
+7.  Update `framework/res/xml/config.xml` ähnliche Einstellungen haben, wie es früher war.
+
+8.  Kopieren Sie Dateien aus `bin/templates/cordova` für des Projekts `cordova` Verzeichnis.
+
+## Ein Upgrade auf 2.6.0 von 2.5.0
+
+1.  Entfernen Sie `Cordova-2.5.0.jar` aus dem Projektverzeichnis `Libs` .
+
+2.  `Cordova-2.6.0.jar` des Projekts `Libs` Verzeichnis hinzufügen.
+
+3.  Wenn Sie Eclipse verwenden, aktualisieren das Eclipse-Projekt und eine saubere zu tun.
+
+4.  Kopieren Sie die neue `cordova-2.6.0.js` in Ihr Projekt.
+
+5.  Aktualisieren Sie Ihre HTML-um das neue `cordova-2.6.0.js` Datei.
+
+6.  Kopie der `res/xml/config.xml` entsprechend`framework/res/xml/config.xml`.
+
+7.  Update `framework/res/xml/config.xml` ähnliche Einstellungen haben, wie es früher war.
+
+8.  Kopieren Sie Dateien aus `bin/templates/cordova` dem Projekt `cordova` Verzeichnis.
+
+Führen Sie `bin/update <project>` mit den Projektpfad im Cordova Quellverzeichnis aufgeführt.
+
+## Ein Upgrade auf 2.5.0 von 2.4.0
+
+1.  Entfernen Sie `Cordova-2.4.0.jar` aus dem Projektverzeichnis `Libs` .
+
+2.  `Cordova-2.5.0.jar` des Projekts `Libs` Verzeichnis hinzufügen.
+
+3.  Wenn Sie Eclipse verwenden, aktualisieren das Eclipse-Projekt und eine saubere zu tun.
+
+4.  Kopieren Sie die neue `cordova-2.5.0.js` in Ihr Projekt.
+
+5.  Aktualisieren Sie Ihre HTML-um das neue `cordova-2.5.0.js` Datei.
+
+6.  Kopie der `res/xml/config.xml` entsprechend`framework/res/xml/config.xml`.
+
+7.  Update `framework/res/xml/config.xml` ähnliche Einstellungen haben, wie es früher war.
+
+8.  Kopieren Sie Dateien aus `bin/templates/cordova` dem Projekt `cordova` Verzeichnis.
+
+## Ein Upgrade auf 2.4.0 von 2.3.0
+
+1.  Entfernen Sie `Cordova-2.3.0.jar` aus dem Projektverzeichnis `Libs` .
+
+2.  `Cordova-2.4.0.jar` des Projekts `Libs` Verzeichnis hinzufügen.
+
+3.  Wenn Sie Eclipse verwenden, aktualisieren das Eclipse-Projekt und eine saubere zu tun.
+
+4.  Kopieren Sie die neue `cordova-2.4.0.js` in Ihr Projekt.
+
+5.  Aktualisieren Sie Ihre HTML-um das neue `cordova-2.4.0.js` Datei.
+
+6.  Kopie der `res/xml/config.xml` entsprechend`framework/res/xml/config.xml`.
+
+7.  Kopieren Sie Dateien aus `bin/templates/cordova` für des Projekts `cordova` Verzeichnis.
+
+## Ein Upgrade auf 2.3.0 von 2.2.0
+
+1.  Entfernen Sie `Cordova-2.2.0.jar` aus dem Projektverzeichnis `Libs` .
+
+2.  `Cordova-2.3.0.jar` des Projekts `Libs` Verzeichnis hinzufügen.
+
+3.  Wenn Sie Eclipse verwenden, aktualisieren das Eclipse-Projekt und eine saubere zu tun.
+
+4.  Kopieren Sie die neue `cordova-2.3.0.js` in Ihr Projekt.
+
+5.  Aktualisieren Sie Ihre HTML-um das neue `cordova-2.3.0.js` Datei.
+
+6.  Kopie der `res/xml/config.xml` entsprechend`framework/res/xml/config.xml`.
+
+7.  Kopieren Sie Dateien aus `bin/templates/cordova` für des Projekts `cordova` Verzeichnis.
+
+## Ein Upgrade auf 2.2.0 von 2.1.0
+
+1.  Entfernen Sie `Cordova-2.1.0.jar` aus dem Projektverzeichnis `Libs` .
+
+2.  `Cordova-2.2.0.jar` des Projekts `Libs` Verzeichnis hinzufügen.
+
+3.  Wenn Sie Eclipse verwenden, aktualisieren das Eclipse-Projekt und eine saubere zu tun.
+
+4.  Kopieren Sie die neue `cordova-2.2.0.js` in Ihr Projekt.
+
+5.  Aktualisieren Sie Ihre HTML-um das neue `cordova-2.2.0.js` Datei.
+
+6.  Kopie der `res/xml/config.xml` entsprechend`framework/res/xml/config.xml`.
+
+7.  Kopieren Sie Dateien aus `bin/templates/cordova` dem Projekt `cordova` Verzeichnis.
+
+## Upgrade auf 2.1.0 von 2.0.0
+
+1.  Entfernen Sie `Cordova-2.0.0.jar` aus dem Projektverzeichnis `Libs` .
+
+2.  `Cordova-2.1.0.jar` des Projekts `Libs` Verzeichnis hinzufügen.
+
+3.  Wenn Sie Eclipse verwenden, aktualisieren das Eclipse-Projekt und eine saubere zu tun.
+
+4.  Kopieren Sie die neue `cordova-2.1.0.js` in Ihr Projekt.
+
+5.  Aktualisieren Sie Ihre HTML-um das neue `cordova-2.1.0.js` Datei.
+
+6.  Kopie der `res/xml/config.xml` entsprechen`framework/res/xml/config.xml`.
+
+7.  Kopieren Sie Dateien aus `bin/templates/cordova` dem Projekt `cordova` Verzeichnis.
+
+## Ein Upgrade auf 2.0.0 von 1.9.0
+
+1.  Entfernen Sie `Cordova-1.9.0.jar` aus dem Projektverzeichnis `Libs` .
+
+2.  `Cordova-2.0.0.jar` des Projekts `Libs` Verzeichnis hinzufügen.
+
+3.  Wenn Sie Eclipse verwenden, aktualisieren das Eclipse-Projekt und eine saubere zu tun.
+
+4.  Kopieren Sie die neue `cordova-2.0.0.js` in Ihr Projekt.
+
+5.  Aktualisieren Sie Ihre HTML-um das neue `cordova-2.0.0.js` Datei.
+
+6.  Kopie der `res/xml/config.xml` entsprechen`framework/res/xml/config.xml`.
+
+In der 2.0.0 Release, die Datei `config.xml` kombiniert und ersetzt `cordova.xml` und `plugins.xml`. Die alten Dateien sind veraltet, und während sie noch in 2.0.0, arbeiten funktioniert nicht mehr in einer zukünftigen Version.
+
+## Ein Upgrade auf 1.9.0 von 1.8.1
+
+1.  Entfernen Sie `Cordova-1.8.0.jar` aus dem Projektverzeichnis `Libs` .
+
+2.  `Cordova-1.9.0.jar` des Projekts `Libs` Verzeichnis hinzufügen.
+
+3.  Wenn Sie Eclipse verwenden, aktualisieren das Eclipse-Projekt und eine saubere zu tun.
+
+4.  Kopieren Sie die neue `Cordova-1.9.0.js` in Ihr Projekt.
+
+5.  Aktualisieren Sie den HTML-Code um die neue `Cordova-1.9.0.js` -Datei verwenden.
+
+6.  Update `res/xml/plugins.xml` entsprechend`framework/res/xml/plugins.xml`.
+
+Aufgrund der Einführung des `CordovaWebView` in die 1.9.0 release, Drittanbieter Plugins funktionieren nicht. Diese Plugins müssen einen Kontext aus dem `CordovaInterface` mit `getContext()` oder `getActivity()`. Wenn Sie kein erfahrener Android-Entwickler sind, bitte kontaktieren Sie den Plugin-Betreuer und fügen Sie diese Aufgabe auf ihre Bug-Tracker.
+
+## Ein Upgrade auf 1.8.0 von 1.8.0
+
+1.  Entfernen Sie `Cordova-1.8.0.jar` aus dem Projektverzeichnis `Libs` .
+
+2.  `Cordova-1.8.1.jar` des Projekts `Libs` Verzeichnis hinzufügen.
+
+3.  Wenn Sie Eclipse verwenden, aktualisieren das Eclipse-Projekt und eine saubere zu tun.
+
+4.  Kopieren Sie die neue `Cordova-1.8.1.js` in Ihr Projekt.
+
+5.  Aktualisieren Sie den HTML-Code um die neue `Cordova-1.8.1.js` -Datei verwenden.
+
+6.  Update `res/xml/plugins.xml` entsprechend`framework/res/xml/plugins.xml`.
+
+## Ein Upgrade auf 1.8.0 von 1.7.0
+
+1.  Entfernen Sie `Cordova-1.7.0.jar` aus dem Projektverzeichnis `Libs` .
+
+2.  `Cordova-1.8.0.jar` des Projekts `Libs` Verzeichnis hinzufügen.
+
+3.  Wenn Sie Eclipse verwenden, aktualisieren das Eclipse-Projekt und eine saubere zu tun.
+
+4.  Kopieren Sie die neue `cordova-1.8.0.js` in Ihr Projekt.
+
+5.  Aktualisieren Sie Ihre HTML-um das neue `cordova-1.8.0.js` Datei.
+
+6.  Update `res/xml/plugins.xml` übereinstimmen`framework/res/xml/plugins.xml`.
+
+## Ein Upgrade auf 1.8.0 von 1.7.0
+
+1.  Entfernen Sie `Cordova-1.7.0.jar` aus dem Projektverzeichnis `Libs` .
+
+2.  `Cordova-1.8.0.jar` des Projekts `Libs` Verzeichnis hinzufügen.
+
+3.  Wenn Sie Eclipse verwenden, aktualisieren das Eclipse-Projekt und eine saubere zu tun.
+
+4.  Kopieren Sie die neue `cordova-1.8.0.js` in Ihr Projekt.
+
+5.  Aktualisieren Sie Ihre HTML-um das neue `cordova-1.8.0.js` Datei.
+
+6.  Update `res/xml/plugins.xml` übereinstimmen`framework/res/xml/plugins.xml`.
+
+## Ein Upgrade auf 1.7.0 von 1.6.1
+
+1.  Entfernen Sie `Cordova-1.6.1.jar` aus dem Projektverzeichnis `Libs` .
+
+2.  `Cordova-1.7.0.jar` des Projekts `Libs` Verzeichnis hinzufügen.
+
+3.  Wenn Sie Eclipse verwenden, aktualisieren das Eclipse-Projekt und eine saubere zu tun.
+
+4.  Kopieren Sie die neue `Cordova-1.7.0.js` in Ihr Projekt.
+
+5.  Update `res/xml/plugins.xml` übereinstimmen`framework/res/xml/plugins.xml`.
+
+## Ein Upgrade auf 1.6.1 von 1.6.0
+
+1.  Entfernen Sie `Cordova-1.6.0.jar` aus dem Projektverzeichnis `Libs` .
+
+2.  `Cordova-1.6.1.jar` des Projekts `Libs` Verzeichnis hinzufügen.
+
+3.  Wenn Sie Eclipse verwenden, aktualisieren das Eclipse-Projekt und eine saubere zu tun.
+
+4.  Kopieren Sie die neue `Cordova-1.6.1.js` in Ihr Projekt.
+
+5.  Update `res/xml/plugins.xml` übereinstimmen`framework/res/xml/plugins.xml`.
+
+## Ein Upgrade auf 1.6.0 von 1.5.0
+
+1.  Entfernen Sie `Cordova-1.5.0.jar` aus dem Projektverzeichnis `Libs` .
+
+2.  `Cordova-1.6.0.jar` des Projekts `Libs` Verzeichnis hinzufügen.
+
+3.  Wenn Sie Eclipse verwenden, aktualisieren das Eclipse-Projekt und eine saubere zu tun.
+
+4.  Kopieren Sie die neue `Cordova-1.6.0.js` in Ihr Projekt.
+
+5.  Aktualisieren Sie den HTML-Code um die neue `Cordova-1.6.0.js` -Datei verwenden.
+
+6.  Update `res/xml/plugins.xml` entsprechend`framework/res/xml/plugins.xml`.
+
+7.  Ersetzen Sie `res/xml/phonegap.xml` durch `res/xml/cordova.xml` entsprechend `framework/res/xml/cordova.xml`.
+
+## Ein Upgrade auf 1.5.0 von 1.4.0
+
+1.  Entfernen Sie `Phonegap-1.4.0.jar` aus dem Projektverzeichnis `Libs` .
+
+2.  `Cordova-1.5.0.jar` des Projekts `Libs` Verzeichnis hinzufügen.
+
+3.  Wenn Sie Eclipse verwenden, aktualisieren das Eclipse-Projekt und eine saubere zu tun.
+
+4.  Kopieren Sie die neue `Cordova-1.5.0.js` in Ihr Projekt.
+
+5.  Aktualisieren Sie den HTML-Code um die neue `Cordova-1.5.0.js` -Datei verwenden.
+
+6.  Update `res/xml/plugins.xml` entsprechend`framework/res/xml/plugins.xml`.
+
+7.  Ersetzen Sie `res/xml/phonegap.xml` durch `res/xml/cordova.xml` entsprechend `framework/res/xml/cordova.xml`.
+
+## Ein Upgrade auf 1.4.0 von 1.3.0
+
+1.  Entfernen Sie `Phonegap-1.3.0.jar` aus dem Projektverzeichnis `Libs` .
+
+2.  Das Verzeichnis des Projekts `Libs` `Phonegap-1.4.0.jar` hinzufügen.
+
+3.  Wenn Sie Eclipse verwenden, aktualisieren das Eclipse-Projekt und eine saubere zu tun.
+
+4.  Kopieren Sie die neue `Phonegap-1.4.0.js` in Ihr Projekt.
+
+5.  Aktualisieren Sie den HTML-Code um die neue `Phonegap-1.4.0.js` -Datei verwenden.
+
+6.  Update `res/xml/plugins.xml` entsprechend`framework/res/xml/plugins.xml`.
+
+7.  Update `res/xml/phonegap.xml` entsprechend`framework/res/xml/phonegap.xml`.
+
+## Ein Upgrade auf 1.3.0 von 1.2.0
+
+1.  Entfernen Sie `Phonegap-1.2.0.jar` aus dem Projektverzeichnis `Libs` .
+
+2.  Das Verzeichnis des Projekts `Libs` `Phonegap-1.3.0.jar` hinzufügen.
+
+3.  Wenn Sie Eclipse verwenden, aktualisieren das Eclipse-Projekt und eine saubere zu tun.
+
+4.  Kopieren Sie die neue `Phonegap-1.3.0.js` in Ihr Projekt.
+
+5.  Aktualisieren Sie den HTML-Code um die neue `Phonegap-1.2.0.js` -Datei verwenden.
+
+6.  Update `res/xml/plugins.xml` entsprechend`framework/res/xml/plugins.xml`.
+
+7.  Update `res/xml/phonegap.xml` übereinstimmen`framework/res/xml/phonegap.xml`.
+
+## Ein Upgrade auf 1.2.0 von 1.1.0
+
+1.  Entfernen Sie `Phonegap-1.1.0.jar` aus dem Projektverzeichnis `Libs` .
+
+2.  Das Verzeichnis des Projekts `Libs` `Phonegap-1.2.0.jar` hinzufügen.
+
+3.  Wenn Sie Eclipse verwenden, aktualisieren das Eclipse-Projekt und eine saubere zu tun.
+
+4.  Kopieren Sie die neue `Phonegap-1.2.0.js` in Ihr Projekt.
+
+5.  Aktualisieren Sie den HTML-Code um die neue `Phonegap-1.2.0.js` -Datei verwenden.
+
+6.  Update `res/xml/plugins.xml` übereinstimmen`framework/res/xml/plugins.xml`.
+
+7.  Update `res/xml/phonegap.xml` übereinstimmen`framework/res/xml/phonegap.xml`.
+
+## Von 1.0.0 auf 1.1.0 aktualisieren
+
+1.  Entfernen Sie `Phonegap-1.0.0.jar` aus dem Projektverzeichnis `Libs` .
+
+2.  Das Verzeichnis des Projekts `Libs` `Phonegap-1.1.0.jar` hinzufügen.
+
+3.  Wenn Sie Eclipse verwenden, aktualisieren das Eclipse-Projekt und eine saubere zu tun.
+
+4.  Kopieren Sie die neue `Phonegap-1.1.0.js` in Ihr Projekt.
+
+5.  Aktualisieren Sie den HTML-Code um die neue `Phonegap-1.1.0.js` -Datei verwenden.
+
+6.  Update `res/xml/plugins.xml` übereinstimmen`framework/res/xml/plugins.xml`.
+
+## Ein Upgrade auf 1.0.0 von 0.9.6
+
+1.  Entfernen Sie `Phonegap-0.9.6.jar` aus dem Projektverzeichnis `Libs` .
+
+2.  Das Verzeichnis des Projekts `Libs` `Phonegap-1.0.0.jar` hinzufügen.
+
+3.  Wenn Sie Eclipse verwenden, aktualisieren das Eclipse-Projekt und eine saubere zu tun.
+
+4.  Kopieren Sie die neue `Phonegap-1.0.0.js` in Ihr Projekt.
+
+5.  Aktualisieren Sie den HTML-Code um die neue `Phonegap-1.0.0.js` -Datei verwenden.
+
+6.  Fügen Sie die `res/xml/plugins.xml` entsprechend `framework/res/xml/plugins.xml`.

http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/5ad93d20/www/docs/de/7.x/guide/platforms/android/upgrading.md
----------------------------------------------------------------------
diff --git a/www/docs/de/7.x/guide/platforms/android/upgrading.md b/www/docs/de/7.x/guide/platforms/android/upgrading.md
new file mode 100644
index 0000000..d46691c
--- /dev/null
+++ b/www/docs/de/7.x/guide/platforms/android/upgrading.md
@@ -0,0 +1,436 @@
+---
+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.
+
+title: Aktualisierung von Android
+---
+
+# Aktualisierung von Android
+
+Diese Anleitung zeigt wie Android Projekte Upgrade von älteren Versionen von Cordova zu ändern. Die meisten diese Anweisungen gelten für Projekte, die mit einer älteren Befehlszeilentools, die vorangehen erstellt die `cordova` CLI-Hilfsprogramm. Die Command-Line Interface Informationen finden Sie unter Gewusst wie: Aktualisieren Sie die Version der CLI.
+
+## Upgrade von 3.2.0 auf 3.3.0
+
+Folgen Sie den gleichen Instructinos wie für`3.2.0`.
+
+Beginnend mit 3.3.0, wird Cordova-Runtime jetzt als Android-Bibliothek anstelle von einem Glas kompiliert. Dies sollte keine Auswirkungen für Command-Line Usage, aber IDE-Benutzer müssen die neu hinzugefügte importieren `MyProject-CordovaLib` Projekt in ihren Arbeitsbereich.
+
+## Upgrade von 3.1.0 auf 3.2.0
+
+Für Projekte, die mit Cordova CLI erstellt wurden:
+
+1.  Update der `cordova` CLI-Version. Finden Sie die Befehlszeilenschnittstelle.
+
+2.  Ausführen`cordova platform update android`
+
+Für Projekte, die nicht mit der Cordova CLI erstellt ausgeführt:
+
+        bin/update <project_path>
+
+
+## Upgrade von 3.0.0 auf 3.1.0
+
+Für Projekte, die mit Cordova CLI erstellt wurden:
+
+1.  Update der `cordova` CLI-Version. Finden Sie die Befehlszeilenschnittstelle.
+
+2.  Ausführen`cordova platform update android`
+
+Für Projekte, die nicht mit der Cordova CLI erstellt ausgeführt:
+
+        bin/update <project_path>
+
+
+## Upgrade auf die CLI (3.0.0) von 2.9.0
+
+1.  Erstellen Sie ein neues Apache Cordova 3.0.0-Projekt mit Cordova CLI, wie in der Command-Line Interface beschrieben.
+
+2.  Fügen Sie Ihrer Plattformen Projektes Cordova, zum Beispiel:`cordova
+platform add android`.
+
+3.  Kopieren Sie den Inhalt Ihres Projekts `www` Verzeichnis in das `www` Verzeichnis im Stammverzeichnis des Projektes Cordova, die Sie gerade erstellt haben.
+
+4.  Nativen Vermögen aus dem alten Projekt kopieren, in die entsprechenden Verzeichnisse unter `platforms/android` : in diesem Verzeichnis werden in dem systemeigene Cordova-Android Projekt vorhanden ist.
+
+5.  Verwenden Sie Cordova-CLI-Tool, um alle Plugins zu installieren, die Sie brauchen. Beachten Sie, dass die CLI behandelt alle Kern-APIs als Plugins, so müssen sie möglicherweise hinzugefügt werden. Nur 3.0.0 Plugins sind kompatibel mit CLI.
+
+## Ein Upgrade auf 3.0.0 von 2.9.0
+
+1.  Erstellen Sie ein neues Apache Cordova Android Projekt.
+
+2.  Kopieren Sie den Inhalt Ihrer `www` Verzeichnis in das neue Projekt.
+
+3.  Kopieren Sie nativen Android Vermögen aus Ihrem `res` Verzeichnis in das neue Projekt.
+
+4.  Kopie über alle Plugins, die von der Installation der `src` Unterverzeichnisse in das neue Projekt.
+
+5.  Achten Sie darauf, alle veraltet aktualisieren `<plugin>` Referenzen aus Ihrem alten `config.xml` Datei an den neuen `<feature>` Spezifikation.
+
+6.  Aktualisieren Sie alle Verweise auf die `org.apache.cordova.api` Paket ist`org.apache.cordova`.
+
+    **Hinweis**: alle Core APIs wurden entfernt und als Plugins installiert sein. Einzelheiten finden Sie unter der Verwendung von Plugman zum Verwalten von Plugins-Anleitung.
+
+## Ein Upgrade auf 2.9.0 von 2.8.0
+
+1.  Ausführen`bin/update <project_path>`.
+
+## Ein Upgrade auf 2.8.0 von 2.7.0
+
+1.  Entfernen von `cordova-2.7.0.jar` aus des Projekts `libs` Verzeichnis.
+
+2.  Hinzufügen von `cordova-2.8.0.jar` für des Projekts `libs` Verzeichnis.
+
+3.  Wenn Sie Eclipse verwenden, aktualisieren das Eclipse-Projekt und eine saubere zu tun.
+
+<!-- SS Eclipse -->
+
+1.  Kopieren Sie die neue `cordova.js` in Ihr Projekt.
+
+2.  Aktualisieren Sie den HTML-Code um das neue `cordova.js` Datei.
+
+3.  Kopie der `res/xml/config.xml` -Datei`framework/res/xml/config.xml`.
+
+4.  Update `framework/res/xml/config.xml` ähnliche Einstellungen haben, wie es früher war.
+
+5.  Kopieren Sie Dateien aus `bin/templates/cordova` für des Projekts `cordova` Verzeichnis.
+
+## Ein Upgrade auf 2.7.0 von 2.6.0
+
+1.  Entfernen von `cordova-2.6.0.jar` aus des Projekts `libs` Verzeichnis.
+
+2.  Hinzufügen von `cordova-2.7.0.jar` für des Projekts `libs` Verzeichnis.
+
+3.  Wenn Sie Eclipse verwenden, aktualisieren das Eclipse-Projekt und eine saubere zu tun.
+
+4.  Kopieren Sie die neue `cordova-2.7.0.js` in Ihr Projekt.
+
+5.  Aktualisieren Sie den HTML-Code um das neue `cordova-2.7.0.js` Datei.
+
+6.  Kopie der `res/xml/config.xml` entsprechend`framework/res/xml/config.xml`.
+
+7.  Update `framework/res/xml/config.xml` ähnliche Einstellungen haben, wie es früher war.
+
+8.  Kopieren Sie Dateien aus `bin/templates/cordova` für des Projekts `cordova` Verzeichnis.
+
+## Ein Upgrade auf 2.6.0 von 2.5.0
+
+1.  Entfernen von `cordova-2.5.0.jar` aus des Projekts `libs` Verzeichnis.
+
+2.  Hinzufügen von `cordova-2.6.0.jar` für des Projekts `libs` Verzeichnis.
+
+3.  Wenn Sie Eclipse verwenden, aktualisieren das Eclipse-Projekt und eine saubere zu tun.
+
+4.  Kopieren Sie die neue `cordova-2.6.0.js` in Ihr Projekt.
+
+5.  Aktualisieren Sie den HTML-Code um das neue `cordova-2.6.0.js` Datei.
+
+6.  Kopie der `res/xml/config.xml` entsprechend`framework/res/xml/config.xml`.
+
+7.  Update `framework/res/xml/config.xml` ähnliche Einstellungen haben, wie es früher war.
+
+8.  Kopieren Sie Dateien aus `bin/templates/cordova` für des Projekts `cordova` Verzeichnis.
+
+Führen Sie `bin/update <project>` mit den Projektpfad in Cordova Quellverzeichnis aufgeführt.
+
+## Ein Upgrade auf 2.5.0 von 2.4.0
+
+1.  Entfernen von `cordova-2.4.0.jar` aus des Projekts `libs` Verzeichnis.
+
+2.  Hinzufügen von `cordova-2.5.0.jar` für des Projekts `libs` Verzeichnis.
+
+3.  Wenn Sie Eclipse verwenden, aktualisieren das Eclipse-Projekt und eine saubere zu tun.
+
+4.  Kopieren Sie die neue `cordova-2.5.0.js` in Ihr Projekt.
+
+5.  Aktualisieren Sie den HTML-Code um das neue `cordova-2.5.0.js` Datei.
+
+6.  Kopie der `res/xml/config.xml` entsprechend`framework/res/xml/config.xml`.
+
+7.  Update `framework/res/xml/config.xml` ähnliche Einstellungen haben, wie es früher war.
+
+8.  Kopieren Sie Dateien aus `bin/templates/cordova` für des Projekts `cordova` Verzeichnis.
+
+## Ein Upgrade auf 2.4.0 von 2.3.0
+
+1.  Entfernen von `cordova-2.3.0.jar` aus des Projekts `libs` Verzeichnis.
+
+2.  Hinzufügen von `cordova-2.4.0.jar` für des Projekts `libs` Verzeichnis.
+
+3.  Wenn Sie Eclipse verwenden, aktualisieren das Eclipse-Projekt und eine saubere zu tun.
+
+4.  Kopieren Sie die neue `cordova-2.4.0.js` in Ihr Projekt.
+
+5.  Aktualisieren Sie den HTML-Code um das neue `cordova-2.4.0.js` Datei.
+
+6.  Kopie der `res/xml/config.xml` entsprechend`framework/res/xml/config.xml`.
+
+7.  Kopieren Sie Dateien aus `bin/templates/cordova` für des Projekts `cordova` Verzeichnis.
+
+## Ein Upgrade auf 2.3.0 von 2.2.0
+
+1.  Entfernen von `cordova-2.2.0.jar` aus des Projekts `libs` Verzeichnis.
+
+2.  Hinzufügen von `cordova-2.3.0.jar` für des Projekts `libs` Verzeichnis.
+
+3.  Wenn Sie Eclipse verwenden, aktualisieren das Eclipse-Projekt und eine saubere zu tun.
+
+4.  Kopieren Sie die neue `cordova-2.3.0.js` in Ihr Projekt.
+
+5.  Aktualisieren Sie den HTML-Code um das neue `cordova-2.3.0.js` Datei.
+
+6.  Kopie der `res/xml/config.xml` entsprechend`framework/res/xml/config.xml`.
+
+7.  Kopieren Sie Dateien aus `bin/templates/cordova` für des Projekts `cordova` Verzeichnis.
+
+## Ein Upgrade auf 2.2.0 von 2.1.0
+
+1.  Entfernen von `cordova-2.1.0.jar` aus des Projekts `libs` Verzeichnis.
+
+2.  Hinzufügen von `cordova-2.2.0.jar` für des Projekts `libs` Verzeichnis.
+
+3.  Wenn Sie Eclipse verwenden, aktualisieren das Eclipse-Projekt und eine saubere zu tun.
+
+4.  Kopieren Sie die neue `cordova-2.2.0.js` in Ihr Projekt.
+
+5.  Aktualisieren Sie den HTML-Code um das neue `cordova-2.2.0.js` Datei.
+
+6.  Kopie der `res/xml/config.xml` entsprechend`framework/res/xml/config.xml`.
+
+7.  Kopieren Sie Dateien aus `bin/templates/cordova` für des Projekts `cordova` Verzeichnis.
+
+## Upgrade auf 2.1.0 von 2.0.0
+
+1.  Entfernen von `cordova-2.0.0.jar` aus des Projekts `libs` Verzeichnis.
+
+2.  Hinzufügen von `cordova-2.1.0.jar` für des Projekts `libs` Verzeichnis.
+
+3.  Wenn Sie Eclipse verwenden, aktualisieren das Eclipse-Projekt und eine saubere zu tun.
+
+4.  Kopieren Sie die neue `cordova-2.1.0.js` in Ihr Projekt.
+
+5.  Aktualisieren Sie den HTML-Code um das neue `cordova-2.1.0.js` Datei.
+
+6.  Kopie der `res/xml/config.xml` entsprechend`framework/res/xml/config.xml`.
+
+7.  Kopieren Sie Dateien aus `bin/templates/cordova` für des Projekts `cordova` Verzeichnis.
+
+## Ein Upgrade auf 2.0.0 von 1.9.0
+
+1.  Entfernen von `cordova-1.9.0.jar` aus des Projekts `libs` Verzeichnis.
+
+2.  Hinzufügen von `cordova-2.0.0.jar` für des Projekts `libs` Verzeichnis.
+
+3.  Wenn Sie Eclipse verwenden, aktualisieren das Eclipse-Projekt und eine saubere zu tun.
+
+4.  Kopieren Sie die neue `cordova-2.0.0.js` in Ihr Projekt.
+
+5.  Aktualisieren Sie den HTML-Code um das neue `cordova-2.0.0.js` Datei.
+
+6.  Kopie der `res/xml/config.xml` entsprechend`framework/res/xml/config.xml`.
+
+Die 2.0.0 release, die `config.xml` Datei kombiniert und ersetzt `cordova.xml` und `plugins.xml` . Die alten Dateien sind veraltet, und während sie noch in 2.0.0, arbeiten funktioniert nicht mehr in einer zukünftigen Version.
+
+## Ein Upgrade auf 1.9.0 von 1.8.1
+
+1.  Entfernen von `cordova-1.8.0.jar` aus des Projekts `libs` Verzeichnis.
+
+2.  Hinzufügen von `cordova-1.9.0.jar` für des Projekts `libs` Verzeichnis.
+
+3.  Wenn Sie Eclipse verwenden, aktualisieren das Eclipse-Projekt und eine saubere zu tun.
+
+4.  Kopieren Sie die neue `cordova-1.9.0.js` in Ihr Projekt.
+
+5.  Aktualisieren Sie den HTML-Code um das neue `cordova-1.9.0.js` Datei.
+
+6.  Update `res/xml/plugins.xml` entsprechend`framework/res/xml/plugins.xml`.
+
+Durch die Einführung der `CordovaWebView` in der 1.9.0 Release, Drittanbieter Plugins funktionieren nicht. Diese Plugins brauchen, um einen Kontext aus dem `CordovaInterface` mit `getContext()` oder `getActivity()` . Wenn Sie kein erfahrener Android-Entwickler sind, bitte kontaktieren Sie den Plugin-Betreuer und fügen Sie diese Aufgabe auf ihre Bug-Tracker.
+
+## Ein Upgrade auf 1.8.0 von 1.8.0
+
+1.  Entfernen von `cordova-1.8.0.jar` aus des Projekts `libs` Verzeichnis.
+
+2.  Hinzufügen von `cordova-1.8.1.jar` für des Projekts `libs` Verzeichnis.
+
+3.  Wenn Sie Eclipse verwenden, aktualisieren das Eclipse-Projekt und eine saubere zu tun.
+
+4.  Kopieren Sie die neue `cordova-1.8.1.js` in Ihr Projekt.
+
+5.  Aktualisieren Sie den HTML-Code um das neue `cordova-1.8.1.js` Datei.
+
+6.  Update `res/xml/plugins.xml` entsprechend`framework/res/xml/plugins.xml`.
+
+## Ein Upgrade auf 1.8.0 von 1.7.0
+
+1.  Entfernen von `cordova-1.7.0.jar` aus des Projekts `libs` Verzeichnis.
+
+2.  Hinzufügen von `cordova-1.8.0.jar` für des Projekts `libs` Verzeichnis.
+
+3.  Wenn Sie Eclipse verwenden, aktualisieren das Eclipse-Projekt und eine saubere zu tun.
+
+4.  Kopieren Sie die neue `cordova-1.8.0.js` in Ihr Projekt.
+
+5.  Aktualisieren Sie den HTML-Code um das neue `cordova-1.8.0.js` Datei.
+
+6.  Update `res/xml/plugins.xml` entsprechend`framework/res/xml/plugins.xml`.
+
+## Ein Upgrade auf 1.8.0 von 1.7.0
+
+1.  Entfernen von `cordova-1.7.0.jar` aus des Projekts `libs` Verzeichnis.
+
+2.  Hinzufügen von `cordova-1.8.0.jar` für des Projekts `libs` Verzeichnis.
+
+3.  Wenn Sie Eclipse verwenden, aktualisieren das Eclipse-Projekt und eine saubere zu tun.
+
+4.  Kopieren Sie die neue `cordova-1.8.0.js` in Ihr Projekt.
+
+5.  Aktualisieren Sie den HTML-Code um das neue `cordova-1.8.0.js` Datei.
+
+6.  Update `res/xml/plugins.xml` entsprechend`framework/res/xml/plugins.xml`.
+
+## Ein Upgrade auf 1.7.0 von 1.6.1
+
+1.  Entfernen von `cordova-1.6.1.jar` aus des Projekts `libs` Verzeichnis.
+
+2.  Hinzufügen von `cordova-1.7.0.jar` für des Projekts `libs` Verzeichnis.
+
+3.  Wenn Sie Eclipse verwenden, aktualisieren das Eclipse-Projekt und eine saubere zu tun.
+
+4.  Kopieren Sie die neue `cordova-1.7.0.js` in Ihr Projekt.
+
+5.  Update `res/xml/plugins.xml` entsprechend`framework/res/xml/plugins.xml`.
+
+## Ein Upgrade auf 1.6.1 von 1.6.0
+
+1.  Entfernen von `cordova-1.6.0.jar` aus des Projekts `libs` Verzeichnis.
+
+2.  Hinzufügen von `cordova-1.6.1.jar` für des Projekts `libs` Verzeichnis.
+
+3.  Wenn Sie Eclipse verwenden, aktualisieren das Eclipse-Projekt und eine saubere zu tun.
+
+4.  Kopieren Sie die neue `cordova-1.6.1.js` in Ihr Projekt.
+
+5.  Update `res/xml/plugins.xml` entsprechend`framework/res/xml/plugins.xml`.
+
+## Ein Upgrade auf 1.6.0 von 1.5.0
+
+1.  Entfernen von `cordova-1.5.0.jar` aus des Projekts `libs` Verzeichnis.
+
+2.  Hinzufügen von `cordova-1.6.0.jar` für des Projekts `libs` Verzeichnis.
+
+3.  Wenn Sie Eclipse verwenden, aktualisieren das Eclipse-Projekt und eine saubere zu tun.
+
+4.  Kopieren Sie die neue `cordova-1.6.0.js` in Ihr Projekt.
+
+5.  Aktualisieren Sie den HTML-Code um das neue `cordova-1.6.0.js` Datei.
+
+6.  Update `res/xml/plugins.xml` entsprechend`framework/res/xml/plugins.xml`.
+
+7.  Ersetzen Sie `res/xml/phonegap.xml` mit `res/xml/cordova.xml` übereinstimmen`framework/res/xml/cordova.xml`.
+
+## Ein Upgrade auf 1.5.0 von 1.4.0
+
+1.  Entfernen von `phonegap-1.4.0.jar` aus des Projekts `libs` Verzeichnis.
+
+2.  Hinzufügen von `cordova-1.5.0.jar` für des Projekts `libs` Verzeichnis.
+
+3.  Wenn Sie Eclipse verwenden, aktualisieren das Eclipse-Projekt und eine saubere zu tun.
+
+4.  Kopieren Sie die neue `cordova-1.5.0.js` in Ihr Projekt.
+
+5.  Aktualisieren Sie den HTML-Code um das neue `cordova-1.5.0.js` Datei.
+
+6.  Update `res/xml/plugins.xml` entsprechend`framework/res/xml/plugins.xml`.
+
+7.  Ersetzen Sie `res/xml/phonegap.xml` mit `res/xml/cordova.xml` übereinstimmen`framework/res/xml/cordova.xml`.
+
+## Ein Upgrade auf 1.4.0 von 1.3.0
+
+1.  Entfernen von `phonegap-1.3.0.jar` aus des Projekts `libs` Verzeichnis.
+
+2.  Hinzufügen von `phonegap-1.4.0.jar` für des Projekts `libs` Verzeichnis.
+
+3.  Wenn Sie Eclipse verwenden, aktualisieren das Eclipse-Projekt und eine saubere zu tun.
+
+4.  Kopieren Sie die neue `phonegap-1.4.0.js` in Ihr Projekt.
+
+5.  Aktualisieren Sie den HTML-Code um das neue `phonegap-1.4.0.js` Datei.
+
+6.  Update `res/xml/plugins.xml` entsprechend`framework/res/xml/plugins.xml`.
+
+7.  Update `res/xml/phonegap.xml` entsprechend`framework/res/xml/phonegap.xml`.
+
+## Ein Upgrade auf 1.3.0 von 1.2.0
+
+1.  Entfernen von `phonegap-1.2.0.jar` aus des Projekts `libs` Verzeichnis.
+
+2.  Hinzufügen von `phonegap-1.3.0.jar` für des Projekts `libs` Verzeichnis.
+
+3.  Wenn Sie Eclipse verwenden, aktualisieren das Eclipse-Projekt und eine saubere zu tun.
+
+4.  Kopieren Sie die neue `phonegap-1.3.0.js` in Ihr Projekt.
+
+5.  Aktualisieren Sie den HTML-Code um das neue `phonegap-1.2.0.js` Datei.
+
+6.  Update `res/xml/plugins.xml` entsprechend`framework/res/xml/plugins.xml`.
+
+7.  Update `res/xml/phonegap.xml` entsprechend`framework/res/xml/phonegap.xml`.
+
+## Ein Upgrade auf 1.2.0 von 1.1.0
+
+1.  Entfernen von `phonegap-1.1.0.jar` aus des Projekts `libs` Verzeichnis.
+
+2.  Hinzufügen von `phonegap-1.2.0.jar` für des Projekts `libs` Verzeichnis.
+
+3.  Wenn Sie Eclipse verwenden, aktualisieren das Eclipse-Projekt und eine saubere zu tun.
+
+4.  Kopieren Sie die neue `phonegap-1.2.0.js` in Ihr Projekt.
+
+5.  Aktualisieren Sie den HTML-Code um das neue `phonegap-1.2.0.js` Datei.
+
+6.  Update `res/xml/plugins.xml` entsprechend`framework/res/xml/plugins.xml`.
+
+7.  Update `res/xml/phonegap.xml` entsprechend`framework/res/xml/phonegap.xml`.
+
+## Von 1.0.0 auf 1.1.0 aktualisieren
+
+1.  Entfernen von `phonegap-1.0.0.jar` aus des Projekts `libs` Verzeichnis.
+
+2.  Hinzufügen von `phonegap-1.1.0.jar` für des Projekts `libs` Verzeichnis.
+
+3.  Wenn Sie Eclipse verwenden, aktualisieren das Eclipse-Projekt und eine saubere zu tun.
+
+4.  Kopieren Sie die neue `phonegap-1.1.0.js` in Ihr Projekt.
+
+5.  Aktualisieren Sie den HTML-Code um das neue `phonegap-1.1.0.js` Datei.
+
+6.  Update `res/xml/plugins.xml` entsprechend`framework/res/xml/plugins.xml`.
+
+## Ein Upgrade auf 1.0.0 von 0.9.6
+
+1.  Entfernen von `phonegap-0.9.6.jar` aus des Projekts `libs` Verzeichnis.
+
+2.  Hinzufügen von `phonegap-1.0.0.jar` für des Projekts `libs` Verzeichnis.
+
+3.  Wenn Sie Eclipse verwenden, aktualisieren das Eclipse-Projekt und eine saubere zu tun.
+
+4.  Kopieren Sie die neue `phonegap-1.0.0.js` in Ihr Projekt.
+
+5.  Aktualisieren Sie den HTML-Code um das neue `phonegap-1.0.0.js` Datei.
+
+6.  Fügen Sie die `res/xml/plugins.xml` entsprechend`framework/res/xml/plugins.xml`.

http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/5ad93d20/www/docs/de/7.x/guide/platforms/android/webview.md
----------------------------------------------------------------------
diff --git a/www/docs/de/7.x/guide/platforms/android/webview.md b/www/docs/de/7.x/guide/platforms/android/webview.md
new file mode 100644
index 0000000..a141f53
--- /dev/null
+++ b/www/docs/de/7.x/guide/platforms/android/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.
+
+title: Android Webansichten für
+---
+
+# Android Webansichten für
+
+Diese Anleitung zeigt, wie eine Cordova-fähigen WebView Komponente innerhalb einer größeren Android Anwendung einbetten. Details darüber, wie diese Komponenten miteinander kommunizieren können finden Sie unter Application Plugins.
+
+Wenn Sie mit Android nicht vertraut sind, sollten Sie zunächst machen Sie sich vertraut mit der [Android-Plattform-Guide](index.html) und haben die neuesten Android SDK installiert, bevor Sie versuchen die ungewöhnlicheren Entwicklungsoption einen WebView-Einbettung. Beginnend mit Cordova 1,9, die Android-Plattform setzt auf eine `CordovaWebView` -Komponente, die auf ein Vermächtnis baut `CordovaActivity` Komponente, die vor der 1.9 Version stammt.
+
+1.  Um diese Anweisungen befolgen, stellen Sie sicher, dass Sie die neueste Cordova-Verteilung. Von [cordova.apache.org][1] herunterladen Sie und entpacken Sie das Android-Paket.
+
+2.  Navigieren Sie zu des Android-Pakets `/framework` Verzeichnis und führen `ant jar` . Es schafft die Cordova `.jar` Datei, bildete sich als`/framework/cordova-x.x.x.jar`.
+
+3.  Kopie der `.jar` Datei in des Android-Projekts `/libs` Verzeichnis.
+
+4.  Fügen Sie Folgendes in der Anwendung `/res/xml/main.xml` -Datei, mit der `layout_height` , `layout_width` und `id` die Anwendung angepasst:
+    
+        <org.apache.cordova.CordovaWebView
+            android:id="@+id/tutorialView"
+            android:layout_width="match_parent"
+            android:layout_height="match_parent" />
+        
+
+5.  Die Aktivität ändern, sodass es implementiert die `CordovaInterface` . Es sollte die enthalten Methoden implementieren. Vielleicht möchten Sie Kopieren von `/framework/src/org/apache/cordova/CordovaActivity.java` , oder sonst auf eigene Faust zu realisieren. Das folgende Codefragment zeigt eine einfache Anwendung, die auf die Schnittstelle beruht. 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());
+            }
+        
+
+6.  Wenn die Anwendung die Kamera benutzen muss, implementieren Sie Folgendes:
+    
+        @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);
+            }
+        }
+        
+
+7.  Denken Sie daran, den Threadpool hinzufügen, sonst Plugins keine Threads für die Ausführung:
+    
+        @Override
+        public ExecutorService getThreadPool() {
+            return threadPool;
+        }
+        
+
+8.  Kopieren von HTML und JavaScript-Dateien der Anwendung für des Android-Projekts `/assets/www` Verzeichnis.
+
+9.  Kopie der `config.xml` -Datei `/framework/res/xml` in des Projekts `/res/xml` Verzeichnis.
+
+ [1]: http://cordova.apache.org
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/5ad93d20/www/docs/de/7.x/guide/platforms/blackberry/config.md
----------------------------------------------------------------------
diff --git a/www/docs/de/7.x/guide/platforms/blackberry/config.md b/www/docs/de/7.x/guide/platforms/blackberry/config.md
new file mode 100644
index 0000000..0518466
--- /dev/null
+++ b/www/docs/de/7.x/guide/platforms/blackberry/config.md
@@ -0,0 +1,28 @@
+---
+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.
+
+title: BlackBerry-Konfiguration
+---
+
+# BlackBerry-Konfiguration
+
+BlackBerry unterstützt die [W3C-Widget-Spezifikation][1] sowie die proprietären Erweiterungen, so RIM. Finden Sie die vollständigen [BlackBerry WebWorks Dokumentation bezüglich "config.xml"][2] für Details.
+
+ [1]: http://www.w3.org/TR/widgets/
+ [2]: https://developer.blackberry.com/html5/documentation/working_with_config_xml_file_1866970_11.html
\ No newline at end of file


---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@cordova.apache.org
For additional commands, e-mail: commits-help@cordova.apache.org


Mime
View raw message