From 4b1a9203c547c019fc5398082ae19a3f3d4c3efe Mon Sep 17 00:00:00 2001 From: Peter Bengtsson Date: Tue, 8 Dec 2020 14:41:15 -0500 Subject: initial commit --- .../mozilla/add-ons/add-on_guidelines/index.html | 124 ++ files/de/mozilla/add-ons/amo/index.html | 9 + files/de/mozilla/add-ons/amo/policy/index.html | 19 + .../add-ons/bootstrapped_extensions/index.html | 243 ++++ files/de/mozilla/add-ons/index.html | 198 +++ .../index.html | 156 +++ files/de/mozilla/add-ons/sdk/builder/index.html | 16 + .../add-ons/sdk/guides/content_scripts/index.html | 484 +++++++ files/de/mozilla/add-ons/sdk/guides/index.html | 154 +++ files/de/mozilla/add-ons/sdk/index.html | 83 ++ files/de/mozilla/add-ons/sdk/tools/index.html | 14 + files/de/mozilla/add-ons/sdk/tools/jpm/index.html | 497 +++++++ .../adding_a_button_to_the_toolbar/index.html | 100 ++ .../sdk/tutorials/getting_started/index.html | 214 +++ files/de/mozilla/add-ons/sdk/tutorials/index.html | 165 +++ .../add-ons/sdk/tutorials/installation/index.html | 134 ++ .../sdk/tutorials/mobile_development/index.html | 476 +++++++ .../index.html | 80 ++ .../de/mozilla/add-ons/themes/obsolete/index.html | 10 + .../anatomy_of_a_webextension/index.html | 133 ++ .../webextensions/api/browseraction/index.html | 135 ++ .../api/browseraction/setpopup/index.html | 136 ++ .../add-ons/webextensions/api/commands/index.html | 83 ++ .../add-ons/webextensions/api/downloads/index.html | 123 ++ .../mozilla/add-ons/webextensions/api/index.html | 51 + .../add-ons/webextensions/api/lesezeich/index.html | 121 ++ .../webextensions/arbeiten_mit_taps_api/index.html | 608 +++++++++ .../add-ons/webextensions/beispiele/index.html | 22 + .../browser_support_for_javascript_apis/index.html | 15 + .../deine_erste_weberweiterung/index.html | 155 +++ .../deine_zweite_erweiterung/index.html | 357 +++++ .../extending_the_developer_tools/index.html | 143 ++ files/de/mozilla/add-ons/webextensions/index.html | 86 ++ .../manifest.json/commands/index.html | 184 +++ .../manifest.json/devtools_page/index.html | 42 + .../add-ons/webextensions/manifest.json/index.html | 105 ++ .../webextensions/manifest.json/theme/index.html | 1361 ++++++++++++++++++++ .../webextensions/match_patterns/index.html | 430 +++++++ .../what_are_webextensions/index.html | 24 + .../\303\274berliegende_erweiterungen/index.html" | 54 + 40 files changed, 7544 insertions(+) create mode 100644 files/de/mozilla/add-ons/add-on_guidelines/index.html create mode 100644 files/de/mozilla/add-ons/amo/index.html create mode 100644 files/de/mozilla/add-ons/amo/policy/index.html create mode 100644 files/de/mozilla/add-ons/bootstrapped_extensions/index.html create mode 100644 files/de/mozilla/add-ons/index.html create mode 100644 files/de/mozilla/add-ons/performance_best_practices_in_extensions/index.html create mode 100644 files/de/mozilla/add-ons/sdk/builder/index.html create mode 100644 files/de/mozilla/add-ons/sdk/guides/content_scripts/index.html create mode 100644 files/de/mozilla/add-ons/sdk/guides/index.html create mode 100644 files/de/mozilla/add-ons/sdk/index.html create mode 100644 files/de/mozilla/add-ons/sdk/tools/index.html create mode 100644 files/de/mozilla/add-ons/sdk/tools/jpm/index.html create mode 100644 files/de/mozilla/add-ons/sdk/tutorials/adding_a_button_to_the_toolbar/index.html create mode 100644 files/de/mozilla/add-ons/sdk/tutorials/getting_started/index.html create mode 100644 files/de/mozilla/add-ons/sdk/tutorials/index.html create mode 100644 files/de/mozilla/add-ons/sdk/tutorials/installation/index.html create mode 100644 files/de/mozilla/add-ons/sdk/tutorials/mobile_development/index.html create mode 100644 files/de/mozilla/add-ons/security_best_practices_in_extensions/index.html create mode 100644 files/de/mozilla/add-ons/themes/obsolete/index.html create mode 100644 files/de/mozilla/add-ons/webextensions/anatomy_of_a_webextension/index.html create mode 100644 files/de/mozilla/add-ons/webextensions/api/browseraction/index.html create mode 100644 files/de/mozilla/add-ons/webextensions/api/browseraction/setpopup/index.html create mode 100644 files/de/mozilla/add-ons/webextensions/api/commands/index.html create mode 100644 files/de/mozilla/add-ons/webextensions/api/downloads/index.html create mode 100644 files/de/mozilla/add-ons/webextensions/api/index.html create mode 100644 files/de/mozilla/add-ons/webextensions/api/lesezeich/index.html create mode 100644 files/de/mozilla/add-ons/webextensions/arbeiten_mit_taps_api/index.html create mode 100644 files/de/mozilla/add-ons/webextensions/beispiele/index.html create mode 100644 files/de/mozilla/add-ons/webextensions/browser_support_for_javascript_apis/index.html create mode 100644 files/de/mozilla/add-ons/webextensions/deine_erste_weberweiterung/index.html create mode 100644 files/de/mozilla/add-ons/webextensions/deine_zweite_erweiterung/index.html create mode 100644 files/de/mozilla/add-ons/webextensions/extending_the_developer_tools/index.html create mode 100644 files/de/mozilla/add-ons/webextensions/index.html create mode 100644 files/de/mozilla/add-ons/webextensions/manifest.json/commands/index.html create mode 100644 files/de/mozilla/add-ons/webextensions/manifest.json/devtools_page/index.html create mode 100644 files/de/mozilla/add-ons/webextensions/manifest.json/index.html create mode 100644 files/de/mozilla/add-ons/webextensions/manifest.json/theme/index.html create mode 100644 files/de/mozilla/add-ons/webextensions/match_patterns/index.html create mode 100644 files/de/mozilla/add-ons/webextensions/what_are_webextensions/index.html create mode 100644 "files/de/mozilla/add-ons/\303\274berliegende_erweiterungen/index.html" (limited to 'files/de/mozilla/add-ons') diff --git a/files/de/mozilla/add-ons/add-on_guidelines/index.html b/files/de/mozilla/add-ons/add-on_guidelines/index.html new file mode 100644 index 0000000000..e781073547 --- /dev/null +++ b/files/de/mozilla/add-ons/add-on_guidelines/index.html @@ -0,0 +1,124 @@ +--- +title: Add-on guidelines +slug: Mozilla/Add-ons/Add-on_guidelines +tags: + - Zusatzgerä +translation_of: 'https://extensionworkshop.com/documentation/publish/add-on-policies/' +--- +

These add-on guidelines were created to foster an open and diverse add-on developer community while ensuring an excellent user experience. They apply to all add-ons and add-on updates regardless of where they are hosted, and also apply to customizations performed by installers that configure Firefox without using an add-on. Add-ons hosted on AMO are subject to additional policies.

+ +

Be Transparent

+ + + +

Be Respectful to Users

+ + + +

Be Safe

+ + + +

Be Stable

+ + + +

Exceptions

+ + + +

Other exceptions may apply.

+ +

Enforcement

+ +

Add-ons that do not follow these guidelines may qualify for blocklisting, depending on the extent of the violations. Guidelines qualified with the wordmust are especially important, and violations thereof will most likely result in a blocklisting nomination.

+ +

The Add-ons Team will do their best to contact the add-on's developers and provide a reasonable time frame for the problems to be corrected before a block is put in place. If an add-on is considered malicious or its developers have proven unreachable or unresponsive, or in case of repeat violations, blocklisting may be immediate.

+ +

Guideline violations should be reported via Bugzilla, under Tech Evangelism > Add-ons. Questions can be posted in the #addons IRC channel.

+ +

These guidelines may change in the future. All updates will be announced in the Add-ons Blog.

diff --git a/files/de/mozilla/add-ons/amo/index.html b/files/de/mozilla/add-ons/amo/index.html new file mode 100644 index 0000000000..5867afab50 --- /dev/null +++ b/files/de/mozilla/add-ons/amo/index.html @@ -0,0 +1,9 @@ +--- +title: AMO +slug: Mozilla/Add-ons/AMO +tags: + - NeedsTranslation + - TopicStub +translation_of: Mozilla/Add-ons/AMO +--- +

Seiten, die addons.mozilla.org dokumentieren:

diff --git a/files/de/mozilla/add-ons/amo/policy/index.html b/files/de/mozilla/add-ons/amo/policy/index.html new file mode 100644 index 0000000000..45bdc8ac09 --- /dev/null +++ b/files/de/mozilla/add-ons/amo/policy/index.html @@ -0,0 +1,19 @@ +--- +title: AMO Policies +slug: Mozilla/Add-ons/AMO/Policy +translation_of: Mozilla/Add-ons/AMO/Policy +--- +

{{AddonSidebar}}

+ +

Mozilla ist bestrebt, unseren Nutzern und Entwicklern eine großartige Add-On-Erfahrung zu bieten. Bitte lesen Sie die folgenden Richtlinien, bevor Sie Ihr Add-on abschicken.

+ + +
+
Developer Agreement
+
Effective January 5, 2016
Review Process
+
Add-ons extend the core capabilities of Firefox, allowing users to modify and personalize their Web experience. A healthy add-on ecosystem, built on trust, is vital for developers to be successful and users to feel safe making Firefox their own. For these reasons, Mozilla requires all add-ons to comply with the following set of policies on acceptable practices. The below is not intended to serve as legal advice, nor is it intended to serve as a comprehensive list of terms to include in your add-on’s privacy policy.
Featured Add-ons
+
How up-and-coming add-ons become featured and what's involved in the process.
Contacting us + +

Wie Sie uns bezüglich dieser Richtlinien oder Ihres Add-ons kontaktieren können.

+ +
diff --git a/files/de/mozilla/add-ons/bootstrapped_extensions/index.html b/files/de/mozilla/add-ons/bootstrapped_extensions/index.html new file mode 100644 index 0000000000..582b48c775 --- /dev/null +++ b/files/de/mozilla/add-ons/bootstrapped_extensions/index.html @@ -0,0 +1,243 @@ +--- +title: Bootstrapped extensions +slug: Mozilla/Add-ons/Bootstrapped_extensions +translation_of: Archive/Add-ons/Bootstrapped_extensions +--- +

{{ gecko_minversion_header("2.0") }}

+
+

Note: All extensions created using the Add-on SDK are bootstrapped! All the bootstrapping code is generated for you, so you don't really need to think about it. Not using the Add-on SDK? Read on...

+
+

Traditional extensions include overlays, wherein the application can load up XUL from the extension's package and automatically apply it atop its own UI. While this makes creating extensions that add to the application's user interface relatively easy, it means that updating, installing, or disabling an extension requires an application restart.

+

Gecko 2.0 {{ geckoRelease("2.0") }} introduces bootstrapped extensions. These are special extensions that, instead of using overlays to apply their user interface to the application, programmatically insert themselves into the application. This is done using a special script file that's included in the extension that contains functions the browser calls to command the extension to install, uninstall, start up, and shut down.

+

All the application does is call into this script file; the extension is responsible for adding and removing its user interface and handling any other setup and shutdown tasks it requires.

+

This article discusses how bootstrapped extensions work. See this tutorial on converting from an overlay extension to restartless for a practical step by step guide to migrating.

+

The startup and shutdown process

+

A key feature of bootstrapped extensions is that they must be able to be started up and shut down on demand by the application. When the extension's startup() function is called, it must manually inject its user interface and other behavior into the application. Similarly, when its shutdown() function is called, it must remove anything it's added to the application, as well as all references to any of its objects.

+

There are several scenarios in which the startup() function may be called; for example:

+ +

Some examples of when the shutdown() function may be called:

+ +

Notes on modifying the application user interface

+

chrome.manifest in bootstrapped add-ons

+

You can use a chrome.manifest file in bootstrapped add-ons to:

+
    +
  1. make your add-on's content available via a chrome:// URL (using the content, locale, and skin instructions in the manifest);
  2. +
  3. replace existing chrome:// URIs with your content (using the override instruction).
  4. +
+

Not all chrome.manifest instructions are supported in bootstrapped add-ons, for example you still cannot register XUL Overlays from a bootstrapped add-on. See the chrome.manifest documentation for details.

+

In Firefox 10 and later the chrome.manifest file located in the root of the add-on's XPI (i.e. a sibling of the install.rdf) is loaded automatically. In Firefox 8 and 9 you had to load/unload the manifest manually using {{ ifmethod("nsIComponentManager", "addBootstrappedManifestLocation") }} and {{ ifmethod("nsIComponentManager", "removeBootstrappedManifestLocation") }}. This feature was unavailable in Firefox versions before 8.

+

Adding user interface manually

+

If you decide to go ahead and try to develop a bootstrapped extension that modifies the application's user interface, here are a few suggestions to get you started.

+

You need to look up the relevant application UI elements by their ID by calling {{ domxref("document.getElementById()") }}, then manipulate them to inject your UI. For example, you can get access to the menu bar in Firefox with document.getElementById("main-menubar").

+

Be sure that at shutdown time, you remove any user interface you've added.

+

Creating a bootstrapped extension

+

To mark an extension as bootstrappable, you need to add the following element to its install manifest:

+
<em:bootstrap>true</em:bootstrap>
+

Then you need to add a bootstrap.js file that contains the required functions; this should be alongside the install.rdf file in the extension's package.

+

Backward compatibility

+

Because older versions of Firefox don't know about the bootstrap property or bootstrap.js file, it's not overly difficult to create an XPI that will work on both as a bootstrappable extension and as a traditional extension. Create your extension as a bootstrappable extension, then add the traditional overlays as well. Newer versions of Firefox will use the bootstrap.js script, ignoring the components and overlays, while older versions will use the overlays.

+

Bootstrap entry points

+

The bootstrap.js script should contain several specific functions, which are called by the browser to manage the extension. The script gets executed in a privileged sandbox, which is cached until the extension is shut down.

+

startup

+

Called when the extension needs to start itself up. This happens at application launch time or when the extension is enabled after being disabled (or after it has been shut down in order to install an update. As such, this can be called many times during the lifetime of the application.

+

This is when your add-on should inject its UI, start up any tasks it may need running, and so forth.

+
void startup(
+  data,
+  reason
+);
+
+
Parameters
+
+
+ data
+
+ A bootstrap data structure.
+
+ reason
+
+ One of the reason constants, indicating why the extension is being started up. This will be one of APP_STARTUP, ADDON_ENABLE, ADDON_INSTALL, ADDON_UPGRADE, or ADDON_DOWNGRADE.
+
+

shutdown

+

Called when the extension needs to shut itself down, such as when the application is quitting or when the extension is about to be upgraded or disabled. Any user interface that has been injected must be removed, tasks shut down, and objects disposed of.

+
void shutdown(
+  data,
+  reason
+);
+
+
Parameters
+
+
+ data
+
+ A bootstrap data structure.
+
+ reason
+
+ One of the reason constants, indicating why the extension is being shut down. This will be one of APP_SHUTDOWN, ADDON_DISABLE, ADDON_UNINSTALL, ADDON_UPGRADE, or ADDON_DOWNGRADE.
+
+

install

+

Your bootstrap script must include an install() function, which the application calls before the first call to startup() after the extension is installed, upgraded, or downgraded.

+
+ Note: This method is never called if the extension has never been started; for example, if an extension is installed but isn't compatible with the current version of the application, install() never gets called if it is uninstalled before becoming compatible. However, if the extension gets upgraded to a version that's compatible with the application, its install() function will be called at that time, before the first startup() call.
+
void install(
+  data,
+  reason
+);
+
+
Parameters
+
+
+ data
+
+ A bootstrap data structure.
+
+ reason
+
+ One of the reason constants, indicating why the extension is being installed. This will be one of ADDON_INSTALL, ADDON_UPGRADE, or ADDON_DOWNGRADE.
+
+

uninstall

+

This function is called after the last call to shutdown() before a particular version of an extension is uninstalled. This will not be called if install() was never called.

+
+ Note: It's important to keep in mind that uninstall() can be called even on extensions that are currently disabled, or are not compatible with the current application. Because of this, it's crucial that the function be implemented to gracefully handle APIs that may not be present in the application. This function will also not be called if a third-party application removes the extension while Firefox isn't running. Simply having code function install() {} IS NOT ENOUGH, if you have code in uninstall it will not run, you MUST run some code in the install function, at the least you must set arguments on the install function so like: function install(aData, aReason) {} then uninstall WILL WORK.
+
+ Note: If you open addon manager and then click "Remove" on addon, it will not call uninstall function right away. Because it was soft uninstalled, as the "Undo" button is there. If you close addon manager or something to make that "Undo" button to go away then the hard uninstall takes place.
+
+ Note: The uninstall function fires on downgrade and upgrade as well so you should make sure it is an uninstall by doing this:
+ function uninstall(aData, aReason) {
+      if (aReason == ADDON_UNINSTALL) {
+           console.log('really uninstalling');
+      } else {
+           console.log('not a permanent uninstall, likely an upgrade or downgrade');
+      }
+ }
+
void uninstall(
+  data,
+  reason
+);
+
+
Parameters
+
+
+ data
+
+ A bootstrap data structure.
+
+ reason
+
+ One of the reason constants, indicating why the extension is being uninstalled. This will be one of ADDON_UNINSTALL, ADDON_UPGRADE, or ADDON_DOWNGRADE.
+
+

Reason constants

+

The bootstrap functions accept a reason parameter, which explains to the extension why it's being called. The reason constants are:

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
ConstantValueDescription
APP_STARTUP1The application is starting up.
APP_SHUTDOWN2The application is shutting down.
ADDON_ENABLE3The add-on is being enabled.
ADDON_DISABLE4The add-on is being disabled. (Also sent during uninstallation)
ADDON_INSTALL5The add-on is being installed.
ADDON_UNINSTALL6The add-on is being uninstalled.
ADDON_UPGRADE7The add-on is being upgraded.
ADDON_DOWNGRADE8The add-on is being downgraded.
+

Bootstrap data

+

Each of the entry points is passed a simple data structure containing some useful information about the add-on being bootstrapped. More information about the add-on can be obtained by calling AddonManager.getAddonByID(). The data is a simple JavaScript object with the following properties:

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
PropertyTypeDescription
idstringThe ID of the add-on being bootstrapped.
versionstringThe version of the add-on being bootstrapped.
installPathnsIFileThe installation location of the add-on being bootstrapped. This may be a directory or an XPI file depending on whether the add-on is installed unpacked or not.
resourceURInsIURIA URI pointing at the root of the add-ons files, this may be a jar: or file: URI depending on whether the add-on is installed unpacked or not. {{ gecko_minversion_inline("7.0") }}
oldVersionstringThe previously installed version, if the reason is ADDON_UPGRADE or ADDON_DOWNGRADE, and the method is install or startup. {{ gecko_minversion_inline("22.0") }}
newVersionstringThe version to be installed, if the reason is ADDON_UPGRADE or ADDON_DOWNGRADE, and the method is shutdown or uninstall. {{ gecko_minversion_inline("22.0") }}
+
+

Note: An add-on may be upgraded/downgraded at application startup, in this case the startup method reason is APP_STARTUP, and the oldVersion property is not set. Also be aware that in some circumstances an add-on upgrade/downgrade may occur without the uninstall method being called.

+
+

Add-on debugger

+

From Firefox 31 onwards, you can use the Add-on Debugger to debug bootstrapped add-ons.

+

Further reading

+ diff --git a/files/de/mozilla/add-ons/index.html b/files/de/mozilla/add-ons/index.html new file mode 100644 index 0000000000..298aba8754 --- /dev/null +++ b/files/de/mozilla/add-ons/index.html @@ -0,0 +1,198 @@ +--- +title: Add-ons +slug: Mozilla/Add-ons +tags: + - Add-ons + - Erweiterungen + - Mozilla +translation_of: Mozilla/Add-ons +--- +
{{AddonSidebar}}
+ +
Ändern und Erweitern von Mozilla-Anwendungen
+ +

Add-ons fügen neue Funktionalitäten zu Gecko-basierten Anwendungen wie zum Beispiel Firefox, SeaMonkey und Thunderbird hinzu. Es gibt zwei Arten von Add-ons: Erweiterungen fügen neue Funktionen zur Anwendung hinzu, während Themes nur die Oberfläche verändern.

+ +

Für Erweiterungen und Themes betreibt Mozilla ein Repository auf addons.mozilla.org, auch bekannt als AMO. Wenn Sie Add-ons bei AMO einreichen werden diese überprüft und erst nach bestandener Prüfung veröffentlicht. Allerdings ist es nicht zwingend erforderlich, dass Add-ons nur über AMO veröffentlicht werden, aber durch die Überprüfung gewinnen Anwender an Vertrauen und im Gegenzug können Sie von AMO als einer zentralen Plattform, auf der viele hilfreiche Add-ons zu finden sind, nur profitieren.

+ +
+
Add-ons können großen Einfluss auf das Verhalten der Anwendung haben, die sie hosten. Wir haben eine Reihe von Richtlinien entwickelt, um sicherzustellen, dass Sie eine gute Erfahrung für Benutzer bereitstellen. Diese Richtlinien gelten für alle Arten von Add-ons, ob sie auf addons.mozilla.org oder nicht gehostet werden.
+
+ +
+

Erweiterungen

+ +

Erweiterungen fügen neue Funktionalität bei Mozilla-Anwendungen wie Firefox und Thunderbird hinzu. Sie können dem Browser neue Funktionen hinzufügen, z. B. eine andere Möglichkeit zum Verwalten von Registerkarten, neue Funktionen hinzufügen und sie können Web-Inhalte zur Verbesserung der Benutzerfreundlichkeit oder die Sicherheit von bestimmten Webseiten ändern.

+ +
+
Es gibt drei verschiedene Ansätze Erweiterungen zu erstellen können: Add-on SDK-basierte Erweiterungen, manuell bootstrapped restartless Erweiterungen und Overlay-Erweiterungen.
+ +
+
+ + + +
+
Wenn Sie können, ist es ratsam, das Add-on-SDK  zu verwenden, die Add-on-SDK verwendet die restartless Erweiterungsmechanismus die aber bestimmte Aufgaben vereinfacht und sich selbst bereinigt. Wenn das Add-on SDK nicht ausreichend für Ihre Bedürfnisse ist, implementieren Sie stattdessen eine manuelle restartless-Erweiterung.
+ +
+
+ +
+
Lesen Sie für weitere Informationen zur Auswahl "welche Technik verwenden" diesen Vergleich.
+ +
+
+ +

Debugging

+ +

Die Entwicklung von Erweiterung wird erschwert, wenn man für den Debug über keine Möglichkeit verfügt zu sehen, in welcher Zeile der Fehler aufgetreten ist. Sie müssen die Entwickler Präferenzen aktivieren, damit die logs in der Browser Konsole gezeigt werden. Für Dektopnutzer: Einrichten einer Entwicklungsumgebung für Erweiterungen.

+ +

Für eine Desktop-Umgebung nutzen Sie: Eine Entwicklungsumgebung einrichten, für Mobile Geräte (Android/iOS) nutzen Sie: Debugging Firefox for Android with WebIDE. Letztere verwendet die "Browser Toolbox" innerhalb der Dektop WebIDE, um auf dem Mobilgerät auftretende Fehler zu erkennen, nutzen Sie für Firefox OS auch die WebIDE.

+ +
+
+

Empfohlene Vorgehensweisen

+ +
+
Egal, wie Sie eine Erweiterung entwickeln. Gibt es einige Richtlinien, denen Sie folgen können, um sicherzustellen, dass Ihre Erweiterung einem Benutzer eine möglichst gute Nutzererfahrung bietet.
+ +
+
+ +
+
Leistung
+
+
+
Die Erweiterung ist schnell, reaktionsfähig und Speicher-effizient.
+
+
+
Sicherheit
+
+
+
Die Erweiterung setzt den Nutzer keinen schädlichen Websites aus.
+
+
+
Etikette
+
+
+

Die Erweiterung arbeitet problemlos mit anderen Erweiterungen.

+
+
+
+
+ +
+

Anwendungsspezifische

+ +
+
Der Großteil der Dokumentation geht davon aus, dass Sie für Firefox Desktop entwickeln. Wenn Sie für einige andere Gecko-basierte Anwendung entwickeln, gibt es große Unterschiede, über die Sie Bescheid wissen müssen.
+ +
+
+ +
+
Thunderbird
+
+
+
Entwicklung von Erweiterungen für den Thunderbird-Mail-Client.
+
+
+
Firefox for Android
+
+
+
Entwicklung von Erweiterungen für Firefox für Android.
+
+
+
SeaMonkey
+
+
+
Entwicklung von Erweiterungen für SeaMonkey Software-Suite.
+
+
+
+
+
+ +
+

Themes

+ +
+
Themen sind Add-ons, die Benutzeroberfläche der Anwendung anpassen. Es gibt zwei Arten von Themen: leichte Themen und komplette Themen.
+ +
+
+ +
+
+

Leichte Themen sind viel einfacher zu implementieren als komplette Themen, aber sie bieten sehr begrenzte Anpassungs möglichkeiten .

+
+ +
+
+
Mit kompletten Themes machen Sie viel tieferen Änderungen an der Benutzeroberfläche der Anwendung. Die Dokumentation für komplette Themes ist veraltet, aber ist hier als eine mögliche Grundlage für aktualisierte Dokumentation verbunden.
+
+
+
+ +

Andere Arten von Add-ons

+ +
+
Search engine plugins sind eine einfache und sehr spezifische Art von Add-on: sie fügen neue Suchmaschinen zu den Browser-Suchleiste hinzu.
+ +
+
+ +
+
Plugins helfen den Anwendung den Inhalt zu verstehen, die nicht nativ unterstützt werden. Wir sind dabei ablehnend Plugins zu Supporten, da sie eine Geschichte der Stabilität, Leistung und Sicherheitsprobleme verursacht haben.
+
+ +

Inhalt

+ +
    +
  1. Overlay Erweiterung
  2. +
  3. Restartless Erweiterung
  4. +
  5. Add-on SDK
  6. +
  7. Erweiterung  Bewährte +
      +
    1. Leistung
    2. +
    3. Sicherheit
    4. +
    5. Etikette
    6. +
    +
  8. +
  9. Themes +
      +
    1. Leichte Themes
    2. +
    3. Komplete Themes
    4. +
    +
  10. +
  11. Veröffentlichung Add-ons +
      +
    1. addons.mozilla.org
    2. +
    3. Add-on Richtlinien
    4. +
    +
  12. +
diff --git a/files/de/mozilla/add-ons/performance_best_practices_in_extensions/index.html b/files/de/mozilla/add-ons/performance_best_practices_in_extensions/index.html new file mode 100644 index 0000000000..5a1c7e8052 --- /dev/null +++ b/files/de/mozilla/add-ons/performance_best_practices_in_extensions/index.html @@ -0,0 +1,156 @@ +--- +title: Best Practice für Performance in Erweiterungen +slug: Mozilla/Add-ons/Performance_best_practices_in_extensions +tags: + - Add-ons + - Best Practice + - Erweiterungen + - Leitfaden + - Performanz +translation_of: Archive/Add-ons/Performance_best_practices_in_extensions +--- +

Einer der größten Vorteile von Firefox ist seine Erweiterbarkeit. Erweiterungen können beinahe jede beliebige Funktion erfüllen. Doch dieses Konzept hat einen Nachteil: Eine schlecht geschriebene Erweiterung kann sich stark negativ auf das Nutzungserlebnis auswirken, und auch zu allgemeinen Leistungseinbußen in Firefox führen. Der folgende Artikel soll eine Reihe von Vorschlägen liefern, um die Leistung und Geschwindigkeit Deiner Erweiterung zu erhöhen, und dadurch auch von Firefox selbst.

+ +

Die Startup Leistung Verbessern

+ +

Erweiterungen werden immer dann geladen und gestartet, wenn eine neues Browser Fenster geöffnet wird. Im Umkehrschluss bedeutet das aber, dass Deine Erweiterung einen direkten Einfluss darauf hat, wie lange ein Benutzer beim Laden einer neuen Seite warten muss. Es gibt mehrere Möglichkeiten, die Startzeit Deiner Erweiterung zu optimieren und somit die Verzögerung für den Endbenutzer zu minimieren.

+ +

Lade nur, was nötig ist

+ +

Lade keine Ressourcen beim Startup, die nicht direkt benötigt werden. Das sind Daten, die erst nach einer Benutzerinteraktion, etwa ein Klick auf einen Button, benötigt werden, oder Daten die nur bei bestimmten Einstellungen zum Tragen kommen. Auch wenn Deine Erweiterung Features anbietet, die nur funktionieren wenn der Benutzer sich in ein Service eingeloggt hat, lade die Ressourcen für diese Features erst beim tatsächlichen Login.

+ +

Nutze JavaScript Code Module

+ +

Du kannst Teile deiner Erweiterung in JavaScript code modules kapseln. Diese Module können zur Laufzeit bei Bedarf geladen werden und reduzieren somit den Ladeaufwand zum Programmstart.

+ +

Die JavaScript Code Module bieten hier einen Vorteil gegenüber XPCOM Modulen, die immer zu Beginn geladen werden.

+ +

Natürlich hängt es von der Komplexität der Erweiterung ab, ob eine Modularisierung des Codes sinnvoll ist.

+ +

Verschiebe alles, was verschoben werden kann

+ +

Die meisten Erweiterungen fangen das load event eines Fensters ab, um ihren Startup Code auszuführen. Hier sollte so wenig wie möglich getan werden. Das Browser Fenster wird so lange blockiert, bis der load Handler deiner Erweiterung abgeschlossen ist. Das bedeutet, je länger die Erweiterung dafür braucht, desto langsamer wirkt Firefox für den Benutzer.

+ +

Jede Operation, die nicht sofort ausgeführt werden muss, kann mittels einem {{ interface("nsITimer") }} oder mit der {{ domxref("window.setTimeout()") }} Funktion für einen späteren Zeitpunkt geplant werden. Sogar kurze Verzögerungen in diesem Programmbereich können eine große Auswirkung auf die Ladegeschwindigkeit haben.

+ +

General Performance Tips

+ +

Vermeide Speicherlecks

+ +

Speicherlecks können die Leistung deiner Erweiterung stark reduzieren, weil sie dafür sorgen, dass der Garbage Collector und der Cycle Collector mehr Arbeit haben.

+ +

Sogenannte Zombiebereiche sind eine Form von Speicherlecks, die Du selbst sehr einfach entdecken und verhindern kannst. Lies dazu den Artikel zu Zombie compartments, speziell die Sektion Proactive checking of add-ons.

+ +

Im Artikel Common causes of memory leaks in extensions werden weitere Möglichkeiten, wie Du Zombiebereiche und andere Formen von Speicherlecks verhindern kannst, besprochen.

+ +

Neben der direkten Suche nach den oben genannten Lecks solltest Du auch allgemein ein Auge auf die Speichernutzung deines Addons haben und regelmäßig unter about:memory überprüfen. Als Beispiel sei bug 719601 genannt, bei dem ein "System Principal" JavaScript Bereich auf mehrere 100 MB an Speicher anwuchs, was sehr viel größer ist als im Regelfall.

+ +

Nutze JavaScript Module

+ +

JavaScript Module verhalten sich wie jeder andere JavaScript Code, mit dem feinen Unterschied, dass sie als Singletons agieren und daher von Firefox in den Cache abgelegt werden können. Dadurch können sie beim nächsten Start sehr viel effizienter geladen werden. Wann immer deine Erweiterung JavaScript Code von einem {{ HTMLElement("script") }} Element lädt, solltest du überlegen, stattdessen ein JavaScript Modul zu nutzen. Weitere Information über JavaScript Module und ihre Verwendung werden im Artikel Using JavaScript Code Modules besprochen.

+ +

Vermeide Langsamen CSS Code

+ + + +

Vermeide DOM Mutation Event Listeners

+ +

Durch das Hinzufügen eines DOM Mutation Listeners in einem Dokument werden die meisten DOM Mutation Optimierungen deaktiviert und die Performanz von weiteren Änderungen der DOM-Struktur des Dokuments wird stark herabgesetzt. Des weiteren kann dieser Effekt durch das Deaktivieren eines Mutation Listeners nicht wieder rückgängig gemacht werden. Die folgenden Events sollten daher strikt vermieden werden: DOMAttrModified, DOMAttributeNameChanged, DOMCharacterDataModified, DOMElementNameChanged, DOMNodeInserted, DOMNodeInsertedIntoDocument, DOMNodeRemoved, DOMNodeRemovedFromDocument, DOMSubtreeModified

+ +

Weitere Information zu diesen veralteten Events findest Du im Artikel Mutation events. Stattdessen sollten Mutation Observers benutzt werden.

+ +

Benutze Lazy Load für Services

+ +

Das JavaScript Modul XPCOMUtils bietet zwei Möglichkeiten für Lazy Loading:

+ + + +

Seit Firefox 4.0 werden viele übliche Services bereits in Services.jsm gecached.

+ +

Reduziere File I/O

+ +

TODO: Hier fehlen Beispiele, wie etwa Links zu Code, Bugs, oder Docs.

+ + + +

Benutze die Richtige Kompressionsstufe für JAR und XPI Dateien

+ +

Daten von komprimierten Archiven zu lesen ist zeitaufwändig. Je stärker ein Archiv komprimiert ist, desto mehr Aufwand muss auch für das Lesen der darin befindlichen Daten erbracht werden. Daher sollten alle JAR Dateien in deiner Erweiterung mit Kompressionslevel 0 (keine Kompression) gepackt werden. Es mag kontraproduktiv klingen, aber dadurch wird zwar die Dateigröße der JAR Datei erhöht, die Größe der XPI Datei aber reduziert, weil dadurch die Möglichkeit gegeben ist, dass beim Komprimiered der XPI Datei Kompressionen der einzelnen im JAR enthaltenen Dateien stattfinden können. (Das kann als eine Art progressive Kompression bezeichnet werden).

+ +

Wenn deine Erweiterung nicht explizit em:unpack verwendet, wird das XPI file ab Firefox 4 nicht entpackt, sondern direkt genutzt. Aus diesem Grund ist eine niedrige Kompressionsstufe zu bevorzugen, wobei wir zu Kompressionslevel 1 raten. Selbst im Vergleich mit maximaler Kompression wird dadurch die Größe des Downloads nur geringfügig angehoben.

+ +

Benutze asynchrone I/O

+ +

Diese Regel kann nicht oft genug wiederholt werden: Benutze niemals synchrone I/O in einem GUI Thread.

+ + + +

Unnötige Verwendung von onreadystatechange in XHR

+ +

Für die meisten Anwendungsfälle sind addEventListener(load/error) und/oder xhr.onload/.onerror völlig ausreichend und bieten den Vorteil, dass sie nur einmal aufgerufen werden, im Gegensatz zu onreadystatechange. In vielen Fällen wird onreadystatechange aus Kompatibilitätsgründen verwendet, wenn XHR in einer Webseite verwendet wird. Das ist oft auchreichend, um Ressourcen zu laden oder Fehler zu behandeln. Allerdings werden load/error Event Listener viel seltener aufgerufen als onreadystatechange, genauer gesagt nur einmal, und es ist nicht notwendig jedes mal den readyState  zu überprüfen oder herauszufinden, ob es sich um ein error Event handelt. onreadystatechange sollte nur benutzt werden, wenn es notwendig ist, eine Antwort noch während ihrem Einlangen zu behandeln.

+ +

Entferne Event Listeners

+ +

Entferne Event Listener, wenn sie nicht mehr benötigt werden. Es ist viel effizienter, Event Listener zu entfernen, als sie etwa durch Flags zu deaktivieren; denn bei zweiterem Ansatz muss bei jedem auftretenden Event die Flag abgefragt werden. Konstrukte wie function onMouseOver(evt) { if (is_active) { /* doSomeThing */ } } sollten also vermieden werden. Auch "Einmal-Events" sollten danach wieder deaktiviert werden:

+ +
 function init() {
+   var largeArray;
+   addEventListener('load', function onLoad() {
+        removeEventListener('load', onLoad, true);
+        largeArray.forEach();
+ }, true);
+
+ +

Andernfalls kann es vorkommen, dass Closure Objekte des Listeners weiter referenziert werden (in obigem Beispiel die Variable largeArray). Der Listener wird dadurch weit über seine nötige Lebensdauer im Speicher gehalten.

+ +

Befülle Menüs nach Bedarf

+ +

Befülle Kontextmenüs (page, tabs, tools) nur nach Bedarf und reduziere Berechnungen auf ein Minimum, um die Reaktionsgeschwindigkeit der UI zu erhalten. Es ist nicht notwendig, bei jeder Änderung das gesamte Menü neu zu befüllen. Diese Aufgabe kann warten, bis der Benutzer das Menü tatsächlich verwenden will. Füge einen Listener für das "popupshowing" Event hinzu und erstelle/befülle das Kontextmenü dort.

+ +

Vermeide Maus-Bewegungs-Events

+ +

Vermeide die Verwendung von Mausbewegungsevents (enter, over, exit) oder minimiere zumindest die Berechnungen, die beim Auslösen eines solchen Events durchgeführt werden auf ein Minimum. Solche Events, besonders das mouseover Event, treten überlichweise sehr häufig auf. Es wird geraten, im Eventhandler nur neue Information zu speichern und die Berechnung erst dann auszuführen, wenn der Benutzer sie benötigt (zum Beispiel bei einem popupshowing Event). Vergiss auch nicht darauf, nicht mehr benötigte Event Listener auszuschalten (siehe oben).

+ +

Vermeide Polling

+ +

Benutze die {{ interface("nsIObserverService") }} Funktion stattdessen. Jede Erweiterung darf via {{ interface("nsIObserverService") }} eigene Benachrichtigungen versenden, aber die wenigsten benutzen diese Funktionalität. Auch viele andere Services bieten Funktionalität zur Beobachtung, etwa nslPrefBranch2.

+ +

aPNG/aGIF sind oft nicht zu Empfehlen

+ +

Animationen benötigen viel Ladezeit, weil eine große Anzahl an Bildern dekodiert werden muss (die Frames der Animation). Animierte Bilder werden häufig aus dem Cache entfernt, was dazu führt, dass sie immer wieder neu geladen werden müssen. Besonders anfällig dafür ist {{ interface("nsITree") }} / {{ XULElem("tree") }}, das unter manchen Umständen gar kein Caching betreibt.

+ +

base64/md5/sha1 Implementierungen

+ +

Verwende keine eigenen base64/md5/sha1 Implementierungen. Die eingebauten Funktionen für base64 atob/btoa sind völlig ausreichend und können in overlay Scripts sowie in JavaScript Modulen verwendet werden. Hashes können mit {{ interface("nsICryptoHash") }}, berechnet werden, das entweder einen String oder {{ interface("nsIInputStream") }} akzeptiert.

+ +

Image sprites

+ +

Mehrere Bilder können in ein Sprite kombiniert werden. Siehe {{ cssxref("-moz-image-region") }}. Die meisten XUL Widgets, die zum Anzeigen von Bildern verwendet werden können (inklusive {{ XULElem("button") }} und {{ XULElem("toolbarbutton") }}) erlauben auch die Verwendung von {{ cssxref("list-style-image") }}. Vermeide die Benutzung der imagesrc/src Attribute für die einbettung von Bildern.

+ +

Verwende Chrome Workers

+ +

Für lange andauernde Berechnungen oder Datenverarbeitung kann {{ domxref("ChromeWorker") }} verwendet werden.

+ + + + diff --git a/files/de/mozilla/add-ons/sdk/builder/index.html b/files/de/mozilla/add-ons/sdk/builder/index.html new file mode 100644 index 0000000000..d243acec45 --- /dev/null +++ b/files/de/mozilla/add-ons/sdk/builder/index.html @@ -0,0 +1,16 @@ +--- +title: Builder +slug: Mozilla/Add-ons/SDK/Builder +tags: + - builder +translation_of: Archive/Add-ons/Add-on_SDK/Builder +--- +

Der Add-on Builder war ein web-basiertes Entwicklungssystem welches Entwicklern erlaubt hat, mit den SDK APIs Addons zu erstellen ohne das cfx Kommando-Zeilen-Tool verwenden zu müssen. Es wurde am 1. April 2014 eingestellt und jetzt leitet es auf die builder.addons.mozilla.org-Seite weiter.
+
+ Falls sie bisher das SDK nur über den Builder verwendet haben, wissen sie bereits das meiste, das sie benötigen um direkt mit dem SDK arbeiten zu können. Die high-level und low-level APIs, die für Builder Addons verwendet wurden sind jeweils die gleichen. Mit folgenden Schritten können sie zum SDK wechseln:

+ + diff --git a/files/de/mozilla/add-ons/sdk/guides/content_scripts/index.html b/files/de/mozilla/add-ons/sdk/guides/content_scripts/index.html new file mode 100644 index 0000000000..a94176f2cb --- /dev/null +++ b/files/de/mozilla/add-ons/sdk/guides/content_scripts/index.html @@ -0,0 +1,484 @@ +--- +title: Content Scripts +slug: Mozilla/Add-ons/SDK/Guides/Content_Scripts +translation_of: Archive/Add-ons/Add-on_SDK/Guides/Content_Scripts +--- +
+

Viele Add-ons müssen den Inhalt von Webseiten modifizieren oder auf diesen zugreifen können. Der Grundcode des Add-on  bekommt aber keinen direkten Zugriff auf Webinhalte. Stattdessen müssen SDK Add-ons den Code,  der Zugriff auf Webinhalte erhält in seperate Skripte auslagern, die sogenannten "Content Scripts". Diese Seite beschreibt wie man Content Scripts entwickelt und diese implementiert.

+ +

Content Scripts sind einer der verwirrenderen Aspekte beim Arbeiten mit der SDK, aber Sie werden mit Sicherheit mit ihnen arbeiten müssen. Es gibt fünf grundlegende Prinzipien:

+ + + +

Dieses komplette Add-on zeigt alle diese Prinzipien. Die "main.js" hängt ein Content Skript an den aktuellen Tab, mittels den tabs Modules, an. In diesem Fall wird der Content Skript in Form eines Strings übergeben. Das Content Skript ersetzt einfach nur den Inhalt der Seite:

+ +
// main.js
+var tabs = require("sdk/tabs");
+var contentScriptString = 'document.body.innerHTML = "<h1>Diese Seite wurde aufgegessen</h1>";'
+
+tabs.activeTab.attach({
+  contentScript: contentScriptString
+});
+ +

Die folgenden high-level SDK Module können Content Skripts benutzen, um Webseiten zu bearbeiten:

+ + + +

Zusätzlich sind manche SDK Benutzeroberflächen Komponenten - Panel, Sidebar, frames - darauf ausgelegt HTML zu benutzen und haben deshalb seperate Skripte um mit ihrem Inhalt zu interagieren. In vielen Punkten sind diese Skripte wie Content Skripte, aber dies ist nicht Teil dieses Artikels. Um mehr über die Interaktion des Inhalts eines Benutzeroberflächenmoduls zu erfahren, schauen Sie sich die modulspezifischen Dokumentationen: panel, sidebar, frame an.

+ +

Fast alle diese Beispiele, die in dieser Anleitung präsentiert werden, sind als komplette, aber minimalistische, Add-ons in der addon-sdk-content-scripts repository auf Github vorhanden.

+ +

Content Skripts laden

+ +
+

Sie können ein einzelnes Skript laden, indem Sie einen String an die contentScript oder die contentScriptFile Option übergeben. Die contentScript Option behandelt den übergebenen String wie ein eigenes Skript:

+ +
// main.js
+
+var pageMod = require("sdk/page-mod");
+var contentScriptValue = 'document.body.innerHTML = ' +
+                         ' "<h1>Page matches ruleset</h1>";';
+
+pageMod.PageMod({
+  include: "*.mozilla.org",
+  contentScript: contentScriptValue
+});
+ +

Die contentScriptFile Option behandelt den String wie eine resource:// URL, die auf ein Skript zeigt, dass in ihrem Add-on Verzeichnis "data" gespeichert ist. jpm erstellt standardmäßig keinen "data" Ordner, also muss dieser erst erstellt werden, wenn Sie ihre Content Scripts verwenden wollen.

+ +

Das Add-on liefert eine URL, die auf die Datei "content-script.js" zeigt, welche im data Unterordner des Add-on Stammverzeichnisses enthalten ist:

+ +
// main.js
+
+var data = require("sdk/self").data;
+var pageMod = require("sdk/page-mod");
+
+pageMod.PageMod({
+  include: "*.mozilla.org",
+  contentScriptFile: data.url("content-script.js")
+});
+ +
// content-script.js
+
+document.body.innerHTML = "<h1>Seite erfüllt die Regeln.</h1>";
+ +
+

Ab Firefox 34 , kann "./content-script.js" als Alias für self.data.url("content-script.js") verwendet werden. Die main.js kann also auch folgendermaßen geschrieben werden:

+ +
var pageMod = require("sdk/page-mod");
+
+pageMod.PageMod({
+  include: "*.mozilla.org",
+  contentScriptFile: "./content-script.js"
+});
+
+
+ +
+

Wenn ihr Content Skript nicht sehr simpel ist oder aus einem statischen String besteht, sollten Sie contentScript:  nicht benutzen. Wenn Sie es doch tun, könnten Sie Probleme haben Ihr Add.on auf AMO verifiziert zu bekommmen.

+ +

Stattdessen sollten Sie ihr Skript in einer seperaten Datei schreiben und mit contentScriptFile laden. Das macht ihren Code übersichtlicher und er ist einfacher zu Warten, sichern und debuggen.

+
+ +

Sie können auch mehrere Skripte in contentScript oder contentScriptFile laden, indem Sie ein Array von Strings übergeben:

+ +
// main.js
+
+var tabs = require("sdk/tabs");
+
+tabs.on('ready', function(tab) {
+  tab.attach({
+      contentScript: ['document.body.style.border = "5px solid red";', 'window.alert("hi");']
+  });
+});
+
+ +
// main.js
+
+var data = require("sdk/self").data;
+var pageMod = require("sdk/page-mod");
+
+pageMod.PageMod({
+  include: "*.mozilla.org",
+  contentScriptFile: [data.url("jquery.min.js"), data.url("my-content-script.js")]
+});
+ +

Wenn Sie das tuen, können die Skripte direkt miteinander kommunizieren, als wären es Skripte der gleichen Webseite.

+ +

Sie können auch contentScript und contentScriptFile zusammen benutzen. Wenn Sie das tun, werden die Skripte, die sie in contentScriptFile spezifizieren vor denen in contentScript geladen. Das ermöglicht es Ihnen javaScript Bibliotheken, wie JQuery über eine URL zu laden und dann ein simples Skript inline zu verwenden, dass diese Bibliothek benutzt:

+ +
// main.js
+
+var data = require("sdk/self").data;
+var pageMod = require("sdk/page-mod");
+
+var contentScriptString = '$("body").html("<h1>Page matches ruleset</h1>");';
+
+pageMod.PageMod({
+  include: "*.mozilla.org",
+  contentScript: contentScriptString,
+  contentScriptFile: data.url("jquery.js")
+});
+ +
+

Wenn ihr Content Skript nicht sehr simpel ist oder aus einem statischen String besteht, sollten Sie contentScript:  nicht benutzen. Wenn Sie es doch tun, könnten Sie Probleme haben Ihr Add.on auf AMO verifiziert zu bekommmen.

+ +

Stattdessen sollten Sie ihr Skript in einer seperaten Datei schreiben und mit contentScriptFile laden. Das macht ihren Code übersichtlicher und er ist einfacher zu Warten, sichern und debuggen.

+
+ +

Kontrollieren, wann das Skript angehängt werden soll.

+ +

Die contentScriptWhen Option spezifiziert, wann das/die Content Skript/e geladen werden sollen. Diese brauch eine dieser Parameter:

+ +
    +
  • "start": Läd das Skript sofort, nach dem das Dokumentelement der Seite in den DOM eingefügt wird. ZU diesem Zeitpunkt wurde der DOM Inhalt noch nicht geladen,, deshalb kann das Skript nicht damit interagieren.
  • +
  • "ready": Läd das Skript nachdem der DOM der Seite geladen wurde: Dies ist der Fall, wenn das DOMContentLoaded Event  abgefeuert wird. Ab diesem Zeitpunkt können Content Skripts mit dem DOM interagieren, aber extern referenzierte Stylesheets und Bilder könnten noch nicht geladen sein.
  • +
  • "end": Läd das Skript nachdem der komplette Inhalt (DOM, JS, CSS, images) der Seute geladen wurde. Zu diesem Zeitpunkt wird das window.onload event abgefeuert.
  • +
+ +

Der Standardwert ist "end".

+ +

Die Funktion tab.attach() akzepiert contentScriptWhen nicht, da es generell aufgerufen wird wenn die Seite geladen wurde.

+ +

Übergabe von Konfigurationsoptionen

+ +

Das contentScriptOptions Objekt ist ein JSON Objekt, das den Content Skripts als "read-only" Wert als self.options Eigenschaft übergeben wird:

+ +
// main.js
+
+var tabs = require("sdk/tabs");
+
+tabs.on('ready', function(tab) {
+  tab.attach({
+      contentScript: 'window.alert(self.options.message);',
+      contentScriptOptions: {"message" : "hello world"}
+  });
+});
+ +

Jeder Wert (Objekt, Feld, String, etc), dass in JSON dargestellt werden kann, kann hier benutzt werden.

+ +

Zugriff auf den DOM

+ +

Content Skripts können natürlich wie jedes andere Skript, dass die Seite geladen hat ( Page Skripts) auf den DOM zugreifen. Content Skripts und Page Skripts sind wie folgt von einander isoliert:

+ +
    +
  • Content Skripts sehen keine JavaScript Objekte, die der Seite über Page Skripts hinzugefügt wurden.
  • +
  • Auch wenn ein Page Skript das Verhalten eines DOM Objekts verändert hat, sieht das Content Skript nur das Originalverhalten.
  • +
+ +

Das gleiche gilt auch umgekehrt: Page Skripts sehen keine JavaScript Objekte, die von Content Skripts hinzugefügt wurden.

+ +

Stellen Sie sich eine Seite vor, die zum Beispiel eine Variable foo über ein Page Skript zum window Objekt hinzufügt:

+ +
<!DOCTYPE html">
+<html>
+  <head>
+    <script>
+    window.foo = "hello from page script"
+    </script>
+  </head>
+</html>
+ +

Ein anderes Skript, dass nach diesem Skript in die Seite geladen wird, kann auf foo zugreifen. Ein Content Skript kann dies nicht:

+ +
// main.js
+
+var tabs = require("sdk/tabs");
+var mod = require("sdk/page-mod");
+var self = require("sdk/self");
+
+var pageUrl = self.data.url("page.html")
+
+var pageMod = mod.PageMod({
+  include: pageUrl,
+  contentScript: "console.log(window.foo);"
+})
+
+tabs.open(pageUrl);
+ +
console.log: my-addon: null
+
+ +

Es gibt gute Gründe für diese Isolation. Erstens können Content Skripts so keine Objekte an Webseiten übermitteln und somit Sicherheitslücken schaffen. Zweitens können Content Skripts so Objekte erzeugen, ohne sich Sorgen machen zu müssen, dass diese mit Objekten kollidieren, die in Page Skripts erzeugt wurden.

+ +

Die Isulation bedeutet, dass wenn zum Beispiel eine Webseite die JQuery Bibliothek läd, das Content Skript nicht in der Lage ist dieses zu sehen, aber eine eigene JQuery Bibliothek laden kann ohne das es ein Problem mit der Version gibt, die über das Page Skript hinzugefügt wurde.

+ +

Interaktion mit Page Skripts

+ +

Normalerweise möchte man Content Skripts und Page Skripts voneinander isolieren. Wenn dies nicht der Fall ist, da Sie zum Beispiel Objekte zwischen beiden Skripten austauschen wollen, oder Nachrichten zwischen ihnen schicken wollen können Sie mehr zum Thema unter  Interaktion mit Page Skripts finden.

+ +

Event Listeners

+ +

Man kann in Content Skripts genau wie in einem Page Skript auf DOM Events warten. Es gibt nur zwei wichtige Unterschieden:

+ +

Erstens: Falls Sie einen Event Listener als String an setAttribute() übergeben, wird der Listener im Seitenkontext ausgeführt und hat somit keinen Zugriff auf Variablen, die im Content Skript definiert wurden.

+ +

Zum Beispiel, wird dieses Content Skript mit der Fehlermeldung "theMessage is not defined" ausgeben:

+ +
var theMessage = "Hello from content script!";
+anElement.setAttribute("onclick", "alert(theMessage);");
+ +

Zweitens: Falls Sie einen Event Listener per direkter Zuweisung einem globalen Event Handler  wie onclick zuweisen, könnten Zuweisungen, die die Seite vornimmt überschrieben werden. Zur Veranschaulichung ist hier ein Add-on, das versucht einen click Handler per Zuweisung an window.onclick anzufügen:

+ +
var myScript = "window.onclick = function() {" +
+               "  console.log('unsafewindow.onclick: ' + window.document.title);" +
+               "}";
+
+require("sdk/page-mod").PageMod({
+  include: "*",
+  contentScript: myScript,
+  contentScriptWhen: "start"
+});
+ +

Das wird auf den meisten Seiten funktionieren, bis auf denen, die ebenfalls ein onclick zuweisen:

+ +
<html>
+  <head>
+  </head>
+  <body>
+    <script>
+    window.onclick = function() {
+      window.alert("it's my click now!");
+    }
+    </script>
+  </body>
+</html>
+ +

Aus diesen Gründen ist es besser Event Listeners per addEventListener() hinzuzufügen. So definieren Sie einen Listener als Funktion:

+ +
var theMessage = "Hello from content script!";
+
+anElement.onclick = function() {
+  alert(theMessage);
+};
+
+anotherElement.addEventListener("click", function() {
+  alert(theMessage);
+});
+ +

Kommunikation mit dem Add-on

+ +

Damit Add-On Sktipts und Content Skripts miteinander kommunizieren können, haben beide Seiten der Konversation Zugriff auf ein port Objekt.

+ +
    +
  • Um eine Nachricht von einer Seite zur anderen zu schicken nutzen Sie port.emit()
  • +
  • Um eine Nachricht von der anderen Seite zu empfangen nutzen port.on()
  • +
+ +

Nachrichten sind asyncron, was bedeutet, dass der Sender nicht wartet, bis er eine Antwort des Empfängers erhält, sondern die Nachricht schickt und das weiter arbeitet.

+ +

Hier ist ein simples Beispieladd-on, das eine Nachricht an ein Content Skript per port schickt:

+ +
// main.js
+
+var tabs = require("sdk/tabs");
+var self = require("sdk/self");
+
+tabs.on("ready", function(tab) {
+  worker = tab.attach({
+    contentScriptFile: self.data.url("content-script.js")
+  });
+  worker.port.emit("alert", "Message from the add-on");
+});
+
+tabs.open("http://www.mozilla.org");
+ +
// content-script.js
+
+self.port.on("alert", function(message) {
+  window.alert(message);
+});
+ +
+

Das context-menu Modul benutzt das Kommunikationsmodul, das hier beschrieben wird nicht. Um etwas über die Kommunikation mit geladenen Content Skripts im context-menu zu erfahren, schauen Sie in die context-menu Dokumentation.

+
+ +

Zugriff auf port im Content Skript

+ +

Im Content Skript ist das port Objekt als Eigenschaft im globalen Objekt self verfügbar. So versenden Sie eine Nachricht vom Content Skript:

+ +
self.port.emit("myContentScriptMessage", myContentScriptMessagePayload);
+ +

Um eine Nachricht vom Add-on Code zu bekommen:

+ +
self.port.on("myAddonMessage", function(myAddonMessagePayload) {
+  // Handle the message
+});
+ +
+

Das globale self Objekt ist etwas komplett anderes als das self Modul, das einer API in einem Add-on die Möglichkeit bietet auf Daten und die ID des Add-ons zuzugreifen.

+
+ +

Zugriff auf port im Add-on Skript

+ +

Im Add-on Code ist das Bindeglied zur Kommunikation zwischen Add-on und einem spezifischen Content Skript das  worker Objekt. Das port Objekt ist also eine Eigenschaft des  worker Objekts.

+ +

Der worker wird aber im Add-on Code nicht von allen Modulen gleich verwendet.

+ +

Vom page-worker

+ +

Das page-worker Objekt integriert die worker API direkt. Um also eine Nachricht von einem Content Skript zu erhalten, das mit dem page-worker assoziiert wird benutzt man pageWorker.port.on():

+ +
// main.js
+
+var pageWorkers = require("sdk/page-worker");
+var self = require("sdk/self");
+
+var pageWorker = require("sdk/page-worker").Page({
+  contentScriptFile: self.data.url("content-script.js"),
+  contentURL: "http://en.wikipedia.org/wiki/Internet"
+});
+
+pageWorker.port.on("first-para", function(firstPara) {
+  console.log(firstPara);
+});
+ +

Um eine benutzerdefinierte Nachricht vom Add-on zu schicken, nutz man pageWorker.port.emit():

+ +
// main.js
+
+var pageWorkers = require("sdk/page-worker");
+var self = require("sdk/self");
+
+pageWorker = require("sdk/page-worker").Page({
+  contentScriptFile: self.data.url("content-script.js"),
+  contentURL: "http://en.wikipedia.org/wiki/Internet"
+});
+
+pageWorker.port.on("first-para", function(firstPara) {
+  console.log(firstPara);
+});
+
+pageWorker.port.emit("get-first-para");
+ +
// content-script.js
+
+self.port.on("get-first-para", getFirstPara);
+
+function getFirstPara() {
+  var paras = document.getElementsByTagName("p");
+  if (paras.length > 0) {
+    var firstPara = paras[0].textContent;
+    self.port.emit("first-para", firstPara);
+  }
+}
+ +

Vom page-mod

+ +

Ein einziges  page-mod Objekt kann ein Skript an mehrere Seiten anhängen. Jede dieser Seiten hat ihren eigenen Context, in dem sie dieses Skript aufrufen. Daher benötigt es seperate Kanäle(worker) für jede Seite.

+ +

page-mod integriert also die worker API nicht direkt, sondern es wird jedes Mal wenn ein Content Skript an eine Seite angehängt wird das attach Event aufgerufen,  dessen listener einen worker für den Kontext übergeben bekommt. Durch das bereit stellen eines listeners bei attach kann man das port Objekt für das Content Skript, dass dieser Seite angefügt wurde über diesen page-mod verwenden:

+ +
// main.js
+
+var pageMods = require("sdk/page-mod");
+var self = require("sdk/self");
+
+var pageMod = pageMods.PageMod({
+  include: ['*'],
+  contentScriptFile: self.data.url("content-script.js"),
+  onAttach: startListening
+});
+
+function startListening(worker) {
+  worker.port.on('click', function(html) {
+    worker.port.emit('warning', 'Do not click this again');
+  });
+}
+ +
// content-script.js
+
+window.addEventListener('click', function(event) {
+  self.port.emit('click', event.target.toString());
+  event.stopPropagation();
+  event.preventDefault();
+}, false);
+
+self.port.on('warning', function(message) {
+  window.alert(message);
+});
+
+ +

Im oben gezeigten Add-on gibt es zwei Nachrichten:

+ +
    +
  • click wird vom page-mod an das Add-on geschickt, wenn der Nutzer auf ein Element auf der Seite klickt
  • +
  • warning schickt einen String zurück an den page-mod
  • +
+ +

Von Tab.attach()

+ +

Die Tab.attach() methode liefert einen worker zurück, den man zur Kommunikation mit dem/den Content Skript/Content Skripts, die angehängt wurden, verwenden kann.

+ +

Das Add-on fügt einen Button zu Firefox hinzu: Wenn der Benutzer den Button drückt, fügt das Add-on ein Content Skript an den aktuellen Tab an. Das Skript sendet eine Nachricht namens "my-addon-message" und wartet auf eine Antwort namens "my-script-response":

+ +
//main.js
+
+var tabs = require("sdk/tabs");
+var buttons = require("sdk/ui/button/action");
+var self = require("sdk/self");
+
+buttons.ActionButton({
+  id: "attach-script",
+  label: "Attach the script",
+  icon: "./icon-16.png",
+  onClick: attachScript
+});
+
+function attachScript() {
+  var worker = tabs.activeTab.attach({
+    contentScriptFile: self.data.url("content-script.js")
+  });
+  worker.port.on("my-script-response", function(response) {
+    console.log(response);
+  });
+  worker.port.emit("my-addon-message", "Message from the add-on");
+}
+
+ +
// content-script.js
+
+self.port.on("my-addon-message", handleMessage);
+
+function handleMessage(message) {
+  alert(message);
+  self.port.emit("my-script-response", "Response from content script");
+}
+ +

Die port API

+ +

Schaue unter der Referenzseite für das port Objekt.

+
+ +

Die postMessage API

+ +

bevor das port Objekt hinzugefügt wurde, kommunizierten Add-on Code und Content Skripts über eine andere API:

+ + + +

Die API ist immer noch verfügbar und dokumentiert, aber es gibt keinen Grund sie statt der port API zu verwenden, die hier beschrieben wird. Die Ausnahme bildet das context-menu Modul, welches immer noch postMessage verwendet.

+ +

Content Skript zu Content Skript

+ +

Content Skripts können nur direkt miteinander kommunizieren, wenn diese im gleichen Kontext geladen wurden. Beispiel: Wenn ein einziger Aufruf von  Tab.attach()  zwei Content Skripts anhängt, können diese sich gegenseitig sehen. Wenn aber Tab.attach() zweimal aufgerufen wird, und die Content Skripts einzeln anhängt,können die Content Skripte nicht miteinander kommunizieren. Dann müssen die Nachrichten über die  port API über den Add-on code gesendet werden.

+ +

Cross-domain Content Skripts

+ +

Grundsätzlich hat ein Content Skript keine cross-domain Privilegien. Sie können also keinen Inhalt eines iframes auslesen, wenn dieser Inhalt von einer anderen Domain stammt, oder XMLHttpRequests an eine andere Domain schicken.

+ +

Um dieses Feature für spezielle Domains hinzuzufügen fügen Sie dem package.json ihres Add-ons den Schlüssel "cross-domain-content" unter dem "permissions" Schlüssel hinzu. Siehe dafür den Artikel  cross-domain content scripts.

+
diff --git a/files/de/mozilla/add-ons/sdk/guides/index.html b/files/de/mozilla/add-ons/sdk/guides/index.html new file mode 100644 index 0000000000..fbb8311866 --- /dev/null +++ b/files/de/mozilla/add-ons/sdk/guides/index.html @@ -0,0 +1,154 @@ +--- +title: Leitfäden +slug: Mozilla/Add-ons/SDK/Guides +translation_of: Archive/Add-ons/Add-on_SDK/Guides +--- +

Auf dieser Seite sind theoretische und detailliertere Artikel über das SDK auffindbar.

+
+

Für Mitwirkende

+
+
+
+
+ Erste Schritte
+
+ Erfahre, wie du zu dem SDK beitragen kannst: den Quellcode erhalten, Bugs melden und beheben, Patches einreichen, Überprüfungen und Hilfe erhalten.
+
+ Module
+
+ Erfahre mehr über das vom SDK verwendete Modulsystem (basierend auf der CommonJS-Spezifikation), wie Sandboxes und Compartments zum Erhöhen der Sicherheit verwendet werden können, und über den im SDK enthaltenen Modul-Loader Cuddlefish.
+
+ Klassen und Vererbung
+
+ Erfahre, wie Klassen und Vererbungen in JavaScript implementiert werden können, unter Verwendung von Konstruktoren und Prototypen, und über die Helper-Funktion des SDKs zum Vereinfachen dieser Prozesse.
+
+
+
+
+
+ Private Eigenschaften
+
+ Erfahre, wie private Eigenschaften in JavaScript unter Verwendung von Prefixes, Closures und WeakMaps implementiert werden können und wie das SDK private Eigenschaften durch das Verwenden von Namespaces (eine Verallgemeinerung von WeakMaps) unterstützt.
+
+ Prozesse
+
+ Das SDK wurde dafür entwickelt, in einer Umgebung zu arbeiten, in welcher Code zum Manipulieren von Web-Inhalten in unterschiedlichen Prozessen wie der Haupt-Code des Add-ons ausgeführt wird. Dieser Artikel erklärt die wichtigsten Vorteile dieses Konzepts.
+
+
+
+
+

SDK-Infrastruktur

+
+
+
+
+ Modulstruktur des SDKs
+
+ Das SDK selbst sowie die dafür konzipierten Add-ons bestehen aus wiederverwendbaren JavaScript-Modulen. Dieser Artikel erklärt, worum es sich bei diesen Modulen handelt, wie sie geladen werden können und wie die Modul-Baumstruktur des SDKs aufgebaut ist.
+
+ SDK-API-Lebenszyklus
+
+  Einführung in den Lebenszyklus der SDK-APIs, beinhaltet Stabilitätsbewertungen für APIs.
+
+
+
+
+
+ Programm-ID
+
+ Die Programm-ID ist ein eindeutiger Bezeichner für ein Add-on. Dieser Leitfaden zeigt, wie sie erstellt wird, und wozu sie dient.
+
+ Firefox-Kompatibilität
+
+ Lerne, mit welchen Firefox-versionen eine SDK-Version kompatibel ist und wie Kompatibilitätsprobleme behandelt werden können.
+
+
+
+
+

SDK-Spracheigenschaften

+
+
+
+
+ Arbeiten mit Events
+
+ Erstelle Event-basierten Code mit Hilfe des SDK-Eventausgabe-Frameworks.
+
+
+
+
+
+ Zwei Arten von Scripts
+
+ Dieser Artikel erklärt die Unterschiede zwischen den vom Haupt-Code des Add-ons verwendbaren APIs und von denen, die von einem Content-Script verwendet werden können.
+
+
+
+
+

Content-Scripts

+
+
+
+
+ Einführung in Content-Scripts
+
+ Eine Übersicht über Content-Scripts.
+
+ Laden von Content-Scripts
+
+ Laden von Content-Scripts in Webseiten, Einbindung entweder von Strings oder von eigenen Dateien und Festlegen des Ausführungszeitpunktes.
+
+ Auf das DOM zugreifen
+
+ Informationen über den Zugriff von Content-Scripts auf das DOM (Document Object Model).
+
+ Kommunikation mit anderen Scripts
+
+ Erfahre, wie ein Content-Script mit der main.js-Datei, mit anderen Content-Scripts und von der Webseite selbst geladenen Scripts kommunizieren kann.
+
+
+
+
+
+ Verwendung von "port"
+
+ Kommunikation zwischen einem Content-Script und den anderen Bestandteilen des Add-ons über das port-Objekt.
+
+ Verwendung von "postMessage()"
+
+ Kommunikation zwischen einem Content-Script und den anderen Bestandteilen des Add-ons über die postMessage()-API und ein Vergleich dieser Technik mit dem port-Objekt.
+
+ Domainübergreifende Content-Scripts
+
+ Lerne, wie man Content-Scripts dazu befähigt, mit Inhalten von anderen Domains zu interagieren.
+
+ Reddit-Beispiel
+
+ Ein einfaches Add-on mit Content-Scripts.
+
+
+
+
+

XUL-Portierung

+
+
+
+
+ XUL Portierungsleitfaden
+
+ Techniken zum Portieren eines XUL Add-ons auf das SDK.
+
+ XUL versus SDK
+
+ Ein Vergleich der Stärken und Schwächen des SDK's mit denen der traditionellen XUL-basierten Add-ons.
+
+
+
+
+
+ Portierungs-Beispiel
+
+ Ein Walkthrough durch das Portieren eines relativ einfachen XUL-basierten Add-ons auf das SDK.
+
+
+
diff --git a/files/de/mozilla/add-ons/sdk/index.html b/files/de/mozilla/add-ons/sdk/index.html new file mode 100644 index 0000000000..4a73b5fbeb --- /dev/null +++ b/files/de/mozilla/add-ons/sdk/index.html @@ -0,0 +1,83 @@ +--- +title: Add-on SDK +slug: Mozilla/Add-ons/SDK +translation_of: Archive/Add-ons/Add-on_SDK +--- +

Das Add-on SDK ermöglicht es, Add-ons für Firefox unter Verwendung der Standard-Webtechnologien zu entwickeln: JavaScript, HTML und CSS. Das SDK beinhaltet JavaScript APIs zum Erstellen, Ausführen, Testen und Packen von Add-ons.

+ +
+

Tutorials

+ +
+ + +
+
+
Benutzeroberflächen
+
Erstelle Benutzeroberflächenkomponenten wie Toolbar-Buttons, Kontextmenüs, Menüeinträge oder Dialoge.
+
Inhalte von Webseiten bearbeiten
+
Inhalte von Seiten über ein spezifisches URL-Muster oder dynamisch einen bestimmten Tab bearbeiten.
+
Zusammenfassung
+
Walk-through durch das Beispiel-Add-on "Annotator".
+
+
+
+ +
+

Leitfäden

+ +
+
+
+
Zum SDK beitragen
+
Trage zum SDK bei und lerne die wichtigsten im SDK-Quelltext verwendeten Objekte wie Module, Klassen und Vererbung, private Eigenschaften und Inhaltsabläufe kennen.
+
SDK-Aufbau
+
Verstehe die Technologien, die dem SDK zugrunde liegen: Modulstruktur, Programm-ID und die Regeln, die die Firefox-Kompatibilität definieren.
+
Content-Scripts
+
Eine detaillierte Anleitung zum Arbeiten mit Content-Scripts. Erklärt wird das Laden von Content-Scripts, auf welche Objekte ein Content-Script zugreifen kann und wie man zwischen einem Content-Script und dem Rest des Add-ons kommunizieren kann.
+
+
+ + +
+ +
+

Referenzen

+ +
+
+
+
High-Level-APIs
+
Dokumentation der High-Level-SDK-APIs.
+
Tools-Referenz
+
Dokumentation des cfx-Tools zum Entwickeln, Testen und Packen von Add-ons, der Konsole, die global zum Loggen verwendet wird und der package.json-Datei.
+
+
+ +
+
+
Low-Level-APIs
+
Dokumentation der Low-Level-SDK-APIs.
+
+
+
+ +

 

diff --git a/files/de/mozilla/add-ons/sdk/tools/index.html b/files/de/mozilla/add-ons/sdk/tools/index.html new file mode 100644 index 0000000000..8c67b4644e --- /dev/null +++ b/files/de/mozilla/add-ons/sdk/tools/index.html @@ -0,0 +1,14 @@ +--- +title: Tools +slug: Mozilla/Add-ons/SDK/Tools +tags: + - Add-on SDK + - CFX + - JPM + - NeedsTranslation + - TopicStub +translation_of: Archive/Add-ons/Add-on_SDK/Tools +--- +

Articles listed here provide a reference for the SDK's tools:

+ +

{{ LandingPageListSubpages ("/en-US/Add-ons/SDK/Tools", 7) }}

diff --git a/files/de/mozilla/add-ons/sdk/tools/jpm/index.html b/files/de/mozilla/add-ons/sdk/tools/jpm/index.html new file mode 100644 index 0000000000..86e6a82aa3 --- /dev/null +++ b/files/de/mozilla/add-ons/sdk/tools/jpm/index.html @@ -0,0 +1,497 @@ +--- +title: jpm +slug: Mozilla/Add-ons/SDK/Tools/jpm +translation_of: Archive/Add-ons/Add-on_SDK/Tools/jpm +--- +
+

Sie können jpm ab Firefox 38 verwenden.

+ +

Dieser Artikel bezieht sich auf jpm.

+
+ +

Der Node-basierte Ersatz für cfx, erlaubt das Testen, Starten und Paketieren von Add-Ons.

+ +

Schauen Sie sich das jpm-Tutorial als Einführung an.

+ +

jpm wird folgendermaßen verwendet:

+ +
jpm [command] [options]
+
+ +

jpm unterstützt die folgenden globalen Optionen:

+ +
-h, --help        - Zeigt eine Hilfsnachricht
+-V, --version     - Anzeigen der JPM Versionsnummer
+
+ +

Installation

+ +

jpm wird über den Node Package Manager (npm) installiert. npm ist im Installer von Node.js enthalten, welchen Sie auf nodejs.org finden.

+ +

Nachdem Sie npm installiert haben, können Sie jpm wie jedes andere npm-Paket installieren:

+ +
npm install jpm -g
+ +

Abhängig von ihren Einstellungen müssen Sie den Befehl möglicherweise mit Adminrechten ausführen:

+ +
sudo npm install jpm -g
+ +

Tippen Sie folgendes in die Eingabeaufforderung:

+ +
jpm
+ +

Es sollte sich eine Zusammenfassung der jpm-Kommandos öffnen. Im Gegensatz zu cfx ist jpm in jeder Eingabeaufforderung verwendbar, solange Sie es mit der Option -g installiert haben.

+ +

Probleme?

+ +

Falls Sie die Zusammenfassung nicht verstehen, fragen Sie nach Hilfe. SDK-Nutzer und Teammitglieder des Projekts diskutieren über Probleme und Vorschläge in der  Projekt- Mailingliste. Andere könnten das selbe Problem wie Sie gehabt haben, also suchen Sie bitte zuerst im Listenarchiv. Sie können mit anderen SDK-Nutzern im Kanal #jetpack in Mozillas IRC-Netzwerk chatten.

+ +

Command reference

+ +

There are six jpm commands:

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + +
jpm initCreate a skeleton add-on as a starting point for your own add-on.
jpm runLaunch an instance of Firefox with your add-on installed.
jpm testRuns your add-on's unit tests.
jpm xpiPackage your add-on as an XPI file, which is the install file format for Firefox add-ons.
jpm postPackage your add-on as an XPI file, then post it to some url.
jpm watchpostPackage your add-on as an XPI file whenever there is a file changed, and post that to some url.
+ +

jpm init

+ +

This command initializes a new add-on from scratch.

+ +

Create a new directory, change into it, and run jpm init.

+ +
mkdir my-addon
+cd my-addon
+jpm init
+ +

You'll then be asked to supply some information about your add-on: this will be used to create your add-on's package.json file.

+ + + +

Most of these fields have a default, which is shown in brackets after the question. If you just press Enter, your add-on will get the default value.

+ +

Once you've supplied a value or accepted the default for these properties, you'll be shown the complete contents of "package.json" and asked to accept it.

+ +

Then jpm will create an skeleton add-on, as a starting point for your own add-on development, with the following file structure:

+ + + +

jpm run

+ +

This command runs a new instance of Firefox with the add-on installed:

+ +
jpm run
+ +

jpm run accepts the following options:

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
-b --binary BINARY +

Use the version of Firefox specified in BINARY. BINARY may be specified as a full path or as a path relative to the current directory.

+ +
+jpm run -b /path/to/Firefox/Nightly
+ See Selecting a browser version.
--binary-args CMDARGS +

Pass extra arguments to Firefox.

+ +

For example, to pass the -jsconsole argument to Firefox, which will launch the Browser Console, try the following:

+ +
+jpm run --binary-args -jsconsole
+ +

To pass multiple arguments, or arguments containing spaces, quote them:

+ +
+jpm run --binary-args '-url mzl.la -jsconsole'
+
--debugRun the add-on debugger attached to the add-on.
-o --overload PATH +

Rather than use the SDK modules built into Firefox, use the modules found at PATH. If -o is specified and PATH is omitted, jpm will look for the JETPACK_ROOT environment variable and use its value as the path.

+ +

See Overloading the built-in modules for more information.

+
-p --profile= PROFILE +

By default, jpm uses a clean temporary Firefox profile each time you call jpm run. Use the --profile option to instruct jpm to launch Firefox with an existing profile.

+ +

The PROFILE value may be a profile name or the path to the profile.

+ +

See Using profiles for more information.

+
-v --verboseVerbose operation.
--no-copy +
Use with caution because jpm run|test changes many preferences, never use with your main profile.
+ +
This only applies when --profile is used.
+ Disables the copying of the profile used, which allows one to reuse a profile.
 
+ +

jpm test

+ +

Use this command to run an add-on's unit tests. It will:

+ + + +
jpm test
+
+ +

See the tutorial on unit testing and the reference documentation for the assert module for more details on this.

+ +

jpm test accepts the following options:

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
-b --binary BINARY +

Use the version of Firefox specified in BINARY. BINARY may be specified as a full path or as a path relative to the current directory.

+ +
+jpm test -b /path/to/Firefox/Nightly
+ +

See Selecting a browser version.

+
--binary-args CMDARGS +

Pass extra arguments to Firefox.

+ +

For example, to pass the -jsconsole argument to Firefox, which will launch the Browser Console, try the following:

+ +
+jpm test --binary-args -jsconsole
+ +

To pass multiple arguments, or arguments containing spaces, quote them:

+ +
+jpm test --binary-args '-url mzl.la -jsconsole'
+
--debugRun the add-on debugger attached to the add-on.
-f --filter FILE[:TEST] +

Only run tests whose filenames match FILE and optionally match TEST, both regexps.

+ +
+jpm test --filter base64:btoa
+ +

The above command only runs tests in files whose names contain "base64", and in those files only runs tests whose names contain "btoa".

+
-o --overload PATH +

Rather than use the SDK modules built into Firefox, use the modules found at PATH. If -o is specified and PATH is omitted, jpm will look for the JETPACK_ROOT environment variable and use its value as the path.

+ +

See Overloading the built-in modules for more information.

+
-p --profile PROFILE +

By default, jpm uses a clean temporary Firefox profile each time you call jpm run. Use the --profile option to instruct jpm to launch Firefox with an existing profile.

+ +

The PROFILE value may be a profile name or the path to the profile.

+ +

See Using profiles for more information.

+
--stop-on-error +

By default jpm test keeps running tests even after tests fail. Specify --stop-on-error to stop running tests after the first failure:

+ +
+jpm test --stop-on-error
+
--tbplPrint test output in Treeherder format
--times NUMBER +

Run tests NUMBER of times:

+ +
+jpm test --times 2
+
-v --verboseVerbose operation.
--no-copy +
Use with caution because jpm run|test changes many preferences, never use with your main profile.
+ +
This only applies when --profile is used.
+ Disables the copying of the profile used, which allows one to reuse a profile.
+ +

jpm xpi

+ +

This command packages the add-on as an XPI file, which is the install file format for Mozilla add-ons.

+ +
jpm xpi
+ +

It looks for a file called package.json in the current directory and creates the corresponding XPI file. It ignores any ZIPs or XPIs in the add-on's root, and any test files.

+ +

Once you have built an XPI file you can distribute your add-on by submitting it to addons.mozilla.org.

+ +

jpm xpi accepts the following option:

+ + + + + + + + +
-v --verbose +

Verbose operation:

+ +
+jpm xpi -v
+
+ +

jpm post

+ +

This command packages the add-on as an XPI file, the posts it to some url.

+ +
jpm post
+ +

It looks for a file called package.json in the current directory and creates a XPI file with which to post to the --post-url.

+ +

jpm post accepts the following options:

+ + + + + + + + + + + + +
--post-url URL +

The url to post the extension to after creating a XPI.

+ +
+jpm post --post-url http://localhost:8888/
+ +

See Using Post and Watchpost for more information.

+
-v --verbose +

Verbose operation:

+ +
+jpm post --post-url http://localhost:8888/ -v
+
+ +

jpm watchpost

+ +

This command packages the add-on as an XPI file, the posts it to some url whenever a file in the current working directory changes.

+ +
jpm watchpost
+ +

Creates a XPI whenever a file in the current working directory changes and posts that to the --post-url.

+ +

jpm watchpost accepts the following options:

+ + + + + + + + + + + + +
--post-url URL +

The url to post the extension to after creating a XPI.

+ +
+jpm watchpost --post-url http://localhost:8888/
+ +

See Using Post and Watchpost for more information.

+
-v --verbose +

Verbose operation:

+ +
+jpm watchpost --post-url http://localhost:8888/ -v
+
+ +

Techniques

+ +

Selecting a browser version

+ +

By default, jpm run and jpm test will run the release version of Firefox. You can instruct jpm to use a different version in one of two ways:

+ + + +

Using .jpmignore to ignore files

+ +

Using .jpmignore is similar to using .gitignore with git, .hgignore with Mercurial, or .npmignore with npm. By using this file you can let jpm know which files you would like it to ignore when building a .xpi file with jpm xpi.

+ +

Here is an example:

+ +
# Ignore .DS_Store files created by mac
+.DS_Store
+
+# Ignore any zip or xpi files
+*.zip
+*.xpi
+
+ +

A .jpmignore file with the above contents would ignore all zip files and .DS_Store files from the xpi generated by jpm xpi.

+ +

Using profiles

+ +

By default, jpm run uses a new profile each time it is executed. This means that any profile-specific data entered from one run of jpm will not, by default, be available in the next run.

+ +

This includes, for example, any extra add-ons you installed, or your history, or any data stored using the simple-storage API.

+ +

To make jpm use a specific profile, pass the --profile option, specifying the name of the profile you wish to use, or the path to the profile.

+ +
jpm run --profile boogaloo
+
+ +
jpm run --profile path/to/boogaloo
+ +

If you supply --profile but its argument is not the name of or path to an existing profile, jpm will open the profile manager,  enabling you to select and existing profile or create a new one:

+ +
jpm run --profile i-dont-exist
+ +

Developing without browser restarts

+ +

Because jpm run restarts the browser each time you invoke it, it can be a little cumbersome if you are making very frequent changes to an add-on. An alternative development model is to use the Extension Auto-Installer add-on: this listens for new XPI files on a specified port and installs them automatically. That way you can test new changes without needing to restart the browser:

+ + + +

You could even automate this workflow with a simple script. For example:

+ +
jpm watchpost --post-url http://localhost:8888/
+
+ +

Note that the logging level defined for the console is different when you use this method, compared to the logging level used when an add-on is run using jpm run. This means that if you want to see output from console.log() messages, you'll have to tweak a setting. See the documentation on logging levels for the details on this.

+ +

Overloading the built-in modules

+ +

The SDK modules you use to implement your add-on are built into Firefox. When you run or package an add-on using jpm run or jpm xpi, the add-on will use the versions of the modules in the version of Firefox that hosts it.

+ +

As an add-on developer, this is usually what you want. But if you're developing the SDK modules themselves, of course, it isn't. In this case you need to:

+ + + +
jpm run -o
+
+ +

This instructs jpm to use the local copies of the SDK modules, not the ones in Firefox. If you don't want to set the JETPACK_ROOT environment variable, you can pass the location of your copy of the SDK modules along with -o:

+ +
jpm run -o "/path/to/SDK/"
diff --git a/files/de/mozilla/add-ons/sdk/tutorials/adding_a_button_to_the_toolbar/index.html b/files/de/mozilla/add-ons/sdk/tutorials/adding_a_button_to_the_toolbar/index.html new file mode 100644 index 0000000000..c5f41a2baf --- /dev/null +++ b/files/de/mozilla/add-ons/sdk/tutorials/adding_a_button_to_the_toolbar/index.html @@ -0,0 +1,100 @@ +--- +title: Einen Button zur Toolbar hinzufügen +slug: Mozilla/Add-ons/SDK/Tutorials/Adding_a_Button_to_the_Toolbar +translation_of: Archive/Add-ons/Add-on_SDK/Tutorials/Adding_a_Button_to_the_Toolbar +--- +
+ Für dieses Tutorial wird die erfolgreiche Installation des SDK und erlernte Vorkenntnisse von cfx vorrausgesetzt.
+
+

Dieses Widget wird ab Firefox 29 nicht mehr verwendet/funktionieren. Um Buttons in Firefox 29 (+) hinzuzufügen, benutze bitte die UI Module, besonders die Action-Buttons oder Toogle-Buttons APIs.

+
+

Um einen Button zur Toolbar hinzuzufügen, verwende das widget-Module.

+

Erstelle ein neues Verzeichnis, navigiere mit der Eingabeaufforderung in dieses Verzeichnis, und gib cfx init ein. Dann öffne die Datei "main.js" im "lib"-Verzeichnis und gib folgenden Code ein:

+
var widgets = require("sdk/widget");
+var tabs = require("sdk/tabs");
+
+var widget = widgets.Widget({
+  id: "mozilla-link",
+  label: "Mozilla website",
+  contentURL: "http://www.mozilla.org/favicon.ico",
+  onClick: function() {
+    tabs.open("http://www.mozilla.org/");
+  }
+});
+

Das Widget wird wird zur AddOn-Leiste (unten am Fensterrand) hinzugefügt:

+

Du kannst leider nicht die Standart-Position des Icons ändern, aber der User kann den Standort jederzeit verändern. Das id-Attribut ist zwingend erforderlich. Es speichert die Position des Icons und sollte nicht verändert weren, da sonst wieder der Standart wiederhergestellt wird.

+

Beim Aktivieren wird dieser Link geöffnet: http://www.mozilla.org.

+
+  
+

Das Icon angeben (URL)

+

Wenn Du dieses Widget verwendest, kannst Du das Icon via contentURL: anzeigen. Das kann eine lokale, aber auch eine externe Datei sein. Allerdings lässt es sich nicht empfehlen Icons im Internet zu verwenden, da bei einem Serverausfall die Grafik nicht geladen werden kann. Das Beispiel verwendet eine Grafik namens "my-icon.png" aus dem AddOn-Verzeichnis (data):

+
+
var widgets = require("sdk/widget");
+var tabs = require("sdk/tabs");
+var self = require("sdk/self");
+
+var widget = widgets.Widget({
+  id: "mozilla-link",
+  label: "Mozilla website",
+  contentURL: self.data.url("my-icon.png"),
+  onClick: function() {
+    tabs.open("http://www.mozilla.org/");
+  }
+});
+
+

Du kannst das Icon immer mit contentURL ändern!

+

Responding To the User

+

You can listen for click, mouseover, and mouseout events by passing handler functions as the corresponding constructor options. The widget example above assigns a listener to the click event using the onClick option, and there are similar onMouseover and onMouseout options.

+

To handle user interaction in more detail, you can attach a content script to the widget. Your add-on script and the content script can't directly access each other's variables or call each other's functions, but they can send each other messages.

+

Here's an example. The widget's built-in onClick property does not distinguish between left and right mouse clicks, so to do this we need to use a content script. The script looks like this:

+
window.addEventListener('click', function(event) {
+  if(event.button == 0 && event.shiftKey == false)
+    self.port.emit('left-click');
+  if(event.button == 2 || (event.button == 0 && event.shiftKey == true))
+    self.port.emit('right-click');
+    event.preventDefault();
+}, true);
+

It uses the standard DOM addEventListener() function to listen for click events, and handles them by sending the corresponding message to the main add-on code. Note that the messages "left-click" and "right-click" are not defined in the widget API itself, they're custom events defined by the add-on author.

+

Save this script in your data directory as "click-listener.js".

+

Next, modify main.js to:

+ +
var widgets = require("sdk/widget");
+var tabs = require("sdk/tabs");
+var self = require("sdk/self");
+
+var widget = widgets.Widget({
+  id: "mozilla-link",
+  label: "Mozilla website",
+  contentURL: "http://www.mozilla.org/favicon.ico",
+  contentScriptFile: self.data.url("click-listener.js")
+});
+widget.port.on("left-click", function(){
+  console.log("left-click");
+});
+widget.port.on("right-click", function(){
+  console.log("right-click");
+});
+

Now execute cfx run again, and try right- and left-clicking on the button. You should see the corresponding string written to the command shell.

+

Attaching a Panel

+ +

+

If you supply a panel object to the widget's constructor, then the panel will be shown when the user clicks the widget:

+
var data = require("sdk/self").data;
+var clockPanel = require("sdk/panel").Panel({
+  width:215,
+  height:160,
+  contentURL: data.url("clock.html")
+});
+require("sdk/widget").Widget({
+  id: "open-clock-btn",
+  label: "Clock",
+  contentURL: data.url("History.png"),
+  panel: clockPanel
+});
+

To learn more about working with panels, see the tutorial on displaying a popup.

+

Learning More

+

To learn more about the widget module, see its API reference documentation.

+

To learn more about content scripts, see the content scripts guide.

diff --git a/files/de/mozilla/add-ons/sdk/tutorials/getting_started/index.html b/files/de/mozilla/add-ons/sdk/tutorials/getting_started/index.html new file mode 100644 index 0000000000..dbafb57553 --- /dev/null +++ b/files/de/mozilla/add-ons/sdk/tutorials/getting_started/index.html @@ -0,0 +1,214 @@ +--- +title: Getting started +slug: Mozilla/Add-ons/SDK/Tutorials/Getting_started +translation_of: Mozilla/Add-ons/SDK/Tutorials/Getting_Started_%28jpm%29 +--- +

This tutorial walks through creating a simple add-on using the SDK.

+ +

Prerequisites

+ +

To create add-ons for Firefox using the SDK, you'll first need to follow the instructions to install and activate the SDK. Once you've done that, you'll be looking at a command prompt.

+ +

Initializing an empty add-on

+ +

In the command prompt, create a new directory. The directory doesn't have to be under the SDK root: you can create it anywhere you like. Navigate to it, type cfx init, and hit enter:

+ +
mkdir my-addon
+cd my-addon
+cfx init
+
+ +

You'll see some output like this:

+ +
* lib directory created
+* data directory created
+* test directory created
+* doc directory created
+* README.md written
+* package.json written
+* test/test-main.js written
+* lib/main.js written
+* doc/main.md written
+Your sample add-on is now ready for testing:
+try "cfx test" and then "cfx run". Have fun!"
+
+ +

Implementing the add-on

+ +

Now you can write the add-on's code, which goes in the "main.js" file in your "lib" directory. This file was created for you in the previous step. Open it and add the following code:

+ +
var buttons = require('sdk/ui/button/action');
+var tabs = require("sdk/tabs");
+
+var button = buttons.ActionButton({
+  id: "mozilla-link",
+  label: "Visit Mozilla",
+  icon: {
+    "16": "./icon-16.png",
+    "32": "./icon-32.png",
+    "64": "./icon-64.png"
+  },
+  onClick: handleClick
+});
+
+function handleClick(state) {
+  tabs.open("https://www.mozilla.org/");
+}
+
+ +

Save the file.

+ +

Next, save these three icon files to the "data" directory:

+ + + + + + + + + + + + + + + + +
icon-16.png
icon-32.png
icon-64.png
+ +

Back at the command prompt, type:

+ +
cfx run
+
+ +

This is the SDK command to run a new instance of Firefox with your add-on installed. When Firefox launches, in the top-right corner of the browser you'll see an icon with the Firefox logo. Click the icon, and a new tab will open with https://www.mozilla.org/ loaded into it.

+ +
+

You might see an error message like this when you type cfx run:

+ +
A given cfx option has an inappropriate value:
+  ZIP does not support timestamps before 1980
+ +

If so, you've run into bug 1005412, meaning that the icon files you downloaded are given a timestamp of 1970. Until this bug is fixed, the workaround is to use the touch command to update the timestamps:

+ +
touch icon-16.png
+
+ +

That's all this add-on does. It uses two SDK modules: the action button module, which enables you to add buttons to the browser, and the tabs module, which enables you to perform basic operations with tabs. In this case, we've created a button whose icon is the Firefox icon, and added a click handler that loads the Mozilla home page in a new tab.

+ +

Try editing this file. For example, we could change the page that gets loaded:

+ +
var buttons = require('sdk/ui/button/action');
+var tabs = require("sdk/tabs");
+
+var button = buttons.ActionButton({
+  id: "mozilla-link",
+  label: "Visit Mozilla",
+  icon: {
+    "16": "./icon-16.png",
+    "32": "./icon-32.png",
+    "64": "./icon-64.png"
+  },
+  onClick: handleClick
+});
+
+function handleClick(state) {
+  tabs.open("https://developer.mozilla.org/");
+}
+ +

At the command prompt, execute cfx run again. This time clicking it takes you to https://developer.mozilla.org/.

+ +

Packaging the add-on

+ +

When you've finished the add-on and are ready to distribute it, you'll need to package it as an XPI file. This is the installable file format for Firefox add-ons. You can distribute XPI files yourself or publish them to https://addons.mozilla.org so other users can download and install them.

+ +

To build an XPI, just execute the command cfx xpi from the add-on's directory:

+ +
cfx xpi
+
+ +

You should see a message like:

+ +
Exporting extension to my-addon.xpi.
+
+ +

To test that this worked, try installing the XPI file in your own Firefox installation. You can do this by pressing the Ctrl+O key combination (Cmd+O on Mac) from within Firefox, or selecting the "Open" item from Firefox's "File" menu. This will bring up a file selection dialog; navigate to the "my-addon.xpi" file, open it and follow the prompts to install the add-on.

+ +

Summary

+ +

In this tutorial we've built and packaged an add-on using three commands:

+ + + +

These are the three main commands you'll use when developing SDK add-ons. There's comprehensive reference documentation covering all the commands you can use and all the options they take.

+ +

The add-on code itself uses two SDK modules, action button and tabs. There's reference documentation for all the high-level and low-level APIs in the SDK.

+ +

What's next?

+ +

To get a feel for some of the things you can do with the SDK APIs, try working through some of the tutorials.

+ +

Advanced techniques

+ +

Overriding the built-in modules

+ +

The SDK modules you use to implement your add-on are built into Firefox. When you run or package an add-on using cfx run or cfx xpi, the add-on will use the versions of the modules in the version of Firefox that hosts it.

+ +

As an add-on developer, this is usually what you want. But if you're developing the SDK modules themselves, of course, it isn't. In this case it's assumed that you have checked out the SDK from its GitHub repo and will have run the bin/activate script from the root of your checkout.

+ +

Then when you invoke cfx run or cfx xpi, you pass the "-o" option:

+ +
cfx run -o
+
+ +

This instructs cfx to use the local copies of the SDK modules, not the ones in Firefox.

+ +

Developing without cfx run

+ +

Because cfx run restarts the browser each time you invoke it, it can be a little cumbersome if you are making frequent changes to an add-on. An alternative development model is to use the Extension Auto-Installer add-on: this listens for new XPI files on a specified port and installs them automatically. That way you can test new changes without needing to restart the browser:

+ + + +

You could even automate this workflow with a simple script. For example:

+ +
while true ; do cfx xpi ; wget --post-file=codesy.xpi http://localhost:8888/ ; sleep 5 ; done
+
+ +

Note that the logging level defined for the console is different when you use this method, compared to the logging level used when an add-on is run using cfx run. This means that if you want to see output from console.log() messages, you'll have to tweak a setting. See the documentation on logging levels for the details on this.

+ +

Another example using grunt and grunt-shell:

+ +
module.exports = function(grunt) {
+  'use strict';
+  require('matchdep').filterDev('grunt-!(cli)').forEach(grunt.loadNpmTasks);
+  grunt.initConfig({
+    shell: {
+      xpi: {
+        command: [
+          'cd pluginpath',
+          'cfx xpi',
+          'wget --post-file=pluginname.xpi http://localhost:8888/ || echo>/dev/null'
+        ].join('&&')
+      }
+    },
+    watch: {
+      xpi: {
+        files: ['pluginpath/**'],
+        tasks: ['shell:xpi']
+      }
+    }
+  });
+
+  grunt.loadNpmTasks('grunt-contrib-watch');
+  grunt.loadNpmTasks('grunt-shell');
+  grunt.registerTask('default', ['watch']);
+};
diff --git a/files/de/mozilla/add-ons/sdk/tutorials/index.html b/files/de/mozilla/add-ons/sdk/tutorials/index.html new file mode 100644 index 0000000000..6eb7e95b49 --- /dev/null +++ b/files/de/mozilla/add-ons/sdk/tutorials/index.html @@ -0,0 +1,165 @@ +--- +title: Tutorials +slug: Mozilla/Add-ons/SDK/Tutorials +translation_of: Archive/Add-ons/Add-on_SDK/Tutorials +--- +

Auf dieser Seite wird gezeigt, wie man spezifische praktische Aufgaben unter Verwendung des SDKs bewältigen kann.

+
+

Erste Schritte

+
+
+
+
+ Installation
+
+ Download, Installation und Einrichtung des SDKs unter Windows, OS X und Linux.
+
+
+
+ Fehlerbehebung
+
+ Lösungsansätze zum Beheben klassischer Probleme und Möglichkeiten zum Erhalten weiterer Hilfe.
+
+
+
+
+
+ Erste Schritte mit cfx
+
+ Die elementaren cfx-Befehle zum Erstellen von Add-ons.
+
+
+
+
+

Benutzeroberflächen erstellen

+
+
+
+
+ Toolbar-Button hinzufügen
+
+ Einen Button zur Firefox-Toolbar hinzufügen.
+
+ Hauptmenü erweitern
+
+ Items den Hauptmenüs von Firefox hinzufügen.
+
+
+
+
+
+ Popups anzeigen
+
+ Einen Popup-Dialog unter Verwendung von HTML und JavaScript anzeigen.
+
+ Kontextmenü erweitern
+
+ Items dem Kontextmenü von Firefox hinzufügen.
+
+
+
+
+

Interagieren mit dem Browser

+
+
+
+
+ Webseiten öffnen
+
+ Mit Hilfe des tabs-Moduls eine Seite in einem neuen Tab oder einem neuen Fenster öffnen und auf deren Inhalt zugreifen.
+
+ Auf das Laden von Webseiten reagieren
+
+ Mit dem tabs-Modul erkennen, wenn neue Webseiten geladen werden und auf deren Inhalte zugreifen.
+
+
+
+
+
+ Geöffnete Tabs auflisten
+
+ Mit dem tabs-Modul geöffnete Tabs auflisten und auf ihre Inhalte zugreifen.
+
+
+
+
+

Inhalte von Webseiten bearbeiten

+
+
+
+
+ Webseiten basierend auf deren URL bearbeiten
+
+ URL-Filter für Webseiten erstellen und ein Script darin ausführen, sobald eine Seite geladen wird, deren URL mit einer URL im Filter übereinstimmt.
+
+
+
+
+
+ Aktive Webseite bearbeiten
+
+ Ein Script dynamisch in der aktuell aktiven Website ausführen.
+
+
+
+
+

Entwicklungstechnologien

+
+
+
+
+ Loggen
+
+ Nachrichten auf der Konsole für Diagnosezwecke ausgeben.
+
+ Wiederverwendbare Module erstellen
+
+ Gliedere dein Add-on in einzelne Module und erleichtere somit das Entwickeln, Debuggen und Erhalten des Add-ons. Erstelle wiederverwendbare Pakete, die deine Module enthalten, damit auch andere Add-on-Entwickler diese verwenden können.
+
+ Testen der Bestandteile
+
+ Erstellen und Ausführen von Tests mit dem SDK-test-Framework.
+
+ Chrome-Autorität
+
+ Erhalte Zugriff auf das Components-Objekt und erlaube deinem Add-on XPCOM-Objekte zu laden und zu verwenden.
+
+ Erstellen von benutzerdefinierten Events
+
+ Erlaube deinen erstellten Objekten, eigene Events auszugeben.
+
+
+
+
+
+ Auf das Starten und Beenden des Add-ons reagieren
+
+ Werde benachrichtigt, wenn ein Add-on von Firefox gestartet oder beendet wird und übergebe Argumente an das Add-on über die Kommandozeile.
+
+ Module von Drittanbietern verwenden
+
+ Installation und Verwendung von zusätzlichen Modulen, die nicht im SDK enthalten sind.
+
+ Lokalisierung
+
+ Entwicklung lokalisierbarer Add-ons.
+
+ Entwicklung für mobile Endgeräte
+
+ Entwicklung von Add-ons für Firefox Mobile für Android.
+
+
+
+
+

Zusammenfassung

+
+
+
+
+ Add-on "Annotator"
+
+ Walk-through durch das Beispiel-Add-on "Annotator".
+
+
+
+

 

diff --git a/files/de/mozilla/add-ons/sdk/tutorials/installation/index.html b/files/de/mozilla/add-ons/sdk/tutorials/installation/index.html new file mode 100644 index 0000000000..28e899226e --- /dev/null +++ b/files/de/mozilla/add-ons/sdk/tutorials/installation/index.html @@ -0,0 +1,134 @@ +--- +title: Installation +slug: Mozilla/Add-ons/SDK/Tutorials/Installation +translation_of: Mozilla/Add-ons/SDK/Tools/jpm#Installation +--- +
+

Die cfx Installation ist veraltet. Sie sollten stattdessen  jpm benutzen.

+ +

Mehr Informationen finden Sie unter JPM replaces CFX for Firefox 38.

+
+ +

Vorraussetzungen

+ +

Um mit dem Add-on SDK zu entwickeln, brauchen Sie:

+ + + +

Installation

+ +

Installation auf FreeBSD/ OS X / Linux

+ +

Entpacken Sie die Dateien an einen beliebigen Ort und navigieren Sie mit einer Kommandozeile/Shell in das Stammverzeichnis der SDK. Zum Beispiel so:

+ +
tar -xf addon-sdk.tar.gz
+cd addon-sdk
+
+ +

Danach aktivieren Sie so die SDK, wenn Sie ein Bash Benutzer sind (was die meisten sind):

+ +
source bin/activate
+
+ +

Als nicht-Bash Benutzer, müssen Sie folgenden Befehl verwenden:

+ +
bash bin/activate
+
+ +

In Ihrer Eingabeaufforderung sollten Sie jetzt einen neuen Prefix haben, der den Namen des SDK's root Verzeichniss hat:

+ +
(addon-sdk)~/mozilla/addon-sdk >
+
+ +

Installation auf Mac mit Homebrew

+ +

Falls Sie ein Mac Benutzer sind, können Sie die SDK auch mithilfe von Homebrew und dem folgenden Befehl installieren:

+ +
brew install mozilla-addon-sdk
+ +

Sobald die Installation erfolgreich abgeschlossen wurde, können Sie das cfx Programm jederzeit in der Kommandozeile verwenden und benötigen keine vorherige Aktivierung.

+ +

Installation auf Windows

+ +

Entpacken Sie die Dateien an einen beliebigen Ort und navigieren Sie mit einer Kommandozeile/Shell in das Stammverzeichnis der SDK. Zum Beispiel so:

+ +
7z.exe x addon-sdk.zip
+cd addon-sdk
+
+ +

Dann führen Sie folgenden Befehl aus:

+ +
bin\activate
+
+ +

In Ihrer Eingabeaufforderung sollten Sie jetzt einen neuen Prefix haben, der den Namen des SDK's root Verzeichniss hat:

+ +
(C:\Users\mozilla\sdk\addon-sdk) C:\Users\Work\sdk\addon-sdk>
+
+ +

Plausibilitätsprüfung

+ +

Rufen Sie diesen Befehl in einer Kommandozeile auf:

+ +
cfx
+
+ +

Es sollte eine Meldung produzieren, die in etwa so aussieht, gefolgt von einer Auflistung der Benutzungsoptionen:

+ +
Usage: cfx [options] [command]
+
+ +

Das ist das cfx Kommandozeilen Programm. Es ist ihr primäres Interface für das Add-on SDK. Damit können Sie Firefox starten und ihr Add-on testen, ihr Add-on zur Veröffentlichung verpacken, sich Dokumentationen ansehen und Unit tests durchführen.

+ +

Nächste Schritte

+ +

Schauen Sie sich als nächstes das Tutorial  Getting Started With cfx an, das erklärt, wie man ein Add-on mit dem CFX Tool erstellt.

+ +

Fortgeschrittene Themen

+ +

Das SDK von Git verwenden

+ +

Die SDK wurde in GitHub entwickelt. Statt das verpackte Release zu verwenden, können Sie von GitHub repository den letzten Entwicklungsstand, statt dem offiziellen Release verwenden.

+ +

Wenn Sie den letzten Entwicklungsstand verwenden, benötigen Sie eine Nightly Version von Firefox und Sie können keine Add-ons bei addons.mozilla.org (AMO) einreichen, da AMP den offiziellen Release vorraussetzt.

+ +

Erweiterungen für AMO von Git Quellen entwickeln

+ +

Zum Einreichein bei AMO können nur der neuste git release tag für die Add-On SDK Quelldateien benutzt werden.

+ +

Der Gitarchivbefehl wird benötigt um ein Paar  Git Atrributplatzhalter im Git Klonverzeichnis zu erweitern.

+ +

git checkout 1.16

+ +

git archive 1.16 python-lib/cuddlefish/_version.py | tar -xvf -

+ +

Permanente Aktivierung

+ +

Sie können die Aktivierung permanent machen, in dem Sie die Variablen in ihrer Umgebung permanent setzen, so dass jede Eingabeaufforderung sie lesen kann. In diesem Fall müssen nicht jedesmal den activate Befehl verwenden, sobald Sie eine neue Eingabeaufforderung öffnen.

+ +

Da sich die Anzahl der zu setzenden Variable mit jeder neuen Version des SDK ändern kann, ist es am Besten sich nach den jeweiligen Aktivierungsskripten zu richten um Festzustellen welche Variablen verwendet werden. Die Aktivierung benutzt verschieden Skripte für Bashumgebungen (Linux und OS X) und Windowsumgebungen.

+ +

Windows

+ +

Bei Windows, benutzt bin\activate die activate.bat Datei. Sie können die Aktivierung permanent machen, indem Sie in der Kommandozeile das setx tool verwenden.

+ +

Linux / OS X

+ +

Auf Linux und OS X benutz source bin/activate das activate bash Skript. Die Aktivierung kann per ~/.bashrc (Linux) oder ~/.bashprofile (OS X) Permanent gemacht werden.

+ +

Eine Alternative ist das Erstellen eines symbolischen Links im Ordner ~/bin, der auf das cfx Programm verweist:

+ +
ln -s PATH_TO_SDK/bin/cfx ~/bin/cfx
+
+ +

Falls Sie Homebrew zur Installation des SDKs verwenden, werden die Umgebungsvariablen bereits permanent für Sie gesetzt.

+ +

activate

+ +

Der activate Befehl setzt Umgebungsvariablen, die zur Nutzung der SDK nötig sind. Er setzt die Variablen nur für die aktuelle Kommandozeile. Das heisst, wenn Sie eine neue Kommandozeile öffnen, müssen Sie den Befehl erneut ausführen, bevor Sie die SDK wieder benutzen können.

+ +

Das bedeutet, dass Sie mehrere Kopien der SDK an verschiedenen Orten ihrer Festplatte haben können und zwischen diesen wechseln können, oder sogar gleichzeitig in verschiedenen Eingabeaufforderungen aktiviert haben können.

diff --git a/files/de/mozilla/add-ons/sdk/tutorials/mobile_development/index.html b/files/de/mozilla/add-ons/sdk/tutorials/mobile_development/index.html new file mode 100644 index 0000000000..9d33162519 --- /dev/null +++ b/files/de/mozilla/add-ons/sdk/tutorials/mobile_development/index.html @@ -0,0 +1,476 @@ +--- +title: Developing for Firefox Mobile +slug: Mozilla/Add-ons/SDK/Tutorials/Mobile_development +translation_of: Archive/Add-ons/Add-on_SDK/Tutorials/Mobile_development +--- +
+

Developing add-ons for Firefox Mobile is still an experimental feature of the SDK. Although the SDK modules used are stable, the setup instructions and cfx commands are likely to change.

+
+
+

To follow this tutorial you'll need to have installed the SDK and learned the basics of cfx.

+
+

Firefox for Android implements its UI using native Android widgets instead of XUL. With the add-on SDK you can develop add-ons that run on this new version of Firefox Mobile as well as on the desktop version of Firefox.

+

You can use the same code to target both desktop Firefox and Firefox Mobile, and just specify some extra options to cfx run, cfx test, and cfx xpi when targeting Firefox Mobile.

+

Right now not all modules are fully functional, but we're working on adding support for more modules. The tables at the end of this guide list the modules that are currently supported on Firefox Mobile.

+

This tutorial explains how to run SDK add-ons on an Android device connected via USB to your development machine. We'll use the Android Debug Bridge (adb) to communicate between the Add-on SDK and the device.

+

+

It's possible to use the Android emulator to develop add-ons for Android without access to a device, but it's slow, so for the time being it's much easier to use the technique described below.

+

Setting up the Environment

+

First you'll need an Android device capable of running the native version of Firefox Mobile. Then:

+ +

On the development machine:

+ +

Next, attach the device to the development machine via USB.

+

Now open up a command shell. Android Platform Tools will have installed adb in the "platform-tools" directory under the directory in which you installed the Android SDK. Make sure the "platform-tools" directory is in your path. Then type:

+
adb devices
+
+

You should see some output like:

+
List of devices attached
+51800F220F01564 device
+
+

(The long hex string will be different.)

+

If you do, then adb has found your device and you can get started.

+

Running Add-ons on Android

+

You can develop your add-on as normal, as long as you restrict yourself to the supported modules.

+

When you need to run the add-on, first ensure that Firefox is not running on the device. Then execute cfx run with some extra options:

+
cfx run -a fennec-on-device -b /path/to/adb --mobile-app fennec --force-mobile
+
+

See "cfx Options for Mobile Development" for the details of this command.

+

In the command shell, you should see something like:

+
Launching mobile application with intent name org.mozilla.fennec
+Pushing the addon to your device
+Starting: Intent { act=android.activity.MAIN cmp=org.mozilla.fennec/.App (has extras) }
+--------- beginning of /dev/log/main
+--------- beginning of /dev/log/system
+Could not read chrome manifest 'file:///data/data/org.mozilla.fennec/chrome.manifest'.
+info: starting
+info: starting
+zerdatime 1329258528988 - browser chrome startup finished.
+
+

This will be followed by lots of debug output.

+

On the device, you should see Firefox launch with your add-on installed.

+

console.log() output from your add-on is written to the command shell, just as it is in desktop development. However, because there's a lot of other debug output in the shell, it's not easy to follow. The command adb logcat prints adb's log, so you can filter the debug output after running the add-on. For example, on Mac OS X or Linux you can use a command like the below to filter only the lines of console output:

+
adb logcat | grep console
+
+

You can experiment with different filter strings on adb logcat to focus in on the lines relevant to you.

+

Running cfx test is identical:

+
cfx test -a fennec-on-device -b /path/to/adb --mobile-app fennec --force-mobile
+
+

cfx Options for Mobile Development

+

As you see in the quote above, cfx run and cfx test need four options to work on Android devices.

+ + + + + + + + + + + + + + + + + + + + + + + +
-a fennec-on-deviceThis tells the Add-on SDK which application will host the add-on, and should be set to "fennec-on-device" when running an add-on on Firefox Mobile on a device.
-b /path/to/adb +

As we've seen, cfx uses the Android Debug Bridge (adb) to communicate with the Android device. This tells cfx where to find the adb executable.

+

You need to supply the full path to the adb executable.

+
--mobile-app +

This is the name of the Android intent. Its value depends on the version of Firefox Mobile that you're running on the device:

+
    +
  • fennec: if you're running Nightly
  • +
  • fennec_aurora: if you're running Aurora
  • +
  • firefox_beta: if you're running Beta
  • +
  • firefox: if you're running Release
  • +
+

If you're not sure, run a command like this (on OS X/Linux, or the equivalent on Windows):

+
+adb shell pm list packages | grep mozilla
+

You should see "package" followed by "org.mozilla." followed by a string. The final string is the name you need to use. For example, if you see:

+
+package:org.mozilla.fennec
+

...then you need to specify:

+
+--mobile-app fennec
+

This option is not required if you have only one Firefox application installed on the device.

+
--force-mobile +

This is used to force compatibility with Firefox Mobile, and should always be used when running on Firefox Mobile.

+
+

Packaging Mobile Add-ons

+

To package a mobile add-on as an XPI, use the command:

+
cfx xpi --force-mobile
+
+

Actually installing the XPI on the device is a little tricky. The easiest way is probably to copy the XPI somewhere on the device:

+
adb push my-addon.xpi /mnt/sdcard/
+
+

Then open Firefox Mobile and type this into the address bar:

+
file:///mnt/sdcard/my-addon.xpi
+
+

The browser should open the XPI and ask if you want to install it.

+

Afterwards you can delete it using adb as follows:

+
adb shell
+cd /mnt/sdcard
+rm my-addon.xpi
+
+

+

Module Compatibility

+

Modules not supported in Firefox Mobile are marked in the tables below.

+

High-Level APIs

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
addon-pageNot supported
base64Supported
clipboardNot supported
context-menuNot supported
hotkeysSupported
indexed-dbSupported
l10nSupported
notificationsSupported
page-modSupported
page-workerSupported
panelNot supported
passwordsSupported
private-browsingNot supported
querystringSupported
requestSupported
selectionNot supported
selfSupported
simple-prefsSupported
simple-storageSupported
systemSupported
tabsSupported
timersSupported
uiNot supported
urlSupported
widgetNot supported
windowsSupported
+

Low-Level APIs

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
loaderSupported
chromeSupported
console/plain-textSupported
console/tracebackSupported
content/contentSupported
content/loaderSupported
content/modSupported
content/workerSupported
core/heritageSupported
core/namespaceSupported
core/promiseSupported
event/coreSupported
event/targetSupported
frame/hidden-frameSupported
frame/utilsSupported
io/byte-streamsSupported
io/fileSupported
io/text-streamsSupported
lang/functionalSupported
lang/typeSupported
loader/cuddlefishSupported
loader/sandboxSupported
net/urlSupported
net/xhrSupported
places/bookmarksNot supported
places/faviconNot supported
places/historyNot supported
platform/xpcomSupported
preferences/serviceSupported
stylesheet/styleSupported
stylesheet/utilsSupported
system/environmentSupported
system/eventsSupported
system/globalsSupported
system/runtimeSupported
system/unloadSupported
system/xul-appSupported
tabs/utilsSupported
test/assertSupported
test/harnessSupported
test/httpdSupported
test/runnerSupported
test/utilsSupported
ui/button/actionNot supported
ui/button/toggleNot supported
ui/frameNot supported
ui/idSupported
ui/sidebarNot supported
ui/toolbarNot supported
util/arraySupported
util/collectionSupported
util/deprecateSupported
util/listSupported
util/match-patternSupported
util/objectSupported
util/uuidSupported
window/utilsSupported
+

 

diff --git a/files/de/mozilla/add-ons/security_best_practices_in_extensions/index.html b/files/de/mozilla/add-ons/security_best_practices_in_extensions/index.html new file mode 100644 index 0000000000..689a9b9679 --- /dev/null +++ b/files/de/mozilla/add-ons/security_best_practices_in_extensions/index.html @@ -0,0 +1,80 @@ +--- +title: Sicherheitsleitfaden bei Erweiterungen +slug: Mozilla/Add-ons/Security_best_practices_in_extensions +tags: + - Add-ons + - Anleitung + - Erweiterungen + - Leitfaden + - Sicherheit +translation_of: Archive/Add-ons/Security_best_practices_in_extensions +--- +

{{ draft() }}

+ +

Dieses Dokument ist dazu gedacht, für Entwickler als Leitfaden zu bestmöglichen Vorgensweisen bei der Absicherung ihrer Erweiterung zu dienen. Dein Ziel ist es, deine Nutzer zu schützen. Einige Einträge sind strikte Richtlinien, was Bedeutet, dass wenn Du diesen nicht folgst, dein Add-On im Gegenzug auf Mozilla Add-Ons nicht akzeptiert wird. Andere Einträge sind Empfehlungen. Der Unterschied wird klar gekennzeichnet.

+ +

Es ist aus der Perspektive einer Firefox Erweiterung geschrieben, aber die meisten Einträge beziehen sich auf Erweiterungen für andere Mozilla-basierte Applikationen wie Thunderbird oder SeaMonkey.

+ +

Handhabung von Webinhalten

+ +

Im Allgemeinen ist der beste Weg sicherzustellen, dass der Browser beim Laden von Inhalten nicht kompromittiert wird, dafür zu sorgen, dass diese keine entsprechenden Rechte haben. Eine detailliertere Erklärung dieses Prozesses findet sich unter Webinhalte ohne Sicherheitsprobleme in einer Erweiterung anzeigen.

+ +

Die Rechte, die ein Dokument bekommt, hängen auch davon ab, wo es herkommt.  Zum Beispiel: Wenn Du eine chrome URL lädst, bedeutet es, dass der Inhalt in Firefox registriert wurde und vollen Zugriff hat. Inhalt von einer Domain (wie http://example.com) kann nur auf die gleiche Domain zugreifen. Über das File Protocol geladene Dateien können auf solche zugreifen, die auf der Festplatte und anderen lokalen Datenträgern liegen. Es gibt Wege, die content/chrome Sicherheitsbarriere zu umgehen, falls Du zum Beispiel möchtest, dass eine Webseite eine Notifikation an ein Add-On sendet (oder umgekehrt). Ein Weg das zu tun ist es, eigene DOM Events zu nutzen; siehe Interaktionen zwischen priviligierten und nicht-priviligierten Seiten.

+ +

Unabhängig davon, wo das Dokument herkommt, kannst du weiter Beschränken, was es kann, indem du Eigenschaften zum Dokumentenhalter - auch bekannt als docshell - zuweist.

+ +

frame.docShell.allowImages = false;
+ frame.docShell.allowJavascript = false;
+ frame.docShell.allowPlugins = false;

+ +

Es gibt mehr Beispiele in dem oben gelisteten Dokument. Unter gewissen Umständen möchte man Code in der Erweiterung ausführen, allerdings solltest du ihm eingeschränkte Rechte geben. Einer der besten Wege das zu tun ist Components.utils.evalInSandbox() zu nutzen. Beachte, dass Objekte, die an die Sandbox weitergegeben werden, eingeschränkt sind, aber solche, die wieder herauskommen es nicht sind. Nimm Bezug auf den Artikel, um herauszufinden, wie du solche Tücken vermeidest. Für weitere Informationen, siehe den Abschnitt evalInSandbox.

+ +

Die Sidebar: Ein Anwendungsfall

+ +

Die Sidebar in Firefox ist dafür gestaltet, sowohl chrome (priviligierte) Inhalte, als auch Web (nichtpriviligierte) Inhalte zu beinhalten - letzteres in Form von Webseiten. Diese Webseiten können von einem Server oder von lokalen HTML Dateien, die mit der Erweiterung gekommen sind, stammen. Für Seiten, die vom Server kommen, musst du Schritte vornehmen, um zu sicherzustellen, dass die Inhalte nicht in den Browser rückrufen und Schadcode ausführen. Hauptsächlich wird dies bewerkstelligt, indem man ein Iframe- oder Browserelement in der Sidebar erstellt und dort die Inhalte lädt. Gebe dem Inhalt ein type="content" Attribut, welches den Code im Wesentlichen sandboxed und alle Rückrufe direkt nach chrome blockiert.

+ +

eval() in einer Erweiterung nutzen

+ +

Das Nutzen der eingebauten JavaScript Funktion {{jsxref("eval")}} ist im Kontext von Erweiterungen verpönt. Während es einige Fälle gibt, in denen die Nutzung legitim ist, gibt es meist sicherere Alternativen. Dieser Blogeintrag bietet einige exzellente Beispiele, warum man eval() nicht nutzen sollte.

+ +

Gesandboxte HTTP Verbindungen

+ +

Der Hauptzweck von gesandboxten HTTP Verbindungen ist es, mit einem Webdienst zu kommunizieren, ohne mit im Browser zu der Website/dem Service gesetzten Cookies zu interferieren. Wenn Du zum Beispiel Fotos oder andere Daten von einer photo sharing Seite lädst, kannst du die Verbindungen sandboxen, sodass normales Surfen des Nutzers auf der Webseite nicht beeinflusst wird. Für einen echten Anwendungsfall, siehe diesen Blogeintrag.

+ +

Umgang mit Logins und Passwörtern

+ +

Es gibt viele Möglichkeiten, Daten in Firefox zu speichern, aber für Logins und Passwörter, solltest Du den Login Manager nutzen. Das ist der gleiche Speicher, welcher Logins von Webseiten beinhaltet und Passwörter können nur abgerufen werden, indem die Kombination von Seite/Username dem Author bekannt sind. Die Gepflogenheit für Erweiterungen ist es, eine chrome URL als den Seitenidentifikator zu nutzen, um Konflikte mit Logins für Seiten zu verhindern. Es könnte der Fall sein, dass deine Erweiterung ein anderes Werkzeug oder andere Werkzeuge für Dienste auf deiner Seite anbietet.

+ +

Diese Herangehensweise ist vorzuziehen, da es den Nutzern eine gewohnte Oberfläche für die Interaktion mit Logins über den Firefox Passwort Manager bietet. Wenn Nutzer Logins über die "Neueste Chronik löschen" Option säubern, wird das die Daten deiner Erweiterung miteinbeziehen.

+ +

APIs und Umgang mit anderen Daten

+ +

Web Inhalte sind mehr als nur Seiten, und mehr und mehr Add-Ons interagieren über das Application Programming Interfae (API) mit Webdiensten.

+ + + +

Remote Javascript und -Inhalte

+ +

Es gibt eine Zahl von Arten, wie Remotescripte in Erweiterungen genutzt werden können. Sie können in Inhalten eingebettet oder in Intervallen heruntergeladen werden.

+ +

Nicht-chrome URLs in chrome XUL oder HTML, so wie im folgenden Beispiel sind nicht erlaubt:

+ +

<script type="text/javascript" src="http://mysite.greatsite.com/js/wow-content.js" />

+ +

Im Allgemeinen sind Skripte von Remotequellen, die im Kontext von chrome laufen, nicht akzeptabel, da die Quelle der Skripte nie zu 100% garantiert werden kann und sie für Man-In-The-Middle Attacken empfindlich sind. Die einzig legitime Umgebung für Remoteskripte ist es, in einer Sandbox zu laufen. Für mehr Informationen, siehe die Sektion evalInSandbox().

+ +

evalInSandbox

+ +

Das evalInSandbox Dokument erklärt die Funktion ziemlich gut, also wird es hier keine Wiederholung geben. Die Nützlichkeit und Kraft der Funktionsweise wird von der beliebten Erweiterung Greasemonkey veranschaulich, welche unter der Prämisse arbeitet, dass Skripte heruntergeladen und gespeichert werden, um im Kontext von Webinhalten via der Sandbox injiziert zu werden. Viele Erweiterungen nutzen den Greasemonkey compiler, um die Funktion aus Bequemlichkeit in ihrer Erweiterung zu bündeln. Wenn Du dich entscheidest das zu tun, sei vorsichtig beim Editieren von gebündelten Dateien, insofern als, gut durchdachte Sicherheitsarchitekturen nicht zu verletzen.

+ +

Drittanbieter JavaScript

+ +

Im Kontext von Webseiten, ist das Nutzen von JavaScripten, welche von anderen geschrieben wurden sehr geläufig. Auch in Add-Ons ist es nicht unbekannt und kann einen nützlichen Weg darstellen, um Codewiederholungen zu vermeiden und die Entwicklung zu beschleunigen. Dieser Artikel ist über Webseiten, aber liefert einige Einsichten in generelle Risiken. Wenn Du andere Skripte einbettest, gibt es eine Reihe von Dingen, die du tun kannst, um ihre Integrität und Sicherheit für Nutzer zu gewährleisten. Als erstes, es immer von einer glaubwürdigen Quelle zu beziehen. Eine andere Sache, die du tun solltest, ist das Namespacen, nur für den Fall, dass andere Add-Ons es inkludieren. Zum Beispiel, wenn Du jQuery nutzt, gibt es da jQuery.noConflict().

+ +

Fazit

+ +

Sicherheit kann nicht als selbstverständlich angesehen werden und jede Veröffentlichung deines Add-Ons, sollte es eine neue Sicherheitsprüfung geben. Ein guter Ort, um mit Mozillas Sicherheitsmeldungen und Sicherheitsdiskussionen mitzuhalten, ist im  Mozilla Security Blog.

diff --git a/files/de/mozilla/add-ons/themes/obsolete/index.html b/files/de/mozilla/add-ons/themes/obsolete/index.html new file mode 100644 index 0000000000..d420b6ebf0 --- /dev/null +++ b/files/de/mozilla/add-ons/themes/obsolete/index.html @@ -0,0 +1,10 @@ +--- +title: Obsolete +slug: Mozilla/Add-ons/Themes/Obsolete +tags: + - NeedsTranslation + - TopicStub +translation_of: Mozilla/Add-ons/Themes/Obsolete +--- +

This page collects theme docs that we don't expect will ever be updated, but which we're keeping for the time being as potential source material for updated docs.

+

{{ ListSubPages ("/en-US/Add-ons/Themes/Obsolete", 5) }}

diff --git a/files/de/mozilla/add-ons/webextensions/anatomy_of_a_webextension/index.html b/files/de/mozilla/add-ons/webextensions/anatomy_of_a_webextension/index.html new file mode 100644 index 0000000000..04bd9d08b5 --- /dev/null +++ b/files/de/mozilla/add-ons/webextensions/anatomy_of_a_webextension/index.html @@ -0,0 +1,133 @@ +--- +title: Aufbau einer WebExtension +slug: Mozilla/Add-ons/WebExtensions/Anatomy_of_a_WebExtension +translation_of: Mozilla/Add-ons/WebExtensions/Anatomy_of_a_WebExtension +--- +
{{AddonSidebar}}
+ +

Eine Extension (Erweiterung) beinhaltet eine Sammlung von Dateien, gepackt für die Verbreitung and Installation. In diesem Artikel, gehen wir kurz auf Dateien ein, die vorhanden sein könnten.

+ +

manifest.json

+ +

"manifest.json" ist die einzige Datei, die in jeder Extension vorhanden sein muss. Sie enthält die grundlegenden Metadaten wie Name, Version und benötigte Genehmigungen. Außerdem verweist sie auf andere Dateien der Extension.

+ +

Dieses Manifest kann auch Zeiger zu mehreren anderen Dateitypen haben:

+ + + +

+ +

Für weitere Einzelheiten gehe auf manifest.json.

+ +

Neben den vom Manifest referenzierten Seiten, kann eine Extension zusätzlche Extension pages mit unterstützenden Dateien enthalten.

+ +

Hintergrundskripte

+ +

Extensions müssen oft langzeitig ihren Zustand aufrechterhalten oder Operationen, unabhängig der Lebensdauer von irgendwelchen speziellen Webseiten oder Browserfenstern, durchführen. Dafür gibt es Hintergrundskripte (background scripts).

+ +

Hintergrundskripte werden geladen, sobald die Extension geladen ist und laufen bis die Extension deaktiviert oder deinstalliert wird. Du kannst alles aus den WebExtension APIs im Skript benutzen, solange du die notwendigen Berechtigungen abgefragt hast.

+ +

Hintergrundskripte festlegen

+ +

Du kannst ein Hintergrundskript einbinden in dem du den background-Key in "manifest.json" benutzt:

+ +
// manifest.json
+
+"background": {
+  "scripts": ["background-script.js"]
+}
+ +

Du kannst mehrere background scripts angeben: wenn du sie im selben Kontext laufen lässt, so wie mehrere Skripts, die in eine einzelne Seite geladen werden.

+ +

Hintergrundskript-Umgebung

+ +

DOM APIs

+ +

Hintergrundskripte laufen im Rahmen spezieller Seiten genannt 'background pages' (Hintergrundseiten). Diese geben ihnen ein globales window, samt der vollständigen Standard DOM APIs, die von diesem Objekt bereitgestellt werden.

+ +

Du musst deine Hintergrundseite nicht bereitstellen. Wenn du dein Hintergrundskript hinzufügst, wird eine leere Hintergrundseite für dich erstellt.

+ +

Dennoch kannst du deine Hintergrundseite auch als separate HTML-Datei erstellen:

+ +
// manifest.json
+
+"background": {
+  "page": "background-page.html"
+}
+ +

WebExtension APIs

+ +

Hintergrundskripte können alles aus den WebExtension APIs im Skript nutzen, solange deren Extension die notwendigen Berechtigungen hat.

+ +

Cross-origin access

+ +

Hintergrundskripte können XHR-Anfragen an alle Hosts machen, für die sie host permissions haben.

+ +

Web content

+ +

Hintergrundskripte haben keinen direkten Zugriff auf Webseiten. Sie können jedoch Content-Scripts in Webseiten laden und mit ihnen über message-passing API kommunizieren.

+ +

Content security policy

+ +

Hintergrundskripte sind beschränkt in einigen potenziell gefährlichen Operationen, wie dem Benutzen von eval(), durch ein Sicherheitskonzept. Für mehr Informationen siehe Content Security Policy.

+ + + +

Deine Extension kann unterschiedliche Benutzeroberflächenkomponenten enthalten, deren Inhalt wird durch ein HTML-Dokument festgelegt:

+ + + +

Für jeden dieser Komponenten, erstellst du eine HTML-Datei und verweist auf sie über ein spezielles Attribut in manifest.json. Die HTML-Datei kann, wie eine normale Webseite, CSS- und JavaScript-Dateien einbinden.

+ +

Sie alle sind Arten von Extension pages, und nicht wie eine normale Webseite, dein JavaScript kann dieselben WebExtension APIs wie dein Hintergrundskript benutzen. Sie können sogar direkt Variabeln aus der Hintergrundseite, mit {{WebExtAPIRef("runtime.getBackgroundPage()")}}, abrufen.

+ +

Extension pages

+ +

Du kannst außerdem HTML-Dokumente in deine Extension mit einbeziehen, die nicht vordefinierten Benutzeroberflächenkomponenten beigefügt wurden. Anders als die Dokumente, die du für Sidebars, Pop-ups, oder Option-Pages bereitstellen könntest, haben diese keinen Zugang zu "manifest.json". Dennoch haben sie Zugriff auf dieselben WebExtension APIs wie dein Hintergrundskript.

+ +

Du lädst eine solche Seite normalerweise mit {{WebExtAPIRef("windows.create()")}} oder {{WebExtAPIRef("tabs.create()")}}.

+ +

Siehe Extension pages um mehr zu lernen.

+ +

Content scripts

+ +

Benutze Content-Scripts um Webseiten abzurufen und zu manipulieren. Content-Scripts werden in Webseiten geladen und laufen im Rahmen der jeweiligen Seite.

+ +

Content-Scripts sind von der Erweiterung bereitgestellte Skripts, die im Kontext einer Webseite laufen; das unterscheidet sie von Skripts, die von der Seite selber geladen werden, einschließlich derer, die in {{HTMLElement("script")}}-Elementen innerhalb der Seite bereitgestellt werden.

+ +

Content-Scripts können das Seiten-DOM sehen und manipulieren, so wie normale, von der Seite geladene Skripte.

+ +

Im Gegensatz zu normalen Skripten können sie:

+ + + +

Content-Scripts können nicht direkt normale Skripte der Seite abrufen, aber mit ihnen Nachrichten austauschen über die übliche window.postMessage() API.

+ +

Wenn wir gewöhnlich über Content-Scripts sprechen, dann im Bezug auf JavaScript. Du kannst jedoch auch CSS zu einer Webseite über das selbe System hinzufügen.

+ +

Sieh dir content scripts an um mehr zu erfahren.

+ +

Web accessible resources

+ +

Zugängliche Webressourcen(Web accessible resources) sind Ressourcen wie Bilder, HTML, CSS, und JavaScript, die du in die Extension einbindest und für Content-Scripts und Skripten der Seite zugänglich machen möchtest. Ressourcen, die web-zugänglich gemacht werden, können von Skripten der Seite und Content-Scripts über ein spezielles URI-Schema referenziert werden.

+ +

Wenn zum Beispiel ein Content-Script Bilder in eine Webseite einfügen will, kannst du sie in der Extension beifügen und web-zugänglich machen. Dann könnte das Content-Script img-Tags erzeugen und hinzufügen, die über das src-Attribut auf die Bilder verweisen.

+ +

Um mehr zu lernen, sieh die Dokumentation für den web_accessible_resources manifest.json key.

+ +

 

+ +

 

diff --git a/files/de/mozilla/add-ons/webextensions/api/browseraction/index.html b/files/de/mozilla/add-ons/webextensions/api/browseraction/index.html new file mode 100644 index 0000000000..184dccf3d6 --- /dev/null +++ b/files/de/mozilla/add-ons/webextensions/api/browseraction/index.html @@ -0,0 +1,135 @@ +--- +title: browserAction +slug: Mozilla/Add-ons/WebExtensions/API/browserAction +tags: + - API + - Add-ons + - Extensions + - Interface + - NeedsTranslation + - Non-standard + - Reference + - TopicStub + - WebExtensions + - browserAction +translation_of: Mozilla/Add-ons/WebExtensions/API/browserAction +--- +
{{AddonSidebar}}
+ +

Adds a button to the browser's toolbar.

+ +

A browser action is a button in the browser's toolbar.

+ +

You can associate a popup with the button. The popup is specified using HTML, CSS and JavaScript, just like a normal web page. JavaScript running in the popup gets access to all the same WebExtension APIs as your background scripts, but its global context is the popup, not the current page displayed in the browser. To affect web pages you need to communicate with them via messages.

+ +

If you specify a popup, it will be shown — and the content will be loaded — when the user clicks the icon. If you do not specify a popup, then when the user clicks the icon an event is dispatched to your extension.

+ +

You can define most of a browser action's properties declaratively using the browser_action key in the manifest.json.

+ +

With the browserAction API, you can:

+ + + +

Types

+ +
+
{{WebExtAPIRef("browserAction.ColorArray")}}
+
An array of four integers in the range 0-255 defining an RGBA color.
+
{{WebExtAPIRef("browserAction.ImageDataType")}}
+
Pixel data for an image. Must be an ImageData object (for example, from a {{htmlelement("canvas")}} element).
+
+ +

Functions

+ +
+
{{WebExtAPIRef("browserAction.setTitle()")}}
+
Sets the browser action's title. This will be displayed in a tooltip.
+
{{WebExtAPIRef("browserAction.getTitle()")}}
+
Gets the browser action's title.
+
{{WebExtAPIRef("browserAction.setIcon()")}}
+
Sets the browser action's icon.
+
{{WebExtAPIRef("browserAction.setPopup()")}}
+
Sets the HTML document to be opened as a popup when the user clicks on the browser action's icon.
+
{{WebExtAPIRef("browserAction.getPopup()")}}
+
Gets the HTML document set as the browser action's popup.
+
{{WebExtAPIRef("browserAction.openPopup()")}}
+
Open the browser action's popup.
+
{{WebExtAPIRef("browserAction.setBadgeText()")}}
+
Sets the browser action's badge text. The badge is displayed on top of the icon.
+
{{WebExtAPIRef("browserAction.getBadgeText()")}}
+
Gets the browser action's badge text.
+
{{WebExtAPIRef("browserAction.setBadgeBackgroundColor()")}}
+
Sets the badge's background color.
+
{{WebExtAPIRef("browserAction.getBadgeBackgroundColor()")}}
+
Gets the badge's background color.
+
{{WebExtAPIRef("browserAction.setBadgeTextColor()")}}
+
Sets the badge's text color.
+
{{WebExtAPIRef("browserAction.getBadgeTextColor()")}}
+
Gets the badge's text color.
+
{{WebExtAPIRef("browserAction.enable()")}}
+
Enables the browser action for a tab. By default, browser actions are enabled for all tabs.
+
{{WebExtAPIRef("browserAction.disable()")}}
+
Disables the browser action for a tab, meaning that it cannot be clicked when that tab is active.
+
{{WebExtAPIRef("browserAction.isEnabled()")}}
+
Checks whether the browser action is enabled or not.
+
+ +

Events

+ +
+
{{WebExtAPIRef("browserAction.onClicked")}}
+
Fired when a browser action icon is clicked. This event will not fire if the browser action has a popup.
+
+ +

Browser compatibility

+ +

{{Compat("webextensions.api.browserAction")}}

+ + + +

{{WebExtExamples("h2")}}

+ +
Acknowledgements + +

This API is based on Chromium's chrome.browserAction API. This documentation is derived from browser_action.json in the Chromium code.

+ +

Microsoft Edge compatibility data is supplied by Microsoft Corporation and is included here under the Creative Commons Attribution 3.0 United States License.

+
+ + diff --git a/files/de/mozilla/add-ons/webextensions/api/browseraction/setpopup/index.html b/files/de/mozilla/add-ons/webextensions/api/browseraction/setpopup/index.html new file mode 100644 index 0000000000..2a4a40e794 --- /dev/null +++ b/files/de/mozilla/add-ons/webextensions/api/browseraction/setpopup/index.html @@ -0,0 +1,136 @@ +--- +title: browserAction.setPopup() +slug: Mozilla/Add-ons/WebExtensions/API/browserAction/setPopup +translation_of: Mozilla/Add-ons/WebExtensions/API/browserAction/setPopup +--- +
{{AddonSidebar()}}
+ +

Sets the HTML document that will be opened as a popup when the user clicks on the browser action's icon. Tabs without a specific popup will inherit the global popup, which defaults to the default_popup specified in the manifest.

+ +

Syntax

+ +
browser.browserAction.setPopup(
+  details // object
+)
+
+ +

Parameters

+ +
+
details
+
object.
+
+
+
tabId{{optional_inline}}
+
integer. Sets the popup only for a specific tab. The popup is reset when the user navigates this tab to a new page.
+
windowId{{optional_inline}}
+
integer. Sets the popup only for the specified window.
+
+ +
+
popup
+
+

string or null. The HTML file to show in a popup, specified as a URL.

+ +

This can point to a file packaged within the extension (for example, created using {{WebExtAPIRef("extension.getURL")}}), or a remote document (e.g. https://example.org/).

+ +

If an empty string ("") is passed here, the popup is disabled, and the extension will receive {{WebExtAPIRef("browserAction.onClicked")}} events.

+ +

If popup is null:

+ +

If tabId is specified, removes the tab-specific popup so that the tab inherits the global popup.

+ +

If windowId is specified, removes the window-specific popup so that the window inherits the global popup.

+ +

Otherwise it reverts the global popup to the default value.

+
+
+
+
+ + + +

Browser compatibility

+ + + +

{{Compat("webextensions.api.browserAction.setPopup",2)}}

+ +

Examples

+ +

This code adds a pair of context menu items that you can use to switch between two popups. Note that you'll need the "contextMenus" permission set in the extension's manifest to create context menu items.

+ +
function onCreated() {
+  if (browser.runtime.lastError) {
+    console.log("error creating item:" + browser.runtime.lastError);
+  } else {
+    console.log("item created successfully");
+  }
+}
+
+browser.contextMenus.create({
+  id: "popup-1",
+  type: "radio",
+  title: "Popup 1",
+  contexts: ["all"],
+  checked: true
+}, onCreated);
+
+browser.contextMenus.create({
+  id: "popup-2",
+  type: "radio",
+  title: "Popup 2",
+  contexts: ["all"],
+  checked: false
+}, onCreated);
+
+browser.contextMenus.onClicked.addListener(function(info, tab) {
+  if (info.menuItemId == "popup-1") {
+    browser.browserAction.setPopup({popup: "/popup/popup1.html"})
+  } else if (info.menuItemId == "popup-2") {
+    browser.browserAction.setPopup({popup: "/popup/popup2.html"})
+  }
+});
+ +

{{WebExtExamples}}

+ +
Acknowledgements + +

This API is based on Chromium's chrome.browserAction API. This documentation is derived from browser_action.json in the Chromium code.

+ +

Microsoft Edge compatibility data is supplied by Microsoft Corporation and is included here under the Creative Commons Attribution 3.0 United States License.

+
+ + diff --git a/files/de/mozilla/add-ons/webextensions/api/commands/index.html b/files/de/mozilla/add-ons/webextensions/api/commands/index.html new file mode 100644 index 0000000000..af45cea002 --- /dev/null +++ b/files/de/mozilla/add-ons/webextensions/api/commands/index.html @@ -0,0 +1,83 @@ +--- +title: commands +slug: Mozilla/Add-ons/WebExtensions/API/commands +translation_of: Mozilla/Add-ons/WebExtensions/API/commands +--- +
{{AddonSidebar}}
+ +

Verwenden Sie die Ausführungsbefehle der Benutzer, die Sie mit Hilfe des Schlüssels commands der manifest.json registriert haben.

+ +

Typen

+ +
+
{{WebExtAPIRef("commands.Command")}}
+
Objekt, das einen Befehl repräsentiert. Es enthält die für den Befehl im Schlüssel commands der manifest.json festgelegten Informationen.
+
+ +

Funktionen

+ +
+
{{WebExtAPIRef("commands.getAll")}}
+
+

Stellt alle registrierten Befehle für diese Erweiterung zur Verfügung.

+
+
{{WebExtAPIRef("commands.reset")}}
+
+

Angegebene Befehlsbeschreibung und das Tastaturkürzel auf die im Manifest-Schlüssel angegebenen Werte zurücksetzen.

+
+
{{WebExtAPIRef("commands.update")}}
+
+

Beschreibung oder Tastenkürzel des angegebenen Befehls ändern.

+
+
+ +

Ereignisse

+ +
+
{{WebExtAPIRef("commands.onCommand")}}
+
+
Wird ausgelöst, wenn ein Befehl mit Hilfe seines zugewiesenen Tastenkürzels ausgeführt wird.
+
+
+ +

Browserkompatibilität

+ +

{{Compat("webextensions.api.commands")}} {{WebExtExamples("h2")}}

+ +
Danksagungen + +

Diese API basiert auf der API chrome.commands von Chromium.

+ +

Die Kompatibilitätsdaten von Microsoft Edge werden von der Microsoft Corporation bereitgestellt und stehen hier unter der Lizenz Creative Commons Attribution 3.0 United States.

+
+ + diff --git a/files/de/mozilla/add-ons/webextensions/api/downloads/index.html b/files/de/mozilla/add-ons/webextensions/api/downloads/index.html new file mode 100644 index 0000000000..7363cde811 --- /dev/null +++ b/files/de/mozilla/add-ons/webextensions/api/downloads/index.html @@ -0,0 +1,123 @@ +--- +title: downloads +slug: Mozilla/Add-ons/WebExtensions/API/downloads +translation_of: Mozilla/Add-ons/WebExtensions/API/downloads +--- +
+ +

Enables extensions to interact with the browser's download manager. You can use this API module to download files, cancel, pause, resume downloads, and show downloaded files in the file manager.

+ +

To use this API you need to have the "downloads" API permission specified in your manifest.json file.

+ +

Types

+ +
+
{{WebExtAPIRef("downloads.FilenameConflictAction")}}
+
Defines options for what to do if the name of a downloaded file conflicts with an existing file.
+
{{WebExtAPIRef("downloads.InterruptReason")}}
+
Defines a set of possible reasons why a download was interrupted.
+
{{WebExtAPIRef("downloads.DangerType")}}
+
Defines a set of common warnings of possible dangers associated with downloadable files.
+
{{WebExtAPIRef("downloads.State")}}
+
Defines different states that a current download can be in.
+
{{WebExtAPIRef("downloads.DownloadItem")}}
+
Represents a downloaded file.
+
{{WebExtAPIRef("downloads.StringDelta")}}
+
Represents the difference between two strings.
+
{{WebExtAPIRef("downloads.DoubleDelta")}}
+
Represents the difference between two doubles.
+
{{WebExtAPIRef("downloads.BooleanDelta")}}
+
Represents the difference between two booleans.
+
{{WebExtAPIRef("downloads.DownloadTime")}}
+
Represents the time a download took to complete.
+
{{WebExtAPIRef("downloads.DownloadQuery")}}
+
Defines a set of parameters that can be used to search the downloads manager for a specific set of downloads.
+
+ +

Functions

+ +
+
{{WebExtAPIRef("downloads.download()")}}
+
Downloads a file, given its URL and other optional preferences.
+
{{WebExtAPIRef("downloads.search()")}}
+
Queries the {{WebExtAPIRef("downloads.DownloadItem", "DownloadItems")}} available in the browser's downloads manager, and returns those that match the specified search criteria.
+
{{WebExtAPIRef("downloads.pause()")}}
+
Pauses a download.
+
{{WebExtAPIRef("downloads.resume()")}}
+
Resumes a paused download.
+
{{WebExtAPIRef("downloads.cancel()")}}
+
Cancels a download.
+
{{WebExtAPIRef("downloads.getFileIcon()")}}
+
Retrieves an icon for the specified download.
+
{{WebExtAPIRef("downloads.open()")}}
+
Opens the downloaded file with its associated application.
+
{{WebExtAPIRef("downloads.show()")}}
+
Opens the platform's file manager application to show the downloaded file in its containing folder.
+
{{WebExtAPIRef("downloads.showDefaultFolder()")}}
+
Opens the platform's file manager application to show the default downloads folder.
+
{{WebExtAPIRef("downloads.erase()")}}
+
Erases matching {{WebExtAPIRef("downloads.DownloadItem", "DownloadItems")}} from the browser's download history, without deleting the downloaded files from disk.
+
{{WebExtAPIRef("downloads.removeFile()")}}
+
Removes a downloaded file from disk, but not from the browser's download history.
+
{{WebExtAPIRef("downloads.acceptDanger()")}}
+
Prompts the user to accept or cancel a dangerous download.
+
{{WebExtAPIRef("downloads.drag()")}}
+
Initiates dragging the downloaded file to another application.
+
{{WebExtAPIRef("downloads.setShelfEnabled()")}}
+
Enables or disables the gray shelf at the bottom of every window associated with the current browser profile. The shelf will be disabled as long as at least one extension has disabled it.
+
+ +

Events

+ +
+
{{WebExtAPIRef("downloads.onCreated")}}
+
Fires with the {{WebExtAPIRef("downloads.DownloadItem", "DownloadItem")}} object when a download begins.
+
{{WebExtAPIRef("downloads.onErased")}}
+
Fires with the downloadId when a download is erased from history.
+
{{WebExtAPIRef("downloads.onChanged")}}
+
When any of a {{WebExtAPIRef("downloads.DownloadItem", "DownloadItem")}}'s properties except bytesReceived changes, this event fires with the downloadId and an object containing the properties that changed.
+
+ +

Browser compatibility

+ +

{{Compat("webextensions.api.downloads")}}

+ +

{{WebExtExamples("h2")}}

+ +
Acknowledgements + +

This API is based on Chromium's chrome.downloads API.

+ +

Microsoft Edge compatibility data is supplied by Microsoft Corporation and is included here under the Creative Commons Attribution 3.0 United States License.

+
+ + diff --git a/files/de/mozilla/add-ons/webextensions/api/index.html b/files/de/mozilla/add-ons/webextensions/api/index.html new file mode 100644 index 0000000000..1a500cdc0c --- /dev/null +++ b/files/de/mozilla/add-ons/webextensions/api/index.html @@ -0,0 +1,51 @@ +--- +title: JavaScript APIs +slug: Mozilla/Add-ons/WebExtensions/API +tags: + - NeedsTranslation + - TopicStub + - WebExtensions +translation_of: Mozilla/Add-ons/WebExtensions/API +--- +
{{AddonSidebar}}
+ +
+

JavaScript APIs for WebExtensions can be used inside the extension's background scripts and in any other documents bundled with the extension, including browser action or page action popups, sidebars, options pages, or new tab pages. A few of these APIs can also be accessed by an extension's content scripts (see the list in the content script guide).

+ +

To use the more powerful APIs you need to request permission in your extension's manifest.json.

+ +

You can access the APIs using the browser namespace:

+ +
function logTabs(tabs) {
+  console.log(tabs);
+}
+
+browser.tabs.query({currentWindow: true}, logTabs);
+
+ +
+

Many of the APIs are asynchronous, returning a Promise:

+ +
function logCookie(c) {
+  console.log(c);
+}
+
+function logError(e) {
+  console.error(e);
+}
+
+var setCookie = browser.cookies.set(
+  {url: "https://developer.mozilla.org/"}
+);
+setCookie.then(logCookie, logError);
+
+ +
+

Note that this is different from Google Chrome's extension system, which uses the chrome namespace instead of browser, and which uses callbacks instead of promises for asynchronous functions. As a porting aid, the Firefox implementation of WebExtensions APIs supports chrome and callbacks as well as browser and promises. Mozilla has also written a polyfill which enables code that uses browser and promises to work unchanged in Chrome: https://github.com/mozilla/webextension-polyfill.

+ +

Microsoft Edge uses the browser namespace, but doesn't yet support promise-based asynchronous APIs. In Edge, for the time being, asynchronous APIs must use callbacks.

+ +

Not all browsers support all the APIs: for the details, see Browser support for JavaScript APIs.

+
+ +
{{SubpagesWithSummaries}}
diff --git a/files/de/mozilla/add-ons/webextensions/api/lesezeich/index.html b/files/de/mozilla/add-ons/webextensions/api/lesezeich/index.html new file mode 100644 index 0000000000..7c43bda2af --- /dev/null +++ b/files/de/mozilla/add-ons/webextensions/api/lesezeich/index.html @@ -0,0 +1,121 @@ +--- +title: Lesezeichen +slug: Mozilla/Add-ons/WebExtensions/API/Lesezeich. +translation_of: Mozilla/Add-ons/WebExtensions/API/bookmarks +--- +
{{AddonSidebar}}
+ +

Die WebExtensions {{WebExtAPIRef("bookmarks")}} API erlaubt es einer Erweiterung mit dem Lesezeichensystem des Browsers interagieren und dieses zu manipulieren. Sie können die API verwenden, um für Seiten Lesezeichen zu setzen, vorhandene Lesezeichen abzurufen und Lesezeichen zu bearbeiten, zu entfernen und zu organisieren.

+ +

Um diese API zu verwenden, muss die Erweiterung die Berechtigung "Lesezeichen" in der manifest.json Datei besitzen.

+ +

Types

+ +
+
{{WebExtAPIRef("bookmarks.BookmarkTreeNodeUnmodifiable")}}
+
Ein {{jsxref("String")}} enum, das angibt, warum ein Lesezeichen oder ein Ordner unmodifizierbar ist.
+
{{WebExtAPIRef("bookmarks.BookmarkTreeNode")}}
+
Stellt ein Lesezeichen oder einen Ordner im Lesezeichenbaum dar.
+
{{WebExtAPIRef("bookmarks.CreateDetails")}}
+
Enthält Informationen, die bei der Erstellung eines neuen Lesezeichens an die {{WebExtAPIRef("bookmarks.create()")}} Funktion übergeben werden.
+
+ +

Functions

+ +
+
{{WebExtAPIRef("bookmarks.create()")}}
+
Erstellt ein Lesezeichen oder Ordner.
+
{{WebExtAPIRef("bookmarks.get()")}}
+
Ruft eine oder mehrere {{WebExtAPIRef("bookmarks.BookmarkTreeNode", "BookmarkTreeNode")}} ab und übergibt eine Lesezeichen-ID oder ein Array von Lesezeichen ID.
+
{{WebExtAPIRef("bookmarks.getChildren()")}}
+
Ruft die Kinder des angegebenen {{WebExtAPIRef("bookmarks.BookmarkTreeNode", "BookmarkTreeNode")}} ab.
+
{{WebExtAPIRef("bookmarks.getRecent()")}}
+
Ruft eine angeforderte Anzahl von zuletzt hinzugefügten Lesezeichen ab.
+
{{WebExtAPIRef("bookmarks.getSubTree()")}}
+
Ruft einen Teil des Lesezeichenbaums ab und beginnt am angegebenen Knoten.
+
{{WebExtAPIRef("bookmarks.getTree()")}}
+
Ruft den gesamten Lesezeichenbaum in ein Array von {{WebExtAPIRef("bookmarks.BookmarkTreeNode", "BookmarkTreeNode")}} Objekte auf.
+
{{WebExtAPIRef("bookmarks.move()")}}
+
Moves the specified {{WebExtAPIRef("bookmarks.BookmarkTreeNode", "BookmarkTreeNode")}} to a new location in the bookmark tree.
+
{{WebExtAPIRef("bookmarks.remove()")}}
+
Removes a bookmark or an empty bookmark folder, given the node's ID.
+
{{WebExtAPIRef("bookmarks.removeTree()")}}
+
Recursively removes a bookmark folder; that is, given the ID of a folder node, removes that node and all its descendants.
+
{{WebExtAPIRef("bookmarks.search()")}}
+
Searches for {{WebExtAPIRef("bookmarks.BookmarkTreeNode", "BookmarkTreeNode")}}s matching a specified set of criteria.
+
{{WebExtAPIRef("bookmarks.update()")}}
+
Updates the title and/or URL of a bookmark, or the name of a bookmark folder, given the bookmark's ID.
+
+ +

Events

+ +
+
{{WebExtAPIRef("bookmarks.onCreated")}}
+
Fired when a bookmark or folder is created.
+
{{WebExtAPIRef("bookmarks.onRemoved")}}
+
Fired when a bookmark or folder is removed. When a folder is removed recursively, a single notification is fired for the folder, and none for its contents.
+
{{WebExtAPIRef("bookmarks.onChanged")}}
+
Fired when a bookmark or folder changes. Currently, only title and url changes trigger this.
+
{{WebExtAPIRef("bookmarks.onMoved")}}
+
Fired when a bookmark or folder is moved to a different parent folder or to a new offset within its folder.
+
{{WebExtAPIRef("bookmarks.onChildrenReordered")}}
+
Fired when the user has sorted the children of a folder in the browser's UI. This is not called as a result of a {{WebExtAPIRef("bookmarks.move", "move()")}}.
+
{{WebExtAPIRef("bookmarks.onImportBegan")}}
+
Fired when a bookmark import session is begun. Expensive observers should ignore {{WebExtAPIRef("bookmarks.onCreated")}} updates until {{WebExtAPIRef("bookmarks.onImportEnded")}} is fired. Observers should still handle other notifications immediately.
+
{{WebExtAPIRef("bookmarks.onImportEnded")}}
+
Fired when a bookmark import session has finished.
+
+ +

Browser compatibility

+ +

{{Compat("webextensions.api.bookmarks")}}

+ + + +

Edge incompatibilities

+ +

Promises are not supported in Edge. Use callbacks instead.

+ +

{{WebExtExamples("h2")}}

+ +
Acknowledgements + +

This API is based on Chromium's chrome.bookmarks API. This documentation is derived from bookmarks.json in the Chromium code.

+ +

Microsoft Edge compatibility data is supplied by Microsoft Corporation and is included here under the Creative Commons Attribution 3.0 United States License.

+
+ + diff --git a/files/de/mozilla/add-ons/webextensions/arbeiten_mit_taps_api/index.html b/files/de/mozilla/add-ons/webextensions/arbeiten_mit_taps_api/index.html new file mode 100644 index 0000000000..39498fa606 --- /dev/null +++ b/files/de/mozilla/add-ons/webextensions/arbeiten_mit_taps_api/index.html @@ -0,0 +1,608 @@ +--- +title: Arbeiten mit Taps API +slug: Mozilla/Add-ons/WebExtensions/Arbeiten_mit_Taps_API +tags: + - tabs +translation_of: Mozilla/Add-ons/WebExtensions/Working_with_the_Tabs_API +--- +

{{AddonSidebar}}

+ +

Tabs lassen einen Benutzer mehrere Webseiten in seinem Browserfenster öffnen und wechseln dann zwischen diesen Webseiten. Mit der Tabs API können Sie mit diesen Tabs arbeiten und diese manipulieren, um Programme zu erstellen, die Nutzern neue Möglichkeiten bieten, mit Tabs zu arbeiten oder die Funktionen Ihrer Erweiterung zu liefern.

+ +

In diesem "how-to"-Artikel schauen wir uns an:

+ + + +

Wir schließen dann mit Blick auf einige andere, andere Funktionen, die von der API angeboten werden.

+ +
+

Hinweis: Es gibt einige Tab-API-Funktionen, die an anderer Stelle abgedeckt sind. Dies sind die Methoden, die Sie verwenden können, um den Inhalt der Registerkarten mit Skripten zu manipulieren  ({{WebExtAPIRef("tabs.connect")}},  {{WebExtAPIRef("tabs.sendMessage")}} und  {{WebExtAPIRef("tabs.executeScript")}}). Wenn Sie mehr Informationen über diese Methoden wünschen, lesen Sie die Artikelinhaltskripte Concepts und die Anleitung ändern Sieeine Webseite.

+
+ +

Berechtigungen und die Tabs API

+ +

Für die meisten Tabs API-Funktionen benötigen Sie keine Berechtigungen; Es gibt jedoch einige Ausnahmen:

+ + + +

Im Folgenden können Sie in der manifest.json-Datei Ihrer Erweiterung die Erlaubnis "Tabs " beantragen :

+ +
"permissions": [
+  "<all_urls>",
+  "tabs"
+],
+ +

Diese Anfrage gibt Ihnen die Nutzung aller Tabs API-Funktion auf allen Websites, die Ihr Nutzer besucht. Es gibt auch einen alternativen Ansatz für die Anforderung von Berechtigungen zur Verwendung von {{WebExtAPIRef("tabs.executeScript")}} or {{WebExtAPIRef("tabs.insertCSS")}}, bei dem Sie keine Host-Erlaubnis benötigen, in Form von "activeTab". Diese Erlaubnis bietet die gleichen Rechte wie "Tabs" mit< all _ urls >,aber mit zwei Einschränkungen:

+ + + +

Der Vorteil dieses Ansatzes ist, dass der Benutzer keine Berechtigung erhält, die besagt, dass Ihre Erweiterung "Zugriff auf Ihre Daten für alle Websites" kann. Das liegt daran , dass < all _ urls > Erlaubnis einer Erweiterung die Möglichkeit gibt, Skripte in jedem Tab auszuführen, zu jeder Zeit, die sie mag, während "activeTab" darauf beschränkt ist, der Erweiterung zu erlauben, eine vom Benutzer angeforderte Aktion in der Aktuelle Registerkarte.

+ +

Mehr über Tabs und ihre Eigenschaften entdecken

+ +

Es wird Gelegenheiten geben, in denen Sie eine Liste aller Tabs in allen Browser-Fenstern erhalten wollen. Zu anderen Zeiten möchten Sie vielleicht eine Untergruppe von Tabs finden, die bestimmten Kriterien entsprechen, wie zum Beispiel solchen, die von einem bestimmten Tab geöffnet werden oder Seiten aus einer bestimmten Domain anzeigen. Und wenn Sie Ihre Liste der Tabs haben, werden Sie wahrscheinlich mehr über ihre Eigenschaften wissen wollen.

+ +

Hier kommt die {{WebExtAPIRef("tabs.query")}} in den Fall. Wird allein verwendet, um alle Tabs zu erhalten oder das queryInfo-Objekt zu nehmen —, um Abfragekriterien anzugeben, wie zum Beispiel, ob die Registerkarte im aktuellen Fenster aktiv ist, oder eines oder mehrere von 17 Kriterien —  {{WebExtAPIRef("tabs.query")}} gibt ein Array von  {{WebExtAPIRef("tabs.Tab")}} Objekte, die Informationen über die Registerkarten enthalten.

+ +

Wenn Sie nur Informationen über den aktuellen Reiter wünschen, können Sie eine {{WebExtAPIRef("tabs.Tab")}} erhalten. Objekt für diese Registerkarte mit {{WebExtAPIRef("tabs.getCurrent")}}. Wenn Sie eine Tab-ID haben, können Sie die  {{WebExtAPIRef("tabs.Tab")}} Objekt mit {{WebExtAPIRef("tabs.get")}}.

+ +
+

notiz:

+ + +
+ +

Wie man mit dem Beispiel geht

+ +

Um zu sehen, wie  {{WebExtAPIRef("tabs.query")}} und  {{WebExtAPIRef("tabs.Tab")}} werden verwendet, lassen Sie uns durch, wie  das Tabs-Tabs-Tabs Beispiel fügt die Liste von" Schalter auf Tabs "zu seiner Toolbar-Taste Popup.

+ +

+ +

manifest.json

+ +

Hier ist das manifest.json:

+ +
{
+  "browser_action": {
+    "browser_style": true,
+    "default_title": "Tabs, tabs, tabs",
+    "default_popup": "tabs.html"
+  },
+  "description": "A list of methods you can perform on a tab.",
+  "homepage_url": "https://github.com/mdn/webextensions-examples/tree/master/tabs-tabs-tabs",
+  "manifest_version": 2,
+  "name": "Tabs, tabs, tabs",
+  "permissions": [
+    "tabs"
+  ],
+  "version": "1.0"
+}
+ +
+

Hinweis:

+ + +
+ +

Tabs.html

+ +

Tabs.html definiert den Inhalt des Popups der Erweiterung:

+ +
<!DOCTYPE html>
+
+<html>
+
+ <head>
+    <meta charset="utf-8">
+    <link rel="stylesheet" href="tabs.css"/>
+ </head>
+
+<body>
+
+ <div class="panel">
+    <div class="panel-section panel-section-header">
+     <div class="text-section-header">Tabs-tabs-tabs</div>
+    </div>
+
+    <a href="#" id="tabs-move-beginning">Move active tab to the beginning of the window</a><br>
+
+
+…
+
+Define the other menu items
+…
+
+    <div class="switch-tabs">
+
+     <p>Switch to tab</p>
+
+     <div id="tabs-list"></div>
+
+    </div>
+ </div>
+
+ <script src="tabs.js"></script>
+
+</body>
+
+</html>
+ +

Hier ist eine Zusammenfassung der oben genannten tut:

+ +
    +
  1. Die Menüpunkte werden deklariert.
  2. +
  3. Ein leerer Div mit der ID-Tabs-Liste wird deklariert, um die Liste der Tabs zu enthalten.
  4. +
  5. Tabs.js heißt.
  6. +
+ +

Tabs.js

+ +

In tabs.jswerdenwir sehen, wie die Liste der Tabs aufgebaut und zum Popup hinzugefügt wird.  

+ +

Das Popup schaffen

+ +

Zunächst wird ein Event-Handler hinzugefügt, um ListTabs () auszuführen , wenn tabs.html geladen wird:

+ +
document.addEventListener ("DOMContentLoaded", hört Tabs);
+ +

Das erste, was listTabs () tut, ist getCurrentWindowTabs ()zu nennen. Hier wird ein {{WebExtAPIRef("tabs.query")}} verwendet, um eine  {{WebExtAPIRef("tabs.Tab")}} zu erhalten. Objekt für die Tabs im aktuellen Fenster:

+ +
function getCurrentWindowTabs() {
+  return browser.tabs.query({currentWindow: true});
+}
+ +

Jetzt ist listTabs() bereit , den Inhalt für das Popup zu erstellen.

+ +

Zunächst:

+ +
    +
  1. Schnappen Sie sich die tabs-list div.
  2. +
  3. Erstellen Sie ein Dokumentenfragment (in das die Liste eingebaut wird).
  4. +
  5. Setzen Sie Zähler.
  6. +
  7. Klären Sie den Inhalt der Tabs-Liste div.
  8. +
+ +
function listTabs() {
+ getCurrentWindowTabs().then((tabs) => {
+    let tabsList = document.getElementById('tabs-list');
+    let currentTabs = document.createDocumentFragment();
+    let limit = 5;
+    let counter = 0;
+
+    tabsList.textContent = '';
+ +

Als nächstes werden wir die Links für jeden Tab erstellen:

+ +
    +
  1. Schleifen Sie sich durch die ersten 5 Elemente aus der   {{WebExtAPIRef("tabs.Tab")}} Objekt.
  2. +
  3. Fügen Sie für jeden Artikel einen Hyperlink zum Dokumentenfragment hinzu. +
      +
    • Das Etikett des Links — das heißt, sein Text — wird mit dem Titel des Tab gesetzt (oder mit der ID, wenn er keinen Titel hat).
    • +
    • Die Adresse des Links wird mit der Personalausweis des Tabs gesetzt.
    • +
    +
  4. +
+ +
 for (let tab of tabs) {
+     if (!tab.active && counter <= limit) {
+        let tabLink = document.createElement('a');
+
+        tabLink.textContent = tab.title || tab.id;
+
+       tabLink.setAttribute('href', tab.id);
+        tabLink.classList.add('switch-tabs');
+        currentTabs.appendChild(tabLink);
+     }
+
+     counter += 1;
+
+    }
+ +

Schließlich wird das Dokumentenfragment auf die Tabs-Liste div geschrieben:

+ +
  tabsList.appendChild(currentTabs);
+  });
+}
+ +

Arbeiten mit dem aktiven Reiter

+ +

Ein weiteres verwandtes Beispielmerkmal ist die Info-Option "Alert active tab", die alle Registerkarten [{WebExtAPIRef ("-Register) ablegt. Tab ")} Objekteigenschaften für die aktive Registerkarte in einen Alarm:

+ +
 else if (e.target.id === "tabs-alertinfo") {
+   callOnActiveTab((tab) => {
+     let props = "";
+     for (let item in tab) {
+       props += `${ item } = ${ tab[item] } \n`;
+     }
+     alert(props);
+   });
+ }
+ +

Wobei callOnActiveTab() das aktive Tab-Objekt findet, indem man sich durch die Registerkarten {{WebExtAPIRef("tabs.Tab")}} schlodert. Tab ")} Objekte, die nach dem Gegenstand mit aktivem Satz suchen:

+ +
document.addEventListener("click", function(e) {
+ function callOnActiveTab(callback) {
+   getCurrentWindowTabs().then((tabs) => {
+     for (var tab of tabs) {
+       if (tab.active) {
+         callback(tab, tabs);
+       }
+     }
+   });
+ }
+}
+ +

Tabs erstellen, duplizieren, verschieben, aktualisieren, neu laden und entfernen

+ +

Nachdem Sie Informationen über die Registerkarten gesammelt haben, werden Sie höchstwahrscheinlich etwas mit ihnen machen wollen — entweder den Benutzern Funktionen für die Manipulation und Verwaltung von Registern bieten oder Funktionen in Ihrer Erweiterung implementieren.

+ +

Folgende Funktionen stehen zur Verfügung:

+ + + +
+

notiz:

+ +

Diese Funktionen erfordern alle die ID (oder IDs) der Registerkarte, die sie manipulieren:

+ + + +

Während die folgenden Funktionen auf dem aktiven Tab (sofern keine Tab-ID zur Verfügung gestellt wird) wirken:

+ + +
+ +

Wie man mit dem Beispiel geht

+ +

Das Beispiel Tabs-Tabs übt all diese Funktionen aus, bis hin zur Aktualisierung der URL eines Tabs. Die Art und Weise, in der diese APIs verwendet werden, ist ähnlich, so dass wir uns eine der am meisten involvierten Implementierungen ansehen werden, die des "Move active tab to the beginning of the the. Option "Option der Fensterliste.

+ +

Aber zunächst ist hier eine Demonstration des Features in Aktion:

+ +

{{EmbedYouTube("-lJRzTIvhxo")}}

+ +

manifest.json

+ +

Keine der Funktionen benötigt eine Betriebsgenehmigung, so dass es keine Funktionen in der manifest.json-Datei gibt, die hervorgehoben werden müssen.

+ +

Tabs.html

+ +

Tabs.html definiert das "Menü", das im Popup angezeigt wird, das die Option "Aktive Registerkarte zum Anfang der Fensterliste verschieben" enthält, mit einer Reihe von <a> Tags, die von einem visuellen Separator gruppiert sind. Jeder Menüpunkt erhält eine ID, die in tabs.js verwendet wird, um festzustellen, welcher Menüpunkt angefordert wird.

+ +
  <a href="#" id="tabs-move-beginning">Move active tab to the beginning of the window</a><br>
+    <a href="#" id="tabs-move-end">Move active tab to the end of the window</a><br>
+
+    <div class="panel-section-separator"></div>
+
+
+    <a href="#" id="tabs-duplicate">Duplicate active tab</a><br>
+
+    <a href="#" id="tabs-reload">Reload active tab</a><br>
+    <a href="#" id="tabs-alertinfo">Alert active tab info</a><br>
+ +

Tabs.js

+ +

Um das in tabs.html definierte "Menü" zu implementieren, enthält tabs.js einen Hörer für Klicks in tabs.html:

+ +
document.addEventListener("click", function(e) {
+ function callOnActiveTab(callback) {
+
+   getCurrentWindowTabs().then((tabs) => {
+     for (var tab of tabs) {
+       if (tab.active) {
+         callback(tab, tabs);
+       }
+     }
+   });
+}
+}
+ +

Eine Reihe von ifAnweisungen dann schauen, um die ID des Artikels geklickt.

+ +

Dieser Code-Snippet ist für die Option "Aktive Registerkarte zum Anfang der Fensterliste verschieben":

+ +
 if (e.target.id === "tabs-move-beginning") {
+   callOnActiveTab((tab, tabs) => {
+     var index = 0;
+     if (!tab.pinned) {
+       index = firstUnpinnedTab(tabs);
+     }
+     console.log(`moving ${tab.id} to ${index}`)
+     browser.tabs.move([tab.id], {index});
+   });
+ }
+ +

Es ist erwähnenswert, die Verwendung von console.log (). Auf diese Weise können Sie Informationen an die Debugger-Konsole ausgeben , was bei der Lösung von Problemen, die während der Entwicklung gefunden wurden, nützlich sein kann.

+ +

+ +

Der Bewegungscode ruft zunächst callOnActiveTab () an , der wiederum getCurrentWindowTabs () anruft, um eine {{WebExtAPIRef("tabs.Tab")}} Objekt, das die Registerkarten des aktiven Fensters enthält. Es schleift sich dann durch das Objekt, um das aktive Tab-Objekt zu finden und zurückzugeben:

+ +
function callOnActiveTab(callback) {
+   getCurrentWindowTabs().then((tabs) => {
+     for (var tab of tabs) {
+       if (tab.active) {
+         callback(tab, tabs);
+       }
+     }
+   });
+ }
+ +

Gepinnte Tabs

+ +

Eine Besonderheit von Registern ist, dass  der Benutzer Tabs in ein Fenster einfügen kann. Gepinnte Tabs werden am Anfang der Tab-Liste platziert und können nicht verschoben werden. Das bedeutet, dass die früheste Position, in die sich ein Tab bewegen kann, die erste Position nach einem gefiederten Tabs ist. Also , firstUnpinnedTab () wird aufgerufen, um die Position des ersten ungepasten Tab zu finden, indem man durch das Tabs-Objekt Looping:

+ +
function firstUnpinnedTab(tabs) {
+ for (var tab of tabs) {
+   if (!tab.pinned) {
+     return tab.index;
+   }
+ }
+}
+ +

Wir haben jetzt alles, was zum Verschieben des Tab notwendig ist: Das aktive Tab-Objekt, von dem wir die Reiter-ID erhalten können und die Position, in die der Reiter verschoben werden soll. So können wir den Schritt umsetzen:

+ +
browser.tabs.move ([tab.id], {index});
+ +

Die restlichen Funktionen zum Duplizieren, Laden, Erstellen und Entfernen von Tabs werden ähnlich implementiert.

+ +

Manipulationen eines Tab

+ +

Die nächste Reihe von Funktionen ermöglicht es Ihnen, die Zoomstufe in einem Tab zu erhalten  ({{WebExtAPIRef("tabs.getZoom")}}) und zu setzen ({{WebExtAPIRef("tabs.setZoom")}}) . Sie können auch die Zoom-Einstellungen abrufen ({{WebExtAPIRef("tabs.getZoomSettings")}}) , aber zum Zeitpunkt des Schreibens war die Möglichkeit, die Einstellungen zu setzen ({{WebExtAPIRef("tabs.setZoomSettings")}}) , war in Firefox nicht verfügbar.

+ +

Der Zoomwert kann zwischen 30% und 300% liegen (dargestellt als Dezimalzahl 0,3 bis 3).

+ +

In Firefox sind die Standard-Zoom-Einstellungen:

+ + + +

Wie man mit dem Beispiel geht

+ +

Das  Beispiel der Tabs-Tabs-Tabs enthält drei Vorführungen der Zoom-Funktion: Zoomen, Zoomen und Zoom zurücksetzen. Hier ist das Feature in Aktion:

+ +

{{EmbedYouTube("RFr3oYBCg28")}}

+ +

Schauen wir uns an, wie der Zoom-In umgesetzt wird.

+ +

manifest.json

+ +

Keine der Zoom-Funktionen benötigt Berechtigungen, so dass es keine Funktionen in der manifest.json-Datei gibt, die hervorgehoben werden müssen.

+ +

Tabs.html

+ +

Wir haben bereits darüber diskutiert, wie der tabs.html die Optionen für diese Erweiterung definiert, nichts Neues oder Einzigartiges wird getan, um die Zoom-Optionen zur Verfügung zu stellen.

+ +

Tabs.js

+ +

Tabs.js beginnt mit der Definition mehrerer Konstanten, die im Zoom-Code verwendet werden:

+ +
const ZOOM_INCREMENT = 0.2;
+const MAX_ZOOM = 3;
+const MIN_ZOOM = 0.3;
+const DEFAULT_ZOOM = 1;
+ +

Es verwendet dann den gleichen Hörer, den wir zuvor besprochen haben, so dass es auf Klicks in tabs.html wirken kann.

+ +

Für den Zoom in der Funktion läuft das:

+ +
else if (e.target.id === "tabs-add-zoom") {
+   callOnActiveTab((tab) => {
+     var gettingZoom = browser.tabs.getZoom(tab.id);
+     gettingZoom.then((zoomFactor) => {
+       //the maximum zoomFactor is 3, it can't go higher
+       if (zoomFactor >= MAX_ZOOM) {
+         alert("Tab zoom factor is already at max!");
+       } else {
+         var newZoomFactor = zoomFactor + ZOOM_INCREMENT;
+         //if the newZoomFactor is set to higher than the max accepted
+         //it won't change, and will never alert that it's at maximum
+         newZoomFactor = newZoomFactor > MAX_ZOOM ? MAX_ZOOM : newZoomFactor;
+         browser.tabs.setZoom(tab.id, newZoomFactor);
+       }
+     });
+   });
+ }
+ +

Dieser Code verwendet callOnActiveTab () , um die Details des aktiven Tab zu erhalten, dann wird {{WebExtAPIRef("tabs.getZoom")}} den aktuellen Zoom-Faktor der Registerkarte erhalten. Der aktuelle Zoom wird mit dem definierten Maximum (MAX _ ZOOM)und einem Alarm verglichen, der ausgegeben wird, wenn sich der Tab bereits im Maximalzoom befindet. Andernfalls wird der Zoom-Level erhöht, aber auf den maximalen Zoom beschränkt, dann wird der Zoom mit {{WebExtAPIRef("tabs.getZoom")}}. gesetzt .

+ +

Manipulationen eines Tabs CSS

+ +

Eine weitere wichtige Fähigkeit, die die Tabs API bietet, ist die Möglichkeit, die CSS innerhalb eines Tab zu manipulieren — neue CSS zu einem Tab hinzufügen ({{WebExtAPIRef ("tabu Die [[Datei]] der [[Datei]] der [[Datei]] der [[Datei]] der [[Datei]] ist (" tabs.removeCSS ")).

+ +

Dies kann zum Beispiel nützlich sein, wenn Sie bestimmte Seitenelemente markieren oder das Standardlayout der Seite ändern wollen.

+ +

Wie man mit dem Beispiel geht

+ +

Das Apply-css-Beispiel nutzt diese Funktionen, um der Webseite im aktiven Tab einen roten Rand hinzuzufügen. Hier ist das Feature in Aktion:

+ +

{{EmbedYouTube ("bcK-GT2Dyhs")}

+ +

Gehen wir durch, wie es aufgebaut ist.

+ +

manifest.json

+ +

Um die CSS-Funktionen nutzen zu können, benötigen Sie entweder:

+ + + +

Letzteres ist das nützlichste, da es einer Erweiterung erlaubt,  {{WebExtAPIRef("tabs.insertCSS")}} und  {{WebExtAPIRef("tabs.removeCSS")}} in der aktiven Registerkarte zu verwenden, wenn sie von der Browser-oder Seitenaktion, dem Kontextmenü oder einem Shortcut der Erweiterung ausgeführt wird.

+ +
{
+  "description": "Adds a page action to toggle applying CSS to pages.",
+
+ "manifest_version": 2,
+ "name": "apply-css",
+ "version": "1.0",
+ "homepage_url": "https://github.com/mdn/webextensions-examples/tree/master/apply-css",
+
+ "background": {
+
+    "scripts": ["background.js"]
+ },
+
+ "page_action": {
+
+    "default_icon": "icons/off.svg",
+    "browser_style": true
+ },
+
+ "permissions": [
+    "activeTab",
+    "tabs"
+ ]
+
+}
+ +

Sie werden darauf hinweisen, dass zusätzlich zu "activeTab" die Erlaubnis " Tabs"angefordert wird. Diese zusätzliche Erlaubnis ist erforderlich, um das Skript der Erweiterung in die Lage zu versetzen, auf die URL des Registers zuzugreifen, deren Bedeutung wir gleich sehen werden.

+ +

Die anderen Hauptmerkmale in der manifest.json-Datei sind die Definition von:

+ + + +

Background.js

+ +

Beim Start setzt background.js einige Konstanten, um die zu bewendenden CSS zu definieren, Titel für die "Seitenaktion", und eine Liste von Protokollen, in denen die Erweiterung funktioniert:

+ +
const CSS = "body { border: 20px solid red; }";
+const TITLE_APPLY = "Apply CSS";
+const TITLE_REMOVE = "Remove CSS";
+const APPLICABLE_PROTOCOLS = ["http:", "https:"];
+ +

Wenn die Erweiterung zum ersten Mal geladen wird, verwendet sie {{WebExtAPIRef("tabs.query")}}, um eine Liste aller Tabs im aktuellen Browserfenster zu erhalten. Es schleit sich dann durch die Tabs, die InitializePageAction()rufen.

+ +
var gettingAllTabs = browser.tabs.query({});
+
+gettingAllTabs.then((tabs) => {
+ for (let tab of tabs) {
+   initializePageAction(tab);
+ }
+});
+ +

InitializePageAction verwendet protokolIsApplicable () , um festzustellen, ob die URL der aktiven Registerkarte eine ist, auf die die CSS angewendet werden kann:

+ +
function protocolIsApplicable(url) {
+ var anchor =  document.createElement('a');
+ anchor.href = url;
+ return APPLICABLE_PROTOCOLS.includes(anchor.protocol);
+}
+ +

Wenn das Beispiel dann auf der Registerkarte wirken kann, setzt initializePageAction () das PageAction-Symbol und den Titel des Tab, um die "Off"-Versionen zu verwenden, bevor die PageAction-Version sichtbar gemacht wird:

+ +
function initializePageAction(tab) {
+
+ if (protocolIsApplicable(tab.url)) {
+   browser.pageAction.setIcon({tabId: tab.id, path: "icons/off.svg"});
+   browser.pageAction.setTitle({tabId: tab.id, title: TITLE_APPLY});
+   browser.pageAction.show(tab.id);
+ }
+}
+ +

Als Nächstes wartet ein Zuhörer auf der pageAction.onClicked darauf, dass das PageAction-Symbol angeklickt wird  , und ruft toggleCSS an , wenn es ist.

+ +
browser.pageAction.onClicked.addListener (toggleCSS);
+ +

ToggleCSS () erhält den Titel der PageAction und nimmt dann die beschriebene Aktion auf:

+ + + +
function toggleCSS(tab) {
+
+
+ function gotTitle(title) {
+
+    if (title === TITLE_APPLY) {
+     browser.pageAction.setIcon({tabId: tab.id, path: "icons/on.svg"});
+     browser.pageAction.setTitle({tabId: tab.id, title: TITLE_REMOVE});
+     browser.tabs.insertCSS({code: CSS});
+    } else {
+     browser.pageAction.setIcon({tabId: tab.id, path: "icons/off.svg"});
+     browser.pageAction.setTitle({tabId: tab.id, title: TITLE_APPLY});
+     browser.tabs.removeCSS({code: CSS});
+    }
+ }
+
+ var gettingTitle = browser.pageAction.getTitle({tabId: tab.id});
+
+ gettingTitle.then(gotTitle);
+}
+ +

Um sicherzustellen, dass die PageAction nach jedem Update auf den Tab gültig ist, ruft ein Zuhörer auf  {{WebExtAPIRef("tabs.onUpdated")}} jedes Mal, wenn der Tab aktualisiert wird, auf initializePageAction () , um zu überprüfen, ob der Reiter immer noch ein Protokoll, auf das das CSS angewendet werden kann.

+ +
browser.tabs.onUpdated.addListener((id, changeInfo, tab) => {
+ initializePageAction(tab);
+});
+ +

Einige weitere interessante Fähigkeiten

+ +

Es gibt noch ein paar andere Tabs API-Funktionen, die nicht in einen der früheren Abschnitte passen:

+ + + +

Weitere Informationen

+ +

Wenn Sie mehr über die Tabs API erfahren möchten, schauen Sie sich an:

+ + + +

 

diff --git a/files/de/mozilla/add-ons/webextensions/beispiele/index.html b/files/de/mozilla/add-ons/webextensions/beispiele/index.html new file mode 100644 index 0000000000..627dbe559d --- /dev/null +++ b/files/de/mozilla/add-ons/webextensions/beispiele/index.html @@ -0,0 +1,22 @@ +--- +title: Beispiele für Erweiterungen +slug: Mozilla/Add-ons/WebExtensions/Beispiele +tags: + - WebExtensions +translation_of: Mozilla/Add-ons/WebExtensions/Examples +--- +
{{AddonSidebar}}
+ +

Um zu veranschaulichen, wie Erweiterungen entwickelt werden, gibt es von uns ein Repository mit einfachen Beispielerweiterungen unter https://github.com/mdn/webextensions-examples. Dieser Artikel beschreibt die WebExtension-APIs, die in diesem Repository verwendet werden.

+ +

Diese Beispiele funktionieren in Firefox Nightly: Die meisten funktionieren in früheren Versionen von Firefox, aber überprüfen Sie zur Sicherheit den Schlüssel strict_min_version in der Datei manifest.json der Erweiterung.
+
+ Wenn Sie diese Beispiele ausprobieren möchten, haben Sie drei Möglichkeiten:
+
+ 1.  Klonen Sie das Repository, und laden Sie die Erweiterung direkt aus dem Quellverzeichnis mit der Funktion "Load Temporary Add-on". Die Erweiterung bleibt solange geladen, bis Sie Firefox neu starten.

+ 2. Klonen Sie das Repository und verwenden Sie dann das web-ext Befehlszeilentool, um Firefox mit der installierten Erweiterung auszuführen.
+ 3. Klonen Sie das Repository und gehen Sie dann zum Build-Verzeichnis. Dieses enthält "Build"- und "Signed"-Versionen aller Beispiele; Sie können sie also einfach in Firefox öffnen (mit Datei / Datei öffnen) und sie dauerhaft installieren, genau wie eine Erweiterung, die Sie von addons.mozilla.org installieren würden.
+
+ Wenn Sie einen Beitrag zum Repository leisten möchten, senden Sie uns ein Pull-Request!

+ +

{{WebExtAllExamples}}

diff --git a/files/de/mozilla/add-ons/webextensions/browser_support_for_javascript_apis/index.html b/files/de/mozilla/add-ons/webextensions/browser_support_for_javascript_apis/index.html new file mode 100644 index 0000000000..1dffe19399 --- /dev/null +++ b/files/de/mozilla/add-ons/webextensions/browser_support_for_javascript_apis/index.html @@ -0,0 +1,15 @@ +--- +title: Browser support for JavaScript APIs +slug: Mozilla/Add-ons/WebExtensions/Browser_support_for_JavaScript_APIs +translation_of: Mozilla/Add-ons/WebExtensions/Browser_support_for_JavaScript_APIs +--- +
{{AddonSidebar}}
+ +
{{WebExtAllCompatTables}}
+ + + +
Acknowledgements + +

Microsoft Edge compatibility data is supplied by Microsoft Corporation and is included here under the Creative Commons Attribution 3.0 United States License.

+
diff --git a/files/de/mozilla/add-ons/webextensions/deine_erste_weberweiterung/index.html b/files/de/mozilla/add-ons/webextensions/deine_erste_weberweiterung/index.html new file mode 100644 index 0000000000..b48b805b98 --- /dev/null +++ b/files/de/mozilla/add-ons/webextensions/deine_erste_weberweiterung/index.html @@ -0,0 +1,155 @@ +--- +title: Deine erste Erweiterung +slug: Mozilla/Add-ons/WebExtensions/Deine_erste_WebErweiterung +tags: + - Anleitung + - Erweiterung + - Weberweiterung +translation_of: Mozilla/Add-ons/WebExtensions/Your_first_WebExtension +--- +
{{AddonSidebar}}
+ +

In diesem Artikel wird die Erstellung einer Erweiterung (Extension) für Firefox komplett beschrieben. Diese Erweiterung soll einen roten Rand zu jeder Seite, die von "mozilla.org" oder einer Subdomain geladen wurde, hinzufügen.

+ +

Der Quellcode für dieses Beispiel ist auf GitHub auffindbar: https://github.com/mdn/webextensions-examples/tree/master/borderify.

+ +

Als Erstes benötigst du Firefox Version 45 oder neuer.

+ +

Schreiben der Erweiterung

+ +

Erstelle ein neues Verzeichnis und navigiere zu diesem:

+ +
mkdir borderify
+cd borderify
+ +

manifest.json

+ +

Jetzt erstelle eine Datei namens "manifest.json" direkt in dem "borderify" -Verzeichnis mit dem folgenden Inhalt:

+ +
{
+
+  "manifest_version": 2,
+  "name": "Borderify",
+  "version": "1.0",
+
+  "description": "Adds a red border to all webpages matching mozilla.org.",
+
+  "icons": {
+    "48": "icons/border-48.png"
+  },
+
+  "content_scripts": [
+    {
+      "matches": ["*://*.mozilla.org/*"],
+      "js": ["borderify.js"]
+    }
+  ]
+
+}
+ + + +

Der interessanteste Key hier ist  content_scripts, welcher Firefox auffordert, ein Skript in allen Webseiten zu laden, deren URLs einem spezifischen Muster zuzuordnen sind. In diesem Fall fragen wir Firefox nach dem Skript namens "borderify.js", um es in allen HTTP oder HTTPS Seiten von "mozilla.org" oder einer Subdomain zu laden.

+ + + +
+

In manchen Situation musst eine ID für deine Erweiterung festlegen. Wenn du eine Add-on ID festlegen musst, schreibe den  applications key in manifest.json und setze die gecko.id-Eigenschaft:

+ +
"applications": {
+  "gecko": {
+    "id": "borderify@example.com"
+  }
+}
+
+ +

icons/border-48.png

+ +

Die Erweiterung sollte ein Icon haben. Dieses wird neben dem Erweiterungseintrag in dem Add-ons manager angezeigt. Unsere manifest.json gibt den Ort des Icons unter "icons/border-48.png" an.

+ +

Erstelle das "icons" Verzeichnis direkt in dem "borderify" Verzeichnis. Speichere dort ein Icon namens "border-48.png".  Du kannst dazu das von unserem Beispiel benutzen, welches von der Google Material Design Iconsammlung stammt und unter den Richtlinien der Creative Commons Attribution-ShareAlike Lizenz steht.

+ +

Wenn du dich entscheidest ein eigenes Icon zu verwenden, dann sollte dieses 48x48 Pixel groß sein. Du kannst ebenfalls ein 96x96 Pixel großes Icon für hochauflösende Bildschirme, übergeben, welches dann als die 96 Property des icons-Objekts in der manifest.json festgelegt wird:

+ +
"icons": {
+  "48": "icons/border-48.png",
+  "96": "icons/border-96.png"
+}
+ +

Alternativ kannst du auch eine SVG-Datei übergeben, welche dann automatisch korrekt skaliert wird.
+ (Beachte: Wenn du SVG verwendest und dein Symbol Text enthält, kannst du das Werkzeug "convert to path" deines SVG-Editors verwenden, um den Text zu verflachen, so dass er mit einer einheitlichen Größe/Position skaliert wird.

+ + + +

borderify.js

+ +

Schließlich erstelle eine Datei namens "borderify.js" direkt in dem "borderify"-Verzeichnis mit diesem Inhalt:

+ +
document.body.style.border = "5px solid red";
+ +

Dieses Skript wird in Seiten geladen, welche mit dem Muster des  content_scripts-Keys in der manifest.json Datei übereinstimmen. Das Skript hat direkten Zugriff auf das Dokument, genauso wie die Skripte, die von der Seite selbst geladen werden.

+ + + +

Probiere es aus:

+ +

Als Erstes stelle sicher, dass du die richtigen Dateien an den richtigen Orten hast:

+ +
borderify/
+    icons/
+        border-48.png
+    borderify.js
+    manifest.json
+ +

Installiere nun das Plugin

+ +

Öffne "about:debugging" in Firefox, klicke "Add-on temporär laden" und wähle eine beliebige Datei aus deinem Erweiterungsverzeichnis:

+ +

{{EmbedYouTube("cer9EUKegG4")}}

+ +

Die Erweiterung wird nun ausgeführt und ist solange aktiv, bis du Firefox neustartest.

+ +

Alternativ kannst du Erweiterung auch von der Kommandozeile mit dem web-ext Tool ausführen.

+ +

Teste es nun aus

+ +

Nun besuche eine Seite von "mozilla.org". Du solltest jetzt einen roten Rand um die Seite erkennen:

+ +

{{EmbedYouTube("rxBQl2Z9IBQ")}}

+ +
+

Versuche es allerdings nicht auf addons.mozilla.org! Content Scripts werden zurzeit auf dieser Domain geblockt.

+
+ +

Experimentiere nun ein bisschen. Bearbeite das "content script", um die Farbe des Randes zu ändern oder mache etwas anderes mit dem Seiteninhalt. Speichere das "content script", lade die Erweiterungsdateien in about:debugging neu mit Hilfe des "Neu laden"-Knopfs. Du kannst die Änderungen sofort sehen:

+ +

{{EmbedYouTube("NuajE60jfGY")}}

+ + + +

Verpacken und Veröffentlichen

+ +

Damit andere Personen deine Erweiterung benutzen können musst du deine Erweiterung verpacken und zum Signieren an Mozilla senden. Um mehr darüber zu lernen, siehe  "Deine Erweiterung veröffentlichen".

+ +

Was nun?

+ +

Jetzt hast du eine Vorstellung vom Prozess der WebExtension-Entwicklung für Firefox erhalten. Versuche:

+ + diff --git a/files/de/mozilla/add-ons/webextensions/deine_zweite_erweiterung/index.html b/files/de/mozilla/add-ons/webextensions/deine_zweite_erweiterung/index.html new file mode 100644 index 0000000000..cc002d0b24 --- /dev/null +++ b/files/de/mozilla/add-ons/webextensions/deine_zweite_erweiterung/index.html @@ -0,0 +1,357 @@ +--- +title: Deine zweite Erweiterung +slug: Mozilla/Add-ons/WebExtensions/Deine_zweite_Erweiterung +translation_of: Mozilla/Add-ons/WebExtensions/Your_second_WebExtension +--- +

{{AddonSidebar}}

+ +

Wenn du den Artikel "Deine erste Erweiterung" gelesen hast, hast du schon eine Vorstellung, wie man eine Erweiterung schreibt. In diesem Artikel werden wir eine komplexere Erweiterung schreiben, die mehr APIs benutzt.

+ +

Die Erweiterung fügt eine neue Schaltfläche zu Firefox hinzu. Wenn der Nutzer diese anklickt, wird ihm ein Popup angezeigt auf dem er ein Tier auswählen kann. Sobald er eines ausgewählt hat, wird der aktulle Inhalt der Website mit dem Bild des ausgewählten Tieres ersetzt.

+ +

Um das zu implementieren werden wir:

+ + + +

Man kann die Struktur der Erweiterung wie folgt darstellen:

+ +

+ +

Es ist eine einfache Erweiterung, aber es zeigt viele der Grundkonzepte der WebExtensions API:

+ + + +

Der komplette Quellcode der Erweiterung ist auf GitHub zu finden.

+ +

Um die Erweiterung zu erstellen, brauchst du mindestens Firefox 45.

+ +

Die Erweiterung schreiben

+ +

Erstelle einen neuen Ordner und öffne ihn:

+ +
mkdir beastify
+cd beastify
+ +

manifest.json

+ +

Erstelle jetzt eine Datei namens "manifest.json" und füge den folgenden Inhalt ein:

+ +
{
+
+  "manifest_version": 2,
+  "name": "Beastify",
+  "version": "1.0",
+
+  "description": "Erstellt eine Schaltfläche in der Toolbar. Klicke auf eine der Schaltflächen, um ein Tier auszuwählen. Der Inhalt des gerade geöffneten Tabs wird dann mit dem Bild des ausgewählten Tieres ersetzt. Nachschlagen: https://developer.mozilla.org/en-US/Add-ons/WebExtensions/Examples#beastify",
+  "homepage_url": "https://github.com/mdn/webextensions-examples/tree/master/beastify",
+  "icons": {
+    "48": "icons/beasts-48.png"
+  },
+
+  "permissions": [
+    "activeTab"
+  ],
+
+  "browser_action": {
+    "default_icon": "icons/beasts-32.png",
+    "default_title": "Beastify",
+    "default_popup": "popup/choose_beast.html"
+  },
+
+  "web_accessible_resources": [
+    "beasts/frog.jpg",
+    "beasts/turtle.jpg",
+    "beasts/snake.jpg"
+  ]
+
+}
+
+ + + +

Beachte, dass alle Pfade relativ zur manifest.json angegeben werden.

+ +

Das Icon

+ +

Die Erweiterung soll ein Icon beinhalten, das neben dem Eintrag der Erweiterung in der Add-ons-Verwaltung angezeigt wird (diese kannst du durch Aufrufen der URL "about:addons" öffnen). In manifest.json haben wir festgelegt, dass wir ein Icon für die Toolbar unter "icons/beasts-48.png" bereitstellen.

+ +

Erstelle das "icons"-Verzeichnis and speichere dort das Icon namens "beasts-48.png".  Du kannst das Icon aus unserem Beispiel verwenden, welches aus dem Aha-Soft’s Free Retina Icon-Set stammt und gemäß seiner Lizenzbestimmungen genutzt wird.

+ +

Wenn du dich entscheidest, ein eigenes Icon zu verwenden, sollte es eine Auflösung von 48x48 Pixeln besitzen. Zusätzlich kannst du ein 96x96 Pixel großes Icon für hochaufgelöste Bildschirme bereitstellen. In diesem Fall wird es unter der Eigenschaft 96 des icons Objekts in manifest.json aufgeführt:

+ +
"icons": {
+  "48": "icons/beasts-48.png",
+  "96": "icons/beasts-96.png"
+}
+ +

Die Toolbar-Schaltfläche

+ +

Die Toolbar-Schaltfläche benötigt ebenfalls ein Icon, das laut unserer manifest.json unter "icons/beasts-32.png" bereitsteht.

+ +

Speichere ein Icon namens "beasts-32.png" im Verzeichnis "icons".Du kannst das Icon aus unserem Beispiel verwenden, welches aus dem IconBeast Lite Icon-Set stammt und gemäß seiner Lizenzbestimmungen genutzt wird.

+ +

Wenn du kein Popup einsetzt, dann wird ein Klick-Event zur Erweiterung gesendet, sobald der Benutzer die Schaltfläche anklickt. Wenn du hingegen ein Popup einsetzt, wird dieses Klick-Event nicht gesendet, sondern das Popup wird geöffnet. Da wir ein Popup verwenden wollen, soll dieses im nächsten Schritt erstellt werden.

+ +

Das Popup

+ +

Mithilfe des Popups soll der Benutzer eines von drei Tieren auswählen können.

+ +

Erstelle ein neues Verzeichnis namens "popup" in der obersten Ebene des Erweiterungsverzeichnisses. Dieses Verzeichnis wird den Code für das Popup enthalten. Das Popup besteht aus drei Dateien:

+ + + +

choose_beast.html

+ +

Die HTML-Datei sieht folgendermaßen aus:

+ +
<!DOCTYPE html>
+
+<html>
+  <head>
+    <meta charset="utf-8">
+    <link rel="stylesheet" href="choose_beast.css"/>
+  </head>
+
+  <body>
+    <div class="button beast">Frog</div>
+    <div class="button beast">Turtle</div>
+    <div class="button beast">Snake</div>
+    <div class="button clear">Reset</div>
+
+    <script src="choose_beast.js"></script>
+  </body>
+
+</html>
+ +

Es gibt ein Element für jedes Tier. Beachte, dass in dieser Datei auch die CSS- und JavaScript-Dateien verlinkt werden, genau wie auf einer Website.

+ +

choose_beast.css

+ +

Die CSS-Datei legt die Größe des Popups fest, stellt sicher, dass die drei Auswahlmöglichkeiten, den verfügbaren Platz ausfüllen und legt das grundlegende Styling fest:

+ +
html, body {
+  width: 100px;
+}
+
+.button {
+  margin: 3% auto;
+  padding: 4px;
+  text-align: center;
+  font-size: 1.5em;
+  cursor: pointer;
+}
+
+.beast:hover {
+  background-color: #CFF2F2;
+}
+
+.beast {
+ background-color: #E5F2F2;
+}
+
+.clear {
+ background-color: #FBFBC9;
+}
+
+.clear:hover {
+ background-color: #EAEAC9;
+}
+
+ +

choose_beast.js

+ +

In der JavaScript-Datei des Popups empfangen wir Klick-Events. Wenn ein Klick auf eines der Tiere erfolgte, wird das Content Script zum aktiven Tab hinzugefügt. Sobald das Content Script geladen wird, übergeben wir ihm eine Nachricht mit der Auswahl des Tieres:

+ +
/*
+Given the name of a beast, get the URL to the corresponding image.
+*/
+function beastNameToURL(beastName) {
+  switch (beastName) {
+    case "Frog":
+      return browser.extension.getURL("beasts/frog.jpg");
+    case "Snake":
+      return browser.extension.getURL("beasts/snake.jpg");
+    case "Turtle":
+      return browser.extension.getURL("beasts/turtle.jpg");
+  }
+}
+
+/*
+Listen for clicks in the popup.
+
+If the click is on one of the beasts:
+  Inject the "beastify.js" content script in the active tab.
+
+  Then get the active tab and send "beastify.js" a message
+  containing the URL to the chosen beast's image.
+
+If it's on a button which contains class "clear":
+  Reload the page.
+  Close the popup. This is needed, as the content script malfunctions after page reloads.
+*/
+
+document.addEventListener("click", (e) => {
+  if (e.target.classList.contains("beast")) {
+    var chosenBeast = e.target.textContent;
+    var chosenBeastURL = beastNameToURL(chosenBeast);
+
+    browser.tabs.executeScript(null, {
+      file: "/content_scripts/beastify.js"
+    });
+
+    var gettingActiveTab = browser.tabs.query({active: true, currentWindow: true});
+    gettingActiveTab.then((tabs) => {
+      browser.tabs.sendMessage(tabs[0].id, {beastURL: chosenBeastURL});
+    });
+  }
+  else if (e.target.classList.contains("clear")) {
+    browser.tabs.reload();
+    window.close();
+  }
+});
+
+ +

It uses three WebExtensions API functions:

+ + + +

The content script

+ +

Create a new directory, under the extension root, called "content_scripts" and create a new file in it called "beastify.js", with the following contents:

+ +
/*
+beastify():
+* removes every node in the document.body,
+* then inserts the chosen beast
+* then removes itself as a listener
+*/
+function beastify(request, sender, sendResponse) {
+  removeEverything();
+  insertBeast(request.beastURL);
+  browser.runtime.onMessage.removeListener(beastify);
+}
+
+/*
+Remove every node under document.body
+*/
+function removeEverything() {
+  while (document.body.firstChild) {
+    document.body.firstChild.remove();
+  }
+}
+
+/*
+Given a URL to a beast image, create and style an IMG node pointing to
+that image, then insert the node into the document.
+*/
+function insertBeast(beastURL) {
+  var beastImage = document.createElement("img");
+  beastImage.setAttribute("src", beastURL);
+  beastImage.setAttribute("style", "width: 100vw");
+  beastImage.setAttribute("style", "height: 100vh");
+  document.body.appendChild(beastImage);
+}
+
+/*
+Assign beastify() as a listener for messages from the extension.
+*/
+browser.runtime.onMessage.addListener(beastify);
+
+ +

The content script adds a listener to messages from the extension (specifically, from "choose_beast.js" above). In the listener, it:

+ + + +

The beasts

+ +

Finally, we need to include the images of the animals.

+ +

Create a new directory called "beasts", and add the three images in that directory, with the appropriate names. You can get the images from the GitHub repository, or from here:

+ +

+ +

Testing it out

+ +

First, double check that you have the right files in the right places:

+ +
beastify/
+
+    beasts/
+        frog.jpg
+        snake.jpg
+        turtle.jpg
+
+    content_scripts/
+        beastify.js
+
+    icons/
+        beasts-32.png
+        beasts-48.png
+
+    popup/
+        choose_beast.css
+        choose_beast.html
+        choose_beast.js
+
+    manifest.json
+ +

Starting in Firefox 45, you can install extensions temporarily from disk.

+ +

Open "about:debugging" in Firefox, click "Load Temporary Add-on", and select your manifest.json file. You should then see the extension's icon appear in the Firefox toolbar:

+ +

{{EmbedYouTube("sAM78GU4P34")}}

+ +

Open a web page, then click the icon, select a beast, and see the web page change:

+ +

{{EmbedYouTube("YMQXyAQSiE8")}}

+ +

Developing from the command line

+ +

You can automate the temporary installation step by using the web-ext tool. Try this:

+ +
cd beastify
+web-ext run
diff --git a/files/de/mozilla/add-ons/webextensions/extending_the_developer_tools/index.html b/files/de/mozilla/add-ons/webextensions/extending_the_developer_tools/index.html new file mode 100644 index 0000000000..688d48f544 --- /dev/null +++ b/files/de/mozilla/add-ons/webextensions/extending_the_developer_tools/index.html @@ -0,0 +1,143 @@ +--- +title: Extending the developer tools +slug: Mozilla/Add-ons/WebExtensions/Extending_the_developer_tools +tags: + - Deutsch Guide + - DevTools + - Extentions + - german +translation_of: Mozilla/Add-ons/WebExtensions/Extending_the_developer_tools +--- +
+

Das heißt Folgendes wird nicht unterstützt , sie können Änderungen an der Seite sehen, die von Seitenskripten vorgenommen wurden.Diese Seite beschreibt devtools-APIs, wie sie in Firefox 55 vorhanden sind. Obwohl die APIs auf den Chrome devtools APIs basieren, gibt es noch viele Funktionen, die in Firefox noch nicht implementiert sind und daher hier nicht dokumentiert sind. Informationen zu den derzeit fehlenden Funktionen finden Sie unter Einschränkungen der devtools-APIs.

+
+ + + +

Die devtools-Seite hat kein sichtbares DOM, kann aber JavaScript-Quellen mit <script> -Tags enthalten. Die Quellen müssen mit der Erweiterung selbst gebündelt werden. Die normalen DOM-APIs, auf die über das globale Fensterobjekt zugegriffen werden kann Die gleichen WebExtension-APIs wie in Inhaltsskripten Die devtools-APIs: Devtools inspiziertes Fenster devtools.network devtools.panels Beachten Sie, dass die devtools-Seite keinen Zugriff auf andere Web Extensions-APIs erhält und die Hintergrundseite keinen Zugriff auf die devtools-APIs erhält. Stattdessen müssen die davetool-Seite und die Hintergrundseite definiert werden. Verwenden der Laufzeit-Messeging-APIs. Hier ist ein Beispiel:

+ +
+ +
+ +
+
+

Code im Zielfenster ausführen

+
+
+ +

Derdevtools.inspectedWindow.eval() bereitgestellt in einfacher weisen um den Code auszuführen in den lnspector Fensten 

+ +
+

Arbeiten mit Inhaltsskripten Dies entspricht in etwa der Verwendung von {{WebExtAPIRef ("tabs.executeScript ()")}} zum Einfügen eines Inhaltsskripts, mit einem wichtigen Unterschied nommen wurden.Beachten Sie, dass eine saubere Ansicht des DOM eine Sicherheitsfunktion ist, mit der verhindert werden soll, dass feindliche Seiten Erweiterungen austricksen, indem das Verhalten nativer DOM-Funktionen neu definiert wird.  Das bedeutet, dass Sie mit eval () sehr vorsichtig sein müssen und ein normales Inhaltsskript verwenden sollten, wenn Sie können.

+
+ +

Mit devtools.inspectedWindow.eval () geladene Skripte sehen auch keine von c definierten JavaJavaScript-Variablen

+ +

Arbeiten mit Inhaltsskripten

+ +

devtools document hat keinen direkten Zugrif Beachten Sie, dass eine saubere Ansicht des DOM eine Sicherheitsfunktion ist, mit der verhindert werden soll, dass feindliche Seiten Erweiterungen austricksen, indem das Verhalten nativer DOM-Funktionen neu definiert wird.  Das bedeutet, dass Sie mit eval () sehr vorsichtig sein müssen und ein normales Inhaltsskript verwenden sollten, wenn Sie können.<

+ +

Bei einem Skript muss das devtools5-Dokument eine Nachricht senden, in der es aufgefordert wird, das Skript einzufügen.  Die devtools.inspectedWindow.table gibt die ID der Zielregisterkarte an:

+ +

Wenn Sie Nachrichten zwischen den im Zielfenster ausgeführten Inhaltsskripten und einem devtools-Dokument austauschen müssen, sollten Sie {{WebExtAPIRef ("runtime.connect ()")} und {{WebExtAPIRef ("runtime.onConnect") verwenden  ")}}, um eine Verbindung zwischen der Hintergrundseite und dem devtools-Dokument herzustellen.  Die Hintergrundseite kann dann eine Zuordnung zwischen Registerkarten-IDs und {{WebExtAPIRef ("runtime.Port")}} -Objekten verwalten und diese verwenden, um Nachrichten zwischen den beiden Bereichen weiterzuleiten.

+ +

Diese APIs basieren auf den Chrome devtools-APIs, aber im Vergleich zu Chrome fehlen noch viele Funktionen.  In diesem Abschnitt werden die Funktionen aufgeführt, die ab Firefox 54 noch nicht implementiert sind. Beachten Sie, dass sich die devtools-APIs in der aktiven Entwicklung befinden und wir erwarten, dass die meisten davon in zukünftigen Versionen unterstützt werden.

+ + + +

 

diff --git a/files/de/mozilla/add-ons/webextensions/index.html b/files/de/mozilla/add-ons/webextensions/index.html new file mode 100644 index 0000000000..bb1b68b2de --- /dev/null +++ b/files/de/mozilla/add-ons/webextensions/index.html @@ -0,0 +1,86 @@ +--- +title: WebExtensions +slug: Mozilla/Add-ons/WebExtensions +translation_of: Mozilla/Add-ons/WebExtensions +--- +
{{AddonSidebar}}
+ +

WebExtensions sind ein Cross-Browser-System zur Entwicklung von Browser-Add-ons. Das System ist in weiten Teilen kompatibel mit der extension API, welche von Google Chrome und Opera unterstützt wird. Erweiterungen, welche für diese Browser geschrieben wurden, werden in den meisten Fällen mit nur wenigen Anpassungen auch in Firefox oder Microsoft Edge lauffähig sein. Die API ist außerdem vollständig kompatibel mit Multiprozess-Firefox.

+ +

Wir beabsichtigen auch, die APIs zu erweitern, um die Unterstützung für Add-on-Entwickler zu verbessern. Sollten Sie Vorschläge dazu haben, würden wir uns über Ihre Mitteilung freuen. Sie erreichen uns über die englischsprachige Mailingliste für Add-on-Entwickler oder auf #webextensions im IRC.

+ +
+ + +
+

Referenz

+ + + +

JavaScript APIs

+ +
{{ ListSubpages ("/en-US/Add-ons/WebExtensions/API") }}
+ +

Manifest keys

+ +
{{ ListSubpages ("/en-US/Add-ons/WebExtensions/manifest.json") }}
+
+
diff --git a/files/de/mozilla/add-ons/webextensions/manifest.json/commands/index.html b/files/de/mozilla/add-ons/webextensions/manifest.json/commands/index.html new file mode 100644 index 0000000000..6222b35145 --- /dev/null +++ b/files/de/mozilla/add-ons/webextensions/manifest.json/commands/index.html @@ -0,0 +1,184 @@ +--- +title: commands +slug: Mozilla/Add-ons/WebExtensions/manifest.json/commands +tags: + - Add-ons Erweiterungen WebExtensions +translation_of: Mozilla/Add-ons/WebExtensions/manifest.json/commands +--- +
{{AddonSidebar}}
+ + + + + + + + + + + + + + + + +
TypObjekt
ObligatorischNein
Beispiel +
+"commands": {
+  "toggle-feature": {
+    "suggested_key": {
+      "default": "Ctrl+Shift+Y",
+      "linux": "Ctrl+Shift+U"
+    },
+    "description": "Ereignis 'toggle-feature' senden"
+  }
+}
+
+ +

Verwenden Sie dencommands-Schlüssel, um für Ihre Erweiterung eine oder mehrere Tastenkürzel zu definieren.

+ +

Jedes Tastenkürzel wird mit einem Namen, eine Kombination von Tasten und einer Beschreibung definiert. Sobald Sie einige Befehle in der manifest.json definiert haben, können Sie die zugewiesenen Tastenkombinationen mittels der JavaScript-API  {{WebExtAPIRef("commands")}} verwenden.

+ +

Syntax

+ +

Der commands-Schlüsselist ein Objekt, und jedes Tastenkürzel ist eine Eigenschaft von ihm. Der Name der Eigenschaft ist der Name des Tastenkürzels.

+ +

Jedes Tastenkürzel ist selbst ein Objekt, das bis zu zwei Eigenschaften hat:

+ + + +

Die Eigenschaft suggested_key ist selbst ein Objekt, das folgende Eigenschaften haben kann, die alle Zeichenketten sind:

+ + + +

Der Wert jeder Eigenschaft ist das Tastenkürzel für den Befehl auf der angegebenen Plattform, der als Zeichenkette angegeben wird, die die durch ein „+“ voneinander getrennten Tasten enthält. Der Wert für „default“ wird auf allen Plattformen verwendet, die nicht ausdrücklich angegeben sind.

+ +

Beispiel:

+ +
"commands": {
+  "toggle-feature": {
+    "suggested_key": {
+      "default": "Alt+Shift+U",
+      "linux": "Ctrl+Shift+U"
+    },
+    "description": "'toggle-feature'-Ereignis an die Erweiterung senden"
+  },
+  "do-another-thing": {
+    "suggested_key": {
+      "default": "Ctrl+Shift+Y"
+    }
+  }
+}
+ +

Dies definiert zwei Tastenkürzel:

+ + + +

Sie könnten dann den ersten dieser Befehle mit einem Code wie diesen verwenden:

+ +
browser.commands.onCommand.addListener(function(command) {
+  if (command == "toggle-feature") {
+    console.log("toggling the feature!");
+  }
+});
+ +

Besondere Tastenkürzel

+ +

Es gibt drei besondere Tastenkürzel:

+ + + +

Dies definiert zum Beispiel eine Tastenkombination, um auf die Browseraktion der Erweiterung zu klicken:

+ +
"commands": {
+  "_execute_browser_action": {
+    "suggested_key": {
+      "default": "Ctrl+Shift+Y"
+    }
+  }
+}
+ +

Tastenkürzel-Werte

+ +

Es gibt zwei gültige Formate für Tastenkürzel: als Tastenkombination oder als Medien-Taste.

+ +

Tastenkombinationen

+ +
+
Auf Macs wird "Ctrl" als  "Command"-Taste interpretiert, geben Sie also "MacCrtl" an, wenn Sie eigentlich "Ctrl" brauchen.
+
+ +

Tastenkombinationen müssen aus zwei oder mehr Tasten bestehen:

+ + + +

Die Taste wird dann als Zeichenkette angegeben, die den Satz an Tastenwerten enthält, in der oben angegebenen Reihenfolge, getrennt durch "+": zum Beispiel "Ctrl+Shift+Z".

+ +

Wenn eine Tastenkombination bereits vom Browser (zum Beispiel "Ctrl+P") oder durch ein bestehendes Add-on verwendet wird, können Sie sie nicht überschreiben. Sie dürfen sie definieren, aber Ihr Eventhandler wird nicht aufgerufen, wenn der Benutzer sie eingibt.

+ +

Medientasten

+ +

Alternativ kann das Tastenkürzel als eine der folgenden Medientasten angegeben werden:

+ + + +

Beispiel

+ +

Definieren Sie ein einzelnes Tastenkürzel, das nur standardmäßig verwendet wird:

+ +
"commands": {
+  "toggle-feature": {
+    "suggested_key": {
+      "default": "Ctrl+Shift+Y"
+    },
+    "description": "Ereignis'toggle-feature' senden"
+  }
+}
+ +

Definieren Sie zwei Tastenkürzel, eins mit einer plattformspezifischen Tastenkombination:

+ +
"commands": {
+  "toggle-feature": {
+    "suggested_key": {
+      "default": "Alt+Shift+U",
+      "linux": "Ctrl+Shift+U"
+    },
+    "description": "Ereignis 'toggle-feature' senden"
+  },
+  "do-another-thing": {
+    "suggested_key": {
+      "default": "Ctrl+Shift+Y"
+    }
+  }
+}
+ +

Browserkompatibilität

+ + + +

{{Compat("webextensions.manifest.commands")}}

diff --git a/files/de/mozilla/add-ons/webextensions/manifest.json/devtools_page/index.html b/files/de/mozilla/add-ons/webextensions/manifest.json/devtools_page/index.html new file mode 100644 index 0000000000..1b4afb1cfa --- /dev/null +++ b/files/de/mozilla/add-ons/webextensions/manifest.json/devtools_page/index.html @@ -0,0 +1,42 @@ +--- +title: devtools_page +slug: Mozilla/Add-ons/WebExtensions/manifest.json/devtools_page +translation_of: Mozilla/Add-ons/WebExtensions/manifest.json/devtools_page +--- +
{{AddonSidebar}}
+ + + + + + + + + + + + + + + + +
TypeString
MandatoryNo
Example +
+"devtools_page": "devtools/my-page.html"
+
+ +

Use this key to enable your extension to extend the browser's built-in devtools.

+ +

This key is defined as a URL to an HTML file. The HTML file must be bundled with the extension, and the URL is relative to the extension's root.

+ +

See Extending the developer tools to learn more.

+ +

Example

+ +
"devtools_page": "devtools/my-page.html"
+ +

Browser compatibility

+ + + +

{{Compat("webextensions.manifest.devtools_page")}}

diff --git a/files/de/mozilla/add-ons/webextensions/manifest.json/index.html b/files/de/mozilla/add-ons/webextensions/manifest.json/index.html new file mode 100644 index 0000000000..10a4fd8597 --- /dev/null +++ b/files/de/mozilla/add-ons/webextensions/manifest.json/index.html @@ -0,0 +1,105 @@ +--- +title: manifest.json +slug: Mozilla/Add-ons/WebExtensions/manifest.json +tags: + - Add-ons + - Extensions + - NeedsTranslation + - TopicStub + - WebExtensions +translation_of: Mozilla/Add-ons/WebExtensions/manifest.json +--- +
{{AddonSidebar}}
+ +

Die Datei manifest.json ist eine JSON-formatierte Datei, und die einzige Datei, die eine Erweiterung, die das WebExtensions API verwendet, unterstützt.

+ +

Durch das Verwenden von manifest.json, legst du Metadaten, wie zum Beispiel Name und Version, für deine Erweiterung fest, und kannst auch einige Aspekte der Funktionalität deiner Erweiterung,wie zum Beispiel Hintergrundskripte, Inhaltsskripte und Browserationen.

+ +

Manifest.json keys sind unten gelistet:

+ +
{{ ListSubpages ("/en-US/Add-ons/WebExtensions/manifest.json") }}
+ +
 
+ +

"manifest_version", "version", und "name" sind die einzigen verpflichtenden Keys. "default_locale" muss vorhanden sein, wenn der "_locales"-Ordner vorhanden ist und darf sonst nicht vorhanden sein. "applications" wird von Google Chrome nicht unterstützt, und ist verpflichtend in Firefox vor Firefox 48 und Firefox für Android.

+ +

Browserkompatiblität

+ +

{{Compat("webextensions.manifest")}}

+ +

Beispiel

+ +

Hier ein kurzes Syntax-Beispiel für manifest.json:

+ +
{
+  "applications": {
+    "gecko": {
+      "id": "addon@example.com",
+      "strict_min_version": "42.0"
+    }
+  },
+
+  "background": {
+    "scripts": ["jquery.js", "my-background.js"],
+    "page": "my-background.html"
+  },
+
+  "browser_action": {
+    "default_icon": {
+      "19": "button/geo-19.png",
+      "38": "button/geo-38.png"
+    },
+    "default_title": "Whereami?",
+    "default_popup": "popup/geo.html"
+  },
+
+  "commands": {
+    "toggle-feature": {
+      "suggested_key": {
+        "default": "Ctrl+Shift+Y",
+        "linux": "Ctrl+Shift+U"
+      },
+      "description": "Send a 'toggle-feature' event"
+    }
+  },
+
+  "content_security_policy": "script-src 'self' https://example.com; object-src 'self'",
+
+  "content_scripts": [
+    {
+      "exclude_matches": ["*://developer.mozilla.org/*"],
+      "matches": ["*://*.mozilla.org/*"],
+      "js": ["borderify.js"]
+    }
+  ],
+
+  "default_locale": "en",
+
+  "description": "...",
+
+  "icons": {
+    "48": "icon.png",
+    "96": "icon@2x.png"
+  },
+
+  "manifest_version": 2,
+
+  "name": "...",
+
+  "page_action": {
+    "default_icon": {
+      "19": "button/geo-19.png",
+      "38": "button/geo-38.png"
+    },
+    "default_title": "Whereami?",
+    "default_popup": "popup/geo.html"
+  },
+
+  "permissions": ["webNavigation"],
+
+  "version": "0.1",
+
+  "web_accessible_resources": ["images/my-image.png"]
+}
+ +

 

diff --git a/files/de/mozilla/add-ons/webextensions/manifest.json/theme/index.html b/files/de/mozilla/add-ons/webextensions/manifest.json/theme/index.html new file mode 100644 index 0000000000..30825db592 --- /dev/null +++ b/files/de/mozilla/add-ons/webextensions/manifest.json/theme/index.html @@ -0,0 +1,1361 @@ +--- +title: theme +slug: Mozilla/Add-ons/WebExtensions/manifest.json/theme +translation_of: Mozilla/Add-ons/WebExtensions/manifest.json/theme +--- +
{{AddonSidebar}}
+ + + + + + + + + + + + + + + + +
TypeObject
MandatoryNo
Example +
+"theme": {
+  "images": {
+    "theme_frame": "images/sun.jpg"
+  },
+  "colors": {
+    "frame": "#CF723F",
+    "tab_background_text": "#000"
+  }
+}
+
+ +

Use the theme key to define a static theme to apply to Firefox.

+ +
+

Note: If you want to include a theme with an extension, please see the {{WebExtAPIRef("theme")}} API.

+
+ +
+

Note: Since May 2019, themes need to be signed to be installed ({{bug(1545109)}}).  See Signing and distributing your add-on for more details.

+
+ +
+

Theme support in Firefox for Android: A new version of Firefox for Android, based on GeckoView, is under development. A pre-release version is available. The pre-release version does not support themes.

+
+ +

Image formats

+ +

The following image formats are supported in all theme image properties:

+ + + +

Syntax

+ +

The theme key is an object that takes the following properties:

+ + + + + + + + + + + + + + + + + + + + + + + + + + +
NameTypeDescription
imagesObject +

Optional as of Firefox 60. Mandatory before Firefox 60.

+ +

A JSON object whose properties represent the images to display in various parts of the browser. See images for details on the properties that this object can contain.

+
colorsObject +

Mandatory.

+ +

A JSON object whose properties represent the colors of various parts of the browser. See colors for details on the properties that this object can contain.

+
propertiesObject +

Optional

+ +

This object has two properties that affect how the "additional_backgrounds" images are displayed. See properties for details on the properties that this object can contain.

+ +
    +
  • "additional_backgrounds_alignment": an array of enumeration values defining the alignment of the corresponding "additional_backgrounds": array item.
    + The alignment options include: "bottom", "center", "left", "right", "top", "center bottom", "center center", "center top", "left bottom", "left center", "left top", "right bottom", "right center", and "right top". If not specified, defaults to "right top".
    + Optional
  • +
  • "additional_backgrounds_tiling": an array of enumeration values defining how the corresponding "additional_backgrounds": array item repeats, with support for "no-repeat", "repeat", "repeat-x", and "repeat-y". If not specified, defaults to "no-repeat".
    + Optional
  • +
+
+ +

images

+ +

All URLs are relative to the manifest.json file and cannot reference an external URL.

+ +

Images should be 200 pixels high to ensure they always fill the header space vertically.

+ + + + + + + + + + + + + + + + + + + + + + + + + + +
NameTypeDescription
headerURL {{Deprecated_Inline}}String +
+

headerURL has been removed in Firefox 70. You will begin to get warnings in Firefox 65 and later if you load a theme that uses this property. Use theme_frame instead.

+
+ +

The URL of a foreground image to be added to the header area and anchored to the upper right corner of the header area.

+ +

Optional in desktop Firefox from Firefox 60 onwards. One of theme_frame or headerURL had to be specified before Firefox 60. Note also that in Firefox 60 onwards, any {{cssxref("text-shadow")}} applied to the header text is removed if no headerURL is specified (see {{bug(1404688)}}).

+ +

In Firefox for Android, headerURL or theme_frame  must be specified.

+
theme_frameString +

The URL of a foreground image to be added to the header area and anchored to the upper right corner of the header area.

+ +
+

Chrome anchors the image to the top left of the header and if the image doesn’t fill the header area tile the image.

+
+ +

Optional in desktop Firefox 60 onwards. One of theme_frame or headerURL had to be specified before Firefox 60.

+ +

In Firefox for Android, headerURL or theme_frame  must be specified.

+
additional_backgroundsArray of String +
+

The additional_backgrounds property is experimental. It is currently accepted in release versions of Firefox, but its behavior is subject to change. It is not supported in Firefox for Android.

+
+ +

An array of URLs for additional background images to be added to the header area and displayed behind the "theme_frame": image. These images layer the first image in the array on top, the last image in the array at the bottom.

+ +

Optional.

+ +

By default all images are anchored to the upper right corner of the header area, but their alignment and repeat behavior can be controlled by properties of "properties":.

+
+ +

colors

+ +

These properties define the colors used for different parts of the browser. They are all optional (but note that "accentcolor" and "textcolor" were mandatory in Firefox before version 63).  How these properties affect the Firefox UI  is shown here:

+ + + + + + + +
+

Overview of the color properties and how they apply to Firefox UI components

+
+ +
+

Where a component is affected by multiple color properties, the properties are listed in order of precedence.

+
+ +

All these properties can be specified as either a string containing any valid CSS color string (including hexadecimal), or an RGB array, such as "tab_background_text": [ 107 , 99 , 23 ].

+ +
+

In Chrome, colors may only be specified as RGB arrays.

+ +

In Firefox for Android colors can be specified using:

+ + + +

Colors for Firefox for Android themes cannot be specified using color names.

+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
NameDescription
+

accentcolor {{Deprecated_Inline}}

+
+
+

accentcolor has been removed in Firefox 70. You will begin to get warnings in Firefox 65 and later if you load a theme that uses this property. Use the frame property instead.

+
+ +

The color of the header area background, displayed in the part of the header not covered or visible through the images specified in "headerURL" and "additional_backgrounds".

+ +
See example + +
+"theme": {
+  "colors": {
+     "accentcolor": "red",
+     "tab_background_text": "white"
+  }
+}
+
+ +

+
bookmark_text +

The color of text and icons in the bookmark and find bars. Also, if tab_text isn't defined it sets the color of the active tab text and if icons isn't defined the color of the toolbar icons. Provided as Chrome compatible alias for toolbar_text.

+ +
+

Ensure any color used contrasts well with those used in frame and frame_inactive or toolbar if you're using that property.

+ +

Where icons isn't defined, also ensure good contrast with button_background_active and button_background_hover.

+
+ +
See example + +
+"theme": {
+  "colors": {
+    "frame": "black",
+    "tab_background_text": "white",
+    "tab_text": "white",
+    "toolbar": "black",
+    "bookmark_text": "red"
+  }
+}
+
+ +

Example use of the bookmark_text color property

+
button_background_active +

The color of the background of the pressed toolbar buttons.

+ +
See example + +
+"theme": {
+  "colors": {
+     "frame": "black",
+     "tab_background_text": "white",
+     "button_background_active": "red"
+  }
+}
+
+ +

+
button_background_hover +

The color of the background of the toolbar buttons on hover.

+ +
See example + +
+"theme": {
+  "colors": {
+     "frame": "black",
+     "tab_background_text": "white",
+     "button_background_hover": "red"
+  }
+}
+
+ +

+
icons +

The color of toolbar icons, excluding those in the find toolbar.

+ +
+

Ensure the color used contrasts well with those used in frameframe_inactive, button_background_active, and button_background_hover.

+
+ +
See example + +
+"theme": {
+  "colors": {
+     "frame": "black",
+     "tab_background_text": "white",
+     "icons": "red"
+  }
+}
+
+ +

+
icons_attention +

The color of toolbar icons in attention state such as the starred bookmark icon or finished download icon.

+ +
+

Ensure the color used contrasts well with those used in frameframe_inactive, button_background_active, and button_background_hover.

+
+ +
See example + +
+"theme": {
+  "colors": {
+     "frame": "black",
+     "tab_background_text": "white",
+     "icons_attention": "red"
+  }
+}
+
+ +

+
frame +

The color of the header area background, displayed in the part of the header not covered or visible through the images specified in "theme_frame" and "additional_backgrounds".

+ +
See example + +
+"theme": {
+  "colors": {
+     "frame": "red",
+     "tab_background_text": "white"
+  }
+}
+
+ +

+
frame_inactive +

The color of the header area background when the browser window is inactive, displayed in the part of the header not covered or visible through the images specified in "theme_frame" and "additional_backgrounds".

+ +
See example + +
+"theme": {
+  "colors": {
+     "frame": "red",
+     "frame_inactive": "gray",
+     "tab_text": "white"
+  }
+}
+
+ +

Example use of the frame_inactive color property

+
ntp_background +

The new tab page background color.

+ +
See example + +
+"theme": {
+  "colors": {
+     "ntp_background": "red",
+     "ntp_text": "white"
+  }
+}
+
+ +

+
ntp_text +

The new tab page text color.

+ +
+

Ensure the color used contrasts well with that used in ntp_background.

+
+ +
See example + +
+"theme": {
+  "colors": {
+     "ntp_background": "red",
+     "ntp_text": "white"
+  }
+}
+
+ +

+
popup +

The background color of popups (such as the url bar dropdown and the arrow panels).

+ +
See example + +
+"theme": {
+  "colors": {
+     "frame": "black",
+     "tab_background_text": "white",
+     "popup": "red"
+  }
+}
+
+ +

+
popup_border +

The border color of popups.

+ +
See example + +
+"theme": {
+  "colors": {
+     "frame": "black",
+     "tab_background_text": "white",
+     "popup": "black",
+     "popup_text": "white",
+     "popup_border": "red"
+  }
+}
+
+ +

+
popup_highlight +

The background color of items highlighted using the keyboard inside popups (such as the selected url bar dropdown item).

+ +
+

It's recommended to define popup_highlight_text to override the browser default text color on various platforms.

+
+ +
See example + +
+"theme": {
+  "colors": {
+     "frame": "black",
+     "tab_background_text": "white",
+     "popup_highlight": "red",
+     "popup_highlight_text": "white"
+  }
+}
+
+ +

+
popup_highlight_text +

The text color of items highlighted inside popups.

+ +
+

Ensure the color used contrasts well with that used in popup_highlight.

+
+ +
See example + +
+"theme": {
+  "colors": {
+     "frame": "black",
+     "tab_background_text": "white",
+     "popup_highlight": "black",
+     "popup_highlight_text": "red"
+  }
+}
+
+ +

+
popup_text +

The text color of popups.

+ +
+

Ensure the color used contrasts well with that used in popup.

+
+ +
See example + +
+"theme": {
+  "colors": {
+     "frame": "black",
+     "tab_background_text": "white",
+     "popup": "black",
+     "popup_text": "red"
+  }
+}
+
+ +

+
sidebar +

The background color of the sidebar.

+ +
See example + +
+"theme": {
+  "colors": {
+     "sidebar": "red",
+     "sidebar_highlight": "white",
+     "sidebar_highlight_text": "green",
+     "sidebar_text": "white"
+  }
+}
+
+ +

+
sidebar_border +

The border and splitter color of the browser sidebar

+ +
See example + +
+"theme": {
+  "colors": {
+     "sidebar_border": "red"
+  }
+}
+
+ +

+
sidebar_highlight +

The background color of highlighted rows in built-in sidebars

+ +
See example + +
+"theme": {
+  "colors": {
+     "sidebar_highlight": "red",
+     "sidebar_highlight_text": "white"
+  }
+}
+
+ +

+
sidebar_highlight_text +

The text color of highlighted rows in sidebars.

+ +
+

Ensure the color used contrasts well with that used in sidebar_highlight.

+
+ +
See example + +
+"theme": {
+  "colors": {
+    "sidebar_highlight": "pink",
+    "sidebar_highlight_text": "red",
+  }
+}
+
+ +

+
sidebar_text +

The text color of sidebars.

+ +
+

Ensure the color used contrasts well with that used in sidebar.

+
+ +
See example + +
+"theme": {
+  "colors": {
+     "sidebar": "red",
+     "sidebar_highlight": "white",
+     "sidebar_highlight_text": "green",
+     "sidebar_text": "white"
+  }
+}
+
+ +

+
tab_background_separator +

The color of the vertical separator of the background tabs.

+ +
See example + +
+"theme": {
+  "colors": {
+     "frame": "black",
+     "tab_background_text": "white",
+     "tab_background_separator": "red"
+  }
+}
+
+ +

A closeup of browser tabs to highlight the separator.

+
tab_background_text +

The color of the text displayed in the inactive page tabs. If tab_text or bookmark_text isn't specified, applies to the active tab text.

+ +
+

Ensure the color used contrasts well with those used in tab_selected or frame and  frame_inactive.

+
+ +
See example + +
+"theme": {
+  "colors": {
+    "frame": "black",
+    "toolbar": "white",
+    "tab_background_text": "red"
+  }
+}
+
+ +

+
tab_line +

The color of the selected tab line.

+ +
See example + +
+"theme": {
+  "colors": {
+     "frame": "black",
+     "tab_background_text": "white",
+     "tab_line": "red"
+  }
+}
+
+ +

+
tab_loading +

The color of the tab loading indicator and the tab loading burst.

+ +
See example + +
+"theme": {
+  "colors": {
+     "frame": "black",
+     "tab_background_text": "white",
+     "tab_loading": "red"
+  }
+}
+
+ +

+
tab_selected +

The background color of the selected tab. When not in use selected tab color is set by frame and the frame_inactive.

+ +
See example + +
+"theme": {
+  "images": {
+  "theme_frame": "weta.png"
+},
+  "colors": {
+     "frame": "black",
+     "tab_background_text": "white",
+     "tab_selected": "red"
+  }
+}
+
+ +

+
tab_text +

From Firefox 59, it represents the text color for the selected tab. If tab_line isn't specified, it also defines the color of the selected tab line.

+ +
+

Ensure the color used contrasts well with those used in tab_selected or frame and  frame_inactive.

+
+ +

From Firefox 55 to 58, it is incorrectly implemented as alias for "textcolor"

+ +
See example + +
+"theme": {
+  "images": {
+  "theme_frame": "weta.png"
+},
+  "colors": {
+     "frame": "black",
+     "tab_background_text": "white",
+     "tab_selected": "white",
+     "tab_text": "red"
+  }
+}
+
+ +

+
textcolor {{Deprecated_Inline}} +
+

textcolor has been removed in Firefox 70. You will begin to get warnings in Firefox 65 and later if you load a theme that uses this property. Use tab_background_text instead.

+
+ +

The color of the text displayed in the header area.

+ +
See example + +
+"theme": {
+  "colors": {
+    "frame": "black",
+    "toolbar": "white",
+    "textcolor": "red"
+  }
+}
+
+ +

+
toolbar +

The background color for the navigation bar, the bookmarks bar, and the selected tab.

+ +

This also sets the background color of the "Find" bar.

+ +
See example + +
+"theme": {
+  "colors": {
+    "frame": "black",
+    "toolbar": "red",
+    "tab_background_text": "white"
+  }
+}
+
+ +

+
toolbar_bottom_separator +

The color of the line separating the bottom of the toolbar from the region below.

+ +
See example + +
+"theme": {
+  "colors": {
+    "frame": "black",
+    "tab_background_text": "white",
+    "toolbar_bottom_separator": "red"
+  }
+}
+
+ +

+
toolbar_field +

The background color for fields in the toolbar, such as the URL bar.

+ +

This also sets the background color of the Find in page field.

+ +
See example + +
+"theme": {
+  "colors": {
+    "frame": "black",
+    "tab_background_text": "white",
+    "toolbar_field": "red"
+  }
+}
+
+ +

+
toolbar_field_border +

The border color for fields in the toolbar.

+ +

This also sets the border color of the Find in page field.

+ +
See example + +
+"theme": {
+  "colors": {
+    "frame": "black",
+    "toolbar": "black",
+    "tab_background_text": "white",
+    "toolbar_field": "black",
+    "toolbar_field_text": "white",
+    "toolbar_field_border": "red"
+  }
+}
+
+ +

+
toolbar_field_border_focus +

The focused border color for fields in the toolbar.

+ +
See example + +
+"theme": {
+  "colors": {
+    "frame": "black",
+    "toolbar": "black",
+    "tab_background_text": "white",
+    "toolbar_field": "black",
+    "toolbar_field_text": "white",
+    "toolbar_field_border_focus": "red"
+  }
+}
+
+ +

+
toolbar_field_focus +

The focused background color for fields in the toolbar, such as the URL bar.

+ +
See example + +
+"theme": {
+  "colors": {
+    "frame": "black",
+    "toolbar": "black",
+    "tab_background_text": "white",
+    "toolbar_field": "black",
+    "toolbar_field_text": "white",
+    "toolbar_field_focus": "red"
+  }
+}
+
+ +

+
toolbar_field_highlightThe background color used to indicate the current selection of text in the URL bar (and the search bar, if it's configured to be separate). +
See example +
+"theme": {
+  "colors": {
+    "toolbar_field": "rgba(255, 255, 255, 0.91)",
+    "toolbar_field_text": "rgb(0, 100, 0)",
+    "toolbar_field_highlight": "rgb(180, 240, 180, 0.9)",
+    "toolbar_field_highlight_text": "rgb(0, 80, 0)"
+  }
+}
+
+ +

Example showing customized text and highlight colors in the URL bar

+ +

Here, the toolbar_field_highlight field specifies that the highlight color is a light green, while the text is set to a dark-to-medium green using toolbar_field_highlight_text.

+
toolbar_field_highlight_text +

The color used to draw text that's currently selected in the URL bar (and the search bar, if it's configured to be separate box).

+ +
+

Ensure the color used contrasts well with those used in toolbar_field_highlight.

+
+ +
See example + +
+"theme": {
+  "colors": {
+    "toolbar_field": "rgba(255, 255, 255, 0.91)",
+    "toolbar_field_text": "rgb(0, 100, 0)",
+    "toolbar_field_highlight": "rgb(180, 240, 180, 0.9)",
+    "toolbar_field_highlight_text": "rgb(0, 80, 0)"
+  }
+}
+
+ +

Example showing customized text and highlight colors in the URL bar

+ +

Here, the toolbar_field_highlight_text field is used to set the text color to a dark medium-dark green, while the highlight color is  a light green.

+
toolbar_field_separator +

The color of separators inside the URL bar. In Firefox 58 this was implemented as toolbar_vertical_separator.

+ +
See example + +
+"theme": {
+  "colors": {
+    "frame": "black",
+    "toolbar": "black",
+    "tab_background_text": "white",
+    "toolbar_field_separator": "red"
+  }
+}
+
+ +

+ +

In this screenshot, "toolbar_vertical_separator" is the white vertical line in the URL bar dividing the Reader Mode icon from the other icons.

+
toolbar_field_text +

The color of text in fields in the toolbar, such as the URL bar. This also sets the color of text in the Find in page field.

+ +
+

Ensure the color used contrasts well with those used in toolbar_field.

+
+ +
See example + +
+"theme": {
+  "colors": {
+    "frame": "black",
+    "toolbar": "black",
+    "tab_background_text": "white",
+    "toolbar_field": "black",
+    "toolbar_field_text": "red"
+  }
+}
+
+ +

+
toolbar_field_text_focus +

The color of text in focused fields in the toolbar, such as the URL bar.

+ +
+

Ensure the color used contrasts well with those used in toolbar_field_focus.

+
+ +
See example + +
+"theme": {
+  "colors": {
+    "frame": "black",
+    "toolbar": "black",
+    "tab_background_text": "white",
+    "toolbar_field": "black",
+    "toolbar_field_text": "white",
+    "toolbar_field_text_focus": "red"
+  }
+}
+
+ +

+
toolbar_text +

The color of toolbar text. This also sets the color of  text in the "Find" bar.

+ +
+

For compatibility with Chrome, use the alias bookmark_text.

+
+ +
See example + +
+"theme": {
+  "colors": {
+    "frame": "black",
+    "tab_background_text": "white",
+    "toolbar": "black",
+    "toolbar_text": "red"
+  }
+}
+
+ +

+
toolbar_top_separator +

The color of the line separating the top of the toolbar from the region above.

+ +
See example + +
+"theme": {
+  "colors": {
+    "frame": "black",
+    "tab_background_text": "white",
+    "toolbar": "black",
+    "toolbar_top_separator": "red"
+  }
+}
+
+ +

+
toolbar_vertical_separator +

The color of the separator next to the application menu icon. In Firefox 58, it corresponds to the color of separators inside the URL bar.

+ +
See example + +
+"theme": {
+  "colors": {
+    "frame": "black",
+    "tab_background_text": "white",
+    "toolbar": "black",
+    "toolbar_vertical_separator": "red"
+  }
+}
+
+ +

+
+ +

Aliases

+ +

Additionally, this key accepts various properties that are aliases for one of the properties above. These are provided for compatibility with Chrome. If an alias is given, and the non-alias version is also given, then the value will be taken from the non-alias version.

+ +
+

Beginning Firefox 70, the following properties are removed: accentcolor and textcolor. Use frame and tab_background_text instead. Using these values in themes loaded into Firefox 65 or later will raise warnings.

+
+ + + + + + + + + + + + + + + + + + + + + + + + + + +
NameAlias for
bookmark_texttoolbar_text
frameaccentcolor {{Deprecated_Inline}}
frame_inactiveaccentcolor {{Deprecated_Inline}}
tab_background_texttextcolor {{Deprecated_Inline}}
+ +

properties

+ + + + + + + + + + + + + + + + + + + + + +
NameTypeDescription
additional_backgrounds_alignment +

Array of String

+
+

Optional.

+ +

An array of enumeration values defining the alignment of the corresponding "additional_backgrounds": array item.
+ The alignment options include:

+ +
    +
  • "bottom"
  • +
  • "center"
  • +
  • "left"
  • +
  • "right"
  • +
  • "top"
  • +
  • "center bottom"
  • +
  • "center center"
  • +
  • "center top"
  • +
  • "left bottom"
  • +
  • "left center"
  • +
  • "left top"
  • +
  • "right bottom"
  • +
  • "right center"
  • +
  • "right top".
  • +
+ +

If not specified, defaults to "right top".

+
additional_backgrounds_tiling +

Array of String

+
+

Optional.

+ +

An array of enumeration values defining how the corresponding "additional_backgrounds": array item repeats. Options include:

+ +
    +
  • "no-repeat"
  • +
  • "repeat"
  • +
  • "repeat-x"
  • +
  • "repeat-y"
  • +
+ +

If not specified, defaults to "no-repeat".

+
+ +

Examples

+ +

A basic theme must define an image to add to the header, the accent color to use in the header, and the color of text used in the header:

+ +
 "theme": {
+   "images": {
+     "theme_frame": "images/sun.jpg"
+   },
+   "colors": {
+     "frame": "#CF723F",
+     "tab_background_text": "#000"
+   }
+ }
+ +

Multiple images can be used to fill the header. Before Firefox version 60, use a blank or transparent header image to gain control over the placement of each additional image:

+ +
 "theme": {
+   "images": {
+     "additional_backgrounds": [ "images/left.png" , "images/middle.png", "images/right.png"]
+   },
+   "properties": {
+     "additional_backgrounds_alignment": [ "left top" , "top", "right top"]
+   },
+   "colors": {
+     "frame": "blue",
+     "tab_background_text": "#ffffff"
+   }
+ }
+ +

You can also fill the header with a repeated image, or images, in this case a single image anchored in the middle top of the header and repeated across the rest of the header:

+ +
 "theme": {
+   "images": {
+     "additional_backgrounds": [ "images/logo.png"]
+   },
+   "properties": {
+     "additional_backgrounds_alignment": [ "top" ],
+     "additional_backgrounds_tiling": [ "repeat"  ]
+   },
+   "colors": {
+     "frame": "green",
+     "tab_background_text": "#000"
+   }
+ }
+ +

The following example uses most of the different values for theme.colors:

+ +
  "theme": {
+    "images": {
+      "theme_frame": "weta.png"
+    },
+
+    "colors": {
+       "frame": "darkgreen",
+       "tab_background_text": "white",
+       "toolbar": "blue",
+       "bookmark_text": "cyan",
+       "toolbar_field": "orange",
+       "toolbar_field_border": "white",
+       "toolbar_field_text": "green",
+       "toolbar_top_separator": "red",
+       "toolbar_bottom_separator": "white",
+       "toolbar_vertical_separator": "white"
+    }
+  }
+ +

It will give you a browser that looks like this:

+ +

+ +

In this screenshot, "toolbar_vertical_separator" is the white vertical line in the URL bar dividing the Reader Mode icon from the other icons.

+ +

Browser compatibility

+ + + +

{{Compat("webextensions.manifest.theme")}}

+ +

Colors

+ +

{{Compat("webextensions.manifest.theme.colors", 10)}}

+ +

Images

+ +

{{Compat("webextensions.manifest.theme.images", 10)}}

+ +

Properties

+ +

{{Compat("webextensions.manifest.theme.properties", 10)}}

+ +

Chrome compatibility

+ +

In Chrome:

+ + diff --git a/files/de/mozilla/add-ons/webextensions/match_patterns/index.html b/files/de/mozilla/add-ons/webextensions/match_patterns/index.html new file mode 100644 index 0000000000..6c4694c922 --- /dev/null +++ b/files/de/mozilla/add-ons/webextensions/match_patterns/index.html @@ -0,0 +1,430 @@ +--- +title: Match patterns in extension manifests +slug: Mozilla/Add-ons/WebExtensions/Match_patterns +translation_of: Mozilla/Add-ons/WebExtensions/Match_patterns +--- +
{{AddonSidebar}}
+ +

Match patterns are a way to specify groups of URLs: a match pattern matches a specific set of URLs. They are used in WebExtensions APIs in a few places, most notably to specify which documents to load content scripts into, and to specify which URLs to add webRequest listeners to.

+ +

APIs that use match patterns usually accept a list of match patterns, and will perform the appropriate action if the URL matches any of the patterns. See, for example, the content_scripts key in manifest.json.

+ +

Match pattern structure

+ +
+

Note: Some browsers don’t support certain schemes.
+ Check the Browser compatibility table for details.

+
+ +

All match patterns are specified as strings. Apart from the special <all_urls> pattern, match patterns consist of three parts: scheme, host, and path. The scheme and host are separated by ://.

+ +
<scheme>://<host><path>
+ +

scheme

+ +

The scheme component may take one of two forms:

+ + + + + + + + + + + + + + + + + + +
FormMatches
*Only "http" and "https" and in some browsers also "ws" and "wss".
One of http, https, ws, wss, ftp, ftps, data or file.Only the given scheme.
+ +

host

+ +

The host component may take one of three forms:

+ + + + + + + + + + + + + + + + + + + + + + +
FormMatches
*Any host.
*. followed by part of the hostname.The given host and any of its subdomains.
A complete hostname, without wildcards.Only the given host.
+ +

host must not include a port number.

+ +

host is optional only if the scheme is "file".

+ +

Note that the wildcard may only appear at the start.

+ +

path

+ +

The path component must begin with a /.

+ +

After that, it may subsequently contain any combination of the * wildcard and any of the characters that are allowed in URL paths or query strings. Unlike host, the path component may contain the * wildcard in the middle or at the end, and the * wildcard may appear more than once.

+ +

The value for the path matches against the string which is the URL path plus the URL query string. This includes the ? between the two, if the query string is present in the URL. For example, if you want to match URLs on any domain where the URL path ends with foo.bar, then you need to use an array of Match Patterns like ['*://*/*foo.bar', '*://*/*foo.bar?*']. The ?* is needed, rather than just bar*, in order to anchor the ending * as applying to the URL query string and not some portion of the URL path.

+ +

Neither the URL fragment identifier, nor the # which precedes it, are considered as part of the path.

+ +
+

Note: The path pattern string should not include a port number. Adding a port, as in: "http://localhost:1234/*" causes the match pattern to be ignored. However, "http://localhost:1234" will match with "http://localhost/*"

+
+ +

<all_urls>

+ +

The special value <all_urls> matches all URLs under any of the supported schemes: that is "http", "https", "ws", "wss", "ftp", "data", and "file".

+ +

Examples

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
PatternExample matchesExample non-matches
+

<all_urls>

+ +

Match all URLs.

+
+

http://example.org/

+ +

https://a.org/some/path/

+ +

ws://sockets.somewhere.org/

+ +

wss://ws.example.com/stuff/

+ +

ftp://files.somewhere.org/

+ +

ftps://files.somewhere.org/

+
+

resource://a/b/c/
+ (unsupported scheme)

+
+

*://*/*

+ +

Match all HTTP, HTTPS and WebSocket URLs.

+
+

http://example.org/

+ +

https://a.org/some/path/

+ +

ws://sockets.somewhere.org/

+ +

wss://ws.example.com/stuff/

+
+

ftp://ftp.example.org/
+ (unmatched scheme)

+ +

ftps://ftp.example.org/
+ (unmatched scheme)

+ +

file:///a/
+ (unmatched scheme)

+
+

*://*.mozilla.org/*

+ +

Match all HTTP, HTTPS and WebSocket URLs that are hosted at "mozilla.org" or one of its subdomains.

+
+

http://mozilla.org/

+ +

https://mozilla.org/

+ +

http://a.mozilla.org/

+ +

http://a.b.mozilla.org/

+ +

https://b.mozilla.org/path/

+ +

ws://ws.mozilla.org/

+ +

wss://secure.mozilla.org/something

+
+

ftp://mozilla.org/
+ (unmatched scheme)

+ +

http://mozilla.com/
+ (unmatched host)

+ +

http://firefox.org/
+ (unmatched host)

+
+

*://mozilla.org/

+ +

Match all HTTP, HTTPS and WebSocket URLs that are hosted at exactly "mozilla.org/".

+
+

http://mozilla.org/

+ +

https://mozilla.org/

+ +

ws://mozilla.org/

+ +

wss://mozilla.org/

+
+

ftp://mozilla.org/
+ (unmatched scheme)

+ +

http://a.mozilla.org/
+ (unmatched host)

+ +

http://mozilla.org/a
+ (unmatched path)

+
+

ftp://mozilla.org/

+ +

Match only "ftp://mozilla.org/".

+
ftp://mozilla.org +

http://mozilla.org/
+ (unmatched scheme)

+ +

ftp://sub.mozilla.org/
+ (unmatched host)

+ +

ftp://mozilla.org/path
+ (unmatched path)

+
+

https://*/path

+ +

Match HTTPS URLs on any host, whose path is "path".

+
+

https://mozilla.org/path

+ +

https://a.mozilla.org/path

+ +

https://something.com/path

+
+

http://mozilla.org/path
+ (unmatched scheme)

+ +

https://mozilla.org/path/
+ (unmatched path)

+ +

https://mozilla.org/a
+ (unmatched path)

+ +

https://mozilla.org/
+ (unmatched path)

+ +

https://mozilla.org/path?foo=1
+ (unmatched path due to URL query string)

+
+

https://*/path/

+ +

Match HTTPS URLs on any host, whose path is "path/" and which has no URL query string.

+
+

https://mozilla.org/path/

+ +

https://a.mozilla.org/path/

+ +

https://something.com/path/

+
+

http://mozilla.org/path/
+ (unmatched scheme)

+ +

https://mozilla.org/path
+ (unmatched path)

+ +

https://mozilla.org/a
+ (unmatched path)

+ +

https://mozilla.org/
+ (unmatched path)

+ +

https://mozilla.org/path/?foo=1
+ (unmatched path due to URL query string)

+
+

https://mozilla.org/*

+ +

Match HTTPS URLs only at "mozilla.org", with any URL path and URL query string.

+
+

https://mozilla.org/

+ +

https://mozilla.org/path

+ +

https://mozilla.org/another

+ +

https://mozilla.org/path/to/doc

+ +

https://mozilla.org/path/to/doc?foo=1

+
+

http://mozilla.org/path
+ (unmatched scheme)

+ +

https://mozilla.com/path
+ (unmatched host)

+
+

https://mozilla.org/a/b/c/

+ +

Match only this URL, or this URL with any URL fragment.

+
+

https://mozilla.org/a/b/c/

+ +

https://mozilla.org/a/b/c/#section1

+
Anything else.
+

https://mozilla.org/*/b/*/

+ +

Match HTTPS URLs hosted on "mozilla.org", whose path contains a component "b" somewhere in the middle. Will match URLs with query strings, if the string ends in a /.

+
+

https://mozilla.org/a/b/c/

+ +

https://mozilla.org/d/b/f/

+ +

https://mozilla.org/a/b/c/d/

+ +

https://mozilla.org/a/b/c/d/#section1

+ +

https://mozilla.org/a/b/c/d/?foo=/

+ +

https://mozilla.org/a?foo=21314&bar=/b/&extra=c/

+
+

https://mozilla.org/b/*/
+ (unmatched path)

+ +

https://mozilla.org/a/b/
+ (unmatched path)

+ +

https://mozilla.org/a/b/c/d/?foo=bar
+ (unmatched path due to URL query string)

+
+

file:///blah/*

+ +

Match any FILE URL whose path begins with "blah".

+
+

file:///blah/

+ +

file:///blah/bleh

+
file:///bleh/
+ (unmatched path)
+ +

Invalid match patterns

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Invalid patternReason
resource://path/Unsupported scheme.
https://mozilla.orgNo path.
https://mozilla.*.org/"*" in host must be at the start.
https://*zilla.org/"*" in host must be the only character or be followed by ".".
http*://mozilla.org/"*" in scheme must be the only character.
https://mozilla.org:80/Host must not include a port number.
*://*Empty path: this should be "*://*/*".
file://*Empty path: this should be "file:///*".
+ +

Browser compatibility

+ +

scheme

+ + + +

{{Compat("webextensions.match_patterns.scheme",10)}}

diff --git a/files/de/mozilla/add-ons/webextensions/what_are_webextensions/index.html b/files/de/mozilla/add-ons/webextensions/what_are_webextensions/index.html new file mode 100644 index 0000000000..85498e8b30 --- /dev/null +++ b/files/de/mozilla/add-ons/webextensions/what_are_webextensions/index.html @@ -0,0 +1,24 @@ +--- +title: Was sind WebExtensions? +slug: Mozilla/Add-ons/WebExtensions/What_are_WebExtensions +tags: + - WebExtensions +translation_of: Mozilla/Add-ons/WebExtensions/What_are_WebExtensions +--- +
{{AddonSidebar}}
+ +

WebExtensions erweitern und modifizieren die Funktionen eines Web-Browsers. Sie werden unter Verwendung von Standard-Webtechnologien - JavaScript, HTML und CSS - sowie zusätzlichen speziell dafür vorgesehenen JavaScript APIs erstellt. Unter anderem können mit so einer Erweiterung neue Funktionen zum Browser hinzufügt, das Erscheinungsbild oder der Inhalt bestimmter Webseiten verändert werden.

+ +

Erweiterungen für Firefox werden mit Hilfe von WebExtensions APIs erstellt, einem Cross-Browser-System zum Entwickeln von Browsererweiterungen. Zum größten Teil ist die API kompatibel mit der extension API für Google Chrome und Opera. Erweiterungen, die für diese Browser erstellt wurden, laufen in den meisten Fällen mit wenigen Änderungen in Firefox oder Microsoft Edge. Die API ist ebenfalls vollständig mit Multiprozess-Firefox kompatibel.

+ +

Vor WebExtensions gab es drei unterschiedliche Möglichkeiten, Erweiterungen für Firefox zu erstellen: XUL/XPCOM overlays, bootstrapped extensions und das Add-on SDK. Seit Ende November 2017 sind WebExtensions APIs die einzige Möglichkeit, Firefox-Erweiterungen zu entwickeln, die vorherigen Systeme gelten als veraltet.

+ +

Wir sind stets bemüht, die API ständig zu erweitern, um den Anforderungen der Add-on-Entwickler gerecht zu werden. Sollten Sie Anregungen dazu haben, würden wir uns über Ihre Mitteilung auf der englischsprachigen Mailingliste für Add-on-Entwickler oder auf #webextensions im IRC freuen.

+ +

Nächste Schritte?

+ + diff --git "a/files/de/mozilla/add-ons/\303\274berliegende_erweiterungen/index.html" "b/files/de/mozilla/add-ons/\303\274berliegende_erweiterungen/index.html" new file mode 100644 index 0000000000..0214de4021 --- /dev/null +++ "b/files/de/mozilla/add-ons/\303\274berliegende_erweiterungen/index.html" @@ -0,0 +1,54 @@ +--- +title: Legacy-Erweiterungen +slug: Mozilla/Add-ons/überliegende_Erweiterungen +tags: + - Add-ons + - Erweiterungen +translation_of: Archive/Add-ons/Overlay_Extensions +--- +

Diese Seite enthält Links zu der Dokumentation für die approach für Entwickeln von Erweiterungen für Gecko-basierte Applikationen welche benutzen:

+ + + +

Priorität zu Firefox 4, und der Gecko-2- Engine welche es ermöglicht, dies war die einzige Möglichkeit Erweiterungen zu entwickeln. Diese Methode wurde sehr übertroffen von Neustartlosen Erweiterungen, und der Add-on SDK, welche an ihrer Spitze gebaut ist. Die privilegierten JavaScript APIs, welche hier beschrieben wurden, können in diesen neueren Typen von Add-ons immer noch benutzt werden.

+ +

XUL-Schule

+ +

XUL-Schule ist ein verständliches Addonentwicklungstutorial, fokussierend auf die Entwicklung von Firefoxerweiterungen, aber ist meistens übertragbar auf andere Gecko-basierte Applikationen.

+ +

Mehr Ressourcen

+ +
+
+
+
Setting up your environment
+
Setting up the application for extension development.
+
XUL
+
Tutorials and reference for the user interface language used by XUL extensions.
+
Code snippets
+
Sample code for many of the things you'll want to do.
+
Installing extensions
+
How to install an extension by copying the extension files into the application's install directory.
+
Firefox add-ons developer guide
+
A guide to developing overlay extensions.
+
+
+ +
+
+
JavaScript code modules
+
JavaScript modules available to extension developers.
+
Extension preferences
+
How to specify the preferences for your extension that will appear in the Add-ons Manager.
+
Extension packaging
+
How extensions are packaged and installed.
+
Binary Firefox extensions
+
Creating binary extensions for Firefox.
+
+
+
+ +

 

-- cgit v1.2.3-54-g00ecf