Abstract
This spec is for review only! This specification is
for review and not for implementation!
This specification defines the app: URL scheme.
The app: URL scheme can be used by packaged applications to obtain
resources that are inside a container. These resources can then be used
with web platform features that accept URLs.
Status of This Document
This section describes the status of this document at the time of its publication. Other documents may supersede this document. A list of current W3C publications and the latest revision of this technical report can be found in the W3C technical reports index at http://www.w3.org/TR/.
This specification is being republished as a Working Group Note as an indication that it not being progressed further as a Recommendation track document.
This document was published by the System Applications Working Group as a Working Group Note.
If you wish to make comments regarding this document, please send them to
public-sysapps@w3.org
(subscribe,
archives).
All comments are welcome.
Publication as a Working Group Note does not imply endorsement by the W3C
Membership. This is a draft document and may be updated, replaced or obsoleted by other
documents at any time. It is inappropriate to cite this document as other than work in
progress.
This document was produced by a group operating under the
5 February 2004 W3C Patent
Policy.
W3C maintains a public list of any patent
disclosures
made in connection with the deliverables of the group; that page also includes
instructions for disclosing a patent. An individual who has actual knowledge of a patent
which the individual believes contains
Essential
Claim(s) must disclose the information in accordance with
section
6 of the W3C Patent Policy.
This document is governed by the 1 August 2014 W3C Process Document.
1.
app: URL
An app: URL is a [URL] that can be used by a packaged
application to address resources within its container (e.g., a .zip
file).
2.
Instance identifier
The instance identifier is a string that uniquely identifies
an instance of a packaged application. It serves the role of the
authority component in a URI.
When the instance identifier is not provided by the developer, a user
agent MUST synthesize one. The structure and length of identifier
represented is application specific, but it MUST be suitable to use
along with the app: scheme as a Document's [ORIGIN].
See also privacy and security considerations.
A.
Use Cases
For developers, this specification attempts to address the following
use cases:
- Provide a URL scheme that is compatible with the features and
security model of [HTML], so that applications that are packaged can
make full use of web platform's capabilities. For example, the app: URL
scheme should be usable as a
document's address so that it can serve as its origin,
and it should be compatible with APIs like [XHR].
- Provide fetching model that constrains retrieval of files to a
specific container.
- Provide an addressing scheme that is easy to work with - and that
developers are already accustomed to working with. The developer should
not be bothered as to whether they are using
http:// or
app:// - the Web's capabilities and APIs need to just
work!
- Support the ability to playback audio and video files within a
packaged web application, including the ability to seek without needing
to load the full resource.
B.
Examples
The following example shows the results of using
"app://com.foo.bar/index.html#example" as the document's location.
Example 1
<!doctype html>
<script>
//Example using HTML's Location object
var loc = window.location;
console.log(loc.protocol === "app:"); //true
console.log(loc.host === "com.foo.bar"); //true
console.log(loc.href === "app://com.foo.bar/index.html"); //true
console.log(loc.origin === "app://com.foo.bar"); //true
console.log(loc.pathname === "/index.html"); //true
console.log(loc.hash === "#example"); //true
console.log(loc.port === ""); //true
</script>
This example shows an app: URL being resolved
in [HTML]. In this case, document's location is
"app://c13c6f30/index.htm". The random string "c13c6f30" serves as the
instance identifier.
Example 2
var img = document.createElement("img");
//the following setter triggers HTML's resolve algorithm
img.src = "example.gif";
//and the expected output:
console.log(img.src === "app://c13c6f30/example.gif") //true
//Append the image to the document
document.body.appendChild(img);
</script>
This example shows a resource within a packaged application being
retrieved over [XHR].
Example 3
function process(text) {
// process the resulting data
}
var xhr = new XMLHttpRequest();
xhr.onload = () => process(this.responseText);
xhr.open( "GET", "playlist.json");
xhr.send();
This example shows how an app: URL can be used in conjunction
with a HTTP `Range` header to request a range of bytes
from a file inside a package.
Example 4
var url = "sample.mp3";
var xhr = new XMLHttpRequest();
xhr.open('GET', url, true);
xhr.responseType = "arraybuffer";
xhr.setRequestHeader('Range', 'bytes=100-199');
xhr.send();
console.log(Uint8Array(xhr.response).byteLength === 100);// trueC.
Acknowledgments
The bulk of the text in this specifications was derived from the
Widget URI
scheme specification. The Systems Application working group
acknowledge the hard work of the Web Applications Working Group in
laying down the foundations for this specification.