|
このページは大阪弁化フィルタによって翻訳生成されたんですわ。 |
As of Google Chrome 10, the background feature lets a hosted app run as soon as the user logs into their computer—before the user launches Chrome or the app—and to continue running even when Chrome or the app has no visible windows. However, if the user explicitly quits Chrome, the browser and app both exit.
One common use of this feature is to display notifications for events that can occur when the app's UI isn't visible—for example, a new email or chat message, important news, or a price change.
To use the background feature, an app declares the "background" permission in its manifest. Apps with "background" permission can use a background window to do miscellaneous tasks in an invisible page that can live as long as the browser runs.
To use the background feature, a hosted app must declare the "background" permission in its manifest. Then it must create a background window that contains whatever code needs to run in the background.
Here's an example of specifying the "background" permission in an app's manifest:
//In manifest.json:
{
"name": "App Name",
...
"permissions": ["background"],
...
}
Once your app has "background" permission, it can open a background window. You can do this in either of two ways:
Version note:
Before Chrome 12, window.open() was the only way
to open a background window.
You should avoid using "background_page" in published apps
until Chrome 12 has been released on the Stable channel.
For information about Stable channel releases, see the
Google Chrome Releases blog.
If you want the background window to open as soon as your app is installed—even if the app is never launched—put a "background_page" field in the app's manifest. When you specify a URL with "background_page", a background window opens every time the browser launches, running the contents of that URL. Once your app launches, it can close the background window or navigate it to a new URL.
Here's how you use the "background_page" field in an app's manifest:
//In manifest.json:
{
"name": "App Name",
...
"permissions": ["background"],
"background_page": "https://somePath/background.html#0",
...
}
The URL for the "background_page" value must be an HTTPS URL. If the URL is covered by the "urls" field in the manifest, then the background window is in the same process as the app and can be called by the app. The fragment identifier ("#0") at the end of the URL is optional; see the performance tip for details on why you might want to use it.
Note:
During development, you can specify a non-HTTPS URL for "background_page"
by launching Chrome with the
--allow-http-background-page flag.
On Windows, you can do this by modifying the properties of the shortcut that you use to launch Google Chrome. For example:
path_to_chrome.exe --allow-http-background-page
Using window.open() instead of "background_page"
lets you control when the window opens,
and it lets you change which URL the window opens.
After the app has launched for the first time,
you have the option of opening the background window
whenever the browser launches.
Note:
Although window.open()
gives you more flexibility than "background_page",
you should use "background_page" if you need the background window
to open before the app has ever launched.
Because your app must explicitly invoke window.open(),
if you don't use "background_page"
your app's background window can't be loaded
until your app has run and
used window.open() to open a background window.
To open a background window with this technique,
use the standard window.open() method,
specifying "background" as the third argument:
//In the app's launch page:
...
if (window.chrome && window.chrome.app && window.chrome.app.isInstalled) {
window.open("background.html#0", "bg", "background");
...
}
...
That call to window.open()
creates a background window only
if the app has "background" permission
and it doesn't already have a background window.
See Opening a background window for details.
You can put any code you like in the background window.
This code goes in the HTML file that you specified
with "background_page" or window.open();
in the preceding code snippets,
this is a file named background.html.
Here's an example of background window code
that brings up a notification.
//In the background window's page (for example, background.html):
<html>
<script>
var notification = webkitNotifications.createNotification("",
"Simple Background App",
"A background window has been created");
notification.show();
</script>
</html>
Use the background feature when you want your app to always be running. The following table shows some common use cases.
| Use case | Example |
|---|---|
| Notifications | A stock market app that notifies the user about changes in the price of a set of stocks |
| Downloading data from a server | A book reader app that downloads book info automatically, so that it always has the latest data and startup is faster |
| Uploading data to a server | A picture uploader that can send data to the server even when the app's window isn't visible |
| Preparing the UI | An app with a complex UI that preloads the UI,
instead of creating or loading the UI when
the user explicitly launches the app
Note: The HTML5 application cache API is a natural fit here; you can use it to preemptively download the components for your app |
| Playing audio | A radio app that offers the option of continuing to play even when the app's window isn't open |
| Performing computations | An app that performs complex computations in the background, either for its own work or in support of a distributed computing effort |
To understand how the background feature works, you first need to know how hosted apps normally execute, without the background feature. A hosted app normally starts executing when the user visits a page in the app or clicks the app's icon in Chrome's New Tab page. When the user closes all tabs for that app, the app stops executing.
The "background" permission changes the way Chrome starts up. If any hosted apps, packaged apps, or extensions are installed that have "background" permission, Chrome starts up (without displaying any windows) as soon as the user logs in.
Each time Chrome starts up, it opens all URLs specified by "background_page", plus it reopens any other background windows that were open the last time Chrome shut down. Chrome records the URL for each background window at the time that the window is created. If the background window navigates to a new URL, that new URL isn't recorded.
Each app can have at most one background window open at a time. Unless the app uses "background_page", if an app closes its background window without opening a new one, Chrome won't create a background window for that app when Chrome starts up.
Extension API note: Extensions and packaged apps can use "background" and "background_page", either separately or together. However, they can't close background pages or navigate them to new URLs. For details, see Background Pages in the extensions documentation.
The following sections have details about the code you need to write for background windows and the pages that interact with them.
This discussion is relevant even if you use the "background_page" feature. Just keep in mind that the name of the window created using "background_page" is "background". For example, to close the background window, you can use the following code:
var bgWindow = window.open(bgUrl, "background", "background"); bgWindow.close();
If your app has no background window open,
calling window.open(bgUrl, BG_WIN_NAME, "background")
opens a new background window and
(unless you used "background_page")
records bgUrl as the URL
to be used at startup,
when Chrome opens your app's background window.
If your app does have a background window open,
calling window.open(bgUrl, BG_WIN_NAME, "background")
with a new URL
makes the existing background window navigate
to the new URL,
rather than opening a new window.
In this case, Chrome doesn't record the new URL,
and at startup
Chrome opens the background window using its original URL.
Before your app calls window.open(),
it should check a few things:
window.chrome.app.isInstalled property.
To open a background window or switch to a new URL,
use window.open(bgUrl, BG_WIN_NAME, "background").
For example, if the background window is implemented in
a file named background.html,
you might call window.open() like this:
window.open("background.html#0", "bg", "background");
Performance tip:
Specifying a fragment identifier
(such as #0)
in the URL can improve performance
when the background window is reopened.
The reason is that window.open()
causes a page reload if the window is already open
unless a fragment identifier is present.
The fragment identifier trick works with any kind of window,
but it's especially useful with background windows
because they tend to be long-lived
and build up state over time.
The fragment identifier doesn't need to point to an existing anchor.
A possible issue is that the browser might not be able to get to the URL for the background window—if there's no network connection, for example. You can use the application cache API to ensure that the background window can be loaded.
If window.open() returns undefined,
check for the following causes:
manifest.json file.
You can install the app either from a .crx file
or by using the chrome://extension page's
Load unpacked extension button
to select the directory containing manifest.json.
Important: Although you can use a port number in the "launch.web_url" field, don't put port numbers in the "urls" field. Port numbers aren't necessary in "urls" because all ports are valid. Values in "urls" that have port numbers are silently ignored, leaving the corresponding pages without the requested permissions.
If you get a popup window instead of a background window, check for the following causes:
window.open()
window.open().
A trick you can use when debugging background windows
is to remove "background" from the third argument to
window.open().
You'll be able to see the background window
(unless Chrome's popup blocker prevents it from opening),
and you can use Chrome's Developer Tools
to see if any errors occurred.
You close a background window
using the usual window close() method.
Here's an example:
//Originally opening the background window:
window.open("background.html#0", BG_WIN_NAME, "background");
...
//Closing the background window:
var bgWindow = window.open("background.html#0", BG_WIN_NAME, "background");
bgWindow.close();
In this example,
the second call to window.open()
has exactly the same arguments as the first call.
If the background window is already open,
the only effect of the second call to window.open()
is to return a handle to the window.
If the window isn't open, it will be opened.
Note: If you close a background window that was specified with "background_page", it will be opened again the next time Chrome starts up.
If you want to completely replace the existing background window, you need to close the existing background window and then open a new one.
Note: Unless your app's manifest contains "background_page", replacing the background window specifies a new URL to be opened when Chrome starts up.
You usually shouldn't call the opener from the background window. Often, the background window has no opener, because it's either launched by Chrome on startup or persists after its opener has closed.
However, sometimes you might want call a method on the page that opened the background window, if that page is available. You can do so with code like this:var opener = window.opener; ... if (opener && opener.someMethod) opener.someMethod();
Calls to window.open() can return
before the background window is loaded,
which means that you can't call the background window
immediately after opening it.
You might be able to avoid calling the background window from the opener
by putting all the necessary code in the background window's
handler for window.onload.
If you want to call the background window as the result of user input, you might not need to worry about waiting for the background window to load. Your app won't get user input until the UI is available, which probably will be well after the background window loads. Here's an example of calling the background window from a button click handler.
//In the app's launch page:
var bgWindow = window.open(bgUrl, BG_WIN_NAME, "background");
window.onload = function() {
//Register a button click handler that calls the background window.
document.getElementById("schedule").onclick = function() {
var durationSecs = parseInt(document.getElementById("durationSecs").value);
if (durationSecs && durationSecs>0)
bgWindow.startCountdown(durationSecs);
};
};
If you want to be sure that the background window is open, you can use code like the following:
//In the background window:
window.bgLoaded = true; //A property that the launch page(s) can check
//In the app's launch page:
var bgWindow = window.open(bgUrl, BG_WIN_NAME, "background");
if (!bgWindow) {
//We couldn't open the background window.
}
...
//Check whether the property we defined in the background window is true.
if (bgWindow.bgLoaded) {
//The background window is already loaded...
} else {
//Register a handler to be called when the background window is done loading.
bgWindow.addEventListener("load", bgWindowLoadedHandler);
}
Note: When designing the interaction between the background window and its opener, keep in mind that two (or more) tabs for the app might open simultaneously.
The following examples demonstrate the background feature.
This very simple app lets you open and close a background window by clicking a button. You can download or view the source code. (See the README file for tips on creating your own copy to play with.) You can also install the app from background-simple.appspot.com.
This simple app implements a countdown timer. Get the source code and details. You can install the app from the Chrome Web Store.